Struct pythagore::force::force_nd::Force

pub struct Force<N: Num, const D: usize> { /* private fields */ }

Force<N, D> structure for D dimension forces

Implementations

impl<N: Copy + Num, const D: usize> Force<N, D>

pub fn null() -> Self

Returns a null force

Example

use pythagore::{force, Force2D, Force3D};

assert_eq!(Force2D::null(), force!{ dx: 0, dy: 0 });
assert_eq!(Force3D::null(), force!{ dx: 0, dy: 0, dz: 0 });

pub fn is_null(&self) -> bool

Returns true if force is null

impl<N: Num, const D: usize> Force<N, D>

pub fn iter(&self) -> Iter<'_, N>

Returns iterator on force elements

pub fn iter_mut(&mut self) -> IterMut<'_, N>

Returns iterator on force elements

impl<N: Copy + Num + Sum, const D: usize> Force<N, D>

pub fn square_norm(&self) -> N

Returns the squared norm of force

Example

use pythagore::force;

assert_eq!(force!{ dx: 2, dy: 3 }.square_norm(), 13);
assert_eq!(force!{ dx: 2, dy: 3, dz: 4 }.square_norm(), 29);

impl<N: Copy + Float + Sum, const D: usize> Force<N, D>

pub fn norm(&self) -> N

Returns the norm of force (only for float forces)

Example

use pythagore::force;

assert_eq!(force!{ dx: 1.0, dy: 0.0 }.norm(), 1.0);
assert_eq!(force!{ dx: 0.0, dy: 0.0, dz: 4.0 }.norm(), 4.0);

pub fn unit(&self) -> Self

Returns a unit force from force (only for float forces)

Example

use pythagore::force;

assert_eq!(force!{ dx: 10.0, dy: 0.0 }.unit(), force!{ dx: 1.0, dy: 0.0 });
assert_eq!(force!{ dx: 0.0, dy: 0.0, dz: 5.0 }.unit(), force!{ dx: 0.0, dy: 0.0, dz: 1.0 });

impl<N: Copy + Signed + Sum, const D: usize> Force<N, D>

pub fn manhattan_norm(&self) -> N

Returns the norm of force (only for signed forces)

Example

use pythagore::force;

assert_eq!(force!{ dx: 1, dy: -2 }.manhattan_norm(), 3);
assert_eq!(force!{ dx: 1, dy: -2, dz: 3 }.manhattan_norm(), 6);

impl<N: Copy + Num> Force<N, 4>

pub fn unit_dx() -> Self

Returns dx unit force

Example

use pythagore::{force, Force3D};

assert_eq!(Force3D::unit_dx(), force!{ dx: 1, dy: 0, dz: 0 });

pub fn unit_dy() -> Self

Returns dy unit force

Example

use pythagore::{force, Force3D};

assert_eq!(Force3D::unit_dy(), force!{ dx: 0, dy: 1, dz: 0 });

pub fn unit_dz() -> Self

Returns dz unit force

Example

use pythagore::{force, Force3D};

assert_eq!(Force3D::unit_dz(), force!{ dx: 0, dy: 0, dz: 1 });

pub fn dx(&self) -> &N

Returns ref on dx element of force

Example

use pythagore::force;

assert_eq!(force!{ dx: 1, dy: 2, dz: 3 }.dx(), &1);

pub fn dx_mut(&mut self) -> &mut N

Returns mutable ref on dx element of force

Example

use pythagore::force;

let mut v = force!{ dx: 1, dy: 2, dz: 3 };
*v.dx_mut() = 5;

assert_eq!(v.dx(), &5);

pub fn dy(&self) -> &N

Returns ref on dy element of force

Example

use pythagore::force;

assert_eq!(force!{ dx: 1, dy: 2, dz: 3 }.dy(), &2);

pub fn dy_mut(&mut self) -> &mut N

Returns mutable ref on dy element of force

Example

use pythagore::force;

let mut v = force!{ dx: 1, dy: 2, dz: 3 };
*v.dy_mut() = 5;

assert_eq!(v.dy(), &5);

pub fn dz(&self) -> &N

Returns ref on dz element of force

Example

use pythagore::force;

assert_eq!(force!{ dx: 1, dy: 2, dz: 3 }.dz(), &3);

pub fn dz_mut(&mut self) -> &mut N

Returns mutable ref on dz element of force

Example

use pythagore::force;

let mut v = force!{ dx: 1, dy: 2, dz: 3 };
*v.dz_mut() = 5;

assert_eq!(v.dz(), &5);

impl<N: Copy + Num> Force<N, 3>

pub fn unit_dx() -> Self

Returns dx unit force

Example

use pythagore::{force, Force2D};

assert_eq!(Force2D::unit_dx(), force!{ dx: 1, dy: 0 });

pub fn unit_dy() -> Self

Returns dy unit force

Example

use pythagore::{force, Force2D};

assert_eq!(Force2D::unit_dy(), force!{ dx: 0, dy: 1 });

pub fn dx(&self) -> &N

Returns ref on dx element of force

Example

use pythagore::force;

assert_eq!(force!{ dx: 1, dy: 2 }.dx(), &1);

pub fn dx_mut(&mut self) -> &mut N

Returns mutable ref on dx element of force

Example

use pythagore::force;

let mut v = force!{ dx: 1, dy: 2 };
*v.dx_mut() = 5;

assert_eq!(v.dx(), &5);

pub fn dy(&self) -> &N

Returns ref on dy element of force

Example

use pythagore::force;

assert_eq!(force!{ dx: 1, dy: 2 }.dy(), &2);

pub fn dy_mut(&mut self) -> &mut N

Returns mutable ref on dy element of force

Example

use pythagore::force;

let mut v = force!{ dx: 1, dy: 2 };
*v.dy_mut() = 5;

assert_eq!(v.dy(), &5);

Trait Implementations

impl<N: Copy + Num, const D: usize> Add<&Force<N, D>> for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the + operator.

fn add(self, rhs: &Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<&Force<N, D>> for &Point<N, D>

type Output = Point<N, D>

The resulting type after applying the + operator.

fn add(self, rhs: &Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<&Force<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<&Force<N, D>> for Point<N, D>

type Output = <&'static Point<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<&Point<N, D>> for &Force<N, D>

type Output = <&'static Point<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Point<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<&Point<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Add<&'static Point<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Point<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<Force<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<Force<N, D>> for &Point<N, D>

type Output = <&'static Point<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<Force<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<Force<N, D>> for Point<N, D>

type Output = <&'static Point<N, D> as Add<&'static Force<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Force<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<Point<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Add<&'static Point<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Point<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num, const D: usize> Add<Point<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Add<&'static Point<N, D>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Point<N, D>) -> Self::Output

Performs the + operation.

impl<N: Copy + Num + AddAssign, const D: usize> AddAssign<&Force<N, D>> for Force<N, D>

fn add_assign(&mut self, rhs: &Force<N, D>)

Performs the += operation.

impl<N: Copy + Num + AddAssign, const D: usize> AddAssign<&Force<N, D>> for Point<N, D>

fn add_assign(&mut self, rhs: &Force<N, D>)

Performs the += operation.

impl<N: Copy + Num + AddAssign, const D: usize> AddAssign<Force<N, D>> for Force<N, D>

fn add_assign(&mut self, rhs: Force<N, D>)

Performs the += operation.

impl<N: Copy + Num + AddAssign, const D: usize> AddAssign<Force<N, D>> for Point<N, D>

fn add_assign(&mut self, rhs: Force<N, D>)

Performs the += operation.

impl<N: Num, const D: usize> AsRef<Vector<N, D>> for Force<N, D>

fn as_ref(&self) -> &Vector<N, D>

Converts this type into a shared reference of the (usually inferred) input type.

impl<N: Clone + Num, const D: usize> Clone for Force<N, D>

fn clone(&self) -> Force<N, D>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N: Debug + Num, const D: usize> Debug for Force<N, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<N: Copy + Num, const D: usize> Default for Force<N, D>

fn default() -> Self

Returns the “default value” for a type.

impl<N: Copy + Num, const D: usize> Div<&N> for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the / operator.

fn div(self, rhs: &N) -> Self::Output

Performs the / operation.

impl<N: Copy + Num, const D: usize> Div<&N> for Force<N, D>

type Output = <&'static Force<N, D> as Div<&'static N>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &N) -> Self::Output

Performs the / operation.

impl<N: Copy + Num, const D: usize> Div<N> for &Force<N, D>

type Output = <&'static Force<N, D> as Div<&'static N>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: N) -> Self::Output

Performs the / operation.

impl<N: Copy + Num, const D: usize> Div<N> for Force<N, D>

type Output = <&'static Force<N, D> as Div<&'static N>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: N) -> Self::Output

Performs the / operation.

impl<N: Copy + Num + DivAssign, const D: usize> DivAssign<&N> for Force<N, D>

fn div_assign(&mut self, rhs: &N)

Performs the /= operation.

impl<N: Copy + Num + DivAssign, const D: usize> DivAssign<N> for Force<N, D>

fn div_assign(&mut self, rhs: N)

Performs the /= operation.

impl<N: Copy + Num, const D: usize> FromIterator<N> for Force<N, D>

fn from_iter<T: IntoIterator<Item = N>>(iter: T) -> Self

Creates a value from an iterator.

impl<N: Num + Hash, const D: usize> Hash for Force<N, D>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<N: Num, I: SliceIndex<[N]>, const D: usize> Index<I> for Force<N, D>

type Output = <I as SliceIndex<[N]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<N: Num, I: SliceIndex<[N]>, const D: usize> IndexMut<I> for Force<N, D>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, N: Num, const D: usize> IntoIterator for &'a Force<N, D>

type Item = &'a N

The type of the elements being iterated over.

type IntoIter = Iter<'a, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, N: Num, const D: usize> IntoIterator for &'a mut Force<N, D>

type Item = &'a mut N

The type of the elements being iterated over.

type IntoIter = IterMut<'a, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Force<N, D>> for &Force<N, D>

type Output = N

The resulting type after applying the * operator.

fn mul(self, rhs: &Force<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Force<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Force<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Force<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num, const D: usize> Mul<&N> for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &N) -> Self::Output

Performs the * operation.

impl<N: Copy + Num, const D: usize> Mul<&N> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static N>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &N) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Force<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Force<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Force<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Force<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Force<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Force<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num, const D: usize> Mul<N> for &Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static N>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl<N: Copy + Num, const D: usize> Mul<N> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static N>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + MulAssign, const D: usize> MulAssign<&N> for Force<N, D>

fn mul_assign(&mut self, rhs: &N)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<&Transform<N, D>> for Force<N, D>

fn mul_assign(&mut self, rhs: &Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Num + MulAssign, const D: usize> MulAssign<N> for Force<N, D>

fn mul_assign(&mut self, rhs: N)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<Transform<N, D>> for Force<N, D>

fn mul_assign(&mut self, rhs: Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Signed, const D: usize> Neg for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N: Copy + Signed, const D: usize> Neg for Force<N, D>

type Output = <&'static Force<N, D> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N: Num, const D: usize> PartialEq<Force<N, D>> for Force<N, D>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: Copy + Num, const D: usize> Sub<&Force<N, D>> for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the - operator.

fn sub(self, rhs: &Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<&Force<N, D>> for &Point<N, D>

type Output = Point<N, D>

The resulting type after applying the - operator.

fn sub(self, rhs: &Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<&Force<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<&Force<N, D>> for Point<N, D>

type Output = <&'static Point<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<&Point<N, D>> for &Force<N, D>

type Output = <&'static Point<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<&Point<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Sub<&'static Point<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<Force<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<Force<N, D>> for &Point<N, D>

type Output = <&'static Point<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<Force<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<Force<N, D>> for Point<N, D>

type Output = <&'static Point<N, D> as Sub<&'static Force<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Force<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<Point<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Sub<&'static Point<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Point<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num, const D: usize> Sub<Point<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Sub<&'static Point<N, D>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Point<N, D>) -> Self::Output

Performs the - operation.

impl<N: Copy + Num + SubAssign, const D: usize> SubAssign<&Force<N, D>> for Force<N, D>

fn sub_assign(&mut self, rhs: &Force<N, D>)

Performs the -= operation.

impl<N: Copy + Num + SubAssign, const D: usize> SubAssign<&Force<N, D>> for Point<N, D>

fn sub_assign(&mut self, rhs: &Force<N, D>)

Performs the -= operation.

impl<N: Copy + Num + SubAssign, const D: usize> SubAssign<Force<N, D>> for Force<N, D>

fn sub_assign(&mut self, rhs: Force<N, D>)

Performs the -= operation.

impl<N: Copy + Num + SubAssign, const D: usize> SubAssign<Force<N, D>> for Point<N, D>

fn sub_assign(&mut self, rhs: Force<N, D>)

Performs the -= operation.

impl<N: Num, const D: usize> TryFrom<Vector<N, D>> for Force<N, D>

type Error = ForceMustEndWithZeroError

The type returned in the event of a conversion error.

fn try_from(vector: Vector<N, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<N: Copy + Num, const D: usize> Zero for Force<N, D>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<N: Copy + Num, const D: usize> Copy for Force<N, D>

impl<N: Eq + Num, const D: usize> Eq for Force<N, D>

impl<N: Num, const D: usize> StructuralEq for Force<N, D>