alg_tools: comparison src/loc.rs

-:d14c877e14b7
+:b3c35d16affe
 For working with small vectors in $ℝ^2$ or $ℝ^3$.
 */
 use std::ops::{Add,Sub,AddAssign,SubAssign,Mul,Div,MulAssign,DivAssign,Neg,Index,IndexMut};
 use std::slice::{Iter,IterMut};
+use std::fmt::{Display, Formatter};
 use crate::types::{Float,Num,SignedNum};
 use crate::maputil::{FixedLength,FixedLengthMut,map1,map2,map1_mut,map2_mut};
 use crate::euclidean::*;
 use crate::norms::*;
-use crate::linops::AXPY;
+use crate::linops::{AXPY, Mapping, Linear};
+use crate::instance::{Instance, BasicDecomposition};
+use crate::mapping::Space;
 use serde::ser::{Serialize, Serializer, SerializeSeq};
 /// A container type for (short) `N`-dimensional vectors of element type `F`.
 ///
 /// Supports basic operations of an [`Euclidean`] space, several [`Norm`]s, and
 /// fused [`AXPY`] operations, among others.
 #[derive(Copy,Clone,Debug,PartialEq,Eq)]
 pub struct Loc<F, const N : usize>(
 /// An array of the elements of the vector
 pub [F; N]
 );
+impl<F : Display, const N : usize> Display for Loc<F, N>{
+// Required method
+fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+write!(f, "[")?;
+let mut comma = "";
+for e in self.iter() {
+write!(f, "{comma}{e}")?;
+comma = ", ";
+}
+write!(f, "]")
+}
+}
 // Need to manually implement as [F; N] serialisation is provided only for some N.
 impl<F, const N : usize> Serialize for Loc<F, N>
 where
 F: Serialize,
 fn from(other: F) -> Loc<F, 1> {
 Loc([other])
 }
 }
+impl<F> Loc<F, 1> {
+#[inline]
+pub fn flatten1d(self) -> F {
+let Loc([v]) = self;
+v
+}
+}
 impl<F, const N : usize> From<Loc<F, N>> for [F; N] {
 #[inline]
 fn from(other : Loc<F, N>) -> [F; N] {
 other.0
 }
 }
 }
 make_binop!(Add, add, AddAssign, add_assign);
 make_binop!(Sub, sub, SubAssign, sub_assign);
+impl<F : Float, const N : usize> std::iter::Sum for Loc<F, N> {
+fn sum<I: Iterator<Item = Loc<F, N>>>(mut iter: I) -> Self {
+match iter.next() {
+None => Self::ORIGIN,
+Some(mut v) => {
+for w in iter {
+v += w
+}
+v
+}
+}
+}
+}
 macro_rules! make_scalarop_rhs {
 ($trait:ident, $fn:ident, $trait_assign:ident, $fn_assign:ident) => {
 impl<F : Num, const N : usize> $trait<F> for Loc<F, N> {
 type Output = Loc<F, N>;
 domination!(Linfinity, L1);
 domination!(Linfinity, L2);
 domination!(L2, L1);
-impl<F : Num,const N : usize> Dot<Loc<F, N>,F> for Loc<F, N> {
+impl<F : Float,const N : usize> Euclidean<F> for Loc<F, N> {
+type Output = Self;
 /// This implementation is not stabilised as it's meant to be used for very small vectors.
 /// Use [`nalgebra`] for larger vectors.
 #[inline]
-fn dot(&self, other : &Loc<F, N>) -> F {
+fn dot<I : Instance<Self>>(&self, other : I) -> F {
 self.0.iter()
-.zip(other.0.iter())
+.zip(other.ref_instance().0.iter())
 .fold(F::ZERO, |m, (&v, &w)| m + v * w)
-}
-}
-impl<F : Float,const N : usize> Euclidean<F> for Loc<F, N> {
-type Output = Self;
-#[inline]
-fn similar_origin(&self) -> Self {
-Self::ORIGIN
 }
 /// This implementation is not stabilised as it's meant to be used for very small vectors.
 /// Use [`nalgebra`] for larger vectors.
 #[inline]
 fn norm2_squared(&self) -> F {
 self.iter().fold(F::ZERO, |m, &v| m + v * v)
 }
-fn dist2_squared(&self, other : &Self) -> F {
+fn dist2_squared<I : Instance<Self>>(&self, other : I) -> F {
 self.iter()
-.zip(other.iter())
+.zip(other.ref_instance().iter())
 .fold(F::ZERO, |m, (&v, &w)| { let d = v - w; m + d * d })
 }
 #[inline]
 fn norm2(&self) -> F {
 self.norm2_squared().sqrt()
 }
 }
 #[inline]
-fn dist2(&self, other : &Self) -> F {
+fn dist2<I : Instance<Self>>(&self, other : I) -> F {
 // Optimisation for N==1 that avoids squaring and square rooting.
+let otherr = other.ref_instance();
 if N==1 {
-unsafe { *self.0.get_unchecked(0) - *other.0.get_unchecked(0) }.abs()
+unsafe { *self.0.get_unchecked(0) - *otherr.0.get_unchecked(0) }.abs()
 } else {
 self.dist2_squared(other).sqrt()
 }
 }
 }
 impl<F : Num, const N : usize> Loc<F, N> {
+/// Origin point
 pub const ORIGIN : Self = Loc([F::ZERO; N]);
+}
+impl<F : Num + std::ops::Neg<Output=F>, const N : usize> Loc<F, N> {
+/// Reflects along the given coordinate
+pub fn reflect(mut self, i : usize) -> Self {
+self[i] = -self[i];
+self
+}
+/// Reflects along the given coordinate sequences
+pub fn reflect_many<I : IntoIterator<Item=usize>>(mut self, idxs : I) -> Self {
+for i in idxs {
+self[i]=-self[i]
+}
+self
+}
+}
+impl<F : std::ops::Neg<Output=F>> Loc<F, 2> {
+/// Reflect x coordinate
+pub fn reflect_x(self) -> Self {
+let Loc([x, y]) = self;
+[-x, y].into()
+}
+/// Reflect y coordinate
+pub fn reflect_y(self) -> Self {
+let Loc([x, y]) = self;
+[x, -y].into()
+}
+}
+impl<F : Float> Loc<F, 2> {
+/// Rotate by angle φ
+pub fn rotate(self, φ : F) -> Self {
+let Loc([x, y]) = self;
+let sin_φ = φ.sin();
+let cos_φ = φ.cos();
+[cos_φ * x - sin_φ * y,
+sin_φ * x + cos_φ * y].into()
+}
+}
+impl<F : std::ops::Neg<Output=F>> Loc<F, 3> {
+/// Reflect x coordinate
+pub fn reflect_x(self) -> Self {
+let Loc([x, y, z]) = self;
+[-x, y, z].into()
+}
+/// Reflect y coordinate
+pub fn reflect_y(self) -> Self {
+let Loc([x, y, z]) = self;
+[x, -y, z].into()
+}
+/// Reflect y coordinate
+pub fn reflect_z(self) -> Self {
+let Loc([x, y, z]) = self;
+[x, y, -z].into()
+}
+}
+impl<F : Float> Loc<F, 3> {
+/// Rotate by angles (yaw, pitch, roll)
+pub fn rotate(self, Loc([φ, ψ, θ]) : Self) -> Self {
+let Loc([mut x, mut y, mut z]) = self;
+let sin_φ = φ.sin();
+let cos_φ = φ.cos();
+[x, y, z] = [cos_φ * x - sin_φ *y,
+sin_φ * x + cos_φ * y,
+z];
+let sin_ψ = ψ.sin();
+let cos_ψ = ψ.cos();
+[x, y, z] = [cos_ψ * x + sin_ψ * z,
+y,
+-sin_ψ * x + cos_ψ * z];
+let sin_θ = θ.sin();
+let cos_θ = θ.cos();
+[x, y, z] = [x,
+cos_θ * y - sin_θ * z,
+sin_θ * y + cos_θ * z];
+[x, y, z].into()
+}
 }
 impl<F : Float,const N : usize> StaticEuclidean<F> for Loc<F, N> {
 #[inline]
 fn origin() -> Self {
 Self::ORIGIN
 }
 }
+/// The default norm for `Loc` is [`L2`].
+impl<F : Float, const N : usize> Normed<F> for Loc<F, N> {
+type NormExp = L2;
+#[inline]
+fn norm_exponent(&self) -> Self::NormExp {
+L2
+}
+// #[inline]
+// fn similar_origin(&self) -> Self {
+//     [F::ZERO; N].into()
+// }
+#[inline]
+fn is_zero(&self) -> bool {
+self.norm2_squared() == F::ZERO
+}
+}
+impl<F : Float, const N : usize> HasDual<F> for Loc<F, N> {
+type DualSpace = Self;
+}
 impl<F : Float, const N : usize> Norm<F, L2> for Loc<F, N> {
 #[inline]
 fn norm(&self, _ : L2) -> F { self.norm2() }
 }
 impl<F : Float, const N : usize> Dist<F, L2> for Loc<F, N> {
 #[inline]
-fn dist(&self, other : &Self, _ : L2) -> F { self.dist2(other) }
+fn dist<I : Instance<Self>>(&self, other : I, _ : L2) -> F { self.dist2(other) }
 }
+/* Implemented automatically as Euclidean.
+impl<F : Float, const N : usize> Projection<F, L2> for Loc<F, N> {
+#[inline]
+fn proj_ball_mut(&mut self, ρ : F, nrm : L2) {
+let n = self.norm(nrm);
+if n > ρ {
+*self *= ρ/n;
+}
+}
+}*/
 impl<F : Float, const N : usize> Norm<F, L1> for Loc<F, N> {
 /// This implementation is not stabilised as it's meant to be used for very small vectors.
 /// Use [`nalgebra`] for larger vectors.
 #[inline]
 }
 }
 impl<F : Float, const N : usize> Dist<F, L1> for Loc<F, N> {
 #[inline]
-fn dist(&self, other : &Self, _ : L1) -> F {
+fn dist<I : Instance<Self>>(&self, other : I, _ : L1) -> F {
 self.iter()
-.zip(other.iter())
+.zip(other.ref_instance().iter())
 .fold(F::ZERO, |m, (&v, &w)| m + (v-w).abs() )
 }
 }
 impl<F : Float, const N : usize> Projection<F, Linfinity> for Loc<F, N> {
 }
 }
 impl<F : Float, const N : usize> Dist<F, Linfinity> for Loc<F, N> {
 #[inline]
-fn dist(&self, other : &Self, _ : Linfinity) -> F {
+fn dist<I : Instance<Self>>(&self, other : I, _ : Linfinity) -> F {
 self.iter()
-.zip(other.iter())
+.zip(other.ref_instance().iter())
 .fold(F::ZERO, |m, (&v, &w)| m.max((v-w).abs()))
 }
 }
 fn fl_iter(self) -> Self::Iter {
 self.iter()
 }
 }
-impl<F : Num, const N : usize> AXPY<F, Loc<F, N>> for Loc<F, N> {
+impl<F : Num, const N : usize> Space for Loc<F, N> {
-#[inline]
+type Decomp = BasicDecomposition;
-fn axpy(&mut self, α : F, x : &Loc<F, N>, β : F) {
+}
-if β == F::ZERO {
-map2_mut(self, x, |yi, xi| { *yi = α * (*xi) })
+impl<F : Float, const N : usize> Mapping<Loc<F, N>> for Loc<F, N> {
-} else {
+type Codomain = F;
-map2_mut(self, x, |yi, xi| { *yi = β * (*yi) + α * (*xi) })
-}
+fn apply<I : Instance<Loc<F, N>>>(&self, x : I) -> Self::Codomain {
-}
+x.eval(|x̃| self.dot(x̃))
+}
-#[inline]
+}
-fn copy_from(&mut self, x : &Loc<F, N>) {
-map2_mut(self, x, |yi, xi| *yi = *xi )
+impl<F : Float, const N : usize> Linear<Loc<F, N>> for Loc<F, N> { }
-}
-}
+impl<F : Float, const N : usize> AXPY<F, Loc<F, N>> for Loc<F, N> {
+type Owned = Self;
+#[inline]
+fn axpy<I : Instance<Loc<F, N>>>(&mut self, α : F, x : I, β : F) {
+x.eval(|x̃| {
+if β == F::ZERO {
+map2_mut(self, x̃, |yi, xi| { *yi = α * (*xi) })
+} else {
+map2_mut(self, x̃, |yi, xi| { *yi = β * (*yi) + α * (*xi) })
+}
+})
+}
+#[inline]
+fn copy_from<I : Instance<Loc<F, N>>>(&mut self, x : I) {
+x.eval(|x̃| map2_mut(self, x̃, |yi, xi| *yi = *xi ))
+}
+#[inline]
+fn similar_origin(&self) -> Self::Owned {
+Self::ORIGIN
+}
+#[inline]
+fn set_zero(&mut self) {
+*self = Self::ORIGIN;
+}
+}

Mercurial > repos > alg_tools / file comparison

comparison: src/loc.rs

src/loc.rs