Struct Quantity

Source

pub struct Quantity<T, U>(/* private fields */);

Expand description

Physical quantity with compile-time checked unit.

Create a one-dimensional array with n logarithmically spaced elements from start to end (inclusive).

§Example

let x = Length::logspace(1.0 * METER, 16.0 * METER, 5);
assert_relative_eq!(x, &(arr1(&[1.0, 2.0, 4.0, 8.0, 16.0]) * METER));

Source

pub fn get<I: NdIndex<D>>(&self, index: I) -> Quantity<T, U>
where T: Clone,

Return the element at index.

The Index trait can not be implemented, because a new instance has to be created, when indexing a quantity array. This serves as replacement for it.

Source

pub fn set<I: NdIndex<D>>(&mut self, index: I, value: Quantity<T, U>)
where S: DataMut,

Set the element at index to scalar.

Source §

Return the absolute value of self.

§Example

let t = -50.0 * KELVIN;
assert_relative_eq!(t.abs(), &(50.0 * KELVIN));

Source

pub fn inv(self) -> Quantity<T, Negate>
where T: Inv<Output = T>, U: Neg,

Return the multiplicative inverse of self.

§Example

let t = 5.0 * PASCAL;
assert_relative_eq!(t.inv(), &(0.2/PASCAL));

Source §

impl Quantity<f64, U>

Source

pub fn signum(self) -> f64

Returns a number that represents the sign of self.

1.0 if the number is positive, +0.0 or INFINITY
-1.0 if the number is negative, -0.0 or NEG_INFINITY
NAN if the number is NAN

Source

pub fn is_sign_negative(&self) -> bool

Returns true if self has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

Source

pub fn is_sign_positive(&self) -> bool

Returns true if self has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

Source

pub fn new(value: T) -> Self

Source

pub fn convert_to<T2>(&self, unit: Quantity<T2, U>) -> Quot<&T, T2>
where for<'a> &'a T: Div<T2>,

Convert a quantity into the given unit and return it as a float or array.

Source

pub fn convert_into<T2>(self, unit: Quantity<T2, U>) -> Quot<T, T2>
where T: Div<T2>,

Convert a quantity into the given unit and return it as a float or array.

Trait Implementations§

Source §

impl<T: AbsDiffEq, U> AbsDiffEq for Quantity<T, U>

Source §

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

Source §

fn default_epsilon() -> Self::Epsilon

Performs the unary - operation. Read more

Source §

impl<T: PartialEq, U> PartialEq for Quantity<T, U>

Source §

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

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

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

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

Source §

Source §

fn default_max_relative() -> Self::Epsilon

impl<'py, T> FromPyObjectBound<'_, 'py> for T
where T: FromPyObject<'py>,

Source §

fn from_py_object_bound(ob: Borrowed<'_, 'py, PyAny>) -> Result<T, PyErr>

Extracts Self from the bound smart pointer obj. Read more

fn into_py_any(self, py: Python<'py>) -> Result<Py<PyAny>, PyErr>

Converts self into an owned Python object, dropping type information and unbinding it from the 'py lifetime.

Source §

fn into_pyobject_or_pyerr(self, py: Python<'py>) -> Result<Self::Output, PyErr>

Converts self into a Python object. Read more

Source §

impl<T> PyErrArguments for T
where T: for<'py> IntoPyObject<'py> + Send + Sync,

Source §

fn arguments(self, py: Python<'_>) -> Py<PyAny>

Arguments for exception

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

Source §

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

Source §

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

Source §

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

Source §

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

pub fn from_vec(v: Vec<Quantity<T, U>>) -> Self

pub fn linspace(start: Quantity<T, U>, end: Quantity<T, U>, n: usize) -> Selfwhere T: Mul<f64, Output = T> + Sub<Output = T> + Add<Output = T>,

§Example

impl<U> Quantity<Array1<f64>, U>

pub fn logspace( start: Quantity<f64, U>, end: Quantity<f64, U>, n: usize, ) -> Self

§Example

impl<T, U, D: Dimension> Quantity<Array<T, D>, U>

pub fn zeros<Sh: ShapeBuilder<Dim = D>>(shape: Sh) -> Selfwhere T: Clone + Zero,

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> Selfwhere Sh: ShapeBuilder<Dim = D>, F: FnMut(D::Pattern) -> Quantity<T, U>,

impl<T, S: Data<Elem = T>, U, D: Dimension> Quantity<ArrayBase<S, D>, U>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn sum(&self) -> Quantity<T, U>where T: Clone + Zero,

§Example

pub fn to_owned(&self) -> Quantity<Array<T, D>, U>where T: Clone,

pub fn shape(&self) -> &[usize]

pub fn raw_dim(&self) -> D

pub fn mapv<F, T2, U2>(&self, f: F) -> Quantity<Array<T2, D>, U2>where T: Clone, S: DataMut, F: FnMut(Quantity<T, U>) -> Quantity<T2, U2>,

pub fn index_axis( &self, axis: Axis, index: usize, ) -> Quantity<ArrayView<'_, T, D::Smaller>, U>where D: RemoveAxis,

pub fn lanes_mut(&mut self, axis: Axis) -> LanesMut<'_, T, D::Smaller>where S: DataMut,

pub fn sum_axis(&self, axis: Axis) -> Quantity<Array<T, D::Smaller>, U>where T: Clone + Zero, D: RemoveAxis,

pub fn insert_axis(self, axis: Axis) -> Quantity<ArrayBase<S, D::Larger>, U>

pub fn get<I: NdIndex<D>>(&self, index: I) -> Quantity<T, U>where T: Clone,

pub fn set<I: NdIndex<D>>(&mut self, index: I, value: Quantity<T, U>)where S: DataMut,

impl<U> Quantity<f64, U>

pub fn powi<E: Integer>(self) -> Quantity<f64, Prod<U, E>>where U: Mul<E>,

§Example

pub fn sqrt(self) -> Quantity<f64, Quot<U, P2>>where U: Div<P2>,

§Example

pub fn cbrt(self) -> Quantity<f64, Quot<U, P3>>where U: Div<P3>,

§Example

pub fn root<R: Integer>(self) -> Quantity<f64, Quot<U, R>>where U: Div<R>,

§Example

impl<T, U> Quantity<T, U>

pub fn abs(self) -> Selfwhere T: Signed,

§Example

pub fn inv(self) -> Quantity<T, Negate<U>>where T: Inv<Output = T>, U: Neg,

§Example

impl<U> Quantity<f64, U>

pub fn signum(self) -> f64

pub fn is_sign_negative(&self) -> bool

pub fn is_sign_positive(&self) -> bool

pub fn is_nan(&self) -> bool

pub fn min(self, other: Self) -> Self

§Example

pub fn max(self, other: Self) -> Self

§Example

impl<D: DualNum<f64>, U> Quantity<D, U>

pub fn re(&self) -> Quantity<f64, U>

impl Quantity<f64, Radians>

pub fn sin(self) -> f64

pub fn cos(self) -> f64

pub fn tan(self) -> f64

pub fn asin(x: f64) -> Self

pub fn acos(x: f64) -> Self

pub fn atan(x: f64) -> Self

pub fn atan2(y: f64, x: f64) -> Self

impl<T> Quantity<T, TArr<Z0, TArr<Z0, TArr<Z0, TArr<Z0, TArr<Z0, TArr<Z0, TArr<Z0, ATerm>>>>>>>>

pub fn into_value(self) -> T

impl<T, U> Quantity<T, U>

pub fn new(value: T) -> Self

pub fn convert_to<T2>(&self, unit: Quantity<T2, U>) -> Quot<&T, T2>where for<'a> &'a T: Div<T2>,

pub fn convert_into<T2>(self, unit: Quantity<T2, U>) -> Quot<T, T2>where T: Div<T2>,

Trait Implementations§

impl<T: AbsDiffEq, U> AbsDiffEq for Quantity<T, U>

type Epsilon = <T as AbsDiffEq>::Epsilon

fn default_epsilon() -> Self::Epsilon

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

impl<'a, 'b, T1, T2, U> Add<&'b Quantity<T2, U>> for &'a Quantity<T1, U>where &'a T1: Add<&'b T2>,

type Output = Quantity<<&'a T1 as Add<&'b T2>>::Output, U>

fn add(self, other: &'b Quantity<T2, U>) -> Self::Output

impl<'b, T1, T2, U> Add<&'b Quantity<T2, U>> for Quantity<T1, U>where T1: Add<&'b T2>,

type Output = Quantity<<T1 as Add<&'b T2>>::Output, U>

fn add(self, other: &'b Quantity<T2, U>) -> Self::Output

impl<'a, T1, T2, U> Add<Quantity<T2, U>> for &'a Quantity<T1, U>where &'a T1: Add<T2>,

type Output = Quantity<<&'a T1 as Add<T2>>::Output, U>

Struct Quantity

pub fn linspace(start: Quantity<T, U>, end: Quantity<T, U>, n: usize) -> Self
where T: Mul<f64, Output = T> + Sub<Output = T> + Add<Output = T>,

pub fn zeros<Sh: ShapeBuilder<Dim = D>>(shape: Sh) -> Self
where T: Clone + Zero,

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> Self
where Sh: ShapeBuilder<Dim = D>, F: FnMut(D::Pattern) -> Quantity<T, U>,

pub fn sum(&self) -> Quantity<T, U>
where T: Clone + Zero,

pub fn to_owned(&self) -> Quantity<Array<T, D>, U>
where T: Clone,

pub fn mapv<F, T2, U2>(&self, f: F) -> Quantity<Array<T2, D>, U2>
where T: Clone, S: DataMut, F: FnMut(Quantity<T, U>) -> Quantity<T2, U2>,

pub fn index_axis( &self, axis: Axis, index: usize, ) -> Quantity<ArrayView<'_, T, D::Smaller>, U>
where D: RemoveAxis,

pub fn lanes_mut(&mut self, axis: Axis) -> LanesMut<'_, T, D::Smaller>
where S: DataMut,

pub fn sum_axis(&self, axis: Axis) -> Quantity<Array<T, D::Smaller>, U>
where T: Clone + Zero, D: RemoveAxis,

pub fn get<I: NdIndex<D>>(&self, index: I) -> Quantity<T, U>
where T: Clone,

pub fn set<I: NdIndex<D>>(&mut self, index: I, value: Quantity<T, U>)
where S: DataMut,

pub fn powi<E: Integer>(self) -> Quantity<f64, Prod<U, E>>
where U: Mul<E>,

pub fn sqrt(self) -> Quantity<f64, Quot<U, P2>>
where U: Div<P2>,

pub fn cbrt(self) -> Quantity<f64, Quot<U, P3>>
where U: Div<P3>,

pub fn root<R: Integer>(self) -> Quantity<f64, Quot<U, R>>
where U: Div<R>,

pub fn abs(self) -> Self
where T: Signed,

pub fn inv(self) -> Quantity<T, Negate<U>>
where T: Inv<Output = T>, U: Neg,

pub fn convert_to<T2>(&self, unit: Quantity<T2, U>) -> Quot<&T, T2>
where for<'a> &'a T: Div<T2>,

pub fn convert_into<T2>(self, unit: Quantity<T2, U>) -> Quot<T, T2>
where T: Div<T2>,

impl<'a, 'b, T1, T2, U> Add<&'b Quantity<T2, U>> for &'a Quantity<T1, U>
where &'a T1: Add<&'b T2>,

impl<'b, T1, T2, U> Add<&'b Quantity<T2, U>> for Quantity<T1, U>
where T1: Add<&'b T2>,

impl<'a, T1, T2, U> Add<Quantity<T2, U>> for &'a Quantity<T1, U>
where &'a T1: Add<T2>,

impl<T1, T2, U> Add<Quantity<T2, U>> for Quantity<T1, U>
where T1: Add<T2>,

impl<'a, T1, T2, U> AddAssign<&'a Quantity<T2, U>> for Quantity<T1, U>
where T1: AddAssign<&'a T2>,

impl<T1, T2, U> AddAssign<Quantity<T2, U>> for Quantity<T1, U>
where T1: AddAssign<T2>,