Think implicit promotion is a good idea?

src/core/Sk4x_sse.h

 // It is important _not_ to put header guards here.
 // This file will be intentionally included three times.
 
 // Useful reading:
 //   https://software.intel.com/sites/landingpage/IntrinsicsGuide/
 
 #if defined(SK4X_PREAMBLE)
     // Code in this file may assume SSE and SSE2.
     #include <emmintrin.h>
 
@@ skipping 57 matching lines @@
 }
 
 template <typename T>
 Sk4x<T> Sk4x<T>::ZWCD(const Sk4x<T>& a, const Sk4x<T>& b) {
     return _mm_movehl_ps(as_4f(b.fVec), as_4f(a.fVec));
 }
 
 // Now we'll write all Sk4f specific methods.  This M() macro will remove some noise.
 #define M(...) template <> inline __VA_ARGS__ Sk4f::
 
+M() Sk4x(float v) : fVec(_mm_set1_ps(v)) {}
 M() Sk4x(float a, float b, float c, float d) : fVec(_mm_set_ps(d,c,b,a)) {}
 
 M(Sk4f) Load       (const float fs[4]) { return _mm_loadu_ps(fs); }
 M(Sk4f) LoadAligned(const float fs[4]) { return _mm_load_ps (fs); }
 
 M(void) store       (float fs[4]) const { _mm_storeu_ps(fs, fVec); }
 M(void) storeAligned(float fs[4]) const { _mm_store_ps (fs, fVec); }
 
 template <>
 M(Sk4i) reinterpret<Sk4i>() const { return as_4i(fVec); }
@@ skipping 17 matching lines @@
 M(Sk4i) lessThanEqual   (const Sk4f& o) const { return _mm_cmple_ps (fVec, o.fVec); }
 M(Sk4i) greaterThanEqual(const Sk4f& o) const { return _mm_cmpge_ps (fVec, o.fVec); }
 
 M(Sk4f) Min(const Sk4f& a, const Sk4f& b) { return _mm_min_ps(a.fVec, b.fVec); }
 M(Sk4f) Max(const Sk4f& a, const Sk4f& b) { return _mm_max_ps(a.fVec, b.fVec); }
 
 // Now we'll write all the Sk4i specific methods.  Same deal for M().
 #undef M
 #define M(...) template <> inline __VA_ARGS__ Sk4i::
 
+M() Sk4x(int32_t v) : fVec(_mm_set1_epi32(v)) {}
 M() Sk4x(int32_t a, int32_t b, int32_t c, int32_t d) : fVec(_mm_set_epi32(d,c,b,a)) {}
 
 M(Sk4i) Load       (const int32_t is[4]) { return _mm_loadu_si128((const __m128i*)is); }
 M(Sk4i) LoadAligned(const int32_t is[4]) { return _mm_load_si128 ((const __m128i*)is); }
 
 M(void) store       (int32_t is[4]) const { _mm_storeu_si128((__m128i*)is, fVec); }
 M(void) storeAligned(int32_t is[4]) const { _mm_store_si128 ((__m128i*)is, fVec); }
 
 template <>
 M(Sk4f) reinterpret<Sk4f>() const { return as_4f(fVec); }
@@ skipping 43 matching lines @@
     }
     M(Sk4i) Max(const Sk4i& a, const Sk4i& b) {
         Sk4i less = a.lessThan(b);
         return b.bitAnd(less).bitOr(a.andNot(less));
     }
 #endif
 
 #undef M
 
 #endif//Method definitions.