init

Author: khernyo

.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="ch.epfl.lamp.sdt.launching.SCALA_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.hgignore

@@ -0,0 +1,3 @@
+syntax: glob
+rngseeds.txt
+bin\pgep/*.class

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_Alphabet.scala

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>pgep</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>ch.epfl.lamp.sdt.core.scalabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>ch.epfl.lamp.sdt.core.scalanature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_Gene.scala

@@ -0,0 +1,4 @@
+#Sat Apr 11 22:55:18 CEST 2009
+eclipse.preferences.version=1
+org.eclipse.jdt.core.builder.cleanOutputFolder=ignore
+org.eclipse.jdt.core.builder.resourceCopyExclusionFilter=*.scala

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_GeneParameters.scala

@@ -0,0 +1,20 @@
+package pgep
+
+abstract class Alphabet[T <: Term](ts: T*) extends Seq[T] {
+  protected val terms = ts.toArray
+
+  protected def _maxParams = ts map (_.nparams) reduceLeft Math.max 
+  def maxParams: Int
+  override def length = terms.length
+  override def elements = terms.elements
+  override def apply(i: Int): T = terms.apply(i)
+}
+
+class AlphabetRO[T <: Term](ts: T*) extends Alphabet[T](ts: _*) {
+  val maxParams = _maxParams
+}
+
+class AlphabetRW[T <: Term](ts: T*) extends Alphabet[T](ts: _*) {
+  var maxParams = _maxParams
+  def update(i: Int, v: T) {terms(i) = v; maxParams = _maxParams}
+}

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_ProbabilityBasedSelector.scala

@@ -0,0 +1,34 @@
+package pgep
+
+import scala.collection.mutable.{HashMap,HashSet}
+
+class Gene(val parameters: GeneParameters) {
+  val _k_expression = new HashMap[Class[_], Array[Term]]
+  private val _constants = new HashMap[Class[_], Array[Const]]
+  
+  private val random = RNGProvider()
+  
+  {
+    val types = new HashSet[Class[_]]
+    types ++= parameters.functions map (_.resultType)
+    types ++= parameters.variables map (_.typee)
+    types ++= parameters.constants.keys
+    
+    types foreach { t =>
+      _k_expression(t) = new Array(parameters.headLen + parameters.tailLen)
+      _constants(t) = new Array(parameters.tailLen)
+    }
+  }
+  
+  def randomize(selector_fvc: Selector[SymbolSetKind], selector_vc: Selector[SymbolSetKind],
+  				headp: () => Boolean, tailp: () => Boolean, constantsp: () => Boolean) {
+    for (tpe <- _k_expression.keys) {
+      val k_expr = _k_expression(tpy)
+      val functions = parameters.functions filter (_.resultType == tpe) toArray
+      val variables = parameters.variables filter (_.typee == tpe) toArray
+      val constants = parameters.constants(tpy)
+    }
+  }
+  
+  def copySymbols
+}

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_RNGProvider.scala

@@ -0,0 +1,22 @@
+package pgep
+
+class GeneParameters(val headLen: Int, val tailLen: Int, val resultType: Class[_],
+                     val functions: Alphabet[Func], val variables: Alphabet[Var], val constants: Map[Class[_], Alphabet[Const]]) {
+  {  
+    assume(constants forall {case (t, a) => a forall (_.typee == t)}, "inconsistent constants")
+    
+    val types = new scala.collection.mutable.HashSet[Class[_]]
+    types ++= functions flatMap (f => f.resultType :: f.parameterTypes)
+    types ++= variables map (_.typee)
+    types ++= constants.keys
+    
+    for (t <- types) {
+      if (!functions.exists(_.resultType == t) ||
+          !variables.exists(_.typee == t) ||
+          !constants.exists(_ == t))
+        throw new IllegalArgumentException("Not all types are covered by Alphabets!");
+    }
+  }
+  
+  def geneLen = headLen + 2 * tailLen
+} 

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_SymbolSetKind.scala

@@ -0,0 +1,73 @@
+package pgep
+
+abstract class Selector[T] {
+  def apply(): T
+}
+
+abstract class ProbabilityBasedSelector[T] extends Selector[T] {
+  protected val random = RNGProvider()
+  
+  protected def constructorPreconditions(probabilities: Seq[Double], values: Seq[T], scale: Double) {
+    assert(probabilities != null)
+    assert(values != null)
+    assert(probabilities.length > 0)
+    assert(probabilities.length == values.length)
+    assert(scale > 0)
+    assert(probabilities forall (_ >= 0))
+    assert(probabilities.reduceLeft(_ + _) == scale)
+  }
+}
+
+class ExactSelector[T](probabilities: Seq[Double], val values: Seq[T], scale: Double) extends ProbabilityBasedSelector[T] {
+  def this(probabilities: Seq[Double], values: Seq[T]) = this(probabilities, values, probabilities reduceLeft (_ + _))
+
+  protected val probabilityDistribution = {
+    constructorPreconditions(probabilities, values, scale)
+    var sum: Double = 0
+    val pdist = probabilities map (p => {sum += p / scale; sum})
+    constructorPostconditions(probabilities, pdist)
+    pdist
+  }
+  
+  protected def constructorPostconditions(probabilities: Seq[Double], pdist: Seq[Double]) {
+    assert(probabilities.length == pdist.length)
+    assert(pdist forall (d => d <= 1.00000000001 && d >= -0.00000000001))
+    val pdistl = pdist.toList
+    assert((pdistl zip pdistl.tail) forall {case (d1, d2) => d1 <= d2})
+    assert(Math.abs(pdist.last - 1) < 0.00000000001)
+  }
+  
+  override def apply() = {
+    var rnd = random.nextDouble
+    val idx = probabilityDistribution map (rnd < _) indexOf true
+    assert(idx >= 0)
+    values(idx)
+  }
+}
+
+class SampledSelector[T](probabilities: Seq[Double], val values: Seq[T], scale: Double, nrsamples: Int) extends ProbabilityBasedSelector[T] {
+  def this(probabilities: Seq[Double], values: Seq[T], scale: Double) = this(probabilities, values, scale, 1000)
+  def this(probabilities: Seq[Double], values: Seq[T]) = this(probabilities, values, probabilities reduceLeft (_ + _))
+  
+  protected val samples = {
+    constructorPreconditions(probabilities, values, scale)
+    val smpls = ((values.toList zip probabilities.toList) flatMap {case (value, prob) => (List.make(Math.floor(prob * nrsamples.toDouble).toInt, value))}).toArray
+    constructorPostconditions(values, nrsamples, smpls)
+    smpls
+  }
+  
+  protected def constructorPostconditions(values: Seq[T], nrsamples: Int, samples: Array[T]) {
+    assert(samples.length == nrsamples)
+    assert(samples forall (values.contains(_)))
+    assert(values forall (samples.contains(_)))
+  }
+  
+  protected def constructorPreconditions(probabilities: Seq[Double], values: Seq[T], scale: Double, nrsamples: Int) {
+    constructorPreconditions(probabilities, values, scale)
+    assert(nrsamples > values.length)
+  }
+  
+  override def apply() = {
+    samples(random.nextInt(samples.length))
+  }
+}

.manager/_$_Users_$_eszaber_$_workspace_$_scala_$_pgep_$_src_$_pgep_$_Term.scala

@@ -0,0 +1,24 @@
+package pgep
+
+import java.util.Date
+import java.io.FileWriter
+import scala.util.Random
+import scala.collection.mutable.{HashMap,SynchronizedMap}
+
+object RNGProvider {
+  var seed: Int = (new Date().getTime & Integer.MAX_VALUE).asInstanceOf[Int]
+  private val logFile = "rngseeds.txt"
+  private val rngs = new HashMap[Thread, Random] with SynchronizedMap[Thread,Random]
+  
+  private def createRng = {
+    val f = new FileWriter(logFile, true)
+    f.write("%s ThreadId:%s ThreadName:\"%s\" seed:%s\n" format (new Date(), currentThread.getId, currentThread.getName, seed))
+    f.close
+    
+    val rng = new Random(seed)
+    rngs(currentThread) = rng
+    rng
+  }
+
+  def apply() = rngs.getOrElseUpdate(currentThread, createRng)
+}

.project

@@ -0,0 +1,6 @@
+package pgep
+
+sealed abstract class SymbolSetKind
+case object Func extends SymbolSetKind
+case object Var extends SymbolSetKind
+case object Const extends SymbolSetKind

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,14 @@
+package pgep
+
+sealed abstract class Term {
+  val nparams = 0
+}
+
+case class Const(name: String, typee: Class[_], value: Any) extends Term
+case class Var(name: String, typee: Class[_]) extends Term
+case class Func(name: String, parameterTypes: List[Class[_]], resultType: Class[_], fn: List[Any] => Any, strFn: List[String] => String) extends Term {
+  def apply = fn
+  def applyStr = strFn
+  
+  override val nparams = parameterTypes.length
+}