Skip to content

Commit 3856c50

Browse files
gregor-igregor-i
committed
updates for scala3 syntax
1 parent 4d2d925 commit 3856c50

25 files changed

+96
-95
lines changed

‎examples/src/main/scala/Readme.scala

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
import mathParser.SpireImplicits.given
2+
13
object Readme extends App {
24
// your input, any string represesenting a function:
35
val string = "2*x*x + 1"
@@ -6,8 +8,7 @@ object Readme extends App {
68

79
// define your language:
810
object X
9-
val language = mathParser.SpireLanguages.doubleLanguage
10-
.withVariables(List("x" -> X))
11+
val language = mathParser.SpireLanguages.doubleLanguage.withVariables(List("x" -> X))
1112

1213
// parsing: string => Option[AST]
1314
// .get only to demonstrate.

‎examples/src/main/scala/plotter/FunctionPlotterCli.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package plotter
22

33
import de.sciss.chart.api._
4-
import mathParser.SpireImplicits._
4+
import mathParser.SpireImplicits.given
55
import org.jfree.chart.ChartPanel
66

77
import java.io.File

‎math-parser-spire/src/main/scala/mathParser/algebra/SpireImplicits.scala

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4,15 +4,15 @@ import mathParser.{Derive, Evaluate, LiteralParser, Optimizer}
44
import spire.algebra.{Field, NRoot, Trig}
55

66
trait SpireImplicits extends spire.std.DoubleInstances {
7-
implicit final def spireLiteralParser[A: Field]: LiteralParser[A] =
7+
given spireLiteralParser[A: Field]: LiteralParser[A] =
88
SpireLanguage.spireLiteralParser
99

10-
implicit final def spireEvaluate[A: Field: NRoot: Trig, V]: Evaluate[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
10+
given spireEvaluate[A: Field: NRoot: Trig, V]: Evaluate[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
1111
SpireLanguage.spireEvaluate
1212

13-
implicit final def spireOptimizer[A: Field: NRoot: Trig, V]: Optimizer[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
13+
given spireOptimizer[A: Field: NRoot: Trig, V]: Optimizer[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
1414
SpireLanguage.spireOptimizer
1515

16-
implicit final def spireDerive[A: Field: Trig: NRoot, V]: Derive[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
16+
given spireDerive[A: Field: Trig: NRoot, V]: Derive[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
1717
SpireLanguage.spireDerive
1818
}

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ object SpireLanguage {
4646
def spireOptimizer[A: Field: NRoot: Trig, V]: Optimizer[SpireUnitaryOperator, SpireBinaryOperator, A, V] =
4747
new Optimizer[SpireUnitaryOperator, SpireBinaryOperator, A, V] {
4848
override def rules: List[PartialFunction[SpireNode[A, V], SpireNode[A, V]]] = List(
49-
Optimize.replaceConstantsRule[SpireUnitaryOperator, SpireBinaryOperator, A, V](spireEvaluate), {
49+
Optimize.replaceConstantsRule(using spireEvaluate), {
5050
case UnitaryNode(Neg, UnitaryNode(Neg, child)) => child
5151
case BinaryNode(Plus, left, ConstantNode(0d)) => left
5252
case BinaryNode(Plus, ConstantNode(0d), right) => right
@@ -118,7 +118,7 @@ object SpireLanguage {
118118

119119
def sqrt[A: Field: Trig: NRoot, V](t: SpireNode[A, V]): SpireNode[A, V] = BinaryNode(Power, t, ConstantNode(Field[A].fromDouble(0.5)))
120120

121-
implicit class EnrichNode[A: Field: Trig: NRoot, V](t1: SpireNode[A, V]) {
121+
extension [A: Field: Trig: NRoot, V](t1: SpireNode[A, V]) {
122122
def +(t2: SpireNode[A, V]): SpireNode[A, V] = BinaryNode(Plus, t1, t2)
123123
def -(t2: SpireNode[A, V]): SpireNode[A, V] = BinaryNode(Minus, t1, t2)
124124
def *(t2: SpireNode[A, V]): SpireNode[A, V] = BinaryNode(Times, t1, t2)

‎math-parser-spire/src/test/scala/mathParser/algebra/DeriveSpec.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package mathParser.algebra
22

3-
import mathParser.SpireImplicits._
3+
import mathParser.SpireImplicits.given
44
import mathParser.SpireLanguages
55
import org.scalatest.funsuite.AnyFunSuite
66
import org.scalatest.matchers.should.Matchers

‎math-parser-spire/src/test/scala/mathParser/algebra/OptimizationSpec.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package mathParser.algebra
22

3-
import mathParser.SpireImplicits._
3+
import mathParser.SpireImplicits.given
44
import mathParser.{LiteralParser, SpireLanguages}
55
import org.scalatest.funsuite.AnyFunSuite
66
import org.scalatest.matchers.should.Matchers

‎math-parser-spire/src/test/scala/mathParser/algebra/ParseComplexSpec.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package mathParser.algebra
22

3-
import mathParser.SpireImplicits._
3+
import mathParser.SpireImplicits.given
44
import mathParser.SpireLanguages
55
import org.scalatest.funsuite.AnyFunSuite
66
import org.scalatest.matchers.should.Matchers

‎math-parser-spire/src/test/scala/mathParser/algebra/ParseSpec.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package mathParser.algebra
22

3-
import mathParser.SpireImplicits._
3+
import mathParser.SpireImplicits.given
44
import mathParser.algebra.SpireLanguage.syntax._
55
import mathParser.{ConstantNode, LiteralParser, SpireLanguages}
66
import org.scalatest.funsuite.AnyFunSuite

‎math-parser-spire/src/test/scala/mathParser/algebra/TimedParseSpec.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package mathParser.algebra
22

3-
import mathParser.SpireImplicits._
3+
import mathParser.SpireImplicits.given
44
import mathParser.{LiteralParser, SpireLanguages}
55
import org.scalatest.concurrent.TimeLimitedTests
66
import org.scalatest.funsuite.AnyFunSuite

‎math-parser/src/main/scala/mathParser/Implicits.scala

Lines changed: 0 additions & 3 deletions
This file was deleted.

‎math-parser/src/main/scala/mathParser/Language.scala

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ package mathParser
22

33
import scala.util.Try
44

5-
case class Language[UO, BO, S, V](
5+
final case class Language[UO, BO, S, V](
66
unitaryOperators: List[(String, UO)],
77
binaryPrefixOperators: List[(String, BO)],
88
binaryInfixOperators: List[(String, BO)],
@@ -42,19 +42,19 @@ case class Language[UO, BO, S, V](
4242

4343
def constantNode(value: S): ConstantNode[UO, BO, S, V] = ConstantNode(value)
4444

45-
def parse(term: String)(implicit literalParser: LiteralParser[S]): Option[Node[UO, BO, S, V]] =
45+
def parse(term: String)(using literalParser: LiteralParser[S]): Option[Node[UO, BO, S, V]] =
4646
Parser.parse(this, literalParser)(term)
4747

48-
def evaluate(node: Node[UO, BO, S, V])(variableAssignment: V => S)(implicit evaluate: Evaluate[UO, BO, S, V]): S =
48+
def evaluate(node: Node[UO, BO, S, V])(variableAssignment: V => S)(using evaluate: Evaluate[UO, BO, S, V]): S =
4949
evaluate.evaluate(node)(variableAssignment)
5050

51-
def derive(node: Node[UO, BO, S, V])(variable: V)(implicit derive: Derive[UO, BO, S, V]): Node[UO, BO, S, V] =
51+
def derive(node: Node[UO, BO, S, V])(variable: V)(using derive: Derive[UO, BO, S, V]): Node[UO, BO, S, V] =
5252
derive.derive(node)(variable)
5353

54-
def optimize(node: Node[UO, BO, S, V])(implicit optimizer: Optimizer[UO, BO, S, V]): Node[UO, BO, S, V] =
54+
def optimize(node: Node[UO, BO, S, V])(using optimizer: Optimizer[UO, BO, S, V]): Node[UO, BO, S, V] =
5555
optimizer.optimize(node)
5656

57-
def compile[F](node: Node[UO, BO, S, V])(implicit compiler: Compiler[UO, BO, S, V, F]): Try[F] =
57+
def compile[F](node: Node[UO, BO, S, V])(using compiler: Compiler[UO, BO, S, V, F]): Try[F] =
5858
compiler.compile(node)
5959
}
6060

‎math-parser/src/main/scala/mathParser/LiteralParser.scala

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
11
package mathParser
22

3-
trait LiteralParser[S] {
3+
trait LiteralParser[S]:
44
def tryToParse(s: String): Option[S]
5-
}
65

7-
object NoLiterals extends LiteralParser[Nothing] {
8-
def tryToParse(s: String): None.type = None
9-
}
6+
object LiteralParser:
7+
given noLiterals: LiteralParser[Nothing] =
8+
new LiteralParser[Nothing]:
9+
def tryToParse(s: String): None.type = None

‎math-parser/src/main/scala/mathParser/Optimize.scala

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,10 @@ package mathParser
22

33
import scala.annotation.tailrec
44

5+
type OptimizationRule[UO, BO, S, V] = PartialFunction[Node[UO, BO, S, V], Node[UO, BO, S, V]]
6+
57
trait Optimizer[UO, BO, S, V] {
6-
def rules: List[PartialFunction[Node[UO, BO, S, V], Node[UO, BO, S, V]]]
8+
def rules: List[OptimizationRule[UO, BO, S, V]]
79

810
@tailrec
911
final def optimize(term: Node[UO, BO, S, V]): Node[UO, BO, S, V] = {
@@ -25,7 +27,7 @@ trait Optimizer[UO, BO, S, V] {
2527
}
2628

2729
object Optimize {
28-
def replaceConstantsRule[UO, BO, S, V](implicit eval: Evaluate[UO, BO, S, V]): PartialFunction[Node[UO, BO, S, V], Node[UO, BO, S, V]] = {
30+
def replaceConstantsRule[UO, BO, S, V](using eval: Evaluate[UO, BO, S, V]): OptimizationRule[UO, BO, S, V] = {
2931
case BinaryNode(op, ConstantNode(l), ConstantNode(r)) => ConstantNode(eval.executeBinaryOperator(op, l, r))
3032
case UnitaryNode(op, ConstantNode(l)) => ConstantNode(eval.executeUnitary(op, l))
3133
}

‎math-parser/src/main/scala/mathParser/Syntax.scala

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3,17 +3,17 @@ package mathParser
33
import scala.util.Try
44

55
object Syntax {
6-
implicit class EnrichNode[UO, BO, S, V](node: Node[UO, BO, S, V]) {
7-
def evaluate(variableAssignment: V => S)(implicit evaluate: Evaluate[UO, BO, S, V]): S =
6+
extension [UO, BO, S, V](node: Node[UO, BO, S, V]) {
7+
def evaluate(variableAssignment: V => S)(using evaluate: Evaluate[UO, BO, S, V]): S =
88
evaluate.evaluate(node)(variableAssignment)
99

10-
def optimize(implicit optimizer: Optimizer[UO, BO, S, V]): Node[UO, BO, S, V] =
10+
def optimize(using optimizer: Optimizer[UO, BO, S, V]): Node[UO, BO, S, V] =
1111
optimizer.optimize(node)
1212

13-
def derive(variable: V)(implicit derive: Derive[UO, BO, S, V]): Node[UO, BO, S, V] =
13+
def derive(variable: V)(using derive: Derive[UO, BO, S, V]): Node[UO, BO, S, V] =
1414
derive.derive(node)(variable)
1515

16-
def compile[F](implicit compiler: Compiler[UO, BO, S, V, F]): Try[F] =
16+
def compile[F](using compiler: Compiler[UO, BO, S, V, F]): Try[F] =
1717
compiler.compile(node)
1818
}
1919
}

‎math-parser/src/main/scala/mathParser/boolean/BooleanLanguage.scala

Lines changed: 6 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,9 @@ package mathParser.boolean
22

33
import mathParser.{Evaluate, Language}
44

5+
import BooleanBinaryOperator.*
6+
import BooleanUnitaryOperator.*
7+
58
object BooleanLanguage {
69
def apply(): Language[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, Nothing] =
710
Language[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, Nothing](
@@ -12,17 +15,9 @@ object BooleanLanguage {
1215
variables = List.empty
1316
)
1417

15-
implicit def booleanEvaluate[V]: Evaluate[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, V] =
18+
given [V]: Evaluate[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, V] =
1619
new Evaluate[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, V] {
17-
override def executeUnitary(uo: BooleanUnitaryOperator, s: Boolean): Boolean = uo match {
18-
case Not => !s
19-
}
20-
21-
override def executeBinaryOperator(bo: BooleanBinaryOperator, left: Boolean, right: Boolean): Boolean = bo match {
22-
case And => left && right
23-
case Or => left || right
24-
case Equals => left == right
25-
case Unequals => left != right
26-
}
20+
override def executeUnitary(uo: BooleanUnitaryOperator, s: Boolean): Boolean = uo.apply(s)
21+
override def executeBinaryOperator(bo: BooleanBinaryOperator, left: Boolean, right: Boolean): Boolean = bo.apply(left, right)
2722
}
2823
}

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

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,11 @@
11
package mathParser.boolean
22

3-
sealed abstract class BooleanUnitaryOperator(val name: String, val apply: Boolean => Boolean)
4-
case object Not extends BooleanUnitaryOperator("!", !_)
53

6-
sealed abstract class BooleanBinaryOperator(val name: String, val apply: (Boolean, Boolean) => Boolean)
7-
case object And extends BooleanBinaryOperator("&", _ && _)
8-
case object Or extends BooleanBinaryOperator("|", _ || _)
9-
case object Equals extends BooleanBinaryOperator("=", _ == _)
10-
case object Unequals extends BooleanBinaryOperator("!=", _ != _)
4+
enum BooleanUnitaryOperator(val name: String, val apply: Boolean => Boolean):
5+
case Not extends BooleanUnitaryOperator("!", !_)
6+
7+
enum BooleanBinaryOperator(val name: String, val apply: (Boolean, Boolean) => Boolean):
8+
case And extends BooleanBinaryOperator("&", _ && _)
9+
case Or extends BooleanBinaryOperator("|", _ || _)
10+
case Equals extends BooleanBinaryOperator("=", _ == _)
11+
case Unequals extends BooleanBinaryOperator("!=", _ != _)

‎math-parser/src/main/scala/mathParser/complex/ComplexEvaluate.scala

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,9 @@ package mathParser.complex
22

33
import mathParser.Evaluate
44

5+
import ComplexBinaryOperator.*
6+
import ComplexUnitaryOperator.*
7+
58
object ComplexEvaluate {
69

710
import Math._

‎math-parser/src/main/scala/mathParser/complex/ComplexImplicits.scala

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,15 @@ package mathParser.complex
22

33
import mathParser.{Derive, Evaluate, LiteralParser, Optimizer}
44

5-
trait ComplexImplicits {
6-
implicit final def complexLiteralParser: LiteralParser[Complex] =
7-
ComplexLanguage.complexLiteralParser
5+
object ComplexImplicits {
6+
given LiteralParser[Complex] = ComplexLanguage.complexLiteralParser
87

9-
implicit final def complexEvaluate[V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
8+
given [V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
109
ComplexLanguage.complexEvaluate
1110

12-
implicit final def complexOptimizer[V]: Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
11+
given [V]: Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
1312
ComplexLanguage.complexOptimizer
1413

15-
implicit final def complexDerive[V]: Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
14+
given [V]: Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
1615
ComplexLanguage.complexDerive
1716
}

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

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,9 @@ package mathParser.complex
22

33
import mathParser._
44

5+
import ComplexBinaryOperator.*
6+
import ComplexUnitaryOperator.*
7+
58
object ComplexLanguage {
69

710
import syntax._
@@ -12,14 +15,14 @@ object ComplexLanguage {
1215
.withBinaryOperators[ComplexBinaryOperator](prefix = List.empty, infix = List(Plus, Minus, Times, Divided, Power).map(op => (op.name, op)))
1316
.withUnitaryOperators(List(Neg, Sin, Cos, Tan, Asin, Acos, Atan, Sinh, Cosh, Tanh, Exp, Log).map(op => (op.name, op)))
1417

15-
def complexLiteralParser: LiteralParser[Complex] = s => s.toDoubleOption.map(Complex(_, 0.0))
18+
given complexLiteralParser: LiteralParser[Complex] = _.toDoubleOption.map(Complex(_, 0.0))
1619

17-
def complexEvaluate[V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] = ComplexEvaluate[V]
20+
given complexEvaluate[V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] = ComplexEvaluate[V]
1821

19-
def complexOptimizer[V]: Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
22+
given complexOptimizer[V]: Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
2023
new Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
2124
override def rules: List[PartialFunction[ComplexNode[V], ComplexNode[V]]] = List(
22-
Optimize.replaceConstantsRule[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V](complexEvaluate[V]), {
25+
Optimize.replaceConstantsRule(using complexEvaluate[V]), {
2326
case UnitaryNode(Neg, UnitaryNode(Neg, child)) => child
2427
case BinaryNode(Plus, left, ConstantNode(Complex(0d, 0d))) => left
2528
case BinaryNode(Plus, ConstantNode(Complex(0d, 0d)), right) => right
@@ -40,7 +43,7 @@ object ComplexLanguage {
4043
)
4144
}
4245

43-
def complexDerive[V]: Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
46+
given complexDerive[V]: Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
4447
new Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
4548
def derive(term: ComplexNode[V])(variable: V): ComplexNode[V] = {
4649
def derive(term: ComplexNode[V]): ComplexNode[V] = term match {
@@ -76,8 +79,6 @@ object ComplexLanguage {
7679
}
7780

7881
object syntax {
79-
implicit def doubleAsComplex(d: Double): Complex = Complex(d, 0.0)
80-
8182
def neg[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Neg, t)
8283
def sin[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Sin, t)
8384
def cos[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Cos, t)
@@ -91,18 +92,18 @@ object ComplexLanguage {
9192
def exp[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Exp, t)
9293
def log[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Log, t)
9394

94-
def sqrt[V](t: ComplexNode[V]): ComplexNode[V] = BinaryNode(Power, t, ConstantNode(0.5))
95+
def sqrt[V](t: ComplexNode[V]): ComplexNode[V] = BinaryNode(Power, t, ConstantNode(Complex(0.5, 0.0)))
9596

96-
implicit class EnrichNode[V](t1: ComplexNode[V]) {
97+
extension [V](t1: ComplexNode[V]) {
9798
def +(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Plus, t1, t2)
9899
def -(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Minus, t1, t2)
99100
def *(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Times, t1, t2)
100101
def /(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Divided, t1, t2)
101102
def ^(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Power, t1, t2)
102103
}
103104

104-
def zero[V]: ComplexNode[V] = ConstantNode(0.0)
105-
def one[V]: ComplexNode[V] = ConstantNode(1.0)
106-
def two[V]: ComplexNode[V] = ConstantNode(2.0)
105+
def zero[V]: ComplexNode[V] = ConstantNode(Complex(0.0, 0.0))
106+
def one[V]: ComplexNode[V] = ConstantNode(Complex(1.0, 0.0))
107+
def two[V]: ComplexNode[V] = ConstantNode(Complex(2.0, 0.0))
107108
}
108109
}

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

Lines changed: 21 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,24 @@
11
package mathParser.complex
22

3-
sealed abstract class ComplexUnitaryOperator(val name: String)
4-
case object Neg extends ComplexUnitaryOperator("-")
5-
case object Sin extends ComplexUnitaryOperator("sin")
6-
case object Cos extends ComplexUnitaryOperator("cos")
7-
case object Tan extends ComplexUnitaryOperator("tan")
8-
case object Asin extends ComplexUnitaryOperator("asin")
9-
case object Acos extends ComplexUnitaryOperator("acos")
10-
case object Atan extends ComplexUnitaryOperator("atan")
11-
case object Sinh extends ComplexUnitaryOperator("sinh")
12-
case object Cosh extends ComplexUnitaryOperator("cosh")
13-
case object Tanh extends ComplexUnitaryOperator("tanh")
14-
case object Exp extends ComplexUnitaryOperator("exp")
15-
case object Log extends ComplexUnitaryOperator("log")
3+
enum ComplexUnitaryOperator(val name: String) {
4+
case Neg extends ComplexUnitaryOperator("-")
5+
case Sin extends ComplexUnitaryOperator("sin")
6+
case Cos extends ComplexUnitaryOperator("cos")
7+
case Tan extends ComplexUnitaryOperator("tan")
8+
case Asin extends ComplexUnitaryOperator("asin")
9+
case Acos extends ComplexUnitaryOperator("acos")
10+
case Atan extends ComplexUnitaryOperator("atan")
11+
case Sinh extends ComplexUnitaryOperator("sinh")
12+
case Cosh extends ComplexUnitaryOperator("cosh")
13+
case Tanh extends ComplexUnitaryOperator("tanh")
14+
case Exp extends ComplexUnitaryOperator("exp")
15+
case Log extends ComplexUnitaryOperator("log")
16+
}
1617

17-
sealed abstract class ComplexBinaryOperator(val name: String)
18-
case object Plus extends ComplexBinaryOperator("+")
19-
case object Minus extends ComplexBinaryOperator("-")
20-
case object Times extends ComplexBinaryOperator("*")
21-
case object Divided extends ComplexBinaryOperator("/")
22-
case object Power extends ComplexBinaryOperator("^")
18+
enum ComplexBinaryOperator(val name: String) {
19+
case Plus extends ComplexBinaryOperator("+")
20+
case Minus extends ComplexBinaryOperator("-")
21+
case Times extends ComplexBinaryOperator("*")
22+
case Divided extends ComplexBinaryOperator("/")
23+
case Power extends ComplexBinaryOperator("^")
24+
}

0 commit comments

Comments
 (0)