mod contraction;
mod level;
mod ufunc;
pub use contraction::{
CONTRACTION, Contraction, FUSES_PRODUCTS, FusedProduct, difference_of_products, fused,
fused_f32, fused_iso_c, sum_of_products,
};
pub use level::{CpuLevel, LEVEL_VARIABLE, NumpyDispatch, UnknownLevel};
pub use ufunc::{Evaluator, Ufunc, evaluate_with};
pub fn remainder(a: f64, b: f64) -> f64 {
let fmod = a % b;
if b == 0.0 {
fmod
} else if fmod == 0.0 {
0.0_f64.copysign(b)
} else if (b < 0.0) != (fmod < 0.0) {
fmod + b
} else {
fmod
}
}
pub fn divmod(x: f64, y: f64) -> (f64, f64) {
let mut rem = x % y;
let mut div = (x - rem) / y;
if rem == 0.0 {
rem = 0.0_f64.copysign(y);
} else if (y < 0.0) != (rem < 0.0) {
rem += y;
div -= 1.0;
}
let floor = if div == 0.0 {
0.0_f64.copysign(x / y)
} else {
let mut floor = div.floor();
if div - floor > 0.5 {
floor += 1.0;
}
floor
};
(floor, rem)
}
pub fn np_divmod(x: f64, y: f64) -> (f64, f64) {
if y == 0.0 {
return (x / y, x % y);
}
divmod(x, y)
}
pub fn floor_div(x: f64, y: f64) -> f64 {
divmod(x, y).0
}
pub fn py_max(a: f64, b: f64) -> f64 {
if b > a { b } else { a }
}
pub fn py_min(a: f64, b: f64) -> f64 {
if b < a { b } else { a }
}
pub fn np_minimum(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else {
a.min(b)
}
}
pub fn np_maximum(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else {
a.max(b)
}
}
pub fn np_clip(v: f64, lo: f64, hi: f64) -> f64 {
let raised = if v.is_nan() || v > lo { v } else { lo };
if raised.is_nan() || raised < hi {
raised
} else {
hi
}
}
pub fn np_sign(x: f64) -> f64 {
if x == 0.0 || x.is_nan() {
x
} else {
x.signum()
}
}
pub fn np_arcsinh(x: f64) -> f64 {
const LN2: f64 = std::f64::consts::LN_2;
let ax = x.abs();
if !ax.is_finite() {
return x + x;
}
let w = if ax < 2f64.powi(-28) {
return x;
} else if ax > 2f64.powi(28) {
let double = 2.0 * ax;
if double.is_finite() && !cfg!(target_os = "macos") {
double.ln()
} else {
ax.ln() + LN2
}
} else if ax > 2.0 {
(2.0 * ax + 1.0 / ((ax * ax + 1.0).sqrt() + ax)).ln()
} else {
let t = ax * ax;
(ax + t / (1.0 + (1.0 + t).sqrt())).ln_1p()
};
w.copysign(x)
}
#[inline]
pub fn pow(base: f64, exponent: f64) -> f64 {
std::hint::black_box(base).powf(exponent)
}
pub fn np_int(x: f64) -> i64 {
const LIMIT: f64 = 9_223_372_036_854_775_808.0;
if cfg!(target_arch = "x86_64") && (x.is_nan() || x.abs() >= LIMIT) {
i64::MIN
} else {
x as i64
}
}
pub const ACCELERATE_BLAS: bool = cfg!(all(target_os = "macos", target_arch = "aarch64"));
pub fn linspace(start: f64, stop: f64, num: usize) -> Vec<f64> {
linspace_with(start, stop, num, true)
}
pub fn linspace_with(start: f64, stop: f64, num: usize, endpoint: bool) -> Vec<f64> {
let div = if endpoint { num.saturating_sub(1) } else { num };
let delta = stop - start;
let mut values: Vec<f64> = if div == 0 {
(0..num).map(|i| i as f64 * delta + start).collect()
} else {
let step = delta / div as f64;
if step == 0.0 {
(0..num)
.map(|i| i as f64 / div as f64 * delta + start)
.collect()
} else {
(0..num).map(|i| i as f64 * step + start).collect()
}
};
if endpoint && num > 1 {
values[num - 1] = stop;
}
values
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[cfg(any(target_os = "linux", target_os = "macos"))]
fn constant_bases_still_go_through_pow() {
assert_eq!(
pow(10.0, -5.449_396_810_393_321).to_bits(),
0x3ecd_ce26_4eb4_2a8a
);
assert_eq!(
pow(2.0, 7.909_669_318_739_461).to_bits(),
0x406e_0ece_71fc_aa74
);
}
#[test]
fn divmod_matches_python() {
assert_eq!(divmod(7.0, 2.0), (3.0, 1.0));
assert_eq!(divmod(-7.0, 2.0), (-4.0, 1.0));
assert_eq!(divmod(7.0, -2.0), (-4.0, -1.0));
let (d, m) = divmod(-0.0, 1.0);
assert!(d == 0.0 && d.is_sign_negative());
assert!(m == 0.0 && m.is_sign_positive());
assert_eq!(divmod(1.0, 0.1), (9.0, 0.099_999_999_999_999_95));
assert_eq!(floor_div(0.7, 0.1), 6.0);
let (d, m) = divmod(1.0, 0.0);
assert!(d.is_nan() && m.is_nan());
}
#[test]
fn divmod_matches_numpy() {
assert_eq!(np_divmod(65.0, 50.0), (1.0, 15.0));
assert_eq!(np_divmod(-7.0, 2.0), (-4.0, 1.0));
assert_eq!(np_divmod(0.0, 10.0), (0.0, 0.0));
assert!(np_divmod(1.0, 0.0).0.is_infinite());
assert!(np_divmod(-0.0, 10.0).0.is_sign_negative());
}
#[test]
fn remainder_matches_numpy() {
assert_eq!(remainder(7.5, 2.0), 1.5);
assert_eq!(remainder(-7.5, 2.0), 0.5);
assert_eq!(remainder(7.5, -2.0), -0.5);
assert_eq!(remainder(-0.5, 1.0), 0.5);
assert!(remainder(-4.0, 2.0).is_sign_positive());
assert!(remainder(4.0, -2.0).is_sign_negative());
assert!(remainder(1.0, 0.0).is_nan());
assert!(remainder(f64::NAN, 2.0).is_nan());
assert_eq!(remainder(1.0, f64::INFINITY), 1.0);
}
#[test]
fn min_max_and_sign() {
assert!(py_max(f64::NAN, 1.0).is_nan());
assert_eq!(py_max(1.0, f64::NAN), 1.0);
assert!(py_min(f64::NAN, 1.0).is_nan());
assert_eq!(py_min(1.0, f64::NAN), 1.0);
assert!(np_minimum(1.0, f64::NAN).is_nan());
assert!(np_maximum(f64::NAN, 1.0).is_nan());
assert_eq!(np_minimum(1.0, 3.0), 1.0);
assert_eq!(np_maximum(1.0, 3.0), 3.0);
assert_eq!(np_clip(2.0, 0.0, 1.0), 1.0);
assert_eq!(np_clip(-1.0, 0.0, 1.0), 0.0);
assert_eq!(np_clip(0.25, 0.0, 1.0), 0.25);
assert!(np_clip(f64::NAN, 0.0, 1.0).is_nan());
assert!(np_clip(0.5, f64::NAN, 1.0).is_nan());
assert!(np_clip(0.5, 0.0, f64::NAN).is_nan());
assert_eq!(np_sign(-3.0), -1.0);
assert_eq!(np_sign(2.0), 1.0);
assert!(np_sign(-0.0) == 0.0 && np_sign(-0.0).is_sign_negative());
assert!(np_sign(f64::NAN).is_nan());
}
#[test]
fn arcsinh_matches_numpy() {
assert_eq!(np_arcsinh(1e12 + 3.0), 28.324_168_296_491_493);
assert_eq!(np_arcsinh(0.5), 0.481_211_825_059_603_47);
assert_eq!(np_arcsinh(-3.0), -1.818_446_459_232_066_8);
assert_eq!(np_arcsinh(1e-30), 1e-30);
let huge = if cfg!(target_os = "macos") {
691.468_675_078_773_6
} else {
691.468_675_078_773_7
};
assert_eq!(np_arcsinh(1e300), huge);
assert!(np_arcsinh(f64::NAN).is_nan());
assert_eq!(np_arcsinh(f64::NEG_INFINITY), f64::NEG_INFINITY);
}
#[test]
fn linspace_matches_numpy() {
assert_eq!(linspace(0.0, 1.0, 1), vec![0.0]);
assert_eq!(linspace(0.0, 1.0, 0), Vec::<f64>::new());
assert_eq!(linspace(2.0, 2.0, 3), vec![2.0, 2.0, 2.0]);
assert_eq!(
linspace_with(0.0, 1.0, 4, false),
vec![0.0, 0.25, 0.5, 0.75]
);
let v = linspace(0.0, 1.0, 7);
assert_eq!(v[3], 0.5);
assert_eq!(v[6], 1.0);
assert_eq!(v[1], 1.0 / 6.0);
}
}