matrix: test det + adjugate

fixed_wide_vectors/src/macros/fixed_wide.rs

@@ -83,17 +83,121 @@ macro_rules! impl_wide_vector_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_vector_3_wide_cross {
+	(
+		(),
+		($lhs:expr, $rhs:expr)
+	)=>{
+		impl Vector3<fixed_wide::fixed::Fixed<{$lhs},{$lhs*32}>>{
+			paste::item!{
+			#[inline]
+			pub fn [<wide_cross_ $lhs _ $rhs>](self,rhs:Vector3<fixed_wide::fixed::Fixed<{$rhs},{$rhs*32}>>)->Vector3<fixed_wide::fixed::Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>>{
+				Vector3{
+					x:self.y.[<wide_mul_ $lhs _ $rhs>](rhs.z)-self.z.[<wide_mul_ $lhs _ $rhs>](rhs.y),
+					y:self.z.[<wide_mul_ $lhs _ $rhs>](rhs.x)-self.x.[<wide_mul_ $lhs _ $rhs>](rhs.z),
+					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_matrix_wide_mul {
+macro_rules! impl_vector_wide_3 {
+	()=>{
+		$crate::do_macro_8x8!(impl_vector_3_wide_cross,());
+	}
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_wide_dot_transpose_helper {
+	(
+		$lhs_axis:expr, $wide_mul:ident, $rhs:ident,
+		($struct: ident { $($field: ident), + }),
+		($from_struct: ident { $($from_field: ident), + }),
+		$static_field: ident
+	) => {
+		$crate::sum_repeating!(
+			$( + $lhs_axis.$field.$wide_mul($rhs.$from_field.$static_field) ) +
+		)
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_wide_dot_inner {
+	(
+		// MatY<VecX>.MatX<VecZ> = MatY<VecZ>
+		$lhs:ident, $lhs_field_outer:ident, $wide_mul:ident, $rhs:ident,
+		$struct_inner_thru: tt, //VecX
+		($struct_inner: ident { $($field_inner: ident), + }), //VecX
+		($rhs_struct_inner: ident { $($rhs_field_inner: ident), + }), //VecZ
+		$rhs_outer: tt //MatX
+	) => {
+		$rhs_struct_inner {
+			$(
+				//directly dot product to avoid a copy
+				$rhs_field_inner: $crate::impl_matrix_wide_dot_transpose_helper!{
+					//lhs.axis.wide_mul(rhs_t.axis)
+					$lhs.$lhs_field_outer,$wide_mul,$rhs,
+					$struct_inner_thru, //VecZ
+					$rhs_outer, //MatX
+					$rhs_field_inner
+				}
+			), +
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_wide_dot_outer {
+	(
+		// MatY<VecX>.MatX<VecZ> = MatY<VecZ>
+		$lhs:ident, $wide_mul:ident, $rhs:ident,
+		//result matrix shape
+		($struct_outer: ident { $($field_outer: ident), + }),//MatY
+		$rhs_struct_inner: tt,//VecZ
+		//inner loop shape
+		$struct_inner: tt,//VecX
+		$rhs_matrix: tt//MatX
+
+	) => {
+		$struct_outer {
+			$(
+				$field_outer: $crate::impl_matrix_wide_dot_inner!{
+					$lhs, $field_outer, $wide_mul, $rhs,
+					$struct_inner, //VecX
+					$struct_inner, //VecX
+					$rhs_struct_inner, //VecZ
+					$rhs_matrix //MatX
+				}
+			), +
+		}
+	}
+}
+
+// Notes:
+// Mat3<Vec2>.dot(Vec2) -> Vec3
+// lhs.dot(rhs) -> out
+// lhs = Mat3<Vec4>
+// rhs = Mat4<Vec2>
+// out = Mat3<Vec2>
+// Mat3<Vec4>.dot(Mat4<Vec2>) -> Mat3<Vec2>
+// how to matrix multiply:
+// RHS TRANSPOSE
+// Mat4<Vec2> -> Mat2<Vec4>
+// rhs_t = Mat2<Vec4>
+// inner loop:
+// out[y][x] = lhs[y].dot(rhs_t[x])
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_wide_dot {
 	(
-		//TODO: Fixed point impls
 		($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),
@@ -103,13 +207,15 @@ macro_rules! impl_matrix_wide_mul {
 			paste::item!{
 			#[inline]
 			pub fn [<wide_dot_ $size_outer x $size_inner _ $size_inner x $rhs_size_inner _ $lhs _ $rhs>](self,rhs:$matrix_inner<$rhs_struct_inner<fixed_wide::fixed::Fixed<{$rhs},{$rhs*32}>>>)->$struct_outer<$rhs_struct_inner<fixed_wide::fixed::Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>>>{
-				//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_ $lhs _ $rhs>](trax)
-					).to_vector()
+				$crate::impl_matrix_wide_dot_outer!(
+					//constituent idents
+					self,[<wide_mul_ $lhs _ $rhs>],rhs,
+					//result matrix shape
+					($struct_outer { $($field_outer), + }),
+					($rhs_struct_inner { $($rhs_field_inner), + }),
+					//inner loop shape
+					($struct_inner { $($field_inner), + }),
+					($matrix_inner { $($matrix_field_inner), + })
 				)
 			}
 			}
@@ -119,32 +225,32 @@ macro_rules! impl_matrix_wide_mul {
 
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_mul_shim {
+macro_rules! impl_matrix_wide_dot_shim {
 	(
 		($outer_info:tt,$inner_info:tt,$rhs_info:tt),
 		($lhs: expr, $rhs: expr)
 	) => {
-		$crate::impl_matrix_wide_mul!($outer_info,$inner_info,$rhs_info,($lhs,$rhs));
+		$crate::impl_matrix_wide_dot!($outer_info,$inner_info,$rhs_info,($lhs,$rhs));
 	}
 }
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_mul_8x8 {
+macro_rules! impl_matrix_wide_dot_8x8 {
 	(
 		($outer_info:tt,$inner_info:tt),
 		$rhs_info:tt
 	) => {
-		$crate::do_macro_8x8!(impl_matrix_wide_mul_shim,($outer_info,$inner_info,$rhs_info));
+		$crate::do_macro_8x8!(impl_matrix_wide_dot_shim,($outer_info,$inner_info,$rhs_info));
 	}
 }
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
-macro_rules! impl_matrix_wide_mul_repeat_rhs {
+macro_rules! impl_matrix_wide_dot_repeat_rhs {
 	(
 		($outer_info:tt,($($rhs_info:tt),+)),
 		$inner_info:tt
 	) => {
-		$crate::macro_repeated!(impl_matrix_wide_mul_8x8,($outer_info,$inner_info),$($rhs_info),+);
+		$crate::macro_repeated!(impl_matrix_wide_dot_8x8,($outer_info,$inner_info),$($rhs_info),+);
 	}
 }
 #[doc(hidden)]
@@ -187,6 +293,72 @@ macro_rules! impl_wide_matrix_operations_1arg_not_const_generic {
 	};
 }
 
+#[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_3x3_det_not_const_generic {
+	(
+		$n: expr,
+		$_2n: expr
+	)=>{
+		impl Matrix3<Vector3<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 Matrix3<Vector3<fixed_wide::fixed::Fixed<$n,{$n*32}>>>{
+			paste::item!{
+			pub fn [<wide_adjugate_3x3_ $n>](self)->Matrix3<Vector3<fixed_wide::fixed::Fixed<{$n*2},{$n*2*32}>>>{
+				Matrix3{
+					x_axis:Vector3{x:self.y_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.z)-self.y_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.y),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),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)},
+					y_axis:Vector3{x:self.y_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.x)-self.y_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.z),y:self.x_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.z)-self.x_axis.z.[<wide_mul_ $n _ $n>](self.z_axis.x),z:self.x_axis.z.[<wide_mul_ $n _ $n>](self.y_axis.x)-self.x_axis.x.[<wide_mul_ $n _ $n>](self.y_axis.z)},
+					z_axis:Vector3{x:self.y_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.y)-self.y_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.x),y:self.x_axis.y.[<wide_mul_ $n _ $n>](self.z_axis.x)-self.x_axis.x.[<wide_mul_ $n _ $n>](self.z_axis.y),z: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,());
+	}
+}
+
 // HACK: Allows us to sum repeating tokens in macros.
 // See: https://stackoverflow.com/a/60187870/17452730
 #[doc(hidden)]

fixed_wide_vectors/src/macros/matrix.rs

@@ -48,7 +48,7 @@ macro_rules! impl_matrix_inner_shim {
 	) => {
 		$crate::macro_repeated!(impl_matrix_inner,$matrix_info,$($vector_info),+);
 		#[cfg(feature="fixed_wide")]
-		$crate::macro_repeated!(impl_matrix_wide_mul_repeat_rhs,($matrix_info,($($vector_info),+)),$($vector_info),+);
+		$crate::macro_repeated!(impl_matrix_wide_dot_repeat_rhs,($matrix_info,($($vector_info),+)),$($vector_info),+);
 	}
 }
 #[doc(hidden)]
@@ -152,6 +152,15 @@ macro_rules! matrix_transpose_inner {
 	}
 }
 
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_matrix_3x3 {
+	()=>{
+		#[cfg(feature="fixed_wide")]
+		$crate::impl_matrix_wide_3x3!();
+	}
+}
+
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
 macro_rules! impl_matrix_operator {

fixed_wide_vectors/src/macros/vector.rs

@@ -144,3 +144,12 @@ macro_rules! impl_vector_operator {
 		}
 	};
 }
+
+#[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

@@ -34,3 +34,6 @@ crate::impl_matrices!(
 		(Vector4 { x, y, z, w }, Matrix4 { x_axis, y_axis, z_axis, w_axis }, 4)
 	)
 );
+
+//Special case 3x3 matrix operations because I cba to write macros for the arbitrary cases
+crate::impl_matrix_3x3!();

fixed_wide_vectors/src/tests/fixed_wide.rs

@@ -61,3 +61,34 @@ fn wide_matrix_dot(){
 		])
 	);
 }
+
+#[test]
+fn wide_matrix_det(){
+	let m=Matrix3::from([
+		Vector3::from([Planar64::from(1),Planar64::from(2),Planar64::from(3)]),
+		Vector3::from([Planar64::from(4),Planar64::from(5),Planar64::from(7)]),
+		Vector3::from([Planar64::from(6),Planar64::from(8),Planar64::from(9)]),
+	]);
+	// 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));
+}
+
+#[test]
+fn wide_matrix_adjugate(){
+	let m=Matrix3::from([
+		Vector3::from([Planar64::from(1),Planar64::from(2),Planar64::from(3)]),
+		Vector3::from([Planar64::from(4),Planar64::from(5),Planar64::from(7)]),
+		Vector3::from([Planar64::from(6),Planar64::from(8),Planar64::from(9)]),
+	]);
+	// 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(),
+		Matrix3::from([
+			Vector3::from([Planar64Wide1::from(-11),Planar64Wide1::from(6),Planar64Wide1::from(-1)]),
+			Vector3::from([Planar64Wide1::from(6),Planar64Wide1::from(-9),Planar64Wide1::from(5)]),
+			Vector3::from([Planar64Wide1::from(2),Planar64Wide1::from(4),Planar64Wide1::from(-3)]),
+		])
+	);
+}

fixed_wide_vectors/src/vector.rs

@@ -79,3 +79,6 @@ crate::impl_matrix_inner!((Vector3 { x, y, z }, Vector3 { x, y, z }, 3), (Vector
 crate::impl_matrix_inner!((Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), (Vector2 { x, y }, Vector2 { x, y }, 2) );
 crate::impl_matrix_inner!((Vector4 { x, y, z, w }, Vector4 { x, y, z, w }, 4), (Vector3 { x, y, z }, Vector3 { x, y, z }, 3) );
 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) );
+
+//cross product
+crate::impl_vector_3!();