Trait NCIntegrable

pub trait NCIntegrable: Sub<Self, Output = Self> + Sized {
    type NodeY;
    type NCPolynomial;

    // Required methods
    fn compute_node_y<F>(f: F, node_x: &[f64]) -> Self::NodeY
       where F: Fn(f64) -> Self;
    fn compute_polynomial(
        node_x: &[f64],
        node_y: &Self::NodeY,
    ) -> Self::NCPolynomial;
    fn integrate_polynomial(p: &Self::NCPolynomial) -> Self::NCPolynomial;
    fn evaluate_polynomial(p: &Self::NCPolynomial, x: f64) -> Self;
}

Type that can be integrated using Newton Cotes Quadrature

Required Associated Types

type NodeY

type NCPolynomial

Required Methods

fn compute_node_y<F>(f: F, node_x: &[f64]) -> Self::NodeY

where F: Fn(f64) -> Self,

Returns the image of node_x under function f, in a representation (Self::NodeY) suitable for separately computing one Lagrange polynomial for each of the degrees of freedom of Self (e.g. a Vec with as many entries as the number of degrees of freedom).

fn compute_polynomial( node_x: &[f64], node_y: &Self::NodeY, ) -> Self::NCPolynomial

Computes one Lagrange polynomial for each one of the degrees of freedom of Self, returning them in a representation (Self::NCPolynomial) suitable to separately performing operation on them (e.g. Vec<Polynomial>).

fn integrate_polynomial(p: &Self::NCPolynomial) -> Self::NCPolynomial

Separately integrates each of the polynomials obtained using compute_polynomial.

fn evaluate_polynomial(p: &Self::NCPolynomial, x: f64) -> Self

Separately evaluates each of the polynomial integrated using integrate_polynomial at x, then recombines the result into a Self.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl NCIntegrable for f64

type NodeY = Vec<f64>

type NCPolynomial = Polynomial

fn compute_node_y<F>(f: F, node_x: &[f64]) -> Vec<f64>

where F: Fn(f64) -> Self,

fn compute_polynomial(node_x: &[f64], node_y: &Vec<f64>) -> Polynomial

fn integrate_polynomial(p: &Polynomial) -> Polynomial

fn evaluate_polynomial(p: &Polynomial, x: f64) -> Self

Implementors

impl NCIntegrable for C64

type NodeY = (Vec<f64>, Vec<f64>)

type NCPolynomial = (Polynomial, Polynomial)