added vector interconversions

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

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

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

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

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

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

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

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

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

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

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

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()
+                    
+