no transpose trait

deferred_division/Cargo.lock

@@ -2,13 +2,35 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "bnum"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e31ea183f6ee62ac8b8a8cf7feddd766317adfb13ff469de57ce033efd6a790"
+
 [[package]]
 name = "deferred_division"
 version = "0.1.0"
 dependencies = [
+ "fixed_wide",
  "fixed_wide_traits",
 ]
 
+[[package]]
+name = "fixed_wide"
+version = "0.1.0"
+dependencies = [
+ "bnum",
+ "fixed_wide_traits",
+ "typenum",
+]
+
 [[package]]
 name = "fixed_wide_traits"
 version = "0.1.0"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

deferred_division/Cargo.toml

@@ -9,3 +9,6 @@ fixed_wide_traits=["dep:fixed_wide_traits"]
 
 [dependencies]
 fixed_wide_traits = { version = "0.1.0", path = "../fixed_wide_traits", optional = true }
+
+[dev-dependencies]
+fixed_wide = { version = "0.1.0", path = "../fixed_wide" }

deferred_division/src/ratio.rs

@@ -1,3 +1,5 @@
+use std::ops::Mul;
+
 #[derive(Clone,Copy,Debug,Hash)]
 pub struct Ratio<Num,Den>{
 	pub(crate)num:Num,
@@ -8,3 +10,148 @@ impl<Num,Den> Ratio<Num,Den>{
 		Self{num,den}
 	}
 }
+
+impl<Num,Den,Rhs> PartialEq<Rhs> for Ratio<Num,Den>
+	where
+		Den:Copy,
+		Rhs:Mul<Den>+Copy,
+		Num:PartialEq<<Rhs as Mul<Den>>::Output>
+{
+	fn eq(&self,rhs:&Rhs)->bool{
+		self.num.eq(&rhs.mul(self.den))
+	}
+}
+/*
+//You can't do Ratio==Ratio I guess
+impl<Num,Den> Eq for Ratio<Num,Den>
+where
+		Num:Mul<Den>,
+		<Num as Mul<Den>>::Output:PartialEq
+{}
+*/
+
+// num/den == rhs
+// num == rhs * den
+
+impl<Num,Den,Rhs> PartialOrd<Rhs> for Ratio<Num,Den>
+	where
+		Den:Copy,
+		Rhs:Mul<Den>+Copy,
+		Num:PartialOrd<<Rhs as Mul<Den>>::Output>
+{
+	fn partial_cmp(&self,rhs:&Rhs)->Option<std::cmp::Ordering>{
+		self.num.partial_cmp(&rhs.mul(self.den))
+	}
+}
+/*
+impl<Den,Rhs> Ord for Ratio<<Rhs as Mul<Den>>::Output,Den>
+where
+		Rhs:Mul<Den>,
+		Rhs:Ord,
+		<Rhs as Mul<Den>>::Output:Ord,
+{
+	fn cmp(&self,other:&Rhs)->std::cmp::Ordering{
+		self.num.cmp(&other.mul(self.den))
+	}
+}
+*/
+
+impl<NewNum,Num:std::ops::Neg<Output=NewNum>,Den> std::ops::Neg for Ratio<Num,Den>{
+	type Output=Ratio<NewNum,Den>;
+	fn neg(self)->Self::Output{
+		Ratio{
+			num:self.num.neg(),
+			den:self.den,
+		}
+	}
+}
+
+// num/den + rhs == new_num/den
+// new_num = num + rhs * den
+
+macro_rules! impl_operator {
+	($struct:ident,$trait:ident,$method:ident)=>{
+		impl<Num,Den,Rhs> core::ops::$trait<Rhs> for $struct<Num,Den>
+			where
+				Den:Copy,
+				Rhs:Mul<Den>,
+				Num:core::ops::$trait<<Rhs as Mul<Den>>::Output>,
+		{
+			type Output=$struct<<Num as core::ops::$trait<<Rhs as Mul<Den>>::Output>>::Output,Den>;
+
+			fn $method(self,rhs:Rhs)->Self::Output{
+				$struct{
+					num:self.num.$method(rhs.mul(self.den)),
+					den:self.den,
+				}
+			}
+		}
+	};
+}
+macro_rules! impl_assign_operator{
+	($struct:ident,$trait:ident,$method:ident)=>{
+		impl<Num,Den,Rhs> core::ops::$trait<Rhs> for $struct<Num,Den>
+			where
+				Den:Copy,
+				Rhs:Mul<Den>,
+				Num:core::ops::$trait<<Rhs as Mul<Den>>::Output>,
+		{
+			fn $method(&mut self,rhs:Rhs){
+				self.num.$method(rhs.mul(self.den));
+			}
+		}
+	};
+}
+
+// Impl arithmetic operators
+impl_assign_operator!(Ratio,AddAssign,add_assign);
+impl_operator!(Ratio,Add,add);
+impl_assign_operator!(Ratio,SubAssign,sub_assign);
+impl_operator!(Ratio,Sub,sub);
+// num/den % rhs == new_num/den
+// new_num = num % (rhs * den)
+impl_assign_operator!(Ratio,RemAssign,rem_assign);
+impl_operator!(Ratio,Rem,rem);
+
+//mul and div is special
+impl<Num,Den,Rhs> Mul<Rhs> for Ratio<Num,Den>
+	where
+		Num:Mul<Rhs>,
+{
+	type Output=Ratio<<Num as Mul<Rhs>>::Output,Den>;
+	fn mul(self,rhs:Rhs)->Self::Output{
+		Ratio{
+			num:self.num.mul(rhs),
+			den:self.den,
+		}
+	}
+}
+impl<Num,Den,Rhs> core::ops::MulAssign<Rhs> for Ratio<Num,Den>
+	where
+		Num:core::ops::MulAssign<Rhs>,
+{
+	fn mul_assign(&mut self,rhs:Rhs){
+		self.num.mul_assign(rhs);
+	}
+}
+
+impl<Num,Den,Rhs> core::ops::Div<Rhs> for Ratio<Num,Den>
+	where
+		Den:Mul<Rhs>,
+{
+	type Output=Ratio<Num,<Den as Mul<Rhs>>::Output>;
+	fn div(self,rhs:Rhs)->Self::Output{
+		Ratio{
+			num:self.num,
+			den:self.den.mul(rhs),
+		}
+	}
+}
+impl<Num,Den,Rhs> core::ops::DivAssign<Rhs> for Ratio<Num,Den>
+	where
+		Den:core::ops::MulAssign<Rhs>,
+{
+	fn div_assign(&mut self,rhs:Rhs){
+		self.den.mul_assign(rhs);
+	}
+}

deferred_division/src/tests/mod.rs

@@ -0,0 +1,4 @@
+mod tests;
+
+#[cfg(feature="fixed_wide_traits")]
+mod wide;

deferred_division/src/tests/tests.rs

@@ -0,0 +1,22 @@
+use crate::ratio::Ratio;
+
+#[test]
+fn ratio(){
+	let r=Ratio::new(5,3);
+	let a=r%1;
+	assert_eq!(a.num,2);
+	assert_eq!(a.den,3);
+	let b=r*2;
+	assert_eq!(b.num,10);
+	assert_eq!(b.den,3);
+	let c=r/2;
+	assert_eq!(c.num,5);
+	assert_eq!(c.den,6);
+}
+
+#[test]
+fn add_ratio_cmp(){
+	let a=Ratio::new(5,3);
+	let b=Ratio::new(1,3);
+	assert_eq!(a+b,2);
+}

deferred_division/src/tests/wide.rs

@@ -0,0 +1,15 @@
+use crate::ratio::Ratio;
+use fixed_wide_traits::wide::{WideMul,WideDiv};
+use fixed_wide::types::I32F32;
+use fixed_wide::types::I64F64;
+
+#[test]
+fn ratio(){
+	let r=Ratio::new(I32F32::from(5),I32F32::from(3));
+	let a=r.wide_mul(I32F32::from(7)>>2);
+	assert_eq!(a.num,I64F64::from(7*5)>>2);
+	assert_eq!(a.den,I32F32::from(3));
+	let a=r.wide_div(I32F32::from(7)>>2);
+	assert_eq!(a.num,I32F32::from(5));
+	assert_eq!(a.den,I64F64::from(3*7)>>2);
+}

deferred_division/src/wide.rs

@@ -1,6 +1,6 @@
 use std::ops::{Add,Mul};
 use crate::ratio::Ratio;
-use fixed_wide_traits::wide::{WideMul,WideDiv};
+use fixed_wide_traits::wide::{WideMul,WideDiv,WideDot,WideCross};
 
 impl<Num,Den:Copy> Ratio<Num,Den>
 {
@@ -25,18 +25,25 @@ impl<Num,Den:Copy> Ratio<Num,Den>
 		}
 	}
 }
-impl<Num,Den,T> WideMul<T> for Ratio<Num,Den>
-	where
-		Num:WideMul<T>,
-{
-	type Output=Ratio<<Num as WideMul<T>>::Output,Den>;
-	fn wide_mul(self,rhs:T)->Ratio<<Num as WideMul<T>>::Output,Den>{
-		Ratio{
-			num:self.num.wide_mul(rhs),
-			den:self.den,
+macro_rules! impl_mul_operator {
+	($struct:ident,$trait:ident,$method:ident)=>{
+		impl<Num,Den,Rhs> $trait<Rhs> for $struct<Num,Den>
+			where
+				Num:$trait<Rhs>,
+		{
+			type Output=$struct<<Num as $trait<Rhs>>::Output,Den>;
+			fn $method(self,rhs:Rhs)->Self::Output{
+				$struct{
+					num:self.num.$method(rhs),
+					den:self.den,
+				}
+			}
 		}
 	}
 }
+impl_mul_operator!(Ratio,WideMul,wide_mul);
+impl_mul_operator!(Ratio,WideDot,wide_dot);
+impl_mul_operator!(Ratio,WideCross,wide_cross);
 impl<Num,Den,T> WideDiv<T> for Ratio<Num,Den>
 	where
 		Den:WideMul<T>,

fixed_wide/src/fixed.rs

@@ -1,19 +1,41 @@
-use bnum::BInt;
+use bnum::{BInt,cast::As};
 use typenum::Unsigned;
-use std::marker::PhantomData;
 
 #[derive(Clone,Copy,Debug,Hash)]
 pub struct Fixed<const CHUNKS:usize,Frac>{
 	pub(crate)bits:BInt<{CHUNKS}>,
-	pub(crate)frac:PhantomData<Frac>,
+	pub(crate)frac:std::marker::PhantomData<Frac>,
 }
 
 impl<const CHUNKS:usize,Frac:Unsigned> Fixed<CHUNKS,Frac>{
-	pub const ZERO:Self=Self{bits:BInt::<CHUNKS>::ZERO,frac:PhantomData};
-	pub const ONE:Self=Self{bits:BInt::<CHUNKS>::ONE.shl(Frac::U32),frac:PhantomData};
-	pub const NEG_ONE:Self=Self{bits:BInt::<CHUNKS>::NEG_ONE.shl(Frac::U32),frac:PhantomData};
-	pub const MAX:Self=Self{bits:BInt::<CHUNKS>::MAX,frac:PhantomData};
-	pub const MIN:Self=Self{bits:BInt::<CHUNKS>::MIN,frac:PhantomData};
+	pub const MAX:Self=Self::from_bits(BInt::<CHUNKS>::MAX);
+	pub const MIN:Self=Self::from_bits(BInt::<CHUNKS>::MIN);
+	pub const ZERO:Self=Self::from_bits(BInt::<CHUNKS>::ZERO);
+	pub const EPSILON:Self=Self::from_bits(BInt::<CHUNKS>::ONE);
+	pub const NEG_EPSILON:Self=Self::from_bits(BInt::<CHUNKS>::NEG_ONE);
+	pub const ONE:Self=Self::from_bits(BInt::<CHUNKS>::ONE.shl(Frac::U32));
+	pub const TWO:Self=Self::from_bits(BInt::<CHUNKS>::TWO.shl(Frac::U32));
+	pub const HALF:Self=Self::from_bits(BInt::<CHUNKS>::ONE.shl(Frac::U32-1));
+	pub const NEG_ONE:Self=Self::from_bits(BInt::<CHUNKS>::NEG_ONE.shl(Frac::U32));
+	pub const NEG_TWO:Self=Self::from_bits(BInt::<CHUNKS>::NEG_TWO.shl(Frac::U32));
+	pub const NEG_HALF:Self=Self::from_bits(BInt::<CHUNKS>::NEG_ONE.shl(Frac::U32-1));
+}
+impl<const CHUNKS:usize,Frac> Fixed<CHUNKS,Frac>{
+	#[inline]
+	pub const fn from_bits(bits:BInt::<CHUNKS>)->Self{
+		Self{
+			bits,
+			frac:std::marker::PhantomData,
+		}
+	}
+	#[inline]
+	pub const fn to_bits(self)->BInt<CHUNKS>{
+		self.bits
+	}
+	#[inline]
+	pub const fn raw(value:i64)->Self{
+		Self::from_bits(BInt::from_bits(bnum::BUint::from_digit(value as u64)))
+	}
 }
 
 impl<const CHUNKS:usize,Frac:Unsigned,T> From<T> for Fixed<CHUNKS,Frac>
@@ -21,10 +43,7 @@ impl<const CHUNKS:usize,Frac:Unsigned,T> From<T> for Fixed<CHUNKS,Frac>
 		BInt<CHUNKS>:From<T>
 {
 	fn from(value:T)->Self{
-		Self{
-			bits:BInt::<{CHUNKS}>::from(value)<<Frac::U32,
-			frac:PhantomData,
-		}
+		Self::from_bits(BInt::<{CHUNKS}>::from(value)<<Frac::U32)
 	}
 }
 
@@ -49,100 +68,210 @@ impl<const CHUNKS:usize,Frac> Ord for Fixed<CHUNKS,Frac>{
 impl<const CHUNKS:usize,Frac> std::ops::Neg for Fixed<CHUNKS,Frac>{
 	type Output=Self;
 	fn neg(self)->Self{
-		Self{
-			bits:self.bits.neg(),
-			frac:PhantomData,
-		}
+		Self::from_bits(self.bits.neg())
 	}
 }
 
-macro_rules! impl_operator {
+macro_rules! impl_additive_operator {
 	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
-        impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
-            type Output = $output;
+		impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
+			type Output = $output;
 
-            fn $method(self, other: Self) -> Self::Output {
-            	Self {
-                    bits:self.bits.$method(other.bits),
-                    frac:PhantomData,
-                }
-            }
-        }
-        impl<const CHUNKS:usize,Frac:Unsigned,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
-        	where
-        		BInt::<CHUNKS>:From<U>,
-        {
-            type Output = $output;
+			fn $method(self, other: Self) -> Self::Output {
+				Self::from_bits(self.bits.$method(other.bits))
+			}
+		}
+		impl<const CHUNKS:usize,Frac:Unsigned,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
+			where
+				BInt::<CHUNKS>:From<U>,
+		{
+			type Output = $output;
 
-            fn $method(self, other: U) -> Self::Output {
-               	Self {
-                    bits:self.bits.$method(BInt::<CHUNKS>::from(other)<<Frac::U32),
-                    frac:PhantomData,
-                }
-            }
-        }
-    };
+			fn $method(self, other: U) -> Self::Output {
+				Self::from_bits(self.bits.$method(BInt::<CHUNKS>::from(other)<<Frac::U32))
+			}
+		}
+	};
 }
-macro_rules! impl_assign_operator {
-    ( $struct: ident, $trait: ident, $method: ident ) => {
-        impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
-            fn $method(&mut self, other: Self) {
-                self.bits.$method(other.bits);
-            }
-        }
-        impl<const CHUNKS:usize,Frac:Unsigned,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
-       	where
-        		BInt::<CHUNKS>:From<U>,
-        {
-            fn $method(&mut self, other: U) {
-                self.bits.$method(BInt::<CHUNKS>::from(other)<<Frac::U32);
-            }
-        }
-    };
+macro_rules! impl_additive_assign_operator {
+	( $struct: ident, $trait: ident, $method: ident ) => {
+		impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
+			fn $method(&mut self, other: Self) {
+				self.bits.$method(other.bits);
+			}
+		}
+		impl<const CHUNKS:usize,Frac:Unsigned,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
+		where
+				BInt::<CHUNKS>:From<U>,
+		{
+			fn $method(&mut self, other: U) {
+				self.bits.$method(BInt::<CHUNKS>::from(other)<<Frac::U32);
+			}
+		}
+	};
 }
 
 // Impl arithmetic pperators
-impl_assign_operator!( Fixed, AddAssign, add_assign );
-impl_operator!( Fixed, Add, add, Self );
-impl_assign_operator!( Fixed, SubAssign, sub_assign );
-impl_operator!( Fixed, Sub, sub, Self );
-impl_assign_operator!( Fixed, MulAssign, mul_assign );
-impl_operator!( Fixed, Mul, mul, Self );
-impl_assign_operator!( Fixed, DivAssign, div_assign );
-impl_operator!( Fixed, Div, div, Self );
-impl_assign_operator!( Fixed, RemAssign, rem_assign );
-impl_operator!( Fixed, Rem, rem, Self );
+impl_additive_assign_operator!( Fixed, AddAssign, add_assign );
+impl_additive_operator!( Fixed, Add, add, Self );
+impl_additive_assign_operator!( Fixed, SubAssign, sub_assign );
+impl_additive_operator!( Fixed, Sub, sub, Self );
+impl_additive_assign_operator!( Fixed, RemAssign, rem_assign );
+impl_additive_operator!( Fixed, Rem, rem, Self );
 
 // Impl bitwise operators
-impl_assign_operator!( Fixed, BitAndAssign, bitand_assign );
-impl_operator!( Fixed, BitAnd, bitand, Self );
-impl_assign_operator!( Fixed, BitOrAssign, bitor_assign );
-impl_operator!( Fixed, BitOr, bitor, Self );
-impl_assign_operator!( Fixed, BitXorAssign, bitxor_assign );
-impl_operator!( Fixed, BitXor, bitxor, Self );
+impl_additive_assign_operator!( Fixed, BitAndAssign, bitand_assign );
+impl_additive_operator!( Fixed, BitAnd, bitand, Self );
+impl_additive_assign_operator!( Fixed, BitOrAssign, bitor_assign );
+impl_additive_operator!( Fixed, BitOr, bitor, Self );
+impl_additive_assign_operator!( Fixed, BitXorAssign, bitxor_assign );
+impl_additive_operator!( Fixed, BitXor, bitxor, Self );
+
+macro_rules! impl_multiply_operator_const {
+	( $width:expr, $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
+		impl<Frac:Unsigned> core::ops::$trait for $struct<$width,Frac>{
+			type Output = $output;
+
+			fn $method(self, other: Self) -> Self::Output {
+				//this can be done better but that is a job for later
+				let lhs=self.bits.as_::<BInt::<{$width*2}>>();
+				let rhs=other.bits.as_::<BInt::<{$width*2}>>();
+				Self::from_bits(lhs.mul(rhs).shr(Frac::U32).as_())
+			}
+		}
+	};
+}
+macro_rules! impl_multiply_assign_operator_const {
+	( $width:expr, $struct: ident, $trait: ident, $method: ident ) => {
+		impl<Frac> core::ops::$trait for $struct<$width,Frac>{
+			fn $method(&mut self, other: Self) {
+				self.bits.$method(other.bits);
+			}
+		}
+	};
+}
+
+macro_rules! impl_divide_operator_const {
+	( $width:expr, $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
+		impl<Frac:Unsigned> core::ops::$trait for $struct<$width,Frac>{
+			type Output = $output;
+
+			fn $method(self, other: Self) -> Self::Output {
+				//this can be done better but that is a job for later
+				//this only needs to be $width+Frac::U32/64+1 but MUH CONST GENERICS!!!!!
+				let lhs=self.bits.as_::<BInt::<{$width*2}>>().shl(Frac::U32);
+				let rhs=other.bits.as_::<BInt::<{$width*2}>>();
+				Self::from_bits(lhs.div(rhs).as_())
+			}
+		}
+	};
+}
+macro_rules! impl_divide_assign_operator_const {
+	( $width:expr, $struct: ident, $trait: ident, $method: ident ) => {
+		impl<Frac> core::ops::$trait for $struct<$width,Frac>{
+			fn $method(&mut self, other: Self) {
+				self.bits.$method(other.bits);
+			}
+		}
+	};
+}
+
+macro_rules! impl_multiplicatave_operator {
+	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
+		impl<const CHUNKS:usize,Frac,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
+			where
+				BInt::<CHUNKS>:From<U>+core::ops::$trait,
+		{
+			type Output = $output;
+
+			fn $method(self, other: U) -> Self::Output {
+				Self::from_bits(self.bits.$method(BInt::<CHUNKS>::from(other)))
+			}
+		}
+	};
+}
+macro_rules! impl_multiplicatave_assign_operator {
+	( $struct: ident, $trait: ident, $method: ident ) => {
+		impl<const CHUNKS:usize,Frac,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
+			where
+				BInt::<CHUNKS>:From<U>+core::ops::$trait,
+		{
+			fn $method(&mut self, other: U) {
+				self.bits.$method(BInt::<CHUNKS>::from(other));
+			}
+		}
+	};
+}
+
+macro_rules! impl_operator_16 {
+	( $macro: ident, $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
+		$macro!(1,$struct,$trait,$method,$output);
+		$macro!(2,$struct,$trait,$method,$output);
+		$macro!(3,$struct,$trait,$method,$output);
+		$macro!(4,$struct,$trait,$method,$output);
+		$macro!(5,$struct,$trait,$method,$output);
+		$macro!(6,$struct,$trait,$method,$output);
+		$macro!(7,$struct,$trait,$method,$output);
+		$macro!(8,$struct,$trait,$method,$output);
+		$macro!(9,$struct,$trait,$method,$output);
+		$macro!(10,$struct,$trait,$method,$output);
+		$macro!(11,$struct,$trait,$method,$output);
+		$macro!(12,$struct,$trait,$method,$output);
+		$macro!(13,$struct,$trait,$method,$output);
+		$macro!(14,$struct,$trait,$method,$output);
+		$macro!(15,$struct,$trait,$method,$output);
+		$macro!(16,$struct,$trait,$method,$output);
+	}
+}
+macro_rules! impl_assign_operator_16 {
+	( $macro: ident, $struct: ident, $trait: ident, $method: ident ) => {
+		$macro!(1,$struct,$trait,$method);
+		$macro!(2,$struct,$trait,$method);
+		$macro!(3,$struct,$trait,$method);
+		$macro!(4,$struct,$trait,$method);
+		$macro!(5,$struct,$trait,$method);
+		$macro!(6,$struct,$trait,$method);
+		$macro!(7,$struct,$trait,$method);
+		$macro!(8,$struct,$trait,$method);
+		$macro!(9,$struct,$trait,$method);
+		$macro!(10,$struct,$trait,$method);
+		$macro!(11,$struct,$trait,$method);
+		$macro!(12,$struct,$trait,$method);
+		$macro!(13,$struct,$trait,$method);
+		$macro!(14,$struct,$trait,$method);
+		$macro!(15,$struct,$trait,$method);
+		$macro!(16,$struct,$trait,$method);
+	}
+}
+
+impl_assign_operator_16!( impl_multiply_assign_operator_const, Fixed, MulAssign, mul_assign );
+impl_operator_16!( impl_multiply_operator_const, Fixed, Mul, mul, Self );
+impl_assign_operator_16!( impl_divide_assign_operator_const, Fixed, DivAssign, div_assign );
+impl_operator_16!( impl_divide_operator_const, Fixed, Div, div, Self );
+impl_multiplicatave_assign_operator!( Fixed, MulAssign, mul_assign );
+impl_multiplicatave_operator!( Fixed, Mul, mul, Self );
+impl_multiplicatave_assign_operator!( Fixed, DivAssign, div_assign );
+impl_multiplicatave_operator!( Fixed, Div, div, Self );
 
 macro_rules! impl_shift_operator {
 	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
-        impl<const CHUNKS:usize,Frac> core::ops::$trait<u32> for $struct<CHUNKS,Frac>{
-            type Output = $output;
+		impl<const CHUNKS:usize,Frac> core::ops::$trait<u32> for $struct<CHUNKS,Frac>{
+			type Output = $output;
 
-            fn $method(self, other: u32) -> Self::Output {
-            	Self {
-                    bits:self.bits.$method(other),
-                    frac:PhantomData,
-                }
-            }
-        }
-    };
+			fn $method(self, other: u32) -> Self::Output {
+				Self::from_bits(self.bits.$method(other))
+			}
+		}
+	};
 }
 macro_rules! impl_shift_assign_operator {
-    ( $struct: ident, $trait: ident, $method: ident ) => {
-        impl<const CHUNKS:usize,Frac> core::ops::$trait<u32> for $struct<CHUNKS,Frac>{
-            fn $method(&mut self, other: u32) {
-                self.bits.$method(other);
-            }
-        }
-    };
+	( $struct: ident, $trait: ident, $method: ident ) => {
+		impl<const CHUNKS:usize,Frac> core::ops::$trait<u32> for $struct<CHUNKS,Frac>{
+			fn $method(&mut self, other: u32) {
+				self.bits.$method(other);
+			}
+		}
+	};
 }
 impl_shift_assign_operator!( Fixed, ShlAssign, shl_assign );
 impl_shift_operator!( Fixed, Shl, shl, Self );

fixed_wide/src/fixed_wide_traits.rs

@@ -3,7 +3,6 @@ use bnum::cast::As;
 use typenum::{Sum,Unsigned};
 use crate::fixed::Fixed;
 use fixed_wide_traits::wide::WideMul;
-use std::marker::PhantomData;
 
 macro_rules! impl_wide_mul {
 	($lhs: expr,$rhs: expr) => {
@@ -14,21 +13,18 @@ macro_rules! impl_wide_mul {
 		{
 			type Output=Fixed<{$lhs+$rhs},Sum<A,B>>;
 			fn wide_mul(self,rhs:Fixed<$rhs,B>)->Self::Output{
-				Fixed{
-					bits:self.bits.as_::<BInt<{$lhs+$rhs}>>()*rhs.bits.as_::<BInt<{$lhs+$rhs}>>(),
-					frac:PhantomData,
-				}
+				Fixed::from_bits(self.bits.as_::<BInt<{$lhs+$rhs}>>()*rhs.bits.as_::<BInt<{$lhs+$rhs}>>())
 			}
 		}
 	};
 }
 
 macro_rules! impl_wide_mul_all {
-    ($(($x:expr, $y:expr)),*) => {
-        $(
-            impl_wide_mul!($x, $y);
-        )*
-    };
+	($(($x:expr, $y:expr)),*) => {
+		$(
+			impl_wide_mul!($x, $y);
+		)*
+	};
 }
 
 //const generics sidestepped wahoo
@@ -42,3 +38,51 @@ impl_wide_mul_all!(
 	(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),(7,7),(8,7),
 	(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),(8,8)
 );
+impl<const SRC:usize,Frac> Fixed<SRC,Frac>{
+	pub fn widen<const DST:usize>(self)->Fixed<DST,Frac>{
+		Fixed::from_bits(self.bits.as_::<BInt<DST>>())
+	}
+}
+
+impl<const CHUNKS:usize,Frac:Unsigned> Fixed<CHUNKS,Frac>
+	where
+		Fixed::<CHUNKS,Frac>:WideMul,
+		<Fixed::<CHUNKS,Frac> as WideMul>::Output:Ord,
+{
+	pub fn sqrt_unchecked(self)->Self{
+		//1<<max_shift must be the minimum power of two which when squared is greater than self
+		//calculating max_shift:
+		//1. count "used" bits to the left of the decimal, not including the sign bit (so -1)
+		//2. divide by 2 via >>1 (sqrt-ish)
+		//3. add on fractional offset
+		//Voila
+		let used_bits=self.bits.bits() as i32-1-Frac::I32;
+		let max_shift=((used_bits>>1)+Frac::I32) as u32;
+		let mut result=Self::ZERO;
+
+		//multiply by one to make the types match (hack)
+		let wide_self=self.wide_mul(Fixed::<CHUNKS,Frac>::ONE);
+		//descend down the bits and check if flipping each bit would push the square over the input value
+		for shift in (0..=max_shift).rev(){
+			let new_result=result|Fixed::<CHUNKS,Frac>::from_bits(BInt::from_bits(bnum::BUint::power_of_two(shift)));
+			if new_result.wide_mul(new_result)<=wide_self{
+				result=new_result;
+			}
+		}
+		result
+	}
+	pub fn sqrt(self)->Self{
+		if self<Self::ZERO{
+			panic!("Square root less than zero")
+		}else{
+			self.sqrt_unchecked()
+		}
+	}
+	pub fn sqrt_checked(self)->Option<Self>{
+		if self<Self::ZERO{
+			None
+		}else{
+			Some(self.sqrt_unchecked())
+		}
+	}
+}

fixed_wide/src/tests.rs

@@ -1,14 +1,66 @@
 use fixed_wide_traits::wide::WideMul;
+use crate::types::I32F32;
 
 #[test]
 fn test_wide_mul(){
-	let a=crate::types::I32F32::ONE;
+	let a=I32F32::ONE;
 	let aa=a.wide_mul(a);
 	assert_eq!(aa,crate::types::I64F64::ONE);
 }
 
 #[test]
 fn test_bint(){
-	let a=crate::types::I32F32::ONE;
-	assert_eq!(a*2,crate::types::I32F32::from(2));
+	let a=I32F32::ONE;
+	assert_eq!(a*2,I32F32::from(2));
+}
+
+#[test]
+fn test_sqrt(){
+	let a=I32F32::ONE*4;
+	assert_eq!(a.sqrt(),I32F32::from(2));
+}
+#[test]
+fn test_sqrt_zero(){
+	let a=I32F32::ZERO;
+	assert_eq!(a.sqrt(),I32F32::ZERO);
+}
+#[test]
+fn test_sqrt_low(){
+	let a=I32F32::HALF;
+	let b=a*a;
+	assert_eq!(b.sqrt(),a);
+}
+fn find_equiv_sqrt_via_f64(n:I32F32)->I32F32{
+	//GIMME THEM BITS BOY
+	let &[bits]=n.to_bits().to_bits().digits();
+	let ibits=bits as i64;
+	let f=(ibits as f64)/((1u64<<32) as f64);
+	let f_ans=f.sqrt();
+	let i=(f_ans*((1u64<<32) as f64)) as i64;
+	let r=I32F32::from_bits(bnum::BInt::<1>::from(i));
+	//mimic the behaviour of the algorithm,
+	//return the result if it truncates to the exact answer
+	if (r+I32F32::EPSILON).wide_mul(r+I32F32::EPSILON)==n.wide_mul(I32F32::ONE){
+		return r+I32F32::EPSILON;
+	}
+	if (r-I32F32::EPSILON).wide_mul(r-I32F32::EPSILON)==n.wide_mul(I32F32::ONE){
+		return r-I32F32::EPSILON;
+	}
+	return r;
+}
+fn test_exact(n:I32F32){
+	assert_eq!(n.sqrt(),find_equiv_sqrt_via_f64(n));
+}
+#[test]
+fn test_sqrt_exact(){
+	//43
+	for i in 0..((i64::MAX as f32).ln() as u32){
+		let n=I32F32::from_bits(bnum::BInt::<1>::from((i as f32).exp() as i64));
+		test_exact(n);
+	}
+}
+#[test]
+fn test_sqrt_max(){
+	let a=I32F32::MAX;
+	test_exact(a);
 }

fixed_wide_vectors/src/affine.rs

@@ -1,20 +0,0 @@
-use std::ops::Add;
-use fixed_wide_traits::wide::WideDot;
-
-//TODO: replace this with 4x3 matrix
-// mat4x3.wide_dot(vec3.extend(1))
-
-pub struct Affine<M,T>{
-	pub matrix:M,
-	pub offset:T,
-}
-
-impl<M:Copy,T:Copy> Affine<M,T>{
-	pub fn wide_transform<X>(&self,input:X)-><<M as WideDot<X>>::Output as Add<T>>::Output
-		where
-			M:WideDot<X>,
-			<M as WideDot<X>>::Output:Add<T>,
-	{
-		self.matrix.wide_dot(input)+self.offset
-	}
-}

fixed_wide_vectors/src/lib.rs

@@ -1,13 +1,14 @@
 mod macros;
-mod traits;
 mod vector;
-
-#[cfg(feature="fixed_wide_traits")]
-pub mod affine;
+mod matrix;
 
 pub use vector::Vector2;
 pub use vector::Vector3;
 pub use vector::Vector4;
 
+pub use matrix::Matrix2;
+pub use matrix::Matrix3;
+pub use matrix::Matrix4;
+
 #[cfg(test)]
 mod tests;

fixed_wide_vectors/src/macros/common.rs

@@ -0,0 +1,102 @@
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_common {
+	( $struct: ident { $($field: ident), + }, ( $($generic: ident), + ), $size: expr ) => {
+		impl<T> $struct<T> {
+			/// Constructs a new vector with the specified values for each field.
+			///
+			/// # Example
+			///
+			/// ```
+			/// use fixed_wide_vectors::Vector2;
+			///
+			/// let vec2 = Vector2::new(0, 0);
+			///
+			/// assert_eq!(vec2.x, 0);
+			/// assert_eq!(vec2.y, 0);
+			/// ```
+			#[inline(always)]
+			pub const fn new( $($field: T), + ) -> Self {
+				Self {
+					$( $field ), +
+				}
+			}
+
+			/// Consumes the vector and returns its values as an array.
+			///
+			/// # Example
+			///
+			/// ```
+			/// use fixed_wide_vectors::Vector2;
+			///
+			/// let vec2 = Vector2::new(0, 0);
+			/// let array = vec2.to_array();
+			///
+			/// assert_eq!(array, [0, 0]);
+			/// ```
+			#[inline(always)]
+			pub fn to_array(self) -> [T; $size] {
+				[ $(self.$field), + ]
+			}
+
+			/// Consumes the vector and returns its values as a tuple.
+			///
+			/// # Example
+			///
+			/// ```
+			/// use fixed_wide_vectors::Vector2;
+			///
+			/// let vec2 = Vector2::new(0, 0);
+			/// let tuple = vec2.to_tuple();
+			///
+			/// assert_eq!(tuple, (0, 0));
+			/// ```
+			#[inline(always)]
+			pub fn to_tuple(self) -> ( $($generic), + ) {
+				( $(self.$field), + )
+			}
+
+			/// Consumes the vector and returns a new vector with the given function applied on each field.
+			///
+			/// # Example
+			///
+			/// ```
+			/// use fixed_wide_vectors::Vector2;
+			///
+			/// let vec2 = Vector2::new(1, 2)
+			///     .map(|i| i * 2);
+			///
+			/// assert_eq!(vec2, Vector2::new(2, 4));
+			/// ```
+			#[inline]
+			pub fn map<F, U>(self, f: F) -> $struct<U>
+			where
+				F: Fn(T) -> U
+			{
+				$struct {
+					$( $field: f(self.$field) ), +
+				}
+			}
+		}
+
+		impl<T: Copy> $struct<T> {
+			/// Constructs a vector using the given `value` as the value for all of its fields.
+			///
+			/// # Example
+			///
+			/// ```
+			/// use fixed_wide_vectors::Vector2;
+			///
+			/// let vec2 = Vector2::from_value(0);
+			///
+			/// assert_eq!(vec2, Vector2::new(0, 0));
+			/// ```
+			#[inline(always)]
+			pub const fn from_value(value: T) -> Self {
+				Self {
+					$( $field: value ), +
+				}
+			}
+		}
+	}
+}

fixed_wide_vectors/src/macros/matrix.rs

@@ -0,0 +1,185 @@
+// Stolen from https://github.com/c1m50c/fixed-vectors (MIT license)
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix {
+	(
+		($struct_outer: ident { $($field_outer: ident), + }, $vector_outer: ident { $($vector_field_outer: ident), + }, $size_outer: expr),
+		( $($generic_outer: tt), + )
+	) => {
+		$crate::impl_common!($struct_outer { $($field_outer), + }, ( $($generic_outer), + ), $size_outer);
+		impl<U> $struct_outer<U> {
+			#[inline(always)]
+			pub fn to_vector(self) -> $vector_outer<U> {
+				$vector_outer {
+					$(
+						$vector_field_outer: self.$field_outer
+					), +
+				}
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_inner {
+	(
+		($struct_outer: ident { $($field_outer: ident), + }, $vector_outer: ident { $($vector_field_outer: ident), + }, $size_outer: expr),
+		($struct_inner: ident { $($field_inner: ident), + }, $matrix_inner: ident { $($matrix_field_inner: ident), + }, $size_inner: expr),
+		( $($generic_outer: tt), + )
+	) => {
+		impl<T> $struct_outer<$struct_inner<T>> {
+			#[inline(always)]
+			pub fn to_array_2d(self) -> [[T; $size_inner]; $size_outer] {
+				[ $(self.$field_outer.to_array()), + ]
+			}
+
+			#[inline(always)]
+			pub fn to_tuple_2d(self) -> ( $($generic_outer), + ) {
+				( $(self.$field_outer.to_tuple()), + )
+			}
+
+			#[inline]
+			pub fn map_2d<F, U>(self, f: F) -> $struct_outer<$struct_inner<U>>
+			where
+				F: Fn(T) -> U
+			{
+				$crate::matrix_map2d_outer!{f,self,($struct_outer { $($field_outer), + }),($struct_inner { $($field_inner), + })}
+			}
+
+			#[inline]
+			pub fn transpose(self) -> $matrix_inner<$vector_outer<T>>{
+				$crate::matrix_transpose_outer!{self,
+					($matrix_inner { $($matrix_field_inner), + }),($struct_inner { $($field_inner), + }),
+					($vector_outer { $($vector_field_outer), + }),($struct_outer { $($field_outer), + })
+				}
+			}
+		}
+
+		impl<T: Copy> $struct_outer<$struct_inner<T>> {
+			#[inline(always)]
+			pub const fn from_value_2d(value: T) -> Self {
+				Self {
+					$( $field_outer: $struct_inner::from_value(value) ), +
+				}
+			}
+			//TODO: diagonal
+		}
+
+		// Impl floating-point based methods
+		#[cfg(feature="fixed_wide_traits")]
+		$crate::impl_wide_matrix_operations!(
+			($struct_outer { $($field_outer), + }, $vector_outer { $($vector_field_outer), + }, $size_outer),
+			($struct_inner { $($field_inner), + }, $matrix_inner { $($matrix_field_inner), + }, $size_inner)
+		);
+	};
+}
+
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! matrix_map2d_outer {
+	( $f:ident, $value:ident, ($struct_outer: ident { $($field_outer: ident), + }), $unparsed_inner:tt ) => {
+		$struct_outer {
+			$(
+				$field_outer: $crate::matrix_map2d_inner!{$f,$value,$field_outer,$unparsed_inner}
+			), +
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! matrix_map2d_inner {
+	( $f:ident, $value:ident, $field_outer:ident, ($struct_inner: ident { $($field_inner: ident), + }) ) => {
+		$struct_inner {
+			$(
+				$field_inner: $f($value.$field_outer.$field_inner)
+			), +
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! matrix_transpose_outer {
+	(
+		$value:ident,
+		($struct_outer: ident { $($field_outer: ident), + }),
+		($old_outer: ident { $($old_field_outer: ident), + }),
+		$fields_inner:tt,
+		$old_fields_inner:tt
+	) => {
+		$struct_outer {
+			$(
+				$field_outer: $crate::matrix_transpose_inner!{$value,$old_field_outer,$fields_inner,$old_fields_inner}
+			), +
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! matrix_transpose_inner {
+	( $value:ident, $field_outer:ident,
+		($struct_inner: ident { $($field_inner: ident), + }),
+		($old_struct_inner: ident { $($old_field_inner: ident), + })
+	) => {
+		$struct_inner {
+			$(
+				$field_inner: $value.$old_field_inner.$field_outer
+			), +
+		}
+	}
+}
+
+/*
+macro_rules! nested {
+    (($($f:ident),*) $args:tt) => {
+        $(nested!(@call $f $args);)*
+    };
+    (@call $f:ident ($($arg:expr),*)) => {
+        $f($($arg),*);
+    };
+}
+
+nested! {
+    (show1, show2)
+    (a, b, c)
+}
+*/
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_operator {
+	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident, $output: ty ) => {
+		impl<T:core::ops::$trait<Output=T>> core::ops::$trait for $struct<T> {
+			type Output = $output;
+
+			fn $method(self, other: Self) -> Self::Output {
+				Self {
+					$( $field: self.$field.$method(other.$field) ), +
+				}
+			}
+		}
+		impl<T:core::ops::$trait<Output=T>+Copy> core::ops::$trait<T> for $struct<T>{
+			type Output = $output;
+
+			fn $method(self, other: T) -> Self::Output {
+				$struct {
+					$( $field: self.$field.$method(other) ), +
+				}
+			}
+		}
+	};
+
+	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident ) => {
+		impl<T: core::ops::$trait> core::ops::$trait for $struct<T> {
+			fn $method(&mut self, other: Self)  {
+				$( self.$field.$method(other.$field) ); +
+			}
+		}
+
+		impl<T: core::ops::$trait + Copy> core::ops::$trait<T> for $struct<T> {
+			fn $method(&mut self, other: T)  {
+				$( self.$field.$method(other) ); +
+			}
+		}
+	};
+}

fixed_wide_vectors/src/macros/mod.rs

@@ -1,323 +1,6 @@
 #[cfg(feature="fixed_wide_traits")]
 pub mod wide;
 
-// Stolen from https://github.com/c1m50c/fixed-vectors (MIT license)
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector {
-	( $struct: ident { $($field: ident), + }, ( $($generic: ident), + ), $size: expr ) => {
-		impl<T> $struct<T> {
-			/// Constructs a new vector with the specified values for each field.
-			///
-			/// # Example
-			///
-			/// ```
-			/// use fixed_wide_vectors::Vector2;
-			///
-			/// let vec2 = Vector2::new(0, 0);
-			///
-			/// assert_eq!(vec2.x, 0);
-			/// assert_eq!(vec2.y, 0);
-			/// ```
-			#[inline(always)]
-			pub const fn new( $($field: T), + ) -> Self {
-				Self {
-					$( $field ), +
-				}
-			}
-
-			/// Consumes the vector and returns its values as an array.
-			///
-			/// # Example
-			///
-			/// ```
-			/// use fixed_wide_vectors::Vector2;
-			///
-			/// let vec2 = Vector2::new(0, 0);
-			/// let array = vec2.to_array();
-			///
-			/// assert_eq!(array, [0, 0]);
-			/// ```
-			#[inline(always)]
-			pub fn to_array(self) -> [T; $size] {
-				[ $(self.$field), + ]
-			}
-
-			/// Consumes the vector and returns its values as a tuple.
-			///
-			/// # Example
-			///
-			/// ```
-			/// use fixed_wide_vectors::Vector2;
-			///
-			/// let vec2 = Vector2::new(0, 0);
-			/// let tuple = vec2.to_tuple();
-			///
-			/// assert_eq!(tuple, (0, 0));
-			/// ```
-			#[inline(always)]
-			pub fn to_tuple(self) -> ( $($generic), + ) {
-				( $(self.$field), + )
-			}
-
-			/// Consumes the vector and returns a new vector with the given function applied on each field.
-			///
-			/// # Example
-			///
-			/// ```
-			/// use fixed_wide_vectors::Vector2;
-			///
-			/// let vec2 = Vector2::new(1, 2)
-			///     .map(|i| i * 2);
-			///
-			/// assert_eq!(vec2, Vector2::new(2, 4));
-			/// ```
-			#[inline]
-			pub fn map<F, U>(self, f: F) -> $struct<U>
-			where
-				F: Fn(T) -> U
-			{
-				$struct {
-					$( $field: f(self.$field) ), +
-				}
-			}
-		}
-
-		impl<T: Copy> $struct<T> {
-			/// Constructs a vector using the given `value` as the value for all of its fields.
-			///
-			/// # Example
-			///
-			/// ```
-			/// use fixed_wide_vectors::Vector2;
-			///
-			/// let vec2 = Vector2::from_value(0);
-			///
-			/// assert_eq!(vec2, Vector2::new(0, 0));
-			/// ```
-			#[inline(always)]
-			pub const fn from_value(value: T) -> Self {
-				Self {
-					$( $field: value ), +
-				}
-			}
-		}
-
-		impl<T> From<[T; $size]> for $struct<T> {
-			fn from(from: [T; $size]) -> Self {
-				let mut iterator = from.into_iter();
-
-				Self {
-					// SAFETY: We know the size of `from` so `iterator.next()` is always `Some(..)`
-					$( $field: unsafe { iterator.next().unwrap_unchecked() } ), +
-				}
-			}
-		}
-
-		impl<T> From<($($generic), +)> for $struct<T> {
-			fn from(from: ($($generic), +)) -> Self {
-				let ( $($field), + ) = from;
-
-				Self {
-					$( $field ), +
-				}
-			}
-		}
-
-		impl<T: core::fmt::Debug> core::fmt::Debug for $struct<T> {
-			fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-				let identifier = core::stringify!($struct);
-
-				f.debug_struct(identifier)
-					$( .field( core::stringify!($field), &self.$field ) ) +
-					.finish()
-			}
-		}
-
-		impl<T: PartialEq> PartialEq for $struct<T> {
-			fn eq(&self, other: &Self) -> bool {
-				$( self.$field == other.$field ) && +
-			}
-		}
-
-		impl<T: Eq> Eq for $struct<T> {  }
-
-		impl<T: core::hash::Hash> core::hash::Hash for $struct<T> {
-			fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-				$( self.$field.hash(state); ) +
-			}
-		}
-
-		impl<T: Clone> Clone for $struct<T> {
-			fn clone(&self) -> Self {
-				Self {
-					$( $field: self.$field.clone() ), +
-				}
-			}
-		}
-
-		impl<T: Copy> Copy for $struct<T> {  }
-
-		impl<T: Default> Default for $struct<T> {
-			fn default() -> Self {
-				Self {
-					$( $field: T::default() ), +
-				}
-			}
-		}
-
-		impl<T: Ord> $struct<T> {
-			pub fn min(self, rhs: Self) -> $struct<T> {
-				$struct{
-					$( $field: self.$field.min(rhs.$field) ), +
-				}
-			}
-			pub fn max(self, rhs: Self) -> $struct<T> {
-				$struct{
-					$( $field: self.$field.max(rhs.$field) ), +
-				}
-			}
-			pub fn cmp(self, rhs: Self) -> $struct<core::cmp::Ordering> {
-				$struct{
-					$( $field: self.$field.cmp(&rhs.$field) ), +
-				}
-			}
-			pub fn lt(self, rhs: Self) -> $struct<bool> {
-				$struct{
-					$( $field: self.$field.lt(&rhs.$field) ), +
-				}
-			}
-			pub fn gt(self, rhs: Self) -> $struct<bool> {
-				$struct{
-					$( $field: self.$field.gt(&rhs.$field) ), +
-				}
-			}
-			pub fn ge(self, rhs: Self) -> $struct<bool> {
-				$struct{
-					$( $field: self.$field.ge(&rhs.$field) ), +
-				}
-			}
-			pub fn le(self, rhs: Self) -> $struct<bool> {
-				$struct{
-					$( $field: self.$field.le(&rhs.$field) ), +
-				}
-			}
-		}
-
-		impl $struct<bool>{
-			pub fn all(&self)->bool{
-				const ALL:[bool;$size]=[true;$size];
-				core::matches!(self.to_array(),ALL)
-			}
-			pub fn any(&self)->bool{
-				$( self.$field )|| +
-			}
-		}
-
-		impl<T: core::ops::Neg<Output = T>> core::ops::Neg for $struct<T> {
-			type Output = Self;
-
-			fn neg(self) -> Self::Output {
-				Self {
-					$( $field: -self.$field ), +
-				}
-			}
-		}
-
-		// Impl arithmetic pperators
-		$crate::impl_operator!( $struct { $($field), + }, AddAssign, add_assign );
-		$crate::impl_operator!( $struct { $($field), + }, Add, add, Self );
-		$crate::impl_operator!( $struct { $($field), + }, SubAssign, sub_assign );
-		$crate::impl_operator!( $struct { $($field), + }, Sub, sub, Self );
-		$crate::impl_operator!( $struct { $($field), + }, MulAssign, mul_assign );
-		$crate::impl_operator!( $struct { $($field), + }, Mul, mul, Self );
-		$crate::impl_operator!( $struct { $($field), + }, DivAssign, div_assign );
-		$crate::impl_operator!( $struct { $($field), + }, Div, div, Self );
-		$crate::impl_operator!( $struct { $($field), + }, RemAssign, rem_assign );
-		$crate::impl_operator!( $struct { $($field), + }, Rem, rem, Self );
-
-		// Impl bitwise operators
-		$crate::impl_operator!( $struct { $($field), + }, BitAndAssign, bitand_assign );
-		$crate::impl_operator!( $struct { $($field), + }, BitAnd, bitand, Self );
-		$crate::impl_operator!( $struct { $($field), + }, BitOrAssign, bitor_assign );
-		$crate::impl_operator!( $struct { $($field), + }, BitOr, bitor, Self );
-		$crate::impl_operator!( $struct { $($field), + }, BitXorAssign, bitxor_assign );
-		$crate::impl_operator!( $struct { $($field), + }, BitXor, bitxor, Self );
-
-		// Impl floating-point based methods
-		#[cfg(feature="fixed_wide_traits")]
-		$crate::impl_wide_operations!( $struct { $($field), + }, $size );
-	};
-}
-
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_inner {
-	( $struct_outer: ident { $($field_outer: ident), + }, $size_outer: expr,
-	$field_inner: ident) => {
-		$struct_outer {
-			$(
-				$field_outer: self.$field_outer.$field_inner
-			),+
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix {
-	( $struct_outer: ident { $($field_outer: ident),+ }, $size_outer: expr) => {
-		impl<T> Transpose for $struct_outer<$struct_inner<T>> {
-			fn transpose(self) -> $struct_inner<$struct_outer<T>> {
-				$struct_inner {
-					$(
-						$field_inner: impl_matrix_inner!(
-							Vector2{x,y}, $size_outer,
-							$field_inner
-						)
-					),+
-				}
-			}
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_operator {
-	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident, $output: ty ) => {
-		impl<T:core::ops::$trait<Output=T>> core::ops::$trait for $struct<T> {
-			type Output = $output;
-
-			fn $method(self, other: Self) -> Self::Output {
-				Self {
-					$( $field: self.$field.$method(other.$field) ), +
-				}
-			}
-		}
-		impl<T:core::ops::$trait<Output=T>+Copy> core::ops::$trait<T> for $struct<T>{
-			type Output = $output;
-
-			fn $method(self, other: T) -> Self::Output {
-				$struct {
-					$( $field: self.$field.$method(other) ), +
-				}
-			}
-		}
-	};
-
-	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident ) => {
-		impl<T: core::ops::$trait> core::ops::$trait for $struct<T> {
-			fn $method(&mut self, other: Self)  {
-				$( self.$field.$method(other.$field) ); +
-			}
-		}
-
-		impl<T: core::ops::$trait + Copy> core::ops::$trait<T> for $struct<T> {
-			fn $method(&mut self, other: T)  {
-				$( self.$field.$method(other) ); +
-			}
-		}
-	};
-}
+pub mod common;
+pub mod vector;
+pub mod matrix;

fixed_wide_vectors/src/macros/vector.rs

@@ -0,0 +1,209 @@
+// Stolen from https://github.com/c1m50c/fixed-vectors (MIT license)
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector {
+	( $struct: ident { $($field: ident), + }, ( $($generic: ident), + ), $size: expr ) => {
+		$crate::impl_common!($struct { $($field), + }, ( $($generic), + ), $size);
+
+		impl<T> From<[T; $size]> for $struct<T> {
+			fn from(from: [T; $size]) -> Self {
+				let mut iterator = from.into_iter();
+
+				Self {
+					// SAFETY: We know the size of `from` so `iterator.next()` is always `Some(..)`
+					$( $field: unsafe { iterator.next().unwrap_unchecked() } ), +
+				}
+			}
+		}
+
+		impl<T> From<($($generic), +)> for $struct<T> {
+			fn from(from: ($($generic), +)) -> Self {
+				let ( $($field), + ) = from;
+
+				Self {
+					$( $field ), +
+				}
+			}
+		}
+
+		impl<T: core::fmt::Debug> core::fmt::Debug for $struct<T> {
+			fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+				let identifier = core::stringify!($struct);
+
+				f.debug_struct(identifier)
+					$( .field( core::stringify!($field), &self.$field ) ) +
+					.finish()
+			}
+		}
+
+		impl<T: PartialEq> PartialEq for $struct<T> {
+			fn eq(&self, other: &Self) -> bool {
+				$( self.$field == other.$field ) && +
+			}
+		}
+
+		impl<T: Eq> Eq for $struct<T> {  }
+
+		impl<T: core::hash::Hash> core::hash::Hash for $struct<T> {
+			fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+				$( self.$field.hash(state); ) +
+			}
+		}
+
+		impl<T: Clone> Clone for $struct<T> {
+			fn clone(&self) -> Self {
+				Self {
+					$( $field: self.$field.clone() ), +
+				}
+			}
+		}
+
+		impl<T: Copy> Copy for $struct<T> {  }
+
+		impl<T: Default> Default for $struct<T> {
+			fn default() -> Self {
+				Self {
+					$( $field: T::default() ), +
+				}
+			}
+		}
+
+		impl<T: Ord> $struct<T> {
+			pub fn min(self, rhs: Self) -> $struct<T> {
+				$struct{
+					$( $field: self.$field.min(rhs.$field) ), +
+				}
+			}
+			pub fn max(self, rhs: Self) -> $struct<T> {
+				$struct{
+					$( $field: self.$field.max(rhs.$field) ), +
+				}
+			}
+			pub fn cmp(self, rhs: Self) -> $struct<core::cmp::Ordering> {
+				$struct{
+					$( $field: self.$field.cmp(&rhs.$field) ), +
+				}
+			}
+			pub fn lt(self, rhs: Self) -> $struct<bool> {
+				$struct{
+					$( $field: self.$field.lt(&rhs.$field) ), +
+				}
+			}
+			pub fn gt(self, rhs: Self) -> $struct<bool> {
+				$struct{
+					$( $field: self.$field.gt(&rhs.$field) ), +
+				}
+			}
+			pub fn ge(self, rhs: Self) -> $struct<bool> {
+				$struct{
+					$( $field: self.$field.ge(&rhs.$field) ), +
+				}
+			}
+			pub fn le(self, rhs: Self) -> $struct<bool> {
+				$struct{
+					$( $field: self.$field.le(&rhs.$field) ), +
+				}
+			}
+		}
+
+		impl $struct<bool>{
+			pub fn all(&self)->bool{
+				const ALL:[bool;$size]=[true;$size];
+				core::matches!(self.to_array(),ALL)
+			}
+			pub fn any(&self)->bool{
+				$( self.$field )|| +
+			}
+		}
+
+		impl<T: core::ops::Neg<Output = T>> core::ops::Neg for $struct<T> {
+			type Output = Self;
+
+			fn neg(self) -> Self::Output {
+				Self {
+					$( $field: -self.$field ), +
+				}
+			}
+		}
+
+		// Impl arithmetic pperators
+		$crate::impl_vector_operator!( $struct { $($field), + }, AddAssign, add_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, Add, add, Self );
+		$crate::impl_vector_operator!( $struct { $($field), + }, SubAssign, sub_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, Sub, sub, Self );
+		$crate::impl_vector_operator!( $struct { $($field), + }, MulAssign, mul_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, Mul, mul, Self );
+		$crate::impl_vector_operator!( $struct { $($field), + }, DivAssign, div_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, Div, div, Self );
+		$crate::impl_vector_operator!( $struct { $($field), + }, RemAssign, rem_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, Rem, rem, Self );
+
+		// Impl bitwise operators
+		$crate::impl_vector_operator!( $struct { $($field), + }, BitAndAssign, bitand_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, BitAnd, bitand, Self );
+		$crate::impl_vector_operator!( $struct { $($field), + }, BitOrAssign, bitor_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, BitOr, bitor, Self );
+		$crate::impl_vector_operator!( $struct { $($field), + }, BitXorAssign, bitxor_assign );
+		$crate::impl_vector_operator!( $struct { $($field), + }, BitXor, bitxor, Self );
+
+		// Impl floating-point based methods
+		#[cfg(feature="fixed_wide_traits")]
+		$crate::impl_wide_vector_operations!( $struct { $($field), + }, $size );
+	};
+}
+
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_extend {
+	( $struct: ident { $($field: ident), + }, $struct_extended: ident, $field_extended: ident ) => {
+		impl<T> $struct<T> {
+			#[inline(always)]
+			pub fn extend(self,value:T) -> $struct_extended<T> {
+				$struct_extended {
+					$( $field:self.$field, ) +
+					$field_extended:value
+				}
+			}
+		}
+	};
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_operator {
+	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident, $output: ty ) => {
+		impl<T:core::ops::$trait<Output=T>> core::ops::$trait for $struct<T> {
+			type Output = $output;
+
+			fn $method(self, other: Self) -> Self::Output {
+				Self {
+					$( $field: self.$field.$method(other.$field) ), +
+				}
+			}
+		}
+		impl<T:core::ops::$trait<Output=T>+Copy> core::ops::$trait<T> for $struct<T>{
+			type Output = $output;
+
+			fn $method(self, other: T) -> Self::Output {
+				$struct {
+					$( $field: self.$field.$method(other) ), +
+				}
+			}
+		}
+	};
+
+	( $struct: ident { $($field: ident), + }, $trait: ident, $method: ident ) => {
+		impl<T: core::ops::$trait> core::ops::$trait for $struct<T> {
+			fn $method(&mut self, other: Self)  {
+				$( self.$field.$method(other.$field) ); +
+			}
+		}
+
+		impl<T: core::ops::$trait + Copy> core::ops::$trait<T> for $struct<T> {
+			fn $method(&mut self, other: T)  {
+				$( self.$field.$method(other) ); +
+			}
+		}
+	};
+}

fixed_wide_vectors/src/macros/wide.rs

@@ -1,7 +1,8 @@
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
-macro_rules! impl_wide_operations {
+macro_rules! impl_wide_vector_operations {
 	( $struct: ident { $($field: ident), + }, $size: expr ) => {
+		//this one is shared between vec and mat
 		impl<U,T:Copy+fixed_wide_traits::wide::WideMul<Output=U>> fixed_wide_traits::wide::WideMul for $struct<T> {
 			type Output=$struct<U>;
 			#[inline]
@@ -11,6 +12,7 @@ macro_rules! impl_wide_operations {
 				}
 			}
 		}
+		//these ones are vec only
 		impl<V:core::ops::Add<Output=V>,U,T:fixed_wide_traits::wide::WideMul<U,Output=V>> fixed_wide_traits::wide::WideDot<$struct<U>> for $struct<T> {
 			type Output=V;
 			#[inline]
@@ -31,6 +33,57 @@ macro_rules! impl_wide_operations {
 	};
 }
 
+// Notes:
+// Mat3<Vec2>.dot(Vec2) -> Vec3
+// Mat3<Vec4>.dot(Mat4<Vec2>) -> Mat3<Vec2>
+// mat.mat can be implemented off the back of mat.vec
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_wide_matrix_mul {
+	(
+		($struct_outer: ident { $($field_outer: ident), + }, $vector_outer: ident { $($vector_field_outer: ident), + }, $size_outer: expr),
+		($struct_inner: ident { $($field_inner: ident), + }, $matrix_inner: ident { $($matrix_field_inner: ident), + }, $size_inner: expr),
+		($rhs_struct_inner: ident { $($rhs_field_inner: ident), + }, $rhs_matrix_inner: ident { $($rhs_matrix_field_inner: ident), + }, $rhs_size_inner: expr)
+	) => {
+		impl<T,U> fixed_wide_traits::wide::WideDot<$matrix_inner<$rhs_struct_inner<U>>> for $struct_outer<$struct_inner<T>>
+			where
+				$struct_inner<T>:fixed_wide_traits::wide::WideDot<$rhs_struct_inner<U>>,
+		{
+			type Output=$struct_outer<<$struct_inner<T> as fixed_wide_traits::wide::WideDot<$rhs_struct_inner<U>>::Output>;
+			#[inline]
+			fn wide_dot(self,rhs:$matrix_inner<$rhs_struct_inner<U>>)->Self::Output{
+				//just made this up, don't trust it
+				let tr=rhs.transpose();
+				//TODO: use a macro expansion instead of transpose and map
+				self.map(|axis|
+					tr.map(|trax|
+						axis.wide_dot(trax)
+					).to_vector()
+				)
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_wide_matrix_operations {
+	(
+		($struct_outer: ident { $($field_outer: ident), + }, $vector_outer: ident { $($vector_field_outer: ident), + }, $size_outer: expr),
+		($struct_inner: ident { $($field_inner: ident), + }, $matrix_inner: ident { $($matrix_field_inner: ident), + }, $size_inner: expr)
+	) => {
+		/* TODO: nasty determinant macro
+		impl<U:std::ops::Add<Output=U>,T:Copy+fixed_wide_traits::wide::WideMul<Output=U>> $struct<T> {
+			#[inline]
+			pub fn wide_det(&self) -> U {
+				$crate::sum_repeating!(
+					$( + self.$field.wide_mul(self.$field) ) +
+				)
+			}
+		}
+		*/
+	};
+}
 
 // HACK: Allows us to sum repeating tokens in macros.
 // See: https://stackoverflow.com/a/60187870/17452730

fixed_wide_vectors/src/matrix.rs

@@ -0,0 +1,34 @@
+use crate::{Vector2,Vector3,Vector4};
+
+pub struct Matrix2<T> {
+	pub x_axis: T,
+	pub y_axis: T,
+}
+pub struct Matrix3<T> {
+	pub x_axis: T,
+	pub y_axis: T,
+	pub z_axis: T,
+}
+pub struct Matrix4<T> {
+	pub x_axis: T,
+	pub y_axis: T,
+	pub z_axis: T,
+	pub w_axis: T,
+}
+
+crate::impl_matrix!((Matrix2 { x_axis, y_axis }, Vector2 { x, y }, 2), (T, T));
+crate::impl_matrix!((Matrix3 { x_axis, y_axis, z_axis }, Vector3 { x, y, z }, 3), (T, T, T));
+crate::impl_matrix!((Matrix4 { x_axis, y_axis, z_axis, w_axis }, Vector4 { x, y, z, w }, 4), (T, T, T, T));
+
+crate::impl_extend!(Matrix2 { x_axis, y_axis }, Matrix3, z_axis);
+crate::impl_extend!(Matrix3 { x_axis, y_axis, z_axis }, Matrix4, w_axis);
+
+crate::impl_matrix_inner!((Matrix2 { x_axis, y_axis }, Vector2 { x, y }, 2), (Vector2 { x, y }, Matrix2 { x_axis, y_axis }, 2), ((T, T), (T, T)) );
+crate::impl_matrix_inner!((Matrix2 { x_axis, y_axis }, Vector2 { x, y }, 2), (Vector3 { x, y, z }, Matrix3 { x_axis, y_axis, z_axis }, 3), ((T, T, T), (T, T, T)) );
+crate::impl_matrix_inner!((Matrix2 { x_axis, y_axis }, Vector2 { x, y }, 2), (Vector4 { x, y, z, w }, Matrix4 { x_axis, y_axis, z_axis, w_axis }, 4), ((T, T, T, T), (T, T, T, T)) );
+crate::impl_matrix_inner!((Matrix3 { x_axis, y_axis, z_axis }, Vector3 { x, y, z }, 3), (Vector2 { x, y }, Matrix2 { x_axis, y_axis }, 2), ((T, T), (T, T), (T, T)) );
+crate::impl_matrix_inner!((Matrix3 { x_axis, y_axis, z_axis }, Vector3 { x, y, z }, 3), (Vector3 { x, y, z }, Matrix3 { x_axis, y_axis, z_axis }, 3), ((T, T, T), (T, T, T), (T, T, T)) );
+crate::impl_matrix_inner!((Matrix3 { x_axis, y_axis, z_axis }, Vector3 { x, y, z }, 3), (Vector4 { x, y, z, w }, Matrix4 { x_axis, y_axis, z_axis, w_axis }, 4), ((T, T, T, T), (T, T, T, T), (T, T, T, T)) );
+crate::impl_matrix_inner!((Matrix4 { x_axis, y_axis, z_axis, w_axis }, Vector4 { x, y, z, w }, 4), (Vector2 { x, y }, Matrix2 { x_axis, y_axis }, 2), ((T, T), (T, T), (T, T), (T, T)) );
+crate::impl_matrix_inner!((Matrix4 { x_axis, y_axis, z_axis, w_axis }, Vector4 { x, y, z, w }, 4), (Vector3 { x, y, z }, Matrix3 { x_axis, y_axis, z_axis }, 3), ((T, T, T), (T, T, T), (T, T, T), (T, T, T)) );
+crate::impl_matrix_inner!((Matrix4 { x_axis, y_axis, z_axis, w_axis }, Vector4 { x, y, z, w }, 4), (Vector4 { x, y, z, w }, Matrix4 { x_axis, y_axis, z_axis, w_axis }, 4), ((T, T, T, T), (T, T, T, T), (T, T, T, T), (T, T, T, T)) );

fixed_wide_vectors/src/tests/fixed_wide_traits.rs

@@ -1,10 +1,10 @@
 use fixed_wide_traits::wide::WideMul;
 use fixed_wide_traits::wide::WideDot;
 
-use crate::Vector3;
+use crate::{Vector2,Vector3,Matrix3};
 
 type Planar64=fixed_wide::types::I32F32;
-//type Planar64Wide1=fixed::types::I64F64;
+type Planar64Wide1=fixed_wide::types::I64F64;
 //type Planar64Wide2=fixed_wide::types::I128F128;
 type Planar64Wide3=fixed_wide::types::I256F256;
 
@@ -49,3 +49,20 @@ fn wide_vec3_length_squared(){
 
 	assert_eq!(v3,Planar64Wide3::from(3i128.pow(8)*3));
 }
+
+#[test]
+fn wide_vec_of_vec_dot(){
+	let vv=Vector3::<Vector2<_>>::from_value_2d(Planar64::from(3));
+	// do the dot product of the inner vectors multiplied component wise
+	// this lowers the rank of the data structure and is kind of a weird operation lol
+	let vv_dot=vv.wide_dot(vv);
+	assert_eq!(vv_dot,Vector2::from_value(Planar64Wide1::from(3i128.pow(3))));
+}
+#[test]
+fn wide_matrix_dot(){
+	let m=Matrix3::<Vector3<_>>::from_value_2d(Planar64::from(3));
+	//normal matrix product
+	todo!()
+	//let m_dot=m.wide_dot(m);
+	//assert_eq!(m_dot,Matrix3::<Vector3<_>>::from_value_2d(Planar64Wide1::from(3i128.pow(2))));
+}

fixed_wide_vectors/src/traits.rs

@@ -1,8 +0,0 @@
-pub trait Dot<Rhs=Self>{
-	type Output;
-	fn dot(self,rhs:Rhs)->Self::Output;
-}
-pub trait Transpose{
-	type Output;
-	fn transpose(self)->Self::Output;
-}

fixed_wide_vectors/src/vector.rs

@@ -67,7 +67,15 @@ crate::impl_vector!(Vector2 { x, y }, (T, T), 2);
 crate::impl_vector!(Vector3 { x, y, z }, (T, T, T), 3);
 crate::impl_vector!(Vector4 { x, y, z, w }, (T, T, T, T), 4);
 
-//This internally implements non square matrices, idk how else to separate the repeated fields
-crate::impl_matrix!(Vector2 { x, y }, 2);
-crate::impl_matrix!(Vector3 { x, y, z }, 3);
-crate::impl_matrix!(Vector4 { x, y, z, w }, 4);
+crate::impl_extend!(Vector2 { x, y }, Vector3, z);
+crate::impl_extend!(Vector3 { x, y, z }, Vector4, w);
+
+crate::impl_matrix_inner!((Vector2 { x, y }, Vector2 { x, y }, 2), (Vector2 { x, y }, Vector2 { x, y }, 2), ((T, T), (T, T)) );
+crate::impl_matrix_inner!((Vector2 { x, y }, Vector2 { x, y }, 2), (Vector3 { x, y, z }, Vector3 { x, y, z }, 3), ((T, T, T), (T, T, T)) );
+crate::impl_matrix_inner!((Vector2 { x, y }, Vector2 { x, y }, 2), (Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), ((T, T, T, T), (T, T, T, T)) );
+crate::impl_matrix_inner!((Vector3 { x, y, z }, Vector3 { x, y, z }, 3), (Vector2 { x, y }, Vector2 { x, y }, 2), ((T, T), (T, T), (T, T)) );
+crate::impl_matrix_inner!((Vector3 { x, y, z }, Vector3 { x, y, z }, 3), (Vector3 { x, y, z }, Vector3 { x, y, z }, 3), ((T, T, T), (T, T, T), (T, T, T)) );
+crate::impl_matrix_inner!((Vector3 { x, y, z }, Vector3 { x, y, z }, 3), (Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), ((T, T, T, T), (T, T, T, T), (T, T, T, T)) );
+crate::impl_matrix_inner!((Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), (Vector2 { x, y }, Vector2 { x, y }, 2), ((T, T), (T, T), (T, T), (T, T)) );
+crate::impl_matrix_inner!((Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), (Vector3 { x, y, z }, Vector3 { x, y, z }, 3), ((T, T, T), (T, T, T), (T, T, T), (T, T, T)) );
+crate::impl_matrix_inner!((Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), (Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), ((T, T, T, T), (T, T, T, T), (T, T, T, T), (T, T, T, T)) );