From e0c5bef59bbea7da17a5abce8518e06016ce3f29 Mon Sep 17 00:00:00 2001 From: lbressler13 Date: Tue, 23 Jan 2024 12:46:09 -0500 Subject: [PATCH] nextversion cleanup (#31) --- README.md | 1 + .../exactfraction/ExactFractionImpl.kt | 19 +- .../ExactFractionOverflowException.kt | 4 +- .../exactfraction/exactFractionHelpers.kt | 31 +- .../exactfraction/exactFractionOperators.kt | 5 +- .../exactfraction/exactFractionParsing.kt | 104 ++----- .../exactnumbers/expressions/term/TermImpl.kt | 33 +-- .../exactnumbers/expressions/term/helpers.kt | 10 +- .../lbres/exactnumbers/ext/BigDecimalExt.kt | 2 +- .../lbres/exactnumbers/irrationals/log/Log.kt | 15 +- .../exactnumbers/irrationals/log/LogImpl.kt | 4 +- .../exactnumbers/irrationals/log/helpers.kt | 10 +- .../exactnumbers/irrationals/sqrt/Sqrt.kt | 12 +- .../lbres/exactnumbers/utils/castingUtils.kt | 30 +- .../ExactFractionConstructorsTest.kt | 17 +- .../exactfraction/ExactFractionHelpersTest.kt | 5 +- .../exactfraction/ExactFractionParsingTest.kt | 9 + .../exactfraction/ExactFractionTest.kt | 4 +- .../exactfraction/castingTests.kt | 10 + .../exactfraction/commonPowTests.kt | 10 + .../exactfraction/commonSimplifyTests.kt | 10 +- .../exactfraction/compareToTests.kt | 59 ++-- .../exactnumbers/exactfraction/equalsTests.kt | 1 + .../exactnumbers/exactfraction/stringTests.kt | 29 +- .../exactfraction/timesDivPowTests.kt | 6 +- .../exactfraction/unaryNonOpTests.kt | 18 +- .../expressions/term/HelpersTest.kt | 4 +- .../exactnumbers/expressions/term/TermTest.kt | 175 +----------- .../expressions/term/castingTests.kt | 11 +- .../expressions/term/constuctorTests.kt | 8 +- .../expressions/term/equalsToStringTests.kt | 191 +++++++++++++ .../expressions/term/getComponentsTests.kt | 119 ++++---- .../term/simplifyGetValuesTests.kt | 95 ++++--- .../expressions/term/timesDivTests.kt | 110 ++++---- .../expressions/term/unaryTests.kt | 20 +- .../irrationals/log/LogConstructorsTest.kt | 18 +- .../exactnumbers/irrationals/log/LogTest.kt | 264 +++++++++--------- .../irrationals/log/getValuesTests.kt | 114 ++++---- .../irrationals/log/simplifyTests.kt | 58 ++-- .../irrationals/pi/simplifySetTests.kt | 2 +- .../exactnumbers/irrationals/sqrt/SqrtTest.kt | 8 +- .../irrationals/sqrt/binaryOpTests.kt | 3 + .../irrationals/sqrt/extractWholeOfTests.kt | 2 +- .../irrationals/sqrt/simplifyTests.kt | 27 +- .../lbres/exactnumbers/testutils/helpers.kt | 4 +- 45 files changed, 861 insertions(+), 830 deletions(-) create mode 100644 exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionParsingTest.kt create mode 100644 exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/equalsToStringTests.kt diff --git a/README.md b/README.md index a076563b..bd09df39 100644 --- a/README.md +++ b/README.md @@ -84,6 +84,7 @@ See [here](https://docs.github.com/en/packages/working-with-a-github-packages-re ## Testing Unit tests are written using the [Kotlin test](https://kotlinlang.org/api/latest/kotlin.test/) framework. +Mocking is done using the [MockK library](https://mockk.io/). Tests must be written for all logic in the package. Tests can be run using an IDE, or with the following command: diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionImpl.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionImpl.kt index d45b15eb..12cd2451 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionImpl.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionImpl.kt @@ -23,7 +23,7 @@ internal class ExactFractionImpl private constructor(numerator: BigInteger, deno this.denominator = denominator } else -> { - val simplifiedValues = simplifyFraction(Pair(numerator, denominator)) + val simplifiedValues = simplifyFraction(numerator, denominator) this.numerator = simplifiedValues.first this.denominator = simplifiedValues.second } @@ -56,14 +56,10 @@ internal class ExactFractionImpl private constructor(numerator: BigInteger, deno // UNARY NON-OPERATORS override fun inverse(): ExactFraction { - if (numerator.isZero()) { - throw divideByZero - } - - return if (numerator.isNegative()) { - ExactFractionImpl(-denominator, -numerator, fullySimplified = true) - } else { - ExactFractionImpl(denominator, numerator, fullySimplified = true) + return when { + isZero() -> throw divideByZero + isNegative() -> ExactFractionImpl(-denominator, -numerator, fullySimplified = true) + else -> ExactFractionImpl(denominator, numerator, fullySimplified = true) } } @@ -73,7 +69,10 @@ internal class ExactFractionImpl private constructor(numerator: BigInteger, deno override fun isWholeNumber(): Boolean = denominator == BigInteger.ONE override fun roundToWhole(roundingMode: RoundingMode): ExactFraction { - val decimal = numerator.toBigDecimal().divide(denominator.toBigDecimal(), roundingMode) + val mc = MathContext(0, roundingMode) + val decimal = numerator.toBigDecimal() + .divide(denominator.toBigDecimal(), roundingMode) + .round(mc) return ExactFractionImpl(decimal.toBigInteger(), BigInteger.ONE, fullySimplified = true) } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionOverflowException.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionOverflowException.kt index f2ef8eee..3f54f5b8 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionOverflowException.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionOverflowException.kt @@ -1,8 +1,8 @@ package xyz.lbres.exactnumbers.exactfraction /** - * [ArithmeticException] specifically for ExactFraction casting overflow. - * Has specific field for value of string that caused overflow + * [ArithmeticException] for ExactFraction overflow. + * Has field for string representation of value that caused overflow */ class ExactFractionOverflowException() : ArithmeticException() { override var message: String? = null diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionHelpers.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionHelpers.kt index d6b0f9ea..a3516b45 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionHelpers.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionHelpers.kt @@ -9,34 +9,35 @@ import java.math.MathContext import java.math.RoundingMode /** - * Simplify a pair of numerator and denominator values to smallest values with same ratio, and move all negatives into numerator + * Simplify numerator and denominator values to smallest values with same ratio, and move all negatives into numerator * - * @param values [TypePair]: pair to simplify, where the first value represents a numerator and the second represents a denominator + * @param numerator [BigInteger]: numerator of fraction to simplify + * @param denominator [BigInteger]: denominator of fraction to simplify * @return [TypePair]: pair where first value represents simplified numerator, and second value represents simplified denominator */ -internal fun simplifyFraction(values: TypePair): TypePair { - var numerator = values.first - var denominator = values.second +internal fun simplifyFraction(numerator: BigInteger, denominator: BigInteger): TypePair { + var newNumerator = numerator + var newDenominator = denominator // set denominator to 1 when numerator is 0 - if (numerator.isZero()) { - denominator = BigInteger.ONE + if (newNumerator.isZero()) { + newDenominator = BigInteger.ONE } // move negatives to numerator - if (denominator.isNegative()) { - numerator = -numerator - denominator = -denominator + if (newDenominator.isNegative()) { + newNumerator = -newNumerator + newDenominator = -newDenominator } // simplify using greatest common divisor - if (numerator != BigInteger.ZERO) { - val gcd = getGCD(numerator, denominator) - numerator /= gcd - denominator /= gcd + if (newNumerator != BigInteger.ZERO) { + val gcd = getGCD(newNumerator, newDenominator) + newNumerator /= gcd + newDenominator /= gcd } - return Pair(numerator, denominator) + return Pair(newNumerator, newDenominator) } /** diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionOperators.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionOperators.kt index 48cdd018..3aac8b91 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionOperators.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionOperators.kt @@ -15,10 +15,7 @@ internal fun efAdd(ef1: ExactFraction, ef2: ExactFraction): ExactFraction { return ExactFraction(newNumerator, ef1.denominator) } - val scaled1 = ef1.numerator * ef2.denominator - val scaled2 = ef2.numerator * ef1.denominator - - val newNumerator = scaled1 + scaled2 + val newNumerator = ef1.numerator * ef2.denominator + ef2.numerator * ef1.denominator val newDenominator = ef1.denominator * ef2.denominator return ExactFraction(newNumerator, newDenominator) } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionParsing.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionParsing.kt index 23826ba5..81d45121 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionParsing.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/exactfraction/exactFractionParsing.kt @@ -1,14 +1,12 @@ package xyz.lbres.exactnumbers.exactfraction -import xyz.lbres.kotlinutils.biginteger.ext.isZero import xyz.lbres.kotlinutils.general.simpleIf import xyz.lbres.kotlinutils.general.tryOrDefault -import xyz.lbres.kotlinutils.int.ext.isNegative -import xyz.lbres.kotlinutils.int.ext.isZero -import xyz.lbres.kotlinutils.string.ext.countElement -import xyz.lbres.kotlinutils.string.ext.substringTo +import java.math.BigDecimal import java.math.BigInteger -import kotlin.math.abs + +private const val efPrefix = "EF[" +private const val efSuffix = "]" /** * Parse a string from standard number format into a ExactFraction. @@ -24,52 +22,24 @@ internal fun parseDecimal(s: String): ExactFraction { // remove negative sign val isNegative = currentState.startsWith("-") - val timesNeg = simpleIf(isNegative, -BigInteger.ONE, BigInteger.ONE) if (isNegative) { currentState = currentState.substring(1) } - // remove e-value - val eIndex = currentState.indexOf('E') - var eValue = 0 - if (eIndex != -1) { - eValue = currentState.substring(eIndex + 1).toInt() - currentState = currentState.substringTo(eIndex) - } + val divResult = BigDecimal(currentState).divideAndRemainder(BigDecimal.ONE) + val whole = divResult[0].toBigInteger() - val decimalIndex: Int = currentState.indexOf('.') - val ef: ExactFraction - - // generate fraction - if (decimalIndex == -1) { - val numerator = BigInteger(currentState) - ef = ExactFraction(numerator * timesNeg) - } else { - val wholeString = simpleIf(decimalIndex == 0, "0", currentState.substringTo(decimalIndex)) - val decimalString = currentState.substring(decimalIndex + 1) - val whole = BigInteger(wholeString) - val decimal = BigInteger(decimalString) - - if (decimal.isZero()) { - ef = ExactFraction(whole * timesNeg) // also covers the case where number is 0 - } else { - val zeros = "0".repeat(decimalString.length) - val denomString = "1$zeros" - - val denominator = BigInteger(denomString) - val numerator = whole * denominator + decimal - - ef = ExactFraction(numerator * timesNeg, denominator) - } - } + val rawDecimalString = divResult[1].stripTrailingZeros().toPlainString() + val decimalIndex = rawDecimalString.indexOf('.') + val decimalString = rawDecimalString.substring(decimalIndex + 1) // starts from 0 if decimalIndex == -1 - // apply exponentiation - val eMultiplier = BigInteger.TEN.pow(abs(eValue)) - return when { - eValue.isZero() -> ef - eValue.isNegative() -> ExactFraction(ef.numerator, eMultiplier * ef.denominator) - else -> ExactFraction(eMultiplier * ef.numerator, ef.denominator) - } + val denomZeroes = "0".repeat(decimalString.length) + val denomString = "1$denomZeroes" + + val denominator = BigInteger(denomString) + val numerator = whole * denominator + BigInteger(decimalString) + + return simpleIf(isNegative, { ExactFraction(-numerator, denominator) }, { ExactFraction(numerator, denominator) }) } /** @@ -81,30 +51,14 @@ internal fun parseDecimal(s: String): ExactFraction { private fun validateDecimalString(s: String) { val exception = NumberFormatException("Error parsing $s") - val eIndex = s.indexOf('E') - val validCharacters = s.all { it.isDigit() || it == '-' || it == '.' || it == 'E' } - val validE = eIndex != 0 && eIndex != s.lastIndex && s.countElement('E') in 0..1 - if (!validCharacters || !validE) { + try { + BigDecimal(s) + } catch (_: Exception) { throw exception } - val validateMinus: (String) -> Boolean = { - it.indexOf('-') <= 0 && it.countElement('-') <= 1 - } - - val validateDecimal: (String) -> Boolean = { - it.indexOf('.') != it.lastIndex && it.countElement('.') <= 1 - } - - if (eIndex == -1 && !validateMinus(s) || !validateDecimal(s)) { + if (s.last() == '.') { throw exception - } else if (eIndex != -1) { - val preE = s.substringTo(eIndex) - val postE = s.substring(eIndex + 1) - - if (!validateMinus(preE) || !validateDecimal(preE) || !validateMinus(postE) || postE.contains('.')) { - throw exception - } } } @@ -121,10 +75,9 @@ internal fun parseEFString(s: String): ExactFraction { } try { - val numbers = s.substring(3, s.lastIndex) - val splitNumbers = numbers.split(' ') - val numString = splitNumbers[0].trim() - val denomString = splitNumbers[1].trim() + val numbers = s.trim().substring(efPrefix.length, s.length - efSuffix.length).split(' ') + val numString = numbers[0].trim() + val denomString = numbers[1].trim() val numerator = BigInteger(numString) val denominator = BigInteger(denomString) return ExactFraction(numerator, denominator) @@ -144,24 +97,21 @@ internal fun parseEFString(s: String): ExactFraction { */ internal fun checkIsEFString(s: String): Boolean { val trimmed = s.trim() - val prefix = "EF[" - val suffix = "]" - if (!trimmed.startsWith(prefix) || !trimmed.endsWith(suffix)) { + if (!trimmed.startsWith(efPrefix) || !trimmed.endsWith(efSuffix)) { return false } return tryOrDefault(false) { - val split = trimmed.substring(prefix.length, s.length - suffix.length).split(' ') + val numbers = trimmed.substring(efPrefix.length, s.length - efSuffix.length).split(' ') val validNumber: (String) -> Boolean = { when { it.isEmpty() -> false it.length == 1 -> it[0].isDigit() - it[0] == '-' -> it.substring(1).all(Char::isDigit) - else -> it.all(Char::isDigit) + else -> (it[0] == '-' || it[0].isDigit()) && it.substring(1).all(Char::isDigit) } } - split.size == 2 && validNumber(split[0]) && validNumber(split[1]) + numbers.size == 2 && validNumber(numbers[0]) && validNumber(numbers[1]) } } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/TermImpl.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/TermImpl.kt index 3d303509..18bd5992 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/TermImpl.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/TermImpl.kt @@ -10,6 +10,7 @@ import xyz.lbres.exactnumbers.utils.createHashCode import xyz.lbres.exactnumbers.utils.divideByZero import xyz.lbres.kotlinutils.collection.ext.toConstMultiSet import xyz.lbres.kotlinutils.general.simpleIf +import xyz.lbres.kotlinutils.set.multiset.anyConsistent import xyz.lbres.kotlinutils.set.multiset.const.ConstMultiSet import xyz.lbres.kotlinutils.set.multiset.const.emptyConstMultiSet import xyz.lbres.kotlinutils.set.multiset.mapToSetConsistent @@ -36,16 +37,16 @@ internal class TermImpl(coefficient: ExactFraction, factors: ConstMultiSet + this.logs = factorTypeMapping.getOrDefault(Log.TYPE, emptyList()) as List @Suppress("UNCHECKED_CAST") - squareRoots = factorTypeMapping.getOrDefault(Sqrt.TYPE, emptyList()) as List + this.squareRoots = factorTypeMapping.getOrDefault(Sqrt.TYPE, emptyList()) as List @Suppress("UNCHECKED_CAST") - pis = factorTypeMapping.getOrDefault(Pi.TYPE, emptyList()) as List - piCount = factorSet.getCountOf(Pi()) - factorSet.getCountOf(Pi().inverse()) + this.pis = factorTypeMapping.getOrDefault(Pi.TYPE, emptyList()) as List + this.piCount = factorSet.getCountOf(Pi()) - factorSet.getCountOf(Pi().inverse()) } } @@ -77,8 +78,8 @@ internal class TermImpl(coefficient: ExactFraction, factors: ConstMultiSet>: list of irrational numbers, which all have the provided type @@ -130,8 +131,8 @@ internal class TermImpl(coefficient: ExactFraction, factors: ConstMultiSet", "<${coeffString}x$numString>") + val factorString = factorSet.joinToString("x") + val result = simpleIf(factorString.isEmpty(), "<$coeffString>", "<${coeffString}x$factorString>") string = result } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/helpers.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/helpers.kt index fde96f73..62c86f14 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/helpers.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/expressions/term/helpers.kt @@ -7,7 +7,6 @@ import xyz.lbres.exactnumbers.irrationals.pi.Pi import xyz.lbres.exactnumbers.irrationals.sqrt.Sqrt import xyz.lbres.kotlinutils.collection.ext.toConstMultiSet import xyz.lbres.kotlinutils.general.simpleIf -import xyz.lbres.kotlinutils.set.multiset.anyConsistent import xyz.lbres.kotlinutils.set.multiset.const.ConstMultiSet import xyz.lbres.kotlinutils.set.multiset.const.ConstMutableMultiSet import xyz.lbres.kotlinutils.set.multiset.const.constMutableMultiSetOf @@ -53,9 +52,8 @@ internal fun createSimplifiedTerm(coefficient: ExactFraction, factorGroups: Map< * with rational values, and the second is a set of the irrational values */ private fun simplifyGenericIrrational(values: ConstMultiSet>): Pair>> { - when { - values.isEmpty() -> return Pair(ExactFraction.ONE, emptyConstMultiSet()) - values.anyConsistent { it.isZero() } -> return Pair(ExactFraction.ZERO, emptyConstMultiSet()) + if (values.isEmpty()) { + return Pair(ExactFraction.ONE, emptyConstMultiSet()) } val distinct = values.mapToSetConsistent { simpleIf(it.isInverted, { it.inverse() }, { it }) }.distinctValues @@ -64,6 +62,10 @@ private fun simplifyGenericIrrational(values: ConstMultiSet> // avoids creating a standard MultiSet for efficiency val simplifiedValues: ConstMutableMultiSet> = constMutableMultiSetOf() for (value in distinct) { + if (value.isZero()) { + return Pair(ExactFraction.ONE, emptyConstMultiSet()) + } + val diff = values.getCountOf(value) - values.getCountOf(value.inverse()) val simplifiedValue = simpleIf(diff < 0, { value.inverse() }, { value }) diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/ext/BigDecimalExt.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/ext/BigDecimalExt.kt index d7fe78be..bfc18537 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/ext/BigDecimalExt.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/ext/BigDecimalExt.kt @@ -10,7 +10,7 @@ import java.math.MathContext * @param other [BigDecimal]: number to divide by * @return [BigDecimal]: result of division */ -fun BigDecimal.divideBy(other: BigDecimal): BigDecimal { +internal fun BigDecimal.divideBy(other: BigDecimal): BigDecimal { if (other == BigDecimal.ZERO) { throw divideByZero } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/Log.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/Log.kt index 5c18164d..26472b92 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/Log.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/Log.kt @@ -4,7 +4,6 @@ import xyz.lbres.exactnumbers.exactfraction.ExactFraction import xyz.lbres.exactnumbers.irrationals.IrrationalNumber import xyz.lbres.kotlinutils.collection.ext.toConstMultiSet import xyz.lbres.kotlinutils.general.simpleIf -import xyz.lbres.kotlinutils.set.multiset.anyConsistent import xyz.lbres.kotlinutils.set.multiset.const.ConstMultiSet import xyz.lbres.kotlinutils.set.multiset.const.ConstMutableMultiSet import xyz.lbres.kotlinutils.set.multiset.const.constMutableMultiSetOf @@ -41,9 +40,8 @@ sealed class Log : IrrationalNumber() { */ // TODO: improve simplification by looking at bases internal fun simplifySet(numbers: ConstMultiSet): Pair> { - when { - numbers.isEmpty() -> return Pair(ExactFraction.ONE, emptyConstMultiSet()) - numbers.anyConsistent(Log::isZero) -> return Pair(ExactFraction.ZERO, emptyConstMultiSet()) + if (numbers.isEmpty()) { + return Pair(ExactFraction.ONE, emptyConstMultiSet()) } val simplifiedNumbers = numbers.mapToSetConsistent { it.getSimplified() } @@ -55,11 +53,14 @@ sealed class Log : IrrationalNumber() { // avoids creating a standard MultiSet for efficiency val simplifiedValues: ConstMutableMultiSet = constMutableMultiSetOf() for (log in distinct) { + if (log.isZero()) { + return Pair(ExactFraction.ZERO, emptyConstMultiSet()) + } + if (log != ONE) { val diff = logValues.getCountOf(log) - logValues.getCountOf(log.inverse()) - val simplified: ConstMultiSet = ConstMultiSet(abs(diff)) { - simpleIf(diff < 0, { log.inverse() }, { log }) - } + val valueToAdd = simpleIf(diff < 0, { log.inverse() }, { log }) + val simplified: ConstMultiSet = ConstMultiSet(abs(diff)) { valueToAdd } simplifiedValues.addAll(simplified) } } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogImpl.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogImpl.kt index 8625d608..dd479bc0 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogImpl.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogImpl.kt @@ -97,8 +97,8 @@ internal class LogImpl private constructor( } override fun toString(): String { - val numString = argument.toFractionString() - return simpleIf(isInverted, "[1/log_$base($numString)]", "[log_$base($numString)]") + val argString = argument.toFractionString() + return simpleIf(isInverted, "[1/log_$base($argString)]", "[log_$base($argString)]") } override fun hashCode(): Int = createHashCode(listOf(argument, base, isInverted, type)) diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/helpers.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/helpers.kt index 9430a7c5..32dda70e 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/helpers.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/log/helpers.kt @@ -8,19 +8,19 @@ import kotlin.math.log /** * Get log value of a whole number with the given base * - * @param num [BigInteger]: number to get log of + * @param argument [BigInteger]: argument to use in calculation * @param base [Int]: base to use in calculation * @return [BigDecimal]: the log of the number, using the current base */ -internal fun getLogOf(num: BigInteger, base: Int): BigDecimal { - val logNum = log(num.toDouble(), base.toDouble()) +internal fun getLogOf(argument: BigInteger, base: Int): BigDecimal { + val logNum = log(argument.toDouble(), base.toDouble()) when { logNum.isNaN() -> throw ArithmeticException("Error calculating log") - logNum.isInfinite() -> throw ArithmeticException("Error calculating log: overflow on log_$base($num)") + logNum.isInfinite() -> throw ArithmeticException("Error calculating log: overflow on log_$base($argument)") } // account for imprecision with doubles - val int = getIntFromDecimal(logNum.toBigDecimal()) { base.toBigInteger().pow(it.toInt()) == num } + val int = getIntFromDecimal(logNum.toBigDecimal()) { base.toBigInteger().pow(it.toInt()) == argument } return int?.toBigDecimal() ?: logNum.toBigDecimal() } diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/Sqrt.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/Sqrt.kt index fd9ac04a..ab915db1 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/Sqrt.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/Sqrt.kt @@ -3,7 +3,6 @@ package xyz.lbres.exactnumbers.irrationals.sqrt import xyz.lbres.exactnumbers.exactfraction.ExactFraction import xyz.lbres.exactnumbers.irrationals.IrrationalNumber import xyz.lbres.kotlinutils.general.simpleIf -import xyz.lbres.kotlinutils.set.multiset.anyConsistent import xyz.lbres.kotlinutils.set.multiset.const.ConstMultiSet import xyz.lbres.kotlinutils.set.multiset.const.constMultiSetOf import xyz.lbres.kotlinutils.set.multiset.const.emptyConstMultiSet @@ -41,13 +40,16 @@ sealed class Sqrt : IrrationalNumber() { * @return [Pair]>: product of rational values and a set containing a single, fully simplified irrational root */ internal fun simplifySet(numbers: ConstMultiSet): Pair> { - when { - numbers.isEmpty() -> return Pair(ExactFraction.ONE, emptyConstMultiSet()) - numbers.anyConsistent(Sqrt::isZero) -> return Pair(ExactFraction.ZERO, emptyConstMultiSet()) + if (numbers.isEmpty()) { + return Pair(ExactFraction.ONE, emptyConstMultiSet()) } - // combine all roots into single root, and return that value + // combine all roots into single root val totalProduct = numbers.fold(ExactFraction.ONE) { acc, sqrt -> acc * sqrt.radicand } + if (totalProduct == ExactFraction.ZERO) { + return Pair(ExactFraction.ZERO, emptyConstMultiSet()) + } + val numeratorWhole = extractWholeOf(totalProduct.numerator) val denominatorWhole = extractWholeOf(totalProduct.denominator) val numeratorRoot = totalProduct.numerator / (numeratorWhole * numeratorWhole) diff --git a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/utils/castingUtils.kt b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/utils/castingUtils.kt index d527b3ad..7c81db50 100644 --- a/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/utils/castingUtils.kt +++ b/exact-numbers/src/main/kotlin/xyz/lbres/exactnumbers/utils/castingUtils.kt @@ -5,10 +5,10 @@ import java.math.BigDecimal import java.math.BigInteger /** - * Cast a number to Byte, or throw an exception if number exceeds values for Byte + * Cast a number to Byte, or throw an exception if it exceeds values for Byte * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Byte] value as a byte */ @@ -18,10 +18,10 @@ internal fun castToByte(decimal: BigDecimal, value: T, type: String): Byte { } /** - * Cast a number to Char, or throw an exception if number exceeds values for Char + * Cast a number to Char, or throw an exception if it exceeds values for Char * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Char] value as a char */ @@ -35,10 +35,10 @@ internal fun castToChar(decimal: BigDecimal, value: T, type: String): Char { } /** - * Cast a number to Short, or throw an exception if number exceeds values for Short + * Cast a number to Short, or throw an exception if it exceeds values for Short * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Short] value as a short */ @@ -48,10 +48,10 @@ internal fun castToShort(decimal: BigDecimal, value: T, type: String): Short } /** - * Cast a number to Int, or throw an exception if number exceeds values for Int + * Cast a number to Int, or throw an exception if it exceeds values for Int * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Int] value as an int */ @@ -61,10 +61,10 @@ internal fun castToInt(decimal: BigDecimal, value: T, type: String): Int { } /** - * Cast a number to Long, or throw an exception if number exceeds values for Long + * Cast a number to Long, or throw an exception if it exceeds values for Long * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Long] value as a long */ @@ -74,10 +74,10 @@ internal fun castToLong(decimal: BigDecimal, value: T, type: String): Long { } /** - * Cast a number to Float, or throw an exception if number exceeds values for Float + * Cast a number to Float, or throw an exception if it exceeds values for Float * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Float] value as a float */ @@ -87,10 +87,10 @@ internal fun castToFloat(decimal: BigDecimal, value: T, type: String): Float } /** - * Cast a number to Double, or throw an exception if number exceeds values for Double + * Cast a number to Double, or throw an exception if it exceeds values for Double * * @param decimal [BigDecimal]: number to cast as decimal - * @param value [T]: number to cast + * @param value T: number to cast * @param type [String]: base type * @return [Double] value as a double */ @@ -108,7 +108,7 @@ internal fun castToDouble(decimal: BigDecimal, value: T, type: String): Doub * @param cast (BigDecimal) -> T: function to cast [value] * @param getOverflowException () -> [CastingOverflowException]: get exception to throw if number exceeds supported values * @param isDecimal [Boolean]: flag to indicate if [value] is being cast to a whole number or a decimal - * @return [T]: result of cast, if succeeded + * @return T: result of cast, if succeeded */ private fun castNumber( value: BigDecimal, diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionConstructorsTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionConstructorsTest.kt index 9e460cb0..73271682 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionConstructorsTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionConstructorsTest.kt @@ -2,9 +2,9 @@ package xyz.lbres.exactnumbers.exactfraction import org.junit.Test import xyz.lbres.exactnumbers.testutils.assertDivByZero +import xyz.lbres.exactnumbers.testutils.assertFailsWithMessage import java.math.BigInteger import kotlin.test.assertEquals -import kotlin.test.assertFailsWith class ExactFractionConstructorsTest { @Test @@ -27,13 +27,18 @@ class ExactFractionConstructorsTest { assertEquals(BigInteger("3"), ef.denominator) // invalid - assertFailsWith("Invalid EF string format") { ExactFraction("[]") } + assertFailsWithMessage("Error parsing []") { ExactFraction("[]") } } private fun runSingleValTests() { runMultiTypeSingleValTest(0, ExactFraction(BigInteger.ZERO, BigInteger.ONE)) runMultiTypeSingleValTest(3, ExactFraction(BigInteger("3"), BigInteger.ONE)) runMultiTypeSingleValTest(-3, ExactFraction(BigInteger("-3"), BigInteger.ONE)) + + val largeValue = BigInteger("10000000000000000345678") + val ef = ExactFraction(largeValue) + assertEquals(largeValue, ef.numerator) + assertEquals(BigInteger.ONE, ef.denominator) } private fun runPairValTests() { @@ -67,6 +72,12 @@ class ExactFractionConstructorsTest { // negative fraction < -1 runMultiTypePairValTest(-7, 4, ExactFraction(BigInteger("-7"), BigInteger("4"))) + + val largeValue1 = BigInteger("1000000000000000000345678") + val largeValue2 = BigInteger("88888888888888888888889") + val ef = ExactFraction(largeValue1, largeValue2) + assertEquals(largeValue1, ef.numerator) + assertEquals(largeValue2, ef.denominator) } /** @@ -85,7 +96,7 @@ class ExactFractionConstructorsTest { * Run two-val test with all combinations of Int, Long, and BigInteger values * * @param value1 [Int]: first value to cast to Int, Long, and BigInteger - * @param value2 [Int]: first value to cast to Int, Long, and BigInteger + * @param value2 [Int]: second value to cast to Int, Long, and BigInteger * @param expected [ExactFraction]: expected result */ private fun runMultiTypePairValTest(value1: Int, value2: Int, expected: ExactFraction) { diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionHelpersTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionHelpersTest.kt index 25c6dbd3..7389da15 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionHelpersTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionHelpersTest.kt @@ -7,7 +7,7 @@ import kotlin.test.assertEquals class ExactFractionHelpersTest { @Test - fun testSimplifyFraction() = runCommonSimplifyTests { bi1, bi2 -> simplifyFraction(Pair(bi1, bi2)) } + fun testSimplifyFraction() = runCommonSimplifyTests(::simplifyFraction) @Test fun testCreateDecimalString() { @@ -65,8 +65,7 @@ class ExactFractionHelpersTest { expected = "-0.21053" assertEquals(expected, createDecimalString(ef, 5)) - val largeValue = "100000000000000000000" - val bi = BigInteger(largeValue) + val bi = BigInteger("100000000000000000000") ef = ExactFraction(bi, 3) expected = "33333333333333333333.333333" assertEquals(expected, createDecimalString(ef, 6)) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionParsingTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionParsingTest.kt new file mode 100644 index 00000000..9e3d74fa --- /dev/null +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionParsingTest.kt @@ -0,0 +1,9 @@ +package xyz.lbres.exactnumbers.exactfraction + +import kotlin.test.Test + +class ExactFractionParsingTest { + @Test fun testParseDecimal() = runParseDecimalTests() + @Test fun testParseEFString() = runParseEFStringTests() + @Test fun testCheckIsEFString() = runCommonCheckEFStringTests(::checkIsEFString) +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionTest.kt index c9140db4..6d1c1d74 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/ExactFractionTest.kt @@ -38,9 +38,7 @@ class ExactFractionTest { @Test fun testIsWholeNumber() = runIsWholeNumberTests() // parsing + toString - @Test fun testParseDecimal() = runParseDecimalTests() - @Test fun testParseEFString() = runParseEFStringTests() - @Test fun testCheckIsEFString() = runCheckIsEFStringTests() + @Test fun testIsEFString() = runCommonCheckEFStringTests(ExactFraction.Companion::isEFString) @Test fun testToDecimalString() = runToDecimalStringTests() @Test fun testToFractionString() = runToFractionStringTests() @Test fun testToPairString() = runToPairStringTests() diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/castingTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/castingTests.kt index 0ebad54a..c927ebcb 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/castingTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/castingTests.kt @@ -33,6 +33,16 @@ fun runToPairTests() { ef = ExactFraction(173, 9) expected = Pair(BigInteger("173"), BigInteger("9")) assertEquals(expected, ef.toPair()) + + val largeValue1 = "-800000000000000000000000000000000000" + val largeValue2 = "2000000000000000000000000000000000000" + ef = ExactFraction(BigInteger(largeValue1), BigInteger(largeValue2)) + expected = Pair(BigInteger("-2"), BigInteger("5")) + assertEquals(expected, ef.toPair()) + + ef = ExactFraction(BigInteger(largeValue2), BigInteger("9")) + expected = Pair(BigInteger(largeValue2), BigInteger("9")) + assertEquals(expected, ef.toPair()) } fun runToByteTests() { diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonPowTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonPowTests.kt index 5c8deb2a..1f9ba4b6 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonPowTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonPowTests.kt @@ -14,6 +14,16 @@ fun runCommonPowTests(powFn: (ExactFraction, ExactFraction) -> ExactFraction) { var expected = ExactFraction.ONE assertEquals(expected, powFn(base, exp)) + base = ExactFraction.ZERO + exp = ExactFraction.ZERO + expected = ExactFraction.ZERO + assertEquals(expected, powFn(base, exp)) + + base = ExactFraction.ZERO + exp = ExactFraction.NINE + expected = ExactFraction.ZERO + assertEquals(expected, powFn(base, exp)) + base = ExactFraction.NINE exp = ExactFraction.ONE expected = ExactFraction.NINE diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonSimplifyTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonSimplifyTests.kt index 3f7a74b0..b0e1ac56 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonSimplifyTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/commonSimplifyTests.kt @@ -30,8 +30,8 @@ private fun runSimplifyZeroTests(createSimplifiedPair: (BigInteger, BigInteger) } private fun runSimplifySignTests(createSimplifiedPair: (BigInteger, BigInteger) -> TypePair) { - var pair = createSimplifiedPair(BigInteger("-3"), BigInteger("-4")) - var expected = Pair(BigInteger("3"), BigInteger("4")) + var pair = createSimplifiedPair(BigInteger("-14"), BigInteger("-3")) + var expected = Pair(BigInteger("14"), BigInteger("3")) assertEquals(expected, pair) pair = createSimplifiedPair(BigInteger.ONE, BigInteger("-3")) @@ -63,4 +63,10 @@ private fun runSimplifyGCDTests(createSimplifiedPair: (BigInteger, BigInteger) - pair = createSimplifiedPair(-BigInteger.TWO, BigInteger.TWO) expected = Pair(-BigInteger.ONE, BigInteger.ONE) assertEquals(expected, pair) + + val largeValue1 = BigInteger("-800000000000000000000000000000000000") + val largeValue2 = BigInteger("2000000000000000000000000000000000000") + pair = createSimplifiedPair(largeValue1, largeValue2) + expected = Pair(BigInteger("-2"), BigInteger("5")) + assertEquals(expected, pair) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/compareToTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/compareToTests.kt index 7607b56f..34922866 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/compareToTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/compareToTests.kt @@ -36,52 +36,49 @@ fun runCompareToTests() { first = ExactFraction(-3, 4) second = ExactFraction(-2) assertTrue(first > second) + assertTrue(second < first) first = ExactFraction(-3, 4) second = ExactFraction(-4, 3) assertTrue(first > second) + assertTrue(second < first) // positive order first = ExactFraction(3) second = ExactFraction(2) assertTrue(first > second) + assertTrue(second < first) first = ExactFraction(3, 4) second = ExactFraction(4, 3) assertTrue(first < second) + assertTrue(second > first) // other number types - runMultiTypeCompareTest(ExactFraction.ZERO, 0, 0) // eq - runMultiTypeCompareTest(ExactFraction(100, 3), 100, -1) // lt - runMultiTypeCompareTest(ExactFraction(3, 2), 0, 1) // gt - runMultiTypeCompareTest(ExactFraction(3), 2, 1) // gt - runMultiTypeCompareTest(ExactFraction(-3, 4), -2, 1) // lt + runMultiTypeEqTest(ExactFraction.NEG_ONE, -1) + runMultiTypeLtTest(ExactFraction(100, 3), 100) + runMultiTypeGtTest(ExactFraction(3, 2), 0) + runMultiTypeGtTest(ExactFraction(3), 2) + runMultiTypeLtTest(ExactFraction(-9, 4), -2) +} + +// run compare test where ef == other +private fun runMultiTypeEqTest(ef: ExactFraction, other: Int) { + assertEquals(0, ef.compareTo(other)) + assertEquals(0, ef.compareTo(other.toLong())) + assertEquals(0, ef.compareTo(other.toBigInteger())) +} + +// run compare test where ef > other +private fun runMultiTypeGtTest(ef: ExactFraction, other: Int) { + assertTrue(ef > other) + assertTrue(ef > other.toLong()) + assertTrue(ef > other.toBigInteger()) } -/** - * Run test with Int, Long, and BigInteger values - * - * @param ef [ExactFraction]: first value in comparison - * @param other [Int]: value to cast to Int, Long, and BigInteger - * @param expected [Int]: expected result - */ -private fun runMultiTypeCompareTest(ef: ExactFraction, other: Int, expected: Int) { - // test infix operator - when (expected) { - -1 -> { - assertTrue { - ef < other && ef < other.toLong() && ef < other.toBigInteger() - } - } - 1 -> { - assertTrue { - ef > other && ef > other.toLong() && ef > other.toBigInteger() - } - } - 0 -> { - assertTrue { - ef.compareTo(other) == 0 && ef.compareTo(other.toLong()) == 0 && ef.compareTo(other.toBigInteger()) == 0 - } - } - } +// run compare test where ef < other +private fun runMultiTypeLtTest(ef: ExactFraction, other: Int) { + assertTrue(ef < other) + assertTrue(ef < other.toLong()) + assertTrue(ef < other.toBigInteger()) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/equalsTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/equalsTests.kt index 610a2240..67dbcf5d 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/equalsTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/equalsTests.kt @@ -21,6 +21,7 @@ fun runEqTests() { runMultiTypeEqTest(ExactFraction(34, 17), 2, true) runMultiTypeEqTest(ExactFraction(10), -10, false) + runMultiTypeEqTest(ExactFraction(1, 10), 10, false) runMultiTypeEqTest(ExactFraction(10, 7), 1, false) runMultiTypeEqTest(ExactFraction(-70), 0, false) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/stringTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/stringTests.kt index 46a3a0a6..484657dd 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/stringTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/stringTests.kt @@ -100,6 +100,10 @@ fun runParseDecimalTests() { expected = ExactFraction(39, 10000) assertEquals(expected, parseDecimal(s)) + s = "3.90e-3" // 0.00390 + expected = ExactFraction(39, 10000) + assertEquals(expected, parseDecimal(s)) + s = "-5E-10" // -0.0000000005 expected = ExactFraction(-5, 10000000000) assertEquals(expected, parseDecimal(s)) @@ -137,9 +141,6 @@ fun runParseDecimalTests() { s = "123a456" assertFailsWithMessage("Error parsing 123a456") { parseDecimal(s) } - s = "3.90e-3" - assertFailsWithMessage("Error parsing 3.90e-3") { parseDecimal(s) } - s = "E10" assertFailsWithMessage("Error parsing E10") { parseDecimal(s) } @@ -196,36 +197,36 @@ fun runParseEFStringTests() { assertFailsWithMessage("Invalid EF string format: EF[1 1 1]") { parseEFString(s) } } -fun runCheckIsEFStringTests() { +fun runCommonCheckEFStringTests(checkString: (String) -> Boolean) { var s = "EF[10 1]" - assertTrue(checkIsEFString(s)) + assertTrue(checkString(s)) s = "EF[-5 2]" - assertTrue(checkIsEFString(s)) + assertTrue(checkString(s)) s = "EF[0 ]" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "EF[0]" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "EF[0 0 0]" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "EF[0.1 2]" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "EF[]" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "EF[" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "EF]" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) s = "hello world" - assertFalse(checkIsEFString(s)) + assertFalse(checkString(s)) } // toString diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/timesDivPowTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/timesDivPowTests.kt index 2d797dc4..81f036aa 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/timesDivPowTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/timesDivPowTests.kt @@ -95,7 +95,7 @@ fun runPowTests() { } /** - * Run test with Int, Long, and BigInteger values + * Run times test with Int, Long, and BigInteger values * * @param ef [ExactFraction]: first value in multiplication * @param other [Int]: value to cast to Int, Long, and BigInteger @@ -108,7 +108,7 @@ private fun runMultiTypeTimesTest(ef: ExactFraction, other: Int, expected: Exact } /** - * Run test with Int, Long, and BigInteger values + * Run div test with Int, Long, and BigInteger values * * @param ef [ExactFraction]: first value in division * @param other [Int]: value to cast to Int, Long, and BigInteger @@ -121,7 +121,7 @@ private fun runMultiTypeDivTest(ef: ExactFraction, other: Int, expected: ExactFr } /** - * Run test with Int, Long, and BigInteger values + * Run pow test with Int, Long, and BigInteger values * * @param ef [ExactFraction]: base number * @param other [Int]: value to cast to Int, Long, and BigInteger diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/unaryNonOpTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/unaryNonOpTests.kt index 94b74e09..a530b655 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/unaryNonOpTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/exactfraction/unaryNonOpTests.kt @@ -99,24 +99,20 @@ fun runIsZeroTests() { fun runRoundToWholeTests() { // whole var ef = ExactFraction.ZERO - var expected = ExactFraction.ZERO - assertEquals(expected, ef.roundToWhole()) + assertEquals(ef, ef.roundToWhole()) ef = ExactFraction.ONE - expected = ExactFraction.ONE - assertEquals(expected, ef.roundToWhole()) + assertEquals(ef, ef.roundToWhole()) ef = ExactFraction(BigInteger("1000000000000000000000")) - expected = ExactFraction(BigInteger("1000000000000000000000")) - assertEquals(expected, ef.roundToWhole()) + assertEquals(ef, ef.roundToWhole()) ef = ExactFraction(-123) - expected = ExactFraction(-123) - assertEquals(expected, ef.roundToWhole()) + assertEquals(ef, ef.roundToWhole()) // up ef = ExactFraction.HALF - expected = ExactFraction.ONE + var expected = ExactFraction.ONE assertEquals(expected, ef.roundToWhole()) ef = ExactFraction(-1, 3) @@ -153,10 +149,6 @@ fun runRoundToWholeTests() { expected = ExactFraction.ZERO assertEquals(expected, ef.roundToWhole()) - ef = ExactFraction(7, 3) - expected = ExactFraction.TWO - assertEquals(expected, ef.roundToWhole()) - ef = ExactFraction(-5, 3) expected = -ExactFraction.TWO assertEquals(expected, ef.roundToWhole()) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/HelpersTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/HelpersTest.kt index ceb9858f..ec8ede2d 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/HelpersTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/HelpersTest.kt @@ -4,7 +4,7 @@ import org.junit.Test class HelpersTest { @Test - fun testCreateSimplifiedTerm() = runCommonSimplifyTests { - createSimplifiedTerm(it.coefficient, it.factors.groupBy { factor -> factor.type }) + fun testCreateSimplifiedTerm() = runCommonSimplifyTests { term -> + createSimplifiedTerm(term.coefficient, term.factors.groupBy { it.type }) } } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/TermTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/TermTest.kt index b177746f..3335f540 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/TermTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/TermTest.kt @@ -1,196 +1,27 @@ package xyz.lbres.exactnumbers.expressions.term -import xyz.lbres.exactnumbers.exactfraction.ExactFraction -import xyz.lbres.exactnumbers.irrationals.log.Log -import xyz.lbres.exactnumbers.irrationals.pi.Pi -import xyz.lbres.exactnumbers.irrationals.sqrt.Sqrt -import xyz.lbres.exactnumbers.testutils.TestNumber import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertNotEquals class TermTest { - private val logNum1 = Log(ExactFraction(15, 4)) - private val logNum2 = Log(8, 7) - private val logNum3 = Log(ExactFraction(19, 33)).inverse() - private val logNum4 = Log(ExactFraction(25, 121)) - private val testNumber1 = TestNumber(ExactFraction(5, 6)) - private val testNumber2 = TestNumber(ExactFraction.SEVEN) - private val one = ExactFraction.ONE - @Test fun testConstructor() = runConstructorTests() @Test fun testTimes() = runTimesTests() @Test fun testDiv() = runDivTests() + @Test fun testEquals() = runEqualsTests() @Test fun testGetSimplified() = runCommonSimplifyTests(Term::getSimplified) @Test fun testGetValue() = runGetValueTests() - @Test fun testGetFactorsByType() = runGetFactorsByTypeTests() - - @Test - fun testEquals() { - // equal - var term1 = Term.ZERO - assertEquals(term1, term1) - - term1 = Term.fromValues(ExactFraction(-17, 4), emptyList()) - assertEquals(term1, term1) - - term1 = Term.fromValues(one, listOf(logNum1, logNum2)) - assertEquals(term1, term1) - - term1 = Term.fromValues(one, listOf(Pi(), Pi())) - assertEquals(term1, term1) - - term1 = Term.fromValues(ExactFraction.EIGHT, listOf(logNum4, logNum3, logNum1, Sqrt(15), Pi().inverse(), Pi())) - assertEquals(term1, term1) - - term1 = Term.fromValues(one, listOf(Pi(), TestNumber(ExactFraction(5)))) - assertEquals(term1, term1) - - // not equal - term1 = Term.ONE - var term2 = -Term.ONE - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(ExactFraction.TWO, emptyList()) - term2 = Term.fromValues(ExactFraction.HALF, emptyList()) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(logNum1)) - term2 = Term.ONE - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(logNum1)) - term2 = Term.fromValues(one, listOf(logNum1.inverse())) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(logNum1)) - term2 = Term.fromValues(one, listOf(logNum1, logNum2)) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(Pi())) - term2 = Term.ONE - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(Pi())) - term2 = Term.fromValues(one, listOf(Pi().inverse())) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(Pi(), Pi().inverse())) - term2 = Term.fromValues(one, listOf(Pi().inverse())) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(Sqrt(12))) - term2 = Term.ONE - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(Sqrt(12))) - term2 = Term.fromValues(one, listOf(Sqrt(ExactFraction(1, 12)))) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(one, listOf(Sqrt(12), Sqrt(1000))) - term2 = Term.fromValues(one, listOf(Sqrt(ExactFraction(1, 12)))) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(ExactFraction.EIGHT, listOf(Log(15))) - term2 = Term.fromValues(ExactFraction.EIGHT, listOf(Sqrt(15))) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(ExactFraction(5, 7), listOf(logNum1, logNum1, Pi(), Pi().inverse())) - term2 = Term.fromValues(ExactFraction.FIVE, listOf(logNum1, logNum1, Pi(), Pi().inverse())) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(ExactFraction.EIGHT, listOf(logNum3, logNum4, Pi().inverse())) - term2 = Term.fromValues(ExactFraction(-17, 15), listOf(logNum1, logNum2, logNum3)) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - - term1 = Term.fromValues(ExactFraction.FOUR, listOf(Pi(), testNumber1)) - term2 = Term.fromValues(ExactFraction.FOUR, listOf(Pi(), testNumber1.inverse())) - assertNotEquals(term1, term2) - assertNotEquals(term2, term1) - } - @Test fun testUnaryMinus() = runUnaryMinusTests() @Test fun testUnaryPlus() = runUnaryPlusTests() @Test fun testIsZero() = runIsZeroTests() + @Test fun testGetFactorsByType() = runGetFactorsByTypeTests() @Test fun testGetLogs() = runGetLogsTests() @Test fun testGetPiCount() = runGetPiCountTests() @Test fun testGetSquareRoots() = runGetSquareRootsTests() - @Test - fun testToString() { - // zero - var term = Term.ZERO - var expected = "<0>" - assertEquals(expected, term.toString()) - - // just coefficient - term = Term.fromValues(ExactFraction(-25), emptyList()) - expected = "<-25>" - assertEquals(expected, term.toString()) - - term = Term.fromValues(ExactFraction(44, 7), emptyList()) - expected = "<[44/7]>" - assertEquals(expected, term.toString()) - - // just logs - term = Term.fromValues(one, listOf(Log.ONE)) - expected = "<1x${Log.ONE}>" - assertEquals(expected, term.toString()) - - term = Term.fromValues(one, listOf(logNum2, logNum4, logNum1)) - expected = "<1x${logNum2}x${logNum4}x$logNum1>" - assertEquals(expected, term.toString()) - - // just pi - term = Term.fromValues(one, listOf(Pi())) - expected = "<1x${Pi()}>" - assertEquals(expected, term.toString()) - - term = Term.fromValues(one, listOf(Pi(), Pi().inverse(), Pi())) - expected = "<1x${Pi()}x${Pi().inverse()}x${Pi()}>" - assertEquals(expected, term.toString()) - - // just sqrt - term = Term.fromValues(one, listOf(Sqrt.ONE)) - expected = "<1x${Sqrt.ONE}>" - assertEquals(expected, term.toString()) - - term = Term.fromValues(one, listOf(Sqrt(32), Sqrt(127), Sqrt(ExactFraction(2, 9)))) - expected = "<1x${Sqrt(32)}x${Sqrt(127)}x${Sqrt(ExactFraction(2, 9))}>" - assertEquals(expected, term.toString()) - - // mix - term = Term.fromValues(ExactFraction.EIGHT, listOf(logNum3, Sqrt(12), testNumber2, Pi())) - expected = "<8x${logNum3}x${Sqrt(12)}x${testNumber2}x${Pi()}>" - assertEquals(expected, term.toString()) - - val sqrt1 = Sqrt(ExactFraction(1000, 109)) - val sqrt2 = Sqrt(5096) - term = Term.fromValues( - ExactFraction(-100, 333), - listOf(logNum2, logNum2, logNum4, logNum1, sqrt1, sqrt2, Pi().inverse(), Pi()) - ) - expected = "<[-100/333]x${logNum2}x${logNum2}x${logNum4}x${logNum1}x${sqrt1}x${sqrt2}x${Pi().inverse()}x${Pi()}>" - assertEquals(expected, term.toString()) - } + @Test fun testToString() = runToStringTests() @Test fun testToByte() = runToByteTests() @Test fun testToChar() = runToCharTests() diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/castingTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/castingTests.kt index e8d4b5bc..f7112d77 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/castingTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/castingTests.kt @@ -4,6 +4,7 @@ import xyz.lbres.exactnumbers.exactfraction.ExactFraction import xyz.lbres.exactnumbers.irrationals.log.Log import xyz.lbres.exactnumbers.irrationals.pi.Pi import xyz.lbres.exactnumbers.irrationals.sqrt.Sqrt +import xyz.lbres.exactnumbers.testutils.TestNumber import xyz.lbres.exactnumbers.testutils.assertSucceeds import xyz.lbres.exactnumbers.testutils.getCastingOverflowAssertion import kotlin.test.assertEquals @@ -30,8 +31,8 @@ fun runToCharTests() { expected = 116.toChar() assertEquals(expected, term.toChar()) - factors = listOf(Sqrt(17), Pi(), Pi(), Log(1245, 12)) - term = Term.fromValues(ExactFraction(7, 17), factors) + factors = listOf(Sqrt(17), Pi(), Pi(), TestNumber(ExactFraction(3)), Log(1245, 12)) + term = Term.fromValues(ExactFraction(7, 51), factors) expected = 48.toChar() assertEquals(expected, term.toChar()) @@ -104,8 +105,8 @@ private fun runWholeNumberCastingTests(castLong: (Long) -> T, castT expected = castLong(116) assertEquals(expected, castTerm(term)) - factors = listOf(Sqrt(17), Pi(), Pi(), Log(1245, 12)) - term = Term.fromValues(ExactFraction(7, 17), factors) + factors = listOf(Sqrt(17), Pi(), Pi(), TestNumber(ExactFraction(3)), Log(1245, 12)) + term = Term.fromValues(ExactFraction(7, 51), factors) expected = castLong(48) assertEquals(expected, castTerm(term)) @@ -160,7 +161,7 @@ private fun runDecimalNumberCastingTests(castDouble: (Double) -> T, expected = castDouble(-8.377580409572781) assertEquals(expected, castTerm(term)) - term = Term.fromValues(ExactFraction.HALF, listOf(Log(4, 2).inverse(), Log(123456789), Pi().inverse())) + term = Term.fromValues(ExactFraction.EIGHT, listOf(TestNumber(ExactFraction(1, 16)), Log(4, 2).inverse(), Log(123456789), Pi().inverse())) expected = castDouble(0.6439023028592971) assertEquals(expected, castTerm(term)) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/constuctorTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/constuctorTests.kt index bc711261..4249498e 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/constuctorTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/constuctorTests.kt @@ -25,11 +25,11 @@ private val testNumber2 = TestNumber(ExactFraction.SEVEN) private val one = ExactFraction.ONE fun runConstructorTests() { - runFullListConstructorTests() + runFactorsConstructorTests() runComponentConstructorTests() } -private fun runFullListConstructorTests() { +private fun runFactorsConstructorTests() { // zero var term = Term.fromValues(ExactFraction.ZERO, emptyList()) checkTerm(term, ExactFraction.ZERO) @@ -86,8 +86,8 @@ private fun runFullListConstructorTests() { term = Term.fromValues(ExactFraction(-1, 5), sqrts + pis) checkTerm(term, ExactFraction(-1, 5), sqrts + pis, emptyList(), sqrts, pis, 1) - term = Term.fromValues(one, sqrts + pis + logs + listOf(testNumber1, testNumber2)) - checkTerm(term, one, sqrts + pis + logs + listOf(testNumber1, testNumber2), logs, sqrts, pis, 1) + term = Term.fromValues(one, pis + logs + listOf(testNumber1, testNumber2)) + checkTerm(term, one, pis + logs + listOf(testNumber1, testNumber2), logs, sqrts = emptyList(), pis, 1) } private fun runComponentConstructorTests() { diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/equalsToStringTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/equalsToStringTests.kt new file mode 100644 index 00000000..4f6b3672 --- /dev/null +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/equalsToStringTests.kt @@ -0,0 +1,191 @@ +package xyz.lbres.exactnumbers.expressions.term + +import xyz.lbres.exactnumbers.exactfraction.ExactFraction +import xyz.lbres.exactnumbers.irrationals.log.Log +import xyz.lbres.exactnumbers.irrationals.pi.Pi +import xyz.lbres.exactnumbers.irrationals.sqrt.Sqrt +import xyz.lbres.exactnumbers.testutils.TestNumber +import kotlin.test.assertEquals +import kotlin.test.assertNotEquals + +private val log1 = Log(ExactFraction(15, 4)) +private val log2 = Log(8, 7) +private val log3 = Log(ExactFraction(19, 33)).inverse() +private val log4 = Log(ExactFraction(25, 121)) +private val testNumber1 = TestNumber(ExactFraction(5, 6)) +private val testNumber2 = TestNumber(ExactFraction.SEVEN) +private val one = ExactFraction.ONE + +fun runEqualsTests() { + // equal + var term1 = Term.ZERO + assertEquals(term1, term1) + + term1 = Term.fromValues(ExactFraction(-17, 4), emptyList()) + assertEquals(term1, term1) + + term1 = Term.fromValues(one, listOf(log1, log2)) + assertEquals(term1, term1) + + term1 = Term.fromValues(one, listOf(Pi(), Pi())) + assertEquals(term1, term1) + + term1 = Term.fromValues(ExactFraction.EIGHT, listOf(log4, log3, log1, Sqrt(15), Pi().inverse(), Pi())) + assertEquals(term1, term1) + + term1 = Term.fromValues(one, listOf(Pi(), TestNumber(ExactFraction(5)))) + assertEquals(term1, term1) + + term1 = Term.fromValues(ExactFraction.EIGHT, listOf(log4, log3, log1, Sqrt(5), Sqrt(7), Pi().inverse(), Pi())) + var term2 = Term.fromValues(ExactFraction.EIGHT, listOf(log4, log3, log1, Sqrt(35))) + assertEquals(term1, term2) + assertEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction(-4, 7), listOf(Log.ZERO, Sqrt.ONE)) + term2 = Term.ZERO + assertEquals(term1, term2) + assertEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction(-4, 7), listOf(testNumber2, Sqrt(ExactFraction(7, 9)), Pi(), log1, log1.inverse())) + term2 = Term.fromValues(ExactFraction(-4, 3), listOf(Sqrt(7), Pi())) + assertEquals(term1, term2) + assertEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction(-4, 7), listOf(testNumber2, Sqrt(ExactFraction(7, 9)), Pi(), log1, log1.inverse())) + term2 = Term.fromValues(ExactFraction(-4, 3), listOf(Sqrt(7), Sqrt.ONE, Pi().inverse(), Pi(), Pi())) + assertEquals(term1, term2) + assertEquals(term2, term1) + + // not equal + term1 = Term.ONE + term2 = -Term.ONE + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction.TWO, emptyList()) + term2 = Term.fromValues(ExactFraction.HALF, emptyList()) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(log1)) + term2 = Term.ONE + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(log1)) + term2 = Term.fromValues(one, listOf(log1.inverse())) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(log1)) + term2 = Term.fromValues(one, listOf(log1, log2)) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(Pi())) + term2 = Term.ONE + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(Pi())) + term2 = Term.fromValues(one, listOf(Pi().inverse())) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(Pi(), Pi().inverse())) + term2 = Term.fromValues(one, listOf(Pi().inverse())) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(Sqrt(12))) + term2 = Term.ONE + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(Sqrt(12))) + term2 = Term.fromValues(one, listOf(Sqrt(ExactFraction(1, 12)))) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(one, listOf(Sqrt(12), Sqrt(1000))) + term2 = Term.fromValues(one, listOf(Sqrt(ExactFraction(1, 12)))) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction.EIGHT, listOf(Log(15))) + term2 = Term.fromValues(ExactFraction.EIGHT, listOf(Sqrt(15))) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction(5, 7), listOf(log1, log1, Pi(), Pi().inverse())) + term2 = Term.fromValues(ExactFraction.FIVE, listOf(log1, log1, Pi(), Pi().inverse())) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction.EIGHT, listOf(log3, log4, Pi().inverse())) + term2 = Term.fromValues(ExactFraction(-17, 15), listOf(log1, log2, log3)) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) + + term1 = Term.fromValues(ExactFraction.FOUR, listOf(Pi(), testNumber1)) + term2 = Term.fromValues(ExactFraction.FOUR, listOf(Pi(), testNumber1.inverse())) + assertNotEquals(term1, term2) + assertNotEquals(term2, term1) +} + +fun runToStringTests() { + // zero + var term = Term.ZERO + var expected = "<0>" + assertEquals(expected, term.toString()) + + // just coefficient + term = Term.fromValues(ExactFraction(-25), emptyList()) + expected = "<-25>" + assertEquals(expected, term.toString()) + + term = Term.fromValues(ExactFraction(44, 7), emptyList()) + expected = "<[44/7]>" + assertEquals(expected, term.toString()) + + // just logs + term = Term.fromValues(one, listOf(Log.ONE)) + expected = "<1x${Log.ONE}>" + assertEquals(expected, term.toString()) + + term = Term.fromValues(one, listOf(log2, log4, log1)) + expected = "<1x${log2}x${log4}x$log1>" + assertEquals(expected, term.toString()) + + // just pi + term = Term.fromValues(one, listOf(Pi())) + expected = "<1x${Pi()}>" + assertEquals(expected, term.toString()) + + term = Term.fromValues(one, listOf(Pi(), Pi().inverse(), Pi())) + expected = "<1x${Pi()}x${Pi().inverse()}x${Pi()}>" + assertEquals(expected, term.toString()) + + // just sqrt + term = Term.fromValues(one, listOf(Sqrt.ONE)) + expected = "<1x${Sqrt.ONE}>" + assertEquals(expected, term.toString()) + + term = Term.fromValues(one, listOf(Sqrt(32), Sqrt(127), Sqrt(ExactFraction(2, 9)))) + expected = "<1x${Sqrt(32)}x${Sqrt(127)}x${Sqrt(ExactFraction(2, 9))}>" + assertEquals(expected, term.toString()) + + // mix + term = Term.fromValues(ExactFraction.EIGHT, listOf(log3, Sqrt(12), testNumber2, Pi())) + expected = "<8x${log3}x${Sqrt(12)}x${testNumber2}x${Pi()}>" + assertEquals(expected, term.toString()) + + val sqrt1 = Sqrt(ExactFraction(1000, 109)) + val sqrt2 = Sqrt(5096) + term = Term.fromValues( + ExactFraction(-100, 333), + listOf(log2, log2, log4, testNumber1, log1, sqrt1, sqrt2, Pi().inverse(), Pi()) + ) + expected = "<[-100/333]x${log2}x${log2}x${log4}x${testNumber1}x${log1}x${sqrt1}x${sqrt2}x${Pi().inverse()}x${Pi()}>" + assertEquals(expected, term.toString()) +} diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/getComponentsTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/getComponentsTests.kt index e16b808c..7a50b3c9 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/getComponentsTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/getComponentsTests.kt @@ -9,10 +9,10 @@ import xyz.lbres.exactnumbers.testutils.TestNumber import xyz.lbres.kotlinutils.list.StringList import kotlin.test.assertEquals -private val logNum1 = Log(ExactFraction(15, 4)) -private val logNum2 = Log(8, 7) -private val logNum3 = Log(ExactFraction(19, 33)).inverse() -private val logNum4 = Log(ExactFraction(25, 121)) +private val log1 = Log(ExactFraction(15, 4)) +private val log2 = Log(8, 7) +private val log3 = Log(ExactFraction(19, 33)).inverse() +private val log4 = Log(ExactFraction(25, 121)) private val testNumber1 = TestNumber(ExactFraction(3, 4)) private val testNumber2 = TestNumber(ExactFraction.SEVEN) private val one = ExactFraction.ONE @@ -24,7 +24,7 @@ fun runGetFactorsByTypeTests() { var term = Term.fromValues(ExactFraction.ZERO, emptyList()) runSingleIrrationalsByTypeTest(term, types, emptyMap()) - term = Term.fromValues(one, listOf(logNum1, logNum2, testNumber1, Pi(), TestNumber(ExactFraction.ZERO))) + term = Term.fromValues(one, listOf(log1, log2, testNumber1, Pi(), TestNumber(ExactFraction.ZERO))) runSingleIrrationalsByTypeTest(term, types, emptyMap()) // non-zero @@ -40,154 +40,157 @@ fun runGetFactorsByTypeTests() { ) ) - term = Term.fromValues(one, listOf(testNumber1, logNum2, testNumber2.inverse(), Pi().inverse())) + term = Term.fromValues(one, listOf(testNumber1, log2, testNumber2.inverse(), Pi().inverse())) runSingleIrrationalsByTypeTest( term, types + listOf("Random"), mapOf( TestNumber.TYPE to listOf(testNumber1, testNumber2.inverse()), - Log.TYPE to listOf(logNum2), + Log.TYPE to listOf(log2), Pi.TYPE to listOf(Pi().inverse()) ) ) - term = Term.fromValues(one, listOf(logNum4, logNum4, logNum2), listOf(Sqrt.ONE, Sqrt(ExactFraction(17, 7))), -2) + term = Term.fromValues(one, listOf(log4, log4, log2), listOf(Sqrt.ONE, Sqrt(ExactFraction(17, 7))), -2) runSingleIrrationalsByTypeTest( term, types, mapOf( - Log.TYPE to listOf(logNum4, logNum4, logNum2), + Log.TYPE to listOf(log4, log4, log2), Sqrt.TYPE to listOf(Sqrt.ONE, Sqrt(ExactFraction(17, 7))), Pi.TYPE to listOf(Pi().inverse(), Pi().inverse()) ) ) } +@Suppress("Deprecation") fun runGetLogsTests() { // empty var expected: List = emptyList() var term = Term.fromValues(one, emptyList()) - assertEquals(expected, term.logs) + assertEquals(expected, term.getLogs()) term = Term.fromValues(ExactFraction.TEN, emptyList()) - assertEquals(expected, term.logs) + assertEquals(expected, term.getLogs()) term = Term.fromValues(one, listOf(Sqrt(ExactFraction(64, 9)), Pi(), Pi())) - assertEquals(expected, term.logs) + assertEquals(expected, term.getLogs()) // just logs - term = Term.fromValues(one, listOf(logNum1)) - expected = listOf(logNum1) - assertEquals(expected, term.logs) + term = Term.fromValues(one, listOf(log1)) + expected = listOf(log1) + assertEquals(expected, term.getLogs()) - term = Term.fromValues(one, listOf(logNum1, logNum1)) - expected = listOf(logNum1, logNum1) - assertEquals(expected, term.logs) + term = Term.fromValues(one, listOf(log1, log1)) + expected = listOf(log1, log1) + assertEquals(expected, term.getLogs()) - term = Term.fromValues(one, listOf(logNum1, logNum1.inverse())) - expected = listOf(logNum1, logNum1.inverse()) - assertEquals(expected, term.logs) + term = Term.fromValues(one, listOf(log1, log1.inverse())) + expected = listOf(log1, log1.inverse()) + assertEquals(expected, term.getLogs()) - term = Term.fromValues(one, listOf(logNum3, logNum4, logNum1)) - expected = listOf(logNum3, logNum4, logNum1) - assertEquals(expected, term.logs) + term = Term.fromValues(one, listOf(log3, log4, log1)) + expected = listOf(log3, log4, log1) + assertEquals(expected, term.getLogs()) // mix - term = Term.fromValues(one, listOf(logNum3, Sqrt(2), Pi())) - expected = listOf(logNum3) - assertEquals(expected, term.logs) + term = Term.fromValues(one, listOf(log3, Sqrt(2), Pi())) + expected = listOf(log3) + assertEquals(expected, term.getLogs()) - term = Term.fromValues(ExactFraction.EIGHT, listOf(logNum2, logNum2, logNum3, logNum4, Sqrt(15), Pi(), Pi().inverse())) - expected = listOf(logNum2, logNum2, logNum3, logNum4) - assertEquals(expected, term.logs) + term = Term.fromValues(ExactFraction.EIGHT, listOf(log2, log2, log3, log4, Sqrt(15), Pi(), Pi().inverse())) + expected = listOf(log2, log2, log3, log4) + assertEquals(expected, term.getLogs()) } +@Suppress("Deprecation") fun runGetPiCountTests() { // zero var expected = 0 var term = Term.fromValues(one, emptyList()) - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) term = Term.fromValues(ExactFraction.TEN, emptyList()) - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) term = Term.fromValues(one, listOf(Pi(), Pi().inverse())) - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) term = Term.fromValues(one, listOf(Pi(), Pi().inverse(), Pi(), Pi().inverse(), Pi(), Pi().inverse())) - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) - term = Term.fromValues(one, listOf(logNum1, logNum2, Sqrt(ExactFraction(64, 9)))) - assertEquals(expected, term.piCount) + term = Term.fromValues(one, listOf(log1, log2, Sqrt(ExactFraction(64, 9)))) + assertEquals(expected, term.getPiCount()) - term = Term.fromValues(one, listOf(logNum3, logNum4, logNum2, Pi().inverse(), Pi(), Pi().inverse(), Pi())) - assertEquals(expected, term.piCount) + term = Term.fromValues(one, listOf(log3, log4, log2, Pi().inverse(), Pi(), Pi().inverse(), Pi())) + assertEquals(expected, term.getPiCount()) // just pi term = Term.fromValues(one, listOf(Pi())) expected = 1 - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) term = Term.fromValues(one, listOf(Pi().inverse())) expected = -1 - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) term = Term.fromValues(one, listOf(Pi().inverse(), Pi().inverse(), Pi().inverse())) expected = -3 - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) term = Term.fromValues(one, listOf(Pi(), Pi().inverse(), Pi(), Pi(), Pi().inverse())) expected = 1 - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) // mix - term = Term.fromValues(one, listOf(logNum2, Sqrt(2), Pi().inverse())) + term = Term.fromValues(one, listOf(log2, Sqrt(2), Pi().inverse())) expected = -1 - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) - term = Term.fromValues(ExactFraction.EIGHT, listOf(logNum3, logNum2, Sqrt(36), Pi(), Pi(), Pi().inverse(), Pi())) + term = Term.fromValues(ExactFraction.EIGHT, listOf(log3, log2, Sqrt(36), Pi(), Pi(), Pi().inverse(), Pi())) expected = 2 - assertEquals(expected, term.piCount) + assertEquals(expected, term.getPiCount()) } +@Suppress("Deprecation") fun runGetSquareRootsTests() { // zero var expected: List = emptyList() var term = Term.ONE - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) term = Term.fromValues(ExactFraction.TEN, emptyList()) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) - term = Term.fromValues(one, listOf(logNum1, logNum2, Pi(), Pi().inverse())) - assertEquals(expected, term.squareRoots) + term = Term.fromValues(one, listOf(log1, log2, Pi(), Pi().inverse())) + assertEquals(expected, term.getSquareRoots()) // just sqrt term = Term.fromValues(one, listOf(Sqrt(4))) expected = listOf(Sqrt(4)) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) term = Term.fromValues(one, listOf(Sqrt(4), Sqrt(4))) expected = listOf(Sqrt(4), Sqrt(4)) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) term = Term.fromValues(one, listOf(Sqrt(ExactFraction(9, 23)), Sqrt(ExactFraction(23, 9)))) expected = listOf(Sqrt(ExactFraction(9, 23)), Sqrt(ExactFraction(23, 9))) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) term = Term.fromValues(one, listOf(Sqrt.ONE, Sqrt(97), Sqrt(ExactFraction(9, 25)))) expected = listOf(Sqrt.ONE, Sqrt(97), Sqrt(ExactFraction(9, 25))) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) // mix - term = Term.fromValues(one, listOf(logNum2, Sqrt(2), Pi().inverse())) + term = Term.fromValues(one, listOf(log2, Sqrt(2), Pi().inverse())) expected = listOf(Sqrt(2)) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) - term = Term.fromValues(ExactFraction.EIGHT, listOf(logNum1, logNum2, Sqrt.ONE, Sqrt(97), Sqrt(ExactFraction(9, 25)), Pi())) + term = Term.fromValues(ExactFraction.EIGHT, listOf(log1, log2, Sqrt.ONE, Sqrt(97), Sqrt(ExactFraction(9, 25)), Pi())) expected = listOf(Sqrt.ONE, Sqrt(97), Sqrt(ExactFraction(9, 25))) - assertEquals(expected, term.squareRoots) + assertEquals(expected, term.getSquareRoots()) } /** diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/simplifyGetValuesTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/simplifyGetValuesTests.kt index 38e18f2d..aea8ac11 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/simplifyGetValuesTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/simplifyGetValuesTests.kt @@ -9,37 +9,39 @@ import xyz.lbres.exactnumbers.testutils.TestNumber import java.math.BigDecimal import kotlin.test.assertEquals -private val logNum1 = Log(ExactFraction(15, 4)) -private val logNum2 = Log(8, 7) +private val log1 = Log(ExactFraction(15, 4)) +private val log2 = Log(8, 7) private val sqrt = Sqrt(ExactFraction(20, 33)) private val testNumber1 = TestNumber(ExactFraction(3, 4)) private val testNumber2 = TestNumber(ExactFraction.SEVEN) +private val pi = Pi() +private val piInverse = Pi().inverse() private val one = ExactFraction.ONE fun runCommonSimplifyTests(simplify: (Term) -> Term) { // simplified - var term = Term.fromValues(ExactFraction.EIGHT, listOf(Pi(), Pi().inverse())) + var term = Term.fromValues(ExactFraction.EIGHT, listOf(pi, piInverse)) var result = simplify(term) var expectedCoeff = ExactFraction.EIGHT checkTerm(result, expectedCoeff) - term = Term.fromValues(ExactFraction(-3, 2), listOf(logNum1, Pi(), Pi().inverse(), Pi())) + term = Term.fromValues(ExactFraction(-3, 2), listOf(log1, pi, piInverse, pi)) result = simplify(term) expectedCoeff = ExactFraction(-3, 2) - var expectedFactors: List> = listOf(logNum1, Pi()) - checkTerm(result, expectedCoeff, expectedFactors, logs = listOf(logNum1), pis = listOf(Pi()), piCount = 1) + var expectedFactors: List> = listOf(log1, pi) + checkTerm(result, expectedCoeff, expectedFactors, logs = listOf(log1), pis = listOf(pi), piCount = 1) - term = Term.fromValues(ExactFraction.HALF, listOf(Log.ONE, logNum1, testNumber2, testNumber2)) + term = Term.fromValues(ExactFraction.HALF, listOf(Log.ONE, log1, testNumber2, testNumber2)) result = simplify(term) expectedCoeff = ExactFraction(49, 2) - expectedFactors = listOf(logNum1) - checkTerm(result, expectedCoeff, expectedFactors, logs = listOf(logNum1)) + expectedFactors = listOf(log1) + checkTerm(result, expectedCoeff, expectedFactors, logs = listOf(log1)) - term = Term.fromValues(-ExactFraction.HALF, listOf(Log.ONE, Pi().inverse())) + term = Term.fromValues(-ExactFraction.HALF, listOf(Log.ONE, piInverse)) result = simplify(term) expectedCoeff = -ExactFraction.HALF - expectedFactors = listOf(Pi().inverse()) - checkTerm(result, expectedCoeff, expectedFactors, pis = listOf(Pi().inverse()), piCount = -1) + expectedFactors = listOf(piInverse) + checkTerm(result, expectedCoeff, expectedFactors, pis = listOf(piInverse), piCount = -1) term = Term.fromValues(ExactFraction.TEN, listOf(Sqrt.ONE, sqrt, testNumber1, testNumber1, testNumber1.inverse(), testNumber1.inverse(), testNumber1.inverse())) result = simplify(term) @@ -56,15 +58,12 @@ fun runCommonSimplifyTests(simplify: (Term) -> Term) { term = Term.fromValues( ExactFraction(18, 5), - listOf( - logNum2, logNum2, logNum1, logNum2.inverse(), - Pi().inverse(), Pi().inverse(), Pi().inverse(), Pi() - ) + listOf(log2, log2, log1, log2.inverse(), piInverse, piInverse, piInverse, pi) ) result = simplify(term) expectedCoeff = ExactFraction(18, 5) - var logs = listOf(logNum2, logNum1) - var pis = listOf(Pi().inverse(), Pi().inverse()) + var logs = listOf(log2, log1) + var pis = listOf(piInverse, piInverse) checkTerm(result, expectedCoeff, logs + pis, logs = logs, pis = pis, piCount = -2) term = Term.fromValues(ExactFraction.FOUR, listOf(Log(100), Sqrt(9), testNumber1, Sqrt(ExactFraction(1, 4)))) @@ -72,12 +71,12 @@ fun runCommonSimplifyTests(simplify: (Term) -> Term) { expectedCoeff = ExactFraction(12) checkTerm(result, expectedCoeff, listOf(testNumber1)) - term = Term.fromValues(-ExactFraction.EIGHT, listOf(Sqrt(ExactFraction(27, 98)), Pi().inverse())) + term = Term.fromValues(-ExactFraction.EIGHT, listOf(Sqrt(ExactFraction(27, 98)), piInverse)) result = simplify(term) expectedCoeff = ExactFraction(-24, 7) - expectedFactors = listOf(Sqrt(ExactFraction(3, 2)), Pi().inverse()) + expectedFactors = listOf(Sqrt(ExactFraction(3, 2)), piInverse) sqrts = listOf(Sqrt(ExactFraction(3, 2))) - checkTerm(result, expectedCoeff, expectedFactors, sqrts = sqrts, pis = listOf(Pi().inverse()), piCount = -1) + checkTerm(result, expectedCoeff, expectedFactors, sqrts = sqrts, pis = listOf(piInverse), piCount = -1) term = Term.fromValues(ExactFraction(20), listOf(Log(ExactFraction(1, 27), 3).inverse())) result = simplify(term) @@ -94,15 +93,23 @@ fun runCommonSimplifyTests(simplify: (Term) -> Term) { Sqrt(ExactFraction(18, 7)), Sqrt(25), Sqrt(ExactFraction(13, 3)), - Pi() + pi ) ) result = simplify(term) expectedCoeff = ExactFraction(-6) - expectedFactors = listOf(Log(4), Log(1000, 12), Sqrt(ExactFraction(78, 7)), Pi()) + expectedFactors = listOf(Log(4), Log(1000, 12), Sqrt(ExactFraction(78, 7)), pi) logs = listOf(Log(4), Log(1000, 12)) sqrts = listOf(Sqrt(ExactFraction(78, 7))) - checkTerm(result, expectedCoeff, expectedFactors, logs, sqrts, listOf(Pi()), 1) + checkTerm(result, expectedCoeff, expectedFactors, logs, sqrts, listOf(pi), 1) + + term = Term.fromValues( + ExactFraction(4, 7), + listOf(testNumber2, pi, piInverse, Log.ONE, Sqrt(ExactFraction(9, 49)), Log(1000), Log(ExactFraction(1, 32), 2)) + ) + result = simplify(term) + expectedCoeff = ExactFraction(-180, 7) + checkTerm(result, expectedCoeff) // no changes term = Term.fromValues(ExactFraction.EIGHT, emptyList()) @@ -110,11 +117,11 @@ fun runCommonSimplifyTests(simplify: (Term) -> Term) { expectedCoeff = ExactFraction.EIGHT checkTerm(result, expectedCoeff) - term = Term.fromValues(ExactFraction.EIGHT, listOf(logNum1)) + term = Term.fromValues(ExactFraction.EIGHT, listOf(log1)) result = simplify(term) expectedCoeff = ExactFraction.EIGHT - expectedFactors = listOf(logNum1) - checkTerm(result, expectedCoeff, expectedFactors, logs = listOf(logNum1)) + expectedFactors = listOf(log1) + checkTerm(result, expectedCoeff, expectedFactors, logs = listOf(log1)) term = Term.fromValues(ExactFraction.EIGHT, listOf(Sqrt(ExactFraction(1, 46)))) result = simplify(term) @@ -123,23 +130,23 @@ fun runCommonSimplifyTests(simplify: (Term) -> Term) { sqrts = listOf(Sqrt(ExactFraction(1, 46))) checkTerm(result, expectedCoeff, expectedFactors, sqrts = sqrts) - term = Term.fromValues(ExactFraction(-5, 6), listOf(Pi().inverse(), testNumber1)) + term = Term.fromValues(ExactFraction(-5, 6), listOf(piInverse, testNumber1)) result = simplify(term) expectedCoeff = ExactFraction(-5, 6) - expectedFactors = listOf(Pi().inverse(), testNumber1) - checkTerm(result, expectedCoeff, expectedFactors, pis = listOf(Pi().inverse()), piCount = -1) + expectedFactors = listOf(piInverse, testNumber1) + checkTerm(result, expectedCoeff, expectedFactors, pis = listOf(piInverse), piCount = -1) - term = Term.fromValues(ExactFraction.SEVEN, listOf(logNum1, logNum1, logNum2.inverse(), Sqrt(5), Pi(), Pi())) + term = Term.fromValues(ExactFraction.SEVEN, listOf(log1, log1, log2.inverse(), Sqrt(5), pi, pi)) result = simplify(term) expectedCoeff = ExactFraction.SEVEN - expectedFactors = listOf(logNum1, logNum1, logNum2.inverse(), Sqrt(5), Pi(), Pi()) - logs = listOf(logNum1, logNum1, logNum2.inverse()) - pis = listOf(Pi(), Pi()) + expectedFactors = listOf(log1, log1, log2.inverse(), Sqrt(5), pi, pi) + logs = listOf(log1, log1, log2.inverse()) + pis = listOf(pi, pi) checkTerm(result, expectedCoeff, expectedFactors, logs, listOf(Sqrt(5)), pis, 2) } fun runGetValueTests() { - // just number + // just coefficient var term = Term.ZERO var expected = BigDecimal.ZERO assertEquals(expected, term.getValue()) @@ -153,7 +160,7 @@ fun runGetValueTests() { assertEquals(expected, term.getValue()) // just logs - term = Term.fromValues(one, listOf(logNum1, logNum1.inverse())) + term = Term.fromValues(one, listOf(log1, log1.inverse())) expected = BigDecimal.ONE assertEquals(expected, term.getValue()) @@ -161,20 +168,20 @@ fun runGetValueTests() { expected = BigDecimal("3.52283531366053") assertEquals(expected, term.getValue()) - term = Term.fromValues(one, listOf(logNum1, logNum2)) + term = Term.fromValues(one, listOf(log1, log2)) expected = BigDecimal("0.61342218956802803344500481172832") assertEquals(expected, term.getValue()) // just pi - term = Term.fromValues(one, listOf(Pi(), Pi().inverse())) + term = Term.fromValues(one, listOf(pi, piInverse)) expected = BigDecimal.ONE assertEquals(expected, term.getValue()) - term = Term.fromValues(one, listOf(Pi().inverse())) + term = Term.fromValues(one, listOf(piInverse)) expected = BigDecimal("0.31830988618379069570") assertEquals(expected, term.getValue()) - term = Term.fromValues(one, listOf(Pi(), Pi(), Pi())) + term = Term.fromValues(one, listOf(pi, pi, pi)) expected = BigDecimal("31.006276680299813114880451174049119330924860257") assertEquals(expected, term.getValue()) @@ -192,7 +199,7 @@ fun runGetValueTests() { assertEquals(expected, term.getValue()) // combination - term = Term.fromValues(ExactFraction(-8, 3), listOf(Pi())) + term = Term.fromValues(ExactFraction(-8, 3), listOf(pi)) expected = BigDecimal("-8.3775804095727813333") assertEquals(expected, term.getValue()) @@ -204,15 +211,15 @@ fun runGetValueTests() { expected = BigDecimal("75.57215112395364893851321831545508672") assertEquals(expected, term.getValue()) - term = Term.fromValues(ExactFraction.SEVEN, listOf(Log(ExactFraction(6, 7)), Log(40), Pi())) + term = Term.fromValues(ExactFraction.SEVEN, listOf(Log(ExactFraction(6, 7)), Log(40), pi)) expected = BigDecimal("-2.35861167086684457383417423198393663398251286036") assertEquals(expected, term.getValue()) - term = Term.fromValues(ExactFraction.HALF, listOf(Log(4, 2).inverse(), Log(123456789), Pi().inverse())) + term = Term.fromValues(ExactFraction.HALF, listOf(Log(4, 2).inverse(), Log(123456789), piInverse)) expected = BigDecimal("0.64390230285929702583103243749028475") assertEquals(expected, term.getValue()) - term = Term.fromValues(ExactFraction(3, 11), listOf(Log(5, 2), Sqrt(122), Pi())) + term = Term.fromValues(ExactFraction(3, 11), listOf(Log(5, 2), Sqrt(122), pi)) expected = BigDecimal("21.973899001484265398") assertEquals(expected, term.getValue()) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/timesDivTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/timesDivTests.kt index 7bc3293d..a241ab75 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/timesDivTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/expressions/term/timesDivTests.kt @@ -8,13 +8,15 @@ import xyz.lbres.exactnumbers.testutils.TestNumber import xyz.lbres.exactnumbers.testutils.assertDivByZero import kotlin.test.assertEquals -private val logNum1 = Log(ExactFraction(15, 4)) -private val logNum2 = Log(8) -private val logNum3 = Log(ExactFraction(19, 33)) -private val logNum4 = Log(ExactFraction(25, 121)) +private val log1 = Log(ExactFraction(15, 4)) +private val log2 = Log(8) +private val log3 = Log(ExactFraction(19, 33)) +private val log4 = Log(ExactFraction(25, 121)) private val sqrt1 = Sqrt(99) private val sqrt2 = Sqrt(ExactFraction(64, 121)) private val sqrt3 = Sqrt(ExactFraction(15, 44)) +private val pi = Pi() +private val piInverse = Pi().inverse() private val testNumber1 = TestNumber(ExactFraction(5, 6)) private val testNumber2 = TestNumber(ExactFraction.SEVEN) private val one = ExactFraction.ONE @@ -32,45 +34,45 @@ fun runTimesTests() { assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term2 = Term.fromValues(ExactFraction.EIGHT, listOf(logNum3, logNum4, Pi().inverse())) + term2 = Term.fromValues(ExactFraction.EIGHT, listOf(log3, log4, piInverse)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) // just logs - term1 = Term.fromValues(one, listOf(logNum1, logNum2, logNum3)) + term1 = Term.fromValues(one, listOf(log1, log2, log3)) term2 = Term.ONE - expected = Term.fromValues(one, listOf(logNum1, logNum2, logNum3)) + expected = Term.fromValues(one, listOf(log1, log2, log3)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term1 = Term.fromValues(one, listOf(logNum1, logNum2)) - term2 = Term.fromValues(one, listOf(logNum1, logNum4)) - expected = Term.fromValues(one, listOf(logNum1, logNum1, logNum2, logNum4)) + term1 = Term.fromValues(one, listOf(log1, log2)) + term2 = Term.fromValues(one, listOf(log1.inverse(), log4)) + expected = Term.fromValues(one, listOf(log1, log1.inverse(), log2, log4)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) // just pi - term1 = Term.fromValues(one, listOf(Pi(), Pi())) - term2 = Term.ONE - expected = Term.fromValues(one, listOf(Pi(), Pi())) + term1 = Term.fromValues(one, listOf(pi)) + term2 = Term.fromValues(one, listOf(pi)) + expected = Term.fromValues(one, listOf(pi, pi)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term1 = Term.fromValues(one, listOf(Pi(), Pi())) - term2 = Term.fromValues(one, listOf(Pi().inverse())) - expected = Term.fromValues(one, listOf(Pi(), Pi(), Pi().inverse())) + term1 = Term.fromValues(one, listOf(pi, pi)) + term2 = Term.fromValues(one, listOf(piInverse)) + expected = Term.fromValues(one, listOf(pi, pi, piInverse)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term1 = Term.fromValues(one, listOf(Pi(), Pi().inverse(), Pi())) - term2 = Term.fromValues(one, listOf(Pi().inverse(), Pi())) - expected = Term.fromValues(one, listOf(Pi(), Pi(), Pi(), Pi().inverse(), Pi().inverse())) + term1 = Term.fromValues(one, listOf(pi, piInverse, pi)) + term2 = Term.fromValues(one, listOf(piInverse, pi)) + expected = Term.fromValues(one, listOf(pi, pi, pi, piInverse, piInverse)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) // just sqrt term1 = Term.fromValues(one, listOf(Sqrt(ExactFraction(19, 9)), sqrt1)) - term2 = Term.ONE + term2 = Term.fromValues(one, listOf(Sqrt.ONE)) expected = Term.fromValues(one, listOf(Sqrt(ExactFraction(19, 9)), sqrt1)) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) @@ -81,9 +83,9 @@ fun runTimesTests() { assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term1 = Term.fromValues(one, listOf(sqrt1, sqrt3)) + term1 = Term.fromValues(one, listOf(sqrt1, sqrt3.inverse())) term2 = Term.fromValues(one, listOf(sqrt3, sqrt2)) - expected = Term.fromValues(one, listOf(sqrt1, sqrt2, sqrt3, sqrt3)) + expected = Term.fromValues(one, listOf(sqrt1, sqrt2, sqrt3, sqrt3.inverse())) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) @@ -94,7 +96,7 @@ fun runTimesTests() { assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term1 = Term.ONE + term1 = Term.fromValues(one, emptyList()) term2 = Term.fromValues(ExactFraction(-17, 3), emptyList()) expected = Term.fromValues(ExactFraction(-17, 3), emptyList()) assertEquals(expected, term1 * term2) @@ -107,20 +109,20 @@ fun runTimesTests() { assertEquals(expected, term2 * term1) // combination - term1 = Term.fromValues(ExactFraction(1, 4), listOf(logNum1, sqrt1, testNumber1, testNumber1, Pi())) - term2 = Term.fromValues(ExactFraction(-1, 3), listOf(Pi().inverse(), testNumber1.inverse(), Pi())) + term1 = Term.fromValues(ExactFraction(1, 4), listOf(log1, sqrt1, testNumber1, testNumber1, pi)) + term2 = Term.fromValues(ExactFraction(-1, 3), listOf(piInverse, testNumber1.inverse(), pi)) expected = Term.fromValues( ExactFraction(-1, 12), - listOf(logNum1, sqrt1, Pi(), Pi(), Pi().inverse(), testNumber1, testNumber1, testNumber1.inverse()) + listOf(log1, sqrt1, pi, pi, piInverse, testNumber1, testNumber1, testNumber1.inverse()) ) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) - term1 = Term.fromValues(ExactFraction.EIGHT, listOf(logNum1, logNum4, sqrt3, Pi().inverse())) - term2 = Term.fromValues(ExactFraction(-15), listOf(logNum1, logNum2, sqrt1, Pi(), Pi())) + term1 = Term.fromValues(ExactFraction.EIGHT, listOf(log1, log4, sqrt3, piInverse)) + term2 = Term.fromValues(ExactFraction(-15), listOf(log1, log2, sqrt1, pi, pi)) expected = Term.fromValues( ExactFraction(-120), - listOf(logNum1, logNum1, logNum2, logNum4, sqrt3, sqrt1, Pi(), Pi(), Pi().inverse()) + listOf(log1, log1, log2, log4, sqrt3, sqrt1, pi, pi, piInverse) ) assertEquals(expected, term1 * term2) assertEquals(expected, term2 * term1) @@ -132,40 +134,44 @@ fun runDivTests() { // zero var term1 = Term.ZERO - var term2 = Term.ONE var expected = Term.ZERO + + var term2 = Term.ONE + assertEquals(expected, term1 / term2) + + term2 = Term.fromValues(ExactFraction(15), listOf(log4, log1.inverse(), sqrt3, pi)) assertEquals(expected, term1 / term2) // just logs - term1 = Term.fromValues(one, listOf(logNum1, logNum2, logNum3)) + term1 = Term.fromValues(one, listOf(log1, log2, log3)) term2 = Term.ONE - expected = Term.fromValues(one, listOf(logNum1, logNum2, logNum3)) + expected = Term.fromValues(one, listOf(log1, log2, log3)) assertEquals(expected, term1 / term2) term1 = Term.ONE - term2 = Term.fromValues(one, listOf(logNum1, logNum2, logNum3)) - expected = Term.fromValues(one, listOf(logNum1.inverse(), logNum2.inverse(), logNum3.inverse())) + term2 = Term.fromValues(one, listOf(log1, log2, log3)) + expected = Term.fromValues(one, listOf(log1.inverse(), log2.inverse(), log3.inverse())) assertEquals(expected, term1 / term2) - term1 = Term.fromValues(one, listOf(logNum1, logNum2)) - term2 = Term.fromValues(one, listOf(logNum3)) - expected = Term.fromValues(one, listOf(logNum1, logNum2, logNum3.inverse())) + term1 = Term.fromValues(one, listOf(log1, log3)) + term2 = Term.fromValues(one, listOf(log3)) + expected = Term.fromValues(one, listOf(log1, log3, log3.inverse())) assertEquals(expected, term1 / term2) // just pi - term1 = Term.fromValues(one, listOf(Pi())) + term1 = Term.fromValues(one, listOf(pi)) term2 = Term.ONE - expected = Term.fromValues(one, listOf(Pi())) + expected = Term.fromValues(one, listOf(pi)) assertEquals(expected, term1 / term2) term1 = Term.ONE - term2 = Term.fromValues(one, listOf(Pi())) - expected = Term.fromValues(one, listOf(Pi().inverse())) + term2 = Term.fromValues(one, listOf(pi)) + expected = Term.fromValues(one, listOf(piInverse)) assertEquals(expected, term1 / term2) - term1 = Term.fromValues(one, listOf(Pi(), Pi(), Pi().inverse())) - term2 = Term.fromValues(one, listOf(Pi().inverse(), Pi(), Pi().inverse())) - expected = Term.fromValues(one, listOf(Pi(), Pi(), Pi(), Pi(), Pi().inverse(), Pi().inverse())) + term1 = Term.fromValues(one, listOf(pi, pi, piInverse)) + term2 = Term.fromValues(one, listOf(piInverse, pi, piInverse)) + expected = Term.fromValues(one, listOf(pi, pi, pi, pi, piInverse, piInverse)) assertEquals(expected, term1 / term2) // just sqrt @@ -201,27 +207,27 @@ fun runDivTests() { assertEquals(expected, term1 / term2) // mix - term1 = Term.fromValues(ExactFraction(1, 4), listOf(logNum1, testNumber2)) - term2 = Term.fromValues(ExactFraction(-1, 3), listOf(sqrt1, Pi())) + term1 = Term.fromValues(ExactFraction(1, 4), listOf(log1, testNumber2)) + term2 = Term.fromValues(ExactFraction(-1, 3), listOf(sqrt1, pi)) - expected = Term.fromValues(ExactFraction(-3, 4), listOf(logNum1, sqrt1.inverse(), Pi().inverse(), testNumber2)) + expected = Term.fromValues(ExactFraction(-3, 4), listOf(log1, sqrt1.inverse(), piInverse, testNumber2)) assertEquals(expected, term1 / term2) - expected = Term.fromValues(ExactFraction(-4, 3), listOf(logNum1.inverse(), sqrt1, Pi(), testNumber2.inverse())) + expected = Term.fromValues(ExactFraction(-4, 3), listOf(log1.inverse(), sqrt1, pi, testNumber2.inverse())) assertEquals(expected, term2 / term1) - term1 = Term.fromValues(ExactFraction.EIGHT, listOf(logNum3, logNum1, sqrt2, Pi().inverse(), Pi().inverse())) - term2 = Term.fromValues(ExactFraction(15), listOf(logNum4, logNum1.inverse(), sqrt3, Pi())) + term1 = Term.fromValues(ExactFraction.EIGHT, listOf(log3, log1, sqrt2, piInverse, piInverse)) + term2 = Term.fromValues(ExactFraction(15), listOf(log4, log1.inverse(), sqrt3, pi)) expected = Term.fromValues( ExactFraction(8, 15), - listOf(logNum1, logNum1, logNum3, logNum4.inverse(), sqrt2, sqrt3.inverse(), Pi().inverse(), Pi().inverse(), Pi().inverse()) + listOf(log1, log1, log3, log4.inverse(), sqrt2, sqrt3.inverse(), piInverse, piInverse, piInverse) ) assertEquals(expected, term1 / term2) expected = Term.fromValues( ExactFraction(15, 8), - listOf(logNum1.inverse(), logNum1.inverse(), logNum3.inverse(), logNum4, sqrt2.inverse(), sqrt3, Pi(), Pi(), Pi()) + listOf(log1.inverse(), log1.inverse(), log3.inverse(), log4, sqrt2.inverse(), sqrt3, pi, pi, pi) ) assertEquals(expected, term2 / term1) } 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 index 43b70cfa..53a588f1 100644 --- 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 @@ -9,9 +9,9 @@ import kotlin.test.assertEquals import kotlin.test.assertFalse import kotlin.test.assertTrue -private val logNum2 = Log(8, 7) -private val logNum3 = Log(ExactFraction(19, 33)).inverse() -private val logNum4 = Log(ExactFraction(25, 121)) +private val log2 = Log(8, 7) +private val log3 = Log(ExactFraction(19, 33)).inverse() +private val log4 = Log(ExactFraction(25, 121)) private val testNumber1 = TestNumber(ExactFraction(5, 6)) private val testNumber2 = TestNumber(ExactFraction.SEVEN) private val one = ExactFraction.ONE @@ -33,15 +33,15 @@ fun runUnaryMinusTests() { expected = Term.fromValues(one, listOf(Sqrt(32))) assertEquals(expected, -term) - term = Term.fromValues(-ExactFraction.SIX, listOf(logNum3, logNum4, Sqrt(36), Pi().inverse(), testNumber2)) - expected = Term.fromValues(ExactFraction.SIX, listOf(logNum3, logNum4, Sqrt(36), Pi().inverse(), testNumber2)) + term = Term.fromValues(-ExactFraction.SIX, listOf(log3, log4, Sqrt(36), Pi().inverse(), testNumber2)) + expected = Term.fromValues(ExactFraction.SIX, listOf(log3, log4, Sqrt(36), Pi().inverse(), testNumber2)) assertEquals(expected, -term) term = Term.fromValues(ExactFraction(15, 44), emptyList()) expected = Term.fromValues(ExactFraction(-15, 44), emptyList()) assertEquals(expected, -term) - val factors = listOf(logNum2, logNum3, logNum4, Sqrt(ExactFraction(3, 5)), Sqrt(961), Pi(), Pi().inverse(), Pi()) + val factors = listOf(log2, log3, log4, Sqrt(ExactFraction(3, 5)), Sqrt(961), Pi(), Pi().inverse(), Pi()) term = Term.fromValues(ExactFraction(-15, 44), factors) expected = Term.fromValues(ExactFraction(15, 44), factors) assertEquals(expected, -term) @@ -60,7 +60,7 @@ fun runUnaryPlusTests() { term = Term.fromValues(one, listOf(Sqrt.ONE)) assertEquals(term, +term) - term = Term.fromValues(-ExactFraction.SIX, listOf(logNum3, logNum4, Sqrt(121), Pi().inverse(), testNumber2)) + term = Term.fromValues(-ExactFraction.SIX, listOf(log3, log4, Sqrt(121), Pi().inverse(), testNumber2)) assertEquals(term, +term) term = Term.fromValues(ExactFraction(15, 44), emptyList()) @@ -68,7 +68,7 @@ fun runUnaryPlusTests() { term = Term.fromValues( ExactFraction(-15, 44), - listOf(logNum2, logNum3, logNum4, Sqrt(ExactFraction(64, 9)), Pi(), Pi().inverse()) + listOf(log2, log3, log4, Sqrt(ExactFraction(64, 9)), Pi(), Pi().inverse()) ) assertEquals(term, +term) } @@ -91,10 +91,10 @@ fun runIsZeroTests() { term = Term.fromValues(one, listOf(Sqrt.ONE)) assertFalse(term.isZero()) - term = Term.fromValues(ExactFraction(5, 4), listOf(logNum2, logNum4, Sqrt(12), Pi().inverse())) + term = Term.fromValues(ExactFraction(5, 4), listOf(log2, log4, Sqrt(12), Pi().inverse())) assertFalse(term.isZero()) - term = Term.fromValues(-ExactFraction.HALF, listOf(logNum2, logNum2.inverse(), testNumber1)) + term = Term.fromValues(-ExactFraction.HALF, listOf(log2, log2.inverse(), testNumber1)) assertFalse(term.isZero()) term = Term.fromValues(-ExactFraction.HALF, listOf(Sqrt(64), Sqrt(ExactFraction(1, 64)))) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogConstructorsTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogConstructorsTest.kt index 2b7c0e76..3a51c01a 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogConstructorsTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogConstructorsTest.kt @@ -27,7 +27,7 @@ class LogConstructorsTest { error = "Log base must be greater than 1" assertFailsWithMessage(error) { Log(ExactFraction.TEN, -1) } assertFailsWithMessage(error) { Log(ExactFraction.TEN, 0) } - assertFailsWithMessage(error) { Log(ExactFraction.TEN, 1) } + assertFailsWithMessage(error) { Log(ExactFraction(4, 9), 1) } assertFailsWithMessage(error) { Log(10, -1) } assertFailsWithMessage(error) { Log(10L, 0) } assertFailsWithMessage(error) { Log(BigInteger.TEN, 1) } @@ -53,12 +53,12 @@ class LogConstructorsTest { assertFalse(it.isInverted) } - var logNum = Log(ExactFraction(107, 3)) + var log = Log(ExactFraction(107, 3)) expectedArgument = ExactFraction(107, 3) expectedBase = 10 - assertEquals(expectedArgument, logNum.argument) - assertEquals(expectedBase, logNum.base) - assertFalse(logNum.isInverted) + assertEquals(expectedArgument, log.argument) + assertEquals(expectedBase, log.base) + assertFalse(log.isInverted) // number + base expectedArgument = ExactFraction.TWO @@ -70,11 +70,11 @@ class LogConstructorsTest { assertFalse(it.isInverted) } - logNum = Log(ExactFraction(107, 3), 5) + log = Log(ExactFraction(107, 3), 5) expectedArgument = ExactFraction(107, 3) expectedBase = 5 - assertEquals(expectedArgument, logNum.argument) - assertEquals(expectedBase, logNum.base) - assertFalse(logNum.isInverted) + assertEquals(expectedArgument, log.argument) + assertEquals(expectedBase, log.base) + assertFalse(log.isInverted) } } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogTest.kt index 0857ec59..fb912f7e 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/LogTest.kt @@ -12,95 +12,95 @@ class LogTest { @Test fun testEquals() { // equals - var logNum1 = Log.ZERO - assertEquals(logNum1, logNum1) + var log1 = Log.ZERO + assertEquals(log1, log1) - logNum1 = Log(10) - assertEquals(logNum1, logNum1) + log1 = Log(10) + assertEquals(log1, log1) - logNum1 = Log(30001) - assertEquals(logNum1, logNum1) + log1 = Log(30001) + assertEquals(log1, log1) - logNum1 = Log(ExactFraction(107, 12), 3) - assertEquals(logNum1, logNum1) + log1 = Log(ExactFraction(107, 12), 3) + assertEquals(log1, log1) - logNum1 = Log(ExactFraction(12, 107), 10).inverse() - assertEquals(logNum1, logNum1) + log1 = Log(ExactFraction(12, 107), 10).inverse() + assertEquals(log1, log1) // not equals - logNum1 = Log.ZERO - var logNum2 = Log(2) - assertNotEquals(logNum1, logNum2) - assertNotEquals(logNum2, logNum1) - - logNum1 = Log(8) - logNum2 = Log(8, 2) - assertNotEquals(logNum1, logNum2) - assertNotEquals(logNum2, logNum1) - - logNum1 = Log(15) - logNum2 = Log(1000) - assertNotEquals(logNum1, logNum2) - assertNotEquals(logNum2, logNum1) - - logNum1 = Log(ExactFraction.HALF) - logNum2 = Log(ExactFraction(5, 7)) - assertNotEquals(logNum1, logNum2) - assertNotEquals(logNum2, logNum1) - - logNum1 = Log(ExactFraction(7, 8), 3) - logNum2 = Log(ExactFraction(8, 7), 3) - assertNotEquals(logNum1, logNum2) - assertNotEquals(logNum2, logNum1) - - logNum1 = Log(8, 10).inverse() - logNum2 = Log(8, 10) - assertNotEquals(logNum1, logNum2) - assertNotEquals(logNum2, logNum1) + log1 = Log.ZERO + var log2 = Log(2) + assertNotEquals(log1, log2) + assertNotEquals(log2, log1) + + log1 = Log(8) + log2 = Log(8, 2) + assertNotEquals(log1, log2) + assertNotEquals(log2, log1) + + log1 = Log(15) + log2 = Log(1000) + assertNotEquals(log1, log2) + assertNotEquals(log2, log1) + + log1 = Log(ExactFraction.HALF) + log2 = Log(ExactFraction(5, 7)) + assertNotEquals(log1, log2) + assertNotEquals(log2, log1) + + log1 = Log(ExactFraction(7, 8), 3) + log2 = Log(ExactFraction(8, 7), 3) + assertNotEquals(log1, log2) + assertNotEquals(log2, log1) + + log1 = Log(8, 10).inverse() + log2 = Log(8, 10) + assertNotEquals(log1, log2) + assertNotEquals(log2, log1) } @Test fun testCompareTo() { // equal - var logNum1 = Log.ZERO - assertEquals(0, logNum1.compareTo(logNum1)) + var log1 = Log.ZERO + assertEquals(0, log1.compareTo(log1)) - logNum1 = Log(8, 3) - assertEquals(0, logNum1.compareTo(logNum1)) + log1 = Log(8, 3) + assertEquals(0, log1.compareTo(log1)) - logNum1 = Log(ExactFraction(4, 5), 3).inverse() - assertEquals(0, logNum1.compareTo(logNum1)) + log1 = Log(ExactFraction(4, 5), 3).inverse() + assertEquals(0, log1.compareTo(log1)) - logNum1 = Log(2, 2) - var logNum2 = Log(8, 8) - assertEquals(0, logNum1.compareTo(logNum2)) - assertEquals(0, logNum2.compareTo(logNum1)) + log1 = Log(2, 2) + var log2 = Log(8, 8) + assertEquals(0, log1.compareTo(log2)) + assertEquals(0, log2.compareTo(log1)) // not equal - logNum1 = Log.ZERO - logNum2 = Log.ONE - assertTrue(logNum1 < logNum2) - assertTrue(logNum2 > logNum1) - - logNum1 = Log(8) - logNum2 = Log(8, 2) - assertTrue(logNum1 < logNum2) - assertTrue(logNum2 > logNum1) - - logNum1 = Log(ExactFraction(3, 4), 5) - logNum2 = Log(ExactFraction(4, 3), 5) - assertTrue(logNum1 < logNum2) - assertTrue(logNum2 > logNum1) - - logNum1 = Log(ExactFraction(3, 4), 10).inverse() - logNum2 = Log(ExactFraction(1, 4)) - assertTrue(logNum1 < logNum2) - assertTrue(logNum2 > logNum1) - - logNum1 = Log(2, 8) - logNum2 = Log(32, 8).inverse() - assertTrue(logNum1 < logNum2) - assertTrue(logNum2 > logNum1) + log1 = Log.ZERO + log2 = Log.ONE + assertTrue(log1 < log2) + assertTrue(log2 > log1) + + log1 = Log(8) + log2 = Log(8, 2) + assertTrue(log1 < log2) + assertTrue(log2 > log1) + + log1 = Log(ExactFraction(3, 4), 5) + log2 = Log(ExactFraction(4, 3), 5) + assertTrue(log1 < log2) + assertTrue(log2 > log1) + + log1 = Log(ExactFraction(3, 4), 10).inverse() + log2 = Log(ExactFraction(1, 4)) + assertTrue(log1 < log2) + assertTrue(log2 > log1) + + log1 = Log(2, 8) + log2 = Log(32, 8).inverse() + assertTrue(log1 < log2) + assertTrue(log2 > log1) } @Test fun testTimes() = runTimesTests() @@ -112,81 +112,81 @@ class LogTest { assertDivByZero { Log.ZERO.inverse() } // other - var logNum = Log.ONE + var log = Log.ONE var expected = Log.ONE - assertEquals(expected, logNum.inverse()) + assertEquals(expected, log.inverse()) - logNum = Log(ExactFraction(3, 8), 2) + log = Log(ExactFraction(3, 8), 2) expected = Log(ExactFraction(3, 8), 2).inverse() - assertEquals(expected, logNum.inverse()) + assertEquals(expected, log.inverse()) - logNum = Log(4, 3).inverse() + log = Log(4, 3).inverse() expected = Log(4, 3) - assertEquals(expected, logNum.inverse()) + assertEquals(expected, log.inverse()) } @Test fun testIsZero() { - var logNum = Log.ZERO - assertTrue(logNum.isZero()) + var log = Log.ZERO + assertTrue(log.isZero()) - logNum = Log.ONE - assertFalse(logNum.isZero()) + log = Log.ONE + assertFalse(log.isZero()) - logNum = Log(2, 7) - assertFalse(logNum.isZero()) + log = Log(2, 7) + assertFalse(log.isZero()) - logNum = Log(10) - assertFalse(logNum.isZero()) + log = Log(10) + assertFalse(log.isZero()) - logNum = Log(18) - assertFalse(logNum.isZero()) + log = Log(18) + assertFalse(log.isZero()) - logNum = Log(ExactFraction(18, 7)) - assertFalse(logNum.isZero()) + log = Log(ExactFraction(18, 7)) + assertFalse(log.isZero()) - logNum = Log(ExactFraction(7, 18)) - assertFalse(logNum.isZero()) + log = Log(ExactFraction(7, 18)) + assertFalse(log.isZero()) } @Test fun testIsRational() { // rational - var logNum = Log.ZERO - assertTrue(logNum.isRational()) + var log = Log.ZERO + assertTrue(log.isRational()) - logNum = Log.ONE - assertTrue(logNum.isRational()) + log = Log.ONE + assertTrue(log.isRational()) - logNum = Log(2048, 2) - assertTrue(logNum.isRational()) - assertTrue(logNum.isRational()) + log = Log(2048, 2) + assertTrue(log.isRational()) + assertTrue(log.isRational()) - logNum = Log(2048, 2).inverse() - assertTrue(logNum.isRational()) - assertTrue(logNum.isRational()) + log = Log(2048, 2).inverse() + assertTrue(log.isRational()) + assertTrue(log.isRational()) - logNum = Log(ExactFraction(1, 27), 3) - assertTrue(logNum.isRational()) - assertTrue(logNum.isRational()) + log = Log(ExactFraction(1, 27), 3) + assertTrue(log.isRational()) + assertTrue(log.isRational()) - logNum = Log(ExactFraction(1, 1000)).inverse() - assertTrue(logNum.isRational()) + log = Log(ExactFraction(1, 1000)).inverse() + assertTrue(log.isRational()) // irrational - logNum = Log(20) - assertFalse(logNum.isRational()) + log = Log(20) + assertFalse(log.isRational()) - logNum = Log(ExactFraction(1, 10), 5) - assertFalse(logNum.isRational()) - assertFalse(logNum.isRational()) + log = Log(ExactFraction(1, 10), 5) + assertFalse(log.isRational()) + assertFalse(log.isRational()) - logNum = Log(1000, 100).inverse() - assertFalse(logNum.isRational()) - assertFalse(logNum.isRational()) + log = Log(1000, 100).inverse() + assertFalse(log.isRational()) + assertFalse(log.isRational()) - logNum = Log(ExactFraction(8, 1000), 2) - assertFalse(logNum.isRational()) + log = Log(ExactFraction(8, 1000), 2) + assertFalse(log.isRational()) } @Test fun testGetRationalValue() = runGetRationalValueTests() @@ -205,32 +205,32 @@ class LogTest { @Test fun testToString() { - var logNum = Log.ZERO + var log = Log.ZERO var expected = "[log_10(1)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) - logNum = Log(10, 108) + log = Log(10, 108) expected = "[log_108(10)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) - logNum = Log(15) + log = Log(15) expected = "[log_10(15)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) - logNum = Log(30001, 3) + log = Log(30001, 3) expected = "[log_3(30001)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) - logNum = Log(ExactFraction(103, 272), 14) + log = Log(ExactFraction(103, 272), 14) expected = "[log_14(103/272)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) - logNum = Log(ExactFraction(15, 8), 10).inverse() + log = Log(ExactFraction(15, 8), 10).inverse() expected = "[1/log_10(15/8)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) - logNum = Log(4, 3).inverse() + log = Log(4, 3).inverse() expected = "[1/log_3(4)]" - assertEquals(expected, logNum.toString()) + assertEquals(expected, log.toString()) } } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/getValuesTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/getValuesTests.kt index 73bbe639..f282ca99 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/getValuesTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/getValuesTests.kt @@ -7,113 +7,113 @@ import kotlin.test.assertNull fun runGetValueTests() { // base 10 - var logNum = Log(ExactFraction.ONE) + var log = Log(ExactFraction.ONE) var expected = BigDecimal.ZERO - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(100) + log = Log(100) expected = BigDecimal("2") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(3333) + log = Log(3333) expected = BigDecimal("3.52283531366053") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(ExactFraction.HALF) + log = Log(ExactFraction.HALF) expected = BigDecimal("-0.30102999566398114") - assertEquals(expected, logNum.getValue()) - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(ExactFraction(21, 2)) + log = Log(ExactFraction(21, 2)) expected = BigDecimal("1.02118929906993786") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) // base 2 - logNum = Log(ExactFraction.ONE, 2) + log = Log(ExactFraction.ONE, 2) expected = BigDecimal.ZERO - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(ExactFraction(1, 8), 2) + log = Log(ExactFraction(1, 8), 2) expected = BigDecimal("-3") - assertEquals(expected, logNum.getValue()) - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(200, 2) + log = Log(200, 2) expected = BigDecimal("7.643856189774724") - assertEquals(expected, logNum.getValue()) - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) + assertEquals(expected, log.getValue()) // other - logNum = Log(216, 6) + log = Log(216, 6) expected = BigDecimal("3") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(15151515, 24) + log = Log(15151515, 24) expected = BigDecimal("5.202432673429519") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(ExactFraction(18, 109), 9) + log = Log(ExactFraction(18, 109), 9) expected = BigDecimal("-0.8196595572931246") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(ExactFraction(2000, 3), 3) + log = Log(ExactFraction(2000, 3), 3) expected = BigDecimal("5.9186395764396105") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) // divided - logNum = Log(10, 10).inverse() + log = Log(10, 10).inverse() expected = BigDecimal.ONE - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(8, 2).inverse() + log = Log(8, 2).inverse() expected = BigDecimal("0.33333333333333333333") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(ExactFraction(1, 4), 10).inverse() + log = Log(ExactFraction(1, 4), 10).inverse() expected = BigDecimal("-1.6609640474436814234") - assertEquals(expected, logNum.getValue()) - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) + assertEquals(expected, log.getValue()) - logNum = Log(12, 4).inverse() + log = Log(12, 4).inverse() expected = BigDecimal("0.55788589130225962125") - assertEquals(expected, logNum.getValue()) + assertEquals(expected, log.getValue()) } fun runGetRationalValueTests() { // irrational - var logNum = Log(6) - assertNull(logNum.getRationalValue()) + var log = Log(6) + assertNull(log.getRationalValue()) - logNum = Log(1000, 5) - assertNull(logNum.getRationalValue()) - assertNull(logNum.getRationalValue()) + log = Log(1000, 5) + assertNull(log.getRationalValue()) + assertNull(log.getRationalValue()) - logNum = Log(ExactFraction(5, 12), 5) - assertNull(logNum.getRationalValue()) + log = Log(ExactFraction(5, 12), 5) + assertNull(log.getRationalValue()) - logNum = Log(ExactFraction(5, 12), 5).inverse() - assertNull(logNum.getRationalValue()) + log = Log(ExactFraction(5, 12), 5).inverse() + assertNull(log.getRationalValue()) // rational - logNum = Log.ZERO + log = Log.ZERO var expected = ExactFraction.ZERO - assertEquals(expected, logNum.getRationalValue()) + assertEquals(expected, log.getRationalValue()) - logNum = Log(32, 2) + log = Log(32, 2) expected = ExactFraction.FIVE - assertEquals(expected, logNum.getRationalValue()) + assertEquals(expected, log.getRationalValue()) - logNum = Log(ExactFraction(1, 27), 3) + log = Log(ExactFraction(1, 27), 3) expected = -ExactFraction.THREE - assertEquals(expected, logNum.getRationalValue()) - assertEquals(expected, logNum.getRationalValue()) + assertEquals(expected, log.getRationalValue()) + assertEquals(expected, log.getRationalValue()) - logNum = Log(ExactFraction(1, 1000)) + log = Log(ExactFraction(1, 1000)) expected = -ExactFraction.THREE - assertEquals(expected, logNum.getRationalValue()) + assertEquals(expected, log.getRationalValue()) - logNum = Log(ExactFraction(1, 1000)).inverse() + log = Log(ExactFraction(1, 1000)).inverse() expected = ExactFraction(-1, 3) - assertEquals(expected, logNum.getRationalValue()) - assertEquals(expected, logNum.getRationalValue()) + assertEquals(expected, log.getRationalValue()) + assertEquals(expected, log.getRationalValue()) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/simplifyTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/simplifyTests.kt index 6188764f..9d4af42f 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/simplifyTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/log/simplifyTests.kt @@ -11,63 +11,63 @@ private val one = ExactFraction.ONE fun runGetSimplifiedTests() { // zero - var logNum = Log.ZERO + var log = Log.ZERO var expected = Pair(one, Log.ZERO) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) // one - logNum = logOne + log = logOne expected = Pair(one, logOne) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) // rational - logNum = Log(1000) + log = Log(1000) expected = Pair(ExactFraction.THREE, logOne) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(ExactFraction(1, 1000)) + log = Log(ExactFraction(1, 1000)) expected = Pair(-ExactFraction.THREE, logOne) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(ExactFraction(32), 2) + log = Log(ExactFraction(32), 2) expected = Pair(ExactFraction.FIVE, logOne) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(ExactFraction(32), 2).inverse() + log = Log(ExactFraction(32), 2).inverse() expected = Pair(ExactFraction(1, 5), logOne) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(ExactFraction(1, 81), 3) + log = Log(ExactFraction(1, 81), 3) expected = Pair(-ExactFraction.FOUR, logOne) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) // irrational - logNum = Log(30) + log = Log(30) expected = Pair(one, Log(30)) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(ExactFraction(100, 9)) + log = Log(ExactFraction(100, 9)) expected = Pair(one, Log(ExactFraction(100, 9))) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(100, 2) + log = Log(100, 2) expected = Pair(one, Log(100, 2)) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) - logNum = Log(ExactFraction(2, 15), 7) + log = Log(ExactFraction(2, 15), 7) expected = Pair(one, Log(ExactFraction(2, 15), 7)) - assertEquals(expected, logNum.getSimplified()) + assertEquals(expected, log.getSimplified()) } fun runSimplifySetTests() { // empty var expected: Pair> = Pair(one, emptyConstMultiSet()) - var logs: ConstMultiSet = constMultiSetOf() + var logs: ConstMultiSet = emptyConstMultiSet() assertEquals(expected, Log.simplifySet(logs)) // zero - expected = Pair(ExactFraction.ZERO, constMultiSetOf()) + expected = Pair(ExactFraction.ZERO, emptyConstMultiSet()) logs = constMultiSetOf(Log.ZERO) assertEquals(expected, Log.simplifySet(logs)) @@ -80,11 +80,11 @@ fun runSimplifySetTests() { // ones logs = constMultiSetOf(logOne) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Log.simplifySet(logs)) logs = constMultiSetOf(logOne, logOne, logOne) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Log.simplifySet(logs)) logs = constMultiSetOf(logOne, Log(8), Log(4, 3).inverse()) @@ -97,7 +97,7 @@ fun runSimplifySetTests() { // inverses logs = constMultiSetOf(Log(8), Log(8, 10).inverse()) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Log.simplifySet(logs)) logs = constMultiSetOf( @@ -137,11 +137,11 @@ fun runSimplifySetTests() { // rationals logs = constMultiSetOf(Log(1000)) - expected = Pair(ExactFraction.THREE, constMultiSetOf()) + expected = Pair(ExactFraction.THREE, emptyConstMultiSet()) assertEquals(expected, Log.simplifySet(logs)) logs = constMultiSetOf(Log(9, 3), Log(ExactFraction.HALF, 2)) - expected = Pair(-ExactFraction.TWO, constMultiSetOf()) + expected = Pair(-ExactFraction.TWO, emptyConstMultiSet()) assertEquals(expected, Log.simplifySet(logs)) logs = constMultiSetOf( diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/pi/simplifySetTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/pi/simplifySetTests.kt index 7eaf3d21..0b425096 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/pi/simplifySetTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/pi/simplifySetTests.kt @@ -12,7 +12,7 @@ fun runSimplifySetTests() { // equal var expected: Pair> = Pair(one, emptyConstMultiSet()) - var pis: ConstMultiSet = constMultiSetOf() + var pis: ConstMultiSet = emptyConstMultiSet() assertEquals(expected, Pi.simplifySet(pis)) pis = constMultiSetOf(Pi(), Pi().inverse()) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/SqrtTest.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/SqrtTest.kt index a172eba8..8e83b51c 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/SqrtTest.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/SqrtTest.kt @@ -91,8 +91,8 @@ class SqrtTest { expected = "[√(1/2)]" assertEquals(expected, sqrt.toString()) - sqrt = Sqrt(ExactFraction(12, 35)) - expected = "[√(12/35)]" + sqrt = Sqrt(ExactFraction(35, 12)) + expected = "[√(35/12)]" assertEquals(expected, sqrt.toString()) } @@ -116,8 +116,8 @@ class SqrtTest { expected = "[sqrt(1/2)]" assertEquals(expected, sqrt.toPlainString()) - sqrt = Sqrt(ExactFraction(12, 35)) - expected = "[sqrt(12/35)]" + sqrt = Sqrt(ExactFraction(35, 12)) + expected = "[sqrt(35/12)]" assertEquals(expected, sqrt.toPlainString()) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/binaryOpTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/binaryOpTests.kt index 8d6f9789..9ef6756b 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/binaryOpTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/binaryOpTests.kt @@ -164,6 +164,9 @@ fun runEqualsTests() { sqrt1 = Sqrt(ExactFraction(9, 400)) assertEquals(sqrt1, sqrt1) + sqrt1 = Sqrt(ExactFraction(400, 9)) + assertEquals(sqrt1, sqrt1) + // not equal sqrt1 = Sqrt.ZERO var sqrt2 = Sqrt.ONE diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/extractWholeOfTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/extractWholeOfTests.kt index bed26093..b4912e63 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/extractWholeOfTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/extractWholeOfTests.kt @@ -221,7 +221,7 @@ fun runExtractWholeOfTests() { ) ) - // incorrect value + // incorrect memoization num = BigInteger("100") expected = BigInteger("95") runSingleExtractWholeOfTest(num, expected, mapOf(BigInteger("100") to BigInteger("95")), emptyList()) diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/simplifyTests.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/simplifyTests.kt index 91e48744..2f784b80 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/simplifyTests.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/irrationals/sqrt/simplifyTests.kt @@ -31,8 +31,8 @@ fun runGetSimplifiedTests() { expected = Pair(ExactFraction.FIVE, Sqrt(ExactFraction.TWO)) assertEquals(expected, sqrt.getSimplified()) - sqrt = Sqrt(3000) - expected = Pair(ExactFraction.TEN, Sqrt(ExactFraction(30))) + sqrt = Sqrt(ExactFraction(1, 3000)) + expected = Pair(ExactFraction(1, 10), Sqrt(ExactFraction(1, 30))) assertEquals(expected, sqrt.getSimplified()) sqrt = Sqrt(ExactFraction(50, 27)) @@ -63,20 +63,20 @@ fun runSimplifySetTests() { // zero numbers = constMultiSetOf(Sqrt.ZERO) - expected = Pair(ExactFraction.ZERO, constMultiSetOf()) + expected = Pair(ExactFraction.ZERO, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf(Sqrt.ZERO, Sqrt(2)) - expected = Pair(ExactFraction.ZERO, constMultiSetOf()) + expected = Pair(ExactFraction.ZERO, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) // only whole numbers = constMultiSetOf(Sqrt.ONE) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf(Sqrt(9)) - expected = Pair(ExactFraction.THREE, constMultiSetOf()) + expected = Pair(ExactFraction.THREE, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf( @@ -84,15 +84,15 @@ fun runSimplifySetTests() { Sqrt(ExactFraction(1, 64)), Sqrt(49) ) - expected = Pair(ExactFraction(35, 32), constMultiSetOf()) + expected = Pair(ExactFraction(35, 32), emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf(Sqrt(15), Sqrt(6), Sqrt(10)) - expected = Pair(ExactFraction(30), constMultiSetOf()) + expected = Pair(ExactFraction(30), emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) // partial whole - numbers = constMultiSetOf(Sqrt(2), Sqrt(6)) + numbers = constMultiSetOf(Sqrt(2), Sqrt(6), Sqrt(1)) expected = Pair(ExactFraction.TWO, constMultiSetOf(Sqrt(3))) assertEquals(expected, Sqrt.simplifySet(numbers)) @@ -119,6 +119,7 @@ fun runSimplifySetTests() { Sqrt(ExactFraction(15, 2)), Sqrt(ExactFraction(2, 27)), Sqrt(ExactFraction(1, 17)), + Sqrt.ONE, Sqrt(4) ) expected = Pair( @@ -149,18 +150,18 @@ fun runSimplifySetTests() { assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf(Sqrt(13), Sqrt(ExactFraction(1, 13))) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) // ones val rootOne = Sqrt.ONE numbers = constMultiSetOf(rootOne) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf(rootOne, rootOne, rootOne) - expected = Pair(one, constMultiSetOf()) + expected = Pair(one, emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) numbers = constMultiSetOf(Sqrt(ExactFraction(2, 15)), rootOne, Sqrt(16)) @@ -175,6 +176,6 @@ fun runSimplifySetTests() { Sqrt(ExactFraction(1, 64)), Sqrt(49) ) - expected = Pair(ExactFraction(35, 32), constMultiSetOf()) + expected = Pair(ExactFraction(35, 32), emptyConstMultiSet()) assertEquals(expected, Sqrt.simplifySet(numbers)) } diff --git a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/testutils/helpers.kt b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/testutils/helpers.kt index cf6df3e2..0944e2c0 100644 --- a/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/testutils/helpers.kt +++ b/exact-numbers/src/test/kotlin/xyz/lbres/exactnumbers/testutils/helpers.kt @@ -18,7 +18,7 @@ fun assertDivByZero(test: () -> Unit) { * * @param message [String]: expected error message * @param test () -> Unit: test to run - * @return [Exception] the exception that was thrown + * @return T: the exception that was thrown */ inline fun assertFailsWithMessage(message: String, test: () -> Unit): T { val error = assertFailsWith { test() } @@ -27,7 +27,7 @@ inline fun assertFailsWithMessage(message: String, test: } /** - * Validate that a test succeeds, and throw error if it fails + * Validate that an operation succeeds, and throw an AssertionError if it fails * * @param errorMessage [String]: error message to throw if test fails * @param test () -> Unit: test to run