isZero method (#46)

lbressler13 · Mar 1, 2024 · daf63e9 · daf63e9
1 parent 2e8e803
commit daf63e9
Show file tree

Hide file tree

Showing 12 changed files with 84 additions and 29 deletions.
diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/Expression.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/Expression.kt
@@ -13,7 +13,7 @@ sealed class Expression : Number() {
     abstract fun inverse(): Expression
     abstract fun getValue(): BigDecimal
 
-    // abstract fun isZero(): Boolean
+    abstract fun isZero(): Boolean
 
     // abstract operator fun plus(other: Expression): Expression
     // abstract operator fun minus(other: Expression): Expression

diff --git a/...src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/MultiplicativeExpression.kt b/...src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/MultiplicativeExpression.kt
@@ -41,6 +41,8 @@ internal class MultiplicativeExpression private constructor(expressions: ConstMu
         return MultiplicativeExpression(newExpressions)
     }
 
+    override fun isZero(): Boolean = expressions.any { it.isZero() }
+
     override fun toTerm(): Term {
         return getOrSet({ term }, { term = it }) {
             expressions.fold(Term.ONE) { acc, expr -> acc * expr.toTerm() }.getSimplified()

diff --git a/...numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/SimpleExpression.kt b/...numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/expression/SimpleExpression.kt
@@ -13,6 +13,7 @@ internal class SimpleExpression(private val term: Term) : ExpressionImpl() {
     override fun unaryPlus(): Expression = this
     override fun unaryMinus(): Expression = SimpleExpression(-term)
     override fun inverse(): Expression = SimpleExpression(term.inverse())
+    override fun isZero(): Boolean = term.isZero()
 
     override fun toTerm(): Term = term
 

diff --git a/...test/kotlin/xyz/lbres/exactnumbers/expressions/expression/MultiplicativeExpressionTest.kt b/...test/kotlin/xyz/lbres/exactnumbers/expressions/expression/MultiplicativeExpressionTest.kt
@@ -11,6 +11,7 @@ class MultiplicativeExpressionTest {
     @Test fun testUnaryPlus() = runUnaryPlusTests()
     @Test fun testInverse() = runInverseTests()
     @Test fun testGetValue() = runGetValueTests()
+    @Test fun testIsZero() = runIsZeroTests()
 
     @Test fun testToTerm() = runToTermTests()
     @Test fun testToByte() = runToByteTests()

diff --git a/...ers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/SimpleExpressionTest.kt b/...ers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/SimpleExpressionTest.kt
@@ -11,6 +11,7 @@ class SimpleExpressionTest {
     @Test fun testUnaryPlus() = runUnaryPlusTests()
     @Test fun testInverse() = runInverseTests()
     @Test fun testGetValue() = runGetValueTests()
+    @Test fun isZero() = runIsZeroTests()
 
     @Test fun testToTerm() = runToTermTests()
     @Test fun testToByte() = runToByteTests()

diff --git a/.../test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/castingTests.kt b/.../test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/castingTests.kt
@@ -16,15 +16,15 @@ fun runToTermTests() {
     var expr = MultiplicativeExpression(Expression.ONE, Expression.ZERO)
     assertEquals(Term.ZERO, expr.toTerm())
 
-    expr = MultiplicativeExpression(partialExpr, partialExpr.inverse())
+    expr = MultiplicativeExpression(multExpr1, multExpr1.inverse())
     assertEquals(Term.ONE, expr.toTerm())
     assertEquals(Term.ONE, expr.toTerm())
 
     expr = MultiplicativeExpression(simpleExpr1, Expression.ONE)
     var expected = Term.fromValues(ExactFraction.EIGHT, listOf(pi))
     assertEquals(expected, expr.toTerm())
 
-    expr = MultiplicativeExpression(simpleExpr1, partialExpr.inverse())
+    expr = MultiplicativeExpression(simpleExpr1, multExpr1.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, multExpr1.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(multExpr1.inverse(), -simpleExpr2.inverse())
     expected = 0.toChar()
     assertEquals(expected, expr.toChar())
 
-    expr = MultiplicativeExpression(partialExpr, simpleExpr2)
+    expr = MultiplicativeExpression(multExpr1, simpleExpr2)
     assertCastingOverflow("Char", expr) { expr.toChar() }
 
     val maxExpr = SimpleExpression(Term.fromValues(ExactFraction(Char.MAX_VALUE.code), emptyList()))
@@ -115,11 +115,11 @@ private fun <T : Number> runWholeNumberCastingTests(castLong: (Long) -> T, castE
     expected = castLong(25)
     assertEquals(expected, castExpr(expr))
 
-    expr = MultiplicativeExpression(partialExpr, simpleExpr2)
+    expr = MultiplicativeExpression(multExpr1, simpleExpr2)
     expected = castLong(-58)
     assertEquals(expected, castExpr(expr))
 
-    expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse())
+    expr = MultiplicativeExpression(multExpr1.inverse(), -simpleExpr2.inverse())
     expected = castLong(0)
     assertEquals(expected, castExpr(expr))
 
@@ -163,11 +163,11 @@ private fun <T : Number> runDecimalNumberCastingTests(castDouble: (Double) -> T,
     expected = castDouble(25.132741228718345)
     assertEquals(expected, castExpr(expr))
 
-    expr = MultiplicativeExpression(partialExpr, simpleExpr2)
+    expr = MultiplicativeExpression(multExpr1, simpleExpr2)
     expected = castDouble(-58.61224322251436)
     assertEquals(expected, castExpr(expr))
 
-    expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse())
+    expr = MultiplicativeExpression(multExpr1.inverse(), -simpleExpr2.inverse())
     expected = castDouble(0.01706128182474811)
     assertEquals(expected, castExpr(expr))
 

diff --git a/.../kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/stringEqualsTests.kt b/.../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, multExpr1)
     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, multExpr1)
     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, multExpr1)
+    expr2 = MultiplicativeExpression(simpleExpr1.inverse(), multExpr1)
     assertNotEquals(expr1, expr2)
     assertNotEquals(expr2, expr1)
 
-    expr1 = MultiplicativeExpression(simpleExpr1, partialExpr)
-    expr2 = MultiplicativeExpression(simpleExpr1.inverse(), partialExpr.inverse())
+    expr1 = MultiplicativeExpression(simpleExpr1, multExpr1)
+    expr2 = MultiplicativeExpression(simpleExpr1.inverse(), multExpr1.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(multExpr1, simpleExpr2)
     expected = "((${simpleExpr3}x$simpleExpr1)x$simpleExpr2)"
     assertEquals(expected, expr.toString())
 }
diff --git a/...rc/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/unaryTests.kt b/...rc/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/multiplicative/unaryTests.kt
@@ -7,6 +7,8 @@ import xyz.lbres.exactnumbers.expressions.term.Term
 import xyz.lbres.exactnumbers.testutils.assertDivByZero
 import java.math.BigDecimal
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 fun runUnaryMinusTests() {
     var expr = MultiplicativeExpression(simpleExpr1, Expression.ZERO)
@@ -17,16 +19,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, multExpr1)
+    expected = MultiplicativeExpression(simpleExpr2, multExpr1)
     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(multExpr1, MultiplicativeExpression(multExpr1, Expression.ONE))
+    expected = MultiplicativeExpression(multExpr1, MultiplicativeExpression(multExpr1, SimpleExpression(-Term.ONE)))
     assertEquals(expected, -expr)
 }
 
@@ -37,13 +39,13 @@ fun runUnaryPlusTests() {
     expr = MultiplicativeExpression(simpleExpr1, simpleExpr1)
     assertEquals(expr, +expr)
 
-    expr = MultiplicativeExpression(-simpleExpr2, partialExpr)
+    expr = MultiplicativeExpression(-simpleExpr2, multExpr1)
     assertEquals(expr, +expr)
 
     expr = MultiplicativeExpression(simpleExpr2, simpleExpr3)
     assertEquals(expr, +expr)
 
-    expr = MultiplicativeExpression(partialExpr, MultiplicativeExpression(partialExpr, simpleExpr2.inverse()))
+    expr = MultiplicativeExpression(multExpr1, MultiplicativeExpression(multExpr1, simpleExpr2.inverse()))
     assertEquals(expr, +expr)
 }
 
@@ -62,7 +64,7 @@ fun runInverseTests() {
     expected = MultiplicativeExpression(simpleExpr2.inverse(), simpleExpr1)
     assertEquals(expected, expr.inverse())
 
-    expr = MultiplicativeExpression(partialExpr, simpleExpr2)
+    expr = MultiplicativeExpression(multExpr1, simpleExpr2)
     val partialInverse = MultiplicativeExpression(simpleExpr1.inverse(), simpleExpr3.inverse())
     expected = MultiplicativeExpression(partialInverse, simpleExpr2.inverse())
     assertEquals(expected, expr.inverse())
@@ -85,11 +87,39 @@ fun runGetValueTests() {
     expected = BigDecimal("25.132741228718344")
     assertEquals(expected, expr.getValue())
 
-    expr = MultiplicativeExpression(partialExpr, simpleExpr2)
+    expr = MultiplicativeExpression(multExpr1, simpleExpr2)
     expected = BigDecimal("-58.612243222514359594") // -58.61224322251435719068...
     assertEquals(expected, expr.getValue())
 
-    expr = MultiplicativeExpression(partialExpr.inverse(), -simpleExpr2.inverse())
+    expr = MultiplicativeExpression(multExpr1.inverse(), -simpleExpr2.inverse())
     expected = BigDecimal("0.017061281824748112795308108019747092438130381820126559258080078125")
     assertEquals(expected, expr.getValue())
 }
+
+fun runIsZeroTests() {
+    // zero
+    var expr = MultiplicativeExpression(Expression.ZERO, Expression.ZERO)
+    assertTrue(expr.isZero())
+
+    var partialExpr = MultiplicativeExpression(simpleExpr1, simpleExpr2)
+    expr = MultiplicativeExpression(partialExpr, Expression.ZERO)
+    assertTrue(expr.isZero())
+
+    partialExpr = MultiplicativeExpression(Expression.ZERO, multExpr1)
+    expr = MultiplicativeExpression(simpleExpr3, partialExpr)
+    assertTrue(expr.isZero())
+
+    // not zero
+    expr = MultiplicativeExpression(simpleExpr1, -simpleExpr1)
+    assertFalse(expr.isZero())
+
+    expr = MultiplicativeExpression(simpleExpr1.inverse(), simpleExpr1)
+    assertFalse(expr.isZero())
+
+    partialExpr = MultiplicativeExpression(simpleExpr1, multExpr1)
+    expr = MultiplicativeExpression(simpleExpr3, partialExpr)
+    assertFalse(expr.isZero())
+
+    expr = MultiplicativeExpression(partialExpr, Expression.ONE)
+    assertFalse(expr.isZero())
+}
diff --git a/...umbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/simple/unaryTests.kt b/...umbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/expression/simple/unaryTests.kt
@@ -8,6 +8,8 @@ import xyz.lbres.exactnumbers.irrationals.sqrt.Sqrt
 import xyz.lbres.exactnumbers.testutils.assertDivByZero
 import java.math.BigDecimal
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 fun runUnaryMinusTests() {
     var expr = SimpleExpression(Term.ZERO)
@@ -172,3 +174,22 @@ fun runGetValueTests() {
     expected = BigDecimal("85.33085748711055350")
     assertEquals(expected, expr.getValue())
 }
+
+fun runIsZeroTests() {
+    // zero
+    var expr = SimpleExpression(Term.ZERO)
+    assertTrue(expr.isZero())
+
+    // not zero
+    expr = SimpleExpression(Term.ONE)
+    assertFalse(expr.isZero())
+
+    expr = SimpleExpression(Term.fromValues(one, listOf(Sqrt.ONE)))
+    assertFalse(expr.isZero())
+
+    expr = SimpleExpression(Term.fromValues(ExactFraction(-1, Long.MAX_VALUE), emptyList()))
+    assertFalse(expr.isZero())
+
+    expr = SimpleExpression(Term.fromValues(ExactFraction(5, 4), listOf(log2, log4, Sqrt(12), piInverse)))
+    assertFalse(expr.isZero())
+}
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
@@ -24,4 +24,4 @@ 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 multExpr1 = MultiplicativeExpression(simpleExpr3, simpleExpr1)
diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/unaryTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/unaryTests.kt
@@ -92,8 +92,6 @@ fun runIsZeroTests() {
 
     term = Term.fromValues(ExactFraction(-1, 1000000), listOf(Sqrt(64), Sqrt(ExactFraction(1, 64))))
     assertFalse(term.isZero())
-
-    assertFalse(term.isZero())
 }
 
 fun runInverseTests() {

diff --git a/signatures/v1.1.0/v1.1.0.md b/signatures/v1.1.0/v1.1.0.md
@@ -127,6 +127,7 @@ class Expression: Number()
 
 fun getValue(): BigDecimal
 fun inverse(): Expression
+fun isZero(): Boolean
 
 fun toTerm(): Term