refactor to easily allow algorithms generic over f16/32/64

[vector-math.git] / src / ir.rs

diff --git a/src/ir.rs b/src/ir.rs
index e2b4a0ecd72cb58421cf07b060a023e3ef640020..279902041a39bfcdee4f2385cd550f8891d16374 100644 (file)
--- a/src/ir.rs
+++ b/src/ir.rs
@@ -1220,40 +1220,41 @@ macro_rules! impl_integer_ops {
     };
 }
 
-macro_rules! impl_uint_ops {
-    ($scalar:ident, $vec:ident) => {
-        impl_integer_ops!($scalar, $vec);
-
-        impl<'ctx> UInt for $scalar<'ctx> {}
-        impl<'ctx> UInt for $vec<'ctx> {}
-    };
-}
+macro_rules! impl_uint_sint_ops {
+    ($uint_scalar:ident, $uint_vec:ident, $sint_scalar:ident, $sint_vec:ident) => {
+        impl_integer_ops!($uint_scalar, $uint_vec);
+        impl_integer_ops!($sint_scalar, $sint_vec);
+        impl_neg!($sint_scalar);
+        impl_neg!($sint_vec);
 
-impl_uint_ops!(IrU8, IrVecU8);
-impl_uint_ops!(IrU16, IrVecU16);
-impl_uint_ops!(IrU32, IrVecU32);
-impl_uint_ops!(IrU64, IrVecU64);
-
-macro_rules! impl_sint_ops {
-    ($scalar:ident, $vec:ident) => {
-        impl_integer_ops!($scalar, $vec);
-        impl_neg!($scalar);
-        impl_neg!($vec);
-
-        impl<'ctx> SInt for $scalar<'ctx> {}
-        impl<'ctx> SInt for $vec<'ctx> {}
+        impl<'ctx> UInt for $uint_scalar<'ctx> {
+            type PrimUInt = Self::Prim;
+            type SignedType = $sint_scalar<'ctx>;
+        }
+        impl<'ctx> UInt for $uint_vec<'ctx> {
+            type PrimUInt = Self::Prim;
+            type SignedType = $sint_vec<'ctx>;
+        }
+        impl<'ctx> SInt for $sint_scalar<'ctx> {
+            type PrimSInt = Self::Prim;
+            type UnsignedType = $uint_scalar<'ctx>;
+        }
+        impl<'ctx> SInt for $sint_vec<'ctx> {
+            type PrimSInt = Self::Prim;
+            type UnsignedType = $uint_vec<'ctx>;
+        }
     };
 }
 
-impl_sint_ops!(IrI8, IrVecI8);
-impl_sint_ops!(IrI16, IrVecI16);
-impl_sint_ops!(IrI32, IrVecI32);
-impl_sint_ops!(IrI64, IrVecI64);
+impl_uint_sint_ops!(IrU8, IrVecU8, IrI8, IrVecI8);
+impl_uint_sint_ops!(IrU16, IrVecU16, IrI16, IrVecI16);
+impl_uint_sint_ops!(IrU32, IrVecU32, IrI32, IrVecI32);
+impl_uint_sint_ops!(IrU64, IrVecU64, IrI64, IrVecI64);
 
 macro_rules! impl_float {
     ($float:ident, $bits:ident, $signed_bits:ident) => {
         impl<'ctx> Float for $float<'ctx> {
-            type FloatEncoding = <$float<'ctx> as Make>::Prim;
+            type PrimFloat = <$float<'ctx> as Make>::Prim;
             type BitsType = $bits<'ctx>;
             type SignedBitsType = $signed_bits<'ctx>;
             fn abs(self) -> Self {