From b09abd0fa9da236fc442cef67210a48c8076a24a Mon Sep 17 00:00:00 2001 From: lbressler13 Date: Sun, 11 Feb 2024 06:17:20 -0500 Subject: [PATCH] feat: partial AdditiveExpression implementation + start of tests --- .../expression/AdditiveExpression.kt | 53 ++++++ .../expression/AdditiveExpressionTest.kt | 23 +++ .../expression/additive/castingTests.kt | 167 ++++++++++++++++++ .../expression/additive/stringEqualsTests.kt | 82 +++++++++ .../expression/additive/unaryTests.kt | 73 ++++++++ .../expression/multiplicative/castingTests.kt | 18 +- .../multiplicative/stringEqualsTests.kt | 14 +- .../expression/multiplicative/unaryTests.kt | 18 +- .../expressions/expression/testutils.kt | 3 +- 9 files changed, 425 insertions(+), 26 deletions(-) create mode 100644 exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpression.kt create mode 100644 exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpressionTest.kt create mode 100644 exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/castingTests.kt create mode 100644 exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/stringEqualsTests.kt create mode 100644 exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/unaryTests.kt diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpression.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpression.kt new file mode 100644 index 0000000..54df52d --- /dev/null +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpression.kt @@ -0,0 +1,53 @@ +package xyz.lbres.exactnumbers.expressions.expression + +import xyz.lbres.exactnumbers.exactfraction.ExactFraction +import xyz.lbres.exactnumbers.expressions.Expression +import xyz.lbres.exactnumbers.expressions.ExpressionImpl +import xyz.lbres.exactnumbers.expressions.term.Term +import xyz.lbres.exactnumbers.utils.createHashCode +import xyz.lbres.exactnumbers.utils.getOrSet +import xyz.lbres.kotlinutils.collection.ext.toConstMultiSet +import xyz.lbres.kotlinutils.set.multiset.const.ConstMultiSet +import xyz.lbres.kotlinutils.set.multiset.const.constMultiSetOf +import xyz.lbres.kotlinutils.set.multiset.mapToSetConsistent + +/** + * Expression which is the sum of several other expressions. + * Can also represent 1/sum + */ +@Suppress("EqualsOrHashCode") +internal class AdditiveExpression private constructor(private val expressions: ConstMultiSet, private val isInverted: Boolean) : ExpressionImpl() { + private var term: Term? = null + + init { + if (expressions.isEmpty()) { + throw Exception("Invalid expression") + } + } + + constructor(expr1: Expression, expr2: Expression) : this(constMultiSetOf(expr1, expr2), false) + + override fun unaryPlus(): Expression = this + override fun unaryMinus(): Expression { + val newExpressions = expressions.mapToSetConsistent { -it }.toConstMultiSet() + return AdditiveExpression(newExpressions, isInverted) + } + + override fun inverse(): Expression = AdditiveExpression(expressions, !isInverted) + + override fun toTerm(): Term { + return getOrSet({ term }, { term = it }) { + val terms = expressions.map { it.toTerm() } + .groupBy { it.factors }.map { + val coefficient = it.value.fold(ExactFraction.ZERO) { acc, t -> acc + t.coefficient } // value is list of terms + Term.fromValues(coefficient, it.key) // key is list of factors + } + Term.ZERO + // TODO + } + } + + override fun hashCode(): Int = createHashCode(listOf(expressions, "AdditiveExpression")) + + override fun toString(): String = "(${expressions.joinToString("+")})" +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpressionTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpressionTest.kt new file mode 100644 index 0000000..31a0096 --- /dev/null +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/AdditiveExpressionTest.kt @@ -0,0 +1,23 @@ +package xyz.lbres.exactnumbers.expressions.expression + +import xyz.lbres.exactnumbers.expressions.expression.additive.* // ktlint-disable no-wildcard-imports no-unused-imports +import kotlin.test.Test + +class AdditiveExpressionTest { + // @Test fun testEquals() = runEqualsTests() // TODO + @Test fun testToString() = runToStringTests() + + @Test fun testUnaryMinus() = runUnaryMinusTests() + @Test fun testUnaryPlus() = runUnaryPlusTests() + // @Test fun testInverse() = runInverseTests() // TODO + // @Test fun testGetValue() = runGetValueTests() // TODO + + // @Test fun testToTerm() = runToTermTests() // TODO + // @Test fun testToByte() = runToByteTests() // TODO + // @Test fun testToChar() = runToCharTests() // TODO + // @Test fun testToShort() = runToShortTests() // TODO + // @Test fun testToInt() = runToIntTests() // TODO + // @Test fun testToLong() = runToLongTests() // TODO + // @Test fun testToFloat() = runToFloatTests() // TODO + // @Test fun testToDouble() = runToDoubleTests() // TODO +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/castingTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/castingTests.kt new file mode 100644 index 0000000..b9d21b9 --- /dev/null +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/castingTests.kt @@ -0,0 +1,167 @@ +package xyz.lbres.exactnumbers.expressions.expression.additive + +import xyz.lbres.exactnumbers.exactfraction.ExactFraction +import xyz.lbres.exactnumbers.expressions.Expression +import xyz.lbres.exactnumbers.expressions.expression.* // ktlint-disable no-wildcard-imports no-unused-imports +import xyz.lbres.exactnumbers.expressions.term.Term +import xyz.lbres.exactnumbers.irrationals.log.Log +import xyz.lbres.exactnumbers.testutils.assertSucceeds +import xyz.lbres.exactnumbers.testutils.getCastingOverflowAssertion +import kotlin.test.assertEquals + +private val assertCastingOverflow = getCastingOverflowAssertion("Expression") + +fun runToTermTests() { +} + +fun runToByteTests() { + runWholeNumberCastingTests(Long::toByte, AdditiveExpression::toByte, Byte.MIN_VALUE, Byte.MAX_VALUE, "Byte") +} + +fun runToCharTests() { + var expr = AdditiveExpression(Expression.ZERO, Expression.ZERO) + var expected = 0.toChar() + assertEquals(expected, expr.toChar()) + + expr = AdditiveExpression(simpleExpr1, simpleExpr1.inverse()) + expected = 1.toChar() + assertEquals(expected, expr.toChar()) + + expr = AdditiveExpression(simpleExpr1, AdditiveExpression(simpleExpr2, simpleExpr2.inverse())) + expected = 25.toChar() + assertEquals(expected, expr.toChar()) + + expr = AdditiveExpression(partialMultExpr.inverse(), -simpleExpr2.inverse()) + expected = 0.toChar() + assertEquals(expected, expr.toChar()) + + expr = AdditiveExpression(partialMultExpr, simpleExpr2) + assertCastingOverflow("Char", expr) { expr.toChar() } + + val maxExpr = SimpleExpression(Term.fromValues(ExactFraction(Char.MAX_VALUE.code), emptyList())) + expr = AdditiveExpression(maxExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11).inverse())))) + assertSucceeds("Cast expected to succeed") { expr.toChar() } + + expr = AdditiveExpression(maxExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11))))) + assertCastingOverflow("Char", expr) { expr.toChar() } +} + +fun runToShortTests() { + runWholeNumberCastingTests(Long::toShort, AdditiveExpression::toShort, Short.MIN_VALUE, Short.MAX_VALUE, "Short") +} + +fun runToIntTests() { + runWholeNumberCastingTests(Long::toInt, AdditiveExpression::toInt, Int.MIN_VALUE, Int.MAX_VALUE, "Int") +} + +fun runToLongTests() { + runWholeNumberCastingTests({ it }, AdditiveExpression::toLong, Long.MIN_VALUE, Long.MAX_VALUE, "Long") +} + +fun runToFloatTests() { + runDecimalNumberCastingTests(Double::toFloat, AdditiveExpression::toFloat, Float.MAX_VALUE, "Float") +} + +fun runToDoubleTests() { + runDecimalNumberCastingTests({ it }, AdditiveExpression::toDouble, Double.MAX_VALUE, "Double") +} + +/** + * Run tests for a single type of whole number + * + * @param castLong (Long) -> T: cast a long value to a value of the current number type + * @param castExpr (AdditiveExpression) -> T: cast a multiplicative expression to a value of the current number type + * @param minValue T: minimum valid value for the current number type + * @param maxValue T: maximum valid value for the current number type + * @param type [String]: string representation of type, which is used in overflow exceptions + */ +private fun runWholeNumberCastingTests(castLong: (Long) -> T, castExpr: (AdditiveExpression) -> T, minValue: T, maxValue: T, type: String) { + var expr = AdditiveExpression(Expression.ZERO, Expression.ZERO) + var expected = castLong(0) + assertEquals(expected, castExpr(expr)) + + expr = AdditiveExpression(simpleExpr1, -simpleExpr1) + expected = castLong(1) + assertEquals(expected, castExpr(expr)) + + expr = AdditiveExpression(simpleExpr1, MultiplicativeExpression(simpleExpr2, simpleExpr2.inverse())) + expected = castLong(25) + assertEquals(expected, castExpr(expr)) + + expr = AdditiveExpression(simpleExpr1, AdditiveExpression(simpleExpr2, -simpleExpr1)) + expected = castLong(25) + assertEquals(expected, castExpr(expr)) + +// expr = AdditiveExpression(partialExpr, simpleExpr2) +// expected = castLong(-58) +// assertEquals(expected, castExpr(expr)) +// +// expr = AdditiveExpression(partialExpr.inverse(), -simpleExpr2.inverse()) +// expected = castLong(0) +// assertEquals(expected, castExpr(expr)) +// +// val minExpr = SimpleExpression(Term.fromValues(ExactFraction(minValue.toLong()), emptyList())) +// expr = AdditiveExpression(minExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11).inverse())))) +// assertSucceeds("Cast expected to succeed") { castExpr(expr) } +// +// expr = AdditiveExpression(minExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11))))) +// assertCastingOverflow(type, expr) { castExpr(expr) } +// +// val maxExpr = SimpleExpression(Term.fromValues(ExactFraction(maxValue.toLong()), emptyList())) +// expr = AdditiveExpression(maxExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11).inverse())))) +// assertSucceeds("Cast expected to succeed") { castExpr(expr) } +// +// expr = AdditiveExpression(maxExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11))))) +// assertCastingOverflow(type, expr) { castExpr(expr) } +} + +/** + * Run tests for a single type of decimal number + * + * @param castDouble (Double) -> T: cast a double value to a value of the current number type + * @param castExpr (AdditiveExpression) -> T: cast a multiplicative expression to a value of the current number type + * @param maxValue T: maximum valid value for the current number type + * @param type [String]: string representation of type, which is used in overflow exceptions + */ +private fun runDecimalNumberCastingTests(castDouble: (Double) -> T, castExpr: (AdditiveExpression) -> T, maxValue: T, type: String) { + var expr = AdditiveExpression(Expression.ZERO, Expression.ZERO) + var expected = castDouble(0.0) + assertEquals(expected, castExpr(expr)) + + expr = AdditiveExpression(simpleExpr1, -simpleExpr1) + expected = castDouble(1.0) + assertEquals(expected, castExpr(expr)) + + expr = AdditiveExpression(simpleExpr1, MultiplicativeExpression(simpleExpr2, simpleExpr2.inverse())) + expected = castDouble(25.132741228718345) + assertEquals(expected, castExpr(expr)) + + expr = AdditiveExpression(simpleExpr1, AdditiveExpression(simpleExpr2, -simpleExpr1)) + expected = castDouble(25.132741228718345) + assertEquals(expected, castExpr(expr)) +// +// expr = MultiplicativeExpression(partialExpr, simpleExpr2) +// expected = castDouble(-58.61224322251436) +// assertEquals(expected, castExpr(expr)) +// +// expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse()) +// expected = castDouble(0.01706128182474811) +// assertEquals(expected, castExpr(expr)) +// +// val largeValue = maxValue.toDouble().toBigDecimal().toBigInteger() +// val smallValue = (-maxValue.toDouble()).toBigDecimal().toBigInteger() +// +// val minExpr = SimpleExpression(Term.fromValues(ExactFraction(smallValue), emptyList())) +// expr = MultiplicativeExpression(minExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11).inverse())))) +// assertSucceeds("Cast expected to succeed") { castExpr(expr) } +// +// expr = MultiplicativeExpression(minExpr, SimpleExpression(Term.fromValues(ExactFraction.TEN, listOf(Log(11))))) +// assertCastingOverflow(type, expr) { castExpr(expr) } +// +// val maxExpr = SimpleExpression(Term.fromValues(ExactFraction(largeValue), emptyList())) +// expr = MultiplicativeExpression(maxExpr, SimpleExpression(Term.fromValues(one, listOf(Log(11).inverse())))) +// assertSucceeds("Cast expected to succeed") { castExpr(expr) } +// +// expr = MultiplicativeExpression(maxExpr, SimpleExpression(Term.fromValues(ExactFraction.TEN, listOf(Log(11))))) +// assertCastingOverflow(type, expr) { castExpr(expr) } +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/stringEqualsTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/stringEqualsTests.kt new file mode 100644 index 0000000..ed38257 --- /dev/null +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/stringEqualsTests.kt @@ -0,0 +1,82 @@ +package xyz.lbres.exactnumbers.expressions.expression.additive + +import xyz.lbres.exactnumbers.expressions.Expression +import xyz.lbres.exactnumbers.expressions.expression.* // ktlint-disable no-wildcard-imports no-unused-imports +import kotlin.test.assertEquals +import kotlin.test.assertNotEquals + +fun runEqualsTests() { + // equal + var expr1 = MultiplicativeExpression(simpleExpr1, Expression.ZERO) + assertEquals(expr1, expr1) + + expr1 = MultiplicativeExpression(simpleExpr1, simpleExpr1) + assertEquals(expr1, expr1) + + expr1 = MultiplicativeExpression(-simpleExpr2, partialMultExpr) + assertEquals(expr1, expr1) + + expr1 = MultiplicativeExpression(simpleExpr2, simpleExpr3) + var expr2 = MultiplicativeExpression(simpleExpr3, simpleExpr2) + assertEquals(expr1, expr2) + assertEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(simpleExpr2, simpleExpr1) + expr2 = MultiplicativeExpression(-simpleExpr1, -simpleExpr2) + assertEquals(expr1, expr2) + assertEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(simpleExpr3, simpleExpr3.inverse()) + expr2 = MultiplicativeExpression(Expression.ONE, Expression.ONE) + assertEquals(expr1, expr2) + assertEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(Expression.ONE, MultiplicativeExpression(simpleExpr1, simpleExpr2)) + expr2 = MultiplicativeExpression(simpleExpr1, simpleExpr2) + assertEquals(expr1, expr2) + assertEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(Expression.ZERO, partialMultExpr) + expr2 = MultiplicativeExpression(simpleExpr2, MultiplicativeExpression(simpleExpr3, Expression.ZERO)) + assertEquals(expr1, expr2) + assertEquals(expr2, expr1) + + // not equal + expr1 = MultiplicativeExpression(simpleExpr1, simpleExpr1) + expr2 = MultiplicativeExpression(simpleExpr1, -simpleExpr1) + assertNotEquals(expr1, expr2) + assertNotEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(simpleExpr2.inverse(), MultiplicativeExpression(simpleExpr1, simpleExpr2)) + expr2 = MultiplicativeExpression(simpleExpr1, simpleExpr2) + assertNotEquals(expr1, expr2) + assertNotEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(simpleExpr1, partialMultExpr) + expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialMultExpr) + assertNotEquals(expr1, expr2) + assertNotEquals(expr2, expr1) + + expr1 = MultiplicativeExpression(simpleExpr1, partialMultExpr) + expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialMultExpr.inverse()) + assertNotEquals(expr1, expr2) + assertNotEquals(expr2, expr1) +} + +fun runToStringTests() { + var expr = AdditiveExpression(simpleExpr1, simpleExpr1) + var expected = "($simpleExpr1+$simpleExpr1)" + assertEquals(expected, expr.toString()) + + expr = AdditiveExpression(simpleExpr1.inverse(), simpleExpr3) + expected = "(${simpleExpr1.inverse()}+$simpleExpr3)" + assertEquals(expected, expr.toString()) + + expr = AdditiveExpression(partialMultExpr, simpleExpr2) + expected = "((${simpleExpr3}x$simpleExpr1)+$simpleExpr2)" + assertEquals(expected, expr.toString()) + + expr = AdditiveExpression(partialAddExpr, partialMultExpr) + expected = "(($simpleExpr2+$simpleExpr3)+(${simpleExpr3}x$simpleExpr1))" + assertEquals(expected, expr.toString()) +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/unaryTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/unaryTests.kt new file mode 100644 index 0000000..a011fd1 --- /dev/null +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/additive/unaryTests.kt @@ -0,0 +1,73 @@ +package xyz.lbres.exactnumbers.expressions.expression.additive + +import xyz.lbres.exactnumbers.exactfraction.ExactFraction +import xyz.lbres.exactnumbers.expressions.Expression +import xyz.lbres.exactnumbers.expressions.expression.* // ktlint-disable no-wildcard-imports no-unused-imports +import xyz.lbres.exactnumbers.expressions.term.Term +import kotlin.test.assertEquals + +fun runUnaryMinusTests() { + var expr = AdditiveExpression(simpleExpr1, Expression.ZERO) + var expected1: Expression = SimpleExpression(Term.fromValues(-ExactFraction.EIGHT, listOf(pi))) + var expected = AdditiveExpression(expected1, Expression.ZERO) + assertEquals(expected, -expr) + + expr = AdditiveExpression(simpleExpr1, simpleExpr1) + expected1 = SimpleExpression(Term.fromValues(-ExactFraction.EIGHT, listOf(pi))) + var expected2: Expression = SimpleExpression(Term.fromValues(-ExactFraction.EIGHT, listOf(pi))) + expected = AdditiveExpression(expected1, expected2) + assertEquals(expected, -expr) + + expr = AdditiveExpression(-simpleExpr2, partialMultExpr) + expected1 = SimpleExpression(Term.fromValues(ExactFraction(8, 17), listOf(log4, sqrt2, piInverse, pi))) + expected2 = MultiplicativeExpression(SimpleExpression(Term.fromValues(-one, listOf(sqrt1))), simpleExpr1) + expected = AdditiveExpression(expected1, expected2) + assertEquals(expected, -expr) + + expr = AdditiveExpression(simpleExpr2, simpleExpr3) + expected1 = SimpleExpression(Term.fromValues(ExactFraction(-8, 17), listOf(log4, sqrt2, piInverse, pi))) + expected2 = SimpleExpression(Term.fromValues(-one, listOf(sqrt1))) + expected = AdditiveExpression(expected1, expected2) + assertEquals(expected, -expr) + + expr = AdditiveExpression(partialMultExpr, AdditiveExpression(partialMultExpr, Expression.ONE)) + expected1 = MultiplicativeExpression(SimpleExpression(Term.fromValues(-one, listOf(sqrt1))), simpleExpr1) + expected2 = AdditiveExpression(SimpleExpression(Term.fromValues(-one, listOf(sqrt1))), -Expression.ONE) + expected = AdditiveExpression(expected1, expected2) + assertEquals(expected, -expr) + + expr = AdditiveExpression(-simpleExpr2, partialAddExpr) + expected1 = SimpleExpression(Term.fromValues(ExactFraction(-8, 17), listOf(log4, sqrt2, piInverse, pi))) + expected2 = AdditiveExpression( + SimpleExpression(Term.fromValues(ExactFraction(-8, 17), listOf(log4, sqrt2, piInverse, pi))), + SimpleExpression(Term.fromValues(-one, listOf(sqrt1))) + ) + expected = AdditiveExpression(expected1, expected2) + assertEquals(expected, -expr) +} + +fun runUnaryPlusTests() { + var expr = AdditiveExpression(simpleExpr1, Expression.ZERO) + assertEquals(expr, +expr) + + expr = AdditiveExpression(simpleExpr1, simpleExpr1) + assertEquals(expr, +expr) + + expr = AdditiveExpression(-simpleExpr2, partialMultExpr) + assertEquals(expr, +expr) + + expr = AdditiveExpression(simpleExpr2, simpleExpr3) + assertEquals(expr, +expr) + + expr = AdditiveExpression(partialAddExpr, MultiplicativeExpression(partialMultExpr, simpleExpr2.inverse())) + assertEquals(expr, +expr) + + expr = AdditiveExpression(partialMultExpr, AdditiveExpression(partialMultExpr, simpleExpr2.inverse())) + assertEquals(expr, +expr) +} + +fun runInverseTests() { +} + +fun runGetValueTests() { +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/castingTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/castingTests.kt index bb3123e..a079512 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/castingTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/castingTests.kt @@ -16,7 +16,7 @@ fun runToTermTests() { var expr = MultiplicativeExpression(Expression.ONE, Expression.ZERO) assertEquals(Term.ZERO, expr.toTerm()) - expr = MultiplicativeExpression(partialExpr, partialExpr.inverse()) + expr = MultiplicativeExpression(partialMultExpr, partialMultExpr.inverse()) assertEquals(Term.ONE, expr.toTerm()) assertEquals(Term.ONE, expr.toTerm()) @@ -24,7 +24,7 @@ fun runToTermTests() { var expected = Term.fromValues(ExactFraction.EIGHT, listOf(pi)) assertEquals(expected, expr.toTerm()) - expr = MultiplicativeExpression(simpleExpr1, partialExpr.inverse()) + expr = MultiplicativeExpression(simpleExpr1, partialMultExpr.inverse()) expected = Term.fromValues(one, listOf(sqrt1.inverse())) assertEquals(expected, expr.toTerm()) assertEquals(expected, expr.toTerm()) @@ -33,7 +33,7 @@ fun runToTermTests() { expected = Term.fromValues(ExactFraction(512, 187), listOf(pi, log4)) assertEquals(expected, expr.toTerm()) - val expr1 = MultiplicativeExpression(-simpleExpr2, partialExpr.inverse()) + val expr1 = MultiplicativeExpression(-simpleExpr2, partialMultExpr.inverse()) val expr2 = MultiplicativeExpression(simpleExpr1.inverse(), MultiplicativeExpression(simpleExpr3, simpleExpr3)) expr = MultiplicativeExpression(expr1, expr2) expected = Term.fromValues(ExactFraction(-3, 187), listOf(log4, Sqrt(11), piInverse, piInverse)) @@ -58,11 +58,11 @@ fun runToCharTests() { expected = 25.toChar() assertEquals(expected, expr.toChar()) - expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse()) + expr = MultiplicativeExpression(partialMultExpr.inverse(), -simpleExpr2.inverse()) expected = 0.toChar() assertEquals(expected, expr.toChar()) - expr = MultiplicativeExpression(partialExpr, simpleExpr2) + expr = MultiplicativeExpression(partialMultExpr, simpleExpr2) assertCastingOverflow("Char", expr) { expr.toChar() } val maxExpr = SimpleExpression(Term.fromValues(ExactFraction(Char.MAX_VALUE.code), emptyList())) @@ -115,11 +115,11 @@ private fun runWholeNumberCastingTests(castLong: (Long) -> T, castE expected = castLong(25) assertEquals(expected, castExpr(expr)) - expr = MultiplicativeExpression(partialExpr, simpleExpr2) + expr = MultiplicativeExpression(partialMultExpr, simpleExpr2) expected = castLong(-58) assertEquals(expected, castExpr(expr)) - expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse()) + expr = MultiplicativeExpression(partialMultExpr.inverse(), -simpleExpr2.inverse()) expected = castLong(0) assertEquals(expected, castExpr(expr)) @@ -163,11 +163,11 @@ private fun runDecimalNumberCastingTests(castDouble: (Double) -> T, expected = castDouble(25.132741228718345) assertEquals(expected, castExpr(expr)) - expr = MultiplicativeExpression(partialExpr, simpleExpr2) + expr = MultiplicativeExpression(partialMultExpr, simpleExpr2) expected = castDouble(-58.61224322251436) assertEquals(expected, castExpr(expr)) - expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse()) + expr = MultiplicativeExpression(partialMultExpr.inverse(), -simpleExpr2.inverse()) expected = castDouble(0.01706128182474811) assertEquals(expected, castExpr(expr)) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/stringEqualsTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/stringEqualsTests.kt index 9d4f735..ba3b428 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/stringEqualsTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/stringEqualsTests.kt @@ -13,7 +13,7 @@ fun runEqualsTests() { expr1 = MultiplicativeExpression(simpleExpr1, simpleExpr1) assertEquals(expr1, expr1) - expr1 = MultiplicativeExpression(-simpleExpr2, partialExpr) + expr1 = MultiplicativeExpression(-simpleExpr2, partialMultExpr) assertEquals(expr1, expr1) expr1 = MultiplicativeExpression(simpleExpr2, simpleExpr3) @@ -36,7 +36,7 @@ fun runEqualsTests() { assertEquals(expr1, expr2) assertEquals(expr2, expr1) - expr1 = MultiplicativeExpression(Expression.ZERO, partialExpr) + expr1 = MultiplicativeExpression(Expression.ZERO, partialMultExpr) expr2 = MultiplicativeExpression(simpleExpr2, MultiplicativeExpression(simpleExpr3, Expression.ZERO)) assertEquals(expr1, expr2) assertEquals(expr2, expr1) @@ -52,13 +52,13 @@ fun runEqualsTests() { assertNotEquals(expr1, expr2) assertNotEquals(expr2, expr1) - expr1 = MultiplicativeExpression(simpleExpr1, partialExpr) - expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialExpr) + expr1 = MultiplicativeExpression(simpleExpr1, partialMultExpr) + expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialMultExpr) assertNotEquals(expr1, expr2) assertNotEquals(expr2, expr1) - expr1 = MultiplicativeExpression(simpleExpr1, partialExpr) - expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialExpr.inverse()) + expr1 = MultiplicativeExpression(simpleExpr1, partialMultExpr) + expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialMultExpr.inverse()) assertNotEquals(expr1, expr2) assertNotEquals(expr2, expr1) } @@ -72,7 +72,7 @@ fun runToStringTests() { expected = "(${simpleExpr1.inverse()}x$simpleExpr3)" assertEquals(expected, expr.toString()) - expr = MultiplicativeExpression(partialExpr, simpleExpr2) + expr = MultiplicativeExpression(partialMultExpr, simpleExpr2) expected = "((${simpleExpr3}x$simpleExpr1)x$simpleExpr2)" assertEquals(expected, expr.toString()) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/unaryTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/unaryTests.kt index 4c4b798..88d7fe0 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/unaryTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/unaryTests.kt @@ -17,16 +17,16 @@ fun runUnaryMinusTests() { expected = MultiplicativeExpression(SimpleExpression(Term.fromValues(-ExactFraction.EIGHT, listOf(pi))), simpleExpr1) assertEquals(expected, -expr) - expr = MultiplicativeExpression(-simpleExpr2, partialExpr) - expected = MultiplicativeExpression(simpleExpr2, partialExpr) + expr = MultiplicativeExpression(-simpleExpr2, partialMultExpr) + expected = MultiplicativeExpression(simpleExpr2, partialMultExpr) assertEquals(expected, -expr) expr = MultiplicativeExpression(simpleExpr2, simpleExpr3) expected = MultiplicativeExpression(SimpleExpression(Term.fromValues(-one, listOf(sqrt1))), simpleExpr2) assertEquals(expected, -expr) - expr = MultiplicativeExpression(partialExpr, MultiplicativeExpression(partialExpr, Expression.ONE)) - expected = MultiplicativeExpression(partialExpr, MultiplicativeExpression(partialExpr, SimpleExpression(-Term.ONE))) + expr = MultiplicativeExpression(partialMultExpr, MultiplicativeExpression(partialMultExpr, Expression.ONE)) + expected = MultiplicativeExpression(partialMultExpr, MultiplicativeExpression(partialMultExpr, SimpleExpression(-Term.ONE))) assertEquals(expected, -expr) } @@ -37,13 +37,13 @@ fun runUnaryPlusTests() { expr = MultiplicativeExpression(simpleExpr1, simpleExpr1) assertEquals(expr, +expr) - expr = MultiplicativeExpression(-simpleExpr2, partialExpr) + expr = MultiplicativeExpression(-simpleExpr2, partialMultExpr) assertEquals(expr, +expr) expr = MultiplicativeExpression(simpleExpr2, simpleExpr3) assertEquals(expr, +expr) - expr = MultiplicativeExpression(partialExpr, MultiplicativeExpression(partialExpr, simpleExpr2.inverse())) + expr = MultiplicativeExpression(partialMultExpr, MultiplicativeExpression(partialMultExpr, simpleExpr2.inverse())) assertEquals(expr, +expr) } @@ -62,7 +62,7 @@ fun runInverseTests() { expected = MultiplicativeExpression(simpleExpr2.inverse(), simpleExpr1) assertEquals(expected, expr.inverse()) - expr = MultiplicativeExpression(partialExpr, simpleExpr2) + expr = MultiplicativeExpression(partialMultExpr, simpleExpr2) val partialInverse = MultiplicativeExpression(simpleExpr1.inverse(), simpleExpr3.inverse()) expected = MultiplicativeExpression(partialInverse, simpleExpr2.inverse()) assertEquals(expected, expr.inverse()) @@ -85,11 +85,11 @@ fun runGetValueTests() { expected = BigDecimal("25.132741228718344") assertEquals(expected, expr.getValue()) - expr = MultiplicativeExpression(partialExpr, simpleExpr2) + expr = MultiplicativeExpression(partialMultExpr, simpleExpr2) expected = BigDecimal("-58.612243222514359594") // -58.61224322251435719068... assertEquals(expected, expr.getValue()) - expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse()) + expr = MultiplicativeExpression(partialMultExpr.inverse(), -simpleExpr2.inverse()) expected = BigDecimal("0.017061281824748112795308108019747092438130381820126559258080078125") assertEquals(expected, expr.getValue()) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/testutils.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/testutils.kt index 26e1383..f371b5d 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/testutils.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/testutils.kt @@ -24,4 +24,5 @@ val one = ExactFraction.ONE internal val simpleExpr1 = SimpleExpression(Term.fromValues(ExactFraction.EIGHT, listOf(pi))) internal val simpleExpr2 = SimpleExpression(Term.fromValues(ExactFraction(8, 17), listOf(log4, sqrt2, piInverse, pi))) internal val simpleExpr3 = SimpleExpression(Term.fromValues(one, listOf(sqrt1))) -internal val partialExpr = MultiplicativeExpression(simpleExpr3, simpleExpr1) +internal val partialMultExpr = MultiplicativeExpression(simpleExpr3, simpleExpr1) +internal val partialAddExpr = AdditiveExpression(simpleExpr2, simpleExpr3)