Struct FiniteTempBasis 

pub struct FiniteTempBasis<K, S>
where
    K: KernelProperties + CentrosymmKernel + Clone + 'static,
    S: StatisticsType,
{ /* private fields */ }

Finite temperature basis for imaginary time/frequency Green’s functions

For a continuation kernel K from real frequencies ω ∈ [-ωmax, ωmax] to imaginary time τ ∈ [0, β], this type stores the truncated singular value expansion or IR basis:

K(τ, ω) ≈ sum(u[l](τ) * s[l] * v[l](ω) for l in 1:L)

This basis is inferred from a reduced form by appropriate scaling of the variables.

Type Parameters

• K - Kernel type implementing KernelProperties + CentrosymmKernel
• S - Statistics type (Fermionic or Bosonic)

Implementations

impl<K, S> FiniteTempBasis<K, S>

where K: KernelProperties + CentrosymmKernel + Clone + 'static, S: StatisticsType,

pub fn kernel(&self) -> &K

Get a reference to the kernel

pub fn sve_result(&self) -> &Arc<SVEResult>

Get the SVE result

pub fn accuracy(&self) -> f64

Get the accuracy of the basis

pub fn beta(&self) -> f64

Get the inverse temperature β

pub fn u(&self) -> &Arc<PiecewiseLegendrePolyVector>

Get the left singular functions (u) on imaginary time axis

pub fn v(&self) -> &Arc<PiecewiseLegendrePolyVector>

Get the right singular functions (v) on real frequency axis

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

Get the singular values

pub fn uhat(&self) -> &Arc<PiecewiseLegendreFTVector<S>>

Get the left singular functions on Matsubara frequency axis (uhat)

pub fn uhat_full(&self) -> &Arc<PiecewiseLegendreFTVector<S>>

Get the full uhat (before truncation)

pub fn wmax(&self) -> f64

Get the frequency cutoff ωmax

pub fn default_matsubara_sampling_points_i64( &self, positive_only: bool, ) -> Vec<i64>

where S: 'static,

Get default Matsubara sampling points as i64 indices (for C-API)

pub fn default_matsubara_sampling_points_i64_with_mitigate( &self, positive_only: bool, mitigate: bool, n_points: usize, ) -> Vec<i64>

where S: 'static,

Get default Matsubara sampling points as i64 indices with mitigate parameter (for C-API)

Panics

Panics if the kernel is not centrosymmetric. This method relies on centrosymmetry to generate sampling points.

pub fn new( kernel: K, beta: f64, epsilon: Option<f64>, max_size: Option<usize>, ) -> Self

Create a new FiniteTempBasis

Arguments

• kernel - Kernel implementing KernelProperties + CentrosymmKernel
• beta - Inverse temperature (β > 0)
• epsilon - Accuracy parameter (optional, defaults to NaN for auto)
• max_size - Maximum number of basis functions (optional)

Returns

A new FiniteTempBasis

pub fn from_sve_result( kernel: K, beta: f64, sve_result: SVEResult, epsilon: Option<f64>, max_size: Option<usize>, ) -> Self

Create basis from existing SVE result

This is useful when you want to reuse the same SVE computation for both fermionic and bosonic bases.

pub fn size(&self) -> usize

Get the size of the basis (number of basis functions)

pub fn lambda(&self) -> f64

Get the cutoff parameter Λ = β * ωmax

pub fn omega_max(&self) -> f64

Get the frequency cutoff ωmax

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

Get significance of each singular value (s[i] / s[0])

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

Get default tau sampling points

C++ implementation: libsparseir/include/sparseir/basis.hpp:229-270

Returns sampling points in imaginary time τ ∈ [-β/2, β/2].

Panics

Panics if the kernel is not centrosymmetric. This method relies on centrosymmetry to generate symmetric sampling points.

pub fn default_tau_sampling_points_size_requested( &self, size_requested: usize, ) -> Vec<f64>

Get default tau sampling points with a requested size

Panics

Panics if the kernel is not centrosymmetric. This method relies on centrosymmetry to generate symmetric sampling points.

pub fn default_matsubara_sampling_points( &self, positive_only: bool, ) -> Vec<MatsubaraFreq<S>>

where S: 'static,

Get default Matsubara frequency sampling points

Returns sampling points as MatsubaraFreq objects based on extrema of the Matsubara basis functions (same algorithm as C++/Julia).

Arguments

• positive_only - If true, returns only non-negative frequencies

Returns

Vector of Matsubara frequency sampling points

Panics

Panics if the kernel is not centrosymmetric. This method relies on centrosymmetry to generate sampling points.

pub fn default_matsubara_sampling_points_impl( uhat_full: &PiecewiseLegendreFTVector<S>, l: usize, fence: bool, positive_only: bool, ) -> Vec<MatsubaraFreq<S>>

where S: StatisticsType + 'static,

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

Get default omega (real frequency) sampling points

Returns sampling points on the real-frequency axis ω ∈ [-ωmax, ωmax]. These are used as pole locations for the Discrete Lehmann Representation (DLR).

The sampling points are chosen as the roots of the L-th basis function in the spectral domain (v), which provides near-optimal conditioning.

Returns

Vector of real-frequency sampling points in [-ωmax, ωmax]

Trait Implementations

impl<K, S> Basis<S> for FiniteTempBasis<K, S>

where K: KernelProperties + CentrosymmKernel + Clone + 'static, S: StatisticsType + 'static,

type Kernel = K

Associated kernel type

fn kernel(&self) -> &Self::Kernel

Get reference to the kernel

fn beta(&self) -> f64

Inverse temperature β

fn wmax(&self) -> f64

Maximum frequency ωmax

fn lambda(&self) -> f64

Kernel parameter Λ = β × ωmax

fn size(&self) -> usize

Number of basis functions

fn accuracy(&self) -> f64

Accuracy of the basis

fn significance(&self) -> Vec<f64>

Significance of each basis function

fn svals(&self) -> Vec<f64>

Get singular values (non-normalized)

fn default_tau_sampling_points(&self) -> Vec<f64>

Get default tau sampling points

fn default_matsubara_sampling_points( &self, positive_only: bool, ) -> Vec<MatsubaraFreq<S>>

Get default Matsubara sampling points

fn evaluate_tau(&self, tau: &[f64]) -> DTensor<f64, 2>

Evaluate basis functions at imaginary time points

fn evaluate_matsubara( &self, freqs: &[MatsubaraFreq<S>], ) -> DTensor<Complex<f64>, 2>

Evaluate basis functions at Matsubara frequencies

fn evaluate_omega(&self, omega: &[f64]) -> DTensor<f64, 2>

Evaluate spectral basis functions at real frequencies

fn default_omega_sampling_points(&self) -> Vec<f64>

Get default omega (real frequency) sampling points

impl<K, S> Clone for FiniteTempBasis<K, S>

where K: KernelProperties + CentrosymmKernel + Clone + 'static + Clone, S: StatisticsType + Clone,

fn clone(&self) -> FiniteTempBasis<K, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.