Struct PiecewiseLegendrePoly 

pub struct PiecewiseLegendrePoly {
    pub polyorder: usize,
    pub xmin: f64,
    pub xmax: f64,
    pub knots: Vec<f64>,
    pub delta_x: Vec<f64>,
    pub data: DTensor<f64, 2>,
    pub symm: i32,
    pub l: i32,
    pub xm: Vec<f64>,
    pub inv_xs: Vec<f64>,
    pub norms: Vec<f64>,
}

A single piecewise Legendre polynomial

Fields

polyorder: usize

Polynomial order (degree of Legendre polynomials in each segment)

xmin: f64

Minimum x value of the domain

xmax: f64

Maximum x value of the domain

knots: Vec<f64>

Knot points defining the segments

delta_x: Vec<f64>

Segment widths (for numerical stability)

data: DTensor<f64, 2>

Coefficient matrix: [degree][segment_index]

symm: i32

Symmetry parameter

l: i32

Polynomial parameter (used in power moments calculation)

xm: Vec<f64>

Segment midpoints

inv_xs: Vec<f64>

Inverse segment widths

norms: Vec<f64>

Normalization factors

Implementations

impl PiecewiseLegendrePoly

pub fn new( data: DTensor<f64, 2>, knots: Vec<f64>, l: i32, delta_x: Option<Vec<f64>>, symm: i32, ) -> Self

Create a new PiecewiseLegendrePoly from data and knots

pub fn with_data(&self, new_data: DTensor<f64, 2>) -> Self

Create a new PiecewiseLegendrePoly with new data but same structure

pub fn symm(&self) -> i32

Get the symmetry parameter

pub fn with_data_and_symmetry( &self, new_data: DTensor<f64, 2>, new_symm: i32, ) -> Self

Create a new PiecewiseLegendrePoly with new data and symmetry

pub fn rescale_domain( &self, new_knots: Vec<f64>, new_delta_x: Option<Vec<f64>>, new_symm: Option<i32>, ) -> Self

Rescale domain: create a new polynomial with the same data but different knots

This is useful for transforming from one domain to another, e.g., from x ∈ [-1, 1] to τ ∈ [0, β].

Arguments

• new_knots - New knot points
• new_delta_x - Optional new segment widths (computed from knots if None)
• new_symm - Optional new symmetry parameter (keeps old if None)

Returns

New polynomial with rescaled domain

pub fn scale_data(&self, factor: f64) -> Self

Scale all data values by a constant factor

This is useful for normalizations, e.g., multiplying by √β for Fourier transform preparations.

Arguments

• factor - Scaling factor to multiply all data by

Returns

New polynomial with scaled data

pub fn evaluate(&self, x: f64) -> f64

Evaluate the polynomial at a given point

pub fn evaluate_many(&self, xs: &[f64]) -> Vec<f64>

Evaluate the polynomial at multiple points

pub fn split(&self, x: f64) -> (usize, f64)

Split x into segment index and normalized x

pub fn evaluate_legendre_polynomial(&self, x: f64, coeffs: &[f64]) -> f64

Evaluate Legendre polynomial using recurrence relation

pub fn deriv(&self, n: usize) -> Self

Compute derivative of the polynomial

pub fn derivs(&self, x: f64) -> Vec<f64>

Compute derivatives at a point x

pub fn overlap<F>(&self, f: F) -> f64

where F: Fn(f64) -> f64,

Compute overlap integral with a function

pub fn roots(&self) -> Vec<f64>

Find roots of the polynomial using C++ compatible algorithm

pub fn get_xmin(&self) -> f64

pub fn get_xmax(&self) -> f64

pub fn get_l(&self) -> i32

pub fn get_domain(&self) -> (f64, f64)

pub fn get_knots(&self) -> &[f64]

pub fn get_delta_x(&self) -> &[f64]

pub fn get_symm(&self) -> i32

pub fn get_data(&self) -> &DTensor<f64, 2>

pub fn get_norms(&self) -> &[f64]

pub fn get_polyorder(&self) -> usize

Trait Implementations

impl Clone for PiecewiseLegendrePoly

fn clone(&self) -> PiecewiseLegendrePoly

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PiecewiseLegendrePoly

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

Formats the value using the given formatter.