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)

Panics

Panics if coeffs.len() != basis_size

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

where T: ComplexFloat + ComplexField + 'static + From<f64> + Copy,

Evaluate basis coefficients at sampling points (N-dimensional)

Evaluates along the specified dimension, keeping other dimensions intact. Supports both real (f64) and complex (Complex<f64>) coefficients.

Type Parameters

• T - Element type (f64 or Complex)

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

Panics

Panics if coeffs.shape().dim(dim) != basis_size or if dim >= rank

Example

use num_complex::Complex;
use mdarray::tensor;

// Real coefficients
let values_real = sampling.evaluate_nd::<f64>(&coeffs_real, 0);

// Complex coefficients
let values_complex = sampling.evaluate_nd::<Complex<f64>>(&coeffs_complex, 0);

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

where T: ComplexFloat + ComplexField + 'static + From<f64> + Copy + Default,

Fit basis coefficients from values at sampling points (N-dimensional)

Fits along the specified dimension, keeping other dimensions intact. Supports both real (f64) and complex (Complex<f64>) values.

Type Parameters

• T - Element type (f64 or Complex)

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

Panics

Panics if values.shape().dim(dim) != n_sampling_points, if dim >= rank, or if SVD not computed

Example

use num_complex::Complex;
use mdarray::tensor;

// Real values
let coeffs_real = sampling.fit_nd::<f64>(&values_real, 0);

// Complex values
let coeffs_complex = sampling.fit_nd::<Complex<f64>>(&values_complex, 0);