#cs373

package com.swisscom.scala.cs373 abstract class State case class Red extends State case class Green extends State object Ps1 extends App { val colors = List( List(Red(), Green(), Green(), Red(), Red()), List(Red(), Red(), Green(), Red(), Red()), List(Red(), Red(), Green(), Green(), Red()), List(Red(), Red(), Red(), Red(), Red())) val measurements = List(Green(), Green(),Green(),Green(),Green()) val motions = List((0,0),(0,1),(1,0),(1,0),(0,1)) val sensor_right = 0.7 val p_move = 0.8 def show(p:Seq[Seq[Double]]) = p.foreach(println) def sense(w: Seq[Seq[Double]], m: State) = { val tmp = for (r <- 0 until w.size) yield for (c <- 0 until w(r).size) yield if (colors(r)(c) == m) w(r)(c) * sensor_right else w(r)(c) * (1 - sensor_right) val sum = tmp.foldLeft(0.)(_ + _.sum) tmp.map(_.map(_ / sum)) } def move(w: Seq[Seq[Double]], m: Tuple2[Int,Int]): Seq[Seq[Double]] = { return ( for (r <- 0 until w.size) yield for (c <- 0 until w(r).size) yield p_move * w((w.size + r - m._1) % w.size)((w(r).size + c - m._2) % w(r).size) + (1-p_move) * w(r)(c) ) } var p: Seq[Seq[Double]] = { val cnt = colors.size * colors(0).size for (r <- 0 until colors.size) yield for (c <- 0 until colors(r).size) yield 1d/cnt } for (i <- 0 until measurements.size) { p = move(p, motions(i)) p = sense(p, measurements(i)) } show(p) }

def shiftL[A](i:List[A], c:Int) : List[A] = { val m = abs(c) % i.size val s = c match { case f if f > 0 => m case s if s < 0 => i.size - m case _ => 0 } i.slice(s % l.size, l.size) ++ i.slice(0, s % i.size) } val l = List(1, 2, 3, 4, 5, 6, 7, "A", "B", "C", "D") val ml3 = List(4, 5, 6, 7, "A", "B", "C", "D", 1, 2, 3) val ml10 = List("D", 1, 2, 3, 4, 5, 6, 7, "A", "B", "C") val ml15 = List(5, 6, 7, "A", "B", "C", "D", 1, 2, 3, 4) val mr3 = List("B", "C", "D", 1, 2, 3, 4, 5, 6, 7, "A") assert(ml3 == shiftL(l, 3)) assert(ml10 == shiftL(l, 10)) assert(ml15 == shiftL(l, 15)) assert(l == shiftL(l, 0)) assert(mr3 == shiftL(l, -3))

object RobotSense extends App { abstract class State case class Red extends State case class Green extends State val world: List[State] = List(Green(), Red(), Red(), Green(), Green()) val (pHit, pMiss) = (0.6, 0.2) val pExact = 0.8 val pOvershoot = 0.1 val pUndershoot = 0.1 def sense(p: List[Double], m: State): List[Double] = { val tmp = for (i <- 0 until world.size) yield if (world(i) == m) p(i) * pHit else p(i) * pMiss // Normalize tmp.map(_ / tmp.sum).toList } var p = List(0.2, 0.2, 0.2, 0.2, 0.2) List(Red(), Green()) foreach (m => p = sense(p, m)) println(p) }

I'm done with CS373, having implemented some quite nice algorithms that can be used to real-life robot navigation and after a surprisingly well done final exam (my hopes weren't so high after the AI class, so I'm positively surprised). It was so fun I signed up for two more classes starting April 16. - Applied Cryptography and Design of Computer Programs. Can't wait to have moar edjuukation.

With the material provided I'm basically ready to build a small self-navigating robot, so I hope my Pololu 3pi will get some use soon.

These two classes together seem like they'll be alot of work, but I can already tell I'll be glad at the end of the summer that I did decide to take them if not a little sleep deprived.