use special::Gamma;
use crate::ContinuousSF;
use crate::beta;
use crate::beta::{
beta_derivatives, inc_beta_derivatives, inc_beta_derivatives_split, outer_beta_complete,
outer_beta_derivatives, outer_beta_derivatives_split, outer_beta_entire_factor,
outer_beta_tail,
};
use crate::polynomial::Polynomial;
use crate::segment::Segment;
use crate::singularity::{AsymptTerm, Singularity, power_log_integral};
use crate::util::{
Table, alternating_sign, bilby_integrate_or_0, binomials, integrate_by_subtraction,
negate_table, subtract_tables,
};
fn derivatives_to_log_coeffs(table: &Table, j_max: usize, k_max: usize) -> Polynomial {
let degree = j_max + k_max;
let (c_row1, c_row2) = (binomials(j_max), binomials(k_max));
let mut out = Polynomial::zeros(degree);
for (j, &c1) in c_row1.iter().enumerate() {
for (k, &c2) in c_row2.iter().enumerate() {
out[degree - j - k] += c1 * c2 * table[j][k];
}
}
out
}
pub fn pair_support(c1: &dyn ContinuousSF, c2: &dyn ContinuousSF) -> Segment {
let (s1, s2) = (c1.support(), c2.support());
assert!(
s1.is_bounded() && s2.is_bounded(),
"convolution of continuous parts is restricted to bounded supports"
);
s1 + s2
}
pub fn pair_singularities(c1: &dyn ContinuousSF, c2: &dyn ContinuousSF) -> Vec<Singularity> {
let (s1, s2) = (c1.support(), c2.support());
let forms = |csf: &dyn ContinuousSF| -> Vec<(f64, LocalForm)> {
features(csf)
.into_iter()
.map(|p| (p, local_form_at(csf, p)))
.collect()
};
let (forms1, forms2) = (forms(c1), forms(c2));
let mut derived: Vec<(f64, Vec<AsymptTerm>)> = Vec::new();
for (p1, (singular1, constant1)) in &forms1 {
for (p2, (singular2, constant2)) in &forms2 {
let reach = reach_between(s1, *p1, s2, *p2);
let mut terms = Vec::new();
for t1 in singular1 {
for t2 in singular2 {
terms.extend(convolve_terms(t1, t2, Some(reach)));
}
terms.extend(convolve_terms(t1, constant2, None));
}
for t2 in singular2 {
terms.extend(convolve_terms(constant1, t2, None));
}
let position = p1 + p2;
match derived.iter_mut().find(|(p, _)| *p == position) {
Some((_, already)) => already.extend(terms),
None => derived.push((position, terms)),
}
}
}
derived.sort_by(|x, y| x.0.total_cmp(&y.0));
derived
.into_iter()
.map(|(position, terms)| Singularity::new(position, 1.0, terms))
.collect()
}
fn features(csf: &dyn ContinuousSF) -> Vec<f64> {
let support = csf.support();
let mut out: Vec<f64> = csf.singularities().iter().map(|s| s.position()).collect();
out.push(support.min());
out.push(support.max());
out.sort_unstable_by(f64::total_cmp);
out.dedup();
out
}
type LocalForm = (Vec<AsymptTerm>, AsymptTerm);
fn local_form_at(csf: &dyn ContinuousSF, position: f64) -> LocalForm {
let support = csf.support();
let (reaches_below, reaches_above) = (position > support.min(), position < support.max());
let sided = |t: &AsymptTerm| t.sides_kept(reaches_below, reaches_above);
let mut singular = Vec::new();
let mut constant = csf.regular(position);
for sing in csf.singularities() {
if sing.position() == position {
for t in sing.terms() {
singular.push(sided(t));
}
} else {
constant += sing.value(position);
}
}
(singular, sided(&AsymptTerm::power(0.0, constant)))
}
fn reach_between(s1: Segment, p1: f64, s2: Segment, p2: f64) -> Segment {
s1.shifted(-p1)
.intersection(s2.mirrored(p2))
.expect("a feature lies within its own support")
}
fn convolve_terms(t1: &AsymptTerm, t2: &AsymptTerm, reach: Option<Segment>) -> Vec<AsymptTerm> {
let (r1, r2) = (t1.exponent(), t2.exponent());
let rho = r1 + r2 + 1.0;
let constant = reach.map_or(0.0, |reach| coincident_constant(t1, t2, reach));
debug_assert!(
rho != 0.0 || reach.is_some(),
"rho = 0 needs two singular parts"
);
let mut terms = Vec::new();
if rho < AsymptTerm::MAX_EXPONENT {
let degenerate = beta::near_a_whole_exponent(rho);
let degree = t1.log_degree() + t2.log_degree() + usize::from(degenerate);
let (mut below, mut above) = (Polynomial::zeros(degree), Polynomial::zeros(degree));
for (m1, cb1, ca1) in t1.log_coeffs() {
for (m2, cb2, ca2) in t2.log_coeffs() {
let [mid, lo, hi] = if degenerate {
degenerate_stretches(r1, m1, r2, m2, rho.round() as usize)
} else {
generic_stretches(r1, m1, r2, m2)
};
below.add_scaled(&mid, cb1 * cb2);
below.add_scaled(&lo, ca1 * cb2);
below.add_scaled(&hi, cb1 * ca2);
above.add_scaled(&mid, ca1 * ca2);
above.add_scaled(&lo, cb1 * ca2);
above.add_scaled(&hi, ca1 * cb2);
}
}
if rho == 0.0 {
below[0] += constant;
above[0] += constant;
}
let family = AsymptTerm::sided_log_poly(rho, below, above);
if !family.is_zero() {
terms.push(family);
}
}
if rho != 0.0 && constant != 0.0 {
terms.push(AsymptTerm::power(0.0, constant));
}
terms
}
fn coincident_constant(t1: &AsymptTerm, t2: &AsymptTerm, reach: Segment) -> f64 {
let exponent = t1.exponent() + t2.exponent();
let stretch = |c: f64, m: u8, l: f64| {
if c == 0.0 || l == 0.0 {
0.0
} else if exponent == -1.0 {
c * l.ln().powi(i32::from(m) + 1) / f64::from(m + 1)
} else {
c * power_log_integral(exponent, m, l)
}
};
let mut total = 0.0;
for (m1, cb1, ca1) in t1.log_coeffs() {
for (m2, cb2, ca2) in t2.log_coeffs() {
let m = (m1 + m2) as u8;
total += stretch(cb1 * ca2, m, -reach.min()) + stretch(ca1 * cb2, m, reach.max());
}
}
total
}
fn generic_stretches(r1: f64, m1: usize, r2: f64, m2: usize) -> [Polynomial; 3] {
let outer = |r_own: f64, m_own: usize, r_other: f64, m_other: usize| {
let table = outer_beta_complete(r_other + 1.0, r_own + 1.0, m_other, m_own);
derivatives_to_log_coeffs(&table, m_other, m_own)
};
[
middle_coefficients(r1, m1, r2, m2),
outer(r1, m1, r2, m2),
outer(r2, m2, r1, m1),
]
}
fn middle_coefficients(r1: f64, m1: usize, r2: f64, m2: usize) -> Polynomial {
derivatives_to_log_coeffs(&beta_derivatives(r1 + 1.0, r2 + 1.0, m1, m2), m1, m2)
}
fn degenerate_stretches(r1: f64, m1: usize, r2: f64, m2: usize, n: usize) -> [Polynomial; 3] {
let degree = m1 + m2 + 1;
let pad = |mut v: Polynomial| {
v.resize(degree);
if n > 0 {
v[0] = 0.0;
}
v
};
[
pad(middle_coefficients(r1, m1, r2, m2)),
pad(outer_stretch_logs(r1, m1, m2, n)),
pad(outer_stretch_logs(r2, m2, m1, n)),
]
}
fn outer_stretch_logs(r_own: f64, m_own: usize, m_other: usize, n: usize) -> Polynomial {
let degree = m_own + m_other;
let f = outer_beta_entire_factor(r_own + 1.0, n, m_own, degree + 1);
let (c_row_own, c_row_other) = (binomials(m_own), binomials(m_other));
let factorial = |p: usize| Gamma::gamma(p as f64 + 1.0);
let mut out = Polynomial::zeros(degree + 1);
for (j, &c1) in c_row_own.iter().enumerate() {
let c_row_inner = binomials(j);
for (k, &c2) in c_row_other.iter().enumerate() {
for (i, &c_inner) in c_row_inner.iter().enumerate() {
let p = i + k + 1;
let scale = c1 * c2 * c_inner * factorial(i + k);
out[degree - j - k + p] += scale * alternating_sign(p) * f[j - i][0] / factorial(p);
out[degree - j - k] += scale * alternating_sign(i + k) * f[j - i][p];
}
}
}
out
}
pub fn pair_value(c1: &dyn ContinuousSF, c2: &dyn ContinuousSF, omega: f64, tol: f64) -> f64 {
let (s1, s2) = (c1.support(), c2.support());
let Some(overlap) = s1.intersection(s2.mirrored(omega)) else {
return 0.0;
};
if overlap.is_degenerate() {
return 0.0;
}
let parts1: Vec<Part> = c1
.singularities()
.iter()
.filter(|sing| !sing.is_trivial())
.map(|sing| Part {
sing,
support: s1,
reflected: None,
})
.collect();
let parts2: Vec<Part> = c2
.singularities()
.iter()
.filter(|sing| !sing.is_trivial())
.map(|sing| Part {
sing,
support: s2,
reflected: Some(omega),
})
.collect();
let mut total =
bilby_integrate_or_0(|nu| c1.regular(nu) * c2.regular(omega - nu), overlap, tol);
for part in &parts1 {
total += subtracted(part, |nu| c2.regular(omega - nu), overlap, tol);
}
for part in &parts2 {
total += subtracted(part, |nu| c1.regular(nu), overlap, tol);
}
for first in &parts1 {
for second in &parts2 {
total += singular_singular(first, second, overlap);
}
}
total
}
struct Part<'a> {
sing: &'a Singularity,
support: Segment,
reflected: Option<f64>,
}
impl Part<'_> {
fn argument(&self, nu: f64) -> f64 {
match self.reflected {
Some(omega) => omega - nu,
None => nu,
}
}
fn at(&self) -> f64 {
match self.reflected {
Some(omega) => omega - self.sing.position(),
None => self.sing.position(),
}
}
fn value(&self, nu: f64) -> f64 {
let argument = self.argument(nu);
if !self.support.contains(argument) {
return 0.0;
}
let value = self.sing.value(argument);
if value.is_finite() { value } else { 0.0 }
}
fn sided_terms(&self) -> Vec<AsymptTerm> {
let position = self.sing.position();
let reaches_below = position > self.support.min();
let reaches_above = position < self.support.max();
let mut out = Vec::with_capacity(self.sing.terms().len());
for t in self.sing.terms() {
out.push(t.sides_kept(reaches_below, reaches_above));
}
out
}
fn integral(&self, segment: Segment) -> f64 {
let own = match self.reflected {
Some(_) => segment.shifted(-self.at()).mirrored(self.sing.position()),
None => segment,
};
match own.intersection(self.support) {
Some(within) => self.sing.integral(within),
None => 0.0,
}
}
}
fn subtracted<G: Fn(f64) -> f64>(part: &Part, g: G, segment: Segment, tol: f64) -> f64 {
integrate_by_subtraction(
part.at(),
|nu| part.value(nu),
|stretch| part.integral(stretch),
g,
segment,
tol,
)
.map_or(0.0, |integral| integral.value)
}
fn singular_singular(first: &Part, second: &Part, segment: Segment) -> f64 {
let (p, q) = (first.at(), second.at());
let raw = q - p;
assert!(
raw != 0.0,
"a pair has no value where its two singular points meet"
);
let reach = segment.shifted(-p);
let (delta, reach, flipped) = if raw < 0.0 {
(-raw, reach.mirrored(0.0), true)
} else {
(raw, reach, false)
};
let sided = |c_below: f64, c_above: f64| {
if flipped {
(c_above, c_below)
} else {
(c_below, c_above)
}
};
let below_zero = Segment::new(f64::NEG_INFINITY, 0.0);
let between = Segment::new(0.0, delta);
let past_delta = Segment::new(delta, f64::INFINITY);
let mut total = 0.0;
let (terms1, terms2) = (first.sided_terms(), second.sided_terms());
for t1 in &terms1 {
let r1 = t1.exponent();
for t2 in &terms2 {
let r2 = t2.exponent();
let rho = r1 + r2 + 1.0;
for (m1, cb1, ca1) in t1.log_coeffs() {
for (m2, cb2, ca2) in t2.log_coeffs() {
let (below1, above1) = sided(cb1, ca1);
let (below2, above2) = sided(cb2, ca2);
let mut take = |weight: f64, stretch: StretchContrib| {
total += weight
* (contract_with_ln_m(&stretch.singular, rho, delta) + stretch.regular);
};
if let Some(s) = stretch_within(reach, below_zero)
&& below1 != 0.0
&& above2 != 0.0
{
take(
below1 * above2,
outer_stretch(r1, m1, r2, m2, delta, s.mirrored(0.0)),
);
}
if let Some(x) = stretch_within(reach, between)
&& above1 != 0.0
&& above2 != 0.0
{
take(above1 * above2, middle_stretch(r1, m1, r2, m2, delta, x));
}
if let Some(s) = stretch_within(reach, past_delta)
&& above1 != 0.0
&& below2 != 0.0
{
take(
above1 * below2,
outer_stretch(r2, m2, r1, m1, delta, s.shifted(-delta)),
);
}
}
}
}
}
total
}
fn stretch_within(reach: Segment, region: Segment) -> Option<Segment> {
reach.intersection(region).filter(|s| !s.is_degenerate())
}
struct StretchContrib {
singular: Polynomial,
regular: f64,
}
impl StretchContrib {
fn undivided(degree: usize, value: f64) -> StretchContrib {
StretchContrib {
singular: Polynomial::zeros(degree),
regular: value,
}
}
}
fn outer_stretch(r1: f64, m1: usize, r2: f64, m2: usize, delta: f64, s: Segment) -> StretchContrib {
let rho = r1 + r2 + 1.0;
let (a, b) = (r2 + 1.0, r1 + 1.0);
let u = |t: f64| t / delta;
let degree = m1 + m2;
let Some((complete, far)) = outer_beta_derivatives_split(a, b, u(s.max()), m2, m1) else {
let upper = outer_beta_derivatives(a, b, u(s.max()), m2, m1);
let lower = outer_beta_derivatives(a, b, u(s.min()), m2, m1);
let step = subtract_tables(&upper, &lower);
let coefficients = derivatives_to_log_coeffs(&step, m2, m1);
return StretchContrib::undivided(degree, contract_with_ln_m(&coefficients, rho, delta));
};
let (singular, rest) = if s.min() == 0.0 {
(
derivatives_to_log_coeffs(&complete, m2, m1),
negate_table(&far),
)
} else {
let near = outer_beta_tail(a, b, u(s.min()), &complete, m2, m1);
(Polynomial::zeros(degree), subtract_tables(&near, &far))
};
let regular = contract_with_ln_m(&derivatives_to_log_coeffs(&rest, m2, m1), rho, delta);
StretchContrib { singular, regular }
}
fn middle_stretch(
r1: f64,
m1: usize,
r2: f64,
m2: usize,
delta: f64,
x: Segment,
) -> StretchContrib {
let rho = r1 + r2 + 1.0;
let (a, b) = (r1 + 1.0, r2 + 1.0);
let degree = m1 + m2;
let Some((complete, far)) = inc_beta_derivatives_split(a, b, x.max() / delta, m1, m2) else {
let upper = inc_beta_derivatives(a, b, x.max() / delta, m1, m2);
let lower = inc_beta_derivatives(a, b, x.min() / delta, m1, m2);
let step = subtract_tables(&upper, &lower);
let coefficients = derivatives_to_log_coeffs(&step, m1, m2);
return StretchContrib::undivided(degree, contract_with_ln_m(&coefficients, rho, delta));
};
let (singular, rest) = if x.min() == 0.0 && x.max() == delta {
(
derivatives_to_log_coeffs(&complete, m1, m2),
negate_table(&far),
)
} else {
let (_, near) = inc_beta_derivatives_split(a, b, x.min() / delta, m1, m2)
.expect("the far end already split, so the near one does too");
(Polynomial::zeros(degree), subtract_tables(&near, &far))
};
let regular = contract_with_ln_m(&derivatives_to_log_coeffs(&rest, m1, m2), rho, delta);
StretchContrib { singular, regular }
}
fn contract_with_ln_m(coefficients: &Polynomial, rho: f64, delta: f64) -> f64 {
delta.powf(rho) * coefficients.eval(delta.ln())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::SpectralFunction;
use crate::models::*;
use approx::assert_relative_eq;
fn only(sf: &SpectralFunction) -> &dyn ContinuousSF {
sf.continuous[0].0.as_ref()
}
#[test]
fn support_adds() {
let (a, b) = (chain(0.0, 1.0), flat(0.5, 1.0, 0.0));
let reach = pair_support(only(&a), only(&b));
assert_relative_eq!(reach.min(), -2.5);
assert_relative_eq!(reach.max(), 3.5);
assert_eq!(pair_value(only(&a), only(&b), 4.0, 1e-10), 0.0);
assert_eq!(pair_value(only(&a), only(&b), -3.0, 1e-10), 0.0);
}
#[test]
fn the_square_lattice_logarithm_is_derived() {
let t = 1.0f64;
let (a, b) = (chain(0.0, t), chain(0.0, t));
let derived = pair_singularities(only(&a), only(&b));
let centre = derived.iter().find(|s| s.position() == 0.0).unwrap();
let slope = (centre.value(1e-8) - centre.value(1e-4)) / (1e-8f64.ln() - 1e-4f64.ln());
assert_relative_eq!(
slope,
-1.0 / (2.0 * std::f64::consts::PI.powi(2) * t),
max_relative = 1e-11
);
for position in [-4.0f64, 4.0] {
let edge = derived.iter().find(|s| s.position() == position).unwrap();
let (inside, outside) = if position < 0.0 {
(position + 1e-6, position - 1e-6)
} else {
(position - 1e-6, position + 1e-6)
};
assert_relative_eq!(
edge.value(inside),
1.0 / (4.0 * std::f64::consts::PI * t),
max_relative = 1e-12
);
assert_eq!(edge.value(outside), 0.0);
}
}
#[test]
fn a_pair_leaves_nothing_to_the_regular_part() {
let cases = [
(
"two chain edges, ρ = 0",
chain(0.0, 1.0),
0,
chain(0.0, 1.0),
1,
),
(
"two chain edges meeting, ρ = 0",
chain(0.0, 1.0),
1,
chain(0.0, 1.0),
1,
),
(
"a chain edge and a log, ρ = 1/2",
chain(0.0, 1.0),
1,
square(0.0, 1.0),
0,
),
("two logs, ρ = 1", square(0.0, 1.0), 0, square(0.0, 1.0), 0),
(
"a bethe edge and a chain edge, ρ = 1",
bethe(3, 0.0, 1.0),
1,
chain(0.0, 1.0),
0,
),
(
"two Dirac points, ρ = 3",
honeycomb(0.0, 1.0),
1,
honeycomb(0.0, 1.0),
1,
),
];
for (name, a, ia, b, ib) in cases {
let (c1, c2) = (only(&a), only(&b));
let (s1, s2) = (c1.support(), c2.support());
let (sing1, sing2) = (&c1.singularities()[ia], &c2.singularities()[ib]);
let (p1, p2) = (sing1.position(), sing2.position());
let reach = reach_between(s1, p1, s2, p2);
let first = Part {
sing: sing1,
support: s1,
reflected: None,
};
let mut terms = Vec::new();
for t1 in &first.sided_terms() {
let second = Part {
sing: sing2,
support: s2,
reflected: Some(p1 + p2),
};
for t2 in &second.sided_terms() {
terms.extend(convolve_terms(t1, t2, Some(reach)));
}
}
let claimed = Singularity::new(p1 + p2, 1.0, terms);
for side in [-1.0f64, 1.0] {
let residual = |h: f64| {
let omega = p1 + p2 + side * h;
let second = Part {
sing: sing2,
support: s2,
reflected: Some(omega),
};
let value = s1
.intersection(s2.mirrored(omega))
.map_or(0.0, |overlap| singular_singular(&first, &second, overlap));
value - claimed.value(omega)
};
let (far, near) = (residual(1e-4).abs(), residual(1e-6).abs());
assert!(
near < 0.05 * far.max(1e-13),
"{name} left {near:.3e} at 1e-6 against {far:.3e} at 1e-4"
);
}
}
}
#[test]
fn the_regular_part_meets_itself_at_a_derived_point() {
let (a, b) = (chain(0.0, 1.0), chain(0.0, 1.0));
let (c1, c2) = (only(&a), only(&b));
let derived = pair_singularities(c1, c2);
let regular = |omega: f64| {
let singular: f64 = derived.iter().map(|s| s.value(omega)).sum();
pair_value(c1, c2, omega, 1e-13) - singular
};
let (mut below, mut above) = (0.0, 0.0);
for h in [1e-4f64, 1e-6] {
(below, above) = (regular(-h), regular(h));
assert_relative_eq!(below, above, max_relative = 1e-6, epsilon = 1e-9);
}
assert!(below.is_finite() && above.is_finite());
}
#[test]
fn the_constant_continues_below_rho_zero() {
let (r, l) = (-0.6f64, 1.5f64);
let term = |c_below: f64, c_above: f64| AsymptTerm::sided_log(r, 0, c_below, c_above);
let claimed = coincident_constant(&term(1.0, 1.0), &term(1.0, 1.0), Segment::new(-l, l));
let mut previous = f64::INFINITY;
for delta in [1e-3f64, 1e-5, 1e-7] {
let outer = outer_stretch(r, 0, r, 0, delta, Segment::new(0.0, l)).regular;
let middle = middle_stretch(r, 0, r, 0, delta, Segment::new(0.0, delta));
assert_eq!(middle.regular, 0.0);
let error = (2.0 * outer - claimed).abs();
assert!(
error < previous,
"{error:.3e} did not improve on {previous:.3e}"
);
previous = error;
}
assert!(previous < 1e-6 * claimed.abs(), "stalled at {previous:.3e}");
}
#[test]
fn an_outer_stretch_against_a_closed_form() {
let lambda = 1.0f64;
for &(a, b) in &[(0.7f64, 0.6f64), (1.3, 0.25), (0.4, 1.9)] {
let rho = a + b - 1.0;
let singular = beta_derivatives(b, -rho, 0, 0)[0][0];
for delta in [1e-3f64, 1e-4, 1e-5] {
let stretch = Segment::new(0.0, lambda - delta);
let got = outer_stretch(b - 1.0, 0, a - 1.0, 0, delta, stretch);
assert_eq!(got.singular.degree(), 0);
assert_relative_eq!(got.singular[0], singular, max_relative = 1e-12);
let background = lambda.powf(rho) / rho
- (b - 1.0) * lambda.powf(rho - 1.0) / (rho - 1.0) * delta;
let slack = delta * delta;
assert!(
(got.regular - background).abs() < slack,
"a={a} b={b} Δ={delta:.0e}: {} against {background}, off by more \
than {slack:.1e}",
got.regular
);
}
}
}
#[test]
fn the_constant_a_pair_leaves_is_sided() {
let term = |c_below: f64, c_above: f64| AsymptTerm::sided_log(-0.5, 0, c_below, c_above);
let pair = Singularity::new(
0.0,
1.0,
convolve_terms(
&term(1.0, 2.0),
&term(0.7, 0.3),
Some(Segment::new(-1.0, 3.0)),
),
);
let (d1, d2) = (1e-3f64, 1e-6f64);
let split = |side: f64| {
let (s1, s2) = (pair.value(side * d1), pair.value(side * d2));
let slope = (s1 - s2) / (d1.ln() - d2.ln());
(slope, s1 - slope * d1.ln())
};
let (slope_above, constant_above) = split(1.0);
let (slope_below, constant_below) = split(-1.0);
assert_relative_eq!(slope_above, -1.7, max_relative = 1e-12);
assert_relative_eq!(slope_below, -1.7, max_relative = 1e-12);
assert_relative_eq!(constant_above, 5.779_713_210_193, max_relative = 1e-11);
assert_relative_eq!(constant_below, 6.093_872_475_552, max_relative = 1e-11);
}
#[test]
fn a_termless_singular_part_is_no_pair() {
let d = 1.5f64;
let boxes = flat(0.0, d, 0.0).conv(&flat(0.0, d, 0.0), None);
let band = chain(0.0, 1.0);
let (triangle, chain_band) = (only(&boxes), only(&band));
assert!(triangle.singularities().iter().all(|s| s.is_trivial()));
let omega =
triangle.singularities()[1].position() + chain_band.singularities()[0].position();
let at = |w: f64| pair_value(triangle, chain_band, w, 1e-11);
let value = at(omega);
assert!(value.is_finite(), "got {value}");
let h = 1e-6;
assert_relative_eq!(
value,
0.5 * (at(omega - h) + at(omega + h)),
max_relative = 1e-6
);
}
#[test]
fn the_regular_part_is_smooth_enough_to_fit() {
use crate::interp::InterpolatedSF;
let cases = [
(
"chain against chain",
chain(0.0, 1.0),
chain(0.0, 1.0),
1e-12f64,
),
(
"box against box",
flat(0.0, 1.5, 0.0),
flat(0.0, 1.5, 0.0),
1e-14,
),
(
"chain against square",
chain(0.0, 1.0),
square(0.0, 1.0),
2e-12,
),
(
"square against square",
square(0.0, 1.0),
square(0.0, 1.0),
1e-12,
),
(
"triangular against itself",
triangular(0.0, 1.0),
triangular(0.0, 1.0),
1e-12,
),
];
for (name, a, b, want) in cases {
let derived = pair_singularities(only(&a), only(&b));
let tol = 1e-12;
let regular = |omega: f64| {
let singular: f64 = derived.iter().map(|s| s.value(omega)).sum();
pair_value(only(&a), only(&b), omega, tol) - singular
};
let reach = pair_support(only(&a), only(&b));
let fitted = InterpolatedSF::from_parts(reach, derived.clone(), regular, Some(tol));
assert!(
fitted.fit_error() < want,
"{name} fitted to {:.2e}, wanted better than {want:.0e}",
fitted.fit_error()
);
}
}
#[test]
fn an_exponent_beside_a_whole_number() {
for r in [0.4f64, 0.49, 0.4999, 0.49999, 0.4999999, 0.499999999, 0.5] {
let a = crate::models::pseudogap(0.0, r, 1.0);
let moment = |sf: &crate::SpectralFunction| {
sf.integrate(|omega: f64| omega * omega, None)
.unwrap()
.value
};
let one = moment(&a);
let c = a.conv(&a, None);
assert_relative_eq!(
c.integrate(|_| 1.0, None).unwrap().value,
1.0,
epsilon = 1e-8
);
assert_relative_eq!(moment(&c), 2.0 * one, max_relative = 1e-8);
}
}
#[test]
fn equal_band_edges_derive_nothing() {
let d = 1.5f64;
let (a, b) = (flat(0.0, d, 0.0), flat(0.0, d, 0.0));
let derived = pair_singularities(only(&a), only(&b));
assert_eq!(derived.len(), 3);
assert!(derived.iter().all(|s| s.is_trivial()));
let h = 1e-3f64;
let at = |w: f64| pair_value(only(&a), only(&b), w, 1e-13);
let kink = (at(h) + at(-h) - 2.0 * at(0.0)) / (2.0 * h);
assert_relative_eq!(kink, -1.0 / (4.0 * d * d), max_relative = 1e-9);
}
#[test]
fn two_boxes_make_a_triangle() {
let (d, tol) = (1.5f64, 1e-12);
let (a, b) = (flat(0.0, d, 0.0), flat(0.0, d, 0.0));
let triangle = |w: f64| (2.0 * d - w.abs()).max(0.0) / (4.0 * d * d);
for i in 0..=40 {
let w = -2.0 * d + 4.0 * d * (i as f64) / 40.0;
assert_relative_eq!(
pair_value(only(&a), only(&b), w, tol),
triangle(w),
epsilon = 1e-12
);
}
}
#[test]
fn two_chains_make_a_square_lattice() {
let t = 1.0f64;
let (a, b) = (chain(0.0, t), chain(0.0, t));
let reference = square(0.0, t);
for w in [-3.9f64, -2.5, -1.0, -0.3, 0.3, 1.0, 2.5, 3.9] {
assert_relative_eq!(
pair_value(only(&a), only(&b), w, 1e-12),
reference.continuous_at(w),
max_relative = 1e-12
);
}
}
#[test]
fn colliding_points_diverge() {
let t = 1.0f64;
let derived = chain(0.0, t).conv(&chain(0.0, t), None);
let known = square(0.0, t);
assert_eq!(derived.continuous_at(0.0), f64::INFINITY);
assert_eq!(known.continuous_at(0.0), f64::INFINITY);
for w in [-1e-6f64, 1e-6] {
assert_relative_eq!(
derived.continuous_at(w),
known.continuous_at(w),
max_relative = 1e-9
);
}
let boxes = flat(0.0, 1.5, 0.0);
assert!(boxes.conv(&boxes, None).continuous_at(0.0).is_finite());
}
}