abstracted complex lang and extracted double lang

Author: gregor-i

math-parser-spire/src/main/scala/mathParser/algebra/SpireLanguage.scala

@@ -4,6 +4,7 @@ package algebra
 import spire.algebra.{Field, NRoot, Trig}
 
 import scala.util.Try
+import mathParser.AbstractSyntaxTree.*
 
 object SpireLanguage {
 

math-parser/src/main/scala/mathParser/BuildIn.scala

@@ -0,0 +1,15 @@
+package mathParser
+
+import mathParser.boolean.{BooleanBinaryOperator, BooleanLanguage, BooleanUnitaryOperator}
+import mathParser.number.{Complex, ComplexLanguage, DoubleLanguage, NumberBinaryOperator, NumberUnitaryOperator}
+
+object BuildIn {
+  val booleanLanguage: Language[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, Nothing] =
+    BooleanLanguage()
+
+  val doubleLanguage: Language[NumberUnitaryOperator, NumberBinaryOperator, Double, Nothing] =
+    DoubleLanguage()
+
+  val complexLanguage: Language[NumberUnitaryOperator, NumberBinaryOperator, Complex, Nothing] =
+    ComplexLanguage()
+}

math-parser/src/main/scala/mathParser/MathParser.scala

@@ -1,6 +1,5 @@
 package mathParser.boolean
 
-
 enum BooleanUnitaryOperator(val name: String):
   case Not extends BooleanUnitaryOperator("!")
 

math-parser/src/main/scala/mathParser/boolean/BooleanOperators.scala

@@ -1,9 +1,11 @@
-package mathParser.complex
+package mathParser.number
 
 case class Complex(real: Double, imag: Double)
 
 object Complex {
   val e  = Complex(Math.E, 0.0)
   val pi = Complex(Math.PI, 0.0)
   val i  = Complex(0.0, 1.0)
+
+  given Number[Complex] = Number.contraMap(real => Complex(real, 0.0))
 }

math-parser/src/main/scala/mathParser/complex/ComplexLanguage.scala

@@ -1,15 +1,15 @@
-package mathParser.complex
+package mathParser.number
 
 import mathParser.Evaluate
 
-import ComplexBinaryOperator.*
-import ComplexUnitaryOperator.*
+import NumberBinaryOperator.*
+import NumberUnitaryOperator.*
 
-final class ComplexEvaluate[V] extends Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
+final class ComplexEvaluate[V] extends Evaluate[NumberUnitaryOperator, NumberBinaryOperator, Complex, V] {
 
   import Math._
 
-   def executeUnitary(uo: ComplexUnitaryOperator, a: Complex): Complex = uo match {
+   def executeUnitary(uo: NumberUnitaryOperator, a: Complex): Complex = uo match {
     case Neg  => complexNeg(a)
     case Sin  => complexSin(a)
     case Cos  => complexCos(a)
@@ -24,7 +24,7 @@ final class ComplexEvaluate[V] extends Evaluate[ComplexUnitaryOperator, ComplexB
     case Log  => complexLog(a)
   }
 
-   def executeBinaryOperator(bo: ComplexBinaryOperator, a: Complex, b: Complex): Complex =
+   def executeBinaryOperator(bo: NumberBinaryOperator, a: Complex, b: Complex): Complex =
     bo match {
       case Plus    => complexPlus(a, b)
       case Minus   => complexMinus(a, b)

math-parser/src/main/scala/mathParser/complex/ComplexOperators.scala

@@ -0,0 +1,23 @@
+package mathParser.number
+
+import mathParser._
+
+import NumberBinaryOperator.*
+import NumberUnitaryOperator.*
+import mathParser.number.NumberSyntax.*
+
+object ComplexLanguage {
+  def apply(): ComplexLanguage[Nothing] =
+    Language.emptyLanguage
+      .withConstants[Complex](List("e" -> Complex.e, "pi" -> Complex.pi, "i" -> Complex.i))
+      .withBinaryOperators[NumberBinaryOperator](prefix = List.empty, infix = List(Plus, Minus, Times, Divided, Power).map(op => (op.name, op)))
+      .withUnitaryOperators(List(Neg, Sin, Cos, Tan, Asin, Acos, Atan, Sinh, Cosh, Tanh, Exp, Log).map(op => (op.name, op)))
+
+  given LiteralParser[Complex] = _.toDoubleOption.map(Complex(_, 0.0))
+
+  given [V]: Evaluate[NumberUnitaryOperator, NumberBinaryOperator, Complex, V] = ComplexEvaluate[V]
+
+  given [V]: Optimizer[NumberUnitaryOperator, NumberBinaryOperator, Complex, V] = NumberOptimizer[Complex, V]
+
+  given [V]: Derive[NumberUnitaryOperator, NumberBinaryOperator, Complex, V] = NumberDerive[Complex, V]
+}

math-parser/src/main/scala/mathParser/complex/ComplexOptimize.scala

@@ -0,0 +1,32 @@
+package mathParser.number
+
+import mathParser.Evaluate
+
+final class DoubleEvaluate[V] extends Evaluate[NumberUnitaryOperator, NumberBinaryOperator, Double, V] {
+
+  import Math._
+
+   def executeUnitary(uo: NumberUnitaryOperator, a: Double): Double = uo match {
+    case Neg  => -a
+    case Sin  => sin(a)
+    case Cos  => cos(a)
+    case Tan  => tan(a)
+    case Asin => asin(a)
+    case Acos => acos(a)
+    case Atan => atan(a)
+    case Sinh => sinh(a)
+    case Cosh => cosh(a)
+    case Tanh => tanh(a)
+    case Exp  => exp(a)
+    case Log  => log(a)
+  }
+
+   def executeBinaryOperator(bo: NumberBinaryOperator, a: Double, b: Double): Double =
+    bo match {
+      case Plus    => a+b
+      case Minus   => a - b
+      case Times   => a * b
+      case Divided => a / b
+      case Power   => pow(a, b)
+    }
+}

math-parser/src/main/scala/mathParser/complex/package.scala

@@ -0,0 +1,20 @@
+package mathParser.number
+
+import mathParser._
+import mathParser.number.NumberSyntax
+
+object DoubleLanguage {
+  def apply(): Language[NumberUnitaryOperator, NumberBinaryOperator, Double, Nothing] =
+    Language.emptyLanguage
+      .withConstants[Double](List("e" -> Math.E, "pi" -> Math.PI))
+      .withBinaryOperators[NumberBinaryOperator](prefix = List.empty, infix = List(Plus, Minus, Times, Divided, Power).map(op => (op.name, op)))
+      .withUnitaryOperators(List(Neg, Sin, Cos, Tan, Asin, Acos, Atan, Sinh, Cosh, Tanh, Exp, Log).map(op => (op.name, op)))
+
+  given LiteralParser[Double] = _.toDoubleOption
+
+  given [V]: Evaluate[NumberUnitaryOperator, NumberBinaryOperator, Double, V] = DoubleEvaluate[V]
+
+  given [V]: Optimizer[NumberUnitaryOperator, NumberBinaryOperator, Double, V] = NumberOptimizer[Double, V]
+
+  given [V]: Derive[NumberUnitaryOperator, NumberBinaryOperator, Double, V] = NumberDerive[Double, V]
+}

math-parser/src/main/scala/mathParser/complex/syntax.scala

@@ -0,0 +1,26 @@
+package mathParser.number
+
+trait Number[S]:
+  def zero: S
+  def one: S
+  def two: S
+  def oneHalf: S
+
+object Number:
+  def zero[S](using number: Number[S]): S = number.zero
+  def one[S](using number: Number[S]): S = number.one
+  def two[S](using number: Number[S]): S = number.two
+  def oneHalf[S](using number: Number[S]):S = number.oneHalf
+
+  def contraMap[A, B](f: A => B)(using number: Number[A]): Number[B] =
+    new Number[B]:
+      def zero = f(number.zero)
+      def one = f(number.one)
+      def two = f(number.two)
+      def oneHalf = f(number.oneHalf)
+
+  given Number[Double] = new Number[Double]:
+    def zero = 0.0
+    def one = 1.0
+    def two = 2.0
+    def oneHalf = 0.5

math-parser/src/main/scala/mathParser/complex/Complex.scala renamed to math-parser/src/main/scala/mathParser/number/Complex.scala

@@ -1,14 +1,17 @@
-package mathParser.complex
+package mathParser.number
 
-import mathParser.{Derive}
-import mathParser.complex.ComplexUnitaryOperator.*
-import mathParser.complex.ComplexBinaryOperator.*
-import mathParser.complex.Syntax.*
-import mathParser.*
+import mathParser.{AbstractSyntaxTree, Derive}
+import mathParser.AbstractSyntaxTree.*
+import mathParser.number.NumberUnitaryOperator
+import mathParser.number.NumberBinaryOperator
+import mathParser.number.NumberSyntax.*
 
-class ComplexDerive[V] extends Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
-  def derive(term: ComplexNode[V])(variable: V): ComplexNode[V] = {
-    def derive(term: ComplexNode[V]): ComplexNode[V] = term match {
+class NumberDerive[S: Number, V] extends Derive[NumberUnitaryOperator, NumberBinaryOperator, S, V] {
+  def derive(term: AbstractSyntaxTree[NumberUnitaryOperator, NumberBinaryOperator, S, V])(variable: V): AbstractSyntaxTree[NumberUnitaryOperator, NumberBinaryOperator, S, V] = {
+    val zero = ConstantNode[NumberUnitaryOperator, NumberBinaryOperator, S, V](Number.zero[S])
+    val one = ConstantNode[NumberUnitaryOperator, NumberBinaryOperator, S, V](Number.one[S])
+
+    def derive(term: AbstractSyntaxTree[NumberUnitaryOperator, NumberBinaryOperator, S, V]): AbstractSyntaxTree[NumberUnitaryOperator, NumberBinaryOperator, S, V] = term match {
       case VariableNode(`variable`)          => one
       case VariableNode(_) | ConstantNode(_) => zero
       case UnitaryNode(op, f) =>

math-parser/src/main/scala/mathParser/complex/ComplexEvaluate.scala renamed to math-parser/src/main/scala/mathParser/number/ComplexEvaluate.scala

@@ -0,0 +1,25 @@
+package mathParser.number
+
+enum NumberUnitaryOperator(val name: String):
+  case Neg extends NumberUnitaryOperator("-")
+  case Sin extends NumberUnitaryOperator("sin")
+  case Cos extends NumberUnitaryOperator("cos")
+  case Tan extends NumberUnitaryOperator("tan")
+  case Asin extends NumberUnitaryOperator("asin")
+  case Acos extends NumberUnitaryOperator("acos")
+  case Atan extends NumberUnitaryOperator("atan")
+  case Sinh extends NumberUnitaryOperator("sinh")
+  case Cosh extends NumberUnitaryOperator("cosh")
+  case Tanh extends NumberUnitaryOperator("tanh")
+  case Exp extends NumberUnitaryOperator("exp")
+  case Log extends NumberUnitaryOperator("log")
+
+enum NumberBinaryOperator(val name: String):
+  case Plus extends NumberBinaryOperator("+")
+  case Minus extends NumberBinaryOperator("-")
+  case Times extends NumberBinaryOperator("*")
+  case Divided extends NumberBinaryOperator("/")
+  case Power extends NumberBinaryOperator("^")
+
+export NumberBinaryOperator.*
+export NumberUnitaryOperator.*