#![doc = include_str!("../README.md")]
#![forbid(unsafe_code)]
#![warn(missing_docs)]
mod beta;
mod conv;
pub mod discrete;
pub mod interp;
pub mod models;
mod polynomial;
pub mod segment;
pub mod singularity;
mod util;
use std::f64::consts::PI;
use std::ops::{Add, Mul, Neg, Sub};
use std::sync::Arc;
use bilby::QuadratureError;
use bilby::result::QuadratureResult;
use num_complex::Complex64;
use crate::discrete::DiscreteSF;
use crate::interp::InterpolatedSF;
use crate::segment::Segment;
use crate::singularity::{Singularity, Strength};
#[doc = include_str!("../doc/theory.md")]
pub mod theory {}
pub trait ContinuousSF: Send + Sync {
fn support(&self) -> Segment;
fn regular(&self, omega: f64) -> f64;
fn singularities(&self) -> &[Singularity] {
&[]
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF>;
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF>;
}
#[derive(Clone)]
pub struct SpectralFunction {
discrete: DiscreteSF,
continuous: Vec<(Arc<dyn ContinuousSF>, f64)>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub struct Integral<T> {
pub value: T,
pub error_estimate: T,
pub converged: bool,
}
impl Integral<f64> {
pub(crate) fn exact(value: f64) -> Integral<f64> {
Integral {
value,
error_estimate: 0.0,
converged: true,
}
}
pub(crate) fn from_quadrature(result: QuadratureResult<f64>) -> Integral<f64> {
Integral {
value: result.value,
error_estimate: result.error_estimate,
converged: result.converged,
}
}
pub(crate) fn add_scaled(&mut self, other: &Integral<f64>, weight: f64) {
self.value += weight * other.value;
self.error_estimate += weight.abs() * other.error_estimate;
self.converged &= other.converged;
}
}
impl Mul<f64> for SpectralFunction {
type Output = Self;
fn mul(self, a: f64) -> Self {
Self::from_discrete_continuous(
self.discrete * a,
self.continuous
.into_iter()
.map(|(cd, w)| (cd, w * a))
.collect(),
)
}
}
impl Mul<SpectralFunction> for f64 {
type Output = SpectralFunction;
fn mul(self, sf: SpectralFunction) -> SpectralFunction {
sf * self
}
}
impl Neg for SpectralFunction {
type Output = Self;
fn neg(self) -> SpectralFunction {
self * (-1.0)
}
}
impl Add for SpectralFunction {
type Output = Self;
fn add(self, rhs: SpectralFunction) -> SpectralFunction {
let mut continuous = self.continuous;
continuous.extend(rhs.continuous);
SpectralFunction::from_discrete_continuous(self.discrete + rhs.discrete, continuous)
}
}
impl Sub for SpectralFunction {
type Output = Self;
fn sub(self, rhs: SpectralFunction) -> SpectralFunction {
self + (-rhs)
}
}
fn conv_discrete_continuous(
discrete: &DiscreteSF,
continuous: &[(Arc<dyn ContinuousSF>, f64)],
) -> Vec<(Arc<dyn ContinuousSF>, f64)> {
let mut contributions = Vec::with_capacity(discrete.len() * continuous.len());
for (csf, w) in continuous {
for res in discrete.iter() {
contributions.push((Arc::from(csf.shifted(res.eps)), w * res.weight));
}
}
contributions
}
impl SpectralFunction {
fn from_discrete_continuous(
discrete: DiscreteSF,
continuous: Vec<(Arc<dyn ContinuousSF>, f64)>,
) -> SpectralFunction {
let mut merged: Vec<(Arc<dyn ContinuousSF>, f64, f64)> =
Vec::with_capacity(continuous.len());
for (cd, w) in continuous {
match merged
.iter_mut()
.find(|(other, _, _)| Arc::ptr_eq(other, &cd))
{
Some((_, sum, magnitude)) => {
*sum += w;
*magnitude += w.abs();
}
None => merged.push((cd, w, w.abs())),
}
}
SpectralFunction {
discrete,
continuous: merged
.into_iter()
.filter(|(_, sum, magnitude)| sum.abs() > DiscreteSF::WEIGHT_TOL * magnitude)
.map(|(cd, sum, _)| (cd, sum))
.collect(),
}
}
pub fn from_continuous<C: ContinuousSF + 'static>(continuous: C) -> SpectralFunction {
SpectralFunction::from_discrete_continuous(
DiscreteSF::new(),
vec![(Arc::new(continuous), 1.0)],
)
}
pub fn discrete(&self) -> &DiscreteSF {
&self.discrete
}
pub fn continuous(&self) -> impl Iterator<Item = (&dyn ContinuousSF, f64)> {
self.continuous.iter().map(|(csf, w)| (csf.as_ref(), *w))
}
pub fn support(&self) -> Option<Segment> {
Segment::hull(
self.continuous
.iter()
.map(|(cd, _)| cd.support())
.chain(self.discrete.support()),
)
}
pub fn shifted(&self, by: f64) -> SpectralFunction {
let mut continuous = Vec::with_capacity(self.continuous.len());
for (csf, w) in &self.continuous {
continuous.push((Arc::from(csf.shifted(by)), *w));
}
SpectralFunction::from_discrete_continuous(self.discrete.shifted(by), continuous)
}
pub fn mirrored(&self, omega: f64) -> SpectralFunction {
let mut continuous = Vec::with_capacity(self.continuous.len());
for (csf, w) in &self.continuous {
continuous.push((Arc::from(csf.mirrored(omega)), *w));
}
SpectralFunction::from_discrete_continuous(self.discrete.mirrored(omega), continuous)
}
pub fn precomputed(&self, tol: Option<f64>) -> SpectralFunction {
let continuous = self
.continuous
.iter()
.map(|(csf, w)| {
if csf.support().is_bounded() {
let interpolated = InterpolatedSF::new(csf.as_ref(), tol);
(Arc::new(interpolated) as Arc<dyn ContinuousSF>, *w)
} else {
(Arc::clone(csf), *w)
}
})
.collect();
SpectralFunction::from_discrete_continuous(self.discrete.clone(), continuous)
}
pub fn conv(&self, other: &SpectralFunction, tol: Option<f64>) -> SpectralFunction {
let mut continuous = conv_discrete_continuous(&self.discrete, &other.continuous);
continuous.extend(conv_discrete_continuous(&other.discrete, &self.continuous));
let tol = tol.unwrap_or(InterpolatedSF::DEFAULT_TOL);
for (c1, w1) in &self.continuous {
for (c2, w2) in &other.continuous {
let (c1, c2) = (c1.as_ref(), c2.as_ref());
let support = conv::pair_support(c1, c2);
let singularities = conv::pair_singularities(c1, c2);
let regular = |omega: f64| {
let singular: f64 = singularities.iter().map(|s| s.value(omega)).sum();
conv::pair_value(c1, c2, omega, tol) - singular
};
let interpolated =
InterpolatedSF::from_parts(support, singularities.clone(), regular, Some(tol));
continuous.push((Arc::new(interpolated) as Arc<dyn ContinuousSF>, w1 * w2));
}
}
SpectralFunction::from_discrete_continuous(self.discrete.conv(&other.discrete), continuous)
}
pub fn total_weight(&self) -> f64 {
self.discrete.total_weight() + self.continuous.iter().map(|(_, w)| w).sum::<f64>()
}
pub fn continuous_at(&self, omega: f64) -> f64 {
let mut divergent: Vec<(Strength, f64, f64)> = Vec::new();
let mut finite = 0.0f64;
for (csf, w) in &self.continuous {
if !csf.support().contains(omega) {
continue;
}
let mut value = csf.regular(omega);
for sing in csf.singularities() {
if sing.position() != omega {
value += sing.value(omega);
continue;
}
value += sing.finite_limit();
for (strength, c) in sing.divergences() {
let coeff = w * c;
match divergent.iter_mut().find(|(s, _, _)| *s == strength) {
Some((_, sum, magnitude)) => {
*sum += coeff;
*magnitude += coeff.abs();
}
None => divergent.push((strength, coeff, coeff.abs())),
}
}
}
finite += w * value;
}
match divergent
.iter()
.filter(|(_, sum, magnitude)| sum.abs() > DiscreteSF::WEIGHT_TOL * magnitude)
.max_by(|x, y| x.0.order(&y.0))
{
Some((_, sum, _)) => sum.signum() * f64::INFINITY,
None => finite,
}
}
pub fn integrate<F: Fn(f64) -> f64>(
&self,
f: F,
tol: Option<f64>,
) -> Result<Integral<f64>, QuadratureError> {
let mut discrete = 0.0f64;
for r in self.discrete.iter() {
discrete += r.weight * f(r.eps);
}
let mut result = Integral::exact(discrete);
let tol = tol.unwrap_or(1e-10);
for (csf, w) in &self.continuous {
let support = csf.support();
let mut res_contrib = Integral::from_quadrature(util::bilby_integrate(
|omega| csf.regular(omega) * f(omega),
support,
tol,
)?);
for sing in csf.singularities() {
if sing.is_trivial() {
continue;
}
let asympt = util::integrate_by_subtraction(
sing.position(),
|omega| sing.value(omega),
|stretch| sing.integral(stretch),
&f,
support,
tol,
)?;
res_contrib.add_scaled(&asympt, 1.0);
}
result.add_scaled(&res_contrib, *w);
}
Ok(result)
}
pub fn integrate_complex<F: Fn(f64) -> Complex64>(
&self,
f: F,
tol: Option<f64>,
) -> Result<Integral<Complex64>, QuadratureError> {
let re = self.integrate(|omega| f(omega).re, tol)?;
let im = self.integrate(|omega| f(omega).im, tol)?;
Ok(Integral {
value: Complex64::new(re.value, im.value),
error_estimate: Complex64::new(re.error_estimate, im.error_estimate),
converged: re.converged && im.converged,
})
}
pub fn broadened(
&self,
omega: f64,
delta: f64,
tol: Option<f64>,
) -> Result<Integral<f64>, QuadratureError> {
assert!(delta > 0.0, "broadening must be positive");
let (weight, delta_sq) = (delta / PI, delta.powi(2));
let f = |omega_prime: f64| -> f64 { weight / (delta_sq + (omega_prime - omega).powi(2)) };
self.integrate(f, tol)
}
}
#[cfg(test)]
mod tests {
use crate::SpectralFunction;
use crate::models::*;
use crate::segment::Segment;
use crate::util;
use approx::{assert_abs_diff_eq, assert_relative_eq};
use num_complex::Complex64;
use std::f64::consts::PI;
#[test]
fn send_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<SpectralFunction>();
}
#[test]
fn total_weight() {
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5);
assert_relative_eq!(dos.total_weight(), 6.7, epsilon = 1e-12);
}
#[test]
fn discrete_part() {
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5);
let d = dos.discrete();
assert_eq!(d.len(), 2);
assert_relative_eq!(d.total_weight(), 1.7, epsilon = 1e-12);
assert_relative_eq!(d.find(1.2).unwrap().weight, 1.2, epsilon = 1e-12);
assert!(d.find(1.4).is_none());
assert!(gaussian(1.4, 0.5).discrete().is_empty());
}
#[test]
fn continuous_part() {
let band = chain(0.5, 1.0);
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6])
+ 5.0 * gaussian(1.4, 0.5)
+ band.clone()
+ 0.5 * band.clone();
let parts: Vec<_> = dos.continuous().collect();
assert_eq!(parts.len(), 2);
assert_eq!(parts[0].1, 5.0);
assert_eq!(parts[1].1, 1.5);
assert_eq!(
parts[0].0.support(),
Segment::new(f64::NEG_INFINITY, f64::INFINITY)
);
assert_eq!(parts[1].0.support(), Segment::new(-1.5, 2.5));
assert_eq!(discrete(&[-0.7], &[1.0]).continuous().count(), 0);
}
#[test]
fn support() {
assert_eq!(discrete(&[], &[]).support(), None);
assert_eq!((gaussian(1.4, 0.5) * 0.0).support(), None);
assert_eq!(
discrete(&[-0.7, 1.2, 0.3], &[0.25, 0.6, 0.15]).support(),
Some(Segment::new(-0.7, 1.2))
);
assert_eq!(chain(0.5, 1.0).support(), Some(Segment::new(-1.5, 2.5)));
let dos = discrete(&[0.0, 5.0], &[0.3, 0.3]) + chain(0.5, 1.0) + square(0.0, 0.25);
assert_eq!(dos.support(), Some(Segment::new(-1.5, 5.0)));
let dos = discrete(&[-0.7], &[0.5]) + gaussian(1.4, 0.5);
assert_eq!(
dos.support(),
Some(Segment::new(f64::NEG_INFINITY, f64::INFINITY))
);
}
#[test]
fn continuous_at() {
let (eps, t) = (0.5f64, 1.0f64);
let dos = chain(eps, t);
for omega in [-1.0, 0.0, 0.8, 2.0] {
let ref_value = 1.0 / (PI * ((2.0 * t).powi(2) - (omega - eps).powi(2)).sqrt());
assert_relative_eq!(dos.continuous_at(omega), ref_value, max_relative = 1e-12);
}
assert_eq!(dos.continuous_at(10.0), 0.0);
assert_eq!(dos.continuous_at(eps - 2.0 * t), f64::INFINITY);
assert_eq!(dos.continuous_at(eps + 2.0 * t), f64::INFINITY);
assert_eq!(square(eps, t).continuous_at(eps), f64::INFINITY);
assert_eq!(
(-1.0 * square(eps, t)).continuous_at(eps),
f64::NEG_INFINITY
);
assert_eq!(semicircle(eps, 2.0).continuous_at(eps - 2.0), 0.0);
assert_eq!(discrete(&[-0.7, 1.2], &[0.25, 0.6]).continuous_at(1.2), 0.0);
}
#[test]
fn continuous_at_cancelling_divergences() {
let dos = square(0.0, 1.0) + (-2.0) * square(0.0, 2.0);
assert_relative_eq!(
dos.continuous_at(0.0),
-2f64.ln() / (2.0 * PI.powi(2)),
max_relative = 1e-12
);
let dos = square(0.0, 1.0) + (-1.0) * chain(2.0, 1.0);
assert_eq!(dos.continuous_at(0.0), f64::NEG_INFINITY);
}
#[test]
fn continuous_at_cancelling_across_scales() {
let (narrow, wide) = (powerlaw(0.0, -0.5, 1.0), powerlaw(0.0, -0.5, 4.0));
let cancelling = narrow.clone() + (-2.0) * wide.clone();
assert!(cancelling.continuous_at(0.0).is_finite());
for omega in [1e-6f64, 1e-10] {
assert_abs_diff_eq!(cancelling.continuous_at(omega), 0.0, epsilon = 1e-12);
}
let surviving = narrow + (-1.0) * wide;
assert_eq!(surviving.continuous_at(0.0), f64::INFINITY);
assert!(surviving.continuous_at(1e-10) > 1e4);
}
#[test]
fn mul() {
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5);
assert_eq!(dos.discrete.len(), 2);
assert_eq!(dos.continuous.len(), 1);
let scaled = f64::MIN_POSITIVE * (f64::MIN_POSITIVE * dos.clone());
assert!(scaled.discrete.is_empty());
assert!(scaled.continuous.is_empty());
assert_eq!(scaled.total_weight(), 0.0);
let scaled = dos * 0.0;
assert!(scaled.discrete.is_empty());
assert!(scaled.continuous.is_empty());
assert_eq!(scaled.total_weight(), 0.0);
}
#[test]
fn add_merges_repeated_contributions() {
let dos = chain(0.5, 1.0);
let omega = 0.8;
let tripled = dos.clone() + dos.clone() + dos.clone();
assert_eq!(tripled.continuous.len(), 1);
assert_relative_eq!(tripled.total_weight(), 3.0, epsilon = 1e-12);
assert_relative_eq!(
tripled.continuous_at(omega),
3.0 * dos.continuous_at(omega),
max_relative = 1e-12
);
let zero = 2.0 * dos.clone() - 2.0 * dos.clone();
assert!(zero.continuous.is_empty());
assert_eq!(zero.continuous_at(omega), 0.0);
let pair = chain(0.5, 1.0) + chain(0.5, 1.0);
assert_eq!(pair.continuous.len(), 2);
assert_relative_eq!(
pair.continuous_at(omega),
2.0 * dos.continuous_at(omega),
max_relative = 1e-12
);
let mixed = dos.clone() + square(0.0, 1.0) + dos.clone();
assert_eq!(mixed.continuous.len(), 2);
assert_eq!(mixed.continuous[0].1, 2.0);
assert_eq!(mixed.continuous[1].1, 1.0);
}
#[test]
fn neg() {
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5);
let neg_dos = -dos.clone();
assert_eq!(neg_dos.discrete.len(), 2);
assert_eq!(neg_dos.continuous.len(), 1);
assert_eq!(neg_dos.support(), dos.support());
assert_relative_eq!(neg_dos.total_weight(), -dos.total_weight(), epsilon = 1e-12);
assert_relative_eq!(
neg_dos.discrete().find(1.2).unwrap().weight,
-1.2,
epsilon = 1e-12
);
for omega in [-1.0, 0.5, 1.4, 3.0] {
assert_relative_eq!(
neg_dos.continuous_at(omega),
-dos.continuous_at(omega),
max_relative = 1e-12
);
}
let (eps, t) = (0.5f64, 1.0f64);
assert_eq!((-square(eps, t)).continuous_at(eps), f64::NEG_INFINITY);
let dos2 = -(-dos.clone());
assert_relative_eq!(dos2.total_weight(), dos.total_weight(), epsilon = 1e-12);
assert_relative_eq!(
dos2.continuous_at(0.5),
dos.continuous_at(0.5),
epsilon = 1e-12
);
let zero = dos.clone() + (-dos);
assert!(zero.discrete.is_empty());
assert!(zero.continuous.is_empty());
assert_relative_eq!(zero.total_weight(), 0.0, epsilon = 1e-12);
assert_eq!(zero.continuous_at(1.4), 0.0);
}
#[test]
fn sub() {
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5);
let rhs = discrete(&[1.2], &[1.0]) + 2.0 * gaussian(1.4, 0.5);
let diff = dos.clone() - rhs.clone();
assert_eq!(diff.discrete.len(), 2);
assert_relative_eq!(
diff.discrete().find(1.2).unwrap().weight,
0.2,
epsilon = 1e-12
);
assert_relative_eq!(
diff.total_weight(),
dos.total_weight() - rhs.total_weight(),
epsilon = 1e-12
);
for omega in [-1.0, 0.5, 1.4, 3.0] {
assert_relative_eq!(
diff.continuous_at(omega),
dos.continuous_at(omega) - rhs.continuous_at(omega),
max_relative = 1e-12
);
}
let diff2 = dos.clone() + (-rhs);
assert_relative_eq!(diff2.total_weight(), diff.total_weight(), epsilon = 1e-12);
assert_relative_eq!(
diff2.continuous_at(0.5),
diff.continuous_at(0.5),
max_relative = 1e-12
);
let zero = dos.clone() - dos;
assert!(zero.discrete.is_empty());
assert_relative_eq!(zero.total_weight(), 0.0, epsilon = 1e-12);
assert_eq!(zero.continuous_at(1.4), 0.0);
}
#[test]
fn precomputed() {
let dos = square(0.0, 1.0);
let fast = dos.precomputed(None);
assert_eq!(fast.support(), dos.support());
assert_relative_eq!(fast.total_weight(), dos.total_weight(), epsilon = 1e-14);
assert_eq!(fast.continuous_at(0.0), f64::INFINITY);
for omega in [-3.5, -1.2, 0.3, 2.0, 3.9] {
assert_relative_eq!(
fast.continuous_at(omega),
dos.continuous_at(omega),
max_relative = 1e-10
);
}
for order in [0, 2, 4] {
assert_relative_eq!(
fast.integrate(|omega| omega.powi(order), None)
.unwrap()
.value,
dos.integrate(|omega| omega.powi(order), None)
.unwrap()
.value,
max_relative = 1e-10
);
}
let g = gaussian(1.4, 0.5);
let fast_g = g.precomputed(None);
for omega in [0.0, 1.4, 3.0] {
assert_eq!(fast_g.continuous_at(omega), g.continuous_at(omega));
}
for dos in [honeycomb(0.0, 1.0), lieb(0.0, 1.0)] {
let fast = dos.precomputed(None);
let support = dos.support().unwrap();
let (mut worst, mut peak) = (0.0f64, 0.0f64);
for i in 1..500 {
let omega = support.min() + support.length() * (i as f64) / 500.0;
let (a, b) = (dos.continuous_at(omega), fast.continuous_at(omega));
if a.is_finite() && b.is_finite() {
worst = worst.max((b - a).abs());
peak = peak.max(a.abs());
}
}
assert!(worst < 1e-7 * peak, "fit stalled at {:.2e}", worst / peak);
}
let mixed = 0.5 * square(0.0, 1.0) + 0.5 * discrete(&[3.0], &[1.0]);
let fast_mixed = mixed.precomputed(None);
assert_eq!(fast_mixed.discrete().len(), 1);
assert_relative_eq!(fast_mixed.total_weight(), 1.0, epsilon = 1e-14);
}
#[test]
fn conv_discrete_continuous() {
let shifted = discrete(&[1.5], &[1.0]).conv(&semicircle(0.0, 2.0), None);
let reference = semicircle(1.5, 2.0);
assert_eq!(shifted.support(), reference.support());
for omega in [-0.5, 0.4, 1.5, 2.6, 3.5] {
assert_relative_eq!(
shifted.continuous_at(omega),
reference.continuous_at(omega),
max_relative = 1e-14
);
}
let shifted = discrete(&[2.0], &[1.0]).conv(&square(0.0, 1.0), None);
assert_eq!(shifted.continuous_at(2.0), f64::INFINITY);
assert_eq!(shifted.support(), Some(Segment::new(-2.0, 6.0)));
let a = 0.5 * discrete(&[-1.0, 2.0], &[0.25, 0.75]);
let b = 3.0 * chain(0.0, 1.0);
let c = a.conv(&b, None);
assert_relative_eq!(
c.total_weight(),
a.total_weight() * b.total_weight(),
max_relative = 1e-14
);
assert_eq!(c.continuous.len(), 2);
assert_eq!(c.support(), Some(Segment::new(-3.0, 4.0)));
for omega in [-2.5, 0.0, 1.3, 3.5] {
assert_relative_eq!(
c.continuous_at(omega),
b.conv(&a, None).continuous_at(omega),
max_relative = 1e-14
);
}
let moment =
|sf: &SpectralFunction, n: i32| sf.integrate(|w| w.powi(n), None).unwrap().value;
for n in 0..=4usize {
let c_row = util::binomials(n);
let reference: f64 = (0..=n)
.map(|k| c_row[k] * moment(&a, k as i32) * moment(&b, (n - k) as i32))
.sum();
assert_relative_eq!(moment(&c, n as i32), reference, max_relative = 1e-9);
}
}
#[test]
fn conv_shifts_every_model() {
let by = 1.25f64;
let unit = discrete(&[by], &[1.0]);
let models = [
chain(0.5, 1.0),
semicircle(0.5, 2.0),
bethe(4, 0.5, 1.0),
powerlaw(0.5, -0.5, 2.0),
powerlaw(0.5, 2.5, 2.0),
pseudogap(0.5, 0.5, 2.0),
pseudogap(0.5, 2.5, 2.0),
square(0.5, 1.0),
triangular(0.5, 1.0),
honeycomb(0.5, 1.0),
lieb(0.5, 1.0),
kagome(0.5, 1.0),
gaussian(0.5, 1.0),
flat(0.5, 2.0, 0.0),
flat(0.5, 2.0, 0.3),
square(0.5, 1.0).precomputed(None),
];
for dos in models {
let moved = unit.conv(&dos, None);
let support = dos.support().unwrap();
let (lo, hi) = (support.min().max(-20.0), support.max().min(20.0));
for i in 0..=40 {
let omega = lo + (hi - lo) * (i as f64) / 40.0;
let (before, after) = (dos.continuous_at(omega), moved.continuous_at(omega + by));
assert_relative_eq!(after, before, max_relative = 1e-12, epsilon = 1e-300);
}
assert_relative_eq!(
moved.total_weight(),
dos.total_weight(),
max_relative = 1e-14
);
}
}
#[test]
fn mirrored_every_model() {
let omega = 0.3f64;
let models = [
chain(0.5, 1.0),
semicircle(0.5, 2.0),
bethe(4, 0.5, 1.0),
powerlaw(0.5, -0.5, 2.0),
powerlaw(0.5, 2.5, 2.0),
pseudogap(0.5, 0.5, 2.0),
pseudogap(0.5, 2.5, 2.0),
square(0.5, 1.0),
triangular(0.5, 1.0),
triangular(0.5, -1.0),
honeycomb(0.5, 1.0),
lieb(0.5, 1.0),
kagome(0.5, 1.0),
gaussian(0.5, 1.0),
flat(0.5, 2.0, 0.0),
flat(0.5, 2.0, 0.3),
triangular(0.5, 1.0).precomputed(None),
powerlaw(0.5, -0.5, 2.0).conv(&chain(0.0, 1.0), None),
2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5),
];
for dos in models {
let image = dos.mirrored(omega);
let support = dos.support().unwrap();
assert_eq!(image.support().unwrap(), support.mirrored(omega));
let (lo, hi) = (support.min().max(-20.0), support.max().min(20.0));
for i in 1..40 {
let nu = lo + (hi - lo) * (i as f64) / 40.0;
assert_relative_eq!(
image.continuous_at(omega - nu),
dos.continuous_at(nu),
max_relative = 1e-12,
epsilon = 1e-14
);
}
for (csf, _) in image.continuous() {
let positions: Vec<f64> =
csf.singularities().iter().map(|s| s.position()).collect();
assert!(positions.is_sorted(), "singular points out of order");
}
let moment = |sf: &SpectralFunction, n: i32| {
sf.integrate(|w: f64| w.powi(n), None).unwrap().value
};
assert_relative_eq!(moment(&image, 0), moment(&dos, 0), max_relative = 1e-10);
assert_relative_eq!(
moment(&image, 1),
omega * moment(&dos, 0) - moment(&dos, 1),
max_relative = 1e-9,
epsilon = 1e-10
);
let back = image.mirrored(omega);
for i in 1..40 {
let nu = lo + (hi - lo) * (i as f64) / 40.0;
assert_relative_eq!(
back.continuous_at(nu),
dos.continuous_at(nu),
max_relative = 1e-12,
epsilon = 1e-14
);
}
}
}
#[test]
fn shifted_spectral_function() {
let by = 0.7f64;
let dos = 0.5 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + triangular(0.5, 1.0);
let moved = dos.shifted(by);
assert_eq!(moved.support().unwrap(), dos.support().unwrap().shifted(by));
assert_relative_eq!(moved.discrete().resonances()[0].eps, -0.7 + by);
for nu in [-4.0, -1.1, 0.2, 2.4, 3.3] {
assert_relative_eq!(
moved.continuous_at(nu + by),
dos.continuous_at(nu),
max_relative = 1e-12
);
}
}
#[test]
fn conv_of_mirrored_is_mirrored_conv() {
let (a, b) = (powerlaw(0.0, -0.5, 1.0), triangular(0.0, 1.0));
let (omega_a, omega_b) = (0.4, -0.1);
let direct = a.conv(&b, None).mirrored(omega_a + omega_b);
let reflected = a.mirrored(omega_a).conv(&b.mirrored(omega_b), None);
let support = direct.support().unwrap();
let (got, want) = (reflected.support().unwrap(), support);
assert_relative_eq!(got.min(), want.min(), max_relative = 1e-15);
assert_relative_eq!(got.max(), want.max(), max_relative = 1e-15);
for i in 1..60 {
let nu = support.min() + support.length() * (i as f64) / 60.0;
assert_relative_eq!(
reflected.continuous_at(nu),
direct.continuous_at(nu),
max_relative = 1e-8
);
}
}
#[test]
fn conv_two_continuous() {
let c = chain(0.0, 1.0).conv(&square(0.0, 1.0), None);
assert_relative_eq!(c.total_weight(), 1.0, max_relative = 1e-9);
assert!(c.discrete().is_empty());
assert_relative_eq!(
c.integrate(|_| 1.0, None).unwrap().value,
1.0,
max_relative = 1e-9
);
}
#[test]
fn conv_of_two_chains_is_the_square_lattice() {
let t = 1.3f64;
let derived = chain(0.0, t).conv(&chain(0.0, t), None);
let known = square(0.0, t);
for i in 0..=120 {
let omega = -3.99 * t + 7.98 * t * f64::from(i) / 120.0;
let want = known.continuous_at(omega);
if want.abs() < 1e-9 {
continue;
}
assert_relative_eq!(derived.continuous_at(omega), want, max_relative = 1e-9);
}
}
#[test]
fn conv_moments_follow_the_binomial_rule() {
let (a, b) = (chain(0.0, 1.0), semicircle(0.5, 2.0));
let c = a.conv(&b, None);
let moment = |sf: &SpectralFunction, n: i32| {
sf.integrate(|omega: f64| omega.powi(n), None)
.unwrap()
.value
};
for n in 0..=4i32 {
let c_row = util::binomials(n as usize);
let want: f64 = (0..=n)
.map(|k| c_row[k as usize] * moment(&a, k) * moment(&b, n - k))
.sum();
assert_relative_eq!(moment(&c, n), want, max_relative = 1e-8, epsilon = 1e-10);
}
}
#[test]
fn conv_of_mixed_spectral_functions() {
let a = 0.4 * discrete(&[-1.0, 0.5], &[0.3, 0.7]) + 0.6 * chain(0.0, 1.0);
let b = 0.25 * discrete(&[2.0], &[1.0]) + 0.75 * flat(0.0, 1.0, 0.0);
let c = a.conv(&b, None);
assert_relative_eq!(
c.total_weight(),
a.total_weight() * b.total_weight(),
max_relative = 1e-9
);
assert_relative_eq!(
c.integrate(|_| 1.0, None).unwrap().value,
a.total_weight() * b.total_weight(),
max_relative = 1e-8
);
let mean = |sf: &SpectralFunction| sf.integrate(|w: f64| w, None).unwrap().value;
assert_relative_eq!(
mean(&c),
mean(&a) * b.total_weight() + a.total_weight() * mean(&b),
max_relative = 1e-8,
epsilon = 1e-10
);
}
#[test]
fn conv_of_two_boxes_is_a_triangle() {
let d = 1.5f64;
let c = flat(0.0, d, 0.0).conv(&flat(0.0, d, 0.0), None);
for i in 0..=60 {
let omega = -2.0 * d + 4.0 * d * f64::from(i) / 60.0;
let want = (2.0 * d - omega.abs()).max(0.0) / (4.0 * d * d);
assert_relative_eq!(c.continuous_at(omega), want, epsilon = 1e-12);
}
}
#[test]
fn broadened_discrete() {
let levels = [-0.7f64, 1.2];
let weights = [0.25f64, 0.6];
let dos = 2.0 * discrete(&levels, &weights);
for delta in [1e-1, 1e-2, 1e-4] {
for omega in [-0.7, 0.0, 0.5, 1.2, 50.0] {
let ref_value: f64 = 2.0
* levels
.iter()
.zip(&weights)
.map(|(eps, w)| w * (delta / PI) / (delta.powi(2) + (omega - eps).powi(2)))
.sum::<f64>();
assert_relative_eq!(
dos.broadened(omega, delta, None).unwrap().value,
ref_value,
max_relative = 1e-10
);
}
}
}
#[test]
fn broadened_narrow_limit() {
let (eps, t, omega) = (0.5f64, 1.0f64, 0.8f64);
let dos = chain(eps, t);
let ref_value = 1.0 / (PI * ((2.0 * t).powi(2) - (omega - eps).powi(2)).sqrt());
for delta in [1e-4, 1e-6] {
assert_relative_eq!(
dos.broadened(omega, delta, None).unwrap().value,
ref_value,
max_relative = 10.0 * delta
);
}
}
#[test]
fn broadened_log_singularity() {
let t = 2.0f64;
let dos = square(0.0, t);
let mut prev = dos.broadened(0.0, 1e-2, None).unwrap().value;
for delta in [1e-3, 1e-4, 1e-5, 1e-6] {
let value = dos.broadened(0.0, delta, None).unwrap().value;
assert_relative_eq!(
value - prev,
10f64.ln() / (2.0 * PI.powi(2) * t),
max_relative = 1e-3
);
prev = value;
}
}
#[test]
fn broadened_mixed() {
let dos = 2.0 * discrete(&[-0.7, 1.2], &[0.25, 0.6]) + 5.0 * gaussian(1.4, 0.5);
assert_relative_eq!(
dos.broadened(0.5, 1e-2, None).unwrap().value,
0.8138402146,
epsilon = 1e-9
);
}
#[test]
#[should_panic(expected = "broadening must be positive")]
fn broadened_zero_delta() {
let _ = gaussian(1.4, 0.5).broadened(0.5, 0.0, None);
}
#[test]
fn integral_reports_convergence() {
let d = discrete(&[-0.7, 1.2], &[0.25, 0.6]).integrate(|w| w * w, None);
let d = d.unwrap();
assert_relative_eq!(d.value, 0.25 * 0.49 + 0.6 * 1.44, max_relative = 1e-15);
assert_eq!(d.error_estimate, 0.0);
assert!(d.converged);
let g = gaussian(1.4, 0.5);
let reached = g.integrate(|_| 1.0, None).unwrap();
let missed = g.integrate(|_| 1.0, Some(1e-30)).unwrap();
assert!(reached.converged);
assert!(!missed.converged);
assert_relative_eq!(missed.value, 1.0, max_relative = 1e-12);
assert!(g.integrate(|_| 1.0, Some(f64::NAN)).is_err());
}
#[test]
fn complex_integral_reports_its_parts_apart() {
let dos = flat(0.3, 1.0, 0.0);
let integral = dos
.integrate_complex(|w| Complex64::new(1.0, (1e5 * w * w).cos()), None)
.unwrap();
assert!(!integral.converged);
assert_relative_eq!(integral.value.re, 1.0, max_relative = 1e-12);
assert!(integral.error_estimate.re < 1e-10);
assert!(integral.error_estimate.im > 1e-10);
}
}