Commits

Anonymous committed 3bb4e15

swizzling goes beyond the boundaries now. vec2.xxxx works now.

  • Participants
  • Parent commits 654e176

Comments (0)

Files changed (8)

File neglect/cpplib/include/neglect/_vector2_swizzle.inc

 // this file was automatically generated by
-// make_swizzle_includes.py on Mon Mar 29 22:19:33 2010.  DO NOT EDIT
+// make_swizzle_includes.py on Tue Mar 30 21:08:50 2010.  DO NOT EDIT
 
+vector<T, 2> xx() const { return vector<T, 2>(x, x); }
 const vector<T, 2> &xy() const { return *this; }
 vector<T, 2> yx() const { return vector<T, 2>(y, x); }
+vector<T, 2> yy() const { return vector<T, 2>(y, y); }
+vector<T, 3> xxx() const { return vector<T, 3>(x, x, x); }
+vector<T, 3> xxy() const { return vector<T, 3>(x, x, y); }
+vector<T, 3> xyx() const { return vector<T, 3>(x, y, x); }
+vector<T, 3> xyy() const { return vector<T, 3>(x, y, y); }
+vector<T, 3> yxx() const { return vector<T, 3>(y, x, x); }
+vector<T, 3> yxy() const { return vector<T, 3>(y, x, y); }
+vector<T, 3> yyx() const { return vector<T, 3>(y, y, x); }
+vector<T, 3> yyy() const { return vector<T, 3>(y, y, y); }
+vector<T, 4> xxxx() const { return vector<T, 4>(x, x, x, x); }
+vector<T, 4> xxxy() const { return vector<T, 4>(x, x, x, y); }
+vector<T, 4> xxyx() const { return vector<T, 4>(x, x, y, x); }
+vector<T, 4> xxyy() const { return vector<T, 4>(x, x, y, y); }
+vector<T, 4> xyxx() const { return vector<T, 4>(x, y, x, x); }
+vector<T, 4> xyxy() const { return vector<T, 4>(x, y, x, y); }
+vector<T, 4> xyyx() const { return vector<T, 4>(x, y, y, x); }
+vector<T, 4> xyyy() const { return vector<T, 4>(x, y, y, y); }
+vector<T, 4> yxxx() const { return vector<T, 4>(y, x, x, x); }
+vector<T, 4> yxxy() const { return vector<T, 4>(y, x, x, y); }
+vector<T, 4> yxyx() const { return vector<T, 4>(y, x, y, x); }
+vector<T, 4> yxyy() const { return vector<T, 4>(y, x, y, y); }
+vector<T, 4> yyxx() const { return vector<T, 4>(y, y, x, x); }
+vector<T, 4> yyxy() const { return vector<T, 4>(y, y, x, y); }
+vector<T, 4> yyyx() const { return vector<T, 4>(y, y, y, x); }
+vector<T, 4> yyyy() const { return vector<T, 4>(y, y, y, y); }
+vector<T, 2> rr() const { return vector<T, 2>(r, r); }
 const vector<T, 2> &rg() const { return *this; }
 vector<T, 2> gr() const { return vector<T, 2>(g, r); }
+vector<T, 2> gg() const { return vector<T, 2>(g, g); }
+vector<T, 3> rrr() const { return vector<T, 3>(r, r, r); }
+vector<T, 3> rrg() const { return vector<T, 3>(r, r, g); }
+vector<T, 3> rgr() const { return vector<T, 3>(r, g, r); }
+vector<T, 3> rgg() const { return vector<T, 3>(r, g, g); }
+vector<T, 3> grr() const { return vector<T, 3>(g, r, r); }
+vector<T, 3> grg() const { return vector<T, 3>(g, r, g); }
+vector<T, 3> ggr() const { return vector<T, 3>(g, g, r); }
+vector<T, 3> ggg() const { return vector<T, 3>(g, g, g); }
+vector<T, 4> rrrr() const { return vector<T, 4>(r, r, r, r); }
+vector<T, 4> rrrg() const { return vector<T, 4>(r, r, r, g); }
+vector<T, 4> rrgr() const { return vector<T, 4>(r, r, g, r); }
+vector<T, 4> rrgg() const { return vector<T, 4>(r, r, g, g); }
+vector<T, 4> rgrr() const { return vector<T, 4>(r, g, r, r); }
+vector<T, 4> rgrg() const { return vector<T, 4>(r, g, r, g); }
+vector<T, 4> rggr() const { return vector<T, 4>(r, g, g, r); }
+vector<T, 4> rggg() const { return vector<T, 4>(r, g, g, g); }
+vector<T, 4> grrr() const { return vector<T, 4>(g, r, r, r); }
+vector<T, 4> grrg() const { return vector<T, 4>(g, r, r, g); }
+vector<T, 4> grgr() const { return vector<T, 4>(g, r, g, r); }
+vector<T, 4> grgg() const { return vector<T, 4>(g, r, g, g); }
+vector<T, 4> ggrr() const { return vector<T, 4>(g, g, r, r); }
+vector<T, 4> ggrg() const { return vector<T, 4>(g, g, r, g); }
+vector<T, 4> gggr() const { return vector<T, 4>(g, g, g, r); }
+vector<T, 4> gggg() const { return vector<T, 4>(g, g, g, g); }
+vector<T, 2> ss() const { return vector<T, 2>(s, s); }
 const vector<T, 2> &st() const { return *this; }
 vector<T, 2> ts() const { return vector<T, 2>(t, s); }
+vector<T, 2> tt() const { return vector<T, 2>(t, t); }
+vector<T, 3> sss() const { return vector<T, 3>(s, s, s); }
+vector<T, 3> sst() const { return vector<T, 3>(s, s, t); }
+vector<T, 3> sts() const { return vector<T, 3>(s, t, s); }
+vector<T, 3> stt() const { return vector<T, 3>(s, t, t); }
+vector<T, 3> tss() const { return vector<T, 3>(t, s, s); }
+vector<T, 3> tst() const { return vector<T, 3>(t, s, t); }
+vector<T, 3> tts() const { return vector<T, 3>(t, t, s); }
+vector<T, 3> ttt() const { return vector<T, 3>(t, t, t); }
+vector<T, 4> ssss() const { return vector<T, 4>(s, s, s, s); }
+vector<T, 4> ssst() const { return vector<T, 4>(s, s, s, t); }
+vector<T, 4> ssts() const { return vector<T, 4>(s, s, t, s); }
+vector<T, 4> sstt() const { return vector<T, 4>(s, s, t, t); }
+vector<T, 4> stss() const { return vector<T, 4>(s, t, s, s); }
+vector<T, 4> stst() const { return vector<T, 4>(s, t, s, t); }
+vector<T, 4> stts() const { return vector<T, 4>(s, t, t, s); }
+vector<T, 4> sttt() const { return vector<T, 4>(s, t, t, t); }
+vector<T, 4> tsss() const { return vector<T, 4>(t, s, s, s); }
+vector<T, 4> tsst() const { return vector<T, 4>(t, s, s, t); }
+vector<T, 4> tsts() const { return vector<T, 4>(t, s, t, s); }
+vector<T, 4> tstt() const { return vector<T, 4>(t, s, t, t); }
+vector<T, 4> ttss() const { return vector<T, 4>(t, t, s, s); }
+vector<T, 4> ttst() const { return vector<T, 4>(t, t, s, t); }
+vector<T, 4> ttts() const { return vector<T, 4>(t, t, t, s); }
+vector<T, 4> tttt() const { return vector<T, 4>(t, t, t, t); }

File neglect/cpplib/include/neglect/_vector3_swizzle.inc

 // this file was automatically generated by
-// make_swizzle_includes.py on Mon Mar 29 22:19:33 2010.  DO NOT EDIT
+// make_swizzle_includes.py on Tue Mar 30 21:08:50 2010.  DO NOT EDIT
 
+vector<T, 2> xx() const { return vector<T, 2>(x, x); }
 vector<T, 2> xy() const { return vector<T, 2>(x, y); }
 vector<T, 2> xz() const { return vector<T, 2>(x, z); }
 vector<T, 2> yx() const { return vector<T, 2>(y, x); }
+vector<T, 2> yy() const { return vector<T, 2>(y, y); }
 vector<T, 2> yz() const { return vector<T, 2>(y, z); }
 vector<T, 2> zx() const { return vector<T, 2>(z, x); }
 vector<T, 2> zy() const { return vector<T, 2>(z, y); }
+vector<T, 2> zz() const { return vector<T, 2>(z, z); }
+vector<T, 3> xxx() const { return vector<T, 3>(x, x, x); }
+vector<T, 3> xxy() const { return vector<T, 3>(x, x, y); }
+vector<T, 3> xxz() const { return vector<T, 3>(x, x, z); }
+vector<T, 3> xyx() const { return vector<T, 3>(x, y, x); }
+vector<T, 3> xyy() const { return vector<T, 3>(x, y, y); }
 const vector<T, 3> &xyz() const { return *this; }
+vector<T, 3> xzx() const { return vector<T, 3>(x, z, x); }
 vector<T, 3> xzy() const { return vector<T, 3>(x, z, y); }
+vector<T, 3> xzz() const { return vector<T, 3>(x, z, z); }
+vector<T, 3> yxx() const { return vector<T, 3>(y, x, x); }
+vector<T, 3> yxy() const { return vector<T, 3>(y, x, y); }
 vector<T, 3> yxz() const { return vector<T, 3>(y, x, z); }
+vector<T, 3> yyx() const { return vector<T, 3>(y, y, x); }
+vector<T, 3> yyy() const { return vector<T, 3>(y, y, y); }
+vector<T, 3> yyz() const { return vector<T, 3>(y, y, z); }
 vector<T, 3> yzx() const { return vector<T, 3>(y, z, x); }
+vector<T, 3> yzy() const { return vector<T, 3>(y, z, y); }
+vector<T, 3> yzz() const { return vector<T, 3>(y, z, z); }
+vector<T, 3> zxx() const { return vector<T, 3>(z, x, x); }
 vector<T, 3> zxy() const { return vector<T, 3>(z, x, y); }
+vector<T, 3> zxz() const { return vector<T, 3>(z, x, z); }
 vector<T, 3> zyx() const { return vector<T, 3>(z, y, x); }
+vector<T, 3> zyy() const { return vector<T, 3>(z, y, y); }
+vector<T, 3> zyz() const { return vector<T, 3>(z, y, z); }
+vector<T, 3> zzx() const { return vector<T, 3>(z, z, x); }
+vector<T, 3> zzy() const { return vector<T, 3>(z, z, y); }
+vector<T, 3> zzz() const { return vector<T, 3>(z, z, z); }
+vector<T, 4> xxxx() const { return vector<T, 4>(x, x, x, x); }
+vector<T, 4> xxxy() const { return vector<T, 4>(x, x, x, y); }
+vector<T, 4> xxxz() const { return vector<T, 4>(x, x, x, z); }
+vector<T, 4> xxyx() const { return vector<T, 4>(x, x, y, x); }
+vector<T, 4> xxyy() const { return vector<T, 4>(x, x, y, y); }
+vector<T, 4> xxyz() const { return vector<T, 4>(x, x, y, z); }
+vector<T, 4> xxzx() const { return vector<T, 4>(x, x, z, x); }
+vector<T, 4> xxzy() const { return vector<T, 4>(x, x, z, y); }
+vector<T, 4> xxzz() const { return vector<T, 4>(x, x, z, z); }
+vector<T, 4> xyxx() const { return vector<T, 4>(x, y, x, x); }
+vector<T, 4> xyxy() const { return vector<T, 4>(x, y, x, y); }
+vector<T, 4> xyxz() const { return vector<T, 4>(x, y, x, z); }
+vector<T, 4> xyyx() const { return vector<T, 4>(x, y, y, x); }
+vector<T, 4> xyyy() const { return vector<T, 4>(x, y, y, y); }
+vector<T, 4> xyyz() const { return vector<T, 4>(x, y, y, z); }
+vector<T, 4> xyzx() const { return vector<T, 4>(x, y, z, x); }
+vector<T, 4> xyzy() const { return vector<T, 4>(x, y, z, y); }
+vector<T, 4> xyzz() const { return vector<T, 4>(x, y, z, z); }
+vector<T, 4> xzxx() const { return vector<T, 4>(x, z, x, x); }
+vector<T, 4> xzxy() const { return vector<T, 4>(x, z, x, y); }
+vector<T, 4> xzxz() const { return vector<T, 4>(x, z, x, z); }
+vector<T, 4> xzyx() const { return vector<T, 4>(x, z, y, x); }
+vector<T, 4> xzyy() const { return vector<T, 4>(x, z, y, y); }
+vector<T, 4> xzyz() const { return vector<T, 4>(x, z, y, z); }
+vector<T, 4> xzzx() const { return vector<T, 4>(x, z, z, x); }
+vector<T, 4> xzzy() const { return vector<T, 4>(x, z, z, y); }
+vector<T, 4> xzzz() const { return vector<T, 4>(x, z, z, z); }
+vector<T, 4> yxxx() const { return vector<T, 4>(y, x, x, x); }
+vector<T, 4> yxxy() const { return vector<T, 4>(y, x, x, y); }
+vector<T, 4> yxxz() const { return vector<T, 4>(y, x, x, z); }
+vector<T, 4> yxyx() const { return vector<T, 4>(y, x, y, x); }
+vector<T, 4> yxyy() const { return vector<T, 4>(y, x, y, y); }
+vector<T, 4> yxyz() const { return vector<T, 4>(y, x, y, z); }
+vector<T, 4> yxzx() const { return vector<T, 4>(y, x, z, x); }
+vector<T, 4> yxzy() const { return vector<T, 4>(y, x, z, y); }
+vector<T, 4> yxzz() const { return vector<T, 4>(y, x, z, z); }
+vector<T, 4> yyxx() const { return vector<T, 4>(y, y, x, x); }
+vector<T, 4> yyxy() const { return vector<T, 4>(y, y, x, y); }
+vector<T, 4> yyxz() const { return vector<T, 4>(y, y, x, z); }
+vector<T, 4> yyyx() const { return vector<T, 4>(y, y, y, x); }
+vector<T, 4> yyyy() const { return vector<T, 4>(y, y, y, y); }
+vector<T, 4> yyyz() const { return vector<T, 4>(y, y, y, z); }
+vector<T, 4> yyzx() const { return vector<T, 4>(y, y, z, x); }
+vector<T, 4> yyzy() const { return vector<T, 4>(y, y, z, y); }
+vector<T, 4> yyzz() const { return vector<T, 4>(y, y, z, z); }
+vector<T, 4> yzxx() const { return vector<T, 4>(y, z, x, x); }
+vector<T, 4> yzxy() const { return vector<T, 4>(y, z, x, y); }
+vector<T, 4> yzxz() const { return vector<T, 4>(y, z, x, z); }
+vector<T, 4> yzyx() const { return vector<T, 4>(y, z, y, x); }
+vector<T, 4> yzyy() const { return vector<T, 4>(y, z, y, y); }
+vector<T, 4> yzyz() const { return vector<T, 4>(y, z, y, z); }
+vector<T, 4> yzzx() const { return vector<T, 4>(y, z, z, x); }
+vector<T, 4> yzzy() const { return vector<T, 4>(y, z, z, y); }
+vector<T, 4> yzzz() const { return vector<T, 4>(y, z, z, z); }
+vector<T, 4> zxxx() const { return vector<T, 4>(z, x, x, x); }
+vector<T, 4> zxxy() const { return vector<T, 4>(z, x, x, y); }
+vector<T, 4> zxxz() const { return vector<T, 4>(z, x, x, z); }
+vector<T, 4> zxyx() const { return vector<T, 4>(z, x, y, x); }
+vector<T, 4> zxyy() const { return vector<T, 4>(z, x, y, y); }
+vector<T, 4> zxyz() const { return vector<T, 4>(z, x, y, z); }
+vector<T, 4> zxzx() const { return vector<T, 4>(z, x, z, x); }
+vector<T, 4> zxzy() const { return vector<T, 4>(z, x, z, y); }
+vector<T, 4> zxzz() const { return vector<T, 4>(z, x, z, z); }
+vector<T, 4> zyxx() const { return vector<T, 4>(z, y, x, x); }
+vector<T, 4> zyxy() const { return vector<T, 4>(z, y, x, y); }
+vector<T, 4> zyxz() const { return vector<T, 4>(z, y, x, z); }
+vector<T, 4> zyyx() const { return vector<T, 4>(z, y, y, x); }
+vector<T, 4> zyyy() const { return vector<T, 4>(z, y, y, y); }
+vector<T, 4> zyyz() const { return vector<T, 4>(z, y, y, z); }
+vector<T, 4> zyzx() const { return vector<T, 4>(z, y, z, x); }
+vector<T, 4> zyzy() const { return vector<T, 4>(z, y, z, y); }
+vector<T, 4> zyzz() const { return vector<T, 4>(z, y, z, z); }
+vector<T, 4> zzxx() const { return vector<T, 4>(z, z, x, x); }
+vector<T, 4> zzxy() const { return vector<T, 4>(z, z, x, y); }
+vector<T, 4> zzxz() const { return vector<T, 4>(z, z, x, z); }
+vector<T, 4> zzyx() const { return vector<T, 4>(z, z, y, x); }
+vector<T, 4> zzyy() const { return vector<T, 4>(z, z, y, y); }
+vector<T, 4> zzyz() const { return vector<T, 4>(z, z, y, z); }
+vector<T, 4> zzzx() const { return vector<T, 4>(z, z, z, x); }
+vector<T, 4> zzzy() const { return vector<T, 4>(z, z, z, y); }
+vector<T, 4> zzzz() const { return vector<T, 4>(z, z, z, z); }
+vector<T, 2> rr() const { return vector<T, 2>(r, r); }
 vector<T, 2> rg() const { return vector<T, 2>(r, g); }
 vector<T, 2> rb() const { return vector<T, 2>(r, b); }
 vector<T, 2> gr() const { return vector<T, 2>(g, r); }
+vector<T, 2> gg() const { return vector<T, 2>(g, g); }
 vector<T, 2> gb() const { return vector<T, 2>(g, b); }
 vector<T, 2> br() const { return vector<T, 2>(b, r); }
 vector<T, 2> bg() const { return vector<T, 2>(b, g); }
+vector<T, 2> bb() const { return vector<T, 2>(b, b); }
+vector<T, 3> rrr() const { return vector<T, 3>(r, r, r); }
+vector<T, 3> rrg() const { return vector<T, 3>(r, r, g); }
+vector<T, 3> rrb() const { return vector<T, 3>(r, r, b); }
+vector<T, 3> rgr() const { return vector<T, 3>(r, g, r); }
+vector<T, 3> rgg() const { return vector<T, 3>(r, g, g); }
 const vector<T, 3> &rgb() const { return *this; }
+vector<T, 3> rbr() const { return vector<T, 3>(r, b, r); }
 vector<T, 3> rbg() const { return vector<T, 3>(r, b, g); }
+vector<T, 3> rbb() const { return vector<T, 3>(r, b, b); }
+vector<T, 3> grr() const { return vector<T, 3>(g, r, r); }
+vector<T, 3> grg() const { return vector<T, 3>(g, r, g); }
 vector<T, 3> grb() const { return vector<T, 3>(g, r, b); }
+vector<T, 3> ggr() const { return vector<T, 3>(g, g, r); }
+vector<T, 3> ggg() const { return vector<T, 3>(g, g, g); }
+vector<T, 3> ggb() const { return vector<T, 3>(g, g, b); }
 vector<T, 3> gbr() const { return vector<T, 3>(g, b, r); }
+vector<T, 3> gbg() const { return vector<T, 3>(g, b, g); }
+vector<T, 3> gbb() const { return vector<T, 3>(g, b, b); }
+vector<T, 3> brr() const { return vector<T, 3>(b, r, r); }
 vector<T, 3> brg() const { return vector<T, 3>(b, r, g); }
+vector<T, 3> brb() const { return vector<T, 3>(b, r, b); }
 vector<T, 3> bgr() const { return vector<T, 3>(b, g, r); }
+vector<T, 3> bgg() const { return vector<T, 3>(b, g, g); }
+vector<T, 3> bgb() const { return vector<T, 3>(b, g, b); }
+vector<T, 3> bbr() const { return vector<T, 3>(b, b, r); }
+vector<T, 3> bbg() const { return vector<T, 3>(b, b, g); }
+vector<T, 3> bbb() const { return vector<T, 3>(b, b, b); }
+vector<T, 4> rrrr() const { return vector<T, 4>(r, r, r, r); }
+vector<T, 4> rrrg() const { return vector<T, 4>(r, r, r, g); }
+vector<T, 4> rrrb() const { return vector<T, 4>(r, r, r, b); }
+vector<T, 4> rrgr() const { return vector<T, 4>(r, r, g, r); }
+vector<T, 4> rrgg() const { return vector<T, 4>(r, r, g, g); }
+vector<T, 4> rrgb() const { return vector<T, 4>(r, r, g, b); }
+vector<T, 4> rrbr() const { return vector<T, 4>(r, r, b, r); }
+vector<T, 4> rrbg() const { return vector<T, 4>(r, r, b, g); }
+vector<T, 4> rrbb() const { return vector<T, 4>(r, r, b, b); }
+vector<T, 4> rgrr() const { return vector<T, 4>(r, g, r, r); }
+vector<T, 4> rgrg() const { return vector<T, 4>(r, g, r, g); }
+vector<T, 4> rgrb() const { return vector<T, 4>(r, g, r, b); }
+vector<T, 4> rggr() const { return vector<T, 4>(r, g, g, r); }
+vector<T, 4> rggg() const { return vector<T, 4>(r, g, g, g); }
+vector<T, 4> rggb() const { return vector<T, 4>(r, g, g, b); }
+vector<T, 4> rgbr() const { return vector<T, 4>(r, g, b, r); }
+vector<T, 4> rgbg() const { return vector<T, 4>(r, g, b, g); }
+vector<T, 4> rgbb() const { return vector<T, 4>(r, g, b, b); }
+vector<T, 4> rbrr() const { return vector<T, 4>(r, b, r, r); }
+vector<T, 4> rbrg() const { return vector<T, 4>(r, b, r, g); }
+vector<T, 4> rbrb() const { return vector<T, 4>(r, b, r, b); }
+vector<T, 4> rbgr() const { return vector<T, 4>(r, b, g, r); }
+vector<T, 4> rbgg() const { return vector<T, 4>(r, b, g, g); }
+vector<T, 4> rbgb() const { return vector<T, 4>(r, b, g, b); }
+vector<T, 4> rbbr() const { return vector<T, 4>(r, b, b, r); }
+vector<T, 4> rbbg() const { return vector<T, 4>(r, b, b, g); }
+vector<T, 4> rbbb() const { return vector<T, 4>(r, b, b, b); }
+vector<T, 4> grrr() const { return vector<T, 4>(g, r, r, r); }
+vector<T, 4> grrg() const { return vector<T, 4>(g, r, r, g); }
+vector<T, 4> grrb() const { return vector<T, 4>(g, r, r, b); }
+vector<T, 4> grgr() const { return vector<T, 4>(g, r, g, r); }
+vector<T, 4> grgg() const { return vector<T, 4>(g, r, g, g); }
+vector<T, 4> grgb() const { return vector<T, 4>(g, r, g, b); }
+vector<T, 4> grbr() const { return vector<T, 4>(g, r, b, r); }
+vector<T, 4> grbg() const { return vector<T, 4>(g, r, b, g); }
+vector<T, 4> grbb() const { return vector<T, 4>(g, r, b, b); }
+vector<T, 4> ggrr() const { return vector<T, 4>(g, g, r, r); }
+vector<T, 4> ggrg() const { return vector<T, 4>(g, g, r, g); }
+vector<T, 4> ggrb() const { return vector<T, 4>(g, g, r, b); }
+vector<T, 4> gggr() const { return vector<T, 4>(g, g, g, r); }
+vector<T, 4> gggg() const { return vector<T, 4>(g, g, g, g); }
+vector<T, 4> gggb() const { return vector<T, 4>(g, g, g, b); }
+vector<T, 4> ggbr() const { return vector<T, 4>(g, g, b, r); }
+vector<T, 4> ggbg() const { return vector<T, 4>(g, g, b, g); }
+vector<T, 4> ggbb() const { return vector<T, 4>(g, g, b, b); }
+vector<T, 4> gbrr() const { return vector<T, 4>(g, b, r, r); }
+vector<T, 4> gbrg() const { return vector<T, 4>(g, b, r, g); }
+vector<T, 4> gbrb() const { return vector<T, 4>(g, b, r, b); }
+vector<T, 4> gbgr() const { return vector<T, 4>(g, b, g, r); }
+vector<T, 4> gbgg() const { return vector<T, 4>(g, b, g, g); }
+vector<T, 4> gbgb() const { return vector<T, 4>(g, b, g, b); }
+vector<T, 4> gbbr() const { return vector<T, 4>(g, b, b, r); }
+vector<T, 4> gbbg() const { return vector<T, 4>(g, b, b, g); }
+vector<T, 4> gbbb() const { return vector<T, 4>(g, b, b, b); }
+vector<T, 4> brrr() const { return vector<T, 4>(b, r, r, r); }
+vector<T, 4> brrg() const { return vector<T, 4>(b, r, r, g); }
+vector<T, 4> brrb() const { return vector<T, 4>(b, r, r, b); }
+vector<T, 4> brgr() const { return vector<T, 4>(b, r, g, r); }
+vector<T, 4> brgg() const { return vector<T, 4>(b, r, g, g); }
+vector<T, 4> brgb() const { return vector<T, 4>(b, r, g, b); }
+vector<T, 4> brbr() const { return vector<T, 4>(b, r, b, r); }
+vector<T, 4> brbg() const { return vector<T, 4>(b, r, b, g); }
+vector<T, 4> brbb() const { return vector<T, 4>(b, r, b, b); }
+vector<T, 4> bgrr() const { return vector<T, 4>(b, g, r, r); }
+vector<T, 4> bgrg() const { return vector<T, 4>(b, g, r, g); }
+vector<T, 4> bgrb() const { return vector<T, 4>(b, g, r, b); }
+vector<T, 4> bggr() const { return vector<T, 4>(b, g, g, r); }
+vector<T, 4> bggg() const { return vector<T, 4>(b, g, g, g); }
+vector<T, 4> bggb() const { return vector<T, 4>(b, g, g, b); }
+vector<T, 4> bgbr() const { return vector<T, 4>(b, g, b, r); }
+vector<T, 4> bgbg() const { return vector<T, 4>(b, g, b, g); }
+vector<T, 4> bgbb() const { return vector<T, 4>(b, g, b, b); }
+vector<T, 4> bbrr() const { return vector<T, 4>(b, b, r, r); }
+vector<T, 4> bbrg() const { return vector<T, 4>(b, b, r, g); }
+vector<T, 4> bbrb() const { return vector<T, 4>(b, b, r, b); }
+vector<T, 4> bbgr() const { return vector<T, 4>(b, b, g, r); }
+vector<T, 4> bbgg() const { return vector<T, 4>(b, b, g, g); }
+vector<T, 4> bbgb() const { return vector<T, 4>(b, b, g, b); }
+vector<T, 4> bbbr() const { return vector<T, 4>(b, b, b, r); }
+vector<T, 4> bbbg() const { return vector<T, 4>(b, b, b, g); }
+vector<T, 4> bbbb() const { return vector<T, 4>(b, b, b, b); }
+vector<T, 2> ss() const { return vector<T, 2>(s, s); }
 vector<T, 2> st() const { return vector<T, 2>(s, t); }
 vector<T, 2> sp() const { return vector<T, 2>(s, p); }
 vector<T, 2> ts() const { return vector<T, 2>(t, s); }
+vector<T, 2> tt() const { return vector<T, 2>(t, t); }
 vector<T, 2> tp() const { return vector<T, 2>(t, p); }
 vector<T, 2> ps() const { return vector<T, 2>(p, s); }
 vector<T, 2> pt() const { return vector<T, 2>(p, t); }
+vector<T, 2> pp() const { return vector<T, 2>(p, p); }
+vector<T, 3> sss() const { return vector<T, 3>(s, s, s); }
+vector<T, 3> sst() const { return vector<T, 3>(s, s, t); }
+vector<T, 3> ssp() const { return vector<T, 3>(s, s, p); }
+vector<T, 3> sts() const { return vector<T, 3>(s, t, s); }
+vector<T, 3> stt() const { return vector<T, 3>(s, t, t); }
 const vector<T, 3> &stp() const { return *this; }
+vector<T, 3> sps() const { return vector<T, 3>(s, p, s); }
 vector<T, 3> spt() const { return vector<T, 3>(s, p, t); }
+vector<T, 3> spp() const { return vector<T, 3>(s, p, p); }
+vector<T, 3> tss() const { return vector<T, 3>(t, s, s); }
+vector<T, 3> tst() const { return vector<T, 3>(t, s, t); }
 vector<T, 3> tsp() const { return vector<T, 3>(t, s, p); }
+vector<T, 3> tts() const { return vector<T, 3>(t, t, s); }
+vector<T, 3> ttt() const { return vector<T, 3>(t, t, t); }
+vector<T, 3> ttp() const { return vector<T, 3>(t, t, p); }
 vector<T, 3> tps() const { return vector<T, 3>(t, p, s); }
+vector<T, 3> tpt() const { return vector<T, 3>(t, p, t); }
+vector<T, 3> tpp() const { return vector<T, 3>(t, p, p); }
+vector<T, 3> pss() const { return vector<T, 3>(p, s, s); }
 vector<T, 3> pst() const { return vector<T, 3>(p, s, t); }
+vector<T, 3> psp() const { return vector<T, 3>(p, s, p); }
 vector<T, 3> pts() const { return vector<T, 3>(p, t, s); }
+vector<T, 3> ptt() const { return vector<T, 3>(p, t, t); }
+vector<T, 3> ptp() const { return vector<T, 3>(p, t, p); }
+vector<T, 3> pps() const { return vector<T, 3>(p, p, s); }
+vector<T, 3> ppt() const { return vector<T, 3>(p, p, t); }
+vector<T, 3> ppp() const { return vector<T, 3>(p, p, p); }
+vector<T, 4> ssss() const { return vector<T, 4>(s, s, s, s); }
+vector<T, 4> ssst() const { return vector<T, 4>(s, s, s, t); }
+vector<T, 4> sssp() const { return vector<T, 4>(s, s, s, p); }
+vector<T, 4> ssts() const { return vector<T, 4>(s, s, t, s); }
+vector<T, 4> sstt() const { return vector<T, 4>(s, s, t, t); }
+vector<T, 4> sstp() const { return vector<T, 4>(s, s, t, p); }
+vector<T, 4> ssps() const { return vector<T, 4>(s, s, p, s); }
+vector<T, 4> sspt() const { return vector<T, 4>(s, s, p, t); }
+vector<T, 4> sspp() const { return vector<T, 4>(s, s, p, p); }
+vector<T, 4> stss() const { return vector<T, 4>(s, t, s, s); }
+vector<T, 4> stst() const { return vector<T, 4>(s, t, s, t); }
+vector<T, 4> stsp() const { return vector<T, 4>(s, t, s, p); }
+vector<T, 4> stts() const { return vector<T, 4>(s, t, t, s); }
+vector<T, 4> sttt() const { return vector<T, 4>(s, t, t, t); }
+vector<T, 4> sttp() const { return vector<T, 4>(s, t, t, p); }
+vector<T, 4> stps() const { return vector<T, 4>(s, t, p, s); }
+vector<T, 4> stpt() const { return vector<T, 4>(s, t, p, t); }
+vector<T, 4> stpp() const { return vector<T, 4>(s, t, p, p); }
+vector<T, 4> spss() const { return vector<T, 4>(s, p, s, s); }
+vector<T, 4> spst() const { return vector<T, 4>(s, p, s, t); }
+vector<T, 4> spsp() const { return vector<T, 4>(s, p, s, p); }
+vector<T, 4> spts() const { return vector<T, 4>(s, p, t, s); }
+vector<T, 4> sptt() const { return vector<T, 4>(s, p, t, t); }
+vector<T, 4> sptp() const { return vector<T, 4>(s, p, t, p); }
+vector<T, 4> spps() const { return vector<T, 4>(s, p, p, s); }
+vector<T, 4> sppt() const { return vector<T, 4>(s, p, p, t); }
+vector<T, 4> sppp() const { return vector<T, 4>(s, p, p, p); }
+vector<T, 4> tsss() const { return vector<T, 4>(t, s, s, s); }
+vector<T, 4> tsst() const { return vector<T, 4>(t, s, s, t); }
+vector<T, 4> tssp() const { return vector<T, 4>(t, s, s, p); }
+vector<T, 4> tsts() const { return vector<T, 4>(t, s, t, s); }
+vector<T, 4> tstt() const { return vector<T, 4>(t, s, t, t); }
+vector<T, 4> tstp() const { return vector<T, 4>(t, s, t, p); }
+vector<T, 4> tsps() const { return vector<T, 4>(t, s, p, s); }
+vector<T, 4> tspt() const { return vector<T, 4>(t, s, p, t); }
+vector<T, 4> tspp() const { return vector<T, 4>(t, s, p, p); }
+vector<T, 4> ttss() const { return vector<T, 4>(t, t, s, s); }
+vector<T, 4> ttst() const { return vector<T, 4>(t, t, s, t); }
+vector<T, 4> ttsp() const { return vector<T, 4>(t, t, s, p); }
+vector<T, 4> ttts() const { return vector<T, 4>(t, t, t, s); }
+vector<T, 4> tttt() const { return vector<T, 4>(t, t, t, t); }
+vector<T, 4> tttp() const { return vector<T, 4>(t, t, t, p); }
+vector<T, 4> ttps() const { return vector<T, 4>(t, t, p, s); }
+vector<T, 4> ttpt() const { return vector<T, 4>(t, t, p, t); }
+vector<T, 4> ttpp() const { return vector<T, 4>(t, t, p, p); }
+vector<T, 4> tpss() const { return vector<T, 4>(t, p, s, s); }
+vector<T, 4> tpst() const { return vector<T, 4>(t, p, s, t); }
+vector<T, 4> tpsp() const { return vector<T, 4>(t, p, s, p); }
+vector<T, 4> tpts() const { return vector<T, 4>(t, p, t, s); }
+vector<T, 4> tptt() const { return vector<T, 4>(t, p, t, t); }
+vector<T, 4> tptp() const { return vector<T, 4>(t, p, t, p); }
+vector<T, 4> tpps() const { return vector<T, 4>(t, p, p, s); }
+vector<T, 4> tppt() const { return vector<T, 4>(t, p, p, t); }
+vector<T, 4> tppp() const { return vector<T, 4>(t, p, p, p); }
+vector<T, 4> psss() const { return vector<T, 4>(p, s, s, s); }
+vector<T, 4> psst() const { return vector<T, 4>(p, s, s, t); }
+vector<T, 4> pssp() const { return vector<T, 4>(p, s, s, p); }
+vector<T, 4> psts() const { return vector<T, 4>(p, s, t, s); }
+vector<T, 4> pstt() const { return vector<T, 4>(p, s, t, t); }
+vector<T, 4> pstp() const { return vector<T, 4>(p, s, t, p); }
+vector<T, 4> psps() const { return vector<T, 4>(p, s, p, s); }
+vector<T, 4> pspt() const { return vector<T, 4>(p, s, p, t); }
+vector<T, 4> pspp() const { return vector<T, 4>(p, s, p, p); }
+vector<T, 4> ptss() const { return vector<T, 4>(p, t, s, s); }
+vector<T, 4> ptst() const { return vector<T, 4>(p, t, s, t); }
+vector<T, 4> ptsp() const { return vector<T, 4>(p, t, s, p); }
+vector<T, 4> ptts() const { return vector<T, 4>(p, t, t, s); }
+vector<T, 4> pttt() const { return vector<T, 4>(p, t, t, t); }
+vector<T, 4> pttp() const { return vector<T, 4>(p, t, t, p); }
+vector<T, 4> ptps() const { return vector<T, 4>(p, t, p, s); }
+vector<T, 4> ptpt() const { return vector<T, 4>(p, t, p, t); }
+vector<T, 4> ptpp() const { return vector<T, 4>(p, t, p, p); }
+vector<T, 4> ppss() const { return vector<T, 4>(p, p, s, s); }
+vector<T, 4> ppst() const { return vector<T, 4>(p, p, s, t); }
+vector<T, 4> ppsp() const { return vector<T, 4>(p, p, s, p); }
+vector<T, 4> ppts() const { return vector<T, 4>(p, p, t, s); }
+vector<T, 4> pptt() const { return vector<T, 4>(p, p, t, t); }
+vector<T, 4> pptp() const { return vector<T, 4>(p, p, t, p); }
+vector<T, 4> ppps() const { return vector<T, 4>(p, p, p, s); }
+vector<T, 4> pppt() const { return vector<T, 4>(p, p, p, t); }
+vector<T, 4> pppp() const { return vector<T, 4>(p, p, p, p); }

File neglect/cpplib/include/neglect/_vector4_swizzle.inc

 // this file was automatically generated by
-// make_swizzle_includes.py on Mon Mar 29 22:19:33 2010.  DO NOT EDIT
+// make_swizzle_includes.py on Tue Mar 30 21:08:50 2010.  DO NOT EDIT
 
+vector<T, 2> xx() const { return vector<T, 2>(x, x); }
 vector<T, 2> xy() const { return vector<T, 2>(x, y); }
 vector<T, 2> xz() const { return vector<T, 2>(x, z); }
 vector<T, 2> xw() const { return vector<T, 2>(x, w); }
 vector<T, 2> yx() const { return vector<T, 2>(y, x); }
+vector<T, 2> yy() const { return vector<T, 2>(y, y); }
 vector<T, 2> yz() const { return vector<T, 2>(y, z); }
 vector<T, 2> yw() const { return vector<T, 2>(y, w); }
 vector<T, 2> zx() const { return vector<T, 2>(z, x); }
 vector<T, 2> zy() const { return vector<T, 2>(z, y); }
+vector<T, 2> zz() const { return vector<T, 2>(z, z); }
 vector<T, 2> zw() const { return vector<T, 2>(z, w); }
 vector<T, 2> wx() const { return vector<T, 2>(w, x); }
 vector<T, 2> wy() const { return vector<T, 2>(w, y); }
 vector<T, 2> wz() const { return vector<T, 2>(w, z); }
+vector<T, 2> ww() const { return vector<T, 2>(w, w); }
+vector<T, 3> xxx() const { return vector<T, 3>(x, x, x); }
+vector<T, 3> xxy() const { return vector<T, 3>(x, x, y); }
+vector<T, 3> xxz() const { return vector<T, 3>(x, x, z); }
+vector<T, 3> xxw() const { return vector<T, 3>(x, x, w); }
+vector<T, 3> xyx() const { return vector<T, 3>(x, y, x); }
+vector<T, 3> xyy() const { return vector<T, 3>(x, y, y); }
 vector<T, 3> xyz() const { return vector<T, 3>(x, y, z); }
 vector<T, 3> xyw() const { return vector<T, 3>(x, y, w); }
+vector<T, 3> xzx() const { return vector<T, 3>(x, z, x); }
 vector<T, 3> xzy() const { return vector<T, 3>(x, z, y); }
+vector<T, 3> xzz() const { return vector<T, 3>(x, z, z); }
 vector<T, 3> xzw() const { return vector<T, 3>(x, z, w); }
+vector<T, 3> xwx() const { return vector<T, 3>(x, w, x); }
 vector<T, 3> xwy() const { return vector<T, 3>(x, w, y); }
 vector<T, 3> xwz() const { return vector<T, 3>(x, w, z); }
+vector<T, 3> xww() const { return vector<T, 3>(x, w, w); }
+vector<T, 3> yxx() const { return vector<T, 3>(y, x, x); }
+vector<T, 3> yxy() const { return vector<T, 3>(y, x, y); }
 vector<T, 3> yxz() const { return vector<T, 3>(y, x, z); }
 vector<T, 3> yxw() const { return vector<T, 3>(y, x, w); }
+vector<T, 3> yyx() const { return vector<T, 3>(y, y, x); }
+vector<T, 3> yyy() const { return vector<T, 3>(y, y, y); }
+vector<T, 3> yyz() const { return vector<T, 3>(y, y, z); }
+vector<T, 3> yyw() const { return vector<T, 3>(y, y, w); }
 vector<T, 3> yzx() const { return vector<T, 3>(y, z, x); }
+vector<T, 3> yzy() const { return vector<T, 3>(y, z, y); }
+vector<T, 3> yzz() const { return vector<T, 3>(y, z, z); }
 vector<T, 3> yzw() const { return vector<T, 3>(y, z, w); }
 vector<T, 3> ywx() const { return vector<T, 3>(y, w, x); }
+vector<T, 3> ywy() const { return vector<T, 3>(y, w, y); }
 vector<T, 3> ywz() const { return vector<T, 3>(y, w, z); }
+vector<T, 3> yww() const { return vector<T, 3>(y, w, w); }
+vector<T, 3> zxx() const { return vector<T, 3>(z, x, x); }
 vector<T, 3> zxy() const { return vector<T, 3>(z, x, y); }
+vector<T, 3> zxz() const { return vector<T, 3>(z, x, z); }
 vector<T, 3> zxw() const { return vector<T, 3>(z, x, w); }
 vector<T, 3> zyx() const { return vector<T, 3>(z, y, x); }
+vector<T, 3> zyy() const { return vector<T, 3>(z, y, y); }
+vector<T, 3> zyz() const { return vector<T, 3>(z, y, z); }
 vector<T, 3> zyw() const { return vector<T, 3>(z, y, w); }
+vector<T, 3> zzx() const { return vector<T, 3>(z, z, x); }
+vector<T, 3> zzy() const { return vector<T, 3>(z, z, y); }
+vector<T, 3> zzz() const { return vector<T, 3>(z, z, z); }
+vector<T, 3> zzw() const { return vector<T, 3>(z, z, w); }
 vector<T, 3> zwx() const { return vector<T, 3>(z, w, x); }
 vector<T, 3> zwy() const { return vector<T, 3>(z, w, y); }
+vector<T, 3> zwz() const { return vector<T, 3>(z, w, z); }
+vector<T, 3> zww() const { return vector<T, 3>(z, w, w); }
+vector<T, 3> wxx() const { return vector<T, 3>(w, x, x); }
 vector<T, 3> wxy() const { return vector<T, 3>(w, x, y); }
 vector<T, 3> wxz() const { return vector<T, 3>(w, x, z); }
+vector<T, 3> wxw() const { return vector<T, 3>(w, x, w); }
 vector<T, 3> wyx() const { return vector<T, 3>(w, y, x); }
+vector<T, 3> wyy() const { return vector<T, 3>(w, y, y); }
 vector<T, 3> wyz() const { return vector<T, 3>(w, y, z); }
+vector<T, 3> wyw() const { return vector<T, 3>(w, y, w); }
 vector<T, 3> wzx() const { return vector<T, 3>(w, z, x); }
 vector<T, 3> wzy() const { return vector<T, 3>(w, z, y); }
+vector<T, 3> wzz() const { return vector<T, 3>(w, z, z); }
+vector<T, 3> wzw() const { return vector<T, 3>(w, z, w); }
+vector<T, 3> wwx() const { return vector<T, 3>(w, w, x); }
+vector<T, 3> wwy() const { return vector<T, 3>(w, w, y); }
+vector<T, 3> wwz() const { return vector<T, 3>(w, w, z); }
+vector<T, 3> www() const { return vector<T, 3>(w, w, w); }
+vector<T, 4> xxxx() const { return vector<T, 4>(x, x, x, x); }
+vector<T, 4> xxxy() const { return vector<T, 4>(x, x, x, y); }
+vector<T, 4> xxxz() const { return vector<T, 4>(x, x, x, z); }
+vector<T, 4> xxxw() const { return vector<T, 4>(x, x, x, w); }
+vector<T, 4> xxyx() const { return vector<T, 4>(x, x, y, x); }
+vector<T, 4> xxyy() const { return vector<T, 4>(x, x, y, y); }
+vector<T, 4> xxyz() const { return vector<T, 4>(x, x, y, z); }
+vector<T, 4> xxyw() const { return vector<T, 4>(x, x, y, w); }
+vector<T, 4> xxzx() const { return vector<T, 4>(x, x, z, x); }
+vector<T, 4> xxzy() const { return vector<T, 4>(x, x, z, y); }
+vector<T, 4> xxzz() const { return vector<T, 4>(x, x, z, z); }
+vector<T, 4> xxzw() const { return vector<T, 4>(x, x, z, w); }
+vector<T, 4> xxwx() const { return vector<T, 4>(x, x, w, x); }
+vector<T, 4> xxwy() const { return vector<T, 4>(x, x, w, y); }
+vector<T, 4> xxwz() const { return vector<T, 4>(x, x, w, z); }
+vector<T, 4> xxww() const { return vector<T, 4>(x, x, w, w); }
+vector<T, 4> xyxx() const { return vector<T, 4>(x, y, x, x); }
+vector<T, 4> xyxy() const { return vector<T, 4>(x, y, x, y); }
+vector<T, 4> xyxz() const { return vector<T, 4>(x, y, x, z); }
+vector<T, 4> xyxw() const { return vector<T, 4>(x, y, x, w); }
+vector<T, 4> xyyx() const { return vector<T, 4>(x, y, y, x); }
+vector<T, 4> xyyy() const { return vector<T, 4>(x, y, y, y); }
+vector<T, 4> xyyz() const { return vector<T, 4>(x, y, y, z); }
+vector<T, 4> xyyw() const { return vector<T, 4>(x, y, y, w); }
+vector<T, 4> xyzx() const { return vector<T, 4>(x, y, z, x); }
+vector<T, 4> xyzy() const { return vector<T, 4>(x, y, z, y); }
+vector<T, 4> xyzz() const { return vector<T, 4>(x, y, z, z); }
 const vector<T, 4> &xyzw() const { return *this; }
+vector<T, 4> xywx() const { return vector<T, 4>(x, y, w, x); }
+vector<T, 4> xywy() const { return vector<T, 4>(x, y, w, y); }
 vector<T, 4> xywz() const { return vector<T, 4>(x, y, w, z); }
+vector<T, 4> xyww() const { return vector<T, 4>(x, y, w, w); }
+vector<T, 4> xzxx() const { return vector<T, 4>(x, z, x, x); }
+vector<T, 4> xzxy() const { return vector<T, 4>(x, z, x, y); }
+vector<T, 4> xzxz() const { return vector<T, 4>(x, z, x, z); }
+vector<T, 4> xzxw() const { return vector<T, 4>(x, z, x, w); }
+vector<T, 4> xzyx() const { return vector<T, 4>(x, z, y, x); }
+vector<T, 4> xzyy() const { return vector<T, 4>(x, z, y, y); }
+vector<T, 4> xzyz() const { return vector<T, 4>(x, z, y, z); }
 vector<T, 4> xzyw() const { return vector<T, 4>(x, z, y, w); }
+vector<T, 4> xzzx() const { return vector<T, 4>(x, z, z, x); }
+vector<T, 4> xzzy() const { return vector<T, 4>(x, z, z, y); }
+vector<T, 4> xzzz() const { return vector<T, 4>(x, z, z, z); }
+vector<T, 4> xzzw() const { return vector<T, 4>(x, z, z, w); }
+vector<T, 4> xzwx() const { return vector<T, 4>(x, z, w, x); }
 vector<T, 4> xzwy() const { return vector<T, 4>(x, z, w, y); }
+vector<T, 4> xzwz() const { return vector<T, 4>(x, z, w, z); }
+vector<T, 4> xzww() const { return vector<T, 4>(x, z, w, w); }
+vector<T, 4> xwxx() const { return vector<T, 4>(x, w, x, x); }
+vector<T, 4> xwxy() const { return vector<T, 4>(x, w, x, y); }
+vector<T, 4> xwxz() const { return vector<T, 4>(x, w, x, z); }
+vector<T, 4> xwxw() const { return vector<T, 4>(x, w, x, w); }
+vector<T, 4> xwyx() const { return vector<T, 4>(x, w, y, x); }
+vector<T, 4> xwyy() const { return vector<T, 4>(x, w, y, y); }
 vector<T, 4> xwyz() const { return vector<T, 4>(x, w, y, z); }
+vector<T, 4> xwyw() const { return vector<T, 4>(x, w, y, w); }
+vector<T, 4> xwzx() const { return vector<T, 4>(x, w, z, x); }
 vector<T, 4> xwzy() const { return vector<T, 4>(x, w, z, y); }
+vector<T, 4> xwzz() const { return vector<T, 4>(x, w, z, z); }
+vector<T, 4> xwzw() const { return vector<T, 4>(x, w, z, w); }
+vector<T, 4> xwwx() const { return vector<T, 4>(x, w, w, x); }
+vector<T, 4> xwwy() const { return vector<T, 4>(x, w, w, y); }
+vector<T, 4> xwwz() const { return vector<T, 4>(x, w, w, z); }
+vector<T, 4> xwww() const { return vector<T, 4>(x, w, w, w); }
+vector<T, 4> yxxx() const { return vector<T, 4>(y, x, x, x); }
+vector<T, 4> yxxy() const { return vector<T, 4>(y, x, x, y); }
+vector<T, 4> yxxz() const { return vector<T, 4>(y, x, x, z); }
+vector<T, 4> yxxw() const { return vector<T, 4>(y, x, x, w); }
+vector<T, 4> yxyx() const { return vector<T, 4>(y, x, y, x); }
+vector<T, 4> yxyy() const { return vector<T, 4>(y, x, y, y); }
+vector<T, 4> yxyz() const { return vector<T, 4>(y, x, y, z); }
+vector<T, 4> yxyw() const { return vector<T, 4>(y, x, y, w); }
+vector<T, 4> yxzx() const { return vector<T, 4>(y, x, z, x); }
+vector<T, 4> yxzy() const { return vector<T, 4>(y, x, z, y); }
+vector<T, 4> yxzz() const { return vector<T, 4>(y, x, z, z); }
 vector<T, 4> yxzw() const { return vector<T, 4>(y, x, z, w); }
+vector<T, 4> yxwx() const { return vector<T, 4>(y, x, w, x); }
+vector<T, 4> yxwy() const { return vector<T, 4>(y, x, w, y); }
 vector<T, 4> yxwz() const { return vector<T, 4>(y, x, w, z); }
+vector<T, 4> yxww() const { return vector<T, 4>(y, x, w, w); }
+vector<T, 4> yyxx() const { return vector<T, 4>(y, y, x, x); }
+vector<T, 4> yyxy() const { return vector<T, 4>(y, y, x, y); }
+vector<T, 4> yyxz() const { return vector<T, 4>(y, y, x, z); }
+vector<T, 4> yyxw() const { return vector<T, 4>(y, y, x, w); }
+vector<T, 4> yyyx() const { return vector<T, 4>(y, y, y, x); }
+vector<T, 4> yyyy() const { return vector<T, 4>(y, y, y, y); }
+vector<T, 4> yyyz() const { return vector<T, 4>(y, y, y, z); }
+vector<T, 4> yyyw() const { return vector<T, 4>(y, y, y, w); }
+vector<T, 4> yyzx() const { return vector<T, 4>(y, y, z, x); }
+vector<T, 4> yyzy() const { return vector<T, 4>(y, y, z, y); }
+vector<T, 4> yyzz() const { return vector<T, 4>(y, y, z, z); }
+vector<T, 4> yyzw() const { return vector<T, 4>(y, y, z, w); }
+vector<T, 4> yywx() const { return vector<T, 4>(y, y, w, x); }
+vector<T, 4> yywy() const { return vector<T, 4>(y, y, w, y); }
+vector<T, 4> yywz() const { return vector<T, 4>(y, y, w, z); }
+vector<T, 4> yyww() const { return vector<T, 4>(y, y, w, w); }
+vector<T, 4> yzxx() const { return vector<T, 4>(y, z, x, x); }
+vector<T, 4> yzxy() const { return vector<T, 4>(y, z, x, y); }
+vector<T, 4> yzxz() const { return vector<T, 4>(y, z, x, z); }
 vector<T, 4> yzxw() const { return vector<T, 4>(y, z, x, w); }
+vector<T, 4> yzyx() const { return vector<T, 4>(y, z, y, x); }
+vector<T, 4> yzyy() const { return vector<T, 4>(y, z, y, y); }
+vector<T, 4> yzyz() const { return vector<T, 4>(y, z, y, z); }
+vector<T, 4> yzyw() const { return vector<T, 4>(y, z, y, w); }
+vector<T, 4> yzzx() const { return vector<T, 4>(y, z, z, x); }
+vector<T, 4> yzzy() const { return vector<T, 4>(y, z, z, y); }
+vector<T, 4> yzzz() const { return vector<T, 4>(y, z, z, z); }
+vector<T, 4> yzzw() const { return vector<T, 4>(y, z, z, w); }
 vector<T, 4> yzwx() const { return vector<T, 4>(y, z, w, x); }
+vector<T, 4> yzwy() const { return vector<T, 4>(y, z, w, y); }
+vector<T, 4> yzwz() const { return vector<T, 4>(y, z, w, z); }
+vector<T, 4> yzww() const { return vector<T, 4>(y, z, w, w); }
+vector<T, 4> ywxx() const { return vector<T, 4>(y, w, x, x); }
+vector<T, 4> ywxy() const { return vector<T, 4>(y, w, x, y); }
 vector<T, 4> ywxz() const { return vector<T, 4>(y, w, x, z); }
+vector<T, 4> ywxw() const { return vector<T, 4>(y, w, x, w); }
+vector<T, 4> ywyx() const { return vector<T, 4>(y, w, y, x); }
+vector<T, 4> ywyy() const { return vector<T, 4>(y, w, y, y); }
+vector<T, 4> ywyz() const { return vector<T, 4>(y, w, y, z); }
+vector<T, 4> ywyw() const { return vector<T, 4>(y, w, y, w); }
 vector<T, 4> ywzx() const { return vector<T, 4>(y, w, z, x); }
+vector<T, 4> ywzy() const { return vector<T, 4>(y, w, z, y); }
+vector<T, 4> ywzz() const { return vector<T, 4>(y, w, z, z); }
+vector<T, 4> ywzw() const { return vector<T, 4>(y, w, z, w); }
+vector<T, 4> ywwx() const { return vector<T, 4>(y, w, w, x); }
+vector<T, 4> ywwy() const { return vector<T, 4>(y, w, w, y); }
+vector<T, 4> ywwz() const { return vector<T, 4>(y, w, w, z); }
+vector<T, 4> ywww() const { return vector<T, 4>(y, w, w, w); }
+vector<T, 4> zxxx() const { return vector<T, 4>(z, x, x, x); }
+vector<T, 4> zxxy() const { return vector<T, 4>(z, x, x, y); }
+vector<T, 4> zxxz() const { return vector<T, 4>(z, x, x, z); }
+vector<T, 4> zxxw() const { return vector<T, 4>(z, x, x, w); }
+vector<T, 4> zxyx() const { return vector<T, 4>(z, x, y, x); }
+vector<T, 4> zxyy() const { return vector<T, 4>(z, x, y, y); }
+vector<T, 4> zxyz() const { return vector<T, 4>(z, x, y, z); }
 vector<T, 4> zxyw() const { return vector<T, 4>(z, x, y, w); }
+vector<T, 4> zxzx() const { return vector<T, 4>(z, x, z, x); }
+vector<T, 4> zxzy() const { return vector<T, 4>(z, x, z, y); }
+vector<T, 4> zxzz() const { return vector<T, 4>(z, x, z, z); }
+vector<T, 4> zxzw() const { return vector<T, 4>(z, x, z, w); }
+vector<T, 4> zxwx() const { return vector<T, 4>(z, x, w, x); }
 vector<T, 4> zxwy() const { return vector<T, 4>(z, x, w, y); }
+vector<T, 4> zxwz() const { return vector<T, 4>(z, x, w, z); }
+vector<T, 4> zxww() const { return vector<T, 4>(z, x, w, w); }
+vector<T, 4> zyxx() const { return vector<T, 4>(z, y, x, x); }
+vector<T, 4> zyxy() const { return vector<T, 4>(z, y, x, y); }
+vector<T, 4> zyxz() const { return vector<T, 4>(z, y, x, z); }
 vector<T, 4> zyxw() const { return vector<T, 4>(z, y, x, w); }
+vector<T, 4> zyyx() const { return vector<T, 4>(z, y, y, x); }
+vector<T, 4> zyyy() const { return vector<T, 4>(z, y, y, y); }
+vector<T, 4> zyyz() const { return vector<T, 4>(z, y, y, z); }
+vector<T, 4> zyyw() const { return vector<T, 4>(z, y, y, w); }
+vector<T, 4> zyzx() const { return vector<T, 4>(z, y, z, x); }
+vector<T, 4> zyzy() const { return vector<T, 4>(z, y, z, y); }
+vector<T, 4> zyzz() const { return vector<T, 4>(z, y, z, z); }
+vector<T, 4> zyzw() const { return vector<T, 4>(z, y, z, w); }
 vector<T, 4> zywx() const { return vector<T, 4>(z, y, w, x); }
+vector<T, 4> zywy() const { return vector<T, 4>(z, y, w, y); }
+vector<T, 4> zywz() const { return vector<T, 4>(z, y, w, z); }
+vector<T, 4> zyww() const { return vector<T, 4>(z, y, w, w); }
+vector<T, 4> zzxx() const { return vector<T, 4>(z, z, x, x); }
+vector<T, 4> zzxy() const { return vector<T, 4>(z, z, x, y); }
+vector<T, 4> zzxz() const { return vector<T, 4>(z, z, x, z); }
+vector<T, 4> zzxw() const { return vector<T, 4>(z, z, x, w); }
+vector<T, 4> zzyx() const { return vector<T, 4>(z, z, y, x); }
+vector<T, 4> zzyy() const { return vector<T, 4>(z, z, y, y); }
+vector<T, 4> zzyz() const { return vector<T, 4>(z, z, y, z); }
+vector<T, 4> zzyw() const { return vector<T, 4>(z, z, y, w); }
+vector<T, 4> zzzx() const { return vector<T, 4>(z, z, z, x); }
+vector<T, 4> zzzy() const { return vector<T, 4>(z, z, z, y); }
+vector<T, 4> zzzz() const { return vector<T, 4>(z, z, z, z); }
+vector<T, 4> zzzw() const { return vector<T, 4>(z, z, z, w); }
+vector<T, 4> zzwx() const { return vector<T, 4>(z, z, w, x); }
+vector<T, 4> zzwy() const { return vector<T, 4>(z, z, w, y); }
+vector<T, 4> zzwz() const { return vector<T, 4>(z, z, w, z); }
+vector<T, 4> zzww() const { return vector<T, 4>(z, z, w, w); }
+vector<T, 4> zwxx() const { return vector<T, 4>(z, w, x, x); }
 vector<T, 4> zwxy() const { return vector<T, 4>(z, w, x, y); }
+vector<T, 4> zwxz() const { return vector<T, 4>(z, w, x, z); }
+vector<T, 4> zwxw() const { return vector<T, 4>(z, w, x, w); }
 vector<T, 4> zwyx() const { return vector<T, 4>(z, w, y, x); }
+vector<T, 4> zwyy() const { return vector<T, 4>(z, w, y, y); }
+vector<T, 4> zwyz() const { return vector<T, 4>(z, w, y, z); }
+vector<T, 4> zwyw() const { return vector<T, 4>(z, w, y, w); }
+vector<T, 4> zwzx() const { return vector<T, 4>(z, w, z, x); }
+vector<T, 4> zwzy() const { return vector<T, 4>(z, w, z, y); }
+vector<T, 4> zwzz() const { return vector<T, 4>(z, w, z, z); }
+vector<T, 4> zwzw() const { return vector<T, 4>(z, w, z, w); }
+vector<T, 4> zwwx() const { return vector<T, 4>(z, w, w, x); }
+vector<T, 4> zwwy() const { return vector<T, 4>(z, w, w, y); }
+vector<T, 4> zwwz() const { return vector<T, 4>(z, w, w, z); }
+vector<T, 4> zwww() const { return vector<T, 4>(z, w, w, w); }
+vector<T, 4> wxxx() const { return vector<T, 4>(w, x, x, x); }
+vector<T, 4> wxxy() const { return vector<T, 4>(w, x, x, y); }
+vector<T, 4> wxxz() const { return vector<T, 4>(w, x, x, z); }
+vector<T, 4> wxxw() const { return vector<T, 4>(w, x, x, w); }
+vector<T, 4> wxyx() const { return vector<T, 4>(w, x, y, x); }
+vector<T, 4> wxyy() const { return vector<T, 4>(w, x, y, y); }
 vector<T, 4> wxyz() const { return vector<T, 4>(w, x, y, z); }
+vector<T, 4> wxyw() const { return vector<T, 4>(w, x, y, w); }
+vector<T, 4> wxzx() const { return vector<T, 4>(w, x, z, x); }
 vector<T, 4> wxzy() const { return vector<T, 4>(w, x, z, y); }
+vector<T, 4> wxzz() const { return vector<T, 4>(w, x, z, z); }
+vector<T, 4> wxzw() const { return vector<T, 4>(w, x, z, w); }
+vector<T, 4> wxwx() const { return vector<T, 4>(w, x, w, x); }
+vector<T, 4> wxwy() const { return vector<T, 4>(w, x, w, y); }
+vector<T, 4> wxwz() const { return vector<T, 4>(w, x, w, z); }
+vector<T, 4> wxww() const { return vector<T, 4>(w, x, w, w); }
+vector<T, 4> wyxx() const { return vector<T, 4>(w, y, x, x); }
+vector<T, 4> wyxy() const { return vector<T, 4>(w, y, x, y); }
 vector<T, 4> wyxz() const { return vector<T, 4>(w, y, x, z); }
+vector<T, 4> wyxw() const { return vector<T, 4>(w, y, x, w); }
+vector<T, 4> wyyx() const { return vector<T, 4>(w, y, y, x); }
+vector<T, 4> wyyy() const { return vector<T, 4>(w, y, y, y); }
+vector<T, 4> wyyz() const { return vector<T, 4>(w, y, y, z); }
+vector<T, 4> wyyw() const { return vector<T, 4>(w, y, y, w); }
 vector<T, 4> wyzx() const { return vector<T, 4>(w, y, z, x); }
+vector<T, 4> wyzy() const { return vector<T, 4>(w, y, z, y); }
+vector<T, 4> wyzz() const { return vector<T, 4>(w, y, z, z); }
+vector<T, 4> wyzw() const { return vector<T, 4>(w, y, z, w); }
+vector<T, 4> wywx() const { return vector<T, 4>(w, y, w, x); }
+vector<T, 4> wywy() const { return vector<T, 4>(w, y, w, y); }
+vector<T, 4> wywz() const { return vector<T, 4>(w, y, w, z); }
+vector<T, 4> wyww() const { return vector<T, 4>(w, y, w, w); }
+vector<T, 4> wzxx() const { return vector<T, 4>(w, z, x, x); }
 vector<T, 4> wzxy() const { return vector<T, 4>(w, z, x, y); }
+vector<T, 4> wzxz() const { return vector<T, 4>(w, z, x, z); }
+vector<T, 4> wzxw() const { return vector<T, 4>(w, z, x, w); }
 vector<T, 4> wzyx() const { return vector<T, 4>(w, z, y, x); }
+vector<T, 4> wzyy() const { return vector<T, 4>(w, z, y, y); }
+vector<T, 4> wzyz() const { return vector<T, 4>(w, z, y, z); }
+vector<T, 4> wzyw() const { return vector<T, 4>(w, z, y, w); }
+vector<T, 4> wzzx() const { return vector<T, 4>(w, z, z, x); }
+vector<T, 4> wzzy() const { return vector<T, 4>(w, z, z, y); }
+vector<T, 4> wzzz() const { return vector<T, 4>(w, z, z, z); }
+vector<T, 4> wzzw() const { return vector<T, 4>(w, z, z, w); }
+vector<T, 4> wzwx() const { return vector<T, 4>(w, z, w, x); }
+vector<T, 4> wzwy() const { return vector<T, 4>(w, z, w, y); }
+vector<T, 4> wzwz() const { return vector<T, 4>(w, z, w, z); }
+vector<T, 4> wzww() const { return vector<T, 4>(w, z, w, w); }
+vector<T, 4> wwxx() const { return vector<T, 4>(w, w, x, x); }
+vector<T, 4> wwxy() const { return vector<T, 4>(w, w, x, y); }
+vector<T, 4> wwxz() const { return vector<T, 4>(w, w, x, z); }
+vector<T, 4> wwxw() const { return vector<T, 4>(w, w, x, w); }
+vector<T, 4> wwyx() const { return vector<T, 4>(w, w, y, x); }
+vector<T, 4> wwyy() const { return vector<T, 4>(w, w, y, y); }
+vector<T, 4> wwyz() const { return vector<T, 4>(w, w, y, z); }
+vector<T, 4> wwyw() const { return vector<T, 4>(w, w, y, w); }
+vector<T, 4> wwzx() const { return vector<T, 4>(w, w, z, x); }
+vector<T, 4> wwzy() const { return vector<T, 4>(w, w, z, y); }
+vector<T, 4> wwzz() const { return vector<T, 4>(w, w, z, z); }
+vector<T, 4> wwzw() const { return vector<T, 4>(w, w, z, w); }
+vector<T, 4> wwwx() const { return vector<T, 4>(w, w, w, x); }
+vector<T, 4> wwwy() const { return vector<T, 4>(w, w, w, y); }
+vector<T, 4> wwwz() const { return vector<T, 4>(w, w, w, z); }
+vector<T, 4> wwww() const { return vector<T, 4>(w, w, w, w); }
+vector<T, 2> rr() const { return vector<T, 2>(r, r); }
 vector<T, 2> rg() const { return vector<T, 2>(r, g); }
 vector<T, 2> rb() const { return vector<T, 2>(r, b); }
 vector<T, 2> ra() const { return vector<T, 2>(r, a); }
 vector<T, 2> gr() const { return vector<T, 2>(g, r); }
+vector<T, 2> gg() const { return vector<T, 2>(g, g); }
 vector<T, 2> gb() const { return vector<T, 2>(g, b); }
 vector<T, 2> ga() const { return vector<T, 2>(g, a); }
 vector<T, 2> br() const { return vector<T, 2>(b, r); }
 vector<T, 2> bg() const { return vector<T, 2>(b, g); }
+vector<T, 2> bb() const { return vector<T, 2>(b, b); }
 vector<T, 2> ba() const { return vector<T, 2>(b, a); }
 vector<T, 2> ar() const { return vector<T, 2>(a, r); }
 vector<T, 2> ag() const { return vector<T, 2>(a, g); }
 vector<T, 2> ab() const { return vector<T, 2>(a, b); }
+vector<T, 2> aa() const { return vector<T, 2>(a, a); }
+vector<T, 3> rrr() const { return vector<T, 3>(r, r, r); }
+vector<T, 3> rrg() const { return vector<T, 3>(r, r, g); }
+vector<T, 3> rrb() const { return vector<T, 3>(r, r, b); }
+vector<T, 3> rra() const { return vector<T, 3>(r, r, a); }
+vector<T, 3> rgr() const { return vector<T, 3>(r, g, r); }
+vector<T, 3> rgg() const { return vector<T, 3>(r, g, g); }
 vector<T, 3> rgb() const { return vector<T, 3>(r, g, b); }
 vector<T, 3> rga() const { return vector<T, 3>(r, g, a); }
+vector<T, 3> rbr() const { return vector<T, 3>(r, b, r); }
 vector<T, 3> rbg() const { return vector<T, 3>(r, b, g); }
+vector<T, 3> rbb() const { return vector<T, 3>(r, b, b); }
 vector<T, 3> rba() const { return vector<T, 3>(r, b, a); }
+vector<T, 3> rar() const { return vector<T, 3>(r, a, r); }
 vector<T, 3> rag() const { return vector<T, 3>(r, a, g); }
 vector<T, 3> rab() const { return vector<T, 3>(r, a, b); }
+vector<T, 3> raa() const { return vector<T, 3>(r, a, a); }
+vector<T, 3> grr() const { return vector<T, 3>(g, r, r); }
+vector<T, 3> grg() const { return vector<T, 3>(g, r, g); }
 vector<T, 3> grb() const { return vector<T, 3>(g, r, b); }
 vector<T, 3> gra() const { return vector<T, 3>(g, r, a); }
+vector<T, 3> ggr() const { return vector<T, 3>(g, g, r); }
+vector<T, 3> ggg() const { return vector<T, 3>(g, g, g); }
+vector<T, 3> ggb() const { return vector<T, 3>(g, g, b); }
+vector<T, 3> gga() const { return vector<T, 3>(g, g, a); }
 vector<T, 3> gbr() const { return vector<T, 3>(g, b, r); }
+vector<T, 3> gbg() const { return vector<T, 3>(g, b, g); }
+vector<T, 3> gbb() const { return vector<T, 3>(g, b, b); }
 vector<T, 3> gba() const { return vector<T, 3>(g, b, a); }
 vector<T, 3> gar() const { return vector<T, 3>(g, a, r); }
+vector<T, 3> gag() const { return vector<T, 3>(g, a, g); }
 vector<T, 3> gab() const { return vector<T, 3>(g, a, b); }
+vector<T, 3> gaa() const { return vector<T, 3>(g, a, a); }
+vector<T, 3> brr() const { return vector<T, 3>(b, r, r); }
 vector<T, 3> brg() const { return vector<T, 3>(b, r, g); }
+vector<T, 3> brb() const { return vector<T, 3>(b, r, b); }
 vector<T, 3> bra() const { return vector<T, 3>(b, r, a); }
 vector<T, 3> bgr() const { return vector<T, 3>(b, g, r); }
+vector<T, 3> bgg() const { return vector<T, 3>(b, g, g); }
+vector<T, 3> bgb() const { return vector<T, 3>(b, g, b); }
 vector<T, 3> bga() const { return vector<T, 3>(b, g, a); }
+vector<T, 3> bbr() const { return vector<T, 3>(b, b, r); }
+vector<T, 3> bbg() const { return vector<T, 3>(b, b, g); }
+vector<T, 3> bbb() const { return vector<T, 3>(b, b, b); }
+vector<T, 3> bba() const { return vector<T, 3>(b, b, a); }
 vector<T, 3> bar() const { return vector<T, 3>(b, a, r); }
 vector<T, 3> bag() const { return vector<T, 3>(b, a, g); }
+vector<T, 3> bab() const { return vector<T, 3>(b, a, b); }
+vector<T, 3> baa() const { return vector<T, 3>(b, a, a); }
+vector<T, 3> arr() const { return vector<T, 3>(a, r, r); }
 vector<T, 3> arg() const { return vector<T, 3>(a, r, g); }
 vector<T, 3> arb() const { return vector<T, 3>(a, r, b); }
+vector<T, 3> ara() const { return vector<T, 3>(a, r, a); }
 vector<T, 3> agr() const { return vector<T, 3>(a, g, r); }
+vector<T, 3> agg() const { return vector<T, 3>(a, g, g); }
 vector<T, 3> agb() const { return vector<T, 3>(a, g, b); }
+vector<T, 3> aga() const { return vector<T, 3>(a, g, a); }
 vector<T, 3> abr() const { return vector<T, 3>(a, b, r); }
 vector<T, 3> abg() const { return vector<T, 3>(a, b, g); }
+vector<T, 3> abb() const { return vector<T, 3>(a, b, b); }
+vector<T, 3> aba() const { return vector<T, 3>(a, b, a); }
+vector<T, 3> aar() const { return vector<T, 3>(a, a, r); }
+vector<T, 3> aag() const { return vector<T, 3>(a, a, g); }
+vector<T, 3> aab() const { return vector<T, 3>(a, a, b); }
+vector<T, 3> aaa() const { return vector<T, 3>(a, a, a); }
+vector<T, 4> rrrr() const { return vector<T, 4>(r, r, r, r); }
+vector<T, 4> rrrg() const { return vector<T, 4>(r, r, r, g); }
+vector<T, 4> rrrb() const { return vector<T, 4>(r, r, r, b); }
+vector<T, 4> rrra() const { return vector<T, 4>(r, r, r, a); }
+vector<T, 4> rrgr() const { return vector<T, 4>(r, r, g, r); }
+vector<T, 4> rrgg() const { return vector<T, 4>(r, r, g, g); }
+vector<T, 4> rrgb() const { return vector<T, 4>(r, r, g, b); }
+vector<T, 4> rrga() const { return vector<T, 4>(r, r, g, a); }
+vector<T, 4> rrbr() const { return vector<T, 4>(r, r, b, r); }
+vector<T, 4> rrbg() const { return vector<T, 4>(r, r, b, g); }
+vector<T, 4> rrbb() const { return vector<T, 4>(r, r, b, b); }
+vector<T, 4> rrba() const { return vector<T, 4>(r, r, b, a); }
+vector<T, 4> rrar() const { return vector<T, 4>(r, r, a, r); }
+vector<T, 4> rrag() const { return vector<T, 4>(r, r, a, g); }
+vector<T, 4> rrab() const { return vector<T, 4>(r, r, a, b); }
+vector<T, 4> rraa() const { return vector<T, 4>(r, r, a, a); }
+vector<T, 4> rgrr() const { return vector<T, 4>(r, g, r, r); }
+vector<T, 4> rgrg() const { return vector<T, 4>(r, g, r, g); }
+vector<T, 4> rgrb() const { return vector<T, 4>(r, g, r, b); }
+vector<T, 4> rgra() const { return vector<T, 4>(r, g, r, a); }
+vector<T, 4> rggr() const { return vector<T, 4>(r, g, g, r); }
+vector<T, 4> rggg() const { return vector<T, 4>(r, g, g, g); }
+vector<T, 4> rggb() const { return vector<T, 4>(r, g, g, b); }
+vector<T, 4> rgga() const { return vector<T, 4>(r, g, g, a); }
+vector<T, 4> rgbr() const { return vector<T, 4>(r, g, b, r); }
+vector<T, 4> rgbg() const { return vector<T, 4>(r, g, b, g); }
+vector<T, 4> rgbb() const { return vector<T, 4>(r, g, b, b); }
 const vector<T, 4> &rgba() const { return *this; }
+vector<T, 4> rgar() const { return vector<T, 4>(r, g, a, r); }
+vector<T, 4> rgag() const { return vector<T, 4>(r, g, a, g); }
 vector<T, 4> rgab() const { return vector<T, 4>(r, g, a, b); }
+vector<T, 4> rgaa() const { return vector<T, 4>(r, g, a, a); }
+vector<T, 4> rbrr() const { return vector<T, 4>(r, b, r, r); }
+vector<T, 4> rbrg() const { return vector<T, 4>(r, b, r, g); }
+vector<T, 4> rbrb() const { return vector<T, 4>(r, b, r, b); }
+vector<T, 4> rbra() const { return vector<T, 4>(r, b, r, a); }
+vector<T, 4> rbgr() const { return vector<T, 4>(r, b, g, r); }
+vector<T, 4> rbgg() const { return vector<T, 4>(r, b, g, g); }
+vector<T, 4> rbgb() const { return vector<T, 4>(r, b, g, b); }
 vector<T, 4> rbga() const { return vector<T, 4>(r, b, g, a); }
+vector<T, 4> rbbr() const { return vector<T, 4>(r, b, b, r); }
+vector<T, 4> rbbg() const { return vector<T, 4>(r, b, b, g); }
+vector<T, 4> rbbb() const { return vector<T, 4>(r, b, b, b); }
+vector<T, 4> rbba() const { return vector<T, 4>(r, b, b, a); }
+vector<T, 4> rbar() const { return vector<T, 4>(r, b, a, r); }
 vector<T, 4> rbag() const { return vector<T, 4>(r, b, a, g); }
+vector<T, 4> rbab() const { return vector<T, 4>(r, b, a, b); }
+vector<T, 4> rbaa() const { return vector<T, 4>(r, b, a, a); }
+vector<T, 4> rarr() const { return vector<T, 4>(r, a, r, r); }
+vector<T, 4> rarg() const { return vector<T, 4>(r, a, r, g); }
+vector<T, 4> rarb() const { return vector<T, 4>(r, a, r, b); }
+vector<T, 4> rara() const { return vector<T, 4>(r, a, r, a); }
+vector<T, 4> ragr() const { return vector<T, 4>(r, a, g, r); }
+vector<T, 4> ragg() const { return vector<T, 4>(r, a, g, g); }
 vector<T, 4> ragb() const { return vector<T, 4>(r, a, g, b); }
+vector<T, 4> raga() const { return vector<T, 4>(r, a, g, a); }
+vector<T, 4> rabr() const { return vector<T, 4>(r, a, b, r); }
 vector<T, 4> rabg() const { return vector<T, 4>(r, a, b, g); }
+vector<T, 4> rabb() const { return vector<T, 4>(r, a, b, b); }
+vector<T, 4> raba() const { return vector<T, 4>(r, a, b, a); }
+vector<T, 4> raar() const { return vector<T, 4>(r, a, a, r); }
+vector<T, 4> raag() const { return vector<T, 4>(r, a, a, g); }
+vector<T, 4> raab() const { return vector<T, 4>(r, a, a, b); }
+vector<T, 4> raaa() const { return vector<T, 4>(r, a, a, a); }
+vector<T, 4> grrr() const { return vector<T, 4>(g, r, r, r); }
+vector<T, 4> grrg() const { return vector<T, 4>(g, r, r, g); }
+vector<T, 4> grrb() const { return vector<T, 4>(g, r, r, b); }
+vector<T, 4> grra() const { return vector<T, 4>(g, r, r, a); }
+vector<T, 4> grgr() const { return vector<T, 4>(g, r, g, r); }
+vector<T, 4> grgg() const { return vector<T, 4>(g, r, g, g); }
+vector<T, 4> grgb() const { return vector<T, 4>(g, r, g, b); }
+vector<T, 4> grga() const { return vector<T, 4>(g, r, g, a); }
+vector<T, 4> grbr() const { return vector<T, 4>(g, r, b, r); }
+vector<T, 4> grbg() const { return vector<T, 4>(g, r, b, g); }
+vector<T, 4> grbb() const { return vector<T, 4>(g, r, b, b); }
 vector<T, 4> grba() const { return vector<T, 4>(g, r, b, a); }
+vector<T, 4> grar() const { return vector<T, 4>(g, r, a, r); }
+vector<T, 4> grag() const { return vector<T, 4>(g, r, a, g); }
 vector<T, 4> grab() const { return vector<T, 4>(g, r, a, b); }
+vector<T, 4> graa() const { return vector<T, 4>(g, r, a, a); }
+vector<T, 4> ggrr() const { return vector<T, 4>(g, g, r, r); }
+vector<T, 4> ggrg() const { return vector<T, 4>(g, g, r, g); }
+vector<T, 4> ggrb() const { return vector<T, 4>(g, g, r, b); }
+vector<T, 4> ggra() const { return vector<T, 4>(g, g, r, a); }
+vector<T, 4> gggr() const { return vector<T, 4>(g, g, g, r); }
+vector<T, 4> gggg() const { return vector<T, 4>(g, g, g, g); }
+vector<T, 4> gggb() const { return vector<T, 4>(g, g, g, b); }
+vector<T, 4> ggga() const { return vector<T, 4>(g, g, g, a); }
+vector<T, 4> ggbr() const { return vector<T, 4>(g, g, b, r); }
+vector<T, 4> ggbg() const { return vector<T, 4>(g, g, b, g); }
+vector<T, 4> ggbb() const { return vector<T, 4>(g, g, b, b); }
+vector<T, 4> ggba() const { return vector<T, 4>(g, g, b, a); }
+vector<T, 4> ggar() const { return vector<T, 4>(g, g, a, r); }
+vector<T, 4> ggag() const { return vector<T, 4>(g, g, a, g); }
+vector<T, 4> ggab() const { return vector<T, 4>(g, g, a, b); }
+vector<T, 4> ggaa() const { return vector<T, 4>(g, g, a, a); }
+vector<T, 4> gbrr() const { return vector<T, 4>(g, b, r, r); }
+vector<T, 4> gbrg() const { return vector<T, 4>(g, b, r, g); }
+vector<T, 4> gbrb() const { return vector<T, 4>(g, b, r, b); }
 vector<T, 4> gbra() const { return vector<T, 4>(g, b, r, a); }
+vector<T, 4> gbgr() const { return vector<T, 4>(g, b, g, r); }
+vector<T, 4> gbgg() const { return vector<T, 4>(g, b, g, g); }
+vector<T, 4> gbgb() const { return vector<T, 4>(g, b, g, b); }
+vector<T, 4> gbga() const { return vector<T, 4>(g, b, g, a); }
+vector<T, 4> gbbr() const { return vector<T, 4>(g, b, b, r); }
+vector<T, 4> gbbg() const { return vector<T, 4>(g, b, b, g); }
+vector<T, 4> gbbb() const { return vector<T, 4>(g, b, b, b); }
+vector<T, 4> gbba() const { return vector<T, 4>(g, b, b, a); }
 vector<T, 4> gbar() const { return vector<T, 4>(g, b, a, r); }
+vector<T, 4> gbag() const { return vector<T, 4>(g, b, a, g); }
+vector<T, 4> gbab() const { return vector<T, 4>(g, b, a, b); }
+vector<T, 4> gbaa() const { return vector<T, 4>(g, b, a, a); }
+vector<T, 4> garr() const { return vector<T, 4>(g, a, r, r); }
+vector<T, 4> garg() const { return vector<T, 4>(g, a, r, g); }
 vector<T, 4> garb() const { return vector<T, 4>(g, a, r, b); }
+vector<T, 4> gara() const { return vector<T, 4>(g, a, r, a); }
+vector<T, 4> gagr() const { return vector<T, 4>(g, a, g, r); }
+vector<T, 4> gagg() const { return vector<T, 4>(g, a, g, g); }
+vector<T, 4> gagb() const { return vector<T, 4>(g, a, g, b); }
+vector<T, 4> gaga() const { return vector<T, 4>(g, a, g, a); }
 vector<T, 4> gabr() const { return vector<T, 4>(g, a, b, r); }
+vector<T, 4> gabg() const { return vector<T, 4>(g, a, b, g); }
+vector<T, 4> gabb() const { return vector<T, 4>(g, a, b, b); }
+vector<T, 4> gaba() const { return vector<T, 4>(g, a, b, a); }
+vector<T, 4> gaar() const { return vector<T, 4>(g, a, a, r); }
+vector<T, 4> gaag() const { return vector<T, 4>(g, a, a, g); }
+vector<T, 4> gaab() const { return vector<T, 4>(g, a, a, b); }
+vector<T, 4> gaaa() const { return vector<T, 4>(g, a, a, a); }
+vector<T, 4> brrr() const { return vector<T, 4>(b, r, r, r); }
+vector<T, 4> brrg() const { return vector<T, 4>(b, r, r, g); }
+vector<T, 4> brrb() const { return vector<T, 4>(b, r, r, b); }
+vector<T, 4> brra() const { return vector<T, 4>(b, r, r, a); }
+vector<T, 4> brgr() const { return vector<T, 4>(b, r, g, r); }
+vector<T, 4> brgg() const { return vector<T, 4>(b, r, g, g); }
+vector<T, 4> brgb() const { return vector<T, 4>(b, r, g, b); }
 vector<T, 4> brga() const { return vector<T, 4>(b, r, g, a); }
+vector<T, 4> brbr() const { return vector<T, 4>(b, r, b, r); }
+vector<T, 4> brbg() const { return vector<T, 4>(b, r, b, g); }
+vector<T, 4> brbb() const { return vector<T, 4>(b, r, b, b); }
+vector<T, 4> brba() const { return vector<T, 4>(b, r, b, a); }
+vector<T, 4> brar() const { return vector<T, 4>(b, r, a, r); }
 vector<T, 4> brag() const { return vector<T, 4>(b, r, a, g); }
+vector<T, 4> brab() const { return vector<T, 4>(b, r, a, b); }
+vector<T, 4> braa() const { return vector<T, 4>(b, r, a, a); }
+vector<T, 4> bgrr() const { return vector<T, 4>(b, g, r, r); }
+vector<T, 4> bgrg() const { return vector<T, 4>(b, g, r, g); }
+vector<T, 4> bgrb() const { return vector<T, 4>(b, g, r, b); }
 vector<T, 4> bgra() const { return vector<T, 4>(b, g, r, a); }
+vector<T, 4> bggr() const { return vector<T, 4>(b, g, g, r); }
+vector<T, 4> bggg() const { return vector<T, 4>(b, g, g, g); }
+vector<T, 4> bggb() const { return vector<T, 4>(b, g, g, b); }
+vector<T, 4> bgga() const { return vector<T, 4>(b, g, g, a); }
+vector<T, 4> bgbr() const { return vector<T, 4>(b, g, b, r); }
+vector<T, 4> bgbg() const { return vector<T, 4>(b, g, b, g); }
+vector<T, 4> bgbb() const { return vector<T, 4>(b, g, b, b); }
+vector<T, 4> bgba() const { return vector<T, 4>(b, g, b, a); }
 vector<T, 4> bgar() const { return vector<T, 4>(b, g, a, r); }
+vector<T, 4> bgag() const { return vector<T, 4>(b, g, a, g); }
+vector<T, 4> bgab() const { return vector<T, 4>(b, g, a, b); }
+vector<T, 4> bgaa() const { return vector<T, 4>(b, g, a, a); }
+vector<T, 4> bbrr() const { return vector<T, 4>(b, b, r, r); }
+vector<T, 4> bbrg() const { return vector<T, 4>(b, b, r, g); }
+vector<T, 4> bbrb() const { return vector<T, 4>(b, b, r, b); }
+vector<T, 4> bbra() const { return vector<T, 4>(b, b, r, a); }
+vector<T, 4> bbgr() const { return vector<T, 4>(b, b, g, r); }
+vector<T, 4> bbgg() const { return vector<T, 4>(b, b, g, g); }
+vector<T, 4> bbgb() const { return vector<T, 4>(b, b, g, b); }
+vector<T, 4> bbga() const { return vector<T, 4>(b, b, g, a); }
+vector<T, 4> bbbr() const { return vector<T, 4>(b, b, b, r); }
+vector<T, 4> bbbg() const { return vector<T, 4>(b, b, b, g); }
+vector<T, 4> bbbb() const { return vector<T, 4>(b, b, b, b); }
+vector<T, 4> bbba() const { return vector<T, 4>(b, b, b, a); }
+vector<T, 4> bbar() const { return vector<T, 4>(b, b, a, r); }
+vector<T, 4> bbag() const { return vector<T, 4>(b, b, a, g); }
+vector<T, 4> bbab() const { return vector<T, 4>(b, b, a, b); }
+vector<T, 4> bbaa() const { return vector<T, 4>(b, b, a, a); }
+vector<T, 4> barr() const { return vector<T, 4>(b, a, r, r); }
 vector<T, 4> barg() const { return vector<T, 4>(b, a, r, g); }
+vector<T, 4> barb() const { return vector<T, 4>(b, a, r, b); }
+vector<T, 4> bara() const { return vector<T, 4>(b, a, r, a); }
 vector<T, 4> bagr() const { return vector<T, 4>(b, a, g, r); }
+vector<T, 4> bagg() const { return vector<T, 4>(b, a, g, g); }
+vector<T, 4> bagb() const { return vector<T, 4>(b, a, g, b); }
+vector<T, 4> baga() const { return vector<T, 4>(b, a, g, a); }
+vector<T, 4> babr() const { return vector<T, 4>(b, a, b, r); }
+vector<T, 4> babg() const { return vector<T, 4>(b, a, b, g); }
+vector<T, 4> babb() const { return vector<T, 4>(b, a, b, b); }
+vector<T, 4> baba() const { return vector<T, 4>(b, a, b, a); }
+vector<T, 4> baar() const { return vector<T, 4>(b, a, a, r); }
+vector<T, 4> baag() const { return vector<T, 4>(b, a, a, g); }
+vector<T, 4> baab() const { return vector<T, 4>(b, a, a, b); }
+vector<T, 4> baaa() const { return vector<T, 4>(b, a, a, a); }
+vector<T, 4> arrr() const { return vector<T, 4>(a, r, r, r); }
+vector<T, 4> arrg() const { return vector<T, 4>(a, r, r, g); }
+vector<T, 4> arrb() const { return vector<T, 4>(a, r, r, b); }
+vector<T, 4> arra() const { return vector<T, 4>(a, r, r, a); }
+vector<T, 4> argr() const { return vector<T, 4>(a, r, g, r); }
+vector<T, 4> argg() const { return vector<T, 4>(a, r, g, g); }
 vector<T, 4> argb() const { return vector<T, 4>(a, r, g, b); }
+vector<T, 4> arga() const { return vector<T, 4>(a, r, g, a); }
+vector<T, 4> arbr() const { return vector<T, 4>(a, r, b, r); }
 vector<T, 4> arbg() const { return vector<T, 4>(a, r, b, g); }
+vector<T, 4> arbb() const { return vector<T, 4>(a, r, b, b); }
+vector<T, 4> arba() const { return vector<T, 4>(a, r, b, a); }
+vector<T, 4> arar() const { return vector<T, 4>(a, r, a, r); }
+vector<T, 4> arag() const { return vector<T, 4>(a, r, a, g); }
+vector<T, 4> arab() const { return vector<T, 4>(a, r, a, b); }
+vector<T, 4> araa() const { return vector<T, 4>(a, r, a, a); }
+vector<T, 4> agrr() const { return vector<T, 4>(a, g, r, r); }
+vector<T, 4> agrg() const { return vector<T, 4>(a, g, r, g); }
 vector<T, 4> agrb() const { return vector<T, 4>(a, g, r, b); }
+vector<T, 4> agra() const { return vector<T, 4>(a, g, r, a); }
+vector<T, 4> aggr() const { return vector<T, 4>(a, g, g, r); }
+vector<T, 4> aggg() const { return vector<T, 4>(a, g, g, g); }
+vector<T, 4> aggb() const { return vector<T, 4>(a, g, g, b); }
+vector<T, 4> agga() const { return vector<T, 4>(a, g, g, a); }
 vector<T, 4> agbr() const { return vector<T, 4>(a, g, b, r); }
+vector<T, 4> agbg() const { return vector<T, 4>(a, g, b, g); }
+vector<T, 4> agbb() const { return vector<T, 4>(a, g, b, b); }
+vector<T, 4> agba() const { return vector<T, 4>(a, g, b, a); }
+vector<T, 4> agar() const { return vector<T, 4>(a, g, a, r); }
+vector<T, 4> agag() const { return vector<T, 4>(a, g, a, g); }
+vector<T, 4> agab() const { return vector<T, 4>(a, g, a, b); }
+vector<T, 4> agaa() const { return vector<T, 4>(a, g, a, a); }
+vector<T, 4> abrr() const { return vector<T, 4>(a, b, r, r); }
 vector<T, 4> abrg() const { return vector<T, 4>(a, b, r, g); }
+vector<T, 4> abrb() const { return vector<T, 4>(a, b, r, b); }
+vector<T, 4> abra() const { return vector<T, 4>(a, b, r, a); }
 vector<T, 4> abgr() const { return vector<T, 4>(a, b, g, r); }
+vector<T, 4> abgg() const { return vector<T, 4>(a, b, g, g); }
+vector<T, 4> abgb() const { return vector<T, 4>(a, b, g, b); }
+vector<T, 4> abga() const { return vector<T, 4>(a, b, g, a); }
+vector<T, 4> abbr() const { return vector<T, 4>(a, b, b, r); }
+vector<T, 4> abbg() const { return vector<T, 4>(a, b, b, g); }
+vector<T, 4> abbb() const { return vector<T, 4>(a, b, b, b); }
+vector<T, 4> abba() const { return vector<T, 4>(a, b, b, a); }
+vector<T, 4> abar() const { return vector<T, 4>(a, b, a, r); }
+vector<T, 4> abag() const { return vector<T, 4>(a, b, a, g); }
+vector<T, 4> abab() const { return vector<T, 4>(a, b, a, b); }
+vector<T, 4> abaa() const { return vector<T, 4>(a, b, a, a); }
+vector<T, 4> aarr() const { return vector<T, 4>(a, a, r, r); }
+vector<T, 4> aarg() const { return vector<T, 4>(a, a, r, g); }
+vector<T, 4> aarb() const { return vector<T, 4>(a, a, r, b); }
+vector<T, 4> aara() const { return vector<T, 4>(a, a, r, a); }
+vector<T, 4> aagr() const { return vector<T, 4>(a, a, g, r); }
+vector<T, 4> aagg() const { return vector<T, 4>(a, a, g, g); }
+vector<T, 4> aagb() const { return vector<T, 4>(a, a, g, b); }
+vector<T, 4> aaga() const { return vector<T, 4>(a, a, g, a); }
+vector<T, 4> aabr() const { return vector<T, 4>(a, a, b, r); }
+vector<T, 4> aabg() const { return vector<T, 4>(a, a, b, g); }
+vector<T, 4> aabb() const { return vector<T, 4>(a, a, b, b); }
+vector<T, 4> aaba() const { return vector<T, 4>(a, a, b, a); }
+vector<T, 4> aaar() const { return vector<T, 4>(a, a, a, r); }
+vector<T, 4> aaag() const { return vector<T, 4>(a, a, a, g); }
+vector<T, 4> aaab() const { return vector<T, 4>(a, a, a, b); }
+vector<T, 4> aaaa() const { return vector<T, 4>(a, a, a, a); }
+vector<T, 2> ss() const { return vector<T, 2>(s, s); }
 vector<T, 2> st() const { return vector<T, 2>(s, t); }
 vector<T, 2> sp() const { return vector<T, 2>(s, p); }
 vector<T, 2> sq() const { return vector<T, 2>(s, q); }
 vector<T, 2> ts() const { return vector<T, 2>(t, s); }
+vector<T, 2> tt() const { return vector<T, 2>(t, t); }
 vector<T, 2> tp() const { return vector<T, 2>(t, p); }
 vector<T, 2> tq() const { return vector<T, 2>(t, q); }
 vector<T, 2> ps() const { return vector<T, 2>(p, s); }
 vector<T, 2> pt() const { return vector<T, 2>(p, t); }
+vector<T, 2> pp() const { return vector<T, 2>(p, p); }
 vector<T, 2> pq() const { return vector<T, 2>(p, q); }
 vector<T, 2> qs() const { return vector<T, 2>(q, s); }
 vector<T, 2> qt() const { return vector<T, 2>(q, t); }
 vector<T, 2> qp() const { return vector<T, 2>(q, p); }
+vector<T, 2> qq() const { return vector<T, 2>(q, q); }
+vector<T, 3> sss() const { return vector<T, 3>(s, s, s); }
+vector<T, 3> sst() const { return vector<T, 3>(s, s, t); }
+vector<T, 3> ssp() const { return vector<T, 3>(s, s, p); }
+vector<T, 3> ssq() const { return vector<T, 3>(s, s, q); }
+vector<T, 3> sts() const { return vector<T, 3>(s, t, s); }
+vector<T, 3> stt() const { return vector<T, 3>(s, t, t); }
 vector<T, 3> stp() const { return vector<T, 3>(s, t, p); }
 vector<T, 3> stq() const { return vector<T, 3>(s, t, q); }
+vector<T, 3> sps() const { return vector<T, 3>(s, p, s); }
 vector<T, 3> spt() const { return vector<T, 3>(s, p, t); }
+vector<T, 3> spp() const { return vector<T, 3>(s, p, p); }
 vector<T, 3> spq() const { return vector<T, 3>(s, p, q); }
+vector<T, 3> sqs() const { return vector<T, 3>(s, q, s); }
 vector<T, 3> sqt() const { return vector<T, 3>(s, q, t); }
 vector<T, 3> sqp() const { return vector<T, 3>(s, q, p); }
+vector<T, 3> sqq() const { return vector<T, 3>(s, q, q); }
+vector<T, 3> tss() const { return vector<T, 3>(t, s, s); }
+vector<T, 3> tst() const { return vector<T, 3>(t, s, t); }
 vector<T, 3> tsp() const { return vector<T, 3>(t, s, p); }
 vector<T, 3> tsq() const { return vector<T, 3>(t, s, q); }
+vector<T, 3> tts() const { return vector<T, 3>(t, t, s); }
+vector<T, 3> ttt() const { return vector<T, 3>(t, t, t); }
+vector<T, 3> ttp() const { return vector<T, 3>(t, t, p); }
+vector<T, 3> ttq() const { return vector<T, 3>(t, t, q); }
 vector<T, 3> tps() const { return vector<T, 3>(t, p, s); }
+vector<T, 3> tpt() const { return vector<T, 3>(t, p, t); }
+vector<T, 3> tpp() const { return vector<T, 3>(t, p, p); }
 vector<T, 3> tpq() const { return vector<T, 3>(t, p, q); }
 vector<T, 3> tqs() const { return vector<T, 3>(t, q, s); }
+vector<T, 3> tqt() const { return vector<T, 3>(t, q, t); }
 vector<T, 3> tqp() const { return vector<T, 3>(t, q, p); }
+vector<T, 3> tqq() const { return vector<T, 3>(t, q, q); }
+vector<T, 3> pss() const { return vector<T, 3>(p, s, s); }
 vector<T, 3> pst() const { return vector<T, 3>(p, s, t); }
+vector<T, 3> psp() const { return vector<T, 3>(p, s, p); }
 vector<T, 3> psq() const { return vector<T, 3>(p, s, q); }
 vector<T, 3> pts() const { return vector<T, 3>(p, t, s); }
+vector<T, 3> ptt() const { return vector<T, 3>(p, t, t); }
+vector<T, 3> ptp() const { return vector<T, 3>(p, t, p); }
 vector<T, 3> ptq() const { return vector<T, 3>(p, t, q); }
+vector<T, 3> pps() const { return vector<T, 3>(p, p, s); }
+vector<T, 3> ppt() const { return vector<T, 3>(p, p, t); }
+vector<T, 3> ppp() const { return vector<T, 3>(p, p, p); }
+vector<T, 3> ppq() const { return vector<T, 3>(p, p, q); }
 vector<T, 3> pqs() const { return vector<T, 3>(p, q, s); }
 vector<T, 3> pqt() const { return vector<T, 3>(p, q, t); }
+vector<T, 3> pqp() const { return vector<T, 3>(p, q, p); }
+vector<T, 3> pqq() const { return vector<T, 3>(p, q, q); }
+vector<T, 3> qss() const { return vector<T, 3>(q, s, s); }
 vector<T, 3> qst() const { return vector<T, 3>(q, s, t); }
 vector<T, 3> qsp() const { return vector<T, 3>(q, s, p); }
+vector<T, 3> qsq() const { return vector<T, 3>(q, s, q); }
 vector<T, 3> qts() const { return vector<T, 3>(q, t, s); }
+vector<T, 3> qtt() const { return vector<T, 3>(q, t, t); }
 vector<T, 3> qtp() const { return vector<T, 3>(q, t, p); }
+vector<T, 3> qtq() const { return vector<T, 3>(q, t, q); }
 vector<T, 3> qps() const { return vector<T, 3>(q, p, s); }
 vector<T, 3> qpt() const { return vector<T, 3>(q, p, t); }
+vector<T, 3> qpp() const { return vector<T, 3>(q, p, p); }
+vector<T, 3> qpq() const { return vector<T, 3>(q, p, q); }
+vector<T, 3> qqs() const { return vector<T, 3>(q, q, s); }
+vector<T, 3> qqt() const { return vector<T, 3>(q, q, t); }
+vector<T, 3> qqp() const { return vector<T, 3>(q, q, p); }
+vector<T, 3> qqq() const { return vector<T, 3>(q, q, q); }
+vector<T, 4> ssss() const { return vector<T, 4>(s, s, s, s); }
+vector<T, 4> ssst() const { return vector<T, 4>(s, s, s, t); }
+vector<T, 4> sssp() const { return vector<T, 4>(s, s, s, p); }
+vector<T, 4> sssq() const { return vector<T, 4>(s, s, s, q); }
+vector<T, 4> ssts() const { return vector<T, 4>(s, s, t, s); }
+vector<T, 4> sstt() const { return vector<T, 4>(s, s, t, t); }
+vector<T, 4> sstp() const { return vector<T, 4>(s, s, t, p); }
+vector<T, 4> sstq() const { return vector<T, 4>(s, s, t, q); }
+vector<T, 4> ssps() const { return vector<T, 4>(s, s, p, s); }
+vector<T, 4> sspt() const { return vector<T, 4>(s, s, p, t); }
+vector<T, 4> sspp() const { return vector<T, 4>(s, s, p, p); }
+vector<T, 4> sspq() const { return vector<T, 4>(s, s, p, q); }
+vector<T, 4> ssqs() const { return vector<T, 4>(s, s, q, s); }
+vector<T, 4> ssqt() const { return vector<T, 4>(s, s, q, t); }
+vector<T, 4> ssqp() const { return vector<T, 4>(s, s, q, p); }
+vector<T, 4> ssqq() const { return vector<T, 4>(s, s, q, q); }
+vector<T, 4> stss() const { return vector<T, 4>(s, t, s, s); }
+vector<T, 4> stst() const { return vector<T, 4>(s, t, s, t); }
+vector<T, 4> stsp() const { return vector<T, 4>(s, t, s, p); }
+vector<T, 4> stsq() const { return vector<T, 4>(s, t, s, q); }
+vector<T, 4> stts() const { return vector<T, 4>(s, t, t, s); }
+vector<T, 4> sttt() const { return vector<T, 4>(s, t, t, t); }
+vector<T, 4> sttp() const { return vector<T, 4>(s, t, t, p); }
+vector<T, 4> sttq() const { return vector<T, 4>(s, t, t, q); }
+vector<T, 4> stps() const { return vector<T, 4>(s, t, p, s); }
+vector<T, 4> stpt() const { return vector<T, 4>(s, t, p, t); }
+vector<T, 4> stpp() const { return vector<T, 4>(s, t, p, p); }
 const vector<T, 4> &stpq() const { return *this; }
+vector<T, 4> stqs() const { return vector<T, 4>(s, t, q, s); }
+vector<T, 4> stqt() const { return vector<T, 4>(s, t, q, t); }
 vector<T, 4> stqp() const { return vector<T, 4>(s, t, q, p); }
+vector<T, 4> stqq() const { return vector<T, 4>(s, t, q, q); }
+vector<T, 4> spss() const { return vector<T, 4>(s, p, s, s); }
+vector<T, 4> spst() const { return vector<T, 4>(s, p, s, t); }
+vector<T, 4> spsp() const { return vector<T, 4>(s, p, s, p); }
+vector<T, 4> spsq() const { return vector<T, 4>(s, p, s, q); }
+vector<T, 4> spts() const { return vector<T, 4>(s, p, t, s); }
+vector<T, 4> sptt() const { return vector<T, 4>(s, p, t, t); }
+vector<T, 4> sptp() const { return vector<T, 4>(s, p, t, p); }
 vector<T, 4> sptq() const { return vector<T, 4>(s, p, t, q); }
+vector<T, 4> spps() const { return vector<T, 4>(s, p, p, s); }
+vector<T, 4> sppt() const { return vector<T, 4>(s, p, p, t); }
+vector<T, 4> sppp() const { return vector<T, 4>(s, p, p, p); }
+vector<T, 4> sppq() const { return vector<T, 4>(s, p, p, q); }
+vector<T, 4> spqs() const { return vector<T, 4>(s, p, q, s); }
 vector<T, 4> spqt() const { return vector<T, 4>(s, p, q, t); }
+vector<T, 4> spqp() const { return vector<T, 4>(s, p, q, p); }
+vector<T, 4> spqq() const { return vector<T, 4>(s, p, q, q); }
+vector<T, 4> sqss() const { return vector<T, 4>(s, q, s, s); }
+vector<T, 4> sqst() const { return vector<T, 4>(s, q, s, t); }
+vector<T, 4> sqsp() const { return vector<T, 4>(s, q, s, p); }
+vector<T, 4> sqsq() const { return vector<T, 4>(s, q, s, q); }
+vector<T, 4> sqts() const { return vector<T, 4>(s, q, t, s); }
+vector<T, 4> sqtt() const { return vector<T, 4>(s, q, t, t); }
 vector<T, 4> sqtp() const { return vector<T, 4>(s, q, t, p); }
+vector<T, 4> sqtq() const { return vector<T, 4>(s, q, t, q); }
+vector<T, 4> sqps() const { return vector<T, 4>(s, q, p, s); }
 vector<T, 4> sqpt() const { return vector<T, 4>(s, q, p, t); }
+vector<T, 4> sqpp() const { return vector<T, 4>(s, q, p, p); }
+vector<T, 4> sqpq() const { return vector<T, 4>(s, q, p, q); }
+vector<T, 4> sqqs() const { return vector<T, 4>(s, q, q, s); }
+vector<T, 4> sqqt() const { return vector<T, 4>(s, q, q, t); }
+vector<T, 4> sqqp() const { return vector<T, 4>(s, q, q, p); }
+vector<T, 4> sqqq() const { return vector<T, 4>(s, q, q, q); }
+vector<T, 4> tsss() const { return vector<T, 4>(t, s, s, s); }
+vector<T, 4> tsst() const { return vector<T, 4>(t, s, s, t); }
+vector<T, 4> tssp() const { return vector<T, 4>(t, s, s, p); }
+vector<T, 4> tssq() const { return vector<T, 4>(t, s, s, q); }
+vector<T, 4> tsts() const { return vector<T, 4>(t, s, t, s); }
+vector<T, 4> tstt() const { return vector<T, 4>(t, s, t, t); }
+vector<T, 4> tstp() const { return vector<T, 4>(t, s, t, p); }
+vector<T, 4> tstq() const { return vector<T, 4>(t, s, t, q); }
+vector<T, 4> tsps() const { return vector<T, 4>(t, s, p, s); }
+vector<T, 4> tspt() const { return vector<T, 4>(t, s, p, t); }
+vector<T, 4> tspp() const { return vector<T, 4>(t, s, p, p); }
 vector<T, 4> tspq() const { return vector<T, 4>(t, s, p, q); }
+vector<T, 4> tsqs() const { return vector<T, 4>(t, s, q, s); }
+vector<T, 4> tsqt() const { return vector<T, 4>(t, s, q, t); }
 vector<T, 4> tsqp() const { return vector<T, 4>(t, s, q, p); }
+vector<T, 4> tsqq() const { return vector<T, 4>(t, s, q, q); }
+vector<T, 4> ttss() const { return vector<T, 4>(t, t, s, s); }
+vector<T, 4> ttst() const { return vector<T, 4>(t, t, s, t); }
+vector<T, 4> ttsp() const { return vector<T, 4>(t, t, s, p); }
+vector<T, 4> ttsq() const { return vector<T, 4>(t, t, s, q); }
+vector<T, 4> ttts() const { return vector<T, 4>(t, t, t, s); }
+vector<T, 4> tttt() const { return vector<T, 4>(t, t, t, t); }
+vector<T, 4> tttp() const { return vector<T, 4>(t, t, t, p); }
+vector<T, 4> tttq() const { return vector<T, 4>(t, t, t, q); }
+vector<T, 4> ttps() const { return vector<T, 4>(t, t, p, s); }
+vector<T, 4> ttpt() const { return vector<T, 4>(t, t, p, t); }
+vector<T, 4> ttpp() const { return vector<T, 4>(t, t, p, p); }
+vector<T, 4> ttpq() const { return vector<T, 4>(t, t, p, q); }
+vector<T, 4> ttqs() const { return vector<T, 4>(t, t, q, s); }
+vector<T, 4> ttqt() const { return vector<T, 4>(t, t, q, t); }
+vector<T, 4> ttqp() const { return vector<T, 4>(t, t, q, p); }
+vector<T, 4> ttqq() const { return vector<T, 4>(t, t, q, q); }
+vector<T, 4> tpss() const { return vector<T, 4>(t, p, s, s); }
+vector<T, 4> tpst() const { return vector<T, 4>(t, p, s, t); }
+vector<T, 4> tpsp() const { return vector<T, 4>(t, p, s, p); }
 vector<T, 4> tpsq() const { return vector<T, 4>(t, p, s, q); }
+vector<T, 4> tpts() const { return vector<T, 4>(t, p, t, s); }
+vector<T, 4> tptt() const { return vector<T, 4>(t, p, t, t); }
+vector<T, 4> tptp() const { return vector<T, 4>(t, p, t, p); }
+vector<T, 4> tptq() const { return vector<T, 4>(t, p, t, q); }
+vector<T, 4> tpps() const { return vector<T, 4>(t, p, p, s); }
+vector<T, 4> tppt() const { return vector<T, 4>(t, p, p, t); }
+vector<T, 4> tppp() const { return vector<T, 4>(t, p, p, p); }
+vector<T, 4> tppq() const { return vector<T, 4>(t, p, p, q); }
 vector<T, 4> tpqs() const { return vector<T, 4>(t, p, q, s); }
+vector<T, 4> tpqt() const { return vector<T, 4>(t, p, q, t); }
+vector<T, 4> tpqp() const { return vector<T, 4>(t, p, q, p); }
+vector<T, 4> tpqq() const { return vector<T, 4>(t, p, q, q); }
+vector<T, 4> tqss() const { return vector<T, 4>(t, q, s, s); }
+vector<T, 4> tqst() const { return vector<T, 4>(t, q, s, t); }
 vector<T, 4> tqsp() const { return vector<T, 4>(t, q, s, p); }
+vector<T, 4> tqsq() const { return vector<T, 4>(t, q, s, q); }
+vector<T, 4> tqts() const { return vector<T, 4>(t, q, t, s); }
+vector<T, 4> tqtt() const { return vector<T, 4>(t, q, t, t); }
+vector<T, 4> tqtp() const { return vector<T, 4>(t, q, t, p); }
+vector<T, 4> tqtq() const { return vector<T, 4>(t, q, t, q); }
 vector<T, 4> tqps() const { return vector<T, 4>(t, q, p, s); }
+vector<T, 4> tqpt() const { return vector<T, 4>(t, q, p, t); }
+vector<T, 4> tqpp() const { return vector<T, 4>(t, q, p, p); }
+vector<T, 4> tqpq() const { return vector<T, 4>(t, q, p, q); }
+vector<T, 4> tqqs() const { return vector<T, 4>(t, q, q, s); }
+vector<T, 4> tqqt() const { return vector<T, 4>(t, q, q, t); }
+vector<T, 4> tqqp() const { return vector<T, 4>(t, q, q, p); }
+vector<T, 4> tqqq() const { return vector<T, 4>(t, q, q, q); }
+vector<T, 4> psss() const { return vector<T, 4>(p, s, s, s); }
+vector<T, 4> psst() const { return vector<T, 4>(p, s, s, t); }
+vector<T, 4> pssp() const { return vector<T, 4>(p, s, s, p); }
+vector<T, 4> pssq() const { return vector<T, 4>(p, s, s, q); }
+vector<T, 4> psts() const { return vector<T, 4>(p, s, t, s); }
+vector<T, 4> pstt() const { return vector<T, 4>(p, s, t, t); }
+vector<T, 4> pstp() const { return vector<T, 4>(p, s, t, p); }
 vector<T, 4> pstq() const { return vector<T, 4>(p, s, t, q); }
+vector<T, 4> psps() const { return vector<T, 4>(p, s, p, s); }
+vector<T, 4> pspt() const { return vector<T, 4>(p, s, p, t); }
+vector<T, 4> pspp() const { return vector<T, 4>(p, s, p, p); }
+vector<T, 4> pspq() const { return vector<T, 4>(p, s, p, q); }
+vector<T, 4> psqs() const { return vector<T, 4>(p, s, q, s); }
 vector<T, 4> psqt() const { return vector<T, 4>(p, s, q, t); }
+vector<T, 4> psqp() const { return vector<T, 4>(p, s, q, p); }
+vector<T, 4> psqq() const { return vector<T, 4>(p, s, q, q); }
+vector<T, 4> ptss() const { return vector<T, 4>(p, t, s, s); }
+vector<T, 4> ptst() const { return vector<T, 4>(p, t, s, t); }
+vector<T, 4> ptsp() const { return vector<T, 4>(p, t, s, p); }
 vector<T, 4> ptsq() const { return vector<T, 4>(p, t, s, q); }
+vector<T, 4> ptts() const { return vector<T, 4>(p, t, t, s); }
+vector<T, 4> pttt() const { return vector<T, 4>(p, t, t, t); }
+vector<T, 4> pttp() const { return vector<T, 4>(p, t, t, p); }
+vector<T, 4> pttq() const { return vector<T, 4>(p, t, t, q); }
+vector<T, 4> ptps() const { return vector<T, 4>(p, t, p, s); }
+vector<T, 4> ptpt() const { return vector<T, 4>(p, t, p, t); }
+vector<T, 4> ptpp() const { return vector<T, 4>(p, t, p, p); }
+vector<T, 4> ptpq() const { return vector<T, 4>(p, t, p, q); }
 vector<T, 4> ptqs() const { return vector<T, 4>(p, t, q, s); }
+vector<T, 4> ptqt() const { return vector<T, 4>(p, t, q, t); }
+vector<T, 4> ptqp() const { return vector<T, 4>(p, t, q, p); }
+vector<T, 4> ptqq() const { return vector<T, 4>(p, t, q, q); }
+vector<T, 4> ppss() const { return vector<T, 4>(p, p, s, s); }
+vector<T, 4> ppst() const { return vector<T, 4>(p, p, s, t); }
+vector<T, 4> ppsp() const { return vector<T, 4>(p, p, s, p); }
+vector<T, 4> ppsq() const { return vector<T, 4>(p, p, s, q); }
+vector<T, 4> ppts() const { return vector<T, 4>(p, p, t, s); }
+vector<T, 4> pptt() const { return vector<T, 4>(p, p, t, t); }
+vector<T, 4> pptp() const { return vector<T, 4>(p, p, t, p); }
+vector<T, 4> pptq() const { return vector<T, 4>(p, p, t, q); }
+vector<T, 4> ppps() const { return vector<T, 4>(p, p, p, s); }
+vector<T, 4> pppt() const { return vector<T, 4>(p, p, p, t); }
+vector<T, 4> pppp() const { return vector<T, 4>(p, p, p, p); }
+vector<T, 4> pppq() const { return vector<T, 4>(p, p, p, q); }
+vector<T, 4> ppqs() const { return vector<T, 4>(p, p, q, s); }
+vector<T, 4> ppqt() const { return vector<T, 4>(p, p, q, t); }
+vector<T, 4> ppqp() const { return vector<T, 4>(p, p, q, p); }
+vector<T, 4> ppqq() const { return vector<T, 4>(p, p, q, q); }
+vector<T, 4> pqss() const { return vector<T, 4>(p, q, s, s); }
 vector<T, 4> pqst() const { return vector<T, 4>(p, q, s, t); }
+vector<T, 4> pqsp() const { return vector<T, 4>(p, q, s, p); }
+vector<T, 4> pqsq() const { return vector<T, 4>(p, q, s, q); }
 vector<T, 4> pqts() const { return vector<T, 4>(p, q, t, s); }
+vector<T, 4> pqtt() const { return vector<T, 4>(p, q, t, t); }
+vector<T, 4> pqtp() const { return vector<T, 4>(p, q, t, p); }
+vector<T, 4> pqtq() const { return vector<T, 4>(p, q, t, q); }
+vector<T, 4> pqps() const { return vector<T, 4>(p, q, p, s); }
+vector<T, 4> pqpt() const { return vector<T, 4>(p, q, p, t); }
+vector<T, 4> pqpp() const { return vector<T, 4>(p, q, p, p); }
+vector<T, 4> pqpq() const { return vector<T, 4>(p, q, p, q); }
+vector<T, 4> pqqs() const { return vector<T, 4>(p, q, q, s); }
+vector<T, 4> pqqt() const { return vector<T, 4>(p, q, q, t); }
+vector<T, 4> pqqp() const { return vector<T, 4>(p, q, q, p); }
+vector<T, 4> pqqq() const { return vector<T, 4>(p, q, q, q); }
+vector<T, 4> qsss() const { return vector<T, 4>(q, s, s, s); }
+vector<T, 4> qsst() const { return vector<T, 4>(q, s, s, t); }
+vector<T, 4> qssp() const { return vector<T, 4>(q, s, s, p); }
+vector<T, 4> qssq() const { return vector<T, 4>(q, s, s, q); }
+vector<T, 4> qsts() const { return vector<T, 4>(q, s, t, s); }
+vector<T, 4> qstt() const { return vector<T, 4>(q, s, t, t); }
 vector<T, 4> qstp() const { return vector<T, 4>(q, s, t, p); }
+vector<T, 4> qstq() const { return vector<T, 4>(q, s, t, q); }
+vector<T, 4> qsps() const { return vector<T, 4>(q, s, p, s); }
 vector<T, 4> qspt() const { return vector<T, 4>(q, s, p, t); }
+vector<T, 4> qspp() const { return vector<T, 4>(q, s, p, p); }
+vector<T, 4> qspq() const { return vector<T, 4>(q, s, p, q); }
+vector<T, 4> qsqs() const { return vector<T, 4>(q, s, q, s); }
+vector<T, 4> qsqt() const { return vector<T, 4>(q, s, q, t); }
+vector<T, 4> qsqp() const { return vector<T, 4>(q, s, q, p); }
+vector<T, 4> qsqq() const { return vector<T, 4>(q, s, q, q); }
+vector<T, 4> qtss() const { return vector<T, 4>(q, t, s, s); }
+vector<T, 4> qtst() const { return vector<T, 4>(q, t, s, t); }
 vector<T, 4> qtsp() const { return vector<T, 4>(q, t, s, p); }
+vector<T, 4> qtsq() const { return vector<T, 4>(q, t, s, q); }
+vector<T, 4> qtts() const { return vector<T, 4>(q, t, t, s); }
+vector<T, 4> qttt() const { return vector<T, 4>(q, t, t, t); }
+vector<T, 4> qttp() const { return vector<T, 4>(q, t, t, p); }
+vector<T, 4> qttq() const { return vector<T, 4>(q, t, t, q); }
 vector<T, 4> qtps() const { return vector<T, 4>(q, t, p, s); }
+vector<T, 4> qtpt() const { return vector<T, 4>(q, t, p, t); }
+vector<T, 4> qtpp() const { return vector<T, 4>(q, t, p, p); }
+vector<T, 4> qtpq() const { return vector<T, 4>(q, t, p, q); }
+vector<T, 4> qtqs() const { return vector<T, 4>(q, t, q, s); }
+vector<T, 4> qtqt() const { return vector<T, 4>(q, t, q, t); }
+vector<T, 4> qtqp() const { return vector<T, 4>(q, t, q, p); }
+vector<T, 4> qtqq() const { return vector<T, 4>(q, t, q, q); }
+vector<T, 4> qpss() const { return vector<T, 4>(q, p, s, s); }
 vector<T, 4> qpst() const { return vector<T, 4>(q, p, s, t); }
+vector<T, 4> qpsp() const { return vector<T, 4>(q, p, s, p); }
+vector<T, 4> qpsq() const { return vector<T, 4>(q, p, s, q); }
 vector<T, 4> qpts() const { return vector<T, 4>(q, p, t, s); }
+vector<T, 4> qptt() const { return vector<T, 4>(q, p, t, t); }
+vector<T, 4> qptp() const { return vector<T, 4>(q, p, t, p); }
+vector<T, 4> qptq() const { return vector<T, 4>(q, p, t, q); }
+vector<T, 4> qpps() const { return vector<T, 4>(q, p, p, s); }
+vector<T, 4> qppt() const { return vector<T, 4>(q, p, p, t); }
+vector<T, 4> qppp() const { return vector<T, 4>(q, p, p, p); }
+vector<T, 4> qppq() const { return vector<T, 4>(q, p, p, q); }
+vector<T, 4> qpqs() const { return vector<T, 4>(q, p, q, s); }
+vector<T, 4> qpqt() const { return vector<T, 4>(q, p, q, t); }
+vector<T, 4> qpqp() const { return vector<T, 4>(q, p, q, p); }
+vector<T, 4> qpqq() const { return vector<T, 4>(q, p, q, q); }
+vector<T, 4> qqss() const { return vector<T, 4>(q, q, s, s); }
+vector<T, 4> qqst() const { return vector<T, 4>(q, q, s, t); }
+vector<T, 4> qqsp() const { return vector<T, 4>(q, q, s, p); }
+vector<T, 4> qqsq() const { return vector<T, 4>(q, q, s, q); }
+vector<T, 4> qqts() const { return vector<T, 4>(q, q, t, s); }
+vector<T, 4> qqtt() const { return vector<T, 4>(q, q, t, t); }
+vector<T, 4> qqtp() const { return vector<T, 4>(q, q, t, p); }
+vector<T, 4> qqtq() const { return vector<T, 4>(q, q, t, q); }
+vector<T, 4> qqps() const { return vector<T, 4>(q, q, p, s); }
+vector<T, 4> qqpt() const { return vector<T, 4>(q, q, p, t); }
+vector<T, 4> qqpp() const { return vector<T, 4>(q, q, p, p); }
+vector<T, 4> qqpq() const { return vector<T, 4>(q, q, p, q); }
+vector<T, 4> qqqs() const { return vector<T, 4>(q, q, q, s); }
+vector<T, 4> qqqt() const { return vector<T, 4>(q, q, q, t); }
+vector<T, 4> qqqp() const { return vector<T, 4>(q, q, q, p); }
+vector<T, 4> qqqq() const { return vector<T, 4>(q, q, q, q); }

File neglect/cpplib/include/neglect/math.hpp

         template <typename T> T exp(T x) { return ::std::exp(x); }
         template <typename T> T log(T x) { return ::std::log(x); }
         template <typename T> T log10(T x) { return ::std::log10(x); }
-        template <typename T> T pow(T x) { return ::std::pow(x); }
+        template <typename T> T pow(T x, T y) { return ::std::pow(x, y); }
 
         template <typename T>
         T deg_to_rad(T degrees)

File neglect/cpplib/include/neglect/matrix.hpp

 
 #include <neglect/boot.hpp>
 #include <neglect/vector.hpp>
+#include <neglect/math.hpp>
 
 namespace neglect {
 
             return m_cols[row];
         }
 
+        matrix<T, M - 1, N - 1> exclude(size_t row, size_t column) const
+        {
+            assert(row < M);
+            assert(column < N);
+            matrix<T, M - 1, N - 1> rv;
+            for (size_t i = 0; i < M; i++) {
+                if (i == row)
+                    continue;
+                for (size_t j = 0; j < N; j++)
+                    if (j != column)
+                        rv[j - (j > column)][i - (i > row)] = m_cols[j][i];
+            }
+            return rv;
+        }
+
+        T minor(size_t row, size_t column) const
+        {
+            return det(exclude(row, column));
+        }
+
+        T cofactor(size_t row, size_t column) const
+        {
+            return math::pow(T(-1), (row + column)) * minor(row, column);
+        }
+
+        T determinant() const
+        {
+            T sum = T();
+            for (size_t i = 0; i < N; i++)
+                sum += m_cols[i][0] * cofactor(i, 0);
+            return sum;
+        }
+
     private:
         neglect::vector<T, M> m_cols[N];
     };

File neglect/cpplib/include/neglect/unittest.hpp

 
 #include <neglect/boot.hpp>
 #include <neglect/math.hpp>
+#include <neglect/path.hpp>
 
 #include <fstream>
 #include <stack>
 
         neglect::string header() const
         {
-            return "File [" + filename() + "]";
+            return "File " + path::basename(filename());
         }
     };
 

File neglect/scripts/make_swizzle_includes.py

 import os
 import time
-from itertools import permutations
+from itertools import product
 
 vec_sets = {
     2:  ["xy", "rg", "st"],
     4:  ["xyzw", "rgba", "stpq"]
 }
 
-
-def swizzle_permutations(sets):
-    for x in xrange(2, len(set) + 1):
-        for p in permutations(set, x):
-            yield x, p
+def swizzle_permutations(set):
+    for x in xrange(2, 5):
+        for p in product(set, repeat=x):
+            yield x, ''.join(p)
 
 
 os.chdir((os.path.dirname(__file__) or '.') + '/../cpplib/include/neglect')
                 '// %s on %s.  DO NOT EDIT\n\n' %
                 (os.path.basename(__file__), time.ctime()))
         for set in sets:
-            for result_size, elms in swizzle_permutations(set):
-                name = ''.join(elms)
+            for result_size, name in swizzle_permutations(set):
                 if name == set:
                     f.write('const vector<T, %d> &%s() const { return *this; }\n' % (
                         result_size,
                         result_size,
                         name,
                         result_size,
-                        ', '.join(elms)
+                        ', '.join(name)
                     ))

File neglect/tests/src/test_matrix.cpp

         NUT_CHECK_EQUAL(m1, expected);
         NUT_CHECK_EQUAL(m1, m3);
     }
+
+    NUT_TESTCASE(matrix_exclude)
+    {
+        mat4 m1;
+        m1[0] = vec4( 1,  2,  3,  4);
+        m1[1] = vec4( 5,  6,  7,  8);
+        m1[2] = vec4( 9, 10, 11, 12);
+        m1[3] = vec4(13, 14, 15, 16);
+
+        mat3 expected;
+        expected[0] = vec3( 1,  3,  4);
+        expected[1] = vec3( 5,  7,  8);
+        expected[2] = vec3(13, 15, 16);
+
+        mat3 m1x = m1.exclude(1, 2);
+        NUT_CHECK_EQUAL(m1x, expected);
+        m1x(2, 2) = 100.0f;
+        NUT_CHECK_NOT_EQUAL(m1x, expected);
+    }
 }