Revert of Sk4f: add floor()

src/core/SkNx.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkNx_DEFINED
 #define SkNx_DEFINED
 
@@ skipping 32 matching lines @@
         fHi.store(vals+N/2);
     }
 
 #define OP(op) SkNx operator op(const SkNx& o) const { return {fLo op o.fLo, fHi op o.fHi}; }
     OP(+) OP(-) OP(*) OP(/)
     OP(&) OP(|) OP(^)
     OP(==) OP(!=) OP(<) OP(>) OP(<=) OP(>=)
 #undef OP
 
 #define OP(op) SkNx op() const { return {fLo.op(), fHi.op()}; }
-    OP(abs) OP(floor)
+    OP(abs)
     OP(sqrt) OP(rsqrt0) OP(rsqrt1) OP(rsqrt2)
     OP(invert) OP(approxInvert)
 #undef OP
 
     SkNx operator << (int bits) const { return SkNx(fLo << bits, fHi << bits); }
     SkNx operator >> (int bits) const { return SkNx(fLo >> bits, fHi >> bits); }
 
     SkNx saturatedAdd(const SkNx& o) const {
         return {fLo.saturatedAdd(o.fLo), fHi.saturatedAdd(o.fHi)};
     }
@@ skipping 53 matching lines @@
     SkNx saturatedAdd(const SkNx& o) const {
         SkASSERT((T)(~0) > 0); // TODO: support signed T?
         T sum = fVal + o.fVal;
         return sum < fVal ? (T)(~0) : sum;
     }
 
     static SkNx Min(const SkNx& a, const SkNx& b) { return SkTMin(a.fVal, b.fVal); }
     static SkNx Max(const SkNx& a, const SkNx& b) { return SkTMax(a.fVal, b.fVal); }
 
     SkNx abs() const { return SkTAbs(fVal); }
-    SkNx floor() const { return Floor(fVal); }
 
     SkNx  sqrt () const { return Sqrt(fVal); }
     SkNx rsqrt0() const { return this->sqrt().invert(); }
     SkNx rsqrt1() const { return this->rsqrt0(); }
     SkNx rsqrt2() const { return this->rsqrt1(); }
 
     SkNx       invert() const { return 1 / fVal; }
     SkNx approxInvert() const { return this->invert(); }
 
     T operator[](int k) const {
         SkASSERT(0 == k);
         return fVal;
     }
 
     template <int k> T kth() const { return (*this)[k]; }
 
     bool allTrue() const { return fVal != 0; }
     bool anyTrue() const { return fVal != 0; }
     SkNx thenElse(const SkNx& t, const SkNx& e) const { return fVal != 0 ? t : e; }
 
 protected:
-    static double Floor(double val) { return ::floor (val); }
-    static float  Floor(float  val) { return ::floorf(val); }
     static double Sqrt(double val) { return ::sqrt (val); }
     static float  Sqrt(float  val) { return ::sqrtf(val); }
 
     T fVal;
 };
 
 // This generic shuffle can be called to create any valid SkNx<N,T>.
 //     Sk4f f(a,b,c,d);
 //     Sk2f t = SkNx_shuffle<2,1>(f);  // ~~~> Sk2f(c,b)
 //     f = SkNx_shuffle<0,1,1,0>(t);   // ~~~> Sk4f(c,b,b,c)
@@ skipping 47 matching lines @@
     static inline
     void Sk4f_ToBytes(uint8_t p[16], const Sk4f& a, const Sk4f& b, const Sk4f& c, const Sk4f& d) {
         SkNx_cast<uint8_t>(a).store(p+ 0);
         SkNx_cast<uint8_t>(b).store(p+ 4);
         SkNx_cast<uint8_t>(c).store(p+ 8);
         SkNx_cast<uint8_t>(d).store(p+12);
     }
 #endif
 
 #endif//SkNx_DEFINED