refactor Random --> Chance

import.ck

@@ -108,8 +108,8 @@ Machine.add(path + "lick/fn/Trunc.ck");
 Machine.add(path + "lick/fn/Uniform.ck");
 
 // random suppliers
-Machine.add(path + "lick/fn/Random.ck");
-Machine.add(path + "lick/fn/GaussianRandom.ck");
+Machine.add(path + "lick/fn/Chance.ck");
+Machine.add(path + "lick/fn/Gaussian.ck");
 
 // random predicates
 Machine.add(path + "lick/fn/AlmostAlways.ck");

lick/duration/Humanize.ck

@@ -55,64 +55,33 @@ public class Humanize
     // todo:  add swing
 
 
-    fun static dur humanize(dur value, Random random)
+    fun static dur humanize(dur value, Chance chance)
     {
-        return humanize(value, 0.05, 0.05, random);
+        return humanize(value, 0.05, 0.05, chance);
     }
 
-    fun static dur humanize(dur value, float anticipation, float delay, Random random)
+    fun static dur humanize(dur value, float anticipation, float delay, Chance chance)
     {
-        return value - random.get() * anticipation * value + random.get() * delay * value;
+        return value - chance.get() * anticipation * value + chance.get() * delay * value;
     }
 
-    fun static dur anticipate(dur value, Random random)
+    fun static dur anticipate(dur value, Chance chance)
     {
-        return anticipate(value, 0.1, random);
+        return anticipate(value, 0.1, chance);
     }
 
-    fun static dur anticipate(dur value, float anticipation, Random random)
+    fun static dur anticipate(dur value, float anticipation, Chance chance)
     {
-        return value - random.get() * anticipation * value;
+        return value - chance.get() * anticipation * value;
     }
 
-    fun static dur delay(dur value, Random random)
+    fun static dur delay(dur value, Chance chance)
     {
-        return delay(value, 0.1, random);
+        return delay(value, 0.1, chance);
     }
 
-    fun static dur delay(dur value, float delay, Random random)
+    fun static dur delay(dur value, float delay, Chance chance)
     {
-        return value + random.get() * delay * value;
-    }
-
-
-    fun dur humanizeGaussian(dur value)
-    {
-        return humanizeGaussian(value, 0.05, 0.05);
-    }
-
-    fun dur humanizeGaussian(dur value, float anticipation, float delay)
-    {
-        return value + GaussianRandom.nextGaussian() * anticipation * value - GaussianRandom.nextGaussian() * delay * value;
-    }
-
-    fun static dur anticipateGaussian(dur value)
-    {
-        return anticipateGaussian(value, 0.1);
-    }
-
-    fun static dur anticipateGaussian(dur value, float anticipation)
-    {
-        return value - GaussianRandom.nextGaussian() * anticipation * value;
-    }
-
-    fun static dur delayGaussian(dur value)
-    {
-        return delayGaussian(value, 0.1);
-    }
-
-    fun static dur delayGaussian(dur value, float delay)
-    {
-        return value + GaussianRandom.nextGaussian() * delay * value;
+        return value + chance.get() * delay * value;
     }
 }

lick/duration/HumanizedDurProvider.ck

@@ -24,11 +24,11 @@ public class HumanizedDurProvider extends DurProvider
 {
     0.05 => float anticipation;
     0.05 => float delay;
-    Random random;
+    Chance chance;
 
     fun dur evaluate()
     {
-        return Humanize.humanize(duration, anticipation, delay, random);
+        return Humanize.humanize(duration, anticipation, delay, chance);
     }
 
     fun static HumanizedDurProvider create(dur duration, float anticipation, float delay)
@@ -40,13 +40,13 @@ public class HumanizedDurProvider extends DurProvider
         return humanizedDurProvider;
     }
 
-    fun static HumanizedDurProvider create(dur duration, float anticipation, float delay, Random random)
+    fun static HumanizedDurProvider create(dur duration, float anticipation, float delay, Chance chance)
     {
         HumanizedDurProvider humanizedDurProvider;
         duration => humanizedDurProvider.duration;
         anticipation => humanizedDurProvider.anticipation;
         delay => humanizedDurProvider.delay;
-        random @=> humanizedDurProvider.random;
+        chance @=> humanizedDurProvider.chance;
         return humanizedDurProvider;
     }
 }

lick/duration/IntervalDurProvider.ck

@@ -30,7 +30,7 @@ public class IntervalDurProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         interval.evaluate(f) * durProvider.get() => dur duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 
     fun static IntervalDurProvider create(TimeSignature timeSignature, Interval interval, float f, DurProvider durProvider)

lick/duration/TimeSignature.ck

@@ -28,7 +28,7 @@ class BreveProvider extends HumanizedDurProvider
     {
         timeSignature.d => duration;
         //return super.evaluate();  not supported
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -44,7 +44,7 @@ class SemibreveProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.w => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -60,7 +60,7 @@ class MinimProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.h => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -76,7 +76,7 @@ class CrotchetProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.q => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -92,7 +92,7 @@ class TripletQuarterProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.triplet(timeSignature.q) => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -103,7 +103,7 @@ class QuaverProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.e => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -119,7 +119,7 @@ class DottedEighthProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.dotted(timeSignature.e) => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -130,7 +130,7 @@ class TripletEighthProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.triplet(timeSignature.e) => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -141,7 +141,7 @@ class SemiquaverProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.s => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -157,7 +157,7 @@ class TripletSixteenthProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.triplet(timeSignature.s) => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -168,7 +168,7 @@ class DemiSemiquaverProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.t => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -184,7 +184,7 @@ class HemiDemiSemiquaverProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.f => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -200,7 +200,7 @@ class SemiHemiDemiSemiquaverProvider extends HumanizedDurProvider
     fun dur evaluate()
     {
         timeSignature.u => duration;
-        return Humanize.humanize(duration, anticipation, delay, timeSignature.random);
+        return Humanize.humanize(duration, anticipation, delay, timeSignature.chance);
     }
 }
 
@@ -223,7 +223,7 @@ public class TimeSignature
     dur t;
     dur f;
     dur u;
-    Random random;
+    Chance chance;
 
     fun void update()
     {
@@ -609,13 +609,13 @@ public class TimeSignature
         return timeSignature;
     }
 
-    fun static TimeSignature create(int bar, int beat, int bpm, Random random)
+    fun static TimeSignature create(int bar, int beat, int bpm, Chance chance)
     {
         TimeSignature timeSignature;
         bar => timeSignature.bar;
         beat => timeSignature.beat;
         bpm => timeSignature.bpm;
-        random @=> timeSignature.random;
+        chance @=> timeSignature.chance;
         timeSignature.update();
         return timeSignature;
     }

lick/effect/Mixer.ck

@@ -90,17 +90,17 @@ public class Mixer extends Effect
 
     fun void randomize()
     {
-        Random r;
-        randomize(r);
+        Chance c;
+        randomize(c);
     }
 
-    fun void randomize(Random r)
+    fun void randomize(Chance c)
     {
         1.0 => float remaining;
         inputs.size() => int n;
         for (0 => int i; i < n; i++)
         {
-            r.get() * remaining => float g;
+            c.get() * remaining => float g;
             g => input(i).gain;
             remaining - g => remaining;
         }

lick/fn/AlmostAlways.ck

@@ -22,10 +22,10 @@
 
 public class AlmostAlways extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.almostAlways();
+        return c.almostAlways();
     }
 }

lick/fn/Random.ck → lick/fn/Chance.ck

@@ -20,7 +20,7 @@
 
 */
 
-public class Random extends FloatSupplier
+public class Chance extends FloatSupplier
 {
     fun float get()
     {

lick/fn/CoinFlip.ck

@@ -22,10 +22,10 @@
 
 public class CoinFlip extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.coinFlip();
+        return c.coinFlip();
     }
 }

lick/fn/Frequently.ck

@@ -22,10 +22,10 @@
 
 public class Frequently extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.frequently();
+        return c.frequently();
     }
 }

lick/fn/GaussianRandom.ck → lick/fn/Gaussian.ck

@@ -20,7 +20,7 @@
 
 */
 
-public class GaussianRandom extends Random
+public class Gaussian extends Chance
 {
     //
     // adapted without caching from org.apache.commmons.math3.random.AbstractRandomGenerator,

lick/fn/Infrequently.ck

@@ -22,10 +22,10 @@
 
 public class Infrequently extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.infrequently();
+        return c.infrequently();
     }
 }

lick/fn/Often.ck

@@ -22,10 +22,10 @@
 
 public class Often extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.often();
+        return c.often();
     }
 }

lick/fn/Rarely.ck

@@ -22,10 +22,10 @@
 
 public class Rarely extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.rarely();
+        return c.rarely();
     }
 }

lick/fn/Sometimes.ck

@@ -22,10 +22,10 @@
 
 public class Sometimes extends Predicate
 {
-    Random r;
+    Chance c;
 
     fun int test()
     {
-        return r.sometimes();
+        return c.sometimes();
     }
 }