clean up noise benchmark tests

Author: tayloraswift

sources/noise/cell.swift

@@ -184,7 +184,7 @@ struct CellNoise2D:_CellNoise2D, HashedNoise
     public
     init(amplitude:Double, frequency:Double, seed:Int = 0)
     {
-        self.amplitude = amplitude * 1/2
+        self.amplitude = amplitude / 2
         self.frequency = frequency
         self.permutation_table = PermutationTable(seed: seed)
     }
@@ -221,6 +221,74 @@ struct CellNoise2D:_CellNoise2D, HashedNoise
     }
 }
 
+/*
+public
+struct TilingCellNoise2D:_CellNoise2D, HashedTilingNoise
+{
+    let permutation_table:PermutationTable,
+        amplitude:Double,
+        frequency:Double,
+        wavelengths:Math.IntV2
+
+    init(amplitude:Double, frequency:Double, permutation_table:PermutationTable, wavelengths:Math.IntV2)
+    {
+        self.amplitude = amplitude
+        self.frequency = frequency
+        self.permutation_table = permutation_table
+        self.wavelengths = wavelengths
+    }
+
+    public
+    init(amplitude:Double, frequency:Double, wavelengths:Int, seed:Int = 0)
+    {
+        self.init(  amplitude: amplitude, frequency: frequency,
+                    wavelengths_x: wavelengths,
+                    wavelengths_y: wavelengths,
+                    seed: seed)
+    }
+
+    public
+    init(amplitude:Double, frequency:Double, wavelengths_x:Int, wavelengths_y:Int, seed:Int = 0)
+    {
+        self.amplitude = amplitude / 2
+        self.frequency = frequency
+        self.permutation_table = PermutationTable(seed: seed)
+        self.wavelengths = (wavelengths_x, wavelengths_y)
+    }
+
+    fileprivate
+    func hash(point:Math.IntV2) -> Int
+    {
+        return self.permutation_table.hash(Math.mod(point, self.wavelengths))
+    }
+
+    public
+    func closest_point(_ x:Double, _ y:Double) -> (point:(Int, Int), r2:Double)
+    {
+        return self._closest_point(x, y)
+    }
+
+    public
+    func evaluate(_ x:Double, _ y:Double) -> Double
+    {
+        let (_, r2):((Int, Int), Double) = self.closest_point(x, y)
+        return self.amplitude * r2
+    }
+
+    public
+    func evaluate(_ x:Double, _ y:Double, _:Double) -> Double
+    {
+        return self.evaluate(x, y)
+    }
+
+    public
+    func evaluate(_ x:Double, _ y:Double, _:Double, _:Double) -> Double
+    {
+        return self.evaluate(x, y)
+    }
+}
+*/
+
 public
 struct CellNoise3D:HashedNoise
 {

sources/noise/gradient.swift

@@ -112,7 +112,7 @@ struct ClassicNoise3D:_ClassicNoise3D, HashedNoise
 
 // UNDOCUMENTED
 public
-struct ClassicTilingNoise3D:_ClassicNoise3D, HashedTilingNoise
+struct TilingClassicNoise3D:_ClassicNoise3D, HashedTilingNoise
 {
     let permutation_table:PermutationTable,
         amplitude:Double,

tests/LinuxMain.swift

@@ -9,73 +9,33 @@ banners(width: 700, ratio: 5)
 
 calibrate_noise(width: 256, height: 256)
 
-var t0:Int
-
 let viewer_size:Int = 1024
-var pixbuf:[UInt8]
+var pixbuf:[UInt8]  = [UInt8](repeating: 0, count: viewer_size * viewer_size)
 let png_properties:PNGProperties = PNGProperties(width: viewer_size, height: viewer_size, bit_depth: 8, color: .grayscale, interlaced: false)!
 
+func benchmark<Generator>(noise generator:Generator, name:String, offset:Double = 0) where Generator:Noise
+{
+    let t0:Int = clock()
+    for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
+    {
+        pixbuf[i] = UInt8(max(0, min(255, generator.evaluate(x, y) + offset)))
+    }
+    print("\(name): \(clock() - t0)")
+    try! png_encode(path: "tests/\(name).png", raw_data: pixbuf, properties: png_properties)
+}
+
 var poisson = DiskSampler2D(seed: 0)
-t0 = clock()
-pixbuf = [UInt8](repeating: 0, count: viewer_size * viewer_size)
+let t0:Int = clock()
 for point:(x:Double, y:Double) in poisson.generate(radius: 10, width: viewer_size, height: viewer_size)
 {
     pixbuf[Int(point.y) * viewer_size + Int(point.x)] = 255
 }
-print(clock() - t0)
+print("disk2d: \(clock() - t0)")
 try png_encode(path: "tests/disk2d.png", raw_data: pixbuf, properties: png_properties)
 
-
-let V:CellNoise2D = CellNoise2D(amplitude: 255, frequency: 0.01)
-t0 = clock()
-for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
-{
-    pixbuf[i] = UInt8(max(0, min(255, V.evaluate(x, y))))
-}
-print(clock() - t0)
-try png_encode(path: "tests/cell2d.png", raw_data: pixbuf, properties: png_properties)
-
-let V3:CellNoise3D = CellNoise3D(amplitude: 255, frequency: 0.01)
-t0 = clock()
-for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
-{
-    pixbuf[i] = UInt8(max(0, min(255, V3.evaluate(x, y))))
-}
-print(clock() - t0)
-try png_encode(path: "tests/cell3d.png", raw_data: pixbuf, properties: png_properties)
-
-let P:FBM<ClassicNoise3D> = FBM<ClassicNoise3D>(ClassicNoise3D(amplitude: 255, frequency: 0.001), octaves: 10, persistence: 0.62)
-t0 = clock()
-for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
-{
-    pixbuf[i] = UInt8(max(0, min(255, P.evaluate(x, y) + 127.5)))
-}
-print(clock() - t0)
-try png_encode(path: "tests/classic3d.png", raw_data: pixbuf, properties: png_properties)
-
-let PT:Noise = ClassicTilingNoise3D(amplitude: 255, frequency: 16 / Double(viewer_size), wavelengths: 16)
-t0 = clock()
-for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
-{
-    pixbuf[i] = UInt8(max(0, min(255, PT.evaluate(x, y) + 127.5)))
-}
-print(clock() - t0)
-try png_encode(path: "tests/classic_tiling3d.png", raw_data: pixbuf, properties: png_properties)
-
-let SS:FBM<GradientNoise2D> = FBM<GradientNoise2D>(GradientNoise2D(amplitude: 180, frequency: 0.001), octaves: 10, persistence: 0.62)
-t0 = clock()
-for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
-{
-    pixbuf[i] = UInt8(max(0, min(255, SS.evaluate(x, y) + 127.5)))
-}
-print(clock() - t0)
-try png_encode(path: "tests/gradient2d.png", raw_data: pixbuf, properties: png_properties)
-
-let SS3D:FBM<GradientNoise3D> = FBM<GradientNoise3D>(GradientNoise3D(amplitude: 180, frequency: 0.001), octaves: 10, persistence: 0.62)
-t0 = clock()
-for (i, (x, y)) in Domain2D(samples_x: viewer_size, samples_y: viewer_size).enumerated()
-{
-    pixbuf[i] = UInt8(max(0, min(255, SS3D.evaluate(x, y) + 127.5)))
-}
-print(clock() - t0)
-try png_encode(path: "tests/gradient3d.png", raw_data: pixbuf, properties: png_properties)
+benchmark(noise: CellNoise2D(amplitude: 255, frequency: 0.01), name: "cell2d")
+benchmark(noise: CellNoise3D(amplitude: 255, frequency: 0.01), name: "cell3d")
+benchmark(noise: FBM<ClassicNoise3D>(ClassicNoise3D(amplitude: 255, frequency: 0.001), octaves: 10, persistence: 0.62), name: "classic3d", offset: 127.5)
+benchmark(noise: TilingClassicNoise3D(amplitude: 255, frequency: 16 / Double(viewer_size), wavelengths: 16), name: "classic_tiling3d", offset: 127.5)
+benchmark(noise: FBM<GradientNoise2D>(GradientNoise2D(amplitude: 180, frequency: 0.001), octaves: 10, persistence: 0.62), name: "gradient2d", offset: 127.5)
+benchmark(noise: FBM<GradientNoise3D>(GradientNoise3D(amplitude: 180, frequency: 0.001), octaves: 10, persistence: 0.62), name: "gradient3d", offset: 127.5)