use crate::singularity::power_log_integral;
use crate::util::{Table, alternating_sign, binomials, polygamma, subtract_tables};
use special::Gamma;
fn leibniz(n: usize, f: &[f64], g: &[f64]) -> f64 {
let c_row = binomials(n);
(0..=n).map(|j| c_row[j] * f[n - j] * g[j]).sum()
}
fn gamma_derivatives(z: f64, n: usize) -> Vec<f64> {
let psi: Vec<f64> = (0..=n).map(|j| polygamma(j as u32, z)).collect();
let mut d = vec![Gamma::gamma(z)];
for k in 0..n {
let next = leibniz(k, &d, &psi);
d.push(next);
}
d
}
fn recip_gamma_derivatives(z: f64, n: usize) -> Vec<f64> {
let shift = if z >= 1.0 {
0
} else {
(2.0 - z).ceil() as usize
};
let raised = z + shift as f64;
let psi: Vec<f64> = (0..=n).map(|j| polygamma(j as u32, raised)).collect();
let mut q = vec![Gamma::gamma(raised).recip()];
for k in 0..n {
let next = -leibniz(k, &q, &psi);
q.push(next);
}
if shift == 0 {
return q;
}
let mut poly = vec![1.0];
for m in 0..shift {
let mut next = vec![0.0; poly.len() + 1];
for (i, &p) in poly.iter().enumerate() {
next[i] += p * m as f64;
next[i + 1] += p;
}
poly = next;
}
let p: Vec<f64> = (0..=n)
.map(|j| {
poly.iter()
.enumerate()
.skip(j)
.map(|(i, &c)| {
c * ((i - j + 1)..=i).map(|f| f as f64).product::<f64>()
* z.powi((i - j) as i32)
})
.sum()
})
.collect();
(0..=n).map(|k| leibniz(k, &p, &q)).collect()
}
pub fn beta_derivatives(a: f64, b: f64, j_max: usize, k_max: usize) -> Table {
let g_a = gamma_derivatives(a, j_max);
let g_b = gamma_derivatives(b, k_max);
let inv_g_ab = recip_gamma_derivatives(a + b, j_max + k_max);
leibniz_table(&g_a, &g_b, &inv_g_ab, j_max, k_max)
}
fn leibniz_table(g_a: &[f64], g_b: &[f64], inv_g_ab: &[f64], j_max: usize, k_max: usize) -> Table {
let c_rows: Vec<Vec<f64>> = (0..=j_max.max(k_max)).map(binomials).collect();
let mut table = vec![vec![0.0; k_max + 1]; j_max + 1];
for j in 0..=j_max {
let c_row_j = &c_rows[j];
for k in 0..=k_max {
let c_row_k = &c_rows[k];
for p in 0..=j {
for q in 0..=k {
let scale = c_row_j[p] * c_row_k[q] * g_a[j - p];
table[j][k] += g_b[k - q] * inv_g_ab[p + q] * scale;
}
}
}
}
table
}
fn advance_pochhammer(poch_der: &mut [f64], b: f64, n: usize) {
let (shift, step) = (1.0 - b + n as f64, (n + 1) as f64);
for k in (0..poch_der.len()).rev() {
let lower = if k > 0 {
k as f64 * poch_der[k - 1]
} else {
0.0
};
poch_der[k] = (shift * poch_der[k] - lower) / step;
}
}
const MAX_SERIES_TERMS: usize = 4096;
fn inc_beta_derivatives_series(
a: f64,
b: f64,
z: f64,
j_max: usize,
k_max: usize,
tol: f64,
) -> Table {
let mut out = vec![vec![0.0; k_max + 1]; j_max + 1];
if z <= 0.0 {
return out;
}
let ln_z = z.ln();
let c_rows: Vec<Vec<f64>> = (0..=j_max).map(binomials).collect();
let mut poch_der = vec![0.0; k_max + 1];
poch_der[0] = 1.0;
let mut power = z.powf(a);
let mut scale = 0.0f64;
for n in 0..MAX_SERIES_TERMS {
let an = a + n as f64;
let mut largest = 0.0f64;
for j in 0..=j_max {
let mut d = 0.0;
let mut falling = 1.0;
for (i, &c) in c_rows[j].iter().enumerate() {
d += c * ln_z.powi((j - i) as i32) * falling / an.powi(i as i32 + 1);
falling *= -((i + 1) as f64);
}
d *= power;
for k in 0..=k_max {
let term = poch_der[k] * d;
out[j][k] += term;
largest = largest.max(term.abs());
scale = scale.max(out[j][k].abs());
}
}
if n > 0 && largest <= tol * scale {
break;
}
advance_pochhammer(&mut poch_der, b, n);
power *= z;
}
out
}
fn exp_moments(delta: f64, k_max: usize, l1: f64, l2: f64) -> Vec<f64> {
if l1 == f64::NEG_INFINITY {
return exp_moments_to(delta, k_max, l2);
}
if (delta * l1).abs() <= 2.0 {
return (0..=k_max)
.map(|k| {
let mut total = 0.0;
let mut weight = 1.0;
for i in 0..MAX_EXP_MOMENT_TERMS {
let p = (k + i + 1) as i32;
let term = weight * (l2.powi(p) - l1.powi(p)) / f64::from(p);
total += term;
if i > 2 && term.abs() <= f64::EPSILON * total.abs() {
break;
}
weight *= delta / (i + 1) as f64;
}
total
})
.collect();
}
let (upper, lower) = (
exp_moments_to(delta, k_max, l2),
exp_moments_to(delta, k_max, l1),
);
let mut out = Vec::with_capacity(k_max + 1);
for k in 0..=k_max {
out.push(upper[k] - lower[k]);
}
out
}
const MAX_EXP_MOMENT_TERMS: usize = 64;
fn exp_moments_to(delta: f64, k_max: usize, l: f64) -> Vec<f64> {
let e = (delta * l).exp();
(0..=k_max)
.map(|k| {
let c_row = binomials(k);
let mut total = 0.0;
let mut falling = 1.0;
for i in (0..=k).rev() {
let weight = c_row[i] * falling / delta.powi((k - i + 1) as i32);
total += weight * l.powi(i as i32) * e;
falling *= -((k - i + 1) as f64);
}
total
})
.collect()
}
fn inc_beta_derivatives_near_one(
a: f64,
b: f64,
z: f64,
j_max: usize,
k_max: usize,
tol: f64,
) -> Table {
let y = 1.0 - z;
let (l1, l2) = (y.ln(), -std::f64::consts::LN_2);
let mut out = inc_beta_derivatives_series(a, b, 0.5, j_max, k_max, tol);
let mut poch_der = vec![0.0; j_max + 1];
poch_der[0] = 1.0;
let mut scale: Table = out
.iter()
.map(|row| row.iter().map(|v| v.abs()).collect())
.collect();
for n in 0..MAX_SERIES_TERMS {
let moments = exp_moments(b + n as f64, k_max, l1, l2);
let mut converged = n > 0;
for (j, row) in out.iter_mut().enumerate() {
for (k, value) in row.iter_mut().enumerate() {
let term = poch_der[j] * moments[k];
*value += term;
scale[j][k] = scale[j][k].max(value.abs());
converged &= term.abs() <= tol * scale[j][k];
}
}
if converged {
break;
}
advance_pochhammer(&mut poch_der, a, n);
}
out
}
const TOL: f64 = 1e-17;
pub const WHOLE_EXPONENT_WIDTH: f64 = 1e-4;
pub fn near_a_whole_exponent(rho: f64) -> bool {
let nearest = rho.round();
nearest >= 0.0 && (rho - nearest).abs() < WHOLE_EXPONENT_WIDTH
}
pub type SplitTables = (Table, Table);
pub fn inc_beta_derivatives_split(
a: f64,
b: f64,
z: f64,
j_max: usize,
k_max: usize,
) -> Option<SplitTables> {
assert!(
a > 0.0,
"the first parameter of an incomplete beta must be positive"
);
assert!((0.0..=1.0).contains(&z), "the argument must lie in [0, 1]");
if near_a_whole_exponent(-b) {
return None;
}
let complete = beta_derivatives(a, b, j_max, k_max);
let deficit = if z > 0.5 {
let reflected = inc_beta_derivatives_series(b, a, 1.0 - z, k_max, j_max, TOL);
(0..=j_max)
.map(|j| (0..=k_max).map(|k| reflected[k][j]).collect())
.collect()
} else {
let whole = inc_beta_derivatives_series(a, b, z, j_max, k_max, TOL);
(0..=j_max)
.map(|j| (0..=k_max).map(|k| complete[j][k] - whole[j][k]).collect())
.collect()
};
Some((complete, deficit))
}
pub fn inc_beta_derivatives(a: f64, b: f64, z: f64, j_max: usize, k_max: usize) -> Table {
assert!(
a > 0.0,
"the first parameter of an incomplete beta must be positive"
);
assert!((0.0..=1.0).contains(&z), "the argument must lie in [0, 1]");
if z <= 0.5 {
return inc_beta_derivatives_series(a, b, z, j_max, k_max, TOL);
}
if z == 1.0 {
return beta_derivatives(a, b, j_max, k_max);
}
inc_beta_derivatives_near_one(a, b, z, j_max, k_max, TOL)
}
fn binomial_series(alpha: f64, n_max: usize) -> Vec<f64> {
let mut out = Vec::with_capacity(n_max + 1);
let mut c = 1.0;
for n in 0..=n_max {
out.push(c);
c *= (n as f64 - alpha) / (n + 1) as f64;
}
out
}
fn log_powers(m_max: usize, n_max: usize) -> Vec<Vec<f64>> {
let mut base = vec![0.0; n_max + 1];
for (i, c) in base.iter_mut().enumerate().skip(1) {
*c = -1.0 / i as f64;
}
let mut out = vec![vec![0.0; n_max + 1]];
out[0][0] = 1.0;
for m in 1..=m_max {
let mut next = vec![0.0; n_max + 1];
for i in 0..=n_max {
let p = out[m - 1][i];
if p == 0.0 {
continue;
}
for l in 0..=(n_max - i) {
next[i + l] += p * base[l];
}
}
out.push(next);
}
out
}
fn series_length(ratio: f64) -> usize {
let n = (TOL.ln() / ratio.ln()).ceil() as usize;
(n + 32).min(MAX_SERIES_TERMS)
}
pub fn outer_beta_derivatives(a: f64, b: f64, u_max: f64, j_max: usize, k_max: usize) -> Table {
assert!(b > 0.0, "the outer beta needs b > 0 to converge at u = 0");
assert!(
u_max >= 0.0 && !u_max.is_nan(),
"the outer beta runs over a non-negative range"
);
let mut out = outer_beta_below_one(a, b, u_max.min(1.0), j_max, k_max);
if u_max > 1.0 {
let far = outer_beta_above_one(a, b, u_max, j_max, k_max);
for j in 0..=j_max {
for k in 0..=k_max {
out[j][k] += far[j][k];
}
}
}
out
}
pub fn outer_beta_complete(a: f64, b: f64, j_max: usize, k_max: usize) -> Table {
assert!(b > 0.0, "the outer beta needs b > 0 to converge at u = 0");
debug_assert!(
!near_a_whole_exponent(a + b - 1.0),
"the complete outer beta has a pole at a whole rho"
);
let mut out = outer_beta_below_one(a, b, 1.0, j_max, k_max);
let far = outer_beta_far_half(
a,
b,
j_max,
k_max,
f64::NEG_INFINITY,
-std::f64::consts::LN_2,
);
for (j, row) in out.iter_mut().enumerate() {
for (k, entry) in row.iter_mut().enumerate() {
*entry += far[j][k];
}
}
out
}
pub fn outer_beta_derivatives_split(
a: f64,
b: f64,
u_max: f64,
j_max: usize,
k_max: usize,
) -> Option<SplitTables> {
assert!(b > 0.0, "the outer beta needs b > 0 to converge at u = 0");
assert!(
u_max >= 0.0,
"the outer beta runs over a non-negative range"
);
let rho = a + b - 1.0;
if !u_max.is_finite() || near_a_whole_exponent(rho) {
return None;
}
let complete = outer_beta_complete(a, b, j_max, k_max);
let tail = outer_beta_tail(a, b, u_max, &complete, j_max, k_max);
Some((complete, tail))
}
pub fn outer_beta_tail(
a: f64,
b: f64,
u_min: f64,
complete: &Table,
j_max: usize,
k_max: usize,
) -> Table {
if u_min >= 1.0 {
let l1 = (1.0 / (1.0 + u_min)).ln();
return outer_beta_far_half(a, b, j_max, k_max, f64::NEG_INFINITY, l1);
}
let whole = outer_beta_derivatives(a, b, u_min, j_max, k_max);
subtract_tables(complete, &whole)
}
fn outer_beta_below_one(a: f64, b: f64, u_max: f64, j_max: usize, k_max: usize) -> Table {
let mut out = vec![vec![0.0; k_max + 1]; j_max + 1];
if u_max <= 0.0 {
return out;
}
let w = u_max / (1.0 + u_max);
let n_max = series_length(w);
let degree = j_max + k_max;
let base = binomial_series(-(a + b), n_max);
let logs = log_powers(degree, n_max);
let mut lambda = vec![vec![0.0; n_max + 1]; degree + 1];
for m in 0..=degree {
let sign = alternating_sign(m);
for i in 0..=n_max {
let p = base[i];
if p == 0.0 {
continue;
}
for l in 0..=(n_max - i) {
lambda[m][i + l] += sign * p * logs[m][l];
}
}
}
let mut moment = vec![vec![0.0; k_max + 1]; n_max + 1];
for (n, row) in moment.iter_mut().enumerate() {
for (m, entry) in row.iter_mut().enumerate() {
*entry = power_log_integral(b + n as f64 - 1.0, m as u8, w);
}
}
let c_rows: Vec<Vec<f64>> = (0..=k_max).map(binomials).collect();
for j in 0..=j_max {
for k in 0..=k_max {
let mut total = 0.0;
for p in 0..=k {
let weight = c_rows[k][p];
for n in 0..=n_max {
total += weight * lambda[j + p][n] * moment[n][k - p];
}
}
out[j][k] = total;
}
}
out
}
fn outer_beta_above_one(a: f64, b: f64, u_max: f64, j_max: usize, k_max: usize) -> Table {
let l1 = (1.0 / (1.0 + u_max)).ln();
outer_beta_far_half(a, b, j_max, k_max, l1, -std::f64::consts::LN_2)
}
fn outer_beta_far_half(a: f64, b: f64, j_max: usize, k_max: usize, l1: f64, l2: f64) -> Table {
let rho = a + b - 1.0;
let n_max = series_length(0.5);
let degree = j_max + k_max;
let base = binomial_series(b - 1.0, n_max);
let logs = log_powers(k_max, n_max);
let mut xi = vec![vec![0.0; k_max + 1]; n_max + 1];
for q in 0..=k_max {
for (i, &p) in base.iter().enumerate() {
if p == 0.0 {
continue;
}
for l in 0..=(n_max - i) {
xi[i + l][q] += p * logs[q][l];
}
}
}
let c_rows: Vec<Vec<f64>> = (0..=k_max).map(binomials).collect();
let mut out = vec![vec![0.0; k_max + 1]; j_max + 1];
for (i, xi_row) in xi.iter().enumerate() {
let e = exp_moments(i as f64 - rho, degree, l1, l2);
for (j, row) in out.iter_mut().enumerate() {
for (k, entry) in row.iter_mut().enumerate() {
let mut total = 0.0;
for q in 0..=k {
let m = j + k - q;
total += c_rows[k][q] * alternating_sign(m) * xi_row[q] * e[m];
}
*entry += total;
}
}
}
out
}
pub fn outer_beta_entire_factor(b: f64, n: usize, j_max: usize, l_max: usize) -> Table {
let factorial = |l: usize| Gamma::gamma(l as f64 + 1.0);
let n_max = series_length(0.5).max(n);
let mut g = vec![vec![0.0; j_max + 1]; l_max + 1];
let mut poch = vec![0.0; j_max + 1];
poch[0] = 1.0;
for i in 0..=n_max {
if i == n {
for (j, &p) in poch.iter().enumerate() {
g[0][j] += p;
}
} else {
let d = i as f64 - n as f64;
let mut c = 2.0f64.powi(n as i32 - i as i32) / d;
for g_row in g.iter_mut().skip(1) {
for (j, &p) in poch.iter().enumerate() {
g_row[j] += p * c;
}
c /= -d;
}
}
advance_pochhammer(&mut poch, b, i);
}
let mut out = vec![vec![0.0; l_max + 1]; j_max + 1];
for (j, row) in out.iter_mut().enumerate() {
for (l, entry) in row.iter_mut().enumerate() {
for (v, g_row) in g.iter().enumerate().take(l + 1) {
let ln2_power = (-std::f64::consts::LN_2).powi((l - v) as i32);
*entry += g_row[j] * ln2_power / factorial(l - v);
}
}
}
if l_max == 0 {
return out;
}
let near = outer_beta_below_one(n as f64 + 1.0 - b, b, 1.0, j_max + l_max - 1, j_max);
let c_rows: Vec<Vec<f64>> = (0..=j_max).map(binomials).collect();
for (j, row) in out.iter_mut().enumerate() {
for (l, entry) in row.iter_mut().enumerate().skip(1) {
let m = l - 1;
let mut total = 0.0;
for (i, &c) in c_rows[j].iter().enumerate() {
total += c * alternating_sign(m + i) * near[i + m][j - i];
}
*entry += total / factorial(m);
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::segment::Segment;
use crate::util::bilby_integrate;
use approx::assert_relative_eq;
fn by_quadrature(a: f64, b: f64, z: f64, j: usize, k: usize) -> f64 {
let f = |t: f64| {
if t <= 0.0 || t >= 1.0 {
return 0.0;
}
t.powf(a - 1.0)
* (1.0 - t).powf(b - 1.0)
* t.ln().powi(j as i32)
* (1.0 - t).ln().powi(k as i32)
};
bilby_integrate(f, Segment::new(0.0, z), 1e-13)
.unwrap()
.value
}
fn outer_by_quadrature(a: f64, b: f64, u_max: f64, j: usize, k: usize) -> f64 {
let f = |u: f64| {
if u <= 0.0 {
return 0.0;
}
(1.0 + u).powf(a - 1.0)
* u.powf(b - 1.0)
* (1.0 + u).ln().powi(j as i32)
* u.ln().powi(k as i32)
};
bilby_integrate(f, Segment::new(0.0, u_max), 1e-13)
.unwrap()
.value
}
#[test]
fn the_outer_beta_against_quadrature() {
for &(a, b) in &[(0.5f64, 0.5f64), (1.5, 0.5), (0.25, 1.25), (2.0, 1.0)] {
for &u_max in &[0.01f64, 0.5, 1.0, 3.0, 40.0] {
let table = outer_beta_derivatives(a, b, u_max, 2, 2);
for (j, row) in table.iter().enumerate() {
for (k, &got) in row.iter().enumerate() {
let want = outer_by_quadrature(a, b, u_max, j, k);
assert_relative_eq!(got, want, max_relative = 1e-9, epsilon = 1e-13);
}
}
}
}
}
#[test]
fn the_complete_outer_beta_is_the_beta_reparameterised() {
let (j_max, k_max) = (2usize, 2usize);
for &(a, b) in &[
(0.5f64, 0.25f64),
(0.1, 0.3),
(1.5, 0.7),
(1.25, 0.9),
(2.4, 1.3),
] {
let want = beta_derivatives(b, 1.0 - a - b, k_max, j_max + k_max);
let mine = outer_beta_complete(a, b, j_max, k_max);
for j in 0..=j_max {
for k in 0..=k_max {
let c_row = binomials(k);
let mut rotated = 0.0;
for i in 0..=k {
rotated += c_row[i] * alternating_sign(j + i) * want[k - i][j + i];
}
assert_relative_eq!(mine[j][k], rotated, max_relative = 1e-9, epsilon = 1e-12);
}
}
}
}
#[test]
fn the_outer_split_adds_back_up() {
let (j_max, k_max) = (2usize, 2usize);
for &(a, b) in &[(0.5f64, 0.25f64), (0.1, 0.3), (1.5, 0.7), (2.4, 1.3)] {
for &u_max in &[0.02f64, 0.6, 1.0, 7.0, 1e3, 1e8] {
let (complete, tail) =
outer_beta_derivatives_split(a, b, u_max, j_max, k_max).unwrap();
let whole = outer_beta_derivatives(a, b, u_max, j_max, k_max);
for j in 0..=j_max {
for k in 0..=k_max {
let got = complete[j][k] - tail[j][k];
let scale = complete[j][k].abs().max(whole[j][k].abs());
assert_relative_eq!(
got,
whole[j][k],
max_relative = 1e-9,
epsilon = 1e-12 * scale
);
}
}
}
}
assert!(outer_beta_derivatives_split(0.5, 0.5, 4.0, 1, 1).is_none());
assert!(outer_beta_derivatives_split(0.5, 0.5, 0.2, 1, 1).is_none());
assert!(outer_beta_derivatives_split(1.5, 0.5, f64::INFINITY, 1, 1).is_none());
}
#[test]
fn the_outer_beta_is_the_incomplete_one_reparameterised() {
let (j_max, k_max) = (2usize, 2usize);
for &(a, b) in &[(0.5f64, 0.5f64), (1.5, 0.5), (0.25, 1.25), (1.1, 0.9)] {
for &u_max in &[0.3f64, 1.0, 7.0, 1e3, 1e8] {
let w = u_max / (1.0 + u_max);
let inc = inc_beta_derivatives(b, 1.0 - a - b, w, k_max, j_max + k_max);
let mine = outer_beta_derivatives(a, b, u_max, j_max, k_max);
for j in 0..=j_max {
for k in 0..=k_max {
let c_row = binomials(k);
let mut want = 0.0;
for i in 0..=k {
want += c_row[i] * alternating_sign(j + i) * inc[k - i][j + i];
}
assert_relative_eq!(mine[j][k], want, max_relative = 1e-8, epsilon = 1e-12);
}
}
}
}
}
#[test]
fn a_whole_rho_is_no_special_case_for_the_outer_beta() {
let b = 0.5f64;
for n in [0.0f64, 1.0, 2.0] {
for eps in [0.0f64, 1e-12, -1e-12, 1e-6, -1e-6] {
let a = n + eps + 1.0 - b;
let table = outer_beta_derivatives(a, b, 50.0, 1, 1);
for (j, row) in table.iter().enumerate() {
for (k, &got) in row.iter().enumerate() {
let want = outer_by_quadrature(a, b, 50.0, j, k);
assert_relative_eq!(got, want, max_relative = 1e-9, epsilon = 1e-12);
}
}
}
}
}
#[test]
fn the_entire_factor_rebuilds_the_beta() {
let j_max = 2;
for &(a, n) in &[(0.5f64, 0usize), (0.5, 1), (1.5, 2), (0.25, 3), (2.5, 1)] {
let f = outer_beta_entire_factor(a, n, j_max, 8);
for &delta in &[1e-2f64, -1e-2, 0.05, -0.05] {
let want = beta_derivatives(a, -(n as f64) + delta, j_max, 0);
for (j, row) in f.iter().enumerate() {
let mut series = 0.0;
for (l, &c) in row.iter().enumerate() {
series += c * delta.powi(l as i32);
}
assert_relative_eq!(series / delta, want[j][0], max_relative = 1e-9);
}
}
}
}
#[test]
fn the_residue_is_a_polynomial() {
for &(a, n) in &[(0.5f64, 0usize), (0.5, 1), (1.5, 2), (0.25, 3), (3.0, 1)] {
let sign = if n % 2 == 0 { 1.0 } else { -1.0 };
let want = (1..=n).fold(sign / Gamma::gamma(n as f64 + 1.0), |p, i| {
p * (a - i as f64)
});
assert_relative_eq!(
outer_beta_entire_factor(a, n, 0, 0)[0][0],
want,
epsilon = 1e-14
);
}
assert_eq!(outer_beta_entire_factor(1.0, 1, 0, 0)[0][0], 0.0);
assert_eq!(outer_beta_entire_factor(2.0, 2, 0, 0)[0][0], 0.0);
}
#[test]
fn against_quadrature() {
for &(a, b) in &[
(0.5f64, -0.2f64),
(0.5, -1.7),
(1.5, 0.3),
(0.25, 2.0),
(1.0, 1.0),
(2.5, -0.5),
(0.5, 0.0),
(1.5, 0.0),
(0.5, -1.0),
(0.25, -2.0),
] {
for &z in &[0.1f64, 0.4, 0.49, 0.51, 0.75, 0.95] {
let table = inc_beta_derivatives(a, b, z, 2, 2);
for (j, row) in table.iter().enumerate() {
for (k, &got) in row.iter().enumerate() {
let want = by_quadrature(a, b, z, j, k);
assert_relative_eq!(got, want, max_relative = 1e-11, epsilon = 1e-13);
}
}
}
}
}
#[test]
fn a_pole_is_no_special_case() {
let (a, z) = (0.5f64, 0.9f64);
for eps in [0.0f64, 1e-12, 1e-10, 1e-9, 5e-9, 1e-8, 1e-7, 1e-6, 1e-4] {
for side in [1.0f64, -1.0] {
for m in [0.0f64, 1.0, 2.0] {
let b = -m + side * eps;
let got = inc_beta_derivatives(a, b, z, 0, 0)[0][0];
let want = by_quadrature(a, b, z, 0, 0);
assert_relative_eq!(got, want, max_relative = 1e-11);
}
}
}
}
#[test]
fn the_two_branches_agree() {
for &(a, b) in &[(0.5f64, -0.2f64), (1.5, 0.3), (0.25, 2.0)] {
let below = inc_beta_derivatives(a, b, 0.5, 2, 2);
let above = inc_beta_derivatives(a, b, 0.5 + 1e-11, 2, 2);
for (lower, upper) in below.iter().flatten().zip(above.iter().flatten()) {
assert_relative_eq!(lower, upper, max_relative = 1e-9);
}
}
}
#[test]
fn a_whole_exponent_is_no_special_case() {
for &(a, b) in &[
(0.5f64, 0.0f64),
(0.5, -1.0),
(0.5, -2.0),
(0.5, -3.0),
(1.5, -1.0),
(0.25, -2.0),
] {
for &z in &[0.51f64, 0.75, 0.9, 1.0 - 1e-6] {
let table = inc_beta_derivatives(a, b, z, 2, 2);
for (j, row) in table.iter().enumerate() {
for (k, &got) in row.iter().enumerate() {
let want = by_quadrature(a, b, z, j, k);
assert_relative_eq!(got, want, max_relative = 1e-9, epsilon = 1e-13);
}
}
}
}
}
#[test]
fn a_whole_exponent_against_a_closed_form() {
for &z in &[
0.51f64,
0.9,
1.0 - 1e-3,
1.0 - 1e-6,
1.0 - 1e-9,
1.0 - 1e-12,
] {
let y = 1.0 - z;
let want = ((1.0 + z.sqrt()).powi(2) / y).ln();
let got = inc_beta_derivatives(0.5, 0.0, z, 0, 0)[0][0];
assert_relative_eq!(got, want, max_relative = 1e-14);
}
}
#[test]
fn the_ends_are_the_complete_beta() {
for &(a, b) in &[(0.5f64, 0.75f64), (1.5, 2.5), (2.0, 0.25)] {
let whole = inc_beta_derivatives(a, b, 1.0, 2, 2);
let complete = beta_derivatives(a, b, 2, 2);
for (got, want) in whole.iter().flatten().zip(complete.iter().flatten()) {
assert_relative_eq!(got, want, max_relative = 1e-12);
}
for row in inc_beta_derivatives(a, b, 0.0, 2, 2) {
assert!(row.iter().all(|v| *v == 0.0));
}
}
}
}