Add tasks for all the new languages

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

@@ -0,0 +1,73 @@
+use "random"
+
+actor Main
+  let _env: Env
+  let _rand: MT = MT	// Mersenne Twister
+  let _target: String = "METHINKS IT IS LIKE A WEASEL"
+  let _possibilities: String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "
+  let _c: U16 = 100	// number of spawn per generation
+  let _min_mutate_rate: F64 = 0.09
+  let _perfect_fitness: USize = _target.size()
+  var _parent: String = ""
+
+  new create(env: Env) =>
+    _env = env
+    _parent = mutate(_target, 1.0)
+    var iter: U64 = 0
+    while not _target.eq(_parent) do
+      let rate: F64 = new_mutate_rate()
+      iter = iter + 1
+      if (iter % 100) == 0 then
+        _env.out.write(iter.string() + ": " + _parent)
+        _env.out.write(", fitness: " + fitness(_parent).string())
+        _env.out.print(", rate: " + rate.string())
+      end
+      var best_spawn = ""
+      var best_fit: USize = 0
+      var i: U16 = 0
+      while i < _c do
+        let spawn = mutate(_parent, rate)
+        let spawn_fitness = fitness(spawn)
+        if spawn_fitness > best_fit then
+          best_spawn = spawn
+          best_fit = spawn_fitness
+        end
+        i = i + 1
+      end
+      if best_fit > fitness(_parent) then
+        _parent = best_spawn
+      end
+    end
+    _env.out.print(_parent + ", " + iter.string())
+
+  fun fitness(trial: String): USize =>
+    var ret_val: USize = 0
+    var i: USize = 0
+    while i < trial.size() do
+      try
+        if trial(i) == _target(i) then
+          ret_val = ret_val + 1
+        end
+      end
+      i = i + 1
+    end
+    ret_val
+
+  fun new_mutate_rate(): F64 =>
+    let perfect_fit = _perfect_fitness.f64()
+    ((perfect_fit - fitness(_parent).f64()) / perfect_fit) * (1.0 - _min_mutate_rate)
+
+  fun ref mutate(parent: String box, rate: F64): String =>
+    var ret_val = recover trn String end
+    for char in parent.values() do
+      let rnd_real: F64 = _rand.real()
+      if rnd_real <= rate then
+        let rnd_int: U64 = _rand.int(_possibilities.size().u64())
+        try
+          ret_val.push(_possibilities(rnd_int.usize()))
+        end
+      else
+        ret_val.push(char)
+      end
+    end
+    consume ret_val

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())