Skip to content

Commit 1edee5b

Browse files
gregor-igregor-i
committed
restrucured langs
1 parent 3856c50 commit 1edee5b

9 files changed

+170
-166
lines changed

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

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,14 @@ object BooleanLanguage {
1717

1818
given [V]: Evaluate[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, V] =
1919
new Evaluate[BooleanUnitaryOperator, BooleanBinaryOperator, Boolean, V] {
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)
20+
override def executeUnitary(uo: BooleanUnitaryOperator, s: Boolean): Boolean = uo match {
21+
case Not => !s
22+
}
23+
override def executeBinaryOperator(bo: BooleanBinaryOperator, left: Boolean, right: Boolean): Boolean = bo match {
24+
case And => left && right
25+
case Or => left || right
26+
case Equals => left == right
27+
case Unequals => left != right
28+
}
2229
}
2330
}

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

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

33

4-
enum BooleanUnitaryOperator(val name: String, val apply: Boolean => Boolean):
5-
case Not extends BooleanUnitaryOperator("!", !_)
4+
enum BooleanUnitaryOperator(val name: String):
5+
case Not extends BooleanUnitaryOperator("!")
66

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("!=", _ != _)
7+
enum BooleanBinaryOperator(val name: String):
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/ComplexDerive.scala

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
package mathParser.complex
2+
3+
import mathParser.{BinaryNode, ConstantNode, Derive, UnitaryNode, VariableNode}
4+
import mathParser.complex.ComplexUnitaryOperator.*
5+
import mathParser.complex.ComplexBinaryOperator.*
6+
import mathParser.complex.Syntax.*
7+
8+
class ComplexDerive[V] extends Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
9+
def derive(term: ComplexNode[V])(variable: V): ComplexNode[V] = {
10+
def derive(term: ComplexNode[V]): ComplexNode[V] = term match {
11+
case VariableNode(`variable`) => one
12+
case VariableNode(_) | ConstantNode(_) => zero
13+
case UnitaryNode(op, f) =>
14+
op match {
15+
case Neg => neg(derive(f))
16+
case Sin => derive(f) * cos(f)
17+
case Cos => neg(derive(f) * sin(f))
18+
case Tan => derive(f) / (cos(f) * cos(f))
19+
case Asin => derive(f) / sqrt(one - (f * f))
20+
case Acos => neg(derive(f)) / sqrt(one - (f * f))
21+
case Atan => derive(f) / (one + (f * f))
22+
case Sinh => derive(f) * cosh(f)
23+
case Cosh => derive(f) * sinh(f)
24+
case Tanh => derive(f) / (cosh(f) * cosh(f))
25+
case Exp => exp(f) * derive(f)
26+
case Log => derive(f) / f
27+
}
28+
case BinaryNode(op, f, g) =>
29+
op match {
30+
case Plus => derive(f) + derive(g)
31+
case Minus => derive(f) - derive(g)
32+
case Times => (derive(f) * g) + (derive(g) * f)
33+
case Divided => ((f * derive(g)) - (g * derive(f))) / (g * g)
34+
case Power => (f ^ (g - one)) * ((g * derive(f)) + (f * log(f) * derive(g)))
35+
}
36+
}
37+
38+
derive(term)
39+
}
40+
}

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

Lines changed: 43 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -5,42 +5,39 @@ import mathParser.Evaluate
55
import ComplexBinaryOperator.*
66
import ComplexUnitaryOperator.*
77

8-
object ComplexEvaluate {
8+
final class ComplexEvaluate[V] extends Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
99

1010
import Math._
1111

12-
def apply[V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
13-
new Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
14-
override def executeUnitary(uo: ComplexUnitaryOperator, a: Complex): Complex = uo match {
15-
case Neg => complexNeg(a)
16-
case Sin => complexSin(a)
17-
case Cos => complexCos(a)
18-
case Tan => complexTan(a)
19-
case Asin => complexAsin(a)
20-
case Acos => complexAcos(a)
21-
case Atan => complexAtan(a)
22-
case Sinh => complexSinh(a)
23-
case Cosh => complexCosh(a)
24-
case Tanh => complexTanh(a)
25-
case Exp => complexExp(a)
26-
case Log => complexLog(a)
27-
}
28-
29-
override def executeBinaryOperator(bo: ComplexBinaryOperator, a: Complex, b: Complex): Complex =
30-
bo match {
31-
case Plus => complexPlus(a, b)
32-
case Minus => complexMinus(a, b)
33-
case Times => complexTimes(a, b)
34-
case Divided => complexDivided(a, b)
35-
case Power => complexPower(a, b)
36-
}
12+
def executeUnitary(uo: ComplexUnitaryOperator, a: Complex): Complex = uo match {
13+
case Neg => complexNeg(a)
14+
case Sin => complexSin(a)
15+
case Cos => complexCos(a)
16+
case Tan => complexTan(a)
17+
case Asin => complexAsin(a)
18+
case Acos => complexAcos(a)
19+
case Atan => complexAtan(a)
20+
case Sinh => complexSinh(a)
21+
case Cosh => complexCosh(a)
22+
case Tanh => complexTanh(a)
23+
case Exp => complexExp(a)
24+
case Log => complexLog(a)
25+
}
26+
27+
def executeBinaryOperator(bo: ComplexBinaryOperator, a: Complex, b: Complex): Complex =
28+
bo match {
29+
case Plus => complexPlus(a, b)
30+
case Minus => complexMinus(a, b)
31+
case Times => complexTimes(a, b)
32+
case Divided => complexDivided(a, b)
33+
case Power => complexPower(a, b)
3734
}
3835

39-
@inline private final def sq(a: Double): Double = a * a
36+
inline private final def sq(a: Double): Double = a * a
4037

41-
@inline private final def abs(c: Complex): Double = Math.sqrt(sq(c.real) + sq(c.imag))
38+
inline private final def abs(c: Complex): Double = Math.sqrt(sq(c.real) + sq(c.imag))
4239

43-
@inline private final def complexSqrt(z: Complex): Complex = {
40+
inline private final def complexSqrt(z: Complex): Complex = {
4441
val length_z: Double = abs(z)
4542
val b = sqrt((length_z + z.real) / 2.0)
4643
val c = sqrt((length_z - z.real) / 2.0)
@@ -49,21 +46,21 @@ object ComplexEvaluate {
4946
else
5047
Complex(b, c)
5148
}
52-
@inline private def complexPlus(a: Complex, b: Complex) =
49+
inline private def complexPlus(a: Complex, b: Complex) =
5350
Complex(a.real + b.real, a.imag + b.imag)
5451

55-
@inline private def complexMinus(a: Complex, b: Complex) =
52+
inline private def complexMinus(a: Complex, b: Complex) =
5653
Complex(a.real - b.real, a.imag - b.imag)
5754

58-
@inline private def complexTimes(a: Complex, b: Complex) =
55+
inline private def complexTimes(a: Complex, b: Complex) =
5956
Complex(a.real * b.real - a.imag * b.imag, a.real * b.imag + a.imag * b.real)
6057

61-
@inline private def complexDivided(a: Complex, b: Complex) = {
58+
inline private def complexDivided(a: Complex, b: Complex) = {
6259
val denom = sq(b.real) + sq(b.imag)
6360
Complex((a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom)
6461
}
6562

66-
@inline private def complexPower(a: Complex, b: Complex) = {
63+
inline private def complexPower(a: Complex, b: Complex) = {
6764
val length_a = abs(a)
6865
if (abs(b) == 0d) {
6966
Complex(1d, 0d)
@@ -77,62 +74,62 @@ object ComplexEvaluate {
7774
}
7875
}
7976

80-
@inline private def complexNeg(a: Complex) =
77+
inline private def complexNeg(a: Complex) =
8178
Complex(-a.real, -a.imag)
8279

83-
@inline private def complexSin(a: Complex) =
80+
inline private def complexSin(a: Complex) =
8481
Complex(sin(a.real) * cosh(a.imag), cos(a.real) * sinh(a.imag))
8582

86-
@inline private def complexCos(a: Complex) =
83+
inline private def complexCos(a: Complex) =
8784
Complex(cos(a.real) * cosh(a.imag), -sin(a.real) * sinh(a.imag));
8885

89-
@inline private def complexTan(a: Complex) = {
86+
inline private def complexTan(a: Complex) = {
9087
val r2 = a.real + a.real
9188
val i2 = a.imag + a.imag
9289
val d = cos(r2) + cosh(i2)
9390
new Complex(sin(r2) / d, sinh(i2) / d)
9491
}
9592

96-
@inline private def complexAsin(z: Complex) = {
93+
inline private def complexAsin(z: Complex) = {
9794
val z2 = complexTimes(z, z)
9895
val s = complexSqrt(Complex(1.0 - z2.real, -z2.imag))
9996
val l = complexLog(Complex(s.real - z.imag, s.imag + z.real))
10097
Complex(l.imag, -l.real);
10198
}
10299

103-
@inline private def complexAcos(z: Complex) = {
100+
inline private def complexAcos(z: Complex) = {
104101
val z2 = complexTimes(z, z)
105102
val s = complexSqrt(Complex(1.0 - z2.real, -z2.imag))
106103
val l = complexLog(Complex(z.real + s.imag, z.real + s.imag))
107104
Complex(l.real, -l.imag)
108105
}
109106

110-
@inline private def complexAtan(z: Complex) = {
107+
inline private def complexAtan(z: Complex) = {
111108
val n = Complex(z.real, z.imag + 1.0);
112109
val d = Complex(-z.real, 1.0 - z.imag);
113110
val l = complexLog(complexDivided(n, d));
114111
Complex(l.imag / -2.0, l.real / 2.0);
115112
}
116113

117-
@inline private def complexSinh(z: Complex) =
114+
inline private def complexSinh(z: Complex) =
118115
Complex(sinh(z.real) * cos(z.imag), cosh(z.real) * sin(z.imag))
119116

120-
@inline private def complexCosh(z: Complex) =
117+
inline private def complexCosh(z: Complex) =
121118
Complex(cosh(z.real) * cos(z.imag), sinh(z.real) * sin(z.imag))
122119

123-
@inline private def complexTanh(z: Complex) = {
120+
inline private def complexTanh(z: Complex) = {
124121
val r2 = z.real + z.real
125122
val i2 = z.imag + z.imag
126123
val d = cos(r2) + cosh(i2)
127124
Complex(sinh(r2) / d, sin(i2) / d)
128125
}
129126

130-
@inline private def complexExp(a: Complex) = {
127+
inline private def complexExp(a: Complex) = {
131128
val f = exp(a.real)
132129
Complex(f * cos(a.imag), f * sin(a.imag))
133130
}
134131

135-
@inline private def complexLog(a: Complex) =
132+
inline private def complexLog(a: Complex) =
136133
if (abs(a) == 0.0)
137134
Complex(Double.NaN, Double.NaN)
138135
else

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

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

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

Lines changed: 5 additions & 91 deletions
Original file line numberDiff line numberDiff line change
@@ -4,106 +4,20 @@ import mathParser._
44

55
import ComplexBinaryOperator.*
66
import ComplexUnitaryOperator.*
7+
import mathParser.complex.Syntax.*
78

89
object ComplexLanguage {
9-
10-
import syntax._
11-
1210
def apply(): ComplexLanguage[Nothing] =
1311
Language.emptyLanguage
1412
.withConstants[Complex](List("e" -> Complex.e, "pi" -> Complex.pi, "i" -> Complex.i))
1513
.withBinaryOperators[ComplexBinaryOperator](prefix = List.empty, infix = List(Plus, Minus, Times, Divided, Power).map(op => (op.name, op)))
1614
.withUnitaryOperators(List(Neg, Sin, Cos, Tan, Asin, Acos, Atan, Sinh, Cosh, Tanh, Exp, Log).map(op => (op.name, op)))
1715

18-
given complexLiteralParser: LiteralParser[Complex] = _.toDoubleOption.map(Complex(_, 0.0))
19-
20-
given complexEvaluate[V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] = ComplexEvaluate[V]
21-
22-
given complexOptimizer[V]: Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
23-
new Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
24-
override def rules: List[PartialFunction[ComplexNode[V], ComplexNode[V]]] = List(
25-
Optimize.replaceConstantsRule(using complexEvaluate[V]), {
26-
case UnitaryNode(Neg, UnitaryNode(Neg, child)) => child
27-
case BinaryNode(Plus, left, ConstantNode(Complex(0d, 0d))) => left
28-
case BinaryNode(Plus, ConstantNode(Complex(0d, 0d)), right) => right
29-
case BinaryNode(Times, ConstantNode(Complex(0d, 0d)), _) => zero
30-
case BinaryNode(Times, _, ConstantNode(Complex(0d, 0d))) => zero
31-
case BinaryNode(Times, left, ConstantNode(Complex(1d, 0d))) => left
32-
case BinaryNode(Times, ConstantNode(Complex(1d, 0d)), right) => right
33-
case BinaryNode(Power, left, ConstantNode(Complex(1d, 0d))) => left
34-
case BinaryNode(Power, _, ConstantNode(Complex(0d, 0d))) => one[V]
35-
case BinaryNode(Power, ConstantNode(Complex(1d, 0d)), _) => one[V]
36-
case BinaryNode(Power, ConstantNode(Complex(0d, 0d)), _) => zero[V]
37-
case UnitaryNode(Log, UnitaryNode(Exp, child)) => child
38-
case BinaryNode(Plus, left, UnitaryNode(Neg, child)) => left - child
39-
case BinaryNode(Minus, left, UnitaryNode(Neg, child)) => left + child
40-
case BinaryNode(Minus, left, right) if left == right => zero
41-
case BinaryNode(Divided, left, right) if left == right => one
42-
}
43-
)
44-
}
45-
46-
given complexDerive[V]: Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] =
47-
new Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] {
48-
def derive(term: ComplexNode[V])(variable: V): ComplexNode[V] = {
49-
def derive(term: ComplexNode[V]): ComplexNode[V] = term match {
50-
case VariableNode(`variable`) => one
51-
case VariableNode(_) | ConstantNode(_) => zero
52-
case UnitaryNode(op, f) =>
53-
op match {
54-
case Neg => neg(derive(f))
55-
case Sin => derive(f) * cos(f)
56-
case Cos => neg(derive(f) * sin(f))
57-
case Tan => derive(f) / (cos(f) * cos(f))
58-
case Asin => derive(f) / sqrt(one - (f * f))
59-
case Acos => neg(derive(f)) / sqrt(one - (f * f))
60-
case Atan => derive(f) / (one + (f * f))
61-
case Sinh => derive(f) * cosh(f)
62-
case Cosh => derive(f) * sinh(f)
63-
case Tanh => derive(f) / (cosh(f) * cosh(f))
64-
case Exp => exp(f) * derive(f)
65-
case Log => derive(f) / f
66-
}
67-
case BinaryNode(op, f, g) =>
68-
op match {
69-
case Plus => derive(f) + derive(g)
70-
case Minus => derive(f) - derive(g)
71-
case Times => (derive(f) * g) + (derive(g) * f)
72-
case Divided => ((f * derive(g)) - (g * derive(f))) / (g * g)
73-
case Power => (f ^ (g - one)) * ((g * derive(f)) + (f * log(f) * derive(g)))
74-
}
75-
}
76-
77-
derive(term)
78-
}
79-
}
80-
81-
object syntax {
82-
def neg[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Neg, t)
83-
def sin[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Sin, t)
84-
def cos[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Cos, t)
85-
def tan[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Tan, t)
86-
def asin[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Asin, t)
87-
def acos[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Acos, t)
88-
def atan[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Atan, t)
89-
def sinh[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Sinh, t)
90-
def cosh[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Cosh, t)
91-
def tanh[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Tanh, t)
92-
def exp[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Exp, t)
93-
def log[V](t: ComplexNode[V]): ComplexNode[V] = UnitaryNode(Log, t)
16+
given LiteralParser[Complex] = _.toDoubleOption.map(Complex(_, 0.0))
9417

95-
def sqrt[V](t: ComplexNode[V]): ComplexNode[V] = BinaryNode(Power, t, ConstantNode(Complex(0.5, 0.0)))
18+
given [V]: Evaluate[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] = ComplexEvaluate[V]
9619

97-
extension [V](t1: ComplexNode[V]) {
98-
def +(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Plus, t1, t2)
99-
def -(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Minus, t1, t2)
100-
def *(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Times, t1, t2)
101-
def /(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Divided, t1, t2)
102-
def ^(t2: ComplexNode[V]): ComplexNode[V] = BinaryNode(Power, t1, t2)
103-
}
20+
given [V]: Optimizer[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] = ComplexOptimize[V]
10421

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))
108-
}
22+
given [V]: Derive[ComplexUnitaryOperator, ComplexBinaryOperator, Complex, V] = ComplexDerive[V]
10923
}

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

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

3-
enum ComplexUnitaryOperator(val name: String) {
3+
enum ComplexUnitaryOperator(val name: String):
44
case Neg extends ComplexUnitaryOperator("-")
55
case Sin extends ComplexUnitaryOperator("sin")
66
case Cos extends ComplexUnitaryOperator("cos")
@@ -13,12 +13,10 @@ enum ComplexUnitaryOperator(val name: String) {
1313
case Tanh extends ComplexUnitaryOperator("tanh")
1414
case Exp extends ComplexUnitaryOperator("exp")
1515
case Log extends ComplexUnitaryOperator("log")
16-
}
1716

18-
enum ComplexBinaryOperator(val name: String) {
17+
enum ComplexBinaryOperator(val name: String):
1918
case Plus extends ComplexBinaryOperator("+")
2019
case Minus extends ComplexBinaryOperator("-")
2120
case Times extends ComplexBinaryOperator("*")
2221
case Divided extends ComplexBinaryOperator("/")
2322
case Power extends ComplexBinaryOperator("^")
24-
}

0 commit comments

Comments
 (0)