use crate::application::index::{validate_mutable_output, RowMajorTraversal};
use crate::domain::real::RealScalar;
use crate::domain::rng::Xorshift64;
use leto::{Array, ArrayViewMut, LetoError, Result, VecStorage};
use std::sync::LazyLock;
fn uniform_draw<T: RealScalar>(rng: &mut Xorshift64, low: T, span: T, high: T) -> T {
loop {
let sample = low.add(T::from_f64(rng.next_unit_f64()).mul(span));
if sample < high {
return sample;
}
}
}
fn validate_uniform_interval<T: RealScalar>(low: T, high: T) -> Result<T> {
let span = high.sub(low);
if low < high && span.is_finite() {
Ok(span)
} else {
Err(LetoError::InvalidInput(format!(
"uniform interval [{low:?}, {high:?}) must satisfy low < high with a finite span"
)))
}
}
fn validate_normal_parameters<T: RealScalar>(mean: T, std_dev: T) -> Result<()> {
if mean.is_finite() && std_dev.is_finite() && std_dev > T::ZERO {
Ok(())
} else {
Err(LetoError::InvalidInput(format!(
"normal distribution needs a finite mean and a finite positive std_dev, got mean {mean:?}, std_dev {std_dev:?}"
)))
}
}
pub fn uniform_with_seed_into<T: RealScalar, const N: usize>(
out: &mut ArrayViewMut<'_, T, N>,
low: T,
high: T,
seed: u64,
) -> Result<()> {
let span = validate_uniform_interval(low, high)?;
let mut rng = Xorshift64::new(seed);
if let Some(out_slice) = out.as_mut_slice() {
for val in out_slice.iter_mut() {
*val = uniform_draw(&mut rng, low, span, high);
}
return Ok(());
}
validate_mutable_output(out, "random")?;
let size = out.layout().checked_size()?;
let shape = out.shape();
let out_layout = out.layout();
let out_data = out.data_mut();
let Some(traversal) = RowMajorTraversal::new(size, shape) else {
return Ok(());
};
let out_step = traversal.last_axis_stride(out_layout);
for row in 0..traversal.rows() {
let base_idx = traversal.base_index(row);
let mut out_offset = out_layout.offset_of(base_idx)? as isize;
for _ in 0..traversal.inner() {
out_data[out_offset as usize] = uniform_draw(&mut rng, low, span, high);
out_offset += out_step;
}
}
Ok(())
}
pub fn uniform_with_seed<T: RealScalar, const N: usize>(
shape: [usize; N],
low: T,
high: T,
seed: u64,
) -> Result<Array<T, VecStorage<T>, N>> {
let mut out = Array::from_elem(shape, T::ZERO);
uniform_with_seed_into(&mut out.view_mut(), low, high, seed)?;
Ok(out)
}
struct ZigguratNormal {
kn: [u64; 128],
wn: [f64; 128],
fx: [f64; 128],
}
const ZIG_R: f64 = 3.442_619_855_899;
const ZIG_V: f64 = 9.912_563_035_262_17e-3;
static ZIGGURAT_NORMAL: LazyLock<ZigguratNormal> = LazyLock::new(ZigguratNormal::build);
impl ZigguratNormal {
fn build() -> Self {
const M1: f64 = 2_147_483_648.0;
let mut kn = [0u64; 128];
let mut wn = [0.0f64; 128];
let mut fx = [0.0f64; 128];
let mut dn = ZIG_R;
let mut tn = ZIG_R;
let q = ZIG_V / (-0.5 * dn * dn).exp();
kn[0] = ((dn / q) * M1) as u64;
kn[1] = 0;
wn[0] = q / M1;
wn[127] = dn / M1;
fx[0] = 1.0;
fx[127] = (-0.5 * dn * dn).exp();
for i in (1..=126).rev() {
dn = (-2.0 * (ZIG_V / dn + (-0.5 * dn * dn).exp()).ln()).sqrt();
kn[i + 1] = ((dn / tn) * M1) as u64;
tn = dn;
fx[i] = (-0.5 * dn * dn).exp();
wn[i] = dn / M1;
}
Self { kn, wn, fx }
}
#[inline]
fn sample(&self, rng: &mut Xorshift64) -> f64 {
loop {
let hz = rng.next_u64() as u32 as i32;
let iz = (hz & 127) as usize;
if (hz as i64).unsigned_abs() < self.kn[iz] {
return hz as f64 * self.wn[iz];
}
if iz == 0 {
let tail = loop {
let x = -rng.next_unit_f64().ln() / ZIG_R;
let y = -rng.next_unit_f64().ln();
if x * x <= y + y {
break x;
}
};
return if hz <= 0 { -ZIG_R - tail } else { ZIG_R + tail };
}
let x = hz as f64 * self.wn[iz];
if self.fx[iz] + rng.next_unit_f64() * (self.fx[iz - 1] - self.fx[iz])
< (-0.5 * x * x).exp()
{
return x;
}
}
}
}
pub fn normal_with_seed_into<T: RealScalar, const N: usize>(
out: &mut ArrayViewMut<'_, T, N>,
mean: T,
std_dev: T,
seed: u64,
) -> Result<()> {
validate_normal_parameters(mean, std_dev)?;
let mut rng = Xorshift64::new(seed);
if let Some(out_slice) = out.as_mut_slice() {
for val in out_slice.iter_mut() {
*val = mean.add(std_dev.mul(T::from_f64(ZIGGURAT_NORMAL.sample(&mut rng))));
}
return Ok(());
}
validate_mutable_output(out, "random")?;
let size = out.layout().checked_size()?;
let shape = out.shape();
let out_layout = out.layout();
let out_data = out.data_mut();
let Some(traversal) = RowMajorTraversal::new(size, shape) else {
return Ok(());
};
let out_step = traversal.last_axis_stride(out_layout);
for row in 0..traversal.rows() {
let base_idx = traversal.base_index(row);
let mut out_offset = out_layout.offset_of(base_idx)? as isize;
for _ in 0..traversal.inner() {
out_data[out_offset as usize] =
mean.add(std_dev.mul(T::from_f64(ZIGGURAT_NORMAL.sample(&mut rng))));
out_offset += out_step;
}
}
Ok(())
}
pub fn normal_with_seed<T: RealScalar, const N: usize>(
shape: [usize; N],
mean: T,
std_dev: T,
seed: u64,
) -> Result<Array<T, VecStorage<T>, N>> {
let mut out = Array::from_elem(shape, T::ZERO);
normal_with_seed_into(&mut out.view_mut(), mean, std_dev, seed)?;
Ok(out)
}