Evaluating Expressions in Scala - scala

Question

I am a bit new to scala and I have a program here that does everything I would like it to, except one thing I cannot seem to figure out. I Have expressions and I simplify the expression based on a few simple math rules.Then I prompt the user for bindings to variables and substitutes the variables with integers the user types in and then the expression is evaluated. That all works like I want it to. However I still want to simplify/evaluate the expression when I do not substitute a specific variable for an integer. I just simply evaluate the expression without asking the user for a value for x and I remove the statement for replacing x in my Environment for example. The problem is I get a scala.Match error when the eval method calls the env when it hits the x in my expression. To maybe make it clearer what I am trying to do is with the expression in my example.. Expression: (x + (x * (y - (z / 2)))) by only substituting the variables y and z with 2, the result I would like to see is (x + x). I would appreciate any advice/help possible! My program at this point looks like this:
var n1 = 0
var n2 = 0
var n3 = 0
type Environment = String => Int
lazy val exp: Tree = Sum(Var("x"), Times(Var("x"), Minus(Var("y"), Divide(Var("z"), Const(2)))))
lazy val env: Environment = {
case "x" => n1 //take this line out to not bind x
case "y" => n2
case "z" => n3
}
abstract class Tree
case class Sum(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " + " + r + ")"
}
case class Minus(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " - " + r + ")"
}
case class Times(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " * " + r + ")"
}
case class Divide(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " / " + r + ")"
}
case class Var(n: String) extends Tree {
override def toString = n
}
case class Const(v: Int) extends Tree {
override def toString = v.toString
}
def simplify(t: Tree): Tree = t match {
case Times(Const(1), r) => simplify(r)
case Times(l, Const(1)) => simplify(l)
case Times(Const(0), r) => Const(0)
case Times(l, Const(0)) => Const(0)
case Sum(Const(0), r) => simplify(r)
case Sum(l, Const(0)) => simplify(l)
case Minus(l, Const(0)) => simplify(l)
case Minus(l, r) if l == r => Const(0)
case Divide(Const(0), r) => Const(0)
case Divide(l, Const(1)) => simplify(l)
case Divide(l, r) if l == r => Const(1)
case Times(l, r) => Times(simplify(l), simplify(r))
case Sum(l, r) => Sum(simplify(l), simplify(r))
case Minus(l, r) => Minus(simplify(l), simplify(r))
case Divide(l, r) => Divide(simplify(l), simplify(r))
case _ => t
}
def eval(t: Tree): Int = t match {
case Sum(l, r) => eval(l) + eval(r)
case Minus(l, r) => eval(l) - eval(r)
case Times(l, r) => eval(l) * eval(r)
case Divide(l, r) => eval(l) / eval(r)
case Var(n) => env(n)
case Const(v) => v
}
println("Expression: " + exp)
println("Simplified: " + simplify(exp))
println("Enter the binding for x.") //take this line out to not bind x
n1 = readInt() //take this line out to not bind x
println("Enter the binding for y.")
n2 = readInt()
println("Enter the binding for z.")
n3 = readInt()
println("Evaluation: " + eval(exp))

Answer 1

Here is a relatively clean solution. I've only included the pieces I modified.
type Environment = String => Option[Int]
lazy val env: Environment = {
case "y" => Some(n2)
case "z" => Some(n3)
case _ => None
}
def simplify(t: Tree): Tree = {
val reducedTree = t match {
case Times(l, r) => Times(simplify(l), simplify(r))
case Sum(l, r) => Sum(simplify(l), simplify(r))
case Minus(l, r) => Minus(simplify(l), simplify(r))
case Divide(l, r) => Divide(simplify(l), simplify(r))
case Var(n) => env(n).map(Const).getOrElse(t)
case _ => t
}
reducedTree match {
case Times(Const(1), r) => r
case Times(l, Const(1)) => l
case Times(Const(0), r) => Const(0)
case Times(l, Const(0)) => Const(0)
case Times(Const(l), Const(r)) => Const(l * r)
case Sum(Const(0), r) => r
case Sum(l, Const(0)) => l
case Sum(Const(l), Const(r)) => Const(l + r)
case Minus(l, Const(0)) => l
case Minus(l, r) if l == r => Const(0)
case Minus(Const(l), Const(r)) => Const(l - r)
case Divide(Const(0), r) => Const(0)
case Divide(l, Const(1)) => l
case Divide(l, r) if l == r => Const(1)
case Divide(Const(l), Const(r)) => Const(l / r)
case _ => reducedTree
}
}

Answer 2

I changed your code a little bit to make it work as you want:
abstract class Tree
case class Sum(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " + " + r + ")"
}
case class Minus(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " - " + r + ")"
}
case class Times(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " * " + r + ")"
}
case class Divide(l: Tree, r: Tree) extends Tree {
override def toString = "(" + l + " / " + r + ")"
}
case class Var(n: String) extends Tree {
override def toString = n
}
case class Const(v: Int) extends Tree {
override def toString = v.toString
}
object ExprEval {
lazy val exp: Tree = Sum(Var("x"), Times(Var("x"), Minus(Var("y"), Divide(Var("z"), Const(2)))))
var env = Map[String, Int]()
def simplify(t: Tree, recursive : Boolean = true): Tree = {
t match {
case Sum(Const(0), r) => simplify(r)
case Sum(l, Const(0)) => simplify(l)
case Sum(Const(l), Const(r)) => Const(l + r)
case Sum(Var(l), Var(r)) if l == r => Times(Const(2), Var(l))
case Sum(l, r) if recursive => simplify(Sum(simplify(l), simplify(r)), recursive = false)
case Minus(l, Const(0)) => simplify(l)
case Minus(l, r) if l == r => Const(0)
case Minus(Const(l), Const(r)) => Const(l - r)
case Minus(l, r) if recursive => simplify(Minus(simplify(l), simplify(r)), recursive = false)
case Times(Const(1), r) => simplify(r)
case Times(l, Const(1)) => simplify(l)
case Times(Const(0), r) => Const(0)
case Times(l, Const(0)) => Const(0)
case Times(Const(l), Const(r)) => Const(l * r)
case Times(l, r) if recursive => simplify(Times(simplify(l), simplify(r)), recursive = false)
case Divide(Const(0), r) => Const(0)
case Divide(l, Const(1)) => simplify(l)
case Divide(l, r) if l == r => Const(1)
case Divide(Const(l), Const(r)) => Const(l / r)
case Divide(l, r) if recursive => simplify(Divide(simplify(l), simplify(r)), recursive = false)
case Var(n) => env.get(n).map(Const).getOrElse(Var(n))
case _ => t
}
}
def eval(t: Tree): Int = t match {
case Sum(l, r) => eval(l) + eval(r)
case Minus(l, r) => eval(l) - eval(r)
case Times(l, r) => eval(l) * eval(r)
case Divide(l, r) => eval(l) / eval(r)
case Var(n) => env(n)
case Const(v) => v
}
def main(args: Array[String]) {
env = Map()
println(s"env: $env, exp : $exp, simplified : ${simplify(exp)}")
env = Map("y" -> 2, "z" -> 2)
println(s"env: $env, exp : $exp, simplified : ${simplify(exp)}")
env = Map("z" -> 4)
println(s"env: $env, exp : $exp, simplified : ${simplify(exp)}")
env = Map("x" -> 3, "y" -> 2, "z" -> 2)
println(s"env: $env, exp : $exp, simplified : ${simplify(exp)}")
}
}
If no variables are bound, it returns a simplified original expression tree. If all variables are bound, it produces the same result as eval().
Output:
env: Map(), exp : (x + (x * (y - (z / 2)))), simplified : (x + (x * (y - (z / 2))))
env: Map(y -> 2, z -> 2), exp : (x + (x * (y - (z / 2)))), simplified : (2 * x)
env: Map(z -> 4), exp : (x + (x * (y - (z / 2)))), simplified : (x + (x * (y - 2)))
env: Map(x -> 3, y -> 2, z -> 2), exp : (x + (x * (y - (z / 2)))), simplified : 6