drewcassidy/vector-victor
1
0
Fork 0
mirror of https://github.com/drewcassidy/vector-victor.git synced 2024-09-01 14:58:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor to move ops impls alongside matrix

Browse Source
This commit is contained in:
Andrew Cassidy 2023-05-17 22:44:02 -07:00
parent f697db6d35
commit 58ff79f649
4 changed files with 58 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/lib.rs
View File

@ -2,7 +2,6 @@ extern crate core;
pub mod decompose;
pub mod index;
mod macros;
mod matrix;
mod util;

1
src/macros/mod.rs
View File

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

18
src/matrix.rs → src/matrix/mod.rs
View File

@ -1,12 +1,13 @@
use crate::impl_matrix_op;
use crate::index::Index2D;
use num_traits::{Num, NumOps, One, Zero};
use num_traits::{NumOps, One, Zero};
use std::fmt::Debug;
use std::iter::{zip, Flatten, Product, Sum};
use std::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut, Mul, MulAssign, Neg};
pub mod ops;
/// A 2D array of values which can be operated upon.
///
/// Matrices have a fixed size known at compile time
@ -529,16 +530,3 @@ where
iter.fold(Self::one(), Self::mul)
}
}
impl_matrix_op!(neg);
impl_matrix_op!(!);
impl_matrix_op!(+);
impl_matrix_op!(-);
impl_matrix_op!(*);
impl_matrix_op!(/);
impl_matrix_op!(%);
impl_matrix_op!(&);
impl_matrix_op!(|);
impl_matrix_op!(^);
impl_matrix_op!(<<);
impl_matrix_op!(>>);

102
src/macros/ops.rs → src/matrix/ops.rs
View File

@ -1,58 +1,60 @@
use crate::matrix::Matrix;
use num_traits::Num;
// borrowed from the auto_ops crate
#[doc(hidden)]
#[macro_export]
macro_rules! impl_matrix_op {
(neg) => {
$crate::_impl_op_m_internal_ex!(Neg, neg);
_impl_op_m_internal_ex!(Neg, neg);
};
(!) => {
$crate::_impl_op_m_internal_ex!(Not, not);
_impl_op_m_internal_ex!(Not, not);
};
(+) => {
$crate::_impl_op_mm_internal_ex!(Add, add);
$crate::_impl_opassign_mm_internal_ex!(AddAssign, add_assign);
_impl_op_mm_internal_ex!(Add, add);
_impl_opassign_mm_internal_ex!(AddAssign, add_assign);
};
(-) => {
$crate::_impl_op_mm_internal_ex!(Sub, sub);
$crate::_impl_opassign_mm_internal_ex!(SubAssign, sub_assign);
_impl_op_mm_internal_ex!(Sub, sub);
_impl_opassign_mm_internal_ex!(SubAssign, sub_assign);
};
(*) => {
$crate::_impl_op_mm_internal_ex!(Mul, mul);
$crate::_impl_op_ms_internal_ex!(Mul, mul);
$crate::_impl_opassign_mm_internal_ex!(MulAssign, mul_assign);
$crate::_impl_opassign_ms_internal_ex!(MulAssign, mul_assign);
_impl_op_mm_internal_ex!(Mul, mul);
_impl_op_ms_internal_ex!(Mul, mul);
_impl_opassign_mm_internal_ex!(MulAssign, mul_assign);
_impl_opassign_ms_internal_ex!(MulAssign, mul_assign);
};
(/) => {
$crate::_impl_op_mm_internal_ex!(Div, div);
$crate::_impl_op_ms_internal_ex!(Div, div);
$crate::_impl_opassign_mm_internal_ex!(DivAssign, div_assign);
$crate::_impl_opassign_ms_internal_ex!(DivAssign, div_assign);
_impl_op_mm_internal_ex!(Div, div);
_impl_op_ms_internal_ex!(Div, div);
_impl_opassign_mm_internal_ex!(DivAssign, div_assign);
_impl_opassign_ms_internal_ex!(DivAssign, div_assign);
};
(%) => {
$crate::_impl_op_mm_internal_ex!(Rem, rem);
$crate::_impl_op_ms_internal_ex!(Rem, rem);
$crate::_impl_opassign_mm_internal_ex!(RemAssign, rem_assign);
$crate::_impl_opassign_ms_internal_ex!(RemAssign, rem_assign);
_impl_op_mm_internal_ex!(Rem, rem);
_impl_op_ms_internal_ex!(Rem, rem);
_impl_opassign_mm_internal_ex!(RemAssign, rem_assign);
_impl_opassign_ms_internal_ex!(RemAssign, rem_assign);
};
(&) => {
$crate::_impl_op_mm_internal_ex!(BitAnd, bitand);
$crate::_impl_opassign_mm_internal_ex!(BitAndAssign, bitand_assign);
_impl_op_mm_internal_ex!(BitAnd, bitand);
_impl_opassign_mm_internal_ex!(BitAndAssign, bitand_assign);
};
(|) => {
$crate::_impl_op_mm_internal_ex!(BitOr, bitor);
$crate::_impl_opassign_mm_internal_ex!(BitOrAssign, bitor_assign);
_impl_op_mm_internal_ex!(BitOr, bitor);
_impl_opassign_mm_internal_ex!(BitOrAssign, bitor_assign);
};
(^) => {
$crate::_impl_op_mm_internal_ex!(BitXor, bitxor);
$crate::_impl_opassign_mm_internal_ex!(BitXorAssign, bitxor_assign);
_impl_op_mm_internal_ex!(BitXor, bitxor);
_impl_opassign_mm_internal_ex!(BitXorAssign, bitxor_assign);
};
(<<) => {
$crate::_impl_op_ms_internal_ex!(Shl, shl);
$crate::_impl_opassign_ms_internal_ex!(ShlAssign, shl_assign);
_impl_op_ms_internal_ex!(Shl, shl);
_impl_opassign_ms_internal_ex!(ShlAssign, shl_assign);
};
(>>) => {
$crate::_impl_op_ms_internal_ex!(Shr, shr);
$crate::_impl_opassign_ms_internal_ex!(ShrAssign, shr_assign);
_impl_op_ms_internal_ex!(Shr, shr);
_impl_opassign_ms_internal_ex!(ShrAssign, shr_assign);
};
}
@ -60,8 +62,8 @@ macro_rules! impl_matrix_op {
#[macro_export]
macro_rules! _impl_op_m_internal_ex {
($ops_trait:ident, $ops_fn:ident) => {
$crate::_impl_op_m_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, Matrix<L,M,N>);
$crate::_impl_op_m_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, Matrix<L,M,N>);
_impl_op_m_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, Matrix<L,M,N>);
_impl_op_m_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, Matrix<L,M,N>);
}
}
@ -69,10 +71,10 @@ macro_rules! _impl_op_m_internal_ex {
#[macro_export]
macro_rules! _impl_op_mm_internal_ex {
($ops_trait:ident, $ops_fn:ident) => {
$crate::_impl_op_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, Matrix<R,M,N>, Matrix<L,M,N>);
$crate::_impl_op_mm_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, Matrix<R,M,N>, Matrix<L,M,N>);
$crate::_impl_op_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, &Matrix<R,M,N>, Matrix<L,M,N>);
$crate::_impl_op_mm_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, &Matrix<R,M,N>, Matrix<L,M,N>);
_impl_op_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, Matrix<R,M,N>, Matrix<L,M,N>);
_impl_op_mm_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, Matrix<R,M,N>, Matrix<L,M,N>);
_impl_op_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, &Matrix<R,M,N>, Matrix<L,M,N>);
_impl_op_mm_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, &Matrix<R,M,N>, Matrix<L,M,N>);
}
}
@ -80,30 +82,27 @@ macro_rules! _impl_op_mm_internal_ex {
#[macro_export]
macro_rules! _impl_opassign_mm_internal_ex {
($ops_trait:ident, $ops_fn:ident) => {
$crate::_impl_opassign_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, Matrix<R,M,N>, Matrix<L,M,N>);
$crate::_impl_opassign_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, &Matrix<R,M,N>, Matrix<L,M,N>);
_impl_opassign_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, Matrix<R,M,N>, Matrix<L,M,N>);
_impl_opassign_mm_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, &Matrix<R,M,N>, Matrix<L,M,N>);
}
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_op_ms_internal_ex {
($ops_trait:ident, $ops_fn:ident) => {
$crate::_impl_op_ms_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, R, Matrix<L,M,N>);
$crate::_impl_op_ms_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, R, Matrix<L,M,N>);
_impl_op_ms_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, R, Matrix<L,M,N>);
_impl_op_ms_internal!($ops_trait, $ops_fn, &Matrix<L,M,N>, R, Matrix<L,M,N>);
}
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_opassign_ms_internal_ex {
($ops_trait:ident, $ops_fn:ident) => {
$crate::_impl_opassign_ms_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, R, Matrix<L,M,N>);
_impl_opassign_ms_internal!($ops_trait, $ops_fn, Matrix<L,M,N>, R, Matrix<L,M,N>);
}
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_op_m_internal {
($ops_trait:ident, $ops_fn:ident, $lhs:ty, $out:ty) => {
impl<L, const M: usize, const N: usize> ::std::ops::$ops_trait for $lhs
@ -127,7 +126,6 @@ macro_rules! _impl_op_m_internal {
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_op_mm_internal {
($ops_trait:ident, $ops_fn:ident, $lhs:ty, $rhs:ty, $out:ty) => {
impl<L, R, const M: usize, const N: usize> ::std::ops::$ops_trait<$rhs> for $lhs
@ -152,7 +150,6 @@ macro_rules! _impl_op_mm_internal {
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_opassign_mm_internal {
($ops_trait:ident, $ops_fn:ident, $lhs:ty, $rhs:ty, $out:ty) => {
impl<L, R, const M: usize, const N: usize> ::std::ops::$ops_trait<$rhs> for $lhs
@ -173,7 +170,6 @@ macro_rules! _impl_opassign_mm_internal {
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_op_ms_internal {
($ops_trait:ident, $ops_fn:ident, $lhs:ty, $rhs:ty, $out:ty) => {
impl<L, R, const M: usize, const N: usize> ::std::ops::$ops_trait<$rhs> for $lhs
@ -198,7 +194,6 @@ macro_rules! _impl_op_ms_internal {
}
#[doc(hidden)]
#[macro_export]
macro_rules! _impl_opassign_ms_internal {
($ops_trait:ident, $ops_fn:ident, $lhs:ty, $rhs:ty, $out:ty) => {
impl<L, R, const M: usize, const N: usize> ::std::ops::$ops_trait<$rhs> for $lhs
@ -217,3 +212,16 @@ macro_rules! _impl_opassign_ms_internal {
}
};
}
impl_matrix_op!(neg);
impl_matrix_op!(!);
impl_matrix_op!(+);
impl_matrix_op!(-);
impl_matrix_op!(*);
impl_matrix_op!(/);
impl_matrix_op!(%);
impl_matrix_op!(&);
impl_matrix_op!(|);
impl_matrix_op!(^);
impl_matrix_op!(<<);
impl_matrix_op!(>>);