Struct ConstEquidistant

pub struct ConstEquidistant<R, const N: usize>(/* private fields */);

Struct used as a generator for equidistant elements in constant context. Acts like an array of knots.

This struct is necessary as to date neither generic bounds nor floating point opterations are allowed in constant functions. Such to be able to use Equidistant in a constant context, we use this structure instead.

In comparison to Equidistant, this struct is slower (as it has to do more calculations) and only represents knots in [0.0,1.0]. However as knot base for interpolations, it is more performant, as we have the knowledge of the domain.

Implementations

impl<R, const N: usize> ConstEquidistant<R, N>

pub const fn new() -> Self

Create a list of equidistant real numbers. This struct should only be created in a constant context. Otherwise use Equidistant instead.

Trait Implementations

impl<R: Clone, const N: usize> Clone for ConstEquidistant<R, N>

fn clone(&self) -> ConstEquidistant<R, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug, const N: usize> Debug for ConstEquidistant<R, N>

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

Formats the value using the given formatter.

impl<R, const N: usize> DiscreteGenerator for ConstEquidistant<R, N>

where R: Real + FromPrimitive,

fn len(&self) -> usize

Returns the minimum amount of elements the generator can create.

fn first(&self) -> Option<Self::Output>

Returns the first element of the generator, or None if it is empty.

fn last(&self) -> Option<Self::Output>

Returns the last element of the generator, or None if it is empty.

fn is_empty(&self) -> bool

Returns true if the generator does not generate any elements.

fn into_iter(self) -> IntoIter<Self>

where Self: Sized,

Convert generator to an iterator which steps through all generatable values.

fn iter(&self) -> IntoIter<&Self>

Create iterator which steps through all generatable values.

fn repeat(self) -> Repeat<Self>

where Self: Sized,

Transfrom generator to one which repeats its elements.

impl<R, const N: usize> Generator<usize> for ConstEquidistant<R, N>

where R: Real + FromPrimitive,

type Output = R

The element outputted

fn gen(&self, input: usize) -> R

Method to generate the element at the given input

fn extract<I, J>(self, iterator: I) -> Extract<Self, J>

where Self: Sized, I: IntoIterator<IntoIter = J>, J: Iterator<Item = Input>,

Helper function if one wants to extract values from the interpolation.

fn stack<G>(self, gen: G) -> Stack<Self, G>

where Self: Sized,

Stack two generators together

fn composite<G>(self, gen: G) -> Composite<Self, G>

where Self: Sized,

Takes two generators and creates a new generator pipelining both generators.

fn by_ref(&self) -> &Self

Get a reference of the generator.

fn sample<I, J>(&self, iterator: I) -> Extract<&Self, J>

where Self: Sized, I: IntoIterator<IntoIter = J>, J: Iterator<Item = Input>,

Helper function if one wants to sample values from the interpolation.

impl<R: PartialEq, const N: usize> PartialEq for ConstEquidistant<R, N>

fn eq(&self, other: &ConstEquidistant<R, N>) -> bool

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

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

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

impl<R, const N: usize> SortedGenerator for ConstEquidistant<R, N>

where R: Real + FromPrimitive,

fn strict_upper_bound(&self, element: Self::Output) -> usize

where Self::Output: PartialOrd + Copy,

Returns the smallest index for which the corresponding element is bigger then the input. If all elements are bigger, this function will return self.len().

Panics

Panics if N is 0. May panic if N-1 can not be converted to type R.

Examples

let equi = ConstEquidistant::<f64,11>::new();
assert_eq!(equi.strict_upper_bound(-1.0),0);
assert_eq!(equi.strict_upper_bound(0.15),2);
assert_eq!(equi.strict_upper_bound(20.0),11);

fn strict_upper_bound_clamped( &self, element: Self::Output, min: usize, max: usize, ) -> usize

where Self::Output: PartialOrd + Copy,

Returns the smallest index between min and max for which the corresponding element is bigger then the input. If all elements are bigger, this function will return the given maximum.

#Panic

Panics if min or max are not within [0,self.len()].

Examples

let equi = ConstEquidistant::<f64,11>::new();
assert_eq!(equi.strict_upper_bound_clamped(-1.0,1,3),1);
assert_eq!(equi.strict_upper_bound_clamped(0.15,1,3),2);
assert_eq!(equi.strict_upper_bound_clamped(20.0,1,3),3);

fn upper_border(&self, element: R) -> (usize, usize, R)

where R: PartialOrd + Sub<Output = R> + Div<Output = R> + Copy + Debug,

Find the values inside the collection for which the given element is inbetween and a linear factor at how close it is to which value.

This function in general returns indices with values (first and second) such that first <= value <= second is true.

If the given element is smaller/bigger than every element in the collection, then the indices given will be the smallest/biggest possible.

Remark

There are collections for which the returned values of this function are not uniquely defined. You may not assume any other invariant except first * factor + second * (1.0 - factor) == value, where value is the value inserted into this function, and the function returned (first, second, factor).

Panics

Panics if self is has less than two elements. Also panics if length-1 as usize can not be converted to R.

Examples

let equdist = ConstEquidistant::<f64,6>::new();
let values = vec![-1.0,0.0,0.15,0.6,1.0,20.0];
for value in values {
    let (min_index, max_index, factor) = equdist.upper_border(value);
    let min = equdist.gen(min_index);
    let max = equdist.gen(max_index);
    assert_f64_near!(utils::lerp(min,max,factor),value);
}

fn linear_factor_unchecked( &self, min_index: usize, max_index: usize, element: Self::Output, ) -> Self::Output

where Self::Output: Sub<Output = Self::Output> + Div<Output = Self::Output> + Copy,

Calculate the factor of element inbetween min and max.

fn linear_factor( &self, min_index: usize, max_index: usize, element: Self::Output, ) -> Self::Output

where Self::Output: Sub<Output = Self::Output> + Div<Output = Self::Output> + Zero + Copy,

Calculate the factor of element inbetween min and max.

impl<R: Copy, const N: usize> Copy for ConstEquidistant<R, N>

impl<R, const N: usize> StructuralPartialEq for ConstEquidistant<R, N>