From 4fe50d12d08d811858d8fe87e58fb066f856d569 Mon Sep 17 00:00:00 2001
From: madrocketsci <aschinder@amssolarempire.com>
Date: Wed, 11 Mar 2026 14:23:36 -0400
Subject: [PATCH] added vector interconversions

---
 amsmathutil25_vec_conversions.cpp.tmp         | 504 +++++++++++++++++
 amsmathutil25_vec_conversions.hpp.tmp         |  81 +++
 build_linux64/libamsmathutil25.linux64.a      | Bin 468572 -> 496852 bytes
 build_linux64/objstore/amsmathutil25_vec2i.o  | Bin 0 -> 3056 bytes
 build_linux64/objstore/amsmathutil25_vec3i.o  | Bin 0 -> 3200 bytes
 build_linux64/objstore/amsmathutil25_vec4i.o  | Bin 0 -> 3232 bytes
 .../objstore/amsmathutil25_vecconversions.o   | Bin 0 -> 13000 bytes
 .../amsmathutil25/math/amsmathutil25_math.hpp |   4 +
 .../math/amsmathutil25_mathpredeclare.hpp     |  33 ++
 .../amsmathutil25/math/amsmathutil25_vec2.hpp |  10 +
 .../math/amsmathutil25_vec2f.hpp              |  10 +
 .../math/amsmathutil25_vec2i.hpp              |  22 +-
 .../amsmathutil25/math/amsmathutil25_vec3.hpp |  10 +
 .../math/amsmathutil25_vec3f.hpp              |  10 +
 .../math/amsmathutil25_vec3i.hpp              |  45 ++
 .../amsmathutil25/math/amsmathutil25_vec4.hpp |  11 +
 .../math/amsmathutil25_vec4f.hpp              |  11 +
 .../math/amsmathutil25_vec4i.hpp              |  47 ++
 include/amsmathutil25/math/genconversions.py  |  63 +++
 .../math/amsmathutil25_vec2i.cpp              | 108 ++++
 .../math/amsmathutil25_vec3i.cpp              | 122 +++++
 .../math/amsmathutil25_vec4f.cpp              |   3 +
 .../math/amsmathutil25_vec4i.cpp              | 131 +++++
 .../math/amsmathutil25_vecconversions.cpp     | 512 ++++++++++++++++++
 24 files changed, 1732 insertions(+), 5 deletions(-)
 create mode 100644 amsmathutil25_vec_conversions.cpp.tmp
 create mode 100644 amsmathutil25_vec_conversions.hpp.tmp
 create mode 100644 build_linux64/objstore/amsmathutil25_vec2i.o
 create mode 100644 build_linux64/objstore/amsmathutil25_vec3i.o
 create mode 100644 build_linux64/objstore/amsmathutil25_vec4i.o
 create mode 100644 build_linux64/objstore/amsmathutil25_vecconversions.o
 create mode 100644 include/amsmathutil25/math/amsmathutil25_mathpredeclare.hpp
 create mode 100644 include/amsmathutil25/math/amsmathutil25_vec3i.hpp
 create mode 100644 include/amsmathutil25/math/amsmathutil25_vec4i.hpp
 create mode 100644 include/amsmathutil25/math/genconversions.py
 create mode 100644 src/amsmathutil25/math/amsmathutil25_vec2i.cpp
 create mode 100644 src/amsmathutil25/math/amsmathutil25_vec3i.cpp
 create mode 100644 src/amsmathutil25/math/amsmathutil25_vec4i.cpp
 create mode 100644 src/amsmathutil25/math/amsmathutil25_vecconversions.cpp

diff --git a/amsmathutil25_vec_conversions.cpp.tmp b/amsmathutil25_vec_conversions.cpp.tmp
new file mode 100644
index 0000000..3b538dd
--- /dev/null
+++ b/amsmathutil25_vec_conversions.cpp.tmp
@@ -0,0 +1,504 @@
+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;
+}
+
diff --git a/amsmathutil25_vec_conversions.hpp.tmp b/amsmathutil25_vec_conversions.hpp.tmp
new file mode 100644
index 0000000..6d3597a
--- /dev/null
+++ b/amsmathutil25_vec_conversions.hpp.tmp
@@ -0,0 +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 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 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 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 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 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 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 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 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);
+
diff --git a/build_linux64/libamsmathutil25.linux64.a b/build_linux64/libamsmathutil25.linux64.a
index b4b1f64c0e8ed8a85f966f7e6cf8bfd1f230c6ac..6996fbdcc49242fd17c9236a43609b20993d599b 100644
GIT binary patch
delta 23269
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

delta 3579
zcmcbzQtr+fnF*Hl#^%Nr3Lucc#lXOv%D}MY3O#W>JuSmxS3O;Qi|K%R`UW?K1M2A<
z-{=k)*!X7_t+!xc79BubKaiFK?XDkC--}w*4_NTCB=|6}B-DclG+cCpfrVbU9-Bp{
zc^FuziSNH)V0o5<71!gEpp$q#R#(x(a#pn&46JJPAYuS<{Xkj{w7VX~_i1|=Sm}%F
z>1`pJef4;Jyz2l1E3I)ott}v6em${1WaHCepaHI@g`p&vSx<tmQVJN@sEzBXZ6Jx}
z)sy6-?Qa;^sEdK|PhA6vGw<C81~xFRhcO0-wu8HbEC+19AmB8YNnd|*;Q`Ib4F^~m
jO*YRyFo&^u_M!IKhZupF35c12m<5Pgx6eMrR#*uD3w7x=

diff --git a/build_linux64/objstore/amsmathutil25_vec2i.o b/build_linux64/objstore/amsmathutil25_vec2i.o
new file mode 100644
index 0000000000000000000000000000000000000000..8cef38f8778e5917d0059d15512538152e3ae547
GIT binary patch
literal 3056
zcmbuBO>7%g5P+ZKr7<P!8id+F5m_V)wSq3TlNPlS$j07yp){(RMpQJx*|_V*s_nS;
zI!ZW%NUkca3?c_E+;TzUfYgX1ryzrR><QEZha5O?KtfeOty*ZAc{{J(Jlmpzk#=Y1
zdo%NX_vd5ty~&|ahzSX?w^-K`l(DTy*G_RW#hzv(Y*%~fo^@jwNk<z?ao>Bxdtd1k
zwXrPo+uQprZ@9A|+O75h%e!lN2Rp?L%x@n^Y@ayjDo}v6CzTU9Mf-d^ke@#Hj`zom
z<^4EqdG~+Cu6EPfniAX9)=o3ayH(U4d{@+d3SXE@&vrJ7MME3Aict*eVf}y4zxNpV
zf$r07C8k~fA+236#}qFNL+~yue(&A>r1&rH{OyI)?QBdzE2BUX&)73ufBj&pf8tcF
z)^8Dix;W9I_WL%UtUp+*^?l^RT!*j!r#YqdAY^IgjUJ!nGMSV5;hBYI)otpDabw(w
zA3fgWZgMR-VZ<kn5avs!z&#4r6L96GX4nv8+sMLjp*-g+7W(Kc3#~*$hen1Y8*pGS
z=S6B8A&o3f_Wl5aW5MOA06R~%8enCzUm$%L^g7uI)RSuTlcB6SdM%t)^_G%XN7HKb
zZ559y#(s@4AdeG!%MWF*qwdztVBHU;x(YoYQe7T9ABc@XsW`>*buiWFH5_j%oKy8V
z9+`&G;yRtDIJ8l4oy!vA4Fhf%s<7J+`!$FAJkifX;IjcP_UzRG{7vFwd}2S(4B!Rg
zI%pKJ*Q;P-zdAw?!9N2Vd7M+m#5wqqc#60<3*Qo-C(ic*?3=_lCH@QX9pZeS!M;O0
zN^33Z><1smbB4GW*BJ42;$l4##PL}`5uDkTM#Xj)n{KI`JeFT}3dxdDsMT2hgQ;<7
zJH|;SX)a47(L<7EsniqHgOcXiQ`7N$PhcNvPj_QabqC{IF{wZR*2;ZgrPL3WO+L&(
z^2KEzVIS2?=G1iFpSHPol%<uPOpb6p>v#iE==$rSFW+$5%Wn_hFVp_Wb?gCLr#kQ+
z#CPE%nIKDWvEP=&b@FE=F3wX;;wkd4N_?LDEs1ZE|Fgt*$dAyx9*vXy35knyJ}Yr?
z&TA4E=bRah)rxB`fOhM?UKCc{DcgqYthmg$XuCEu78(s^6qYI#rwXjP<T?g?V~#dl
zyKtHOOVy@Pt1s1@y1U8@Ucp(+7wdM#p&9)@r9(PSWuH_gMgAtuQ#6Zx75*VG@a&`n
zApI2;Tp=Idk5~%7MJS`bVy}QkF21LP*^bn&;4*#<8nEVn&Byl}))eOtOfI5-tREE7
zztAV4QP{z_k>JA-Xpm#yg*N<Kl*6M0^gu3}V*LbO00V2v`Edg4QipQ>9OU-fKb`-=
zGNw~L?jPoge6fH1`i3yJMH{k3`S@K!B<DX#9Mm3}#~&_`tTcYfWzRs2y!V)wqK?Yw
I1VqmN2gzim_W%F@

literal 0
HcmV?d00001

diff --git a/build_linux64/objstore/amsmathutil25_vec3i.o b/build_linux64/objstore/amsmathutil25_vec3i.o
new file mode 100644
index 0000000000000000000000000000000000000000..de0ddecfe6fd694a2c94b539ff82ea89a0cfa872
GIT binary patch
literal 3200
zcmbuB&2Jk;6u`&v(k#W@H3+pqLCu0JR8+EZ>=c>`kWIXap^!pDXa%WUJGC1V+cEY!
zN<j*hTq>;$l99Od2EA}WYW@HYMgegR;zK!b;(&TU0+d1_g_QSZ-^AOojUsr`?!5W!
z`<i*<UB7KTKhfv&F(E$oG;7ZUWh{2LN9Ssc?PCG9sUO@*e%X&?O&^N!x$}f`N^wr8
zYt3AfKX2?wI{l3a)tN+=GxecMJcK^v`Zx9`oj;P!fyOJUb4p$FSaAQw{*l($0b79t
ztTCmGolt5wAllfZs(;Y(T2s9E%g;LB%p{%PrjyRC>zHX%U$NL`Twe)<a{BgXIsH3-
zypag0eoJ-6)uglW+L`$5PW|YA1N^^j`-7_zf+#ProW9leKm0HL9`|@d3F+6qaClM$
zw77n)5Q5YSq;?imo;{}zC9u+iTO$A8)6UnteDuF^^Oj>VtXko!!WY0*Sip5!0QVP5
zPu71@#qzQ6pIf5%hNa%zz?IiOcUKQ<cUyw_-}&9%Ti^ECgZ1q`TZ7iDwOf{a4|)ju
z45K3YyK8$kIX-^OI5d-~mF$`^5;db{c=+)epGH<9qh@&YQNsLuz)gWG2-jV3O-{|Q
zKE_(e{BWV%?+(oO=1JyT4*CWI{b~~qF#0@5&jK_e3zNRj!(iLF-0NYdNf+_aw?OP+
z8V|vEk@P2VoX~>r_9e7|%l?FB)Rot@fw&fYMpNMt+J1sIAiJ^Ma821U9NTfnF>YRp
ztI!YjsXJ|X4GSLI5Ihf)?NPL~wBTi|x9*?RjEpvr(1LNO7T0>3?1s?}1oxpJG5(;(
z4NVpH>+Noj{axNL4}jr)9xi%zxCh6zqCM7%BKr9f=-qghxB(-I==EEmqrHI;MDX`P
zM;=26BF@3bpd&wv5Ja4XPeDiC<dk|0`d7r)CH^DvAnhsdGq692zet?-6j%V}JU(&W
zKj04$Uneg56(x>87!<)-x>zly?fIIWFGP-{ma=ovyg64cv(&3oQFwNQlktePB$1I0
z60!36e1}yhi&!U*Plr<-mR)Fix@~*BT~785ivoCHxzGg`^W9*<;&pnQ&n>wKbCk|o
zQ`0GT;ntm1=9fD>Ib!UpyRH2FgzuxjZoBeB4~~68L0hkVx(ENL2RASX2)314%jcu~
z-sa+Wk(9VW^I3_<XkM21S(;yxxH#vl5?`nJ_YxQ9T%~o1`o%dPm3Wipvl18Qye#pZ
z%`mGMigr4~%&J{+$9bVuvW2v1XP0eeo=e+lW@f5YX3i}Zi`f#e(xRO;;TtntwbOG8
zG(TUendQo2Ia{$WFq22f&ZlyfbP?Yu|6dFUflJvVg^JO9*xO`aLCJ0q=6IfB5<klS
zk}<YSd@qcc2fsxq1Ma{cff2d*o)Tt7DX-wP?PAIv0}W&TSN{?4#h78Zydv^re6NW7
zV#N2R(7kq7c3J;(;DlQxn}0~a@CF54?4Q6HP%yvj-y(2PDo*x41HRq*w@Upp$RGQM
zzQSMhuUl>~V=)X0vP%B<fQ~(q{qb+T+&e(*7yQEoG9lG3P5Jk-oBui`D!5^G?y~<s
DHn`K+

literal 0
HcmV?d00001

diff --git a/build_linux64/objstore/amsmathutil25_vec4i.o b/build_linux64/objstore/amsmathutil25_vec4i.o
new file mode 100644
index 0000000000000000000000000000000000000000..de440a4cb3febdd74edaf27f7709af1ce3390f71
GIT binary patch
literal 3232
zcmbuB|7%-S6u@ti=NesnHx<#y#0FMn)9sn2t<Zsz*uM6;bzNx|D6X|lx}+`Uo5@S*
z1iwJ$AVi^{{;*&DP4I{P1(HzN=KR6VAq)}OkNsg_rJc$;I?uT|*Sy`PIQ7DN=bX<y
z=iGDex%u*eIXdiixtJU-_8Mzhk}@{?XiJX>HNqZeKDNo9yK7zPK(flaBEnAd+_&i{
z&#i%S8J?fgJb4YC)ilpEcxT7zO4{IE=S3Eb-{kpyh-Ez5R`pNeiSxCmdg=pD+Zs5q
z+L$(QN-J;G#=HZkyye@qVc)=rkAGH&<XuBdtRFr7Ms+K0Rey|G)$Mg$W;4q3S~ui9
z$*k(lG~a<TJZGk(Q>&Q&pZ)JX;2+05S=BqSG%tJy3Ae4v?EpXQ>u#>a^CnC4ysuj<
zm4{O(tp(G3>pCdcQE5QjH7~sC@Je3go%^lIH-R(La4svdo_kRLomlmTNLe%4#Xq*I
zjhd;!(hbxv*Gve`{c;h{73?cD(+BqVFb867w0f&~=$S^8cWT{Yukw6F>SozqS@KCJ
z`PaIrSZo$5@?u3;&qu%8yt3o64_0>EwqDus*qzWG=mwm(^~s1A`vTHOQd9f;ujARs
z;NY>~p?I>Kv&+GrUZd9t9et%N%<%i+J|on3n6S7+@Y3M%!}AC{BV%#qW~`3P0}qZT
zn}WIConWqIzw3an!@B|(9b=xQIUh-6A=00BFxajbPQOWFoFv9(NPm&!A&?)EF7giR
z{*T>5df<X*NDo%DxAZ_%_rI=t!3TZ6dPv`H@ViOA(<n{df5C0(fr@8T54ocvZB+MS
zPWhppLS0$keY{lw<~%}Q057Aj$O*MpJR^E=N~RR&cAEV9(GLdheL-PjqRk84H1^y5
zHdD|uO5&J&2J|N!T=w9lJ@~7{u_hd{j}xF{9+l4%kATD>^S=i=`bQALko;57k&g??
znC$<T#Ak`iJMcB}72+Y1H;C62zD|6DxacqF+r-D|h(teu>0o0$mxznr0Y6Cm7IE3D
ze&Rv+px}_4C9<V#!d@ubi<xl$%u;HuZ_$`56xht0W4$ofFUVlnTvABSE)q5uVeE2i
z1H<OTiCAc6munlEh_!rAv<gbSV^RVKEM(fi>|#5ZF-4({;Im6jglpvH&9T@_bL-}V
zRW2^?iWKOJ=CO+JB@Og@_nYH~JvjCc2l_hw6MOK+9z2LiU|?IRwZiTb?-uuyZ7DoL
zw!Bv|&p7dd;y+9Fd4;c#eM#YUvVT_i2H6_z>+f~R4k=vT^GSuvd!A9ayywg)oy*#Z
zBuKm1lnYWTrZNe`PA%KaIGeB&%t)3>%$Un(v#A`gT;5I@@Y`~<WGCj{CVM_tHVVaj
zAyu@`F+*fXEzG2giEN5?^#4Q<!f`A6lr#~t<IW}n^DBM_z{dL&QTU|z%f{F;@y9^o
zI$p8^Bwrvde@6+k&y{s0r(>5UI|3T!{IBsn5Q{lO@HmHDAM-nhTwls#Fe!DXU*jR`
zKMp~7RI2+`0zqd|(B=6_oCF2eSL4?SEGxyS@%X*pu77LPzaYh9|1eg@%l@@n8{F6|
qCWRqCNBcp?9;xy8w_oiYAm*nFX({z9ChOcIeuEauU^2&0<NpFDFZ6c+

literal 0
HcmV?d00001

diff --git a/build_linux64/objstore/amsmathutil25_vecconversions.o b/build_linux64/objstore/amsmathutil25_vecconversions.o
new file mode 100644
index 0000000000000000000000000000000000000000..93bba8f07d9f7f65e3f990755bc3072f7bf4ef22
GIT binary patch
literal 13000
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
P`tsID^_&))bJo8PsblJQ

literal 0
HcmV?d00001

diff --git a/include/amsmathutil25/math/amsmathutil25_math.hpp b/include/amsmathutil25/math/amsmathutil25_math.hpp
index bb20a19..b10d7db 100644
--- a/include/amsmathutil25/math/amsmathutil25_math.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_math.hpp
@@ -23,6 +23,7 @@ static const double vecmat_det_small = 1.0E-15;
 
 }; //end namespace ams
 
+#include <amsmathutil25/math/amsmathutil25_mathpredeclare.hpp>
 #include <amsmathutil25/math/amsmathutil25_mathfns1.hpp>
 #include <amsmathutil25/math/amsmathutil25_complex64.hpp>
 #include <amsmathutil25/math/amsmathutil25_complex128.hpp>
@@ -32,6 +33,9 @@ static const double vecmat_det_small = 1.0E-15;
 #include <amsmathutil25/math/amsmathutil25_vec2f.hpp>
 #include <amsmathutil25/math/amsmathutil25_vec3f.hpp>
 #include <amsmathutil25/math/amsmathutil25_vec4f.hpp>
+#include <amsmathutil25/math/amsmathutil25_vec2i.hpp>
+#include <amsmathutil25/math/amsmathutil25_vec3i.hpp>
+#include <amsmathutil25/math/amsmathutil25_vec4i.hpp>
 
 
 #endif
diff --git a/include/amsmathutil25/math/amsmathutil25_mathpredeclare.hpp b/include/amsmathutil25/math/amsmathutil25_mathpredeclare.hpp
new file mode 100644
index 0000000..7766e59
--- /dev/null
+++ b/include/amsmathutil25/math/amsmathutil25_mathpredeclare.hpp
@@ -0,0 +1,33 @@
+#ifndef __AMSMATHUTIL25_MATHPREDECLARE_HPP__
+#define __AMSMATHUTIL25_MATHPREDECLARE_HPP__
+
+namespace ams
+{
+
+    //Pre-declarations for interconversion
+    
+    class vec2;
+    class vec2f;
+    class mat2;
+    class mat2f;
+
+    class vec2i;
+
+    class vec3;
+    class vec3f;
+    class mat3;
+    class mat3f;
+
+    class vec3i;
+    
+    class vec4;
+    class vec4f;
+    class mat4;
+    class mat4f;
+
+    class vec4i;
+
+
+};
+
+#endif
\ No newline at end of file
diff --git a/include/amsmathutil25/math/amsmathutil25_vec2.hpp b/include/amsmathutil25/math/amsmathutil25_vec2.hpp
index c132286..ebc20fc 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec2.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec2.hpp
@@ -24,6 +24,16 @@ public:
 
     double& operator[](int ind);
     const double& operator[](int ind) const;
+
+    //explicit conversions for casting
+    explicit vec2(const vec3 rhs);
+    explicit vec2(const vec4 rhs);
+    explicit vec2(const vec2f rhs);
+    explicit vec2(const vec3f rhs);
+    explicit vec2(const vec4f rhs);
+    explicit vec2(const vec2i rhs);
+    explicit vec2(const vec3i rhs);
+    explicit vec2(const vec4i rhs);
 };
 
 //vector operations
diff --git a/include/amsmathutil25/math/amsmathutil25_vec2f.hpp b/include/amsmathutil25/math/amsmathutil25_vec2f.hpp
index 883552d..bb6631f 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec2f.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec2f.hpp
@@ -24,6 +24,16 @@ public:
 
     float& operator[](int ind);
     const float& operator[](int ind) const;
+
+    //explicit conversions for casting
+    explicit vec2f(const vec2 rhs);
+    explicit vec2f(const vec3 rhs);
+    explicit vec2f(const vec4 rhs);
+    explicit vec2f(const vec3f rhs);
+    explicit vec2f(const vec4f rhs);
+    explicit vec2f(const vec2i rhs);
+    explicit vec2f(const vec3i rhs);
+    explicit vec2f(const vec4i rhs);
 };
 
 //vector operations
diff --git a/include/amsmathutil25/math/amsmathutil25_vec2i.hpp b/include/amsmathutil25/math/amsmathutil25_vec2i.hpp
index 205cbe0..88bad83 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec2i.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec2i.hpp
@@ -11,21 +11,33 @@ public:
     int y;
 
     vec2i();
-    vec2i(float _x, float _y);
+    vec2i(int _x, int _y);
     vec2i(const vec2i &rhs);
     vec2i& operator=(const vec2i &rhs);
     bool operator==(const vec2i rhs) const;
     
     vec2i operator+(vec2i rhs) const;
     vec2i operator-(vec2i rhs) const;
-    vec2i operator*(float rhs) const;
-    vec2i operator/(float rhs) const;
+    vec2i operator*(int rhs) const;
+    vec2i operator/(int rhs) const;
     friend vec2i operator-(vec2i rhs);
 
-    float& operator[](int ind);
-    const float& operator[](int ind) const;
+    int& operator[](int ind);
+    const int& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec2i(const vec2 rhs);
+    explicit vec2i(const vec3 rhs);
+    explicit vec2i(const vec4 rhs);
+    explicit vec2i(const vec2f rhs);
+    explicit vec2i(const vec3f rhs);
+    explicit vec2i(const vec4f rhs);
+    explicit vec2i(const vec3i rhs);
+    explicit vec2i(const vec4i rhs);
 };
 
 
 
 };
+
+#endif
\ No newline at end of file
diff --git a/include/amsmathutil25/math/amsmathutil25_vec3.hpp b/include/amsmathutil25/math/amsmathutil25_vec3.hpp
index 9d20220..58d0766 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec3.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec3.hpp
@@ -29,6 +29,16 @@ public:
 
     double& operator[](int ind);
     const double& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec3(const vec2 rhs);
+    explicit vec3(const vec4 rhs);
+    explicit vec3(const vec2f rhs);
+    explicit vec3(const vec3f rhs);
+    explicit vec3(const vec4f rhs);
+    explicit vec3(const vec2i rhs);
+    explicit vec3(const vec3i rhs);
+    explicit vec3(const vec4i rhs);
 };
 
 //vector operations
diff --git a/include/amsmathutil25/math/amsmathutil25_vec3f.hpp b/include/amsmathutil25/math/amsmathutil25_vec3f.hpp
index 85a4e25..e9d3c2c 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec3f.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec3f.hpp
@@ -29,6 +29,16 @@ public:
 
     float& operator[](int ind);
     const float& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec3f(const vec2 rhs);
+    explicit vec3f(const vec3 rhs);
+    explicit vec3f(const vec4 rhs);
+    explicit vec3f(const vec2f rhs);
+    explicit vec3f(const vec4f rhs);
+    explicit vec3f(const vec2i rhs);
+    explicit vec3f(const vec3i rhs);
+    explicit vec3f(const vec4i rhs);
 };
 
 //vector operations
diff --git a/include/amsmathutil25/math/amsmathutil25_vec3i.hpp b/include/amsmathutil25/math/amsmathutil25_vec3i.hpp
new file mode 100644
index 0000000..43e1ea8
--- /dev/null
+++ b/include/amsmathutil25/math/amsmathutil25_vec3i.hpp
@@ -0,0 +1,45 @@
+#ifndef __AMSMATHUTIL25_VEC3I_HPP__
+#define __AMSMATHUTIL25_VEC3I_HPP__
+
+namespace ams
+{
+
+class vec3i
+{
+public:
+    int x;
+    int y;
+    int z;
+
+    vec3i();
+    vec3i(int _x, int _y, int z);
+    vec3i(const vec3i &rhs);
+    vec3i& operator=(const vec3i &rhs);
+    bool operator==(const vec3i rhs) const;
+    
+    vec3i operator+(vec3i rhs) const;
+    vec3i operator-(vec3i rhs) const;
+    vec3i operator*(int rhs) const;
+    vec3i operator/(int rhs) const;
+    friend vec3i operator-(vec3i rhs);
+
+    int& operator[](int ind);
+    const int& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec3i(const vec2 rhs);
+    explicit vec3i(const vec3 rhs);
+    explicit vec3i(const vec4 rhs);
+    explicit vec3i(const vec2f rhs);
+    explicit vec3i(const vec3f rhs);
+    explicit vec3i(const vec4f rhs);
+    explicit vec3i(const vec2i rhs);
+    explicit vec3i(const vec4i rhs);
+
+};
+
+
+
+};
+
+#endif
\ No newline at end of file
diff --git a/include/amsmathutil25/math/amsmathutil25_vec4.hpp b/include/amsmathutil25/math/amsmathutil25_vec4.hpp
index 022b76a..9676bd2 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec4.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec4.hpp
@@ -29,6 +29,17 @@ public:
 
     double& operator[](int ind);
     const double& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec4(const vec2 rhs);
+    explicit vec4(const vec3 rhs);
+    explicit vec4(const vec2f rhs);
+    explicit vec4(const vec3f rhs);
+    explicit vec4(const vec4f rhs);
+    explicit vec4(const vec2i rhs);
+    explicit vec4(const vec3i rhs);
+    explicit vec4(const vec4i rhs);
+
 };
 
 //vector operations
diff --git a/include/amsmathutil25/math/amsmathutil25_vec4f.hpp b/include/amsmathutil25/math/amsmathutil25_vec4f.hpp
index 070b62d..ecc57eb 100644
--- a/include/amsmathutil25/math/amsmathutil25_vec4f.hpp
+++ b/include/amsmathutil25/math/amsmathutil25_vec4f.hpp
@@ -29,6 +29,17 @@ public:
 
     float& operator[](int ind);
     const float& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec4f(const vec2 rhs);
+    explicit vec4f(const vec3 rhs);
+    explicit vec4f(const vec4 rhs);
+    explicit vec4f(const vec2f rhs);
+    explicit vec4f(const vec3f rhs);
+    explicit vec4f(const vec2i rhs);
+    explicit vec4f(const vec3i rhs);
+    explicit vec4f(const vec4i rhs);
+
 };
 
 //vector operations
diff --git a/include/amsmathutil25/math/amsmathutil25_vec4i.hpp b/include/amsmathutil25/math/amsmathutil25_vec4i.hpp
new file mode 100644
index 0000000..6cc4643
--- /dev/null
+++ b/include/amsmathutil25/math/amsmathutil25_vec4i.hpp
@@ -0,0 +1,47 @@
+#ifndef __AMSMATHUTIL25_VEC4I_HPP__
+#define __AMSMATHUTIL25_VEC4I_HPP__
+
+namespace ams
+{
+
+class vec4i
+{
+public:
+    int x;
+    int y;
+    int z;
+    int w;
+
+    vec4i();
+    vec4i(int _x, int _y, int _z, int _w);
+    vec4i(const vec4i &rhs);
+    vec4i& operator=(const vec4i &rhs);
+    bool operator==(const vec4i rhs) const;
+    
+    vec4i operator+(vec4i rhs) const;
+    vec4i operator-(vec4i rhs) const;
+    vec4i operator*(int rhs) const;
+    vec4i operator/(int rhs) const;
+    friend vec4i operator-(vec4i rhs);
+
+    int& operator[](int ind);
+    const int& operator[](int ind) const;
+
+    //explicit conversion constructors for casting
+    explicit vec4i(const vec2 rhs);
+    explicit vec4i(const vec3 rhs);
+    explicit vec4i(const vec4 rhs);
+    explicit vec4i(const vec2f rhs);
+    explicit vec4i(const vec3f rhs);
+    explicit vec4i(const vec4f rhs);
+    explicit vec4i(const vec2i rhs);
+    explicit vec4i(const vec3i rhs);
+
+    
+};
+
+
+
+};
+
+#endif
\ No newline at end of file
diff --git a/include/amsmathutil25/math/genconversions.py b/include/amsmathutil25/math/genconversions.py
new file mode 100644
index 0000000..7abc843
--- /dev/null
+++ b/include/amsmathutil25/math/genconversions.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+
+import os,sys,math
+import numpy as np
+
+
+
+dtype = ['d','f','i']
+dtxt = ['','f','i']
+convtxt = ['double','float','int']
+dim = [2,3,4]
+
+headertxt = ""
+bodytxt = ""
+
+for I in range(0,len(dtype)):
+    for J in range(0,len(dim)):
+        for K in range(0,len(dtype)):
+            for L in range(0,len(dim)):
+                if(I==K and J==L):
+                    continue
+                else:
+                    #generate a converter
+                    ttxt = "vec{:d}{:s}".format(dim[J],dtxt[I])
+                    ftxt = "vec{:d}{:s}".format(dim[L],dtxt[K])
+
+
+
+                    body = ""
+                    body += "{}::{}(const {} rhs)\n".format(ttxt,ttxt,ftxt)
+                    body += "{\n"
+                    body += "   x = ({})rhs.x;\n".format(convtxt[I])
+                    body += "   y = ({})rhs.y;\n".format(convtxt[I])
+                    if(J>=3):
+                        if(L>=3):
+                            body += "   z = ({})rhs.z;\n".format(convtxt[I])
+                        else:
+                            body += "   z = 0;\n".format(convtxt[I])
+                    if(J>=4):
+                        if(L>=4):
+                            body += "   w = ({})rhs.w;\n".format(convtxt[I])
+                        else:
+                            body += "   w = 0;\n".format(convtxt[I])
+                    body += "   return;\n"
+                    body += "}\n\n"
+
+
+                    head = "explicit {}::{}(const {} rhs);\n".format(ttxt,ttxt,ftxt)
+
+                    headertxt+=head
+                    bodytxt+=body
+
+        headertxt+="\n"
+
+
+fp = open("./amsmathutil25_vec_conversions.hpp.tmp","w+")
+fp.write(headertxt)
+fp.close()
+fp = open("./amsmathutil25_vec_conversions.cpp.tmp","w+")
+fp.write(bodytxt)
+fp.close()
+                    
+                    
diff --git a/src/amsmathutil25/math/amsmathutil25_vec2i.cpp b/src/amsmathutil25/math/amsmathutil25_vec2i.cpp
new file mode 100644
index 0000000..1039f3d
--- /dev/null
+++ b/src/amsmathutil25/math/amsmathutil25_vec2i.cpp
@@ -0,0 +1,108 @@
+#include <amsmathutil25/amsmathutil25.hpp>
+
+namespace ams
+{
+
+    vec2i::vec2i()
+    {
+        x = 0;
+        y = 0;
+        return;
+    }
+
+    vec2i::vec2i(int _x, int _y)
+    {
+        x = _x; y = _y; return;
+    }
+
+    vec2i::vec2i(const vec2i &rhs)
+    {
+        x = rhs.x;
+        y = rhs.y;
+        return;
+    }
+
+    vec2i& vec2i::operator=(const vec2i &rhs)
+    {
+        x = rhs.x;
+        y = rhs.y;
+        return *this;
+    }
+
+    bool vec2i::operator==(const vec2i rhs) const
+    {
+        return ((this->x == rhs.x) && (this->y == rhs.y));
+    }
+
+    // vec2i arithmetic operators
+    vec2i vec2i::operator+(vec2i rhs) const
+    {
+        vec2i ret;
+        ret.x = this->x + rhs.x;
+        ret.y = this->y + rhs.y;
+        return ret;
+    }
+
+    vec2i vec2i::operator-(vec2i rhs) const
+    {
+        vec2i ret;
+        ret.x = this->x - rhs.x;
+        ret.y = this->y - rhs.y;
+        return ret;
+    }
+
+    vec2i vec2i::operator*(int rhs) const
+    {
+        vec2i ret;
+        ret.x = this->x*rhs;
+        ret.y = this->y*rhs;
+        return ret;
+    }
+
+    vec2i vec2i::operator/(int rhs) const
+    {
+        vec2i ret;
+        ret.x = this->x/rhs;
+        ret.y = this->y/rhs;
+        return ret;
+    }
+
+    vec2i operator-(vec2i rhs)
+    {
+        vec2i ret;
+        ret.x = -rhs.x;
+        ret.y = -rhs.y;
+        return ret;
+    }
+
+    // vec2i subscript operators
+    int& vec2i::operator[](int ind)
+    {
+        if(ind==0) return x;
+        else if(ind==1) return y;
+        return x;
+    }
+
+    const int& vec2i::operator[](int ind) const
+    {
+        if(ind==0) return x;
+        else if(ind==1) return y;
+        return x;
+    }
+
+    // vec2i::vec2i(const vec2f &rhs)
+    // {
+    //     x = (int)rhs.x;
+    //     y = (int)rhs.y;
+    //     return;   
+    // }
+
+    // vec2i::vec2i(const vec2 &rhs)
+    // {
+    //     x = (int)rhs.x;
+    //     y = (int)rhs.y;
+    //     return;   
+    // }
+
+
+};
diff --git a/src/amsmathutil25/math/amsmathutil25_vec3i.cpp b/src/amsmathutil25/math/amsmathutil25_vec3i.cpp
new file mode 100644
index 0000000..8d1dc34
--- /dev/null
+++ b/src/amsmathutil25/math/amsmathutil25_vec3i.cpp
@@ -0,0 +1,122 @@
+#include <amsmathutil25/amsmathutil25.hpp>
+
+namespace ams
+{
+
+    vec3i::vec3i()
+    {
+        x = 0;
+        y = 0;
+        return;
+    }
+
+    vec3i::vec3i(int _x, int _y, int _z)
+    {
+        x = _x; y = _y; z = _z; return;
+    }
+
+    vec3i::vec3i(const vec3i &rhs)
+    {
+        x = rhs.x;
+        y = rhs.y;
+        z = rhs.z;
+
+        return;
+    }
+
+    vec3i& vec3i::operator=(const vec3i &rhs)
+    {
+        x = rhs.x;
+        y = rhs.y;
+        z = rhs.z;
+
+        return *this;
+    }
+
+    bool vec3i::operator==(const vec3i rhs) const
+    {
+        return ((this->x == rhs.x) && (this->y == rhs.y) && (this->z == rhs.z));
+    }
+
+    // vec3i arithmetic operators
+    vec3i vec3i::operator+(vec3i rhs) const
+    {
+        vec3i ret;
+        ret.x = this->x + rhs.x;
+        ret.y = this->y + rhs.y;
+        ret.z = this->z + rhs.z;
+        return ret;
+    }
+
+    vec3i vec3i::operator-(vec3i rhs) const
+    {
+        vec3i ret;
+        ret.x = this->x - rhs.x;
+        ret.y = this->y - rhs.y;
+        ret.z = this->z - rhs.z;
+        return ret;
+    }
+
+    vec3i vec3i::operator*(int rhs) const
+    {
+        vec3i ret;
+        ret.x = this->x*rhs;
+        ret.y = this->y*rhs;
+        ret.z = this->z*rhs;
+        return ret;
+    }
+
+    vec3i vec3i::operator/(int rhs) const
+    {
+        vec3i ret;
+        ret.x = this->x/rhs;
+        ret.y = this->y/rhs;
+        ret.z = this->z/rhs;
+        return ret;
+    }
+
+    vec3i operator-(vec3i rhs)
+    {
+        vec3i ret;
+        ret.x = -rhs.x;
+        ret.y = -rhs.y;
+        ret.z = -rhs.z;
+        return ret;
+    }
+
+    // vec3i subscript operators
+    int& vec3i::operator[](int ind)
+    {
+        if(ind==0) return x;
+        else if(ind==1) return y;
+        else if(ind==2) return z;
+        return x;
+    }
+
+    const int& vec3i::operator[](int ind) const
+    {
+        if(ind==0) return x;
+        else if(ind==1) return y;
+        else if(ind==2) return z;
+        return x;
+    }
+
+
+    // vec3i::vec3i(const vec3f &rhs)
+    // {
+    //     x = (int)rhs.x;
+    //     y = (int)rhs.y;
+    //     z = (int)rhs.z;
+    //     return;   
+    // }
+
+    // vec3i::vec3i(const vec3 &rhs)
+    // {
+    //     x = (int)rhs.x;
+    //     y = (int)rhs.y;
+    //     z = (int)rhs.z;
+    //     return;   
+    // }
+
+
+};
diff --git a/src/amsmathutil25/math/amsmathutil25_vec4f.cpp b/src/amsmathutil25/math/amsmathutil25_vec4f.cpp
index e0a21d5..30d72fa 100644
--- a/src/amsmathutil25/math/amsmathutil25_vec4f.cpp
+++ b/src/amsmathutil25/math/amsmathutil25_vec4f.cpp
@@ -612,4 +612,7 @@ mat4f mat4f_transpose(mat4f a)
     return a.transpose();
 }
 
+
+
+
 };
\ No newline at end of file
diff --git a/src/amsmathutil25/math/amsmathutil25_vec4i.cpp b/src/amsmathutil25/math/amsmathutil25_vec4i.cpp
new file mode 100644
index 0000000..f5ac2a4
--- /dev/null
+++ b/src/amsmathutil25/math/amsmathutil25_vec4i.cpp
@@ -0,0 +1,131 @@
+#include <amsmathutil25/amsmathutil25.hpp>
+
+namespace ams
+{
+
+    vec4i::vec4i()
+    {
+        x = 0;
+        y = 0;
+        return;
+    }
+
+    vec4i::vec4i(int _x, int _y, int _z, int _w)
+    {
+        x = _x; y = _y; z = _z; w = _w; return;
+    }
+
+    vec4i::vec4i(const vec4i &rhs)
+    {
+        x = rhs.x;
+        y = rhs.y;
+        z = rhs.z;
+        w = rhs.w;
+
+        return;
+    }
+
+    vec4i& vec4i::operator=(const vec4i &rhs)
+    {
+        x = rhs.x;
+        y = rhs.y;
+        z = rhs.z;
+        w = rhs.w;
+
+        return *this;
+    }
+
+    bool vec4i::operator==(const vec4i rhs) const
+    {
+        return ((this->x == rhs.x) && (this->y == rhs.y) && (this->z == rhs.z) && (this->w == rhs.w));
+    }
+
+    // vec4i arithmetic operators
+    vec4i vec4i::operator+(vec4i rhs) const
+    {
+        vec4i ret;
+        ret.x = this->x + rhs.x;
+        ret.y = this->y + rhs.y;
+        ret.z = this->z + rhs.z;
+        ret.w = this->w + rhs.w;
+        return ret;
+    }
+
+    vec4i vec4i::operator-(vec4i rhs) const
+    {
+        vec4i ret;
+        ret.x = this->x - rhs.x;
+        ret.y = this->y - rhs.y;
+        ret.z = this->z - rhs.z;
+        ret.w = this->w - rhs.w;
+        return ret;
+    }
+
+    vec4i vec4i::operator*(int rhs) const
+    {
+        vec4i ret;
+        ret.x = this->x*rhs;
+        ret.y = this->y*rhs;
+        ret.z = this->z*rhs;
+        ret.w = this->w*rhs;
+        return ret;
+    }
+
+    vec4i vec4i::operator/(int rhs) const
+    {
+        vec4i ret;
+        ret.x = this->x/rhs;
+        ret.y = this->y/rhs;
+        ret.z = this->z/rhs;
+        ret.w = this->w/rhs;
+        return ret;
+    }
+
+    vec4i operator-(vec4i rhs)
+    {
+        vec4i ret;
+        ret.x = -rhs.x;
+        ret.y = -rhs.y;
+        ret.z = -rhs.z;
+        ret.w = -rhs.w;
+        return ret;
+    }
+
+    // vec4i subscript operators
+    int& vec4i::operator[](int ind)
+    {
+        if(ind==0) return x;
+        else if(ind==1) return y;
+        else if(ind==2) return z;
+        else if(ind==3) return w;
+        return x;
+    }
+
+    const int& vec4i::operator[](int ind) const
+    {
+        if(ind==0) return x;
+        else if(ind==1) return y;
+        else if(ind==2) return z;
+        else if(ind==3) return w;
+        return x;
+    }
+
+    // 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 vec4 &rhs)
+    // {
+    //     x = (int)rhs.x;
+    //     y = (int)rhs.y;
+    //     z = (int)rhs.z;
+    //     w = (int)rhs.w;
+    //     return;   
+    // }
+
+};
diff --git a/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp b/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp
new file mode 100644
index 0000000..2614dd8
--- /dev/null
+++ b/src/amsmathutil25/math/amsmathutil25_vecconversions.cpp
@@ -0,0 +1,512 @@
+#include <amsmathutil25/amsmathutil25.hpp>
+
+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;
+}
+
+
+
+};
\ No newline at end of file