Divide trait wip

fixed_wide/Cargo.lock

@@ -21,6 +21,7 @@ dependencies = [
  "arrayvec",
  "bnum",
  "paste",
+ "ratio_ops",
 ]
 
 [[package]]
@@ -28,3 +29,7 @@ name = "paste"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "ratio_ops"
+version = "0.1.0"

fixed_wide/Cargo.toml

@@ -4,11 +4,13 @@ version = "0.1.0"
 edition = "2021"
 
 [features]
-default=["zeroes"]
-ratio=[]
-zeroes=["ratio","dep:arrayvec"]
+default=[]
+deferred-division=["dep:ratio_ops"]
+wide-mul=[]
+zeroes=["dep:arrayvec"]
 
 [dependencies]
 bnum = "0.11.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
+ratio_ops = { path = "../ratio_ops", optional = true }

fixed_wide/src/fixed.rs

@@ -1,6 +1,7 @@
 use bnum::{BInt,cast::As};
 
 #[derive(Clone,Copy,Debug,Hash)]
+/// A Fixed point number for which multiply operations widen the bits in the output. (when the wide-mul feature is enabled)
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
 pub struct Fixed<const N:usize,const F:usize>{
@@ -32,6 +33,17 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 		self.bits
 	}
 	#[inline]
+	pub const fn raw_digit(value:i64)->Self{
+		let mut digits=[0u64;N];
+		digits[0]=value.abs() as u64;
+		//sign bit
+		digits[N-1]|=(value&i64::MIN) as u64;
+		Self::from_bits(BInt::from_bits(bnum::BUint::from_digits(digits)))
+	}
+}
+impl<const F:usize> Fixed<1,F>{
+	/// My old code called this function everywhere so let's provide it
+	#[inline]
 	pub const fn raw(value:i64)->Self{
 		Self::from_bits(BInt::from_bits(bnum::BUint::from_digit(value as u64)))
 	}
@@ -41,24 +53,48 @@ impl<const N:usize,const F:usize,T> From<T> for Fixed<N,F>
 	where
 		BInt<N>:From<T>
 {
+	#[inline]
 	fn from(value:T)->Self{
 		Self::from_bits(BInt::<{N}>::from(value)<<F as u32)
 	}
 }
 
 impl<const N:usize,const F:usize> PartialEq for Fixed<N,F>{
+	#[inline]
 	fn eq(&self,other:&Self)->bool{
 		self.bits.eq(&other.bits)
 	}
 }
+impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
+where
+		T:Copy,
+		BInt::<N>:From<T>,
+{
+	#[inline]
+	fn eq(&self,&other:&T)->bool{
+		self.bits.eq(&other.into())
+	}
+}
 impl<const N:usize,const F:usize> Eq for Fixed<N,F>{}
 
 impl<const N:usize,const F:usize> PartialOrd for Fixed<N,F>{
+	#[inline]
 	fn partial_cmp(&self,other:&Self)->Option<std::cmp::Ordering>{
 		self.bits.partial_cmp(&other.bits)
 	}
 }
+impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
+	where
+		T:Copy,
+		BInt::<N>:From<T>,
+{
+	#[inline]
+	fn partial_cmp(&self,&other:&T)->Option<std::cmp::Ordering>{
+		self.bits.partial_cmp(&other.into())
+	}
+}
 impl<const N:usize,const F:usize> Ord for Fixed<N,F>{
+	#[inline]
 	fn cmp(&self,other:&Self)->std::cmp::Ordering{
 		self.bits.cmp(&other.bits)
 	}
@@ -66,18 +102,69 @@ impl<const N:usize,const F:usize> Ord for Fixed<N,F>{
 
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;
+	#[inline]
 	fn neg(self)->Self{
 		Self::from_bits(self.bits.neg())
 	}
 }
+impl<const N:usize,const F:usize> std::iter::Sum for Fixed<N,F>{
+	#[inline]
+	fn sum<I:Iterator<Item=Self>>(iter:I)->Self{
+		let mut sum=Self::ZERO;
+		for elem in iter{
+			sum+=elem;
+		}
+		sum
+	}
+}
+
+macro_rules! impl_into_float {
+	( $output: ty ) => {
+		impl<const N:usize,const F:usize> Into<$output> for Fixed<N,F>{
+			#[inline]
+			fn into(self)->$output{
+				let mut total=0.0;
+				let bits=self.bits.to_bits();
+				let digits=bits.digits();
+				for (i,digit) in digits[0..N-1].iter().enumerate(){
+					// (i*64-F) as i32 will interpret the highest order bit as a sign bit but whatever
+					total+=(*digit as $output)*(2.0 as $output).powi((i*64-F) as i32);
+				}
+				//most significant digit holds the sign bit
+				//assume we are using a number with at least 1 digit...
+				total+=((*digits.last().unwrap() as i64).abs() as $output)*(2.0 as $output).powi(((N-1)*64-F) as i32);
+				if self.bits.is_negative(){
+					total=-total;
+				}
+				total
+			}
+		}
+	}
+}
+impl_into_float!(f32);
+impl_into_float!(f64);
+
+impl<const N:usize,const F:usize> core::fmt::Display for Fixed<N,F>{
+	#[inline]
+	fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
+		let float:f32=(*self).into();
+		core::write!(f,"{:.3}",float)
+	}
+}
 
 macro_rules! impl_additive_operator {
 	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
+		impl<const N:usize,const F:usize> $struct<N,F>{
+			#[inline]
+			pub const fn $method(self, other: Self) -> Self {
+				Self::from_bits(self.bits.$method(other.bits))
+			}
+		}
 		impl<const N:usize,const F:usize> core::ops::$trait for $struct<N,F>{
 			type Output = $output;
-
+			#[inline]
 			fn $method(self, other: Self) -> Self::Output {
-				Self::from_bits(self.bits.$method(other.bits))
+				self.$method(other)
 			}
 		}
 		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
@@ -85,7 +172,7 @@ macro_rules! impl_additive_operator {
 				BInt::<N>:From<U>,
 		{
 			type Output = $output;
-
+			#[inline]
 			fn $method(self, other: U) -> Self::Output {
 				Self::from_bits(self.bits.$method(BInt::<N>::from(other).shl(F as u32)))
 			}
@@ -95,6 +182,7 @@ macro_rules! impl_additive_operator {
 macro_rules! impl_additive_assign_operator {
 	( $struct: ident, $trait: ident, $method: ident ) => {
 		impl<const N:usize,const F:usize> core::ops::$trait for $struct<N,F>{
+			#[inline]
 			fn $method(&mut self, other: Self) {
 				self.bits.$method(other.bits);
 			}
@@ -103,8 +191,9 @@ macro_rules! impl_additive_assign_operator {
 		where
 				BInt::<N>:From<U>,
 		{
+			#[inline]
 			fn $method(&mut self, other: U) {
-				self.bits.$method(BInt::<N>::from(other)<<F as u32);
+				self.bits.$method(BInt::<N>::from(other).shl(F as u32));
 			}
 		}
 	};
@@ -126,146 +215,138 @@ 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 ) => {
+// non-wide operators.  The result is the same width as the inputs.
+
+// This macro is not used in the default configuration.
+#[allow(unused_macros)]
+macro_rules! impl_multiplicative_operator_not_const_generic {
+	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
 			type Output = $output;
-
+			#[inline]
 			fn $method(self, other: Self) -> Self::Output {
-				//this can be done better but that is a job for later
+				paste::item!{
+				self.[<fixed_ $method>](other)
+				}
+			}
+		}
+	};
+}
+macro_rules! impl_multiplicative_assign_operator_not_const_generic {
+	( ($struct: ident, $trait: ident, $method: ident, $non_assign_method: ident ), $width:expr ) => {
+		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
+			#[inline]
+			fn $method(&mut self, other: Self) {
+				paste::item!{
+				*self=self.[<fixed_ $non_assign_method>](other);
+				}
+			}
+		}
+	};
+}
+
+macro_rules! impl_multiply_operator_not_const_generic {
+	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
+		impl<const F:usize> $struct<$width,F>{
+			paste::item!{
+			#[inline]
+			pub fn [<fixed_ $method>](self, other: Self) -> Self {
 				let lhs=self.bits.as_::<BInt::<{$width*2}>>();
 				let rhs=other.bits.as_::<BInt::<{$width*2}>>();
 				Self::from_bits(lhs.mul(rhs).shr(F as u32).as_())
 			}
-		}
-	};
-}
-macro_rules! impl_multiply_assign_operator_const {
-	( $width:expr, $struct: ident, $trait: ident, $method: ident ) => {
-		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
-			fn $method(&mut self, other: Self) {
-				self.bits.$method(other.bits);
 			}
 		}
-	};
+		#[cfg(not(feature="wide-mul"))]
+		impl_multiplicative_operator_not_const_generic!(($struct, $trait, $method, $output ), $width);
+	}
 }
-
-macro_rules! impl_divide_operator_const {
-	( $width:expr, $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
-		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
-			type Output = $output;
-
-			fn $method(self, other: Self) -> Self::Output {
-				//this can be done better but that is a job for later
+macro_rules! impl_divide_operator_not_const_generic {
+	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
+		impl<const F:usize> $struct<$width,F>{
+			paste::item!{
+			#[inline]
+			pub fn [<fixed_ $method>](self, other: Self) -> Self {
 				//this only needs to be $width+F as u32/64+1 but MUH CONST GENERICS!!!!!
 				let lhs=self.bits.as_::<BInt::<{$width*2}>>().shl(F as 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<const F:usize> core::ops::$trait for $struct<$width,F>{
-			fn $method(&mut self, other: Self) {
-				self.bits.$method(other.bits);
 			}
 		}
+		#[cfg(all(not(feature="wide-mul"),not(feature="deferred-division")))]
+		impl_multiplicative_operator_not_const_generic!(($struct, $trait, $method, $output ), $width);
 	};
 }
 
-macro_rules! impl_multiplicatave_operator {
+macro_rules! impl_multiplicative_operator {
 	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
 		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
 			where
 				BInt::<N>:From<U>+core::ops::$trait,
 		{
 			type Output = $output;
-
+			#[inline]
 			fn $method(self, other: U) -> Self::Output {
 				Self::from_bits(self.bits.$method(BInt::<N>::from(other)))
 			}
 		}
 	};
 }
-macro_rules! impl_multiplicatave_assign_operator {
+macro_rules! impl_multiplicative_assign_operator {
 	( $struct: ident, $trait: ident, $method: ident ) => {
 		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
 			where
 				BInt::<N>:From<U>+core::ops::$trait,
 		{
+			#[inline]
 			fn $method(&mut self, other: U) {
 				self.bits.$method(BInt::<N>::from(other));
 			}
 		}
 	};
 }
-impl<const N:usize,const F:usize> std::iter::Sum for Fixed<N,F>{
-	fn sum<I:Iterator<Item=Self>>(iter:I)->Self{
-		let mut sum=Self::ZERO;
-		for elem in iter{
-			sum+=elem;
-		}
-		sum
+
+macro_rules! macro_repeated{
+	(
+		$macro:ident,
+		$any:tt,
+		$($repeated:tt),*
+	)=>{
+		$(
+			$macro!($any, $repeated);
+		)*
+	};
+}
+
+macro_rules! macro_16 {
+	( $macro: ident, $any:tt ) => {
+		macro_repeated!($macro,$any,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
 	}
 }
 
-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_16!( impl_multiplicative_assign_operator_not_const_generic, (Fixed, MulAssign, mul_assign, mul) );
+macro_16!( impl_multiply_operator_not_const_generic, (Fixed, Mul, mul, Self) );
+macro_16!( impl_multiplicative_assign_operator_not_const_generic, (Fixed, DivAssign, div_assign, div) );
+macro_16!( impl_divide_operator_not_const_generic, (Fixed, Div, div, Self) );
+impl_multiplicative_assign_operator!( Fixed, MulAssign, mul_assign );
+impl_multiplicative_operator!( Fixed, Mul, mul, Self );
+impl_multiplicative_assign_operator!( Fixed, DivAssign, div_assign );
+impl_multiplicative_operator!( Fixed, Div, div, Self );
+#[cfg(feature="deferred-division")]
+impl<const LHS_N:usize,const LHS_F:usize,const RHS_N:usize,const RHS_F:usize> core::ops::Div<Fixed<RHS_N,RHS_F>> for Fixed<LHS_N,LHS_F>{
+	type Output=ratio_ops::ratio::Ratio<Fixed<LHS_N,LHS_F>,Fixed<RHS_N,RHS_F>>;
+	#[inline]
+	fn div(self, other: Fixed<RHS_N,RHS_F>)->Self::Output{
+		ratio_ops::ratio::Ratio::new(self,other)
 	}
 }
-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 N:usize,const F:usize> core::ops::$trait<u32> for $struct<N,F>{
 			type Output = $output;
-
+			#[inline]
 			fn $method(self, other: u32) -> Self::Output {
 				Self::from_bits(self.bits.$method(other))
 			}
@@ -275,6 +356,7 @@ macro_rules! impl_shift_operator {
 macro_rules! impl_shift_assign_operator {
 	( $struct: ident, $trait: ident, $method: ident ) => {
 		impl<const N:usize,const F:usize> core::ops::$trait<u32> for $struct<N,F>{
+			#[inline]
 			fn $method(&mut self, other: u32) {
 				self.bits.$method(other);
 			}
@@ -286,56 +368,103 @@ impl_shift_operator!( Fixed, Shl, shl, Self );
 impl_shift_assign_operator!( Fixed, ShrAssign, shr_assign );
 impl_shift_operator!( Fixed, Shr, shr, Self );
 
-// WIDE MUL: multiply into a wider type
-// let a = I32F32::ONE;
-// let b:I64F64 = a.wide_mul(a);
-macro_rules! impl_wide_mul{
+// wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
+
+macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
-				pub fn [<wide_mul_ $lhs _ $rhs>](self,rhs:Fixed<$rhs,{$rhs*32}>)->Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>{
-					Fixed::from_bits(self.bits.as_::<BInt<{$lhs+$rhs}>>()*rhs.bits.as_::<BInt<{$lhs+$rhs}>>())
+		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+			type Output=Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>;
+			#[inline]
+			fn mul(self, other: Fixed<$rhs,{$rhs*32}>)->Self::Output{
+				paste::item!{
+				self.[<wide_mul_ $lhs _ $rhs>](other)
 				}
 			}
 		}
-	};
+		#[cfg(not(feature="deferred-division"))]
+		impl core::ops::Div<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+			type Output=Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>;
+			#[inline]
+			fn div(self, other: Fixed<$rhs,{$rhs*32}>)->Self::Output{
+				paste::item!{
+				self.[<wide_div_ $lhs _ $rhs>](other)
+				}
+			}
+		}
+	}
 }
 
-macro_rules! impl_wide_mul_all{
-	($(($x:expr, $y:expr)),*)=>{
-		$(
-			impl_wide_mul!($x, $y);
-		)*
+// WIDE MUL: multiply into a wider type
+// let a = I32F32::ONE;
+// let b:I64F64 = a.wide_mul(a);
+macro_rules! impl_wide_not_const_generic{
+	(
+		(),
+		($lhs:expr,$rhs:expr)
+	)=>{
+		impl Fixed<$lhs,{$lhs*32}>
+		{
+			paste::item!{
+				#[inline]
+				pub fn [<wide_mul_ $lhs _ $rhs>](self,rhs:Fixed<$rhs,{$rhs*32}>)->Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>{
+					let lhs=self.bits.as_::<BInt<{$lhs+$rhs}>>();
+					let rhs=rhs.bits.as_::<BInt<{$lhs+$rhs}>>();
+					Fixed::from_bits(lhs*rhs)
+				}
+				/// This operation cannot represent the fraction exactly,
+				/// but it shapes the output to have precision for the
+				/// largest and smallest possible fractions.
+				#[inline]
+				pub fn [<wide_div_ $lhs _ $rhs>](self,rhs:Fixed<$rhs,{$rhs*32}>)->Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>{
+					// (lhs/2^LHS_FRAC)/(rhs/2^RHS_FRAC)
+					let lhs=self.bits.as_::<BInt<{$lhs+$rhs}>>().shl($rhs*64);
+					let rhs=rhs.bits.as_::<BInt<{$lhs+$rhs}>>();
+					Fixed::from_bits(lhs/rhs)
+				}
+			}
+		}
+		#[cfg(feature="wide-mul")]
+		impl_wide_operators!($lhs,$rhs);
 	};
 }
 
 //const generics sidestepped wahoo
-impl_wide_mul_all!(
-	(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),
-	(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),
-	(1,3),(2,3),(3,3),(4,3),(5,3),(6,3),(7,3),(8,3),
-	(1,4),(2,4),(3,4),(4,4),(5,4),(6,4),(7,4),(8,4),
-	(1,5),(2,5),(3,5),(4,5),(5,5),(6,5),(7,5),(8,5),
-	(1,6),(2,6),(3,6),(4,6),(5,6),(6,6),(7,6),(8,6),
-	(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)
+macro_repeated!(
+	impl_wide_not_const_generic,(),
+	(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),
+	(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),
+	(1,3),(2,3),(3,3),(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),
+	(1,4),(2,4),(3,4),(4,4),(5,4),(6,4),(7,4),(8,4),(9,4),(10,4),(11,4),(12,4),
+	(1,5),(2,5),(3,5),(4,5),(5,5),(6,5),(7,5),(8,5),(9,5),(10,5),(11,5),
+	(1,6),(2,6),(3,6),(4,6),(5,6),(6,6),(7,6),(8,6),(9,6),(10,6),
+	(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),(7,7),(8,7),(9,7),
+	(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),(8,8),
+	(1,9),(2,9),(3,9),(4,9),(5,9),(6,9),(7,9),
+	(1,10),(2,10),(3,10),(4,10),(5,10),(6,10),
+	(1,11),(2,11),(3,11),(4,11),(5,11),
+	(1,12),(2,12),(3,12),(4,12),
+	(1,13),(2,13),(3,13),
+	(1,14),(2,14),
+	(1,15)
 );
 impl<const SRC:usize,const F:usize> Fixed<SRC,F>{
+	#[inline]
 	pub fn resize_into<const DST:usize>(self)->Fixed<DST,F>{
 		Fixed::from_bits(self.bits.as_::<BInt<DST>>())
 	}
 }
 
-macro_rules! impl_const{
+macro_rules! impl_not_const_generic{
 	($n:expr)=>{
 		impl Fixed<{$n*2},{$n*2*32}>{
+			#[inline]
 			pub fn halve_precision(self)->Fixed<$n,{$n*32}>{
 				Fixed::from_bits(bnum::cast::As::as_(self.bits.shr($n*32)))
 			}
 		}
 		impl Fixed<$n,{$n*32}>{
 			paste::item!{
+			#[inline]
 			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:
@@ -348,17 +477,19 @@ macro_rules! impl_const{
 				let mut result=Self::ZERO;
 
 				//multiply by one to make the types match (hack)
-				let wide_self=self.[<wide_mul_ $n _ $n>](Self::ONE);
+				//TODO: use resize method
+				let wide_self:<Self as core::ops::Mul>::Output=self*Self::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|Self::from_bits(BInt::from_bits(bnum::BUint::power_of_two(shift)));
-					if new_result.[<wide_mul_ $n _ $n>](new_result)<=wide_self{
+					if new_result*new_result<=wide_self{
 						result=new_result;
 					}
 				}
 				result
 			}
 			}
+			#[inline]
 			pub fn sqrt(self)->Self{
 				if self<Self::ZERO{
 					panic!("Square root less than zero")
@@ -366,6 +497,7 @@ macro_rules! impl_const{
 					self.sqrt_unchecked()
 				}
 			}
+			#[inline]
 			pub fn sqrt_checked(self)->Option<Self>{
 				if self<Self::ZERO{
 					None
@@ -376,11 +508,11 @@ macro_rules! impl_const{
 		}
 	}
 }
-impl_const!(1);
-impl_const!(2);
-impl_const!(3);
-impl_const!(4);
-impl_const!(5);
-impl_const!(6);
-impl_const!(7);
-impl_const!(8);
+impl_not_const_generic!(1);
+impl_not_const_generic!(2);
+impl_not_const_generic!(3);
+impl_not_const_generic!(4);
+impl_not_const_generic!(5);
+impl_not_const_generic!(6);
+impl_not_const_generic!(7);
+impl_not_const_generic!(8);

fixed_wide/src/lib.rs

@@ -3,8 +3,6 @@ pub mod types;
 
 #[cfg(feature="zeroes")]
 pub mod zeroes;
-#[cfg(feature="ratio")]
-pub mod ratio;
 
 #[cfg(test)]
 mod tests;

fixed_wide/src/ratio.rs

@@ -1,10 +0,0 @@
-#[derive(Clone,Copy,Debug,Hash)]
-pub struct Ratio<Num,Den>{
-	pub(crate)num:Num,
-	pub(crate)den:Den,
-}
-impl<Num,Den> Ratio<Num,Den>{
-	pub const fn new(num:Num,den:Den)->Self{
-		Self{num,den}
-	}
-}

fixed_wide/src/tests.rs

@@ -20,6 +20,20 @@ fn test_wide_mul(){
 	assert_eq!(aa,crate::types::I64F64::ONE);
 }
 
+#[test]
+fn test_wide_div(){
+	let a=I32F32::ONE*4;
+	let b=I32F32::ONE*2;
+	let wide_a=a.wide_mul_1_1(I32F32::ONE);
+	let wide_b=b.wide_mul_1_1(I32F32::ONE);
+	let ab=a.wide_div_1_1(b);
+	assert_eq!(ab,crate::types::I64F64::ONE*2);
+	let wab=wide_a.wide_div_2_1(b);
+	assert_eq!(wab,crate::fixed::Fixed::<3,96>::ONE*2);
+	let awb=a.wide_div_1_2(wide_b);
+	assert_eq!(awb,crate::fixed::Fixed::<3,96>::ONE*2);
+}
+
 #[test]
 fn test_wide_mul_repeated() {
 	let a=I32F32::from(2);
@@ -51,7 +65,7 @@ fn test_sqrt_zero(){
 #[test]
 fn test_sqrt_low(){
 	let a=I32F32::HALF;
-	let b=a*a;
+	let b=a.fixed_mul(a);
 	assert_eq!(b.sqrt(),a);
 }
 fn find_equiv_sqrt_via_f64(n:I32F32)->I32F32{

fixed_wide/src/zeroes.rs

@@ -1,5 +1,4 @@
 use crate::fixed::Fixed;
-use crate::ratio::Ratio;
 
 use arrayvec::ArrayVec;
 use std::cmp::Ordering;
@@ -7,36 +6,38 @@ macro_rules! impl_zeroes{
 	($n:expr)=>{
 		impl Fixed<$n,{$n*32}>{
 			#[inline]
-			pub fn zeroes2(a0:Self,a1:Self,a2:Self)->ArrayVec<Ratio<Self,Self>,2>{
+			pub fn zeroes2(a0:Self,a1:Self,a2:Self)->ArrayVec<<Self as core::ops::Div>::Output,2>{
 				let a2pos=match a2.cmp(&Self::ZERO){
 					Ordering::Greater=>true,
 					Ordering::Equal=>return ArrayVec::from_iter(Self::zeroes1(a0,a1).into_iter()),
 					Ordering::Less=>true,
 				};
 				paste::item!{
-				let radicand=a1.[<wide_mul_ $n _ $n>](a1)-a2.[<wide_mul_ $n _ $n>](a0)*4;
+				let radicand=a1*a1-a2*a0*4;
 				}
-				match radicand.cmp(&Fixed::<{$n*2},{$n*2*32}>::ZERO){
+				match radicand.cmp(&<Self as core::ops::Mul>::Output::ZERO){
 					Ordering::Greater=>{
-						let planar_radicand=radicand.sqrt().halve_precision();
+						//TODO: use resize method
+						let planar_radicand:Self=radicand.sqrt().halve_precision();
 						//sort roots ascending and avoid taking the difference of large numbers
-						match (a2pos,Self::ZERO<a1){
-							(true, true )=>[Ratio::new(-a1-planar_radicand,a2*2),Ratio::new(a0*2,-a1-planar_radicand)].into(),
-							(true, false)=>[Ratio::new(a0*2,-a1+planar_radicand),Ratio::new(-a1+planar_radicand,a2*2)].into(),
-							(false,true )=>[Ratio::new(a0*2,-a1-planar_radicand),Ratio::new(-a1-planar_radicand,a2*2)].into(),
-							(false,false)=>[Ratio::new(-a1+planar_radicand,a2*2),Ratio::new(a0*2,-a1+planar_radicand)].into(),
-						}
+						let zeroes=match (a2pos,Self::ZERO<a1){
+							(true, true )=>[(-a1-planar_radicand)/(a2*2),(a0*2)/(-a1-planar_radicand)],
+							(true, false)=>[(a0*2)/(-a1+planar_radicand),(-a1+planar_radicand)/(a2*2)],
+							(false,true )=>[(a0*2)/(-a1-planar_radicand),(-a1-planar_radicand)/(a2*2)],
+							(false,false)=>[(-a1+planar_radicand)/(a2*2),(a0*2)/(-a1+planar_radicand)],
+						};
+						ArrayVec::from_iter(zeroes)
 					},
-					Ordering::Equal=>ArrayVec::from_iter([Ratio::new(a1,a2*-2)]),
+					Ordering::Equal=>ArrayVec::from_iter([(a1)/(a2*-2)]),
 					Ordering::Less=>ArrayVec::new_const(),
 				}
 			}
 			#[inline]
-			pub fn zeroes1(a0:Self,a1:Self)->ArrayVec<Ratio<Self,Self>,1>{
+			pub fn zeroes1(a0:Self,a1:Self)->ArrayVec<<Self as core::ops::Div>::Output,1>{
 				if a1==Self::ZERO{
 					ArrayVec::new_const()
 				}else{
-					ArrayVec::from_iter([Ratio::new(-a0,a1)])
+					ArrayVec::from_iter([(-a0)/(a1)])
 				}
 			}
 		}

fixed_wide_vectors/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "fixed_wide_vectors"
-version = "0.1.0"
-edition = "2021"
-
-[features]
-default=["fixed_wide","named-fields"]
-named-fields=[]
-fixed_wide=["dep:fixed_wide","dep:paste"]
-
-[dependencies]
-fixed_wide = { version = "0.1.0", path = "../fixed_wide", optional = true }
-paste = { version = "1.0.15", optional = true }

fixed_wide_vectors/src/macros/fixed_wide.rs

@@ -1,212 +0,0 @@
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_wide_vector_operations_2arg_not_const_generic {
-	(
-		(),
-		($lhs:expr, $rhs:expr)
-	) => {
-		impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<{$lhs},{$lhs*32}>>{
-			paste::item!{
-			#[inline]
-			pub fn [<wide_mul_ $lhs _ $rhs>](self,rhs:Vector<N,fixed_wide::fixed::Fixed<{$rhs},{$rhs*32}>>)->Vector<N,fixed_wide::fixed::Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>>{
-				self.map_zip(rhs,|(a,b)|a.[<wide_mul_ $lhs _ $rhs>](b))
-			}
-			#[inline]
-			pub fn [<wide_dot_ $lhs _ $rhs>](self,rhs:Vector<N,fixed_wide::fixed::Fixed<{$rhs},{$rhs*32}>>)->fixed_wide::fixed::Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>{
-				self.array.into_iter().zip(rhs.array).map(|(a,b)|a.[<wide_mul_ $lhs _ $rhs>](b)).sum()
-			}
-			}
-		}
-	}
-}
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_wide_vector_operations_1arg_not_const_generic {
-	(
-		(),
-		$n:expr
-	) => {
-		impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<{$n},{$n*32}>>{
-			paste::item!{
-			#[inline]
-			pub fn wide_length_squared(&self)->fixed_wide::fixed::Fixed<{$n*2},{$n*2*32}>{
-				self.array.into_iter().map(|t|t.[<wide_mul_ $n _ $n>](t)).sum()
-			}
-			}
-		}
-	};
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! do_macro_8x8{
-	(
-		$macro:ident,
-		$any:tt
-	)=>{
-		$crate::macro_repeated!($macro, $any,
-			(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),
-			(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),
-			(1,3),(2,3),(3,3),(4,3),(5,3),(6,3),(7,3),(8,3),
-			(1,4),(2,4),(3,4),(4,4),(5,4),(6,4),(7,4),(8,4),
-			(1,5),(2,5),(3,5),(4,5),(5,5),(6,5),(7,5),(8,5),
-			(1,6),(2,6),(3,6),(4,6),(5,6),(6,6),(7,6),(8,6),
-			(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)
-		);
-	};
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! do_macro_8{
-	(
-		$macro:ident,
-		$any:tt
-	)=>{
-		$crate::macro_repeated!($macro, $any, 1,2,3,4,5,6,7,8);
-	};
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_wide_vector_operations {
-	() => {
-		$crate::do_macro_8!(impl_wide_vector_operations_1arg_not_const_generic,());
-		$crate::do_macro_8x8!(impl_wide_vector_operations_2arg_not_const_generic,());
-	};
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector_3_wide_cross {
-	(
-		(),
-		($lhs:expr, $rhs:expr)
-	)=>{
-		impl Vector<3,fixed_wide::fixed::Fixed<{$lhs},{$lhs*32}>>{
-			paste::item!{
-			#[inline]
-			pub fn [<wide_cross_ $lhs _ $rhs>](self,rhs:Vector<3,fixed_wide::fixed::Fixed<{$rhs},{$rhs*32}>>)->Vector<3,fixed_wide::fixed::Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>>{
-				Vector::new([
-					self.y.[<wide_mul_ $lhs _ $rhs>](rhs.z)-self.z.[<wide_mul_ $lhs _ $rhs>](rhs.y),
-					self.z.[<wide_mul_ $lhs _ $rhs>](rhs.x)-self.x.[<wide_mul_ $lhs _ $rhs>](rhs.z),
-					self.x.[<wide_mul_ $lhs _ $rhs>](rhs.y)-self.y.[<wide_mul_ $lhs _ $rhs>](rhs.x),
-				])
-			}
-			}
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector_wide_3 {
-	()=>{
-		$crate::do_macro_8x8!(impl_vector_3_wide_cross,());
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! do_macro_4_dumb{
-	(
-		$macro:ident,
-		$any:tt
-	)=>{
-		$crate::macro_repeated!($macro, $any, (1,2),(2,4),(3,6),(4,8));
-	};
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_dot {
-	(
-		(),
-		($lhs: expr, $rhs: expr)
-	) => {
-		impl<const X:usize,const Y:usize> Matrix<X,Y,fixed_wide::fixed::Fixed<{$lhs},{$lhs*32}>>{
-			paste::item!{
-			#[inline]
-			pub fn [<wide_dot_ $lhs _ $rhs>]<const Z:usize>(self,rhs:Matrix<Z,X,fixed_wide::fixed::Fixed<{$rhs},{$rhs*32}>>)->Matrix<Z,Y,fixed_wide::fixed::Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>>{
-				let mut array_of_iterators=rhs.array.map(|axis|axis.into_iter().cycle());
-					Matrix::new(
-						self.array.map(|axis|
-							core::array::from_fn(|_|
-								// axis dot product with transposed rhs array
-								axis.iter().zip(
-									array_of_iterators.iter_mut()
-								).map(|(&lhs_value,rhs_iter)|
-									lhs_value.[<wide_mul_ $lhs _ $rhs>](rhs_iter.next().unwrap())
-								).sum()
-							)
-						)
-					)
-			}
-			}
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_dot_8x8 {
-	() => {
-		$crate::do_macro_8x8!(impl_matrix_wide_dot,());
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_3x3_det_not_const_generic {
-	(
-		$n: expr,
-		$_2n: expr
-	)=>{
-		impl Matrix<3,3,fixed_wide::fixed::Fixed<$n,{$n*32}>>{
-			paste::item!{
-			pub fn [<wide_det_3x3_ $n>](self)->fixed_wide::fixed::Fixed<{$n*3},{$n*3*32}>{
-				//[<wide_dot_ $n _ $n*2>] will not compile, so the doubles are hardcoded above
-				self.x_axis.[<wide_dot_ $n _ $_2n>](self.y_axis.[<wide_cross_ $n _ $n>](self.z_axis))
-			}
-			}
-		}
-	}
-}
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_3x3_det_not_const_generic_shim {
-	(
-		(),($n: expr,$_2n: expr)
-	)=>{
-		$crate::impl_matrix_wide_3x3_det_not_const_generic!($n,$_2n);
-	}
-}
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_3x3_adjugate_not_const_generic {
-	(
-		(),
-		$n: expr
-	)=>{
-		impl Matrix<3,3,fixed_wide::fixed::Fixed<$n,{$n*32}>>{
-			paste::item!{
-			pub fn [<wide_adjugate_3x3_ $n>](self)->Matrix<3,3,fixed_wide::fixed::Fixed<{$n*2},{$n*2*32}>>{
-				Matrix::new([
-					[self.y_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.z)-self.y_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.y),self.x_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.y)-self.x_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.z),self.x_axis.y.[<wide_mul_ $n _ $n>](self.y_axis.z)-self.x_axis.z.[<wide_mul_ $n _ $n>](self.y_axis.y)],
-					[self.y_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.x)-self.y_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.z),self.x_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.z)-self.x_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.x),self.x_axis.z.[<wide_mul_ $n _ $n>](self.y_axis.x)-self.x_axis.x.[<wide_mul_ $n _ $n>](self.y_axis.z)],
-					[self.y_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.y)-self.y_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.x),self.x_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.x)-self.x_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.y),self.x_axis.x.[<wide_mul_ $n _ $n>](self.y_axis.y)-self.x_axis.y.[<wide_mul_ $n _ $n>](self.y_axis.x)],
-				])
-			}
-			}
-		}
-	}
-}
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_3x3 {
-	()=>{
-		$crate::do_macro_4_dumb!(impl_matrix_wide_3x3_det_not_const_generic_shim,());
-		$crate::do_macro_8!(impl_matrix_wide_3x3_adjugate_not_const_generic,());
-	}
-}

fixed_wide_vectors/src/macros/matrix.rs

@@ -1,129 +0,0 @@
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix {
-	() => {
-		impl<const X:usize,const Y:usize,T> Matrix<X,Y,T>{
-			#[inline(always)]
-			pub const fn new(array:[[T;X];Y])->Self{
-				Self{array}
-			}
-			#[inline(always)]
-			pub fn to_array(self)->[[T;X];Y]{
-				self.array
-			}
-			#[inline]
-			pub fn map<F,U>(self,f:F)->Matrix<X,Y,U>
-			where
-				F:Fn(T)->U
-			{
-				Matrix::new(
-					self.array.map(|inner|inner.map(&f)),
-				)
-			}
-			#[inline]
-			pub fn transpose(self)->Matrix<Y,X,T>{
-				//how did I think of this
-				let mut array_of_iterators=self.array.map(|axis|axis.into_iter());
-				Matrix::new(
-					core::array::from_fn(|_|
-						array_of_iterators.each_mut().map(|iter|
-							iter.next().unwrap()
-						)
-					)
-				)
-			}
-			#[inline]
-			// MatY<VecX>.MatX<VecZ> = MatY<VecZ>
-			pub fn dot<const Z:usize,U,V>(self,rhs:Matrix<Z,X,U>)->Matrix<Z,Y,V>
-			where
-				T:core::ops::Mul<U,Output=V>+Copy,
-				V:core::iter::Sum,
-				U:Copy,
-			{
-				let mut array_of_iterators=rhs.array.map(|axis|axis.into_iter().cycle());
-				Matrix::new(
-					self.array.map(|axis|
-						core::array::from_fn(|_|
-							// axis dot product with transposed rhs array
-							axis.iter().zip(
-								array_of_iterators.iter_mut()
-							).map(|(&lhs_value,rhs_iter)|
-								lhs_value*rhs_iter.next().unwrap()
-							).sum()
-						)
-					)
-				)
-			}
-		}
-		impl<const X:usize,const Y:usize,T> Matrix<X,Y,T>
-		where
-			T:Copy
-		{
-			pub const fn from_value(value:T)->Self{
-				Self::new([[value;X];Y])
-			}
-		}
-
-		impl<const X:usize,const Y:usize,T:Default> Default for Matrix<X,Y,T>{
-			fn default()->Self{
-				Self::new(
-					core::array::from_fn(|_|core::array::from_fn(|_|Default::default()))
-				)
-			}
-		}
-		#[cfg(feature="fixed_wide")]
-		$crate::impl_matrix_wide_dot_8x8!();
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_named_fields_shape {
-	(
-		($struct_outer:ident, $size_outer: expr),
-		($size_inner: expr)
-	) => {
-		impl<T> core::ops::Deref for Matrix<$size_outer,$size_inner,T>{
-			type Target=$struct_outer<Vector<$size_inner,T>>;
-			fn deref(&self)->&Self::Target{
-				unsafe{core::mem::transmute(&self.array)}
-			}
-		}
-		impl<T> core::ops::DerefMut for Matrix<$size_outer,$size_inner,T>{
-			fn deref_mut(&mut self)->&mut Self::Target{
-				unsafe{core::mem::transmute(&mut self.array)}
-			}
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_named_fields_shape_shim {
-	(
-		($($vector_info:tt),+),
-		$matrix_info:tt
-	) => {
-		$crate::macro_repeated!(impl_matrix_named_fields_shape,$matrix_info,$($vector_info),+);
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_named_fields {
-	(
-		($($matrix_info:tt),+),
-		$vector_infos:tt
-	) => {
-		$crate::macro_repeated!(impl_matrix_named_fields_shape_shim,$vector_infos,$($matrix_info),+);
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_3x3 {
-	()=>{
-		#[cfg(feature="fixed_wide")]
-		$crate::impl_matrix_wide_3x3!();
-	}
-}

fixed_wide_vectors/src/macros/vector.rs

@@ -1,187 +0,0 @@
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector {
-	() => {
-		impl<const N:usize,T> Vector<N,T>{
-			#[inline(always)]
-			pub const fn new(array:[T;N])->Self{
-				Self{array}
-			}
-			#[inline(always)]
-			pub fn to_array(self)->[T;N]{
-				self.array
-			}
-			#[inline]
-			pub fn map<F,U>(self,f:F)->Vector<N,U>
-			where
-				F:Fn(T)->U
-			{
-				Vector::new(
-					self.array.map(f)
-				)
-			}
-			#[inline]
-			pub fn map_zip<F,U,V>(self,other:Vector<N,U>,f:F)->Vector<N,V>
-			where
-				F:Fn((T,U))->V,
-			{
-				let mut iter=self.array.into_iter().zip(other.array);
-				Vector::new(
-					core::array::from_fn(|_|f(iter.next().unwrap())),
-				)
-			}
-		}
-		impl<const N:usize,T:Copy> Vector<N,T>{
-			#[inline(always)]
-			pub const fn from_value(value:T)->Self{
-				Self::new([value;N])
-			}
-		}
-
-		impl<const N:usize,T:Default> Default for Vector<N,T>{
-			fn default()->Self{
-				Self::new(
-					core::array::from_fn(|_|Default::default())
-				)
-			}
-		}
-
-		impl<const N:usize,T:Ord> Vector<N,T>{
-			#[inline]
-			pub fn min(self,rhs:Self)->Self{
-				self.map_zip(rhs,|(a,b)|a.min(b))
-			}
-			#[inline]
-			pub fn max(self,rhs:Self)->Self{
-				self.map_zip(rhs,|(a,b)|a.max(b))
-			}
-			#[inline]
-			pub fn cmp(self,rhs:Self)->Vector<N,core::cmp::Ordering>{
-				self.map_zip(rhs,|(a,b)|a.cmp(&b))
-			}
-			#[inline]
-			pub fn lt(self,rhs:Self)->Vector<N,bool>{
-				self.map_zip(rhs,|(a,b)|a.lt(&b))
-			}
-			#[inline]
-			pub fn gt(self,rhs:Self)->Vector<N,bool>{
-				self.map_zip(rhs,|(a,b)|a.gt(&b))
-			}
-			#[inline]
-			pub fn ge(self,rhs:Self)->Vector<N,bool>{
-				self.map_zip(rhs,|(a,b)|a.ge(&b))
-			}
-			#[inline]
-			pub fn le(self,rhs:Self)->Vector<N,bool>{
-				self.map_zip(rhs,|(a,b)|a.le(&b))
-			}
-		}
-
-		impl<const N:usize> Vector<N,bool>{
-			#[inline]
-			pub fn all(&self)->bool{
-				self.array==[true;N]
-			}
-			#[inline]
-			pub fn any(&self)->bool{
-				self.array!=[false;N]
-			}
-		}
-
-		impl<const N:usize,T:core::ops::Neg<Output=V>,V> core::ops::Neg for Vector<N,T>{
-			type Output=Vector<N,V>;
-			fn neg(self)->Self::Output{
-				Vector::new(
-					self.array.map(|t|-t)
-				)
-			}
-		}
-
-		// Impl arithmetic operators
-		$crate::impl_vector_assign_operator!(AddAssign, add_assign );
-		$crate::impl_vector_operator!(Add, add );
-		$crate::impl_vector_assign_operator!(SubAssign, sub_assign );
-		$crate::impl_vector_operator!(Sub, sub );
-		$crate::impl_vector_assign_operator!(MulAssign, mul_assign );
-		$crate::impl_vector_operator!(Mul, mul );
-		$crate::impl_vector_assign_operator!(DivAssign, div_assign );
-		$crate::impl_vector_operator!(Div, div );
-		$crate::impl_vector_assign_operator!(RemAssign, rem_assign );
-		$crate::impl_vector_operator!(Rem, rem );
-
-		// Impl bitwise operators
-		$crate::impl_vector_assign_operator!(BitAndAssign, bitand_assign );
-		$crate::impl_vector_operator!(BitAnd, bitand );
-		$crate::impl_vector_assign_operator!(BitOrAssign, bitor_assign );
-		$crate::impl_vector_operator!(BitOr, bitor );
-		$crate::impl_vector_assign_operator!(BitXorAssign, bitxor_assign );
-		$crate::impl_vector_operator!(BitXor, bitxor );
-
-		// Impl floating-point based methods
-		#[cfg(feature="fixed_wide")]
-		$crate::impl_wide_vector_operations!();
-	}
-}
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector_operator {
-	($trait: ident, $method: ident ) => {
-		impl<const N:usize,T:core::ops::$trait<U,Output=V>,U,V> core::ops::$trait<Vector<N,U>> for Vector<N,T>{
-			type Output=Vector<N,V>;
-			fn $method(self,rhs:Vector<N,U>)->Self::Output{
-				self.map_zip(rhs,|(a,b)|a.$method(b))
-			}
-		}
-		impl<const N:usize,T:core::ops::$trait<i64,Output=T>> core::ops::$trait<i64> for Vector<N,T>{
-			type Output=Self;
-			fn $method(self,rhs:i64)->Self::Output{
-				self.map(|t|t.$method(rhs))
-			}
-		}
-	}
-}
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector_assign_operator {
-	($trait: ident, $method: ident ) => {
-		impl<const N:usize,T:core::ops::$trait<U>,U> core::ops::$trait<Vector<N,U>> for Vector<N,T>{
-			fn $method(&mut self,rhs:Vector<N,U>){
-				self.array.iter_mut().zip(rhs.array)
-					.for_each(|(a,b)|a.$method(b))
-			}
-		}
-		impl<const N:usize,T:core::ops::$trait<i64>> core::ops::$trait<i64> for Vector<N,T>{
-			fn $method(&mut self,rhs:i64){
-				self.array.iter_mut()
-					.for_each(|t|t.$method(rhs))
-			}
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector_named_fields {
-	( $struct:ident,  $size: expr ) => {
-		impl<T> core::ops::Deref for Vector<$size,T>{
-			type Target=$struct<T>;
-			fn deref(&self)->&Self::Target{
-				unsafe{core::mem::transmute(&self.array)}
-			}
-		}
-		impl<T> core::ops::DerefMut for Vector<$size,T>{
-			fn deref_mut(&mut self)->&mut Self::Target{
-				unsafe{core::mem::transmute(&mut self.array)}
-			}
-		}
-	}
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! impl_vector_3 {
-	()=>{
-		#[cfg(feature="fixed_wide")]
-		$crate::impl_vector_wide_3!();
-	}
-}

fixed_wide_vectors/src/matrix.rs

@@ -1,9 +0,0 @@
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-pub struct Matrix<const X:usize,const Y:usize,T>{
-	pub(crate) array:[[T;X];Y],
-}
-
-crate::impl_matrix!();
-
-//Special case 3x3 matrix operations because I cba to write macros for the arbitrary cases
-crate::impl_matrix_3x3!();

fixed_wide_vectors/src/vector.rs

@@ -1,9 +0,0 @@
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-pub struct Vector<const N:usize,T>{
-	pub(crate) array:[T;N],
-}
-
-crate::impl_vector!();
-
-//cross product
-crate::impl_vector_3!();

linear_ops/Cargo.lock

@@ -2,12 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "arrayvec"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-
 [[package]]
 name = "bnum"
 version = "0.11.0"
@@ -18,17 +12,16 @@ checksum = "3e31ea183f6ee62ac8b8a8cf7feddd766317adfb13ff469de57ce033efd6a790"
 name = "fixed_wide"
 version = "0.1.0"
 dependencies = [
- "arrayvec",
  "bnum",
  "paste",
 ]
 
 [[package]]
-name = "fixed_wide_vectors"
+name = "linear_ops"
 version = "0.1.0"
 dependencies = [
  "fixed_wide",
- "paste",
+ "ratio_ops",
 ]
 
 [[package]]
@@ -36,3 +29,7 @@ name = "paste"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "ratio_ops"
+version = "0.1.0"

linear_ops/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "linear_ops"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+default=["named-fields"]
+named-fields=[]
+deferred-division=["dep:ratio_ops"]
+
+[dependencies]
+ratio_ops = { path = "../ratio_ops", optional = true }
+
+[dev-dependencies]
+fixed_wide = { version = "0.1.0", path = "../fixed_wide", features = ["wide-mul"] }

linear_ops/src/macros/matrix.rs

@@ -0,0 +1,258 @@
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix {
+	() => {
+		impl<const X:usize,const Y:usize,T> Matrix<X,Y,T>{
+			#[inline(always)]
+			pub const fn new(array:[[T;X];Y])->Self{
+				Self{array}
+			}
+			#[inline(always)]
+			pub fn to_array(self)->[[T;X];Y]{
+				self.array
+			}
+			#[inline]
+			pub fn map<F,U>(self,f:F)->Matrix<X,Y,U>
+			where
+				F:Fn(T)->U
+			{
+				Matrix::new(
+					self.array.map(|inner|inner.map(&f)),
+				)
+			}
+			#[inline]
+			pub fn transpose(self)->Matrix<Y,X,T>{
+				//how did I think of this
+				let mut array_of_iterators=self.array.map(|axis|axis.into_iter());
+				Matrix::new(
+					core::array::from_fn(|_|
+						array_of_iterators.each_mut().map(|iter|
+							iter.next().unwrap()
+						)
+					)
+				)
+			}
+			#[inline]
+			// MatY<VecX>.MatX<VecZ> = MatY<VecZ>
+			pub fn dot<const Z:usize,U,V>(self,rhs:Matrix<Z,X,U>)->Matrix<Z,Y,V>
+			where
+				T:core::ops::Mul<U,Output=V>+Copy,
+				V:core::iter::Sum,
+				U:Copy,
+			{
+				let mut array_of_iterators=rhs.array.map(|axis|axis.into_iter().cycle());
+				Matrix::new(
+					self.array.map(|axis|
+						core::array::from_fn(|_|
+							// axis dot product with transposed rhs array
+							axis.iter().zip(
+								array_of_iterators.iter_mut()
+							).map(|(&lhs_value,rhs_iter)|
+								lhs_value*rhs_iter.next().unwrap()
+							).sum()
+						)
+					)
+				)
+			}
+			#[inline]
+			// MatY<VecX>.VecX = VecY
+			pub fn transform_vector<U,V>(self,rhs:Vector<X,U>)->Vector<Y,V>
+			where
+				T:core::ops::Mul<U,Output=V>,
+				V:core::iter::Sum,
+				U:Copy,
+			{
+				Vector::new(
+					self.array.map(|axis|
+						Vector::new(axis).dot(rhs)
+					)
+				)
+			}
+		}
+		impl<const X:usize,const Y:usize,T> Matrix<X,Y,T>
+		where
+			T:Copy
+		{
+			#[inline(always)]
+			pub const fn from_value(value:T)->Self{
+				Self::new([[value;X];Y])
+			}
+		}
+
+		impl<const X:usize,const Y:usize,T:Default> Default for Matrix<X,Y,T>{
+			#[inline]
+			fn default()->Self{
+				Self::new(
+					core::array::from_fn(|_|core::array::from_fn(|_|Default::default()))
+				)
+			}
+		}
+
+		impl<const X:usize,const Y:usize,T:core::fmt::Display> core::fmt::Display for Matrix<X,Y,T>{
+			#[inline]
+			fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
+				for row in &self.array[0..Y]{
+					core::write!(f,"\n")?;
+					for elem in &row[0..X-1]{
+						core::write!(f,"{}, ",elem)?;
+					}
+					// assume we will be using matrices of size 1x1 or greater
+					core::write!(f,"{}",row.last().unwrap())?;
+				}
+				Ok(())
+			}
+		}
+
+		impl<const X:usize,const Y:usize,const Z:usize,T,U,V> core::ops::Mul<Matrix<Z,X,U>> for Matrix<X,Y,T>
+		where
+			T:core::ops::Mul<U,Output=V>+Copy,
+			V:core::iter::Sum,
+			U:Copy,
+		{
+			type Output=Matrix<Z,Y,V>;
+			#[inline]
+			fn mul(self,rhs:Matrix<Z,X,U>)->Self::Output{
+				self.dot(rhs)
+			}
+		}
+		impl<const X:usize,const Y:usize,T,U,V> core::ops::Mul<Vector<X,U>> for Matrix<X,Y,T>
+		where
+			T:core::ops::Mul<U,Output=V>,
+			V:core::iter::Sum,
+			U:Copy,
+		{
+			type Output=Vector<Y,V>;
+			#[inline]
+			fn mul(self,rhs:Vector<X,U>)->Self::Output{
+				self.transform_vector(rhs)
+			}
+		}
+		#[cfg(feature="deferred-division")]
+		$crate::impl_matrix_deferred_division!();
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_deferred_division {
+	() => {
+		impl<const X:usize,const Y:usize,T:ratio_ops::ratio::Divide<U,Output=V>,U:Copy,V> ratio_ops::ratio::Divide<U> for Matrix<X,Y,T>{
+			type Output=Matrix<X,Y,V>;
+			#[inline]
+			fn divide(self,rhs:U)->Self::Output{
+				self.map(|t|t.divide(rhs))
+			}
+		}
+		impl<const X:usize,const Y:usize,T,U> core::ops::Div<U> for Matrix<X,Y,T>{
+			type Output=ratio_ops::ratio::Ratio<Matrix<X,Y,T>,U>;
+			#[inline]
+			fn div(self,rhs:U)->Self::Output{
+				ratio_ops::ratio::Ratio::new(self,rhs)
+			}
+		}
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_extend {
+	( $x: expr, $y: expr ) => {
+		impl<T> Matrix<$x,$y,T>{
+			#[inline]
+			pub fn extend_row(self,value:Vector<$x,T>)->Matrix<$x,{$y+1},T>{
+				let mut iter=self.array.into_iter().chain(core::iter::once(value.array));
+				Matrix::new(
+					core::array::from_fn(|_|iter.next().unwrap()),
+				)
+			}
+			#[inline]
+			pub fn extend_column(self,value:Vector<$y,T>)->Matrix<{$x+1},$y,T>{
+				let mut iter_rows=value.array.into_iter();
+				Matrix::new(
+					self.array.map(|axis|{
+						let mut elements_iter=axis.into_iter().chain(core::iter::once(iter_rows.next().unwrap()));
+						core::array::from_fn(|_|elements_iter.next().unwrap())
+					})
+				)
+			}
+		}
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_named_fields_shape {
+	(
+		($struct_outer:ident, $size_outer: expr),
+		($size_inner: expr)
+	) => {
+		impl<T> core::ops::Deref for Matrix<$size_outer,$size_inner,T>{
+			type Target=$struct_outer<Vector<$size_inner,T>>;
+			#[inline]
+			fn deref(&self)->&Self::Target{
+				unsafe{core::mem::transmute(&self.array)}
+			}
+		}
+		impl<T> core::ops::DerefMut for Matrix<$size_outer,$size_inner,T>{
+			#[inline]
+			fn deref_mut(&mut self)->&mut Self::Target{
+				unsafe{core::mem::transmute(&mut self.array)}
+			}
+		}
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_named_fields_shape_shim {
+	(
+		($($vector_info:tt),+),
+		$matrix_info:tt
+	) => {
+		$crate::macro_repeated!(impl_matrix_named_fields_shape,$matrix_info,$($vector_info),+);
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_named_fields {
+	(
+		($($matrix_info:tt),+),
+		$vector_infos:tt
+	) => {
+		$crate::macro_repeated!(impl_matrix_named_fields_shape_shim,$vector_infos,$($matrix_info),+);
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_3x3 {
+	()=>{
+		impl<T,T2,T3> Matrix<3,3,T>
+		where
+			//cross
+			T:core::ops::Mul<T,Output=T2>+Copy,
+			T2:core::ops::Sub,
+			//dot
+			T:core::ops::Mul<<T2 as core::ops::Sub>::Output,Output=T3>,
+			T3:core::iter::Sum,
+		{
+			pub fn det(self)->T3{
+				self.x_axis.dot(self.y_axis.cross(self.z_axis))
+			}
+		}
+		impl<T,T2> Matrix<3,3,T>
+		where
+			T:core::ops::Mul<T,Output=T2>+Copy,
+			T2:core::ops::Sub,
+		{
+			pub fn adjugate(self)->Matrix<3,3,<T2 as core::ops::Sub>::Output>{
+				Matrix::new([
+					[self.y_axis.y*self.z_axis.z-self.y_axis.z*self.z_axis.y,self.x_axis.z*self.z_axis.y-self.x_axis.y*self.z_axis.z,self.x_axis.y*self.y_axis.z-self.x_axis.z*self.y_axis.y],
+					[self.y_axis.z*self.z_axis.x-self.y_axis.x*self.z_axis.z,self.x_axis.x*self.z_axis.z-self.x_axis.z*self.z_axis.x,self.x_axis.z*self.y_axis.x-self.x_axis.x*self.y_axis.z],
+					[self.y_axis.x*self.z_axis.y-self.y_axis.y*self.z_axis.x,self.x_axis.y*self.z_axis.x-self.x_axis.x*self.z_axis.y,self.x_axis.x*self.y_axis.y-self.x_axis.y*self.y_axis.x],
+				])
+			}
+		}
+	}
+}

linear_ops/src/macros/mod.rs

@@ -1,6 +1,3 @@
-#[cfg(feature="fixed_wide")]
-pub mod fixed_wide;
-
 pub mod common;
 pub mod vector;
 pub mod matrix;

linear_ops/src/macros/vector.rs

@@ -0,0 +1,353 @@
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector {
+	() => {
+		impl<const N:usize,T> Vector<N,T>{
+			#[inline(always)]
+			pub const fn new(array:[T;N])->Self{
+				Self{array}
+			}
+			#[inline(always)]
+			pub fn to_array(self)->[T;N]{
+				self.array
+			}
+			#[inline]
+			pub fn map<F,U>(self,f:F)->Vector<N,U>
+			where
+				F:Fn(T)->U
+			{
+				Vector::new(
+					self.array.map(f)
+				)
+			}
+			#[inline]
+			pub fn map_zip<F,U,V>(self,other:Vector<N,U>,f:F)->Vector<N,V>
+			where
+				F:Fn((T,U))->V,
+			{
+				let mut iter=self.array.into_iter().zip(other.array);
+				Vector::new(
+					core::array::from_fn(|_|f(iter.next().unwrap())),
+				)
+			}
+		}
+		impl<const N:usize,T:Copy> Vector<N,T>{
+			#[inline(always)]
+			pub const fn from_value(value:T)->Self{
+				Self::new([value;N])
+			}
+		}
+
+		impl<const N:usize,T:Default> Default for Vector<N,T>{
+			#[inline]
+			fn default()->Self{
+				Self::new(
+					core::array::from_fn(|_|Default::default())
+				)
+			}
+		}
+
+		impl<const N:usize,T:core::fmt::Display> core::fmt::Display for Vector<N,T>{
+			#[inline]
+			fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
+				for elem in &self.array[0..N-1]{
+					core::write!(f,"{}, ",elem)?;
+				}
+				// assume we will be using vectors of length 1 or greater
+				core::write!(f,"{}",self.array.last().unwrap())
+			}
+		}
+
+		impl<const N:usize,T:Ord> Vector<N,T>{
+			#[inline]
+			pub fn min(self,rhs:Self)->Self{
+				self.map_zip(rhs,|(a,b)|a.min(b))
+			}
+			#[inline]
+			pub fn max(self,rhs:Self)->Self{
+				self.map_zip(rhs,|(a,b)|a.max(b))
+			}
+			#[inline]
+			pub fn cmp(self,rhs:Self)->Vector<N,core::cmp::Ordering>{
+				self.map_zip(rhs,|(a,b)|a.cmp(&b))
+			}
+			#[inline]
+			pub fn lt(self,rhs:Self)->Vector<N,bool>{
+				self.map_zip(rhs,|(a,b)|a.lt(&b))
+			}
+			#[inline]
+			pub fn gt(self,rhs:Self)->Vector<N,bool>{
+				self.map_zip(rhs,|(a,b)|a.gt(&b))
+			}
+			#[inline]
+			pub fn ge(self,rhs:Self)->Vector<N,bool>{
+				self.map_zip(rhs,|(a,b)|a.ge(&b))
+			}
+			#[inline]
+			pub fn le(self,rhs:Self)->Vector<N,bool>{
+				self.map_zip(rhs,|(a,b)|a.le(&b))
+			}
+		}
+
+		impl<const N:usize> Vector<N,bool>{
+			#[inline]
+			pub fn all(&self)->bool{
+				self.array==[true;N]
+			}
+			#[inline]
+			pub fn any(&self)->bool{
+				self.array!=[false;N]
+			}
+		}
+
+		impl<const N:usize,T:core::ops::Neg<Output=V>,V> core::ops::Neg for Vector<N,T>{
+			type Output=Vector<N,V>;
+			#[inline]
+			fn neg(self)->Self::Output{
+				Vector::new(
+					self.array.map(|t|-t)
+				)
+			}
+		}
+
+		impl<const N:usize,T> Vector<N,T>
+		{
+			#[inline]
+			pub fn dot<U,V>(self,rhs:Vector<N,U>)->V
+			where
+				T:core::ops::Mul<U,Output=V>,
+				V:core::iter::Sum,
+			{
+				self.array.into_iter().zip(rhs.array).map(|(a,b)|a*b).sum()
+			}
+		}
+
+		impl<const N:usize,T,V> Vector<N,T>
+		where
+			T:core::ops::Mul<Output=V>+Copy,
+			V:core::iter::Sum,
+		{
+			#[inline]
+			pub fn length_squared(self)->V{
+				self.array.into_iter().map(|t|t*t).sum()
+			}
+		}
+
+		// Impl arithmetic operators
+		$crate::impl_vector_assign_operator!(AddAssign, add_assign );
+		$crate::impl_vector_operator!(Add, add );
+		$crate::impl_vector_assign_operator!(SubAssign, sub_assign );
+		$crate::impl_vector_operator!(Sub, sub );
+		$crate::impl_vector_assign_operator!(RemAssign, rem_assign );
+		$crate::impl_vector_operator!(Rem, rem );
+
+		// mul and div are special, usually you multiply by a scalar
+		// and implementing both vec*vec and vec*scalar is conflicting implementations Q_Q
+		$crate::impl_vector_assign_operator_scalar!(MulAssign, mul_assign );
+		$crate::impl_vector_operator_scalar!(Mul, mul );
+		$crate::impl_vector_assign_operator_scalar!(DivAssign, div_assign );
+		#[cfg(not(feature="deferred-division"))]
+		$crate::impl_vector_operator_scalar!(Div, div );
+		#[cfg(feature="deferred-division")]
+		$crate::impl_vector_deferred_division!();
+
+		// Impl bitwise operators
+		$crate::impl_vector_assign_operator!(BitAndAssign, bitand_assign );
+		$crate::impl_vector_operator!(BitAnd, bitand );
+		$crate::impl_vector_assign_operator!(BitOrAssign, bitor_assign );
+		$crate::impl_vector_operator!(BitOr, bitor );
+		$crate::impl_vector_assign_operator!(BitXorAssign, bitxor_assign );
+		$crate::impl_vector_operator!(BitXor, bitxor );
+
+		// Impl shift operators
+		$crate::impl_vector_shift_assign_operator!(ShlAssign, shl_assign);
+		$crate::impl_vector_shift_operator!(Shl, shl);
+		$crate::impl_vector_shift_assign_operator!(ShrAssign, shr_assign);
+		$crate::impl_vector_shift_operator!(Shr, shr);
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_deferred_division {
+	() => {
+		impl<const N:usize,T:ratio_ops::ratio::Divide<U,Output=V>,U:Copy,V> ratio_ops::ratio::Divide<U> for Vector<N,T>{
+			type Output=Vector<N,V>;
+			#[inline]
+			fn divide(self,rhs:U)->Self::Output{
+				self.map(|t|t.divide(rhs))
+			}
+		}
+		impl<const N:usize,T,U> core::ops::Div<U> for Vector<N,T>{
+			type Output=ratio_ops::ratio::Ratio<Vector<N,T>,U>;
+			#[inline]
+			fn div(self,rhs:U)->Self::Output{
+				ratio_ops::ratio::Ratio::new(self,rhs)
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_operator_scalar {
+	($trait: ident, $method: ident ) => {
+		impl<const N:usize,T:core::ops::$trait<U,Output=V>,U:Copy,V> core::ops::$trait<U> for Vector<N,T>{
+			type Output=Vector<N,V>;
+			#[inline]
+			fn $method(self,rhs:U)->Self::Output{
+				self.map(|t|t.$method(rhs))
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_operator {
+	($trait: ident, $method: ident ) => {
+		impl<const N:usize,T:core::ops::$trait<U,Output=V>,U,V> core::ops::$trait<Vector<N,U>> for Vector<N,T>{
+			type Output=Vector<N,V>;
+			#[inline]
+			fn $method(self,rhs:Vector<N,U>)->Self::Output{
+				self.map_zip(rhs,|(a,b)|a.$method(b))
+			}
+		}
+		impl<const N:usize,T:core::ops::$trait<i64,Output=T>> core::ops::$trait<i64> for Vector<N,T>{
+			type Output=Self;
+			#[inline]
+			fn $method(self,rhs:i64)->Self::Output{
+				self.map(|t|t.$method(rhs))
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_assign_operator_scalar {
+	($trait: ident, $method: ident ) => {
+		impl<const N:usize,T:core::ops::$trait<U>,U:Copy> core::ops::$trait<U> for Vector<N,T>{
+			#[inline]
+			fn $method(&mut self,rhs:U){
+				self.array.iter_mut()
+					.for_each(|t|t.$method(rhs))
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_assign_operator {
+	($trait: ident, $method: ident ) => {
+		impl<const N:usize,T:core::ops::$trait<U>,U> core::ops::$trait<Vector<N,U>> for Vector<N,T>{
+			#[inline]
+			fn $method(&mut self,rhs:Vector<N,U>){
+				self.array.iter_mut().zip(rhs.array)
+					.for_each(|(a,b)|a.$method(b))
+			}
+		}
+		impl<const N:usize,T:core::ops::$trait<i64>> core::ops::$trait<i64> for Vector<N,T>{
+			#[inline]
+			fn $method(&mut self,rhs:i64){
+				self.array.iter_mut()
+					.for_each(|t|t.$method(rhs))
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_shift_operator {
+	($trait: ident, $method: ident ) => {
+		impl<const N:usize,T:core::ops::$trait<U,Output=V>,U,V> core::ops::$trait<Vector<N,U>> for Vector<N,T>{
+			type Output=Vector<N,V>;
+			#[inline]
+			fn $method(self,rhs:Vector<N,U>)->Self::Output{
+				self.map_zip(rhs,|(a,b)|a.$method(b))
+			}
+		}
+		impl<const N:usize,T:core::ops::$trait<u32,Output=V>,V> core::ops::$trait<u32> for Vector<N,T>{
+			type Output=Vector<N,V>;
+			#[inline]
+			fn $method(self,rhs:u32)->Self::Output{
+				self.map(|t|t.$method(rhs))
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_shift_assign_operator {
+	($trait: ident, $method: ident ) => {
+		impl<const N:usize,T:core::ops::$trait<U>,U> core::ops::$trait<Vector<N,U>> for Vector<N,T>{
+			#[inline]
+			fn $method(&mut self,rhs:Vector<N,U>){
+				self.array.iter_mut().zip(rhs.array)
+					.for_each(|(a,b)|a.$method(b))
+			}
+		}
+		impl<const N:usize,T:core::ops::$trait<u32>> core::ops::$trait<u32> for Vector<N,T>{
+			#[inline]
+			fn $method(&mut self,rhs:u32){
+				self.array.iter_mut()
+					.for_each(|t|t.$method(rhs))
+			}
+		}
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_extend {
+	( $size: expr ) => {
+		impl<T> Vector<$size,T>{
+			#[inline]
+			pub fn extend(self,value:T)->Vector<{$size+1},T>{
+				let mut iter=self.array.into_iter().chain(core::iter::once(value));
+				Vector::new(
+					core::array::from_fn(|_|iter.next().unwrap()),
+				)
+			}
+		}
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_named_fields {
+	( $struct:ident,  $size: expr ) => {
+		impl<T> core::ops::Deref for Vector<$size,T>{
+			type Target=$struct<T>;
+			#[inline]
+			fn deref(&self)->&Self::Target{
+				unsafe{core::mem::transmute(&self.array)}
+			}
+		}
+		impl<T> core::ops::DerefMut for Vector<$size,T>{
+			#[inline]
+			fn deref_mut(&mut self)->&mut Self::Target{
+				unsafe{core::mem::transmute(&mut self.array)}
+			}
+		}
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_vector_3 {
+	()=>{
+		impl<T> Vector<3,T>
+		{
+			#[inline]
+			pub fn cross<U,V>(self,rhs:Vector<3,U>)->Vector<3,<V as core::ops::Sub>::Output>
+			where
+				T:core::ops::Mul<U,Output=V>+Copy,
+				U:Copy,
+				V:core::ops::Sub,
+			{
+				Vector::new([
+					self.y*rhs.z-self.z*rhs.y,
+					self.z*rhs.x-self.x*rhs.z,
+					self.x*rhs.y-self.y*rhs.x,
+				])
+			}
+		}
+	}
+}

linear_ops/src/matrix.rs

@@ -0,0 +1,17 @@
+use crate::vector::Vector;
+
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+pub struct Matrix<const X:usize,const Y:usize,T>{
+	pub(crate) array:[[T;X];Y],
+}
+
+crate::impl_matrix!();
+
+crate::impl_matrix_extend!(2,2);
+crate::impl_matrix_extend!(2,3);
+crate::impl_matrix_extend!(3,2);
+crate::impl_matrix_extend!(3,3);
+
+//Special case 3x3 matrix operations because I cba to write macros for the arbitrary cases
+#[cfg(feature="named-fields")]
+crate::impl_matrix_3x3!();

linear_ops/src/tests/fixed_wide.rs

@@ -8,9 +8,9 @@ type Planar64Wide3=fixed_wide::types::I256F256;
 #[test]
 fn wide_vec3(){
 	let v=Vector3::from_value(Planar64::from(3));
-	let v1=v.wide_mul_1_1(v);
-	let v2=v1.wide_mul_2_2(v1);
-	let v3=v2.wide_mul_4_4(v2);
+	let v1=v*v.x;
+	let v2=v1*v1.y;
+	let v3=v2*v2.z;
 
 	assert_eq!(v3.array,Vector3::from_value(Planar64Wide3::from(3i128.pow(8))).array);
 }
@@ -18,9 +18,9 @@ fn wide_vec3(){
 #[test]
 fn wide_vec3_dot(){
 	let v=Vector3::from_value(Planar64::from(3));
-	let v1=v.wide_mul_1_1(v);
-	let v2=v1.wide_mul_2_2(v1);
-	let v3=v2.wide_dot_4_4(v2);
+	let v1=v*v.x;
+	let v2=v1*v1.y;
+	let v3=v2.dot(v2);
 
 	assert_eq!(v3,Planar64Wide3::from(3i128.pow(8)*3));
 }
@@ -28,9 +28,9 @@ fn wide_vec3_dot(){
 #[test]
 fn wide_vec3_length_squared(){
 	let v=Vector3::from_value(Planar64::from(3));
-	let v1=v.wide_mul_1_1(v);
-	let v2=v1.wide_mul_2_2(v1);
-	let v3=v2.wide_length_squared();
+	let v1=v*v.x;
+	let v2=v1*v1.y;
+	let v3=v2.length_squared();
 
 	assert_eq!(v3,Planar64Wide3::from(3i128.pow(8)*3));
 }
@@ -49,7 +49,7 @@ fn wide_matrix_dot(){
 		[Planar64::from(7),Planar64::from(8)],
 	]);
 	// Mat3<Vec4>.dot(Mat4<Vec2>) -> Mat3<Vec2>
-	let m_dot=lhs.wide_dot_1_1(rhs);
+	let m_dot=lhs*rhs;
 	//In[1]:= {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}} . {{1, 2}, {3, 4}, {5, 6}, {7, 8}}
 	//Out[1]= {{50, 60}, {114, 140}, {178, 220}}
 	assert_eq!(
@@ -63,6 +63,7 @@ fn wide_matrix_dot(){
 }
 
 #[test]
+#[cfg(feature="named-fields")]
 fn wide_matrix_det(){
 	let m=Matrix3::new([
 		[Planar64::from(1),Planar64::from(2),Planar64::from(3)],
@@ -71,10 +72,11 @@ fn wide_matrix_det(){
 	]);
 	// In[2]:= Det[{{1, 2, 3}, {4, 5, 7}, {6, 8, 9}}]
 	// Out[2]= 7
-	assert_eq!(m.wide_det_3x3_1(),fixed_wide::fixed::Fixed::<3,96>::from(7));
+	assert_eq!(m.det(),fixed_wide::fixed::Fixed::<3,96>::from(7));
 }
 
 #[test]
+#[cfg(feature="named-fields")]
 fn wide_matrix_adjugate(){
 	let m=Matrix3::new([
 		[Planar64::from(1),Planar64::from(2),Planar64::from(3)],
@@ -84,7 +86,7 @@ fn wide_matrix_adjugate(){
 	// In[6]:= Adjugate[{{1, 2, 3}, {4, 5, 7}, {6, 8, 9}}]
 	// Out[6]= {{-11, 6, -1}, {6, -9, 5}, {2, 4, -3}}
 	assert_eq!(
-		m.wide_adjugate_3x3_1().array,
+		m.adjugate().array,
 		Matrix3::new([
 			[Planar64Wide1::from(-11),Planar64Wide1::from(6),Planar64Wide1::from(-1)],
 			[Planar64Wide1::from(6),Planar64Wide1::from(-9),Planar64Wide1::from(5)],

linear_ops/src/tests/mod.rs

@@ -3,5 +3,4 @@ mod tests;
 #[cfg(feature="named-fields")]
 mod named;
 
-#[cfg(feature="fixed_wide")]
 mod fixed_wide;

linear_ops/src/tests/tests.rs

@@ -1,4 +1,4 @@
-use crate::types::{Vector3,Matrix4x3,Matrix2x4,Matrix2x3};
+use crate::types::{Vector2,Vector3,Matrix4x3,Matrix2x4,Matrix2x3,Matrix3x2};
 
 #[test]
 fn test_bool(){
@@ -8,12 +8,28 @@ fn test_bool(){
 	assert_eq!(Vector3::new([true,true,true]).all(),true);
 }
 
+#[test]
+fn test_length_squared(){
+	assert_eq!(Vector3::new([1,2,3]).length_squared(),14);
+}
+
 #[test]
 fn test_arithmetic(){
 	let a=Vector3::new([1,2,3]);
 	assert_eq!((a+a*2).array,Vector3::new([1*3,2*3,3*3]).array);
 }
 
+#[test]
+fn matrix_transform_vector(){
+	let m=Matrix3x2::new([
+		[1,2,3],
+		[4,5,6],
+	]);
+	let v=Vector3::new([1,2,3]);
+	let transformed=m*v;
+	assert_eq!(transformed.array,Vector2::new([14,32]).array);
+}
+
 #[test]
 fn matrix_dot(){
 
@@ -29,7 +45,7 @@ fn matrix_dot(){
 		[9.0,10.0,11.0,12.0],//	[178.0,220.0],
 	]);
 	// Mat3<Vec4>.dot(Mat4<Vec2>) -> Mat3<Vec2>
-	let m_dot=lhs.dot(rhs);
+	let m_dot=lhs*rhs;
 	//In[1]:= {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}} . {{1, 2}, {3, 4}, {5, 6}, {7, 8}}
 	//Out[1]= {{50, 60}, {114, 140}, {178, 220}}
 	assert_eq!(

linear_ops/src/vector.rs

@@ -0,0 +1,19 @@
+/// An array-backed vector type.  Named fields are made accessible via the Deref/DerefMut traits which are implmented for 2-4 dimensions.
+/// let mut v = Vector::new([1.0,2.0,3.0]);
+/// v.x += v.z;
+/// println!("v.x={}",v.x);
+
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+pub struct Vector<const N:usize,T>{
+	pub(crate) array:[T;N],
+}
+
+crate::impl_vector!();
+
+// Needs const generics for generic case
+crate::impl_vector_extend!(2);
+crate::impl_vector_extend!(3);
+
+//cross product
+#[cfg(feature="named-fields")]
+crate::impl_vector_3!();

ratio_ops/.gitignore

@@ -0,0 +1 @@
+/target

ratio_ops/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ratio_ops"
+version = "0.1.0"

ratio_ops/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "ratio_ops"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

ratio_ops/src/lib.rs

@@ -0,0 +1 @@
+pub mod ratio;

ratio_ops/src/ratio.rs

@@ -0,0 +1,177 @@
+#[derive(Clone,Copy,Debug,Hash)]
+pub struct Ratio<Num,Den>{
+	pub num:Num,
+	pub den:Den,
+}
+impl<Num,Den> Ratio<Num,Den>{
+	#[inline(always)]
+	pub const fn new(num:Num,den:Den)->Self{
+		Self{num,den}
+	}
+}
+
+/// The actual divide implementation, Div is replaced with a Ratio constructor
+pub trait Divide<Rhs=Self>{
+	type Output;
+	fn divide(self,rhs:Rhs)->Self::Output;
+}
+
+impl<Num,Den> Ratio<Num,Den>
+	where
+		Num:Divide<Den>,
+{
+	#[inline]
+	pub fn divide(self)-><Num as Divide<Den>>::Output{
+		self.num.divide(self.den)
+	}
+}
+
+//take care to use the ratio methods to avoid nested ratios
+
+impl<LhsNum,LhsDen> Ratio<LhsNum,LhsDen>{
+	#[inline]
+	pub fn mul_ratio<RhsNum,RhsDen>(self,rhs:Ratio<RhsNum,RhsDen>)->Ratio<<LhsNum as core::ops::Mul<RhsNum>>::Output,<LhsDen as core::ops::Mul<RhsDen>>::Output>
+		where
+			LhsNum:core::ops::Mul<RhsNum>,
+			LhsDen:core::ops::Mul<RhsDen>,
+	{
+		Ratio::new(self.num*rhs.num,self.den*rhs.den)
+	}
+	#[inline]
+	pub fn div_ratio<RhsNum,RhsDen>(self,rhs:Ratio<RhsNum,RhsDen>)->Ratio<<LhsNum as core::ops::Mul<RhsDen>>::Output,<LhsDen as core::ops::Mul<RhsNum>>::Output>
+		where
+			LhsNum:core::ops::Mul<RhsDen>,
+			LhsDen:core::ops::Mul<RhsNum>,
+	{
+		Ratio::new(self.num*rhs.den,self.den*rhs.num)
+	}
+}
+macro_rules! impl_ratio_method {
+	($trait:ident, $method:ident, $ratio_method:ident) => {
+		impl<LhsNum,LhsDen> Ratio<LhsNum,LhsDen>{
+			#[inline]
+			pub fn $ratio_method<RhsNum,RhsDen,LhsCrossMul,RhsCrossMul>(self,rhs:Ratio<RhsNum,RhsDen>)->Ratio<<LhsCrossMul as core::ops::$trait<RhsCrossMul>>::Output,<LhsDen as core::ops::Mul<RhsDen>>::Output>
+				where
+					LhsNum:core::ops::Mul<RhsDen,Output=LhsCrossMul>,
+					LhsDen:core::ops::Mul<RhsNum,Output=RhsCrossMul>,
+					LhsDen:core::ops::Mul<RhsDen>,
+					LhsDen:Copy,
+					RhsDen:Copy,
+					LhsCrossMul:core::ops::$trait<RhsCrossMul>,
+			{
+				Ratio::new((self.num*rhs.den).$method(self.den*rhs.num),self.den*rhs.den)
+			}
+		}
+	};
+}
+impl_ratio_method!(Add,add,add_ratio);
+impl_ratio_method!(Sub,sub,sub_ratio);
+impl_ratio_method!(Rem,rem,rem_ratio);
+
+/* generic rhs mul is not possible!
+impl<Lhs,RhsNum,RhsDen> core::ops::Mul<Ratio<RhsNum,RhsDen>> for Lhs
+	where
+		Lhs:core::ops::Mul<RhsNum>,
+{
+	type Output=Ratio<<Lhs as core::ops::Mul<RhsNum>>::Output,RhsDen>;
+	#[inline]
+	fn mul(self,rhs:Ratio<RhsNum,RhsDen>)->Self::Output{
+		Ratio::new(self*rhs.num,rhs.den)
+	}
+}
+*/
+
+//operators
+
+impl<LhsNum,LhsDen> core::ops::Neg for Ratio<LhsNum,LhsDen>
+	where
+		LhsNum:core::ops::Neg,
+{
+	type Output=Ratio<<LhsNum as core::ops::Neg>::Output,LhsDen>;
+	#[inline]
+	fn neg(self)->Self::Output{
+		Ratio::new(-self.num,self.den)
+	}
+}
+impl<LhsNum,LhsDen,Rhs> core::ops::Mul<Rhs> for Ratio<LhsNum,LhsDen>
+	where
+		LhsNum:core::ops::Mul<Rhs>,
+{
+	type Output=Ratio<<LhsNum as core::ops::Mul<Rhs>>::Output,LhsDen>;
+	#[inline]
+	fn mul(self,rhs:Rhs)->Self::Output{
+		Ratio::new(self.num*rhs,self.den)
+	}
+}
+impl<LhsNum,LhsDen,Rhs> core::ops::Div<Rhs> for Ratio<LhsNum,LhsDen>
+	where
+		LhsDen:core::ops::Mul<Rhs>,
+{
+	type Output=Ratio<LhsNum,<LhsDen as core::ops::Mul<Rhs>>::Output>;
+	#[inline]
+	fn div(self,rhs:Rhs)->Self::Output{
+		Ratio::new(self.num,self.den*rhs)
+	}
+}
+
+macro_rules! impl_ratio_operator {
+	($trait:ident, $method:ident) => {
+		impl<LhsNum,LhsDen,Rhs,Intermediate> core::ops::$trait<Rhs> for Ratio<LhsNum,LhsDen>
+			where
+				LhsNum:core::ops::$trait<Intermediate>,
+				LhsDen:Copy,
+				Rhs:core::ops::Mul<LhsDen,Output=Intermediate>,
+		{
+			type Output=Ratio<<LhsNum as core::ops::$trait<Intermediate>>::Output,LhsDen>;
+			#[inline]
+			fn $method(self,rhs:Rhs)->Self::Output{
+				Ratio::new(self.num.$method(rhs*self.den),self.den)
+			}
+		}
+	};
+}
+
+impl_ratio_operator!(Add,add);
+impl_ratio_operator!(Sub,sub);
+impl_ratio_operator!(Rem,rem);
+
+//assign operators
+
+impl<LhsNum,LhsDen,Rhs> core::ops::MulAssign<Rhs> for Ratio<LhsNum,LhsDen>
+	where
+		LhsNum:core::ops::MulAssign<Rhs>,
+{
+	#[inline]
+	fn mul_assign(&mut self,rhs:Rhs){
+		self.num*=rhs;
+	}
+}
+impl<LhsNum,LhsDen,Rhs> core::ops::DivAssign<Rhs> for Ratio<LhsNum,LhsDen>
+	where
+		LhsDen:core::ops::MulAssign<Rhs>,
+{
+	#[inline]
+	fn div_assign(&mut self,rhs:Rhs){
+		self.den*=rhs;
+	}
+}
+
+macro_rules! impl_ratio_assign_operator {
+	($trait:ident, $method:ident) => {
+		impl<LhsNum,LhsDen,Rhs> core::ops::$trait<Rhs> for Ratio<LhsNum,LhsDen>
+			where
+				LhsNum:core::ops::$trait,
+				LhsDen:Copy,
+				Rhs:core::ops::Mul<LhsDen,Output=LhsNum>,
+		{
+			#[inline]
+			fn $method(&mut self,rhs:Rhs){
+				self.num.$method(rhs*self.den)
+			}
+		}
+	};
+}
+
+impl_ratio_assign_operator!(AddAssign,add_assign);
+impl_ratio_assign_operator!(SubAssign,sub_assign);
+impl_ratio_assign_operator!(RemAssign,rem_assign);