From 0003a9d6d257368b6ba98c60134dee858192dcbd Mon Sep 17 00:00:00 2001
From: madrocketsci <aschinder@amssolarempire.com>
Date: Wed, 11 Mar 2026 14:28:15 -0400
Subject: [PATCH] added vector interconversions

---
 amsmathutil25_vec_conversions.cpp.tmp         |   72 ++
 amsmathutil25_vec_conversions.hpp.tmp         |  144 +--
 build_linux64/libamsmathutil25.linux64.a      |  Bin 496852 -> 497460 bytes
 .../objstore/amsmathutil25_vecconversions.o   |  Bin 13000 -> 13608 bytes
 include/amsmathutil25/math/genconversions.py  |   10 +-
 .../math/amsmathutil25_vecconversions.cpp     | 1081 +++++++++--------
 6 files changed, 724 insertions(+), 583 deletions(-)

diff --git a/amsmathutil25_vec_conversions.cpp.tmp b/amsmathutil25_vec_conversions.cpp.tmp
index 3b538dd..5c13d1d 100644
--- a/amsmathutil25_vec_conversions.cpp.tmp
+++ b/amsmathutil25_vec_conversions.cpp.tmp
@@ -58,6 +58,7 @@ vec3::vec3(const vec2 rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = 0;
    return;
 }
 
@@ -65,6 +66,7 @@ vec3::vec3(const vec4 rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
    return;
 }
 
@@ -72,6 +74,7 @@ vec3::vec3(const vec2f rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = 0;
    return;
 }
 
@@ -79,6 +82,7 @@ vec3::vec3(const vec3f rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
    return;
 }
 
@@ -86,6 +90,7 @@ vec3::vec3(const vec4f rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
    return;
 }
 
@@ -93,6 +98,7 @@ vec3::vec3(const vec2i rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = 0;
    return;
 }
 
@@ -100,6 +106,7 @@ vec3::vec3(const vec3i rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
    return;
 }
 
@@ -107,6 +114,7 @@ vec3::vec3(const vec4i rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
    return;
 }
 
@@ -114,6 +122,8 @@ vec4::vec4(const vec2 rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -121,6 +131,8 @@ vec4::vec4(const vec3 rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
+   w = 0;
    return;
 }
 
@@ -128,6 +140,8 @@ vec4::vec4(const vec2f rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -135,6 +149,8 @@ vec4::vec4(const vec3f rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
+   w = 0;
    return;
 }
 
@@ -142,6 +158,8 @@ vec4::vec4(const vec4f rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
+   w = (double)rhs.w;
    return;
 }
 
@@ -149,6 +167,8 @@ vec4::vec4(const vec2i rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -156,6 +176,8 @@ vec4::vec4(const vec3i rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
+   w = 0;
    return;
 }
 
@@ -163,6 +185,8 @@ vec4::vec4(const vec4i rhs)
 {
    x = (double)rhs.x;
    y = (double)rhs.y;
+   z = (double)rhs.z;
+   w = (double)rhs.w;
    return;
 }
 
@@ -226,6 +250,7 @@ vec3f::vec3f(const vec2 rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = 0;
    return;
 }
 
@@ -233,6 +258,7 @@ vec3f::vec3f(const vec3 rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
    return;
 }
 
@@ -240,6 +266,7 @@ vec3f::vec3f(const vec4 rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
    return;
 }
 
@@ -247,6 +274,7 @@ vec3f::vec3f(const vec2f rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = 0;
    return;
 }
 
@@ -254,6 +282,7 @@ vec3f::vec3f(const vec4f rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
    return;
 }
 
@@ -261,6 +290,7 @@ vec3f::vec3f(const vec2i rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = 0;
    return;
 }
 
@@ -268,6 +298,7 @@ vec3f::vec3f(const vec3i rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
    return;
 }
 
@@ -275,6 +306,7 @@ vec3f::vec3f(const vec4i rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
    return;
 }
 
@@ -282,6 +314,8 @@ vec4f::vec4f(const vec2 rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -289,6 +323,8 @@ vec4f::vec4f(const vec3 rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
+   w = 0;
    return;
 }
 
@@ -296,6 +332,8 @@ vec4f::vec4f(const vec4 rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
+   w = (float)rhs.w;
    return;
 }
 
@@ -303,6 +341,8 @@ vec4f::vec4f(const vec2f rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -310,6 +350,8 @@ vec4f::vec4f(const vec3f rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
+   w = 0;
    return;
 }
 
@@ -317,6 +359,8 @@ vec4f::vec4f(const vec2i rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -324,6 +368,8 @@ vec4f::vec4f(const vec3i rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
+   w = 0;
    return;
 }
 
@@ -331,6 +377,8 @@ vec4f::vec4f(const vec4i rhs)
 {
    x = (float)rhs.x;
    y = (float)rhs.y;
+   z = (float)rhs.z;
+   w = (float)rhs.w;
    return;
 }
 
@@ -394,6 +442,7 @@ vec3i::vec3i(const vec2 rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = 0;
    return;
 }
 
@@ -401,6 +450,7 @@ vec3i::vec3i(const vec3 rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
    return;
 }
 
@@ -408,6 +458,7 @@ vec3i::vec3i(const vec4 rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
    return;
 }
 
@@ -415,6 +466,7 @@ vec3i::vec3i(const vec2f rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = 0;
    return;
 }
 
@@ -422,6 +474,7 @@ vec3i::vec3i(const vec3f rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
    return;
 }
 
@@ -429,6 +482,7 @@ vec3i::vec3i(const vec4f rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
    return;
 }
 
@@ -436,6 +490,7 @@ vec3i::vec3i(const vec2i rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = 0;
    return;
 }
 
@@ -443,6 +498,7 @@ vec3i::vec3i(const vec4i rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
    return;
 }
 
@@ -450,6 +506,8 @@ vec4i::vec4i(const vec2 rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -457,6 +515,8 @@ vec4i::vec4i(const vec3 rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
+   w = 0;
    return;
 }
 
@@ -464,6 +524,8 @@ vec4i::vec4i(const vec4 rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
+   w = (int)rhs.w;
    return;
 }
 
@@ -471,6 +533,8 @@ vec4i::vec4i(const vec2f rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -478,6 +542,8 @@ vec4i::vec4i(const vec3f rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
+   w = 0;
    return;
 }
 
@@ -485,6 +551,8 @@ vec4i::vec4i(const vec4f rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
+   w = (int)rhs.w;
    return;
 }
 
@@ -492,6 +560,8 @@ vec4i::vec4i(const vec2i rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = 0;
+   w = 0;
    return;
 }
 
@@ -499,6 +569,8 @@ vec4i::vec4i(const vec3i rhs)
 {
    x = (int)rhs.x;
    y = (int)rhs.y;
+   z = (int)rhs.z;
+   w = 0;
    return;
 }
 
diff --git a/amsmathutil25_vec_conversions.hpp.tmp b/amsmathutil25_vec_conversions.hpp.tmp
index 6d3597a..da846ad 100644
--- a/amsmathutil25_vec_conversions.hpp.tmp
+++ b/amsmathutil25_vec_conversions.hpp.tmp
@@ -1,81 +1,81 @@
-explicit vec2::vec2(const vec3 rhs);
-explicit vec2::vec2(const vec4 rhs);
-explicit vec2::vec2(const vec2f rhs);
-explicit vec2::vec2(const vec3f rhs);
-explicit vec2::vec2(const vec4f rhs);
-explicit vec2::vec2(const vec2i rhs);
-explicit vec2::vec2(const vec3i rhs);
-explicit vec2::vec2(const vec4i rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
+explicit vec2(const vec2 rhs);
 
-explicit vec3::vec3(const vec2 rhs);
-explicit vec3::vec3(const vec4 rhs);
-explicit vec3::vec3(const vec2f rhs);
-explicit vec3::vec3(const vec3f rhs);
-explicit vec3::vec3(const vec4f rhs);
-explicit vec3::vec3(const vec2i rhs);
-explicit vec3::vec3(const vec3i rhs);
-explicit vec3::vec3(const vec4i rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
+explicit vec3(const vec3 rhs);
 
-explicit vec4::vec4(const vec2 rhs);
-explicit vec4::vec4(const vec3 rhs);
-explicit vec4::vec4(const vec2f rhs);
-explicit vec4::vec4(const vec3f rhs);
-explicit vec4::vec4(const vec4f rhs);
-explicit vec4::vec4(const vec2i rhs);
-explicit vec4::vec4(const vec3i rhs);
-explicit vec4::vec4(const vec4i rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
+explicit vec4(const vec4 rhs);
 
-explicit vec2f::vec2f(const vec2 rhs);
-explicit vec2f::vec2f(const vec3 rhs);
-explicit vec2f::vec2f(const vec4 rhs);
-explicit vec2f::vec2f(const vec3f rhs);
-explicit vec2f::vec2f(const vec4f rhs);
-explicit vec2f::vec2f(const vec2i rhs);
-explicit vec2f::vec2f(const vec3i rhs);
-explicit vec2f::vec2f(const vec4i rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
+explicit vec2f(const vec2f rhs);
 
-explicit vec3f::vec3f(const vec2 rhs);
-explicit vec3f::vec3f(const vec3 rhs);
-explicit vec3f::vec3f(const vec4 rhs);
-explicit vec3f::vec3f(const vec2f rhs);
-explicit vec3f::vec3f(const vec4f rhs);
-explicit vec3f::vec3f(const vec2i rhs);
-explicit vec3f::vec3f(const vec3i rhs);
-explicit vec3f::vec3f(const vec4i rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
+explicit vec3f(const vec3f rhs);
 
-explicit vec4f::vec4f(const vec2 rhs);
-explicit vec4f::vec4f(const vec3 rhs);
-explicit vec4f::vec4f(const vec4 rhs);
-explicit vec4f::vec4f(const vec2f rhs);
-explicit vec4f::vec4f(const vec3f rhs);
-explicit vec4f::vec4f(const vec2i rhs);
-explicit vec4f::vec4f(const vec3i rhs);
-explicit vec4f::vec4f(const vec4i rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
+explicit vec4f(const vec4f rhs);
 
-explicit vec2i::vec2i(const vec2 rhs);
-explicit vec2i::vec2i(const vec3 rhs);
-explicit vec2i::vec2i(const vec4 rhs);
-explicit vec2i::vec2i(const vec2f rhs);
-explicit vec2i::vec2i(const vec3f rhs);
-explicit vec2i::vec2i(const vec4f rhs);
-explicit vec2i::vec2i(const vec3i rhs);
-explicit vec2i::vec2i(const vec4i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
+explicit vec2i(const vec2i rhs);
 
-explicit vec3i::vec3i(const vec2 rhs);
-explicit vec3i::vec3i(const vec3 rhs);
-explicit vec3i::vec3i(const vec4 rhs);
-explicit vec3i::vec3i(const vec2f rhs);
-explicit vec3i::vec3i(const vec3f rhs);
-explicit vec3i::vec3i(const vec4f rhs);
-explicit vec3i::vec3i(const vec2i rhs);
-explicit vec3i::vec3i(const vec4i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
+explicit vec3i(const vec3i rhs);
 
-explicit vec4i::vec4i(const vec2 rhs);
-explicit vec4i::vec4i(const vec3 rhs);
-explicit vec4i::vec4i(const vec4 rhs);
-explicit vec4i::vec4i(const vec2f rhs);
-explicit vec4i::vec4i(const vec3f rhs);
-explicit vec4i::vec4i(const vec4f rhs);
-explicit vec4i::vec4i(const vec2i rhs);
-explicit vec4i::vec4i(const vec3i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
+explicit vec4i(const vec4i rhs);
 
diff --git a/build_linux64/libamsmathutil25.linux64.a b/build_linux64/libamsmathutil25.linux64.a
index 6996fbdcc49242fd17c9236a43609b20993d599b..8bd7bf874cf90231bfe361ebbea889b7ff98ab73 100644
GIT binary patch
delta 5790
zcma)<e@t7~6~~_+e(xIQ`aNT65(>u25|nlgg#|h^Wf6a%gmzoxP1+W*j<GDUvix99
zAWfuom`<!p2O&-!<>ZeoqFT0PQdL=7q*haeOdtuFXykO!+DTF5N*S88ic+ZdBTCuM
zdGB0!Ja|o>gutKgIrsdy=iX;-|2}r<%~=0{Z$KR=8SoEi1NtSQ?k;(@p(T6k$}_%A
z;Jc|upnbO(g4vg}7}Wn%i=~YYz5V(QQ^Cgwi}6e{S#Q)1&_^XRZ^Z7Sjy!36l%F>`
zwg={n@D3BLjM_Fuc@%x#=nKgJ^TzZT1(5;JKYgDJSfD6###1s%(n{cAdeSgM<VcAb
zVPo7~0O@mvx!uGp)=*h!WLH7!r=1mYZJ*r%xs2?@lC@E5cf<@C9aN{4Rr#3FVdaKZ
zw_5tLg1&Dj?re$G5gEm!GmCpfTQG0@SVz0bq>;+cV0HMn9Wj&4z|;@LiS+dy0jfMn
zsYGy-9UE}p?jI%`u@aucT{h>j6M=EN{}0pK2X$V){Z--YKDPsP`1~!cCXIDVOXIs%
z9!ssW%jnZ>!Jamp13M2a<56@>lty`3rH(>3T9sbk5#&y+Qg9|&4-J0p@ia9Ge{L92
zo>zP4uoM}9YF%+wP@l(13vdv$u?ukQ{Ne)Kf@ND_cPOYd(v(^)a&^Kz+qCm!7>4Ke
zihnL`^E77v*JbDI{+#jjcGKR==`m7Y#T|B><A>>v-J8ddE7qSkp8hIrSRb~)mR$kR
z;4}5*a|8=}#TvNVE~+54SNPMi?@63(EB0!sFK+Hqg)}%c82Gaj%O~gQ8%g7!wXcrB
zlIzRlovp#lyX@3CfHa~CDFCid$htr2^CQg3(ufRh58ygbd|os{;qU%kkT<jn=-(%f
zKUP7biVxk+1^D<^{z&OP3n)qi*8NCCzOt4-l10#Ge{ixmGwb3*ne3XF#o#b45wpE4
z=>?XYfm71lVK=}m0%NqqI*0TIOVtjRXXeb}HnTbi?-vnY4Q$*m{`h32!z-uSADjtJ
zNCqGOtRw=vq9WM%A+yIFzDkMxA?jci%xd5p2Sj9DjYHbXk~6^sgkSMRO82l-4X>kD
zbHw2_BqawMVdgC45*)^r;K2cL`AKJljNf*2ZrBCM;DdwMS*Q7wlpNuTtFTX)l|$np
zfjv4Tf;H9J%1{l=;xJaB(GI+f=F2APptNvA>}O^;*coOKxP?pj)?|M$-ttyWxA>he
zEhp(c-0pJ4r}VR%<g?62n9B_-#Z4u9H($>@&-QXZwyw_8%C}i4vV&}P%7g!cImWgg
zX@9|kk1~(5z1*?)EuQu%ZeflcTG>I4cMvCsDt7Za=3OrPRuA66yr1mT_#<20;}jg6
z#@K4LE5L6&_$c!{+siF@e-%#gl{prQ?68g?K0zE*3hd@}%uVbRJ@P7P_23=M8`xfM
zL9ZX{rvPqYm>m-AP-n+cE_(1Q%=_71ULAKl_`jHssPOEIA_P-ML;#vz6lU2|cv2{%
zoC-5XM6@c$D_Y;bF^f*t^D4x8P|v&c*H|y8u#@xx>!0HaCRs14(1&_?(WNhF5IZKK
zaJdIF+HedrYSQhDloGg0E6STwp6~svn<WtH716Ybn@Nw<M_7+DmlxlkJos(qG`{r6
z@t^VF0b%FYW!tA09o8=w7Wr1@{T!g&j-!0XgCAi&!uIkta&lFU1AUQ&JUhrMYutn1
zWnN@^IX(aN;1&1{mS#l3DWXT(KSMmdits!;#Mwd4{~izC$DGa+Jsa&`$~h1I2j(fX
zw+^&CkW&tU){uOfxqQLN8^Tv=SLWu`%yXQOT<1$GxfNgeCJP02kVALKgP&kN%k~?%
z;$M64QRZ<xPV~rO|63^?AHB-WKVka@4YuL&s*<nPu<fpFDzghuXwXf1g4dP$3#_L!
zI8S=YrDs^rXmFGCj7z`9dQO7{(sM5T0qX?~>W`ydaOq#f`-4VqR)bE`XIYom%0AW=
z9fna)D|lGxk@|VoP3Cd}-}d0|GH+me`I7z6gX{QD8|9a<?bC{Mh%Xlw`InieTnT;4
zgQu8hTnP=X%5eyP%R<iOFy_JUFfXvZyp{g#!OI`x9btPpDVvGYB{1s}+S$RxTZJCk
zq1_(*CFTumAGf>|<*WzKF;AeqbqM9P^k;`aYe;^NdCHa0|2%kA$gVi!N~n1yw=aPN
z3psX>hxC94e}#FT?d7fXx(C0^yvX))sNV}=B$~!W0Z!LyYqKY>1mAl1C*q0$Uz^Ya
zzJEaYuwDt9j;TS&4+=lzKk^4u(+AxXdKB&r3KJT(XaQdfoE#FBP%(s{x(7iQyi<ja
zZ3Mc=;sm_BMXQ8f1ZO)%pghOlqv+jEKc))jhw!Byd_oVv<QC0T6Dr(9a`sa_pem>i
zqv}5?OkWPZ-h{#K4AU191ZDCI1bS?1LaTu$VV2JFw}#{J0R=wyscx3a_x=dH(}V0D
z+QGq7BH){ZL$u_Dt2(BO0imK9r8k-|LR+t9!W0^*Yf50|6fWOJ+Ap8bOMNA<(4%3z
zVT>nVMEhWKGcMKJEW&H~rq1w7Q`VaE!`)#~Ddo3a@~j_17^hTT&_(zjt=M)7!zLE6
z8v#Fb_F~*#Br0B~!`Jkvir407wZ3#M?&9DwC|-*<an&+;?e+U%^eS$mKZ6}?;DdP4
z55u%_6T+$#L-~S|D`j-(%wQiLT*XG6If`3Vz$+C=nLN*N4Q6PWiKAK=Heb_4c{^Xm
za*c$5nWI{?OdhNhey79Fu;DZYmWSb-%PB8l=V=jDivsFH{`J|y_*NL1(h}LkL|pxk
zfX=`8YqLL}tW;Y9_}^PJo1fUkf4+9r`YU#0o4Uu=`jPAlKzCMbgZK%504`-ki>iD9
ZW{{|@A*ertzXR3KO~3Pv@a7p&_kS)qjf?;Q

delta 4243
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

diff --git a/build_linux64/objstore/amsmathutil25_vecconversions.o b/build_linux64/objstore/amsmathutil25_vecconversions.o
index 93bba8f07d9f7f65e3f990755bc3072f7bf4ef22..cc4ababcf46f03359066db88c75d4ea3bad4658a 100644
GIT binary patch
literal 13608
zcmbuFe~eUD702JUxNPmp8z{EaVi^cUtS}C{gOW<jL|}Jg5H}SnSy6U@-7a>2Om+uC
z4Z%&shL&n3h8X^6%o@><h{?qC57H1aNF&tn$Howg2{CIVq<;`xcZs4Q)_d;zo;zpG
zySJOjO@{aG=bZ2Tan8MW-p=Fu+qQQ+($o}jX^Ora)oV<nXl+~lzG!cYQET*gG#5Yn
zpMf~j94}sYIbKop*5e*)uCRT+`doZ$(Oi7{617R~&sV4ZyRLL*Xjr5f7|6vdj@v<2
zFup~zai${^FOFy9#hsbUbqBJW@kn_^>yz;g#DA~N#XTJ@NfVWUc*WMp&UZdLjh{Q<
zdGP?%{HT-J_<8PRz>Z(c-)lGXUql9)nwesF{$>!%k|1#$Z2R@`+u+PMe{O~2P!DFj
zB8f+4QQSk>vx8c4DekdDbL&IR$9AgY!JQypdfqO<N&H5ejo;OQxKz7q0$}cw4l7Cg
zXnhROAf8Cp(|q-=lg(YPFTCv5tFD{zH^<+y&2fG{vQGV7>1?6M^Ds=?$pYo|X$+Ul
z_>y_{bY$jCR9Y^(@tgdH?Ph#vo`x+}FY;mRb7uLs7;DmOrJgdZKW+fiO4}0y4R4N?
zC%2>K@3+(ZO+Fg}pyz+3vla32gh7or$zNtihN5Xc@5N8rvx3hT%9jX8YCUs2(5DLv
z>nXq70Owhbm+a7b!y+<(_>9{1VU8wSPsV@S4E;}r2yf);VeK@&IWw|Q`wwfU_<q#>
zpz*tOW12F4v+=qPlRG-JZeOB7zHXMfI8W!ZC-Jw-$xTzXKWExEE3_U2)&6{TGe5C>
z()mf|f3l+`X}7*vME-dFm??4|-1mi>pIh|xFyK5e=apUGB)<LLKs;m@IL<Sg8n^EP
zAmZodhxXZrhD+_6^bn%2O1mCuK4QXhMY6rVRWR+SbIX<&vTJwkJ2X;0l-<ytYtQA^
zf8mg=wjFCL<no2j0@J>Z7MKrxL4VAAI(O`f9*LqFu}95^%F^T#HGS{JsOd<i>6zAr
zEfw=1LYn2U*%QLt6U%#;`8u}caa_r7H|`}H@~{ao(omu6DSMaPGdt^H7r=N9q@4nL
zQuyD({S$)S$NkfSwc-IxvMiYW{x-hUM*-|vq3!apJz#QtC6C{6Fgd={U@Ju*=fF5G
zG?p5e9N%@YHA4FV*rx@107mUlp=-u05Gs<b_OMN0GQZnBtQRa!nzikgJ?w;sy#@A^
z&{n}@?BDgU8(>R>_72!51>=n%*UM6D4jHSp9<~`w#=aZuInl=fFqyX_U^3@#di*BA
zWDMR0TP^yy3MS)x6Kt{YoAIy(bRd`_{g!#yIu9#)*iJCHHU>THD42|21x)V2Gah!{
zqrK+woA$7KU~+A=&;hApupCT|B@dRh-pM}M3MSXfZjW}zqn!Ygc{>Fr*Tz{ejupC3
zU1&=$i2m_m%3#2wp1&|x8NNhtKI^{};5)(jd|?0K0DlcUYpzsyO-!15>NjhyRG7bG
z?uq9ut@G;veiyu`{98;Qs2$B$fp^27=dn4!Ujpw{{&bF0`<lN2UQ+&N0{kNQ1pN8C
z;{5=h0iT3FpIeWavyH~1`6}=l{CQ1n4)B-2r{T|QzZBqafSayuVgEA$ei1wie_qdY
zUeowBp9L?%pU?ePbB@{kD!vB1SMg$i_kd5ppW{Cs;B-dYIIH%58Q>SeYw+jz-w5zo
z@M-w3L>^krnMM6-z6PAXxA{AU&Smn~yazmQ;!1_%Uk>megLlK9pDE4;`0v0c;Lm5`
z%>e%=_$2&!KW5B%XXC8+^Was*=?o@+&A$U)Q~pN+{3qa3@aJ>sHvxVXd|LVcEx`W^
zJ_CO~_n&S~#;<t+oS#$J|LXz%UGR)qM^xDVhXFnbo`pX@XS@^O*THE&QQ`e~H^5sK
zCiCi5{;L9fGx!Aj`8)cX0X_yk34eaJ`%!?O1+T%M&(F&N{ul6R`15-HcYrT7e;(61
zG+)BDu>a=+{Hx$u`15`|5a7qaX@66BF1bXf1N^t(CHV9Ca4o=ZgY$D3pI1$fCG*mJ
zIe1mI|HS}*5qt{%yxxWb`~>(6{8wYXzX<S);90ZJsPOv#bAaCi=jS?p243{>WWJiO
z1@A`t?EjSj-veG!{)Yp+0$x%6zYg%<gIAURUjzIB_>}U0${cjGZZ&TMpMgK0hhGcu
zLGZ|&2UOVq2Lb*w@C^KU{htr;KZ57s&(9lo0=(Hgpwhg$m47zCUjQ$u@$3rl5_m<m
ze=@*-1zuJDmje7I_!Rv4Jp5OHFZo0=-x>Jx`dlC2UEmpWo>Ad=?hEjv;Cc9GttyIs
z8sJs%Zus+g_=f<$1zu9)`7ppgwJ4cyMU7`;fOmse;m_y8D*^r*cn$u19{xPQFMv<O
zpV#yI0Uq@Yj}P~i2M?7G4z+FEd$@o9{?U=c{bS<?M@PnU`%9&0Z_kc)<5V!Fwk>Vj
zc6?(m-L`LQG;9bNoT3m?XoFR3r0xcM60gN++Jl;u#c2vbP0HdlZ3ly6(-x;`*A^Qz
znor8&G=-o>S=#HlX=@l-`xciQZLqyiHXBnQ6x!g%rE&v_CpQ?Eon>R3g+}E@XjBG-
zCS|FQtubaoqp~LYQ5g`Ll*RRv%7DwKvJ^tODTHz(6pcGgD73+iOXUU<Pj1kQCpSW)
zaw9Y<145Is)W_DC8=+CT5&ftP2u;f3`blNLmzyLczU08-**RKM&w|#ZEOu~>+f8fg
z`%U&k_aY5a<TusBP~UP|C2|ClQ;Ae)RodiKA{knhHaV3@lvXKI`#>mD#uCVs)HLQp
zYEl+Ex^$+brZH38Pcj8}{!*1iep5XTjhT`vm8pil>f0&RSIXr2Qt6O=rA<ziPDf}@
z6@r;EmO!SYrZFE<ld=RdB{hwi;(k2oV3FVC;-Ge-RHaQ$r8bUKrA<zy(jir8lT)co
zNtH6S9SrR$V+mwRY8vw)H7Sc7U3yPRO=G6GA5S`1<TtrEsB}nG+T>JfyGd2r<Wwph
zQk6D2RXQD^J=Gq}l(7UdB{hxtkeZamjxL=kscFm<_v1+ii~J@R2bB(~N}HTYr9-OH
zCZ|%{O{&r+r&5`cDrG7JGi5A+Oi4{+KBOjPv7<|8N@^N2#r=5F!6LuO#X+S*s?sK>
zQt6PYw8^PdI;1LXaw@gmq>4;Q;olADXK?%!ZViRRY#DKWAJC<E7WF-f=TYbPZ`^(n
z{J8S(M*Xzny{Mm4oZGD_K7l&Dr=-IDPTE=&eSj<T8tM-epGG}{_do1UKPgjLt#}so
zO^O#$->!Hs>U`z)C&0_fe-iZ*iq}woOYv#ctBPl+BU9d0JP&?D@ow-ticf&^qM<5%
zCc&5D%DjsDTE%Oq(|b@VbfM1_>fAr`Y48KMGM_>Hh~g367rd!Bzn7U*JPZG~6)%Ec
zRlFDcrs5OeJT5ZRXA*n?uFPwwFH?LP^>vE#dyS&v{QhF6;{2XsQ1KFe&p)bo1-zno
z75t3iQ{d+np8>z7IKLO*`EeZb_<j4H^6v(3L3`|90$;9p1w5~K6@07WQ{cN5p8+3I
zoPSrJP&|X*drv8z2dDS7RCxT|;1?7xfpc8hzXE<s`B%a3D?SC@ig|E5GvJ&D<{A86
zT2TIZ@Gix>!S^U$0xv0E0Y9#I75uc~{Cn>?#rb#LC^!D<aJg@vxt7P0>mc8i`;U~P
z+=0GwUzFQ7J|5-vj}8y_j~F&GTJF!8|Ax7Kyxh0{71UoIIg~4njh6by%CAPbvHqdH
zT>s$Sfw8{f{v>A)^Y1f8Oh+if?wTs%?mp(vh78}}y3$-pk8R<so6LJcU%_$hOrJ4#
z<of^W*BLFfnKvI<xPP+C!u|7gqcQTm^rQEyzM_4%87B%6ty5VBq0dTa?sc=@HjLWT
z`V(+GkM+gPX#H+upsiJ82fltTxv3$s<~61rC+qpWgRgH=7R~zzDp$>W6)NVnpv{ri
kQ@c8M<lll9$+KvO7!@5qdjI6p*EU%9=;h?%{?+>b0TmdL3IG5A

literal 13000
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
P`tsID^_&))bJo8PsblJQ

diff --git a/include/amsmathutil25/math/genconversions.py b/include/amsmathutil25/math/genconversions.py
index 7abc843..f6ca91b 100644
--- a/include/amsmathutil25/math/genconversions.py
+++ b/include/amsmathutil25/math/genconversions.py
@@ -31,13 +31,13 @@ for I in range(0,len(dtype)):
                     body += "{\n"
                     body += "   x = ({})rhs.x;\n".format(convtxt[I])
                     body += "   y = ({})rhs.y;\n".format(convtxt[I])
-                    if(J>=3):
-                        if(L>=3):
+                    if(dim[J]>=3):
+                        if(dim[L]>=3):
                             body += "   z = ({})rhs.z;\n".format(convtxt[I])
                         else:
                             body += "   z = 0;\n".format(convtxt[I])
-                    if(J>=4):
-                        if(L>=4):
+                    if(dim[J]>=4):
+                        if(dim[L]>=4):
                             body += "   w = ({})rhs.w;\n".format(convtxt[I])
                         else:
                             body += "   w = 0;\n".format(convtxt[I])
@@ -45,7 +45,7 @@ for I in range(0,len(dtype)):
                     body += "}\n\n"
 
 
-                    head = "explicit {}::{}(const {} rhs);\n".format(ttxt,ttxt,ftxt)
+                    head = "explicit {}(const {} rhs);\n".format(ttxt,ttxt,ftxt)
 
                     headertxt+=head
                     bodytxt+=body
diff --git a/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp b/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp
index 2614dd8..a0399d3 100644
--- a/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp
+++ b/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp
@@ -2,511 +2,580 @@
 
 namespace ams
 {
-
     vec2::vec2(const vec3 rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec4 rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec2f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec3f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec4f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec2i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec3i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2::vec2(const vec4i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec2 rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec4 rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec2f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec3f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec4f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec2i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec3i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec3::vec3(const vec4i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec2 rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec3 rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec2f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec3f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec4f rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec2i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec3i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec4::vec4(const vec4i rhs)
-{
-   x = (double)rhs.x;
-   y = (double)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec2 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec3 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec4 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec3f rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec4f rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec2i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec3i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2f::vec2f(const vec4i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec2 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec3 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec4 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec2f rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec4f rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec2i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec3i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec3f::vec3f(const vec4i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec2 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec3 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec4 rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec2f rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec3f rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec2i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec3i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec4f::vec4f(const vec4i rhs)
-{
-   x = (float)rhs.x;
-   y = (float)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec2 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec3 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec4 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec2f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec3f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec4f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec3i rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec2i::vec2i(const vec4i rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec2 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec3 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec4 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec2f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec3f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec4f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec2i rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec3i::vec3i(const vec4i rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec2 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec3 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec4 rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec2f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec3f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec4f rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec2i rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-vec4i::vec4i(const vec3i rhs)
-{
-   x = (int)rhs.x;
-   y = (int)rhs.y;
-   return;
-}
-
-
-
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec4 rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec2f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec3f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec4f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec2i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec3i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec2::vec2(const vec4i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       return;
+    }
+    
+    vec3::vec3(const vec2 rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3::vec3(const vec4 rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       return;
+    }
+    
+    vec3::vec3(const vec2f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3::vec3(const vec3f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       return;
+    }
+    
+    vec3::vec3(const vec4f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       return;
+    }
+    
+    vec3::vec3(const vec2i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3::vec3(const vec3i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       return;
+    }
+    
+    vec3::vec3(const vec4i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       return;
+    }
+    
+    vec4::vec4(const vec2 rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4::vec4(const vec3 rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4::vec4(const vec2f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4::vec4(const vec3f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4::vec4(const vec4f rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       w = (double)rhs.w;
+       return;
+    }
+    
+    vec4::vec4(const vec2i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4::vec4(const vec3i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4::vec4(const vec4i rhs)
+    {
+       x = (double)rhs.x;
+       y = (double)rhs.y;
+       z = (double)rhs.z;
+       w = (double)rhs.w;
+       return;
+    }
+    
+    vec2f::vec2f(const vec2 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec3 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec4 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec3f rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec4f rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec2i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec3i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec2f::vec2f(const vec4i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       return;
+    }
+    
+    vec3f::vec3f(const vec2 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3f::vec3f(const vec3 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       return;
+    }
+    
+    vec3f::vec3f(const vec4 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       return;
+    }
+    
+    vec3f::vec3f(const vec2f rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3f::vec3f(const vec4f rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       return;
+    }
+    
+    vec3f::vec3f(const vec2i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3f::vec3f(const vec3i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       return;
+    }
+    
+    vec3f::vec3f(const vec4i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       return;
+    }
+    
+    vec4f::vec4f(const vec2 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4f::vec4f(const vec3 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4f::vec4f(const vec4 rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       w = (float)rhs.w;
+       return;
+    }
+    
+    vec4f::vec4f(const vec2f rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4f::vec4f(const vec3f rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4f::vec4f(const vec2i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4f::vec4f(const vec3i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4f::vec4f(const vec4i rhs)
+    {
+       x = (float)rhs.x;
+       y = (float)rhs.y;
+       z = (float)rhs.z;
+       w = (float)rhs.w;
+       return;
+    }
+    
+    vec2i::vec2i(const vec2 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec3 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec4 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec2f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec3f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec4f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec3i rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec2i::vec2i(const vec4i rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       return;
+    }
+    
+    vec3i::vec3i(const vec2 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3i::vec3i(const vec3 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       return;
+    }
+    
+    vec3i::vec3i(const vec4 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       return;
+    }
+    
+    vec3i::vec3i(const vec2f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3i::vec3i(const vec3f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       return;
+    }
+    
+    vec3i::vec3i(const vec4f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       return;
+    }
+    
+    vec3i::vec3i(const vec2i rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = 0;
+       return;
+    }
+    
+    vec3i::vec3i(const vec4i rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       return;
+    }
+    
+    vec4i::vec4i(const vec2 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4i::vec4i(const vec3 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4i::vec4i(const vec4 rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       w = (int)rhs.w;
+       return;
+    }
+    
+    vec4i::vec4i(const vec2f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4i::vec4i(const vec3f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       w = 0;
+       return;
+    }
+    
+    vec4i::vec4i(const vec4f rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       w = (int)rhs.w;
+       return;
+    }
+    
+    vec4i::vec4i(const vec2i rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = 0;
+       w = 0;
+       return;
+    }
+    
+    vec4i::vec4i(const vec3i rhs)
+    {
+       x = (int)rhs.x;
+       y = (int)rhs.y;
+       z = (int)rhs.z;
+       w = 0;
+       return;
+    }
+    
 };
\ No newline at end of file