fork download
copy 
  1. object SymbolicExpressions {
  2.  
  3. 	object ExpressionType extends Enumeration {
  4. 		val Constant, Variable, Operator = Value
  5. 		type ExpressionType = Value
  6. 	}
  7.  
  8. 	case class Expression(expressionType: ExpressionType.ExpressionType, index: Int)
  9.  
  10. 	trait Variable
  11. 	def Variable = new Variable {}
  12.  
  13. 	object OperatorType extends Enumeration {
  14. 		val Plus, Minus, Multiply, Divide = Value
  15. 		type OperatorType = Value
  16. 	}
  17.  
  18. 	case class Operator(operatorType: OperatorType.OperatorType, a: Expression, b: Expression)
  19.  
  20. 	case class ConstantStore(constants: Array[Float], var count: Int)
  21. 	def constantStore(size: Int) = ConstantStore(Array.ofDim(size), 0)
  22.  
  23. 	case class VariableStore(variables: Array[Variable], var count: Int)
  24. 	def variableStore(size: Int) = VariableStore(Array.ofDim(size), 0)
  25.  
  26. 	case class OperatorStore(operators: Array[Operator], var count: Int)
  27. 	def operatorStore(size: Int) = OperatorStore(Array.ofDim(size), 0)
  28.  
  29. 	case class Environment(
  30. 		constantStore: ConstantStore,
  31. 		variableStore: VariableStore,
  32. 		operatorStore: OperatorStore
  33. 	)
  34.  
  35. 	def constant(environment: Environment, value: Float) = {
  36. 		val store = environment.constantStore
  37. 		val count = store.count
  38. 		if(count < store.constants.length) {
  39. 			store.constants(count) = value
  40. 			store.count += 1
  41. 			Expression(ExpressionType.Constant, count)
  42. 		}
  43. 		else {
  44. 			Expression(ExpressionType.Constant, -1)
  45. 		}
  46. 	}
  47.  
  48. 	def variable(environment: Environment, variable: Variable) = {
  49. 		val store = environment.variableStore
  50. 		val count = store.count
  51. 		if(count < store.variables.length) {
  52. 			store.variables(count) = variable
  53. 			store.count += 1
  54. 			Expression(ExpressionType.Variable, count)
  55. 		}
  56. 		else {
  57. 			Expression(ExpressionType.Variable, -1)
  58. 		}
  59. 	}
  60.  
  61. 	def operator(environment: Environment, operator: Operator) = {
  62. 		val store = environment.operatorStore
  63. 		val count = store.count
  64. 		if(count < store.operators.length) {
  65. 			store.operators(count) = operator
  66. 			store.count += 1
  67. 			Expression(ExpressionType.Operator, count)
  68. 		}
  69. 		else {
  70. 			Expression(ExpressionType.Operator, -1)
  71. 		}
  72. 	}
  73.  
  74. 	def plus(environment: Environment, a: Expression, b: Expression) =
  75. 		operator(environment, Operator(OperatorType.Plus, a, b))
  76.  
  77. 	def minus(environment: Environment, a: Expression, b: Expression) =
  78. 		operator(environment, Operator(OperatorType.Minus, a, b))
  79.  
  80. 	def multiply(environment: Environment, a: Expression, b: Expression) =
  81. 		operator(environment, Operator(OperatorType.Multiply, a, b))
  82.  
  83. 	def divide(environment: Environment, a: Expression, b: Expression) =
  84. 		operator(environment, Operator(OperatorType.Divide, a, b))
  85.  
  86. 	def result(environment: Environment, expression: Expression, context: Map[Variable, Float]): Float = {
  87. 		expression.expressionType match {
  88. 			case ExpressionType.Constant =>
  89. 				environment.constantStore.constants(expression.index)
  90.  
  91. 			case ExpressionType.Variable =>
  92. 				context(environment.variableStore.variables(expression.index))
  93.  
  94. 			case ExpressionType.Operator =>
  95. 				val operator = environment.operatorStore.operators(expression.index)
  96. 				operator.operatorType match {
  97. 					case OperatorType.Plus =>
  98. 						result(environment, operator.a, context) +
  99. 							result(environment, operator.b, context)
  100.  
  101. 					case OperatorType.Minus =>
  102. 						result(environment, operator.a, context) -
  103. 							result(environment, operator.b, context)
  104.  
  105. 					case OperatorType.Multiply =>
  106. 						result(environment, operator.a, context) *
  107. 							result(environment, operator.b, context)
  108.  
  109. 					case OperatorType.Divide =>
  110. 						result(environment, operator.a, context) /
  111. 							result(environment, operator.b, context)
  112. 				}
  113. 		}
  114. 	}
  115.  
  116. }
  117.  
  118. object Main extends App {
  119. 	import SymbolicExpressions._
  120.  
  121. 	val env = Environment(constantStore(10), variableStore(10), operatorStore(10))
  122.  
  123. 	val a = Variable
  124. 	val b = Variable
  125. 	val c = Variable
  126. 	val d = Variable
  127.  
  128. 	val expression = plus(env,
  129. 		minus(env,
  130. 			multiply(env,
  131. 				divide(env,
  132. 					variable(env, a),
  133. 					variable(env, b)
  134. 				),
  135. 				variable(env, c)
  136. 			),
  137. 			variable(env, d)
  138. 		),
  139. 		constant(env, 5f)
  140. 	)
  141.  
  142. 	val context = Map(a -> 1f, b -> 2f, c -> 3f, d -> 4f)
  143. 	println(result(env, expression, context))
  144. }
Success #stdin #stdout 0.44s 322432KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
2.5
https://ideone.com/56NChM
language:
Scala (scala 2.12.8)
created:
8 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!