langis 0.1.0

A signal is a structure that can yield an infinite amount of data. The API is very similar to `std::iter::Iterator` but with the assumption that it will never end.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Signals that deal with randomness.

#[cfg(any(feature = "rand", feature = "num-std", feature = "num-libm"))]
use super::Signal;

#[cfg(feature = "rand")]
use rand::{distributions::Distribution, Rng};

#[cfg(any(feature = "num-std", feature = "num-libm"))]
use crate::num::Phase;

/// A signal that yield random values.
#[cfg(feature = "rand")]
#[derive(Clone)]
pub struct Random<R, D, T> {
    pub(super) rng: R,
    pub(super) dist: D,
    pub(super) _marker: core::marker::PhantomData<T>,
}

#[cfg(feature = "rand")]
impl<R, D, T> Signal for Random<R, D, T>
where
    R: Rng,
    D: Distribution<T>,
{
    type Type = T;

    #[inline]
    fn next(&mut self) -> Self::Type {
        self.dist.sample(&mut self.rng)
    }
}

/// Generates 1D simplex noise.
#[cfg(any(feature = "num-std", feature = "num-libm"))]
#[derive(Clone)]
pub struct Simplex<S: Signal<Type = f64>> {
    perm: [u8; 256],
    phase: Phase<S>,
}

#[cfg(any(feature = "num-std", feature = "num-libm"))]
impl<S: Signal<Type = f64>> Simplex<S> {
    /// Creates a new simplex noise signal with the default permutation table.
    #[inline]
    pub fn default(steps: S) -> Self {
        Self {
            perm: [
                151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36,
                103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0,
                26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87,
                174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146,
                158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40,
                244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18,
                169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64,
                52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206,
                59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2,
                44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
                108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242,
                193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107,
                49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4,
                150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66,
                215, 61, 156, 180,
            ],
            phase: Phase::new(steps, 256f64),
        }
    }

    /// Creates a new simplex noise signal with a random permutation table.
    #[cfg(feature = "rand")]
    pub fn with_rng<R: rand::Rng + ?Sized>(rng: &mut R, steps: S) -> Self {
        use core::mem::MaybeUninit;
        use rand::seq::SliceRandom;

        let mut perm = [MaybeUninit::uninit(); 256];

        for i in 0..=255u8 {
            perm[i as usize] = MaybeUninit::new(i);
        }

        perm.shuffle(rng);

        // Safety: The perm table was just initialized.
        Self {
            perm: unsafe { core::mem::transmute(perm) },
            phase: Phase::new(steps, 256f64),
        }
    }
}

#[cfg(any(feature = "num-std", feature = "num-libm"))]
impl<S> Signal for Simplex<S>
where
    S: Signal<Type = f64>,
{
    type Type = f64;

    // This function was stolen from `https://github.com/SRombauts/SimplexNoise`.

    fn next(&mut self) -> Self::Type {
        /// Helper function to hash an integer using the permutation table.
        fn hash(perm: &[u8; 256], i: i64) -> u8 {
            // Safety: casting `i` to a `u8` makes it
            // in bounds.
            unsafe { *perm.get_unchecked(i as u8 as usize) }
        }

        /// Helper function to compute gradients-dot-residual vectors (1D)
        fn grad(hash: i64, x: f64) -> f64 {
            let h = hash & 0x0F; // Convert low 4 bits of hash code
            let mut grad = (1 + (h & 7)) as f64; // Gradient value 1.0, 2.0, ..., 8.0
            if (h & 8) != 0 {
                grad = -grad;
            }
            grad * x
        }

        let phase = self.phase.next_phase();
        let phase_floor = num_traits::Float::floor(phase);

        // Corners coordinates (nearest integer value):
        let i0 = phase_floor as i64;
        let i1 = i0 + 1;

        // Distances to corners (between 0 and 1):
        let x0 = phase - phase_floor;
        let x1 = x0 - 1.0;

        // Calculate the contribution from the first corner
        let mut t0 = 1.0 - x0 * x0;
        t0 *= t0;
        let n0 = t0 * t0 * grad(hash(&self.perm, i0) as i64, x0);

        // Calculate the contribution from the second corner
        let mut t1 = 1.0 - x1 * x1;
        t1 *= t1;
        let n1 = t1 * t1 * grad(hash(&self.perm, i1) as i64, x1);

        // The maximum value of this noise is 8*(3/4)^4 = 2.53125
        // A factor of 0.395 scales it to fit exactly within [-1, 1]
        0.395 * (n0 + n1)
    }
}