Container

model/src/main/scala/fr/iscpif/schelling/quantity/initial/Container.scala

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2015 Romain Reuillon
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package fr.iscpif.schelling.quantity.initial
+
+import fr.iscpif.schelling.quantity._
+
+import scala.util.Random
+
+trait Container {
+
+  def size : Int
+
+  var values : Seq[Seq[Cell]]
+
+  def container(implicit rng: Random): Seq[Seq[Cell]]
+
+  def printContainer: Unit = {
+    values.foreach(
+      (row : Seq[Cell]) => {
+          row.foreach(
+            (c : Cell) => {print(c.capacity);print(" | ")}
+          )
+          println()
+       }
+    )
+
+  }
+
+
+}

model/src/main/scala/fr/iscpif/schelling/quantity/initial/ExpMixtureContainer.scala

@@ -0,0 +1,48 @@
+package fr.iscpif.schelling.quantity.initial
+
+import fr.iscpif.schelling.quantity.Cell
+
+import scala.util.Random
+
+trait ExpMixtureContainer <: Container {
+
+    /** maximal capacity C_m */
+    def maxCapacity : Int
+
+    /** Size of exponential kernels, of the form C_m*exp(-||x-x_0||/r_0) */
+    def kernelRadius : Double
+
+    /** Number of exponential kernels */
+    def centersNumber : Int
+
+    var values : Seq[Seq[Cell]] = null
+
+    def container(implicit rng: Random) = {
+      val arrayVals = Array.fill[Cell](size, size) {
+        new Cell(0, 0, 0)
+      }
+
+      // generate random center positions
+      val centers = Array.fill[Int](centersNumber, 2) {
+        rng.nextInt(size)
+      }
+
+      for (i <- 0 to size - 1; j <- 0 to size - 1) {
+        for (c <- 0 to centersNumber - 1) {
+          arrayVals(i)(j).capacity = arrayVals(i)(j).capacity + maxCapacity * math.exp(-math.sqrt(math.pow((i - centers(c)(0)), 2) + math.pow((j - centers(c)(1)), 2)) / kernelRadius)
+          //println(i + " " + j + " : " + arrayVals(i)(j).capacity)
+        }
+      }
+
+      //println(arrayVals.toSeq)
+      //val a = arrayVals.map({a:Array[Cell]=>a.toSeq})
+      //for(k <- 0 to a.length - 1){println(a(k))}
+      //println(arrayVals.map({a:Array[Cell]=>a.toSeq}).toSeq)
+      //values = arrayVals.map({ a: Array[Cell] => a.toSeq }).toSeq
+
+      values = Seq.tabulate(size,size){(i:Int,j:Int)=>Cell(arrayVals(i)(j).capacity,0,0) }
+
+      values
+    }
+
+ }

model/src/main/scala/fr/iscpif/schelling/quantity/initial/PrefAttDiffusionContainer.scala

@@ -0,0 +1,114 @@
+package fr.iscpif.schelling.quantity.initial
+
+import fr.iscpif.schelling.quantity.Cell
+
+import scala.util.Random
+
+trait PrefAttDiffusionContainer <: Container {
+
+    /** sum of all capacities */
+    def totalCapacity : Double
+
+    /** diffusion parameters */
+    def diffusion : Double
+    def diffusionSteps : Int
+
+    /** Growth rate */
+    def growthRate : Int
+
+    /** Preferential attachment parameter */
+    def alphaAtt : Double
+
+
+
+
+    var values : Seq[Seq[Cell]] = null
+
+
+
+
+  /**
+   *
+   * @param rng
+   * @return
+   */
+    def container(implicit rng: Random) = {
+      var arrayVals = Array.fill[Cell](size, size){new Cell(0,0,0)}
+      var population :Double = 0
+
+      while(population < totalCapacity) {
+
+        // add new population following pref att rule
+        if(population==0){
+          //choose random patch
+          for(_<- 1 to growthRate){val i = rng.nextInt(size);val j = rng.nextInt(size) ; arrayVals(i)(j).capacity =  arrayVals(i)(j).capacity + 1 }
+        } else{
+          val oldPop = arrayVals.clone()
+          val ptot = oldPop.flatten.map((c:Cell)=>math.pow(c.capacity / population , alphaAtt)).sum
+
+          /*
+          val drawings = Array.fill[Double](growthRate){rng.nextDouble()}
+          Sorting.quickSort(drawings)
+          var s = 0.0; var i =0;var j =0;var k=0;
+          oldPop.flatten.foreach(
+            (c:Cell)=>{
+              s=s+(math.pow(c.capacity/population,alphaAtt)/ptot)
+              while(s<drawings(k)){arrayVals(i)(j).capacity = arrayVals(i)(j).capacity + 1;k=k+1;}
+              j=j+1;if(j==size){j=0;i=i+1};
+            }
+          )
+          */
+
+          for(_<- 1 to growthRate){
+            var s = 0.0 ; val r = rng.nextDouble() ; var i =0;var j =0
+            while(s<r){s=s+(math.pow(oldPop(i)(j).capacity/population,alphaAtt)/ptot);j=j+1;if(j==size){j=0;i=i+1}}
+            if(j==0){j=size-1;i = i - 1}else{j=j-1};
+            arrayVals(i)(j).capacity = arrayVals(i)(j).capacity + 1
+          }
+        }
+
+        // diffuse
+        for (_ <- 1 to diffusionSteps) {
+          arrayVals = diffuse(arrayVals, diffusion)
+        }
+
+        // update total population
+        population = arrayVals.flatten.map(_.capacity).sum
+
+        //println("population : "+population)
+      }
+
+      values = Seq.tabulate(size,size){(i:Int,j:Int)=>Cell(arrayVals(i)(j).capacity,0,0) }
+      values
+
+    }
+
+
+
+
+
+
+  /**
+   * Diffuse to neighbors proportion alpha of capacities
+   * @param a
+   */
+  def diffuse(a : Array[Array[Cell]],alpha : Double): Array[Array[Cell]] = {
+    val newVals = a.clone()
+    for (i <- 0 to size - 1; j <- 0 to size - 1) {
+      if(i>=1){newVals(i-1)(j).capacity = newVals(i-1)(j).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(i<size-1){newVals(i+1)(j).capacity = newVals(i+1)(j).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(j>=1){newVals(i)(j-1).capacity = newVals(i)(j-1).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(j<size-1){newVals(i)(j+1).capacity = newVals(i)(j+1).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(i>=1&&j>=1){newVals(i-1)(j-1).capacity = newVals(i-1)(j-1).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(i>=1&&j<size-1){newVals(i-1)(j+1).capacity = newVals(i-1)(j+1).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(i<size-1&&j>=1){newVals(i+1)(j-1).capacity = newVals(i+1)(j-1).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+      if(i<size-1&&j<size-1){newVals(i+1)(j+1).capacity = newVals(i+1)(j+1).capacity + (alpha / 8)*a(i)(j).capacity ; newVals(i)(j).capacity = newVals(i)(j).capacity  - (alpha / 8)*a(i)(j).capacity }
+    }
+    newVals
+  }
+
+
+
+
+
+ }

model/src/main/scala/fr/iscpif/schelling/quantity/initial/RandomContainer.scala

@@ -0,0 +1,22 @@
+package fr.iscpif.schelling.quantity.initial
+
+import fr.iscpif.schelling.quantity.Cell
+
+import scala.util.Random
+
+
+trait RandomContainer <: Container {
+
+   def maxCapacity : Int
+
+   var values : Seq[Seq[Cell]] = null
+
+   def container(implicit rng: Random) = {
+     values = Seq.fill(size, size) {
+       val capacity: Double = rng.nextInt(maxCapacity).toDouble
+       Cell(capa = capacity, green = 0, red = 0)
+     }
+     values
+   }
+
+}

model/src/main/scala/fr/iscpif/schelling/quantity/test/TestContainer.scala

@@ -0,0 +1,46 @@
+package fr.iscpif.schelling.quantity.test
+
+import fr.iscpif.schelling.quantity.Schelling
+import fr.iscpif.schelling.quantity.initial._
+import fr.iscpif.schelling.quantity.move._
+import fr.iscpif.schelling.quantity.stop._
+
+import scala.util.Random
+
+object TestContainer extends App {
+
+  val t = System.currentTimeMillis()
+
+  implicit val rng = new Random
+
+  val simulation = new Schelling with RandomState with PrefAttDiffusionContainer with RandomMoves with SpeilmanStop {
+    override def size: Int = 50
+    override def greenRatio: Double = 0.5
+    override def redRatio: Double = 0.35
+    override def maxCapacity: Int = 50
+    override def similarWanted: Double = 0.4
+
+    /*// exp Mixture params
+    override def kernelRadius = 0.5
+    override def centersNumber = 2
+    */
+
+    //prefAttdiff
+    override def totalCapacity :Double = 10000
+    override def diffusion : Double = 0.02
+    override def diffusionSteps : Int = 2
+    override def growthRate : Int = 100
+    override def alphaAtt : Double = 1.1
+  }
+
+  // generate initial state
+  simulation.initialState(rng)
+
+  // print container
+  //simulation.printContainer
+
+  println(simulation.values.flatten.map(_.capacity).max)
+
+  println((System.currentTimeMillis()-t)/1000.0)
+
+}

model/src/main/scala/fr/iscpif/spacematters/model/Cell.scala

@@ -20,7 +20,10 @@ object Cell {
   val empty = Cell(0, 0, 0)
 }
 
-case class Cell(capacity: Int, green: Int, red: Int) {
+case class Cell(capa: Double, green: Int, red: Int) {
+
+  var capacity = capa
+
   def isFull = population >= capacity
   def isEmpty = population <= 0
   def population = red + green

model/src/main/scala/fr/iscpif/spacematters/model/Simulation.scala

@@ -15,12 +15,21 @@ object Simulation extends App {
 
   implicit val rng = new Random
 
-  val simulation = new Schelling with RandomState with RandomMoves with SpeilmanStop {
+  val simulation = new Schelling with RandomState with RandomContainer with RandomMoves with SpeilmanStop {
     override def size: Int = 50
     override def greenRatio: Double = 0.5
     override def redRatio: Double = 0.35
     override def maxCapacity: Int = 50
     override def similarWanted: Double = 0.4
+
+/*
+    override def totalCapacity :Double = 50000
+    override def diffusion : Double = 0.02
+    override def diffusionSteps : Int = 2
+    override def growthRate : Int = 100
+    override def alphaAtt : Double = 1.1
+*/
+
   }
 
   simulation.run

model/src/main/scala/fr/iscpif/spacematters/model/initial/RandomState.scala

@@ -21,15 +21,14 @@ import fr.iscpif.spacematters.model._
 
 import scala.util.Random
 
-trait RandomState <: InitialState { self: Schelling =>
+trait RandomState <: InitialState with Container { self: Schelling =>
 
   def maxCapacity: Int
 
   def initialState(implicit rng: Random) = {
-    val cells = Seq.fill(size, size) {
-      val capacity = rng.nextInt(maxCapacity)
-      Cell(capacity = capacity, green = 0, red = 0)
-    }
+
+
+    val cells = container(rng)
 
     val totalCapacity = cells.flatten.map(_.capacity).sum
     val greens = (totalCapacity * greenRatio).toInt