use libnoise::prelude::*;
use proptest::prelude::*;
macro_rules! strategy_float_numeric {
() => {
prop::num::f64::NORMAL
| prop::num::f64::NEGATIVE
| prop::num::f64::POSITIVE
| prop::num::f64::ZERO
};
}
macro_rules! strategy_array_float_numeric {
() => {
prop::array::uniform(strategy_float_numeric!())
};
}
proptest! {
#[test]
fn test_abs_1d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).abs().sample(point);
let expected = value.abs();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_abs_2d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).abs().sample(point);
let expected = value.abs();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_abs_3d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).abs().sample(point);
let expected = value.abs();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_abs_4d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).abs().sample(point);
let expected = value.abs();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_add_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).add(value_b).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_add_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).add(value_b).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_add_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).add(value_b).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_add_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).add(value_b).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_billow_1d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).billow(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * (value.abs() * 2.0 - 1.0);
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_billow_2d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).billow(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * (value.abs() * 2.0 - 1.0);
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_billow_3d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).billow(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * (value.abs() * 2.0 - 1.0);
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_billow_4d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).billow(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * (value.abs() * 2.0 - 1.0);
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_blend_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in -1_f64..1.0, point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).blend(Source::<1>::constant(value_b), Source::<1>::constant(value_control)).sample(point);
let expected = value_a + (value_control * 0.5 + 0.5) * (value_b - value_a);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_blend_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in -1_f64..1.0, point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).blend(Source::<2>::constant(value_b), Source::<2>::constant(value_control)).sample(point);
let expected = value_a + (value_control * 0.5 + 0.5) * (value_b - value_a);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_blend_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in -1_f64..1.0, point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).blend(Source::<3>::constant(value_b), Source::<3>::constant(value_control)).sample(point);
let expected = value_a + (value_control * 0.5 + 0.5) * (value_b - value_a);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_blend_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in -1_f64..1.0, point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).blend(Source::<4>::constant(value_b), Source::<4>::constant(value_control)).sample(point);
let expected = value_a + (value_control * 0.5 + 0.5) * (value_b - value_a);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_clamp_1d(value in strategy_float_numeric!(), min in strategy_float_numeric!(), max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
if min > max {
return Ok(());
}
let n = Source::<1>::constant(value).clamp(min, max).sample(point);
let expected = value.clamp(min, max);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_clamp_2d(value in strategy_float_numeric!(), min in strategy_float_numeric!(), max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
if min > max {
return Ok(());
}
let n = Source::<2>::constant(value).clamp(min, max).sample(point);
let expected = value.clamp(min, max);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_clamp_3d(value in strategy_float_numeric!(), min in strategy_float_numeric!(), max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
if min > max {
return Ok(());
}
let n = Source::<3>::constant(value).clamp(min, max).sample(point);
let expected = value.clamp(min, max);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_clamp_4d(value in strategy_float_numeric!(), min in strategy_float_numeric!(), max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
if min > max {
return Ok(());
}
let n = Source::<4>::constant(value).clamp(min, max).sample(point);
let expected = value.clamp(min, max);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_x_1d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).displace_x(Source::<1>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_x_2d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).displace_x(Source::<2>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_y_2d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).displace_y(Source::<2>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_x_3d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).displace_x(Source::<3>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_y_3d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).displace_y(Source::<3>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_z_3d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).displace_z(Source::<3>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_x_4d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).displace_x(Source::<4>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_y_4d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).displace_y(Source::<4>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_z_4d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).displace_z(Source::<4>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_displace_w_4d(value in strategy_float_numeric!(), displacement in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).displace_w(Source::<4>::constant(displacement)).sample(point);
let expected = value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_exp_1d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).exp().sample(point);
let expected = value.exp();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_exp_2d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).exp().sample(point);
let expected = value.exp();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_exp_3d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).exp().sample(point);
let expected = value.exp();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_exp_4d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).exp().sample(point);
let expected = value.exp();
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_fbm_1d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).fbm(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * value;
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_fbm_2d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).fbm(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * value;
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_fbm_3d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).fbm(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * value;
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_fbm_4d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), persistence in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).fbm(octaves, frequency, lacunarity, persistence).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
expected += amp * value;
amp *= persistence;
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| acc + persistence.powi(octave as i32));
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_lambda_1d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let closure = |x| x * x - 1.0;
let n = Source::<1>::constant(value).lambda(closure).sample(point);
let expected = closure(value);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_lambda_2d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let closure = |x| x * x - 1.0;
let n = Source::<2>::constant(value).lambda(closure).sample(point);
let expected = closure(value);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_lambda_3d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let closure = |x| x * x - 1.0;
let n = Source::<3>::constant(value).lambda(closure).sample(point);
let expected = closure(value);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_lambda_4d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let closure = |x| x * x - 1.0;
let n = Source::<4>::constant(value).lambda(closure).sample(point);
let expected = closure(value);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_max_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).max(Source::<1>::constant(value_b)).sample(point);
let expected = value_a.max(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_max_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).max(Source::<2>::constant(value_b)).sample(point);
let expected = value_a.max(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_max_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).max(Source::<3>::constant(value_b)).sample(point);
let expected = value_a.max(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_max_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).max(Source::<4>::constant(value_b)).sample(point);
let expected = value_a.max(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_min_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).min(Source::<1>::constant(value_b)).sample(point);
let expected = value_a.min(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_min_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).min(Source::<2>::constant(value_b)).sample(point);
let expected = value_a.min(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_min_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).min(Source::<3>::constant(value_b)).sample(point);
let expected = value_a.min(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_min_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).min(Source::<4>::constant(value_b)).sample(point);
let expected = value_a.min(value_b);
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_mul_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).mul(value_b).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_mul_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).mul(value_b).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_mul_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).mul(value_b).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_mul_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).mul(value_b).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_neg_1d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).neg().sample(point);
let expected = -value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_neg_2d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).neg().sample(point);
let expected = -value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_neg_3d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).neg().sample(point);
let expected = -value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_neg_4d(value in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).neg().sample(point);
let expected = -value;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powi_1d(value in strategy_float_numeric!(), exponent in -1000_i32..1000, point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).powi(exponent).sample(point);
let expected = value.powi(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powi_2d(value in strategy_float_numeric!(), exponent in -1000_i32..1000, point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).powi(exponent).sample(point);
let expected = value.powi(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powi_3d(value in strategy_float_numeric!(), exponent in -1000_i32..1000, point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).powi(exponent).sample(point);
let expected = value.powi(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powi_4d(value in strategy_float_numeric!(), exponent in -1000_i32..1000, point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).powi(exponent).sample(point);
let expected = value.powi(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powf_1d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).powf(exponent).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powf_2d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).powf(exponent).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powf_3d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).powf(exponent).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_powf_4d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).powf(exponent).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_power_1d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).power(Source::<1>::constant(exponent)).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_power_2d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).power(Source::<2>::constant(exponent)).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_power_3d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).power(Source::<3>::constant(exponent)).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_power_4d(value in strategy_float_numeric!(), exponent in -1000_f64..1000.0, point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).power(Source::<4>::constant(exponent)).sample(point);
let expected = value.powf(exponent);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_product_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).product(Source::<1>::constant(value_b)).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_product_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).product(Source::<2>::constant(value_b)).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_product_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).product(Source::<3>::constant(value_b)).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_product_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).product(Source::<4>::constant(value_b)).sample(point);
let expected = value_a * value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_ridgedmulti_1d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), attenuation in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value).ridgedmulti(octaves, frequency, lacunarity, attenuation).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
let mut layer = 1.0 - value.abs();
layer *= layer;
layer *= amp;
expected += layer;
amp = (layer / attenuation).clamp(0.0, 1.0);
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| {
acc + (1.0 / attenuation).powi(octave as i32)
});
expected = expected * 2.0 - 1.0;
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_ridgedmulti_2d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), attenuation in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value).ridgedmulti(octaves, frequency, lacunarity, attenuation).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
let mut layer = 1.0 - value.abs();
layer *= layer;
layer *= amp;
expected += layer;
amp = (layer / attenuation).clamp(0.0, 1.0);
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| {
acc + (1.0 / attenuation).powi(octave as i32)
});
expected = expected * 2.0 - 1.0;
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_ridgedmulti_3d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), attenuation in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value).ridgedmulti(octaves, frequency, lacunarity, attenuation).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
let mut layer = 1.0 - value.abs();
layer *= layer;
layer *= amp;
expected += layer;
amp = (layer / attenuation).clamp(0.0, 1.0);
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| {
acc + (1.0 / attenuation).powi(octave as i32)
});
expected = expected * 2.0 - 1.0;
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_ridgedmulti_4d(value in strategy_float_numeric!(), octaves in 0_u32..10, frequency in strategy_float_numeric!(), lacunarity in strategy_float_numeric!(), attenuation in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value).ridgedmulti(octaves, frequency, lacunarity, attenuation).sample(point);
let mut expected = 0.0;
let mut amp = 1.0;
for _ in 0..octaves {
let mut layer = 1.0 - value.abs();
layer *= layer;
layer *= amp;
expected += layer;
amp = (layer / attenuation).clamp(0.0, 1.0);
}
expected *= 1.0 / (0..octaves).fold(0.0, |acc, octave| {
acc + (1.0 / attenuation).powi(octave as i32)
});
expected = expected * 2.0 - 1.0;
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_rotate_2d(seed in prop::num::u64::ANY, rotation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
Source::<2>::simplex(seed).rotate(rotation).sample(point);
}
#[test]
fn test_rotate_3d(seed in prop::num::u64::ANY, rotation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
Source::<3>::simplex(seed).rotate(rotation).sample(point);
}
#[test]
fn test_rotate_4d(seed in prop::num::u64::ANY, rotation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
Source::<4>::simplex(seed).rotate(rotation).sample(point);
}
#[test]
fn test_scale_1d(seed in prop::num::u64::ANY, scale in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::simplex(seed).scale(scale).sample(point);
let expected = Source::<1>::simplex(seed).sample([point[0] * scale[0]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_scale_2d(seed in prop::num::u64::ANY, scale in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::simplex(seed).scale(scale).sample(point);
let expected = Source::<2>::simplex(seed).sample([point[0] * scale[0], point[1] * scale[1]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_scale_3d(seed in prop::num::u64::ANY, scale in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::simplex(seed).scale(scale).sample(point);
let expected = Source::<3>::simplex(seed).sample([point[0] * scale[0], point[1] * scale[1], point[2] * scale[2]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_scale_4d(seed in prop::num::u64::ANY, scale in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::simplex(seed).scale(scale).sample(point);
let expected = Source::<4>::simplex(seed).sample([point[0] * scale[0], point[1] * scale[1], point[2] * scale[2], point[3] * scale[3]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_select_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in strategy_float_numeric!(), selection_min in strategy_float_numeric!(), selection_max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).select(Source::<1>::constant(value_b), Source::<1>::constant(value_control), selection_min, selection_max).sample(point);
let expected = match value_control {
t if t >= selection_min && t <= selection_max => {
value_a
}
_ => value_b
};
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_select_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in strategy_float_numeric!(), selection_min in strategy_float_numeric!(), selection_max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).select(Source::<2>::constant(value_b), Source::<2>::constant(value_control), selection_min, selection_max).sample(point);
let expected = match value_control {
t if t >= selection_min && t <= selection_max => {
value_a
}
_ => value_b
};
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_select_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in strategy_float_numeric!(), selection_min in strategy_float_numeric!(), selection_max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).select(Source::<3>::constant(value_b), Source::<3>::constant(value_control), selection_min, selection_max).sample(point);
let expected = match value_control {
t if t >= selection_min && t <= selection_max => {
value_a
}
_ => value_b
};
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_select_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), value_control in strategy_float_numeric!(), selection_min in strategy_float_numeric!(), selection_max in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).select(Source::<4>::constant(value_b), Source::<4>::constant(value_control), selection_min, selection_max).sample(point);
let expected = match value_control {
t if t >= selection_min && t <= selection_max => {
value_a
}
_ => value_b
};
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_spline_1d(value in (-10.0..15.0).prop_map(|x| x), point in strategy_array_float_numeric!()) {
let knot_vector = [-1.0, 1.5, 3.0, 7.5, 9.2];
let knots = [5.0, 0.0, -6.5, 2.0, -11.0];
let n = Source::<1>::constant(value).spline::<NaturalCubicSpline>(&knot_vector, &knots).sample(point);
match value {
x if x < *knot_vector.first().unwrap() || x > *knot_vector.last().unwrap() => prop_assert!(n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
_ => prop_assert!(!n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
};
}
#[test]
fn test_spline_2d(value in (-10.0..15.0).prop_map(|x| x), point in strategy_array_float_numeric!()) {
let knot_vector = [-1.0, 1.5, 3.0, 7.5, 9.2];
let knots = [5.0, 0.0, -6.5, 2.0, -11.0];
let n = Source::<2>::constant(value).spline::<NaturalCubicSpline>(&knot_vector, &knots).sample(point);
match value {
x if x < *knot_vector.first().unwrap() || x > *knot_vector.last().unwrap() => prop_assert!(n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
_ => prop_assert!(!n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
};
}
#[test]
fn test_spline_3d(value in (-10.0..15.0).prop_map(|x| x), point in strategy_array_float_numeric!()) {
let knot_vector = [-1.0, 1.5, 3.0, 7.5, 9.2];
let knots = [5.0, 0.0, -6.5, 2.0, -11.0];
let n = Source::<3>::constant(value).spline::<NaturalCubicSpline>(&knot_vector, &knots).sample(point);
match value {
x if x < *knot_vector.first().unwrap() || x > *knot_vector.last().unwrap() => prop_assert!(n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
_ => prop_assert!(!n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
};
}
#[test]
fn test_spline_4d(value in (-10.0..15.0).prop_map(|x| x), point in strategy_array_float_numeric!()) {
let knot_vector = [-1.0, 1.5, 3.0, 7.5, 9.2];
let knots = [5.0, 0.0, -6.5, 2.0, -11.0];
let n = Source::<4>::constant(value).spline::<NaturalCubicSpline>(&knot_vector, &knots).sample(point);
match value {
x if x < *knot_vector.first().unwrap() || x > *knot_vector.last().unwrap() => prop_assert!(n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
_ => prop_assert!(!n.is_nan(), "expected value {}, instead: {}", f64::NAN, n),
};
}
#[test]
fn test_sum_1d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::constant(value_a).sum(Source::<1>::constant(value_b)).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_sum_2d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::constant(value_a).sum(Source::<2>::constant(value_b)).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_sum_3d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::constant(value_a).sum(Source::<3>::constant(value_b)).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_sum_4d(value_a in strategy_float_numeric!(), value_b in strategy_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::constant(value_a).sum(Source::<4>::constant(value_b)).sample(point);
let expected = value_a + value_b;
prop_assert_eq!(n, expected, "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_translate_1d(seed in prop::num::u64::ANY, translation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<1>::simplex(seed).translate(translation).sample(point);
let expected = Source::<1>::simplex(seed).sample([point[0] + translation[0]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_translate_2d(seed in prop::num::u64::ANY, translation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<2>::simplex(seed).translate(translation).sample(point);
let expected = Source::<2>::simplex(seed).sample([point[0] + translation[0], point[1] + translation[1]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_translate_3d(seed in prop::num::u64::ANY, translation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<3>::simplex(seed).translate(translation).sample(point);
let expected = Source::<3>::simplex(seed).sample([point[0] + translation[0], point[1] + translation[1], point[2] + translation[2]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
#[test]
fn test_translate_4d(seed in prop::num::u64::ANY, translation in strategy_array_float_numeric!(), point in strategy_array_float_numeric!()) {
let n = Source::<4>::simplex(seed).translate(translation).sample(point);
let expected = Source::<4>::simplex(seed).sample([point[0] + translation[0], point[1] + translation[1], point[2] + translation[2], point[3] + translation[3]]);
prop_assert!(n == expected || (n.is_nan() && expected.is_nan()), "expected value {}, instead: {}", expected, n);
}
}