#[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;Y];X])->Self{
				Self{array}
			}
			#[inline(always)]
			pub fn to_array(self)->[[T;Y];X]{
				self.array
			}
			#[inline]
			pub fn map<F,U>(self,f:F)->Matrix<X,Y,U>
			where
				F:Fn(T)->U
			{
				Matrix{
					array: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{
					array:core::array::from_fn(|_|
						array_of_iterators.each_mut().map(|iter|
							iter.next().unwrap()
						)
					)
				}
			}
			#[inline]
			// MatX<VecY>.MatY<VecZ> = MatX<VecZ>
			pub fn dot<const Z:usize,U,V>(self,rhs:Matrix<Y,Z,U>)->Matrix<X,Z,V>
			where
				T:core::ops::Mul<U,Output=V>+Copy,
				V:core::iter::Sum,
				U:Clone,
			{
				let mut array_of_iterators=rhs.array.map(|axis|axis.into_iter().cycle());
				Matrix{
					array:self.array.map(|axis|
						core::array::from_fn(|_|
							// axis dot product with transposed rhs array
							axis.iter().zip(
								array_of_iterators.each_mut().map(|iter|
									iter.next().unwrap()
								)
							).map(|(&a,b)|
								a*b
							).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{
					array:[[value;Y];X]
				}
			}
		}

		impl<const X:usize,const Y:usize,T:Default> Default for Matrix<X,Y,T>{
			fn default()->Self{
				Self{
					array:core::array::from_fn(|_|core::array::from_fn(|_|Default::default()))
				}
			}
		}
	}
}

#[doc(hidden)]
#[macro_export(local_inner_macros)]
macro_rules! impl_matrix_named_fields_shape {
	(
		($struct_outer:ident, $size_outer: expr),
		($struct_inner:ident, $size_inner: expr)
	) => {
		impl<T> core::ops::Deref for Matrix<$size_outer,$size_inner,T>{
			type Target=$struct_outer<$struct_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),+);
	}
}