Log Run details and Refactor Random Actuator/Sensors (#80)

benderpremier · web-flow · commit 592d8a7f2aff · 2020-02-10T08:27:55.000-06:00
* reorganize type parameters

* update scalafmt

* fix formatting

* return run detail

* build unreliable sensor and actuators from reliable ones

* Actuator and Sensor signal failure by returning Optional value

* abstract randomness

* extract run details case class

* rename to AgentRunSummary

* scalafmt

* remove nopercept

* fix the unit test

* remove optional from actuator act method
diff --git a/core/src/main/scala/aima/core/agent/Actuator.scala b/core/src/main/scala/aima/core/agent/Actuator.scala
@@ -1,19 +1,23 @@
 package aima.core.agent
 
-import aima.core.random.Randomness
+import aima.core.random.{DefaultRandomness, Randomness}
 
 /**
   * @author Shawn Garner
   * @author Damien Favre
   */
 trait Actuator[ENVIRONMENT, ACTION] {
-  def act(action: ACTION, e: ENVIRONMENT): ENVIRONMENT //could be Action => E => E
+  def act(action: ACTION, e: ENVIRONMENT): ENVIRONMENT
 }
 
-trait UnreliableActuator[ENVIRONMENT, ACTION] extends Actuator[ENVIRONMENT, ACTION] with Randomness {
-  def unreliably(original: ENVIRONMENT, reliability: Int = 50)(
-      act: => ENVIRONMENT
-  ): ENVIRONMENT = {
-    if (rand.nextInt(100) < reliability) act else original
+object UnreliableActuator {
+  def fromActuator[ENVIRONMENT, ACTION](
+      actuator: Actuator[ENVIRONMENT, ACTION]
+  )(
+      reliability: Int = 50,
+      randomness: Randomness = new DefaultRandomness {}
+  ): Actuator[ENVIRONMENT, ACTION] = new Actuator[ENVIRONMENT, ACTION] {
+    override def act(action: ACTION, e: ENVIRONMENT): ENVIRONMENT =
+      randomness.unreliably(reliability)(actuator.act(action, e)).getOrElse(e)
   }
 }
diff --git a/core/src/main/scala/aima/core/agent/Agent.scala b/core/src/main/scala/aima/core/agent/Agent.scala
@@ -9,19 +9,24 @@ trait Agent[ENVIRONMENT, PERCEPT, ACTION] {
   def sensors: List[Sensor[ENVIRONMENT, PERCEPT]]
   def agentProgram: AgentProgram[PERCEPT, ACTION]
 
-  def run(e: ENVIRONMENT): ENVIRONMENT = {
-    val actions: Seq[ACTION] = for {
-      sensor <- sensors
-    } yield agentProgram.agentFunction(sensor.perceive(e))
+  def run(e: ENVIRONMENT): (ENVIRONMENT, AgentRunSummary[PERCEPT, ACTION]) = {
+    val percepts: List[PERCEPT] = sensors.flatMap(_.perceive(e))
+    val actions: List[ACTION]   = percepts.map(agentProgram.agentFunction)
 
-    actions.foldLeft(e) { (env, action) =>
+    val newEnvironment = actions.foldLeft(e) { (env, action) =>
       actuators.foldLeft(env) { (env2, actuator) =>
         actuator.act(action, env2)
       }
     }
+    (newEnvironment, AgentRunSummary(percepts, actions))
   }
 }
 
+case class AgentRunSummary[PERCEPT, ACTION](
+    percepts: List[PERCEPT],
+    actions: List[ACTION]
+)
+
 trait AgentProgram[PERCEPT, ACTION] {
   type AgentFunction = PERCEPT => ACTION
 
diff --git a/core/src/main/scala/aima/core/agent/Sensor.scala b/core/src/main/scala/aima/core/agent/Sensor.scala
@@ -1,13 +1,20 @@
 package aima.core.agent
 
-import aima.core.random.Randomness
+import aima.core.random.{DefaultRandomness, Randomness}
 
 trait Sensor[ENVIRONMENT, PERCEPT] {
-  def perceive(e: ENVIRONMENT): PERCEPT
+  def perceive(e: ENVIRONMENT): Option[PERCEPT]
 }
 
-trait UnreliableSensor[ENVIRONMENT, PERCEPT] extends Sensor[ENVIRONMENT, PERCEPT] with Randomness {
-  def unreliably(reliability: Int = 50)(perceive: => PERCEPT)(noPercept: PERCEPT): PERCEPT = {
-    if (rand.nextInt(100) < reliability) perceive else noPercept
+object UnreliableSensor {
+  def fromSensor[ENVIRONMENT, PERCEPT](
+      sensor: Sensor[ENVIRONMENT, PERCEPT]
+  )(
+      reliability: Int = 50,
+      randomness: Randomness = new DefaultRandomness {}
+  ): Sensor[ENVIRONMENT, PERCEPT] = new Sensor[ENVIRONMENT, PERCEPT] {
+    override def perceive(e: ENVIRONMENT): Option[PERCEPT] =
+      randomness.unreliably(reliability)(sensor.perceive(e)).flatten
   }
+
 }
diff --git a/core/src/main/scala/aima/core/environment/vacuum/SimpleReflexVacuumAgentProgram.scala b/core/src/main/scala/aima/core/environment/vacuum/SimpleReflexVacuumAgentProgram.scala
@@ -13,6 +13,5 @@ class SimpleReflexVacuumAgentProgram extends SimpleReflexAgentProgram[VacuumPerc
     case LocationAPercept => RightMoveAction
     case LocationBPercept => LeftMoveAction
     case CleanPercept     => NoAction
-    case NoPercept        => NoAction
   }
 }
diff --git a/core/src/main/scala/aima/core/environment/vacuum/VacuumEnvironment.scala b/core/src/main/scala/aima/core/environment/vacuum/VacuumEnvironment.scala
@@ -6,7 +6,8 @@ import aima.core.random.DefaultRandomness
 /**
   * @author Shawn Garner
   */
-case class VacuumEnvironment(map: VacuumMap = VacuumMap()) extends Environment[VacuumEnvironment, VacuumPercept, VacuumAction] {
+case class VacuumEnvironment(map: VacuumMap = VacuumMap())
+    extends Environment[VacuumEnvironment, VacuumPercept, VacuumAction] {
 
   def addAgent(agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction]): VacuumEnvironment = {
     VacuumEnvironment(map.addAgent(agent))
@@ -26,7 +27,9 @@ case class VacuumMapNode(
     maybeAgent: Option[Agent[VacuumEnvironment, VacuumPercept, VacuumAction]] = None
 )
 
-case class VacuumMap(nodes: Vector[VacuumMapNode] = Vector.fill(2)(VacuumMapNode())) extends DefaultRandomness {
+case class VacuumMap(
+    nodes: Vector[VacuumMapNode] = Vector.fill(2)(VacuumMapNode())
+) extends DefaultRandomness {
   self =>
 
   def isClean(): Boolean = {
@@ -38,10 +41,11 @@ case class VacuumMap(nodes: Vector[VacuumMapNode] = Vector.fill(2)(VacuumMapNode
     }
   }
 
-  def getAgentNode(agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction]): Option[VacuumMapNode] = nodes.collectFirst {
-    case VacuumMapNode(dirtStatus, Some(a)) if agent == a =>
-      VacuumMapNode(dirtStatus, Some(a))
-  }
+  def getAgentNode(agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction]): Option[VacuumMapNode] =
+    nodes.collectFirst {
+      case VacuumMapNode(dirtStatus, Some(a)) if agent == a =>
+        VacuumMapNode(dirtStatus, Some(a))
+    }
   def getDirtStatus(agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction]): Option[VacuumPercept] =
     getAgentNode(agent).map(_.dirtStatus)
 
@@ -81,13 +85,18 @@ case class VacuumMap(nodes: Vector[VacuumMapNode] = Vector.fill(2)(VacuumMapNode
     VacuumMap(updatedNodes)
   }
 
-  def updateStatus(agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction], dirtStatusPercepts: DirtPercept): VacuumMap =
+  def updateStatus(
+      agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction],
+      dirtStatusPercepts: DirtPercept
+  ): VacuumMap =
     updateByAgent(agent)(vacuumMapNode => vacuumMapNode.copy(dirtStatus = dirtStatusPercepts))
 
   def removeAgent(agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction]): VacuumMap =
     updateByAgent(agent)(vacuumMapNode => vacuumMapNode.copy(maybeAgent = None))
 
-  private def updateByIndex(index: Int)(f: VacuumMapNode => VacuumMapNode): VacuumMap = {
+  private def updateByIndex(
+      index: Int
+  )(f: VacuumMapNode => VacuumMapNode): VacuumMap = {
     val node         = nodes.apply(index)
     val updatedNodes = nodes.updated(index, f(node))
     VacuumMap(updatedNodes)
diff --git a/core/src/main/scala/aima/core/environment/vacuum/actuators.scala b/core/src/main/scala/aima/core/environment/vacuum/actuators.scala
@@ -1,34 +1,23 @@
 package aima.core.environment.vacuum
 
-import aima.core.agent.{UnreliableActuator, Agent}
-import aima.core.random.DefaultRandomness
+import aima.core.agent.{Actuator, Agent}
 
 /**
   * @author Shawn Garner
   */
 class SuckerActuator(val agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction])
-    extends UnreliableActuator[VacuumEnvironment, VacuumAction]
-    with DefaultRandomness {
-  def act(action: VacuumAction, vacuum: VacuumEnvironment): VacuumEnvironment = {
-    unreliably(vacuum) {
-      action match {
-        case Suck =>
-          vacuum.copy(vacuum.map.updateStatus(agent, CleanPercept))
-        case _ => vacuum
-      }
-    }
+    extends Actuator[VacuumEnvironment, VacuumAction] {
+  def act(action: VacuumAction, vacuum: VacuumEnvironment): VacuumEnvironment = action match {
+    case Suck =>
+      vacuum.copy(vacuum.map.updateStatus(agent, CleanPercept))
+    case _ => vacuum
   }
 }
 class MoveActuator(val agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction])
-    extends UnreliableActuator[VacuumEnvironment, VacuumAction]
-    with DefaultRandomness { self =>
-  def act(action: VacuumAction, vacuum: VacuumEnvironment): VacuumEnvironment = {
-    unreliably(vacuum) {
-      action match {
-        case move: MoveAction =>
-          vacuum.copy(vacuum.map.moveAgent(agent, move))
-        case _ => vacuum
-      }
-    }
+    extends Actuator[VacuumEnvironment, VacuumAction] {
+  def act(action: VacuumAction, vacuum: VacuumEnvironment): VacuumEnvironment = action match {
+    case move: MoveAction =>
+      vacuum.copy(vacuum.map.moveAgent(agent, move))
+    case _ => vacuum
   }
 }
diff --git a/core/src/main/scala/aima/core/environment/vacuum/percepts.scala b/core/src/main/scala/aima/core/environment/vacuum/percepts.scala
@@ -22,5 +22,3 @@ case object DirtyPercept extends DirtPercept
 object DirtPercept extends SetRandomness[DirtPercept] with DefaultRandomness {
   lazy val valueSet: Set[DirtPercept] = Set(CleanPercept, DirtyPercept)
 }
-
-case object NoPercept extends VacuumPercept
diff --git a/core/src/main/scala/aima/core/environment/vacuum/sensors.scala b/core/src/main/scala/aima/core/environment/vacuum/sensors.scala
@@ -1,25 +1,18 @@
 package aima.core.environment.vacuum
 
-import aima.core.agent.{Environment, UnreliableSensor, Agent}
-import aima.core.random.DefaultRandomness
+import aima.core.agent.{Agent, Sensor}
 
 /**
   * @author Shawn Garner
   */
-class AgentLocationSensor(val agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction], noPercept: VacuumPercept)
-    extends UnreliableSensor[VacuumEnvironment, VacuumPercept]
-    with DefaultRandomness {
-  def perceive(vacuum: VacuumEnvironment): VacuumPercept =
-    unreliably() {
-      vacuum.map.getAgentLocation(agent).getOrElse(NoPercept)
-    }(noPercept)
+class AgentLocationSensor(val agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction])
+    extends Sensor[VacuumEnvironment, VacuumPercept] {
+  def perceive(vacuum: VacuumEnvironment): Option[VacuumPercept] =
+    vacuum.map.getAgentLocation(agent)
 }
 
-class DirtSensor(val agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction], noPercept: VacuumPercept)
-    extends UnreliableSensor[VacuumEnvironment, VacuumPercept]
-    with DefaultRandomness { self =>
-  def perceive(vacuum: VacuumEnvironment): VacuumPercept =
-    unreliably() {
-      vacuum.map.getDirtStatus(agent).getOrElse(NoPercept)
-    }(noPercept)
+class DirtSensor(val agent: Agent[VacuumEnvironment, VacuumPercept, VacuumAction])
+    extends Sensor[VacuumEnvironment, VacuumPercept] {
+  def perceive(vacuum: VacuumEnvironment): Option[VacuumPercept] =
+    vacuum.map.getDirtStatus(agent)
 }
diff --git a/core/src/main/scala/aima/core/random/Randomness.scala b/core/src/main/scala/aima/core/random/Randomness.scala
@@ -7,6 +7,9 @@ import scala.util.Random
   */
 trait Randomness {
   def rand: Random
+  def unreliably[A](reliability: Int = 50)(a: => A): Option[A] =
+    if (rand.nextInt(100) < reliability) Some(a)
+    else None
 }
 
 trait DefaultRandomness extends Randomness {
diff --git a/core/src/test/scala/aima/core/environment/vacuum/ModelBasedReflexVacuumAgentSpec.scala b/core/src/test/scala/aima/core/environment/vacuum/ModelBasedReflexVacuumAgentSpec.scala
@@ -24,7 +24,7 @@ class ModelBasedReflexVacuumAgentSpec extends Specification {
   "should assume dirty after moving to location B" in new context {
     agent.agentFunction.apply(LocationAPercept)
     agent.agentFunction.apply(CleanPercept)
-    agent.agentFunction.apply(NoPercept) must beLike {
+    agent.agentFunction.apply(LocationBPercept) must beLike {
       case Suck => ok
     }
   }
@@ -45,7 +45,7 @@ class ModelBasedReflexVacuumAgentSpec extends Specification {
   "should assume dirty after moving to location A" in new context {
     agent.agentFunction.apply(LocationBPercept)
     agent.agentFunction.apply(CleanPercept)
-    agent.agentFunction.apply(NoPercept) must beLike {
+    agent.agentFunction.apply(LocationAPercept) must beLike {
       case Suck => ok
     }
   }
diff --git a/core/src/test/scala/aima/core/environment/vacuum/ReflexVacuumAgentProgramSpec.scala b/core/src/test/scala/aima/core/environment/vacuum/ReflexVacuumAgentProgramSpec.scala
@@ -19,15 +19,15 @@ class ReflexVacuumAgentProgramSpec extends Specification with ScalaCheck {
       val agentProgram = new SimpleReflexVacuumAgentProgram
       val actuators    = List[Actuator[VacuumEnvironment, VacuumAction]](new SuckerActuator(this), new MoveActuator(this))
       lazy val sensors = List[Sensor[VacuumEnvironment, VacuumPercept]](
-        new DirtSensor(this, NoPercept),
-        new AgentLocationSensor(this, NoPercept)
+        new DirtSensor(this),
+        new AgentLocationSensor(this)
       )
     }
 
     @tailrec def eventuallyClean(currentEnv: VacuumEnvironment): Boolean = {
       currentEnv match {
         case ve: VacuumEnvironment if ve.isClean() => true
-        case _                          => eventuallyClean(agent.run(currentEnv))
+        case _                                     => eventuallyClean(agent.run(currentEnv)._1)
       }
     }
 
diff --git a/core/src/test/scala/aima/core/environment/vacuum/TableDrivenVacuumAgentSpec.scala b/core/src/test/scala/aima/core/environment/vacuum/TableDrivenVacuumAgentSpec.scala
@@ -11,7 +11,7 @@ import scala.util.Random
 class TableDrivenVacuumAgentSpec extends Specification {
 
   "first level dirty sucks" in new context {
-    invokeAgent(List(NoPercept, DirtyPercept)) must_== List(NoAction, Suck)
+    invokeAgent(List(LocationAPercept, DirtyPercept)) must_== List(NoAction, Suck)
   }
 
   "first level A and Clean moves Right" in new context {
@@ -23,43 +23,43 @@ class TableDrivenVacuumAgentSpec extends Specification {
   }
 
   "second level dirty sucks" in new context {
-    val givenPercepts   = List.fill(2)(NoPercept) ++ List(NoPercept, DirtyPercept)
+    val givenPercepts   = List.fill(2)(LocationAPercept) ++ List(LocationAPercept, DirtyPercept)
     val expectedActions = List.fill(2)(NoAction) ++ List(NoAction, Suck)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "second level A and Clean moves Right" in new context {
-    val givenPercepts   = List.fill(2)(NoPercept) ++ List(LocationAPercept, CleanPercept)
+    val givenPercepts   = List.fill(2)(LocationAPercept) ++ List(LocationAPercept, CleanPercept)
     val expectedActions = List.fill(2)(NoAction) ++ List(NoAction, RightMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "second level B and Clean moves Right" in new context {
-    val givenPercepts   = List.fill(2)(NoPercept) ++ List(LocationBPercept, CleanPercept)
+    val givenPercepts   = List.fill(2)(LocationAPercept) ++ List(LocationBPercept, CleanPercept)
     val expectedActions = List.fill(2)(NoAction) ++ List(NoAction, LeftMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "fourth level dirty sucks" in new context {
-    val givenPercepts   = List.fill(6)(NoPercept) ++ List(NoPercept, DirtyPercept)
+    val givenPercepts   = List.fill(6)(LocationAPercept) ++ List(LocationAPercept, DirtyPercept)
     val expectedActions = List.fill(6)(NoAction) ++ List(NoAction, Suck)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "fourth level A and Clean moves Right" in new context {
-    val givenPercepts   = List.fill(6)(NoPercept) ++ List(LocationAPercept, CleanPercept)
+    val givenPercepts   = List.fill(6)(LocationAPercept) ++ List(LocationAPercept, CleanPercept)
     val expectedActions = List.fill(6)(NoAction) ++ List(NoAction, RightMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "fourth level B and Clean moves Right" in new context {
-    val givenPercepts   = List.fill(6)(NoPercept) ++ List(LocationBPercept, CleanPercept)
+    val givenPercepts   = List.fill(6)(LocationAPercept) ++ List(LocationBPercept, CleanPercept)
     val expectedActions = List.fill(6)(NoAction) ++ List(NoAction, LeftMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "twenty dirty percepts is undefined because out of table definition range" in new context {
-    val givenPercepts   = List.fill(20)(NoPercept)
+    val givenPercepts   = List.fill(20)(LocationAPercept)
     val expectedActions = List.fill(20)(NoAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
@@ -70,10 +70,8 @@ class TableDrivenVacuumAgentSpec extends Specification {
       val selector = rnd.nextInt(3)
       if (selector == 0)
         LocationPercept.randomValue
-      else if (selector == 1)
-        DirtPercept.randomValue
       else
-        NoPercept
+        DirtPercept.randomValue
     }
 
     val givenPercepts = randomPerceptStream.take(100).toList
diff --git a/project/dependencies.scala b/project/dependencies.scala
@@ -4,12 +4,15 @@ import org.portablescala.sbtplatformdeps.PlatformDepsPlugin.autoImport._
 import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._
 
 object dependencies {
-  val specs2 = "4.8.1"
+  val specs2     = "4.8.1"
   val scalacheck = "1.14.2"
 
-  def commonDependencies =  Seq(libraryDependencies ++=  Seq(
-    "org.specs2"     %%% "specs2-core"       % specs2  % Test,
-    "org.specs2"     %%% "specs2-scalacheck" % specs2   % Test,
-    "org.scalacheck" %%% "scalacheck"        % scalacheck  % Test
-  ))
+  def commonDependencies =
+    Seq(
+      libraryDependencies ++= Seq(
+        "org.specs2"     %%% "specs2-core"       % specs2 % Test,
+        "org.specs2"     %%% "specs2-scalacheck" % specs2 % Test,
+        "org.scalacheck" %%% "scalacheck"        % scalacheck % Test
+      )
+    )
 }

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,5 @@ class SimpleReflexVacuumAgentProgram extends SimpleReflexAgentProgram[VacuumPerc`
`13`	`13`	`case LocationAPercept => RightMoveAction`
`14`	`14`	`case LocationBPercept => LeftMoveAction`
`15`	`15`	`case CleanPercept => NoAction`
`16`		`- case NoPercept => NoAction`
`17`	`16`	`}`
`18`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,5 +22,3 @@ case object DirtyPercept extends DirtPercept`
`22`	`22`	`object DirtPercept extends SetRandomness[DirtPercept] with DefaultRandomness {`
`23`	`23`	`lazy val valueSet: Set[DirtPercept] = Set(CleanPercept, DirtyPercept)`
`24`	`24`	`}`
`25`		`-`
`26`		`-case object NoPercept extends VacuumPercept`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,9 @@ import scala.util.Random`
`7`	`7`	`*/`
`8`	`8`	`trait Randomness {`
`9`	`9`	`def rand: Random`
	`10`	`+ def unreliably[A](reliability: Int = 50)(a: => A): Option[A] =`
	`11`	`+ if (rand.nextInt(100) < reliability) Some(a)`
	`12`	`+ else None`
`10`	`13`	`}`
`11`	`14`
`12`	`15`	`trait DefaultRandomness extends Randomness {`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ class ModelBasedReflexVacuumAgentSpec extends Specification {`
`24`	`24`	`"should assume dirty after moving to location B" in new context {`
`25`	`25`	`agent.agentFunction.apply(LocationAPercept)`
`26`	`26`	`agent.agentFunction.apply(CleanPercept)`
`27`		`- agent.agentFunction.apply(NoPercept) must beLike {`
	`27`	`+ agent.agentFunction.apply(LocationBPercept) must beLike {`
`28`	`28`	`case Suck => ok`
`29`	`29`	`}`
`30`	`30`	`}`
`@@ -45,7 +45,7 @@ class ModelBasedReflexVacuumAgentSpec extends Specification {`
`45`	`45`	`"should assume dirty after moving to location A" in new context {`
`46`	`46`	`agent.agentFunction.apply(LocationBPercept)`
`47`	`47`	`agent.agentFunction.apply(CleanPercept)`
`48`		`- agent.agentFunction.apply(NoPercept) must beLike {`
	`48`	`+ agent.agentFunction.apply(LocationAPercept) must beLike {`
`49`	`49`	`case Suck => ok`
`50`	`50`	`}`
`51`	`51`	`}`