Initial data commit

Task/Evolutionary-algorithm/Pony/evolutionary-algorithm-2.pony

@@ -0,0 +1,115 @@
+use "random"
+use "collections"
+
+class CreationFactory
+  let _desired: String
+
+  new create(d: String) =>
+    _desired = d
+
+  fun apply(c: String): Creation =>
+    Creation(c, _fitness(c))
+
+  fun _fitness(s: String): USize =>
+    var f = USize(0)
+    for i in Range(0, s.size()) do
+      try
+        if s(i)? == _desired(i)? then
+          f = f +1
+        end
+      end
+    end
+    f
+
+class val Creation
+  let string: String
+  let fitness: USize
+
+  new val create(s: String = "", f: USize = 0) =>
+    string = s
+    fitness = f
+
+class Mutator
+  embed _rand: MT = MT
+  let _possibilities: String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "
+  let _cf: CreationFactory
+
+  new create(cf: CreationFactory) =>
+    _cf = cf
+
+  fun ref apply(parent: Creation, rate: F64): Creation =>
+    let ns = _new_string(parent.string, rate)
+    _cf(ns)
+
+  fun ref _new_string(parent: String, rate: F64): String =>
+    var mutated = recover String(parent.size()) end
+    for char in parent.values() do
+      mutated.push(_mutate_letter(char, rate))
+    end
+    consume mutated
+
+  fun ref _mutate_letter(current: U8, rate: F64): U8 =>
+    if _rand.real() <= rate then
+      _random_letter()
+    else
+      current
+    end
+
+  fun ref _random_letter(): U8 =>
+    let ln = _rand.int(_possibilities.size().u64()).usize()
+    try _possibilities(ln)? else ' ' end
+
+class Generation
+  let _size: USize
+  let _desired: Creation
+  let _mutator: Mutator
+
+  new create(size: USize = 100, desired: Creation, mutator: Mutator) =>
+    _size = size
+    _desired = desired
+    _mutator = consume mutator
+
+  fun ref apply(parent: Creation): Creation =>
+    var best = parent
+    let mutation_rate = _mutation_rate(best)
+    for i in Range(0, _size) do
+      let candidate = _mutator(best, mutation_rate)
+      if candidate.fitness > best.fitness then
+        best = candidate
+      end
+    end
+    best
+
+  fun _mutation_rate(best: Creation): F64 =>
+    let min_mutate_rate: F64 = 0.09
+
+    let df = _desired.fitness.f64()
+    let bf = best.fitness.f64()
+
+    ((df - bf) / df) * (1.0 - min_mutate_rate)
+
+actor Main
+  new create(env: Env) =>
+    let d = "METHINKS IT IS LIKE A WEASEL"
+    let cf = CreationFactory(d)
+    let desired = cf(d)
+    let mutator = Mutator(cf)
+    let start = mutator(desired, 1.0)
+    let spawn_per_generation = USize(100)
+
+    var iterations = U64(0)
+    var best = start
+
+    repeat
+      best = Generation(spawn_per_generation, desired, mutator)(best)
+
+      iterations = iterations + 1
+      if (iterations % 100) == 0 then
+        env.out.print(
+          iterations.string() + ": "
+          + best.string + ", fitness: " + best.fitness.string()
+          )
+      end
+    until best.string == desired.string end
+
+    env.out.print(best.string + ", " + iterations.string())