Add sk_float_rsqrt with SSE + NEON fast paths.

include/core/SkPoint.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPoint_DEFINED
 #define SkPoint_DEFINED
 
@@ skipping 198 matching lines @@
 
     /** Return the euclidian distance from (0,0) to the point
     */
     SkScalar length() const { return SkPoint::Length(fX, fY); }
     SkScalar distanceToOrigin() const { return this->length(); }
 
     /**
      *  Return true if the computed length of the vector is >= the internal
      *  tolerance (used to avoid dividing by tiny values).
      */
-    static bool CanNormalize(SkScalar dx, SkScalar dy)
-#ifdef SK_SCALAR_IS_FLOAT
-    // Simple enough (and performance critical sometimes) so we inline it.
-    { return (dx*dx + dy*dy) > (SK_ScalarNearlyZero * SK_ScalarNearlyZero); }
-#else
-    ;
-#endif
+    static bool CanNormalize(SkScalar dx, SkScalar dy) {
+        // Simple enough (and performance critical sometimes) so we inline it.
+        return (dx*dx + dy*dy) > (SK_ScalarNearlyZero * SK_ScalarNearlyZero);
+    }
 
     bool canNormalize() const {
         return CanNormalize(fX, fY);
     }
 
     /** Set the point (vector) to be unit-length in the same direction as it
         already points.  If the point has a degenerate length (i.e. nearly 0)
         then return false and do nothing; otherwise return true.
     */
     bool normalize();
 
     /** Set the point (vector) to be unit-length in the same direction as the
         x,y params. If the vector (x,y) has a degenerate length (i.e. nearly 0)
         then return false and do nothing, otherwise return true.
     */
     bool setNormalize(SkScalar x, SkScalar y);
 
     /** Scale the point (vector) to have the specified length, and return that
         length. If the original length is degenerately small (nearly zero),
         do nothing and return false, otherwise return true.
     */
     bool setLength(SkScalar length);
 
     /** Set the point (vector) to have the specified length in the same
      direction as (x,y). If the vector (x,y) has a degenerate length
      (i.e. nearly 0) then return false and do nothing, otherwise return true.
     */
     bool setLength(SkScalar x, SkScalar y, SkScalar length);
 
+    /** Same as setLength, but favoring speed over accuracy.
+    */
+    bool setLengthFast(SkScalar length);
+
+    /** Same as setLength, but favoring speed over accuracy.
+    */
+    bool setLengthFast(SkScalar x, SkScalar y, SkScalar length);
+
     /** Scale the point's coordinates by scale, writing the answer into dst.
         It is legal for dst == this.
     */
     void scale(SkScalar scale, SkPoint* dst) const;
 
     /** Scale the point's coordinates by scale, writing the answer back into
         the point.
     */
     void scale(SkScalar value) { this->scale(value, this); }
 
@@ skipping 44 matching lines @@
     */
     void operator-=(const SkPoint& v) {
         fX -= v.fX;
         fY -= v.fY;
     }
 
     /**
      *  Returns true if both X and Y are finite (not infinity or NaN)
      */
     bool isFinite() const {
-#ifdef SK_SCALAR_IS_FLOAT
         SkScalar accum = 0;
         accum *= fX;
         accum *= fY;
 
         // accum is either NaN or it is finite (zero).
         SkASSERT(0 == accum || !(accum == accum));
 
         // value==value will be true iff value is not NaN
         // TODO: is it faster to say !accum or accum==accum?
         return accum == accum;
-#else
-        // use bit-or for speed, since we don't care about short-circuting the
-        // tests, and we expect the common case will be that we need to check all.
-        int isNaN = (SK_FixedNaN == fX) | (SK_FixedNaN == fX));
-        return !isNaN;
-#endif
     }
 
     /**
      *  Returns true if the point's coordinates equal (x,y)
      */
     bool equals(SkScalar x, SkScalar y) const {
         return fX == x && fY == y;
     }
 
     friend bool operator==(const SkPoint& a, const SkPoint& b) {
@@ skipping 158 matching lines @@
 
     /**
      *  cast-safe way to treat the point as an array of (2) SkScalars.
      */
     const SkScalar* asScalars() const { return &fX; }
 };
 
 typedef SkPoint SkVector;
 
 #endif