Struct TauSampling 

pub struct TauSampling<S>
where
    S: StatisticsType,
{ /* private fields */ }

Sparse sampling in imaginary time

Allows transformation between the IR basis and a set of sampling points in imaginary time (τ).

Implementations

impl<S> TauSampling<S>

where S: StatisticsType,

pub fn new(basis: &impl Basis<S>) -> Self

where S: 'static,

Create a new TauSampling with default sampling points

The default sampling points are chosen as the extrema of the highest-order basis function, which gives near-optimal conditioning. SVD is computed lazily on first call to fit or fit_nd.

Arguments

• basis - Any basis implementing the Basis trait

Returns

A new TauSampling object

pub fn with_sampling_points( basis: &impl Basis<S>, sampling_points: Vec<f64>, ) -> Self

where S: 'static,

Create a new TauSampling with custom sampling points

SVD is computed lazily on first call to fit or fit_nd.

Arguments

• basis - Any basis implementing the Basis trait
• sampling_points - Custom sampling points in τ ∈ [-β, β]

Returns

A new TauSampling object

Panics

Panics if sampling_points is empty or if any point is outside [-β, β]

pub fn from_matrix(sampling_points: Vec<f64>, matrix: DTensor<f64, 2>) -> Self

Create a new TauSampling with custom sampling points and pre-computed matrix

This constructor is useful when the sampling matrix is already computed (e.g., from external sources or for testing).

Arguments

• sampling_points - Sampling points in τ ∈ [-β, β]
• matrix - Pre-computed sampling matrix (n_points × basis_size)

Returns

A new TauSampling object

Panics

Panics if sampling_points is empty or if matrix dimensions don’t match

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

Get the sampling points

pub fn n_sampling_points(&self) -> usize

Get the number of sampling points

pub fn basis_size(&self) -> usize

Get the basis size

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

Get the sampling matrix

pub fn evaluate(&self, coeffs: &[f64]) -> Vec<f64>

Evaluate basis coefficients at sampling points

Computes g(τ_i) = Σ_l a_l * u_l(τ_i) for all sampling points

Arguments

• coeffs - Basis coefficients (length = basis_size)

Returns

Values at sampling points (length = n_sampling_points)

pub fn evaluate_to(&self, coeffs: &[f64], out: &mut [f64])

Evaluate basis coefficients at sampling points, writing to output slice

pub fn fit(&self, values: &[f64]) -> Vec<f64>

Fit values at sampling points to basis coefficients

pub fn fit_to(&self, values: &[f64], out: &mut [f64])

Fit values at sampling points to basis coefficients, writing to output slice

pub fn evaluate_zz(&self, coeffs: &[Complex<f64>]) -> Vec<Complex<f64>>

Evaluate complex basis coefficients at sampling points

pub fn evaluate_zz_to(&self, coeffs: &[Complex<f64>], out: &mut [Complex<f64>])

Evaluate complex basis coefficients, writing to output slice

pub fn fit_zz(&self, values: &[Complex<f64>]) -> Vec<Complex<f64>>

Fit complex values at sampling points to basis coefficients

pub fn fit_zz_to(&self, values: &[Complex<f64>], out: &mut [Complex<f64>])

Fit complex values, writing to output slice

pub fn evaluate_nd( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<f64, DynRank>, dim: usize, ) -> Tensor<f64, DynRank>

Evaluate N-D real coefficients at sampling points

Arguments

• coeffs - N-dimensional array with coeffs.shape().dim(dim) == basis_size
• dim - Dimension along which to evaluate (0-indexed)

Returns

N-dimensional array with result.shape().dim(dim) == n_sampling_points

pub fn evaluate_nd_to( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<f64, DynRank>, dim: usize, out: &mut ViewMut<'_, f64, DynRank>, )

Evaluate N-D real coefficients, writing to a mutable view

pub fn fit_nd( &self, backend: Option<&GemmBackendHandle>, values: &Slice<f64, DynRank>, dim: usize, ) -> Tensor<f64, DynRank>

Fit N-D real values at sampling points to basis coefficients

Arguments

• values - N-dimensional array with values.shape().dim(dim) == n_sampling_points
• dim - Dimension along which to fit (0-indexed)

Returns

N-dimensional array with result.shape().dim(dim) == basis_size

pub fn fit_nd_to( &self, backend: Option<&GemmBackendHandle>, values: &Slice<f64, DynRank>, dim: usize, out: &mut ViewMut<'_, f64, DynRank>, )

Fit N-D real values, writing to a mutable view

pub fn evaluate_nd_zz( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<Complex<f64>, DynRank>, dim: usize, ) -> Tensor<Complex<f64>, DynRank>

Evaluate N-D complex coefficients at sampling points

Arguments

• coeffs - N-dimensional complex array with coeffs.shape().dim(dim) == basis_size
• dim - Dimension along which to evaluate (0-indexed)

Returns

N-dimensional complex array with result.shape().dim(dim) == n_sampling_points

pub fn evaluate_nd_zz_to( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<Complex<f64>, DynRank>, dim: usize, out: &mut ViewMut<'_, Complex<f64>, DynRank>, )

Evaluate N-D complex coefficients, writing to a mutable view

pub fn fit_nd_zz( &self, backend: Option<&GemmBackendHandle>, values: &Slice<Complex<f64>, DynRank>, dim: usize, ) -> Tensor<Complex<f64>, DynRank>

Fit N-D complex values at sampling points to basis coefficients

Arguments

• values - N-dimensional complex array with values.shape().dim(dim) == n_sampling_points
• dim - Dimension along which to fit (0-indexed)

Returns

N-dimensional complex array with result.shape().dim(dim) == basis_size

pub fn fit_nd_zz_to( &self, backend: Option<&GemmBackendHandle>, values: &Slice<Complex<f64>, DynRank>, dim: usize, out: &mut ViewMut<'_, Complex<f64>, DynRank>, )

Fit N-D complex values, writing to a mutable view

Trait Implementations

impl<S: StatisticsType> InplaceFitter for TauSampling<S>

InplaceFitter implementation for TauSampling

Delegates to RealMatrixFitter which supports dd and zz operations.

fn n_points(&self) -> usize

Number of sampling points

fn basis_size(&self) -> usize

Number of basis functions

fn evaluate_nd_dd_to( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<f64, DynRank>, dim: usize, out: &mut ViewMut<'_, f64, DynRank>, ) -> bool

Evaluate ND: f64 coeffs → f64 values

fn evaluate_nd_zz_to( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<Complex<f64>, DynRank>, dim: usize, out: &mut ViewMut<'_, Complex<f64>, DynRank>, ) -> bool

Evaluate ND: Complex coeffs → Complex values

fn fit_nd_dd_to( &self, backend: Option<&GemmBackendHandle>, values: &Slice<f64, DynRank>, dim: usize, out: &mut ViewMut<'_, f64, DynRank>, ) -> bool

Fit ND: f64 values → f64 coeffs

fn fit_nd_zz_to( &self, backend: Option<&GemmBackendHandle>, values: &Slice<Complex<f64>, DynRank>, dim: usize, out: &mut ViewMut<'_, Complex<f64>, DynRank>, ) -> bool

Fit ND: Complex values → Complex coeffs

fn evaluate_nd_dz_to( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<f64, DynRank>, dim: usize, out: &mut ViewMut<'_, Complex<f64>, DynRank>, ) -> bool

Evaluate ND: f64 coeffs → Complex values

fn evaluate_nd_zd_to( &self, backend: Option<&GemmBackendHandle>, coeffs: &Slice<Complex<f64>, DynRank>, dim: usize, out: &mut ViewMut<'_, f64, DynRank>, ) -> bool

Evaluate ND: Complex coeffs → f64 values

fn fit_nd_dz_to( &self, backend: Option<&GemmBackendHandle>, values: &Slice<f64, DynRank>, dim: usize, out: &mut ViewMut<'_, Complex<f64>, DynRank>, ) -> bool

Fit ND: f64 values → Complex coeffs

fn fit_nd_zd_to( &self, backend: Option<&GemmBackendHandle>, values: &Slice<Complex<f64>, DynRank>, dim: usize, out: &mut ViewMut<'_, f64, DynRank>, ) -> bool

Fit ND: Complex values → f64 coeffs