2008-10-29 Rodrigo Kumpera <rkumpera@novell.com>
authorRodrigo Kumpera <kumpera@gmail.com>
Wed, 29 Oct 2008 19:10:12 +0000 (19:10 -0000)
committerRodrigo Kumpera <kumpera@gmail.com>
Wed, 29 Oct 2008 19:10:12 +0000 (19:10 -0000)
* Vector*.cs: Added casting between all types.

svn path=/trunk/mcs/; revision=117410

mcs/class/Mono.Simd/Mono.Simd/Changelog
mcs/class/Mono.Simd/Mono.Simd/Vector16b.cs
mcs/class/Mono.Simd/Mono.Simd/Vector16sb.cs
mcs/class/Mono.Simd/Mono.Simd/Vector2d.cs
mcs/class/Mono.Simd/Mono.Simd/Vector2l.cs
mcs/class/Mono.Simd/Mono.Simd/Vector2ul.cs
mcs/class/Mono.Simd/Mono.Simd/Vector4f.cs
mcs/class/Mono.Simd/Mono.Simd/Vector4i.cs
mcs/class/Mono.Simd/Mono.Simd/Vector4ui.cs
mcs/class/Mono.Simd/Mono.Simd/Vector8s.cs
mcs/class/Mono.Simd/Mono.Simd/Vector8us.cs

index 0abe5f8e3d2abf8b7f9355500f62c995f49defb7..2b1d2ab3c0053dcd7e5e17254b507541d01fa462 100644 (file)
@@ -1,3 +1,7 @@
+2008-10-29  Rodrigo Kumpera  <rkumpera@novell.com>
+
+       * Vector*.cs: Added casting between all types.
+
 2008-10-29  Rodrigo Kumpera  <rkumpera@novell.com>
 
        * Vector4i.cs: Add Acceleration attribute to all methods.
index 1aca6621988b2f98dce06d4100ca7883bc4c9c1c..5f0e077ee5d1bb6c10345b7e7ddd2cb1501d8568 100644 (file)
@@ -237,28 +237,72 @@ namespace Mono.Simd
                }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f(Vector16b v)\r
+               public static unsafe explicit operator Vector2d (Vector16b v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector16b v)\r
                {\r
                        Vector4f* p = (Vector4f*)&v;\r
                        return *p;\r
-               }\r
+               }
 
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector16b v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector2ul (Vector16b v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4i (Vector16b v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4ui(Vector16b v)\r
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector4ui (Vector16b v)\r
                {\r
                        Vector4ui* p = (Vector4ui*)&v;\r
                        return *p;\r
                }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector16b v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
 
-               [CLSCompliant(false)]\r
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us(Vector16b v)\r
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector8us (Vector16b v)\r
                {\r
                        Vector8us* p = (Vector8us*)&v;\r
                        return *p;\r
                }
 
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector16sb (Vector16b v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
                public static Vector16b LoadAligned (ref Vector16b v)\r
                {\r
index 897305870765378c4a738d7348d0e04b3beab59d..3338233ca49aadb5baaf015fd55bbd7f89f86d82 100644 (file)
@@ -218,26 +218,68 @@ namespace Mono.Simd
                }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f(Vector16sb v)\r
+               public static unsafe explicit operator Vector2d (Vector16sb v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector16sb v)\r
                {\r
                        Vector4f* p = (Vector4f*)&v;\r
                        return *p;\r
-               }\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector16sb v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2ul (Vector16sb v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4ui(Vector16sb v)\r
+               public static unsafe explicit operator Vector4i (Vector16sb v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4ui (Vector16sb v)\r
                {\r
                        Vector4ui* p = (Vector4ui*)&v;\r
                        return *p;\r
                }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector16sb v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us(Vector16sb v)\r
+               public static unsafe explicit operator Vector8us (Vector16sb v)\r
                {\r
                        Vector8us* p = (Vector8us*)&v;\r
                        return *p;\r
                }
 
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16b (Vector16sb v)\r
+               {\r
+                       Vector16b* p = (Vector16b*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
                public static Vector16sb LoadAligned (ref Vector16sb v)\r
                {\r
index 76f2229708f7834e41d3e597cb7fa297b685c1e6..94636fab74e559618c41fa9a26b62dc3ee88df8e 100644 (file)
@@ -264,29 +264,73 @@ namespace Mono.Simd
                        return new Vector2d (v1.x, v1.x);
                }
 
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector2d v)\r
+               {\r
+                       Vector4f* p = (Vector4f*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector2d v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector2ul (Vector2d v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4i (Vector2d v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4ui(Vector2d v)\r
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector4ui (Vector2d v)\r
                {\r
                        Vector4ui* p = (Vector4ui*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector2d v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
 
-               [CLSCompliant(false)]\r
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us(Vector2d v)\r
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector8us (Vector2d v)\r
                {\r
                        Vector8us* p = (Vector8us*)&v;\r
                        return *p;\r
-               }\r
+               }
 
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector16sb (Vector2d v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b(Vector2d v)\r
+               public static unsafe explicit operator Vector16b (Vector2d v)\r
                {\r
                        Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
 
                [Acceleration (AccelMode.SSE1)]
                public static Vector2d LoadAligned (ref Vector2d v)\r
index 42dc831d45c683fdbae290dc22cbac499aa45845..d4dff9bf19ed259bb0db0b543bb50c3610031c1f 100644 (file)
@@ -119,26 +119,70 @@ namespace Mono.Simd
                        return new Vector2l ((long)(v1.x > v2.x ? -1 : 0), (long)(v1.y >  v2.y ? -1 : 0));
                }
 
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f (Vector2l v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2d (Vector2l v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector2l v)\r
+               {\r
+                       Vector4f* p = (Vector4f*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector2ul (Vector2l v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4i (Vector2l v)\r
                {\r
-                       Vector4f* p = (Vector4f*)&v1;\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector4ui (Vector2l v)\r
+               {\r
+                       Vector4ui* p = (Vector4ui*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector2l v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
                        return *p;\r
                }
 
-               [CLSCompliant(false)]\r
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us (Vector2l v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector8us (Vector2l v)\r
                {\r
-                       Vector8us* p = (Vector8us*)&v1;\r
+                       Vector8us* p = (Vector8us*)&v;\r
                        return *p;\r
                }
 
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b (Vector2l v1)\r
+               public static unsafe explicit operator Vector16sb (Vector2l v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16b (Vector2l v)\r
                {\r
-                       Vector16b* p = (Vector16b*)&v1;\r
+                       Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
                }
 
index 714d2c8eb83407c4cac03ad097e1f85e9a5a1df3..8a1e6077340c64ff900e0093b3ebb1e89e09b53e 100644 (file)
@@ -114,24 +114,66 @@ namespace Mono.Simd
                        return new Vector2ul ((ulong)(v1.x ==  v2.x ? -1 : 0), (ulong)(v1.y ==  v2.y ? -1 : 0));
                }
 
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f (Vector2ul v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2d (Vector2ul v)\r
                {\r
-                       Vector4f* p = (Vector4f*)&v1;\r
+                       Vector2d* p = (Vector2d*)&v;\r
                        return *p;\r
                }
 
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us (Vector2ul v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector2ul v)\r
                {\r
-                       Vector8us* p = (Vector8us*)&v1;\r
+                       Vector4f* p = (Vector4f*)&v;\r
                        return *p;\r
                }
 
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b (Vector2ul v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector2ul v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4i (Vector2ul v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4ui (Vector2ul v)\r
+               {\r
+                       Vector4ui* p = (Vector4ui*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector2ul v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8us (Vector2ul v)\r
+               {\r
+                       Vector8us* p = (Vector8us*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16sb (Vector2ul v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16b (Vector2ul v)\r
                {\r
-                       Vector16b* p = (Vector16b*)&v1;\r
+                       Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
                }
 
index 4d38c40bc8e2ef98d6056421545329ee51f0a5c4..0209d5d973deb567f2ece25d82438e8f33cfec25 100644 (file)
@@ -382,29 +382,72 @@ namespace Mono.Simd
                        return new Vector4f (*(ptr + ((idx >> 0) & 0x3)),*(ptr + ((idx >> 2) & 0x3)),*(ptr + ((idx >> 4) & 0x3)),*(ptr + ((idx >> 6) & 0x3)));\r
                }\r
 
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2d (Vector4f v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector4f v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector2ul (Vector4f v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4ui(Vector4f v)\r
+               public static unsafe explicit operator Vector4i (Vector4f v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector4ui (Vector4f v)\r
                {\r
                        Vector4ui* p = (Vector4ui*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector4f v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
 
-               [CLSCompliant(false)]\r
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us(Vector4f v)\r
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector8us (Vector4f v)\r
                {\r
                        Vector8us* p = (Vector8us*)&v;\r
                        return *p;\r
-               }\r
+               }
 
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector16sb (Vector4f v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b(Vector4f v)\r
+               public static unsafe explicit operator Vector16b (Vector4f v)\r
                {\r
                        Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
-               }\r
+               }
 
                [Acceleration (AccelMode.SSE1)]
                public static Vector4f LoadAligned (ref Vector4f v)\r
index 8bf7424f06a9327215014620284fe3ff8e39119a..f1ea949a3aa5786e9a1defc777df4f5e3d17d6ad 100644 (file)
@@ -189,29 +189,74 @@ namespace Mono.Simd
                        return res;
                }
 
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f (Vector4i v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2d (Vector4i v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector4i v)\r
+               {\r
+                       Vector4f* p = (Vector4f*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector4i v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector2ul (Vector4i v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector4ui (Vector4i v)\r
+               {\r
+                       Vector4ui* p = (Vector4ui*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector4i v)\r
                {\r
-                       Vector4f* p = (Vector4f*)&v1;\r
+                       Vector8s* p = (Vector8s*)&v;\r
                        return *p;\r
                }
 
-               [CLSCompliant(false)]\r
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us (Vector4i v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector8us (Vector4i v)\r
                {\r
-                       Vector8us* p = (Vector8us*)&v1;\r
+                       Vector8us* p = (Vector8us*)&v;\r
                        return *p;\r
                }
 
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector16sb (Vector4i v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b (Vector4i v1)\r
+               public static unsafe explicit operator Vector16b (Vector4i v)\r
                {\r
-                       Vector16b* p = (Vector16b*)&v1;\r
+                       Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
                }
 
+
                [Acceleration (AccelMode.SSE1)]
                public static Vector4i LoadAligned (ref Vector4i v)\r
                {\r
index 1c6c6c5ccbe98d88955076f99653c6b892d92f2f..ea8920aa4a42117f082ee453903818d3d22ded00 100644 (file)
@@ -186,23 +186,65 @@ namespace Mono.Simd
                }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f (Vector4ui v1)\r
+               public static unsafe explicit operator Vector2d (Vector4ui v)\r
                {\r
-                       Vector4f* p = (Vector4f*)&v1;\r
+                       Vector2d* p = (Vector2d*)&v;\r
                        return *p;\r
                }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector8us (Vector4ui v1)\r
+               public static unsafe explicit operator Vector4f (Vector4ui v)\r
                {\r
-                       Vector8us* p = (Vector8us*)&v1;\r
+                       Vector4f* p = (Vector4f*)&v;\r
                        return *p;\r
                }
 
-               [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b (Vector4ui v1)\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector4ui v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2ul (Vector4ui v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4i (Vector4ui v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector4ui v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8us (Vector4ui v)\r
+               {\r
+                       Vector8us* p = (Vector8us*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16sb (Vector4ui v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16b (Vector4ui v)\r
                {\r
-                       Vector16b* p = (Vector16b*)&v1;\r
+                       Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
                }
 
index 1acda53b40b9d82295a937f87fd588ebb3efff90..0f664ab2af0517c9748db27f7b28c10868aa4259 100644 (file)
@@ -301,27 +301,72 @@ namespace Mono.Simd
                }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f(Vector8s v)\r
+               public static unsafe explicit operator Vector2d (Vector8s v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector8s v)\r
                {\r
                        Vector4f* p = (Vector4f*)&v;\r
                        return *p;\r
-               }\r
+               }
 
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2l (Vector8s v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector2ul (Vector8s v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4ui(Vector8s v)\r
+               public static unsafe explicit operator Vector4i (Vector8s v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector4ui (Vector8s v)\r
                {\r
                        Vector4ui* p = (Vector4ui*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector8us (Vector8s v)\r
+               {\r
+                       Vector8us* p = (Vector8us*)&v;\r
+                       return *p;\r
+               }
 
+               [Acceleration (AccelMode.SSE1)]
                [CLSCompliant(false)]\r
+               public static unsafe explicit operator Vector16sb (Vector8s v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b(Vector8s v)\r
+               public static unsafe explicit operator Vector16b (Vector8s v)\r
                {\r
                        Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
 
                [Acceleration (AccelMode.SSE1)]
                public static Vector8s LoadAligned (ref Vector8s v)\r
index 062efd0ba55d801a97c8d35ddf2cfbce36738d10..1c7b14fca936b7154a00ed99f608780d2769148e 100644 (file)
@@ -307,25 +307,68 @@ namespace Mono.Simd
                }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4f(Vector8us v)\r
+               public static unsafe explicit operator Vector2d (Vector8us v)\r
+               {\r
+                       Vector2d* p = (Vector2d*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4f (Vector8us v)\r
                {\r
                        Vector4f* p = (Vector4f*)&v;\r
                        return *p;\r
-               }\r
+               }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector4ui(Vector8us v)\r
+               public static unsafe explicit operator Vector2l (Vector8us v)\r
+               {\r
+                       Vector2l* p = (Vector2l*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector2ul (Vector8us v)\r
+               {\r
+                       Vector2ul* p = (Vector2ul*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4i (Vector8us v)\r
+               {\r
+                       Vector4i* p = (Vector4i*)&v;\r
+                       return *p;\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector4ui (Vector8us v)\r
                {\r
                        Vector4ui* p = (Vector4ui*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector8s (Vector8us v)\r
+               {\r
+                       Vector8s* p = (Vector8s*)&v;\r
+                       return *p;\r
+               }
 
                [Acceleration (AccelMode.SSE1)]
-               public static unsafe explicit operator Vector16b(Vector8us v)\r
+               public static unsafe explicit operator Vector16sb (Vector8us v)\r
+               {\r
+                       Vector16sb* p = (Vector16sb*)&v;\r
+                       return *p;\r
+               }
+
+               [Acceleration (AccelMode.SSE1)]
+               public static unsafe explicit operator Vector16b (Vector8us v)\r
                {\r
                        Vector16b* p = (Vector16b*)&v;\r
                        return *p;\r
-               }\r
+               }
+\r
 
                [Acceleration (AccelMode.SSE1)]
                public static Vector8us LoadAligned (ref Vector8us v)\r