Struct pcw_fn::VecPcwFn

pub struct VecPcwFn<X, F> { /* private fields */ }

A piecewise function internally backed by Vecs

Trait Implementations

impl<Rhs, X, F> Add<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Add<F> + Clone,

type Output = VecPcwFn<X, <F as Add<F>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<Rhs, X, F> BitAnd<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: BitAnd<F> + Clone,

type Output = VecPcwFn<X, <F as BitAnd<F>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<Rhs, X, F> BitOr<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: BitOr<F> + Clone,

type Output = VecPcwFn<X, <F as BitOr<F>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<Rhs, X, F> BitXor<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: BitXor<F> + Clone,

type Output = VecPcwFn<X, <F as BitXor<F>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<X: Clone, F: Clone> Clone for VecPcwFn<X, F>

fn clone(&self) -> VecPcwFn<X, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X: Debug, F: Debug> Debug for VecPcwFn<X, F>

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

Formats the value using the given formatter.

impl<Rhs, X, F> Div<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Div<F> + Clone,

type Output = VecPcwFn<X, <F as Div<F>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<X, F> Functor<F> for VecPcwFn<X, F>

fn fmap<S>(self, f: impl FnMut(F) -> S) -> Self::Constructor<S>

impl<X, F> FunctorRef<F> for VecPcwFn<X, F>where
    X: Clone,

fn fmap_ref<S>(&self, f: impl FnMut(&F) -> S) -> Self::Constructor<S>

impl<X: Hash, F: Hash> Hash for VecPcwFn<X, F>

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<X, F> Kind1To1 for VecPcwFn<X, F>

type Constructor<S> = VecPcwFn<X, S>

impl<Rhs, X, F> Mul<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Mul<F> + Clone,

type Output = VecPcwFn<X, <F as Mul<F>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<X, F> Neg for VecPcwFn<X, F>where
    X: Ord,
    F: Neg,

type Output = VecPcwFn<X, <F as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<X, F> Not for VecPcwFn<X, F>where
    X: Ord,
    F: Not,

type Output = VecPcwFn<X, <F as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<X, F> One for VecPcwFn<X, F>where
    X: Ord,
    F: One + Clone + PartialEq,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> boolwhere
    Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<X: PartialEq, F: PartialEq> PartialEq<VecPcwFn<X, F>> for VecPcwFn<X, F>

fn eq(&self, other: &VecPcwFn<X, F>) -> 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<X: Ord, F> PcwFn<X, F> for VecPcwFn<X, F>

type JmpIter = <Vec<X, Global> as IntoIterator>::IntoIter

type FncIter = <Vec<F, Global> as IntoIterator>::IntoIter

fn jumps(&self) -> &[X]

Get a reference to the jumps.

fn funcs(&self) -> &[F]

Get a reference to the funcs in order.

fn funcs_mut(&mut self) -> &mut [F]

Get a mutable reference to the jumps.

fn try_from_iters<Jmp: IntoIterator<Item = X>, Fnc: IntoIterator<Item = F>>(
    jumps: Jmp,
    funcs: Fnc
) -> Result<Self, PcwFnError>

Try constructing a new piecewise function from iterators over jumps and functions.

fn add_segment(&mut self, jump: X, func: F)

Add another segment to the piecewise function at the back.

fn into_jumps_and_funcs(self) -> (Self::JmpIter, Self::FncIter)

Deconstruct a piecewise function into sequences of functions and jumps.

fn global(f: F) -> Self

A function that’s globally given by a single function f.

fn into_jumps(self) -> Self::JmpIter

Turn the function into an owned iterator over the jumps.

fn into_funcs(self) -> Self::FncIter

Turn the function into an owned iterator over the functions.

fn segment_count(&self) -> usize

How many segments the function consists of.

fn func_at(&self, x: &X) -> &F

Find the function that locally defines the piecewise function at some point x of the domain.

fn func_at_mut(&mut self, x: &X) -> &mut F

Find the function that locally defines the piecewise function at some point x of the domain.

impl<Rhs, X, F> Pow<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Pow<F> + Clone,

type Output = VecPcwFn<X, <F as Pow<F>>::Output>

The result after applying the operator.

fn pow(self, rhs: Rhs) -> Self::Output

Returns self to the power rhs.

impl<Rhs, X, F> Rem<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Rem<F> + Clone,

type Output = VecPcwFn<X, <F as Rem<F>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Rhs) -> Self::Output

Performs the % operation.

impl<Rhs, X, F> Shl<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Shl<F> + Clone,

type Output = VecPcwFn<X, <F as Shl<F>>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: Rhs) -> Self::Output

Performs the << operation.

impl<Rhs, X, F> Shr<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Shr<F> + Clone,

type Output = VecPcwFn<X, <F as Shr<F>>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: Rhs) -> Self::Output

Performs the >> operation.

impl<Rhs, X, F> Sub<Rhs> for VecPcwFn<X, F>where
    X: Ord,
    Rhs: PcwFn<X, F>,
    F: Sub<F> + Clone,

type Output = VecPcwFn<X, <F as Sub<F>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

impl<X, F> Zero for VecPcwFn<X, F>where
    X: Ord,
    F: Zero + Clone,

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<X: Eq, F: Eq> Eq for VecPcwFn<X, F>

impl<X, F> StructuralEq for VecPcwFn<X, F>

impl<X, F> StructuralPartialEq for VecPcwFn<X, F>