rewrite DomainND code with vector math

Author: tayloraswift

sources/noise/hash.swift

@@ -30,12 +30,14 @@ extension HashedNoise
 
 protocol HashedTilingNoise:Noise
 {
+    associatedtype IntV
+
     var permutation_table:PermutationTable { get }
     var amplitude:Double { get }
     var frequency:Double { get }
-    var wavelengths:Math.IntV3 { get }
+    var wavelengths:IntV { get }
 
-    init(amplitude:Double, frequency:Double, permutation_table:PermutationTable, wavelengths:Math.IntV3)
+    init(amplitude:Double, frequency:Double, permutation_table:PermutationTable, wavelengths:IntV)
 }
 
 extension HashedTilingNoise
@@ -59,7 +61,10 @@ extension HashedTilingNoise
         return Self(amplitude: self.amplitude, frequency: self.frequency,
                     permutation_table: new_table, wavelengths: self.wavelengths)
     }
-
+}
+/*
+extension HashedTilingNoise where IntV == Math.IntV3
+{
     public
     func transposed(octaves:Int) -> Self
     {
@@ -69,6 +74,7 @@ extension HashedTilingNoise
                     wavelengths: (self.wavelengths.a << octaves, self.wavelengths.b << octaves, self.wavelengths.c << octaves))
     }
 }
+*/
 
 public
 struct RandomXorshift

sources/noise/noise.swift

@@ -170,6 +170,34 @@ enum Math
         return (v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)
     }
 
+    @inline(__always)
+    static
+    func mult(_ v1:DoubleV2, _ v2:DoubleV2) -> DoubleV2
+    {
+        return (v1.x * v2.x, v1.y * v2.y)
+    }
+
+    @inline(__always)
+    static
+    func mult(_ v1:DoubleV3, _ v2:DoubleV3) -> DoubleV3
+    {
+        return (v1.x * v2.x, v1.y * v2.y, v1.z * v2.z)
+    }
+
+    @inline(__always)
+    static
+    func div(_ v1:DoubleV2, _ v2:DoubleV2) -> DoubleV2
+    {
+        return (v1.x / v2.x, v1.y / v2.y)
+    }
+
+    @inline(__always)
+    static
+    func div(_ v1:DoubleV3, _ v2:DoubleV3) -> DoubleV3
+    {
+        return (v1.x / v2.x, v1.y / v2.y, v1.z / v2.z)
+    }
+
     @inline(__always)
     private static
     func mod(_ x:Int, _ n:Int) -> Int
@@ -255,72 +283,62 @@ public
 struct Domain2D:Sequence
 {
     private
-    let i_max:Double,
-        j_max:Double,
-
-        dx:Double,
-        dy:Double,
-        i0:Double,
-        j0:Double
+    let sample_lower_bound:Math.DoubleV2,
+        sample_upper_bound:Math.DoubleV2,
+        increment:Math.DoubleV2
 
     public
     struct Iterator:IteratorProtocol
     {
         private
-        var i:Double = -0.5,
-            j:Double =  0.5
+        var sample:Math.DoubleV2
 
         private
         let domain:Domain2D
 
         init(_ domain:Domain2D)
         {
-            self.i = domain.i0 - 0.5
-            self.j = domain.j0 + 0.5
-
+            self.sample = Math.add(domain.sample_lower_bound, (-0.5, 0.5))
             self.domain = domain
         }
 
         public mutating
         func next() -> (Double, Double)?
         {
-            self.i += 1
-            if self.i >= self.domain.i_max
+            self.sample.x += 1
+            if self.sample.x >= self.domain.sample_upper_bound.x
             {
-                self.i = self.domain.i0 + 0.5
-                self.j += 1
-                if self.j >= self.domain.j_max
+                self.sample.x = self.domain.sample_lower_bound.x + 0.5
+                self.sample.y += 1
+                if self.sample.y >= self.domain.sample_upper_bound.y
                 {
                     return nil
                 }
             }
 
-            return (self.domain.dx * self.i, self.domain.dy * self.j)
+            return Math.mult(self.domain.increment, self.sample)
         }
     }
 
     public
     init(samples_x:Int, samples_y:Int)
     {
-        self.dx = 1
-        self.dy = 1
-        self.i0 = 0
-        self.j0 = 0
-
-        self.i_max = Double(samples_x)
-        self.j_max = Double(samples_y)
+        self.increment          = (1, 1)
+        self.sample_lower_bound = (0, 0)
+        self.sample_upper_bound = Math.cast_double((samples_x, samples_y))
     }
 
     public
     init(_ x_range:ClosedRange<Double>, _ y_range:ClosedRange<Double>, samples_x:Int, samples_y:Int)
     {
-        self.dx     = (x_range.upperBound - x_range.lowerBound) / Double(samples_x)
-        self.dy     = (y_range.upperBound - y_range.lowerBound) / Double(samples_y)
-        self.i0     = x_range.lowerBound * Double(samples_x) / (x_range.upperBound - x_range.lowerBound)
-        self.j0     = y_range.lowerBound * Double(samples_y) / (y_range.upperBound - y_range.lowerBound)
+        let sample_count:Math.DoubleV2      = Math.cast_double((samples_x, samples_y)),
+            range_lower_bound:Math.DoubleV2 = (x_range.lowerBound, y_range.lowerBound),
+            range_upper_bound:Math.DoubleV2 = (x_range.upperBound, y_range.upperBound),
+            range_difference:Math.DoubleV2  = Math.sub(range_upper_bound, range_lower_bound)
 
-        self.i_max = self.i0 + Double(samples_x)
-        self.j_max = self.j0 + Double(samples_y)
+        self.increment = Math.div(range_difference, sample_count)
+        self.sample_lower_bound = Math.div(Math.mult(range_lower_bound, sample_count), range_difference)
+        self.sample_upper_bound = Math.add(self.sample_lower_bound, sample_count)
     }
 
     public
@@ -335,89 +353,68 @@ public
 struct Domain3D:Sequence
 {
     private
-    let i_max:Double,
-        j_max:Double,
-        k_max:Double,
-
-        dx:Double,
-        dy:Double,
-        dz:Double,
-        i0:Double,
-        j0:Double,
-        k0:Double
+    let sample_lower_bound:Math.DoubleV3,
+        sample_upper_bound:Math.DoubleV3,
+        increment:Math.DoubleV3
 
     public
     struct Iterator:IteratorProtocol
     {
         private
-        var i:Double = -0.5,
-            j:Double =  0.5,
-            k:Double =  0.5
+        var sample:Math.DoubleV3
 
         private
         let domain:Domain3D
 
         init(_ domain:Domain3D)
         {
-            self.i = domain.i0 - 0.5
-            self.j = domain.j0 + 0.5
-            self.k = domain.k0 + 0.5
-
+            self.sample = Math.add(domain.sample_lower_bound, (-0.5, 0.5, 0.5))
             self.domain = domain
         }
 
         public mutating
         func next() -> (Double, Double, Double)?
         {
-            self.i += 1
-            if self.i >= self.domain.i_max
+            self.sample.x += 1
+            if self.sample.x >= self.domain.sample_upper_bound.x
             {
-                self.i = self.domain.i0 + 0.5
-                self.j += 1
-                if self.j >= self.domain.j_max
+                self.sample.x = self.domain.sample_lower_bound.x + 0.5
+                self.sample.y += 1
+                if self.sample.y >= self.domain.sample_upper_bound.y
                 {
-                    self.j = self.domain.j0 + 0.5
-                    self.k += 1
-                    if self.k >= self.domain.k_max
+                    self.sample.y = self.domain.sample_lower_bound.y + 0.5
+                    self.sample.z += 1
+                    if self.sample.z >= self.domain.sample_upper_bound.z
                     {
                         return nil
                     }
                 }
             }
 
-            return (self.domain.dx * self.i, self.domain.dy * self.j, self.domain.dz * self.k)
+            return Math.mult(self.domain.increment, self.sample)
         }
     }
 
     public
     init(samples_x:Int, samples_y:Int, samples_z:Int)
     {
-        self.dx = 1
-        self.dy = 1
-        self.dz = 1
-        self.i0 = 0
-        self.j0 = 0
-        self.k0 = 0
-
-        self.i_max = Double(samples_x)
-        self.j_max = Double(samples_y)
-        self.k_max = Double(samples_z)
+        self.increment          = (1, 1, 1)
+        self.sample_lower_bound = (0, 0, 0)
+        self.sample_upper_bound = Math.cast_double((samples_x, samples_y, samples_z))
     }
 
     public
     init(_ x_range:ClosedRange<Double>, _ y_range:ClosedRange<Double>, _ z_range:ClosedRange<Double>,
         samples_x:Int, samples_y:Int, samples_z:Int)
     {
-        self.dx     = (x_range.upperBound - x_range.lowerBound) / Double(samples_x)
-        self.dy     = (y_range.upperBound - y_range.lowerBound) / Double(samples_y)
-        self.dz     = (z_range.upperBound - z_range.lowerBound) / Double(samples_z)
-        self.i0     = x_range.lowerBound * Double(samples_x) / (x_range.upperBound - x_range.lowerBound)
-        self.j0     = y_range.lowerBound * Double(samples_y) / (y_range.upperBound - y_range.lowerBound)
-        self.k0     = z_range.lowerBound * Double(samples_z) / (z_range.upperBound - z_range.lowerBound)
+        let sample_count:Math.DoubleV3      = Math.cast_double((samples_x, samples_y, samples_z)),
+            range_lower_bound:Math.DoubleV3 = (x_range.lowerBound, y_range.lowerBound, z_range.lowerBound),
+            range_upper_bound:Math.DoubleV3 = (x_range.upperBound, y_range.upperBound, z_range.upperBound),
+            range_difference:Math.DoubleV3  = Math.sub(range_upper_bound, range_lower_bound)
 
-        self.i_max = self.i0 + Double(samples_x)
-        self.j_max = self.j0 + Double(samples_y)
-        self.k_max = self.k0 + Double(samples_z)
+        self.increment = Math.div(range_difference, sample_count)
+        self.sample_lower_bound = Math.div(Math.mult(range_lower_bound, sample_count), range_difference)
+        self.sample_upper_bound = Math.add(self.sample_lower_bound, sample_count)
     }
 
     public