Merge pull request #33 from ionspin/add-tofloat-todouble

Add floatValue, doubleValue to BigInteger

Author: ionspin

CHANGELOG.md

@@ -1,8 +1,11 @@
 ## Descriptive changelog
 (All dates are DD.MM.YYYY)
 
-##### 0.1.0-SNAPSHOT - 11.5.2019
-- Currently same as 0.9.0
+##### 0.1.0-SNAPSHOT - 2.6.2019
+- Added toFloat and toDouble to BigInteger and ModularBigInteger classes
+- Added BigInteger creation from Float and Double by using `tryFromFloat` and `tryFromDouble`, with optional exact 
+parameter to preserve precision.
+- Added BigInteger comparison with Float and Double
 
 ##### 0.0.9 - 11.5.2019 Adding modular integer support, changing api
 - Added modular integers - ModularBigInteger

bignum/build.gradle.kts

@@ -131,6 +131,7 @@ kotlin {
                 implementation(kotlin(Deps.Jvm.testJUnit))
                 implementation(Deps.Jvm.oshi)
                 implementation(Deps.Jvm.coroutinesTest)
+                implementation(kotlin(Deps.Jvm.reflection))
             }
         }
         val jsMain by getting {

bignum/src/commonMain/kotlin/com/ionspin/kotlin/bignum/BigNumber.kt

@@ -41,6 +41,8 @@ interface BigNumber<BigType> where BigType : BigNumber<BigType> {
         fun fromShort(short: Short): BigType
         fun fromByte(byte: Byte): BigType
         fun fromBigInteger(bigInteger: BigInteger) : BigType
+        fun tryFromFloat(float : Float, exactRequired : Boolean = false) : BigType
+        fun tryFromDouble(double : Double, exactRequired : Boolean = false) : BigType
     }
 
     interface Util<BigType> {
@@ -147,6 +149,8 @@ internal interface NarrowingOperations<BigType> where BigType : BigNumber<BigTyp
     fun ulongValue(exactRequired : Boolean = false) : ULong
     fun ubyteValue(exactRequired : Boolean = false) : UByte
     fun ushortValue(exactRequired : Boolean = false) : UShort
+    fun floatValue(exactRequired : Boolean = false) : Float
+    fun doubleValue(exactRequired: Boolean = false) : Double
 }
 
 @ExperimentalUnsignedTypes

bignum/src/commonMain/kotlin/com/ionspin/kotlin/bignum/decimal/BigDecimal.kt

@@ -412,7 +412,12 @@ class BigDecimal private constructor(
          * @return BigDecimal representing input
          */
         fun fromFloat(float: Float, decimalMode: DecimalMode? = null): BigDecimal {
-            return parseStringWithMode(float.toString().dropLastWhile { it == '0' }, decimalMode)
+            val floatString = float.toString()
+            return if (floatString.contains('.')) {
+                parseStringWithMode(floatString.dropLastWhile { it == '0' }, decimalMode)
+            } else {
+                parseStringWithMode(floatString, decimalMode)
+            }
         }
 
         /**
@@ -424,7 +429,12 @@ class BigDecimal private constructor(
          * @return BigDecimal representing input
          */
         fun fromDouble(double: Double, decimalMode: DecimalMode? = null): BigDecimal {
-            return parseStringWithMode(double.toString().dropLastWhile { it == '0' }, decimalMode)
+            val doubleString = double.toString()
+            return if (doubleString.contains('.')) {
+                parseStringWithMode(doubleString.dropLastWhile { it == '0' }, decimalMode)
+            } else {
+                parseStringWithMode(doubleString, decimalMode)
+            }
         }
 
         /**
@@ -614,6 +624,14 @@ class BigDecimal private constructor(
             return fromByte(byte, null)
         }
 
+        override fun tryFromFloat(float: Float, exactRequired: Boolean): BigDecimal {
+            return fromFloat(float, null)
+        }
+
+        override fun tryFromDouble(double: Double, exactRequired: Boolean): BigDecimal {
+            return fromDouble(double, null)
+        }
+
         override fun parseString(string: String, base: Int): BigDecimal {
             return parseStringWithMode(string, null)
         }

bignum/src/commonMain/kotlin/com/ionspin/kotlin/bignum/integer/BigInteger.kt

@@ -21,6 +21,7 @@ import com.ionspin.kotlin.bignum.BigNumber
 import com.ionspin.kotlin.bignum.BitwiseCapable
 import com.ionspin.kotlin.bignum.CommonBigNumberOperations
 import com.ionspin.kotlin.bignum.NarrowingOperations
+import com.ionspin.kotlin.bignum.decimal.BigDecimal
 import com.ionspin.kotlin.bignum.modular.ModularBigInteger
 import kotlin.math.ceil
 import kotlin.math.floor
@@ -94,6 +95,15 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
         val LOG_10_OF_2 = log10(2.0)
 
         override fun parseString(string: String, base: Int): BigInteger {
+            val decimal = string.contains('.')
+            if (decimal) {
+                val bigDecimal = BigDecimal.parseString(string)
+                val isActuallyDecimal = (bigDecimal - bigDecimal.floor()) > 0
+                if (isActuallyDecimal) {
+                    throw NumberFormatException("Supplied string is decimal, which cannot be converted to BigInteger without precision loss.")
+                }
+                return bigDecimal.toBigInteger()
+            }
             val signed = (string[0] == '-' || string[0] == '+')
             return if (signed) {
                 if (string.length == 1) {
@@ -173,6 +183,30 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
         override fun fromShort(short: Short) = BigInteger(short)
         override fun fromByte(byte: Byte) = BigInteger(byte)
 
+        override fun tryFromFloat(float: Float, exactRequired: Boolean): BigInteger {
+            val floatDecimalPart = float - floor(float)
+            val bigDecimal = BigDecimal.fromFloat(floor(float), null)
+
+            if (exactRequired) {
+                if (floatDecimalPart > 0) {
+                    throw ArithmeticException("Cant create BigInteger without precision loss, and exact  value was required")
+                }
+            }
+            return bigDecimal.toBigInteger()
+        }
+
+        override fun tryFromDouble(double: Double, exactRequired: Boolean): BigInteger {
+            val doubleDecimalPart = double - floor(double)
+            val bigDecimal = BigDecimal.fromDouble(floor(double), null)
+
+            if (exactRequired) {
+                if (doubleDecimalPart > 0) {
+                    throw ArithmeticException("Cant create BigInteger without precision loss, and exact  value was required")
+                }
+            }
+            return bigDecimal.toBigInteger()
+        }
+
         override fun max(first: BigInteger, second: BigInteger): BigInteger {
             return if (first > second) {
                 first
@@ -544,6 +578,11 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
     }
 
     override fun compareTo(other: Any): Int {
+        if (other is Number) {
+            if (ComparisonWorkaround.isSpecialHandlingForFloatNeeded(other)) {
+                return javascriptNumberComparison(other)
+            }
+        }
         return when (other) {
             is BigInteger -> compare(other)
             is Long -> compare(fromLong(other))
@@ -554,11 +593,58 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
             is UInt -> compare(fromUInt(other))
             is UShort -> compare(fromUShort(other))
             is UByte -> compare(fromUByte(other))
+            is Float -> compareFloatAndBigInt(other) { compare(it) }
+            is Double -> compareDoubleAndBigInt(other) {compare(it) }
             else -> throw RuntimeException("Invalid comparison type for BigInteger: ${other::class.simpleName}")
         }
 
     }
 
+    /**
+     * Javascrpt doesn't have different types for float, integer, long, it's all just "number", so we need
+     * to check if it's a decimal or integer number before comparing.
+     */
+    private fun javascriptNumberComparison(number : Number) : Int {
+        val float = number.toFloat()
+        return when  {
+            float % 1 == 0f -> compare(fromLong(number.toLong()))
+            else -> compareFloatAndBigInt(number.toFloat()) { compare(it) }
+
+        }
+    }
+
+    fun compareFloatAndBigInt(float : Float, comparisonBlock : (BigInteger) -> Int) : Int {
+        val withoutDecimalPart = floor(float)
+        val hasDecimalPart = (float % 1 != 0f)
+        return if (hasDecimalPart) {
+            val comparisonResult = comparisonBlock.invoke(tryFromFloat(withoutDecimalPart + 1))
+            if (comparisonResult == 0) {
+                // They were equal with float incremented by one (because of decimal part) so the BigInt was larger
+                1
+            } else {
+                comparisonResult
+            }
+        } else {
+            comparisonBlock.invoke(tryFromFloat(withoutDecimalPart))
+        }
+    }
+
+    fun compareDoubleAndBigInt(double : Double, comparisonBlock : (BigInteger) -> Int) : Int {
+        val withoutDecimalPart = floor(double)
+        val hasDecimalPart = (double % 1 != 0.0)
+        return if (hasDecimalPart) {
+            val comparisonResult = comparisonBlock.invoke(tryFromDouble(withoutDecimalPart + 1))
+            if (comparisonResult == 0) {
+                // They were equal with double incremented by one (because of decimal part) so the BigInt was larger
+                1
+            } else {
+                comparisonResult
+            }
+        } else {
+            comparisonBlock.invoke(tryFromDouble(withoutDecimalPart))
+        }
+    }
+
     override fun equals(other: Any?): Boolean {
         val comparison = when (other) {
             is BigInteger -> compare(other)
@@ -678,6 +764,20 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
         return magnitude[0].toUShort()
     }
 
+    override fun floatValue(exactRequired: Boolean): Float {
+        if (exactRequired && this > Float.MAX_VALUE) {
+            throw ArithmeticException("Cannot convert to float and provide exact value")
+        }
+        return this.toString().toFloat()
+    }
+
+    override fun doubleValue(exactRequired: Boolean): Double {
+        if (exactRequired && this > Double.MAX_VALUE) {
+            throw ArithmeticException("Cannot convert to float and provide exact value")
+        }
+        return this.toString().toDouble()
+    }
+
     operator fun rangeTo(other : BigInteger) = BigIntegerRange(this, other)
 
     class BigIntegerRange(override val start : BigInteger, override val endInclusive : BigInteger) : ClosedRange<BigInteger>, Iterable<BigInteger> {

bignum/src/commonMain/kotlin/com/ionspin/kotlin/bignum/integer/PlatformWorkarounds.kt

@@ -0,0 +1,30 @@
+/*
+ *    Copyright 2019 Ugljesa Jovanovic
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+
+package com.ionspin.kotlin.bignum.integer
+
+/**
+ * Created by Ugljesa Jovanovic
+ * [email protected]
+ * on 02-Jun-2019
+ */
+expect object ComparisonWorkaround {
+    /**
+     * We need to know if we are running on a platform that doesn't know how to tell decimal and integer apart.
+     */
+    fun isSpecialHandlingForFloatNeeded(number : Number) : Boolean
+}

bignum/src/commonMain/kotlin/com/ionspin/kotlin/bignum/integer/util/DigitUtil.kt

@@ -29,6 +29,7 @@ fun Char.toDigit() : Int {
         in 'A' .. 'Z' -> this - 'A' + 10
         in '\uFF21' .. '\uFF3A' -> this - '\uFF21' - 10
         in '\uFF41' .. '\uFF5A' -> this - '\uFF41' - 10
-        else -> throw NumberFormatException("Invalid digit for radix ")
+        '.' -> throw NumberFormatException("Invalid digit for radix $this (Possibly a decimal value, which is not supported by BigInteger parser")
+        else -> throw NumberFormatException("Invalid digit for radix $this")
     }
 }

bignum/src/commonMain/kotlin/com/ionspin/kotlin/bignum/modular/ModularBigInteger.kt

@@ -100,6 +100,14 @@ class ModularBigInteger @ExperimentalUnsignedTypes constructor(
                     return ModularBigInteger(BigInteger.fromByte(byte).prep(), modulo, this)
                 }
 
+                override fun tryFromFloat(float: Float, exactRequired: Boolean): ModularBigInteger {
+                    return ModularBigInteger(BigInteger.tryFromFloat(float, exactRequired).prep(), modulo, this)
+                }
+
+                override fun tryFromDouble(double: Double, exactRequired: Boolean): ModularBigInteger {
+                    return ModularBigInteger(BigInteger.tryFromDouble(double, exactRequired).prep(), modulo, this)
+                }
+
                 private fun BigInteger.prep() : BigInteger {
                     val result = this % modulo
                     return when (result.sign) {
@@ -334,7 +342,11 @@ class ModularBigInteger @ExperimentalUnsignedTypes constructor(
         return residue.magnitude[0].toUShort()
     }
 
+    override fun floatValue(exactRequired: Boolean): Float {
+        return residue.floatValue()
+    }
 
-
-
+    override fun doubleValue(exactRequired: Boolean): Double {
+        return residue.doubleValue()
+    }
 }

bignum/src/commonTest/kotlin/com/ionspin/kotlin/bignum/integer/BigIntegerTest.kt

@@ -363,4 +363,48 @@ BigIntegerTest {
         }
     }
 
+    @Test
+    fun doubleComparisonTest() {
+        assertTrue {
+            val a = 1.1
+            val b = BigInteger.fromInt(1)
+            b.compareTo(a) == -1
+        }
+
+        assertTrue {
+            val a = 0.9
+            val b = BigInteger.fromInt(1)
+            b.compareTo(a) == 1
+        }
+
+        assertTrue {
+            val a = 1.0
+            val b = BigInteger.fromInt(1)
+            b.compareTo(a) == 0
+        }
+
+    }
+
+    @Test
+    fun floatComparisonTest() {
+        assertTrue {
+            val a = 1.1f
+            val b = BigInteger.fromInt(1)
+            b.compareTo(a) == -1
+        }
+
+        assertTrue {
+            val a = 0.9f
+            val b = BigInteger.fromInt(1)
+            b.compareTo(a) == 1
+        }
+
+        assertTrue {
+            val a = 1.0f
+            val b = BigInteger.fromInt(1)
+            b.compareTo(a) == 0
+        }
+
+    }
+
 }