alg_tools: comparison src/direct

-:9b782aa6b452
+:0fabd0b5914c
 }
 }
 };
 }
+impl_binary!(Add, add);
+impl_binary!(Sub, sub);
 macro_rules! impl_binary_mut {
 ($trait:ident, $fn:ident) => {
 impl<'a, A, B, C, D> $trait<Pair<C, D>> for Pair<A, B>
 where
 A: $trait<C>,
 }
 }
 };
 }
-impl_binary!(Add, add);
-impl_binary!(Sub, sub);
 impl_binary_mut!(AddAssign, add_assign);
 impl_binary_mut!(SubAssign, sub_assign);
+macro_rules! impl_scalar_mut {
+($trait:ident, $fn:ident) => {
+impl<'a, A, B, F> $trait<F> for Pair<A, B>
+where
+A: $trait<F>,
+B: $trait<F>,
+{
+fn $fn(&mut self, t: F) {
+let Pair(ref mut a, ref mut b) = self;
+a.$fn(t);
+b.$fn(t);
+}
+}
+};
+}
+impl_scalar_mut!(MulAssign, mul_assign);
+impl_scalar_mut!(DivAssign, div_assign);
 #[macro_export]
 macro_rules! impl_pair_vectorspace_ops {
 (($a:ty, $b:ty), $field:ty) => {
 //impl_pair_vectorspace_ops!(@binary, ($a, $b), Add, add);
 // impl_pair_vectorspace_ops!(@scalar, ($a, $b), $field, Div, div);
 // Compiler overflow
 // $(
 //     impl_pair_vectorspace_ops!(@scalar_lhs, ($a, $b), $field, $impl_scalarlhs_op, Mul, mul);
 // )*
-impl_pair_vectorspace_ops!(@scalar_assign, ($a, $b), $field, MulAssign, mul_assign);
-impl_pair_vectorspace_ops!(@scalar_assign, ($a, $b), $field, DivAssign, div_assign);
-};
-(@binary, ($a : ty, $b : ty), $trait : ident, $fn : ident) => {
-impl_binop!(($a, $b), $trait, $fn, ref, ref);
-impl_binop!(($a, $b), $trait, $fn, ref, noref);
-impl_binop!(($a, $b), $trait, $fn, noref, ref);
-impl_binop!(($a, $b), $trait, $fn, noref, noref);
 };
 (@scalar, ($a : ty, $b : ty), $field : ty, $trait : ident, $fn :ident) => {
 impl_scalarop!(($a, $b), $field, $trait, $fn, ref);
 impl_scalarop!(($a, $b), $field, $trait, $fn, noref);
 };
 impl_pair_vectorspace_ops_gen!(@scalar, $field, Mul, mul);
 impl_pair_vectorspace_ops_gen!(@scalar, $field, Div, div);
 // impl_pair_vectorspace_ops_gen!(@scalar_assign, $field, MulAssign, mul_assign);
 // impl_pair_vectorspace_ops_gen!(@scalar_assign, $field, DivAssign, div_assign);
 };
-// (@binary, $trait : ident, $fn : ident) => {
-//     impl_binop_gen!(($a, $b), $trait, $fn, ref, ref);
-//     impl_binop_gen!(($a, $b), $trait, $fn, ref, noref);
-//     impl_binop_gen!(($a, $b), $trait, $fn, noref, ref);
-//     impl_binop_gen!(($a, $b), $trait, $fn, noref, noref);
-// };
-// (@assign, $trait : ident, $fn :ident) => {
-//     impl_assignop_gen!(($a, $b), $trait, $fn, ref);
-//     impl_assignop_gen!(($a, $b), $trait, $fn, noref);
-// };
 (@scalar, $field : ty, $trait : ident, $fn :ident) => {
 impl_scalarop_gen!($field, $trait, $fn, ref);
 impl_scalarop_gen!($field, $trait, $fn, noref);
 };
 // (@scalar_lhs, $field : ty, $trait : ident, $fn : ident) => {
 }
 impl_pair_vectorspace_ops_gen!(f32);
 impl_pair_vectorspace_ops_gen!(f64);
-impl_pair_vectorspace_ops!((f32, f32), f32);
+//impl_pair_vectorspace_ops!((f32, f32), f32);
-impl_pair_vectorspace_ops!((f64, f64), f64);
+//impl_pair_vectorspace_ops!((f64, f64), f64);
-type PairOutput<F, A, B> = Pair<<A as Euclidean<F>>::Output, <B as Euclidean<F>>::Output>;
 /// We need to restrict `A` and `B` as [`Euclidean`] to have closed `Output`
-/// to avoid compiler overflows that the requirement
-/// ```
+impl<A, B, F: Float> Euclidean<F> for Pair<A, B>
-/// Pair<<A as Euclidean<F>>::Output, <B as Euclidean<F>>::Output> : Euclidean<F>
+where
-/// ```
+A: Euclidean<F>,
-/// would generate.
+B: Euclidean<F>,
+//Pair<A, B>: Euclidean<F>,
-macro_rules! impl_euclidean {
+Self: Sized
-($field:ty) => {
++ Mul<F, Output = Pair<A, B>>
-impl<A, B> Euclidean<$field> for Pair<A, B>
++ MulAssign<F>
-where
++ Div<F, Output = Pair<A, B>>
-A: Euclidean<$field>,
++ DivAssign<F>
-B: Euclidean<$field>,
++ Add<Self, Output = Pair<A, B>>
-PairOutput<$field, A, B>: Euclidean<$field>,
++ Sub<Self, Output = Pair<A, B>>
-Self: Sized
++ for<'b> Add<&'b Self, Output = Pair<A, B>>
-+ Mul<$field, Output = PairOutput<$field, A, B>>
++ for<'b> Sub<&'b Self, Output = Pair<A, B>>
-+ MulAssign<$field>
++ AddAssign<Self>
-+ Div<$field, Output = PairOutput<$field, A, B>>
++ for<'b> AddAssign<&'b Self>
-+ DivAssign<$field>
++ SubAssign<Self>
-+ Add<Self, Output = PairOutput<$field, A, B>>
++ for<'b> SubAssign<&'b Self>
-+ Sub<Self, Output = PairOutput<$field, A, B>>
++ Neg<Output = Pair<A, B>>,
-+ for<'b> Add<&'b Self, Output = PairOutput<$field, A, B>>
+{
-+ for<'b> Sub<&'b Self, Output = PairOutput<$field, A, B>>
+type Output = Pair<A, B>;
-+ AddAssign<Self>
-+ for<'b> AddAssign<&'b Self>
+fn dot<I: Instance<Self>>(&self, other: I) -> F {
-+ SubAssign<Self>
+let Pair(u, v) = other.decompose();
-+ for<'b> SubAssign<&'b Self>, //+ Neg<Output = PairOutput<$field, A, B>>,
+self.0.dot(u) + self.1.dot(v)
-{
+}
-type Output = PairOutput<$field, A, B>;
+fn norm2_squared(&self) -> F {
-fn dot<I: Instance<Self>>(&self, other: I) -> $field {
+self.0.norm2_squared() + self.1.norm2_squared()
-let Pair(u, v) = other.decompose();
+}
-self.0.dot(u) + self.1.dot(v)
-}
+fn dist2_squared<I: Instance<Self>>(&self, other: I) -> F {
+let Pair(u, v) = other.decompose();
-fn norm2_squared(&self) -> $field {
+self.0.dist2_squared(u) + self.1.dist2_squared(v)
-self.0.norm2_squared() + self.1.norm2_squared()
+}
 }
-fn dist2_squared<I: Instance<Self>>(&self, other: I) -> $field {
-let Pair(u, v) = other.decompose();
-self.0.dist2_squared(u) + self.1.dist2_squared(v)
-}
-}
-};
-}
-impl_euclidean!(f32);
-impl_euclidean!(f64);
 impl<F, A, B, U, V> AXPY<F, Pair<U, V>> for Pair<A, B>
 where
 U: Space,
 V: Space,

comparison: src/direct_product.rs

src/direct_product.rs

Mercurial > repos > alg_tools / file comparison

comparison: src/direct_product.rs

src/direct_product.rs