Struct MapDegree

pub struct MapDegree { /* private fields */ }

Index map relating coefficients from one degree to another.

For each coefficient for a polynomial in nvars variables and of degree from_degree, this sequence gives the index of the same coefficient (the same powers) for a polynomial with degree to_degree, where to_degree must be larger or equal to from_degree.

The indices are strict monotonic increasing.

Example

The following example shows how to map a vector of coefficients from one degree to another.

use nutils_poly::{self, MapDegree};
use sqnc::traits::*;

// Coefficients for a polynomial in two variables and of degree one.
let coeffs1 = [4, 5, 6];
// Index map from degree two to degree three for a polynomial in one variable.
let map = MapDegree::new(2, 1, 2).unwrap();
// Apply the map to obtain a coefficients vector for a polynomial of degree two.
let mut coeffs2 = [0; nutils_poly::ncoeffs(2, 2)];
coeffs2.as_mut_sqnc().select(map).unwrap().assign(coeffs1);
assert_eq!(coeffs2, [0, 0, 4, 0, 5, 6]);
// Both polynomials evaluate to the same value.
assert_eq!(
    nutils_poly::eval(coeffs1, &[2, 3], 1)?,
    nutils_poly::eval(coeffs2, &[2, 3], 2)?,
);

Implementations

impl MapDegree

pub fn new(nvars: usize, from_degree: Power, to_degree: Power) -> Option<Self>

Returns an index map or None if to_degree is smaller than from_degree.

Trait Implementations

impl Clone for MapDegree

fn clone(&self) -> MapDegree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MapDegree

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

Formats the value using the given formatter.

impl Hash for MapDegree

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 IntoIterator for MapDegree

type Item = usize

The type of the elements being iterated over.

type IntoIter = IntoIter<MapDegree>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for MapDegree

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

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

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.

impl Sequence for MapDegree

fn len(&self) -> usize

Returns the length of the sequence.

fn get(&self, index: usize) -> Option<usize>

Returns the element at the given index or None.

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

Returns an iterator that returns elements.

fn is_empty(&self) -> bool

Returns true if the sequence is empty.

fn rget(&self, rindex: usize) -> Option<Self::Item>

Returns the element at the given index counting from the end or None.

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

Returns the first element or None if the sequence is empty.

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

Returns the last element or None if the sequence is empty.

fn min<'a>(&'a self) -> Option<Self::Item>

where Self::Item: Ord,

Returns the minimum of the sequence or None if the sequence is empty.

fn max<'a>(&'a self) -> Option<Self::Item>

where Self::Item: Ord,

Returns the maximum of the sequence or None if the sequence is empty.

fn copied<Item>(self) -> Copied<Self, Item>

where Self: Sized + for<'a> SequenceTypes<'a, Item = &'a Item>, Item: Copy,

Creates a sequence that copies all of its elements.

fn cloned<Item>(self) -> Cloned<Self, Item>

where Self: Sized + for<'a> SequenceTypes<'a, Item = &'a Item>, Item: Clone,

Creates a sequence that clones all of its elements.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: for<'a> Fn(Self::Item) -> B,

Takes a closure and creates a sequence that calls the closure on each element.

fn repeat(self, nreps: usize) -> Repeat<Self>

where Self: Sized,

Returns a sequence that repeats nreps times.

fn rev(self) -> Rev<Self>

where Self: Sized,

Returns the reverted sequence.

fn concat<Other>(self, other: Other) -> Option<Concat<Self, Other>>

where Self: Sized, Other: Sequence<Item = Self::Item> + for<'a> SequenceTypes<'a>,

Returns the concatenation with another sequence.

fn select<Idx>(self, indices: Idx) -> Option<Select<Self, Idx>>

where Self: Sized, Idx: Sequence<Item = usize> + for<'a> SequenceTypes<'a>,

Returns a selection of the sequence or None if any index is out of bounds.

fn zip<Other>(self, other: Other) -> Option<Zip<Self, Other>>

where Self: Sized, Other: Sequence,

‘Zips up’ two sequences into a single sequence of pairs.

fn as_sqnc(&self) -> Wrapper<&Self, ((),)>

Returns a Sequence that references self.

impl<'this> SequenceTypes<'this> for MapDegree

type Item = usize

The element type of a Sequence.

type Iter = Iter<'this, MapDegree>

The return type of Sequence::iter.

impl Copy for MapDegree

impl Eq for MapDegree

impl StructuralPartialEq for MapDegree

impl UniqueSequence for MapDegree