firefly-compiler 0.4.36 → 0.4.46

package/core/Random.ff

@@ -1,134 +1,134 @@
-class Random {}
-
-// Using Alea PRNG by Johannes Baagøe <baagoe@baagoe.com>, 2010
-// Typical use: Random.seedInstant(system.task().now())
-
-seedInt(seed: Int): Random {
-    seedFloat(seed.toFloat())
-}
-
-seedFloat(seed: Float): Random {
-    let buffer = Buffer.new(8)
-    buffer.setFloat64(0, seed)
-    seedBuffer(buffer)
-}
-
-seedInstant(seed: Instant): Random {
-    seedFloat(seed.since1970.seconds)
-}
-
-seedBuffer(buffer: Buffer): Random
-    target js sync """
-        var n = 0xefc8249d;
-        function mash(data) {
-            for(var i = 0; i < data.byteLength; i++) {
-                n += data.getUint8(i);
-                var h = 0.02519603282416938 * n;
-                n = h >>> 0;
-                h -= n;
-                h *= n;
-                n = h >>> 0;
-                h -= n;
-                n += h * 0x100000000; // 2^32
-            }
-            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
-        }
-        var space = new DataView(new Uint8Array([32]).buffer);
-        var r = {
-            s0: mash(space),
-            s1: mash(space),
-            s2: mash(space),
-            c: 1,
-            spareGauss: NaN
-        };
-        r.s0 -= mash(buffer_);
-        if(r.s0 < 0) r.s0 += 1;
-        r.s1 -= mash(buffer_);
-        if(r.s1 < 0) r.s1 += 1;
-        r.s2 -= mash(buffer_);
-        if(r.s2 < 0) r.s2 += 1;
-        return r;
-    """
-
-extend self: Random {
-    
-    copy(): Random
-        target js sync """
-            return {...self_};
-        """
-
-    nextInt(from: Int, until: Int): Int
-        target js sync """
-            return Random_nextFloat(self_, from_, until_) | 0;
-        """
-
-    nextFloat(from: Float, until: Float): Float
-        target js sync """
-            var t = 2091639 * self_.s0 + self_.c * 2.3283064365386963e-10; // 2^-32
-            self_.s0 = self_.s1;
-            self_.s1 = self_.s2;
-            var uniform = self_.s2 = t - (self_.c = t | 0);
-            return from_ + uniform * (until_ - from_);
-        """
-        
-    nextBool(): Bool {
-        self.nextInt(0, 2) == 0
-    }
-
-    nextBytes(buffer: Buffer, start: Int, stop: Int): Unit {
-        start.until(stop).each {i =>
-            buffer.setUint8(i, self.nextInt(0, 256))
-        }
-    }
-
-    nextGauss(mean: Float, standardDeviation: Float): Float
-        target js sync """
-            if(!isNaN(self_.spareGauss)) {
-                const result = self_.spareGauss * standardDeviation_ + mean_;
-                self_.spareGauss = NaN;
-                return result;
-            } else {
-                let u = 0.5, v = 0.5, s = 0.5;
-                do {
-                    u = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
-                    v = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
-                    s = u * u + v * v;
-                } while(s >= 1 || s == 0);
-                s = Math.sqrt(-2.0 * Math.log(s) / s);
-                self_.spareGauss = v * s;
-                return mean_ + standardDeviation_ * u * s;
-            }
-        """
-
-    shuffleArray[T](array: Array[T]): Unit {
-        0.until(array.size() - 1).each {i =>
-            let j = self.nextInt(0, array.size() - i) + i
-            let value = array.grab(i)
-            array.set(i, array.grab(j))
-            array.set(j, value)
-        }
-    }
-    
-    shuffleList[T](list: List[T]): List[T] {
-        let array = list.toArray()
-        self.shuffleArray(list.toArray())
-        array.drain()
-    }
-
-    sampleArray[T](count: Int, array: Array[T], body: T => Unit): Unit {
-        self.shuffleList(array.toList()).takeFirst(count).each {body(_)}
-    }
-
-    sampleList[T](count: Int, list: List[T]): List[T] {
-        self.shuffleList(list).takeFirst(count)
-    }
-
-    grabArray[T](array: Array[T]): T {
-        array.grab(self.nextInt(0, array.size()))
-    }
-
-    grabList[T](list: List[T]): T {
-        list.grab(self.nextInt(0, list.size()))
-    }
-
-}
+class Random {}
+
+// Using Alea PRNG by Johannes Baagøe <baagoe@baagoe.com>, 2010
+// Typical use: Random.seedInstant(system.task().now())
+
+seedInt(seed: Int): Random {
+    seedFloat(seed.toFloat())
+}
+
+seedFloat(seed: Float): Random {
+    let buffer = Buffer.new(8)
+    buffer.setFloat64(0, seed)
+    seedBuffer(buffer)
+}
+
+seedInstant(seed: Instant): Random {
+    seedFloat(seed.since1970.seconds)
+}
+
+seedBuffer(buffer: Buffer): Random
+    target js sync """
+        var n = 0xefc8249d;
+        function mash(data) {
+            for(var i = 0; i < data.byteLength; i++) {
+                n += data.getUint8(i);
+                var h = 0.02519603282416938 * n;
+                n = h >>> 0;
+                h -= n;
+                h *= n;
+                n = h >>> 0;
+                h -= n;
+                n += h * 0x100000000; // 2^32
+            }
+            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+        }
+        var space = new DataView(new Uint8Array([32]).buffer);
+        var r = {
+            s0: mash(space),
+            s1: mash(space),
+            s2: mash(space),
+            c: 1,
+            spareGauss: NaN
+        };
+        r.s0 -= mash(buffer_);
+        if(r.s0 < 0) r.s0 += 1;
+        r.s1 -= mash(buffer_);
+        if(r.s1 < 0) r.s1 += 1;
+        r.s2 -= mash(buffer_);
+        if(r.s2 < 0) r.s2 += 1;
+        return r;
+    """
+
+extend self: Random {
+    
+    copy(): Random
+        target js sync """
+            return {...self_};
+        """
+
+    nextInt(from: Int, until: Int): Int
+        target js sync """
+            return Random_nextFloat(self_, from_, until_) | 0;
+        """
+
+    nextFloat(from: Float, until: Float): Float
+        target js sync """
+            var t = 2091639 * self_.s0 + self_.c * 2.3283064365386963e-10; // 2^-32
+            self_.s0 = self_.s1;
+            self_.s1 = self_.s2;
+            var uniform = self_.s2 = t - (self_.c = t | 0);
+            return from_ + uniform * (until_ - from_);
+        """
+        
+    nextBool(): Bool {
+        self.nextInt(0, 2) == 0
+    }
+
+    nextBytes(buffer: Buffer, start: Int, stop: Int): Unit {
+        start.until(stop).each {i =>
+            buffer.setUint8(i, self.nextInt(0, 256))
+        }
+    }
+
+    nextGauss(mean: Float, standardDeviation: Float): Float
+        target js sync """
+            if(!isNaN(self_.spareGauss)) {
+                const result = self_.spareGauss * standardDeviation_ + mean_;
+                self_.spareGauss = NaN;
+                return result;
+            } else {
+                let u = 0.5, v = 0.5, s = 0.5;
+                do {
+                    u = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
+                    v = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
+                    s = u * u + v * v;
+                } while(s >= 1 || s == 0);
+                s = Math.sqrt(-2.0 * Math.log(s) / s);
+                self_.spareGauss = v * s;
+                return mean_ + standardDeviation_ * u * s;
+            }
+        """
+
+    shuffleArray[T](array: Array[T]): Unit {
+        0.until(array.size() - 1).each {i =>
+            let j = self.nextInt(0, array.size() - i) + i
+            let value = array.grab(i)
+            array.set(i, array.grab(j))
+            array.set(j, value)
+        }
+    }
+    
+    shuffleList[T](list: List[T]): List[T] {
+        let array = list.toArray()
+        self.shuffleArray(list.toArray())
+        array.drain()
+    }
+
+    sampleArray[T](count: Int, array: Array[T], body: T => Unit): Unit {
+        self.shuffleList(array.toList()).takeFirst(count).each {body(_)}
+    }
+
+    sampleList[T](count: Int, list: List[T]): List[T] {
+        self.shuffleList(list).takeFirst(count)
+    }
+
+    grabArray[T](array: Array[T]): T {
+        array.grab(self.nextInt(0, array.size()))
+    }
+
+    grabList[T](list: List[T]): T {
+        list.grab(self.nextInt(0, list.size()))
+    }
+
+}