Merge pull request #38 from ionspin/modular-integer-mod-improvement

Improving ModularBigInteger exponentiation

Author: ionspin

CHANGELOG.md

@@ -1,11 +1,13 @@
 ## Descriptive changelog
 (All dates are DD.MM.YYYY)
 
-##### 0.1.0-SNAPSHOT - 2.6.2019
+##### 0.1.0-SNAPSHOT - 28.7.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
+- Added BigDecimal configuration option to switch to expanded representation instead of scientific when calling `toString()`
+- Improved ModularBigInteger exponentiation algorithm, based on Bruce Schneier Applied Cryptography pesudocode
 
 ##### 0.0.9 - 11.5.2019 Adding modular integer support, changing api
 - Added modular integers - ModularBigInteger

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

@@ -31,6 +31,10 @@ interface BigNumber<BigType> where BigType : BigNumber<BigType> {
 
     @ExperimentalUnsignedTypes
     interface Creator<BigType> {
+        val ZERO : BigType
+        val ONE : BigType
+        val TWO : BigType
+        val TEN : BigType
         fun parseString(string: String, base: Int = 10): BigType
         fun fromULong(uLong: ULong): BigType
         fun fromUInt(uInt: UInt): BigType

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

@@ -20,14 +20,10 @@ package com.ionspin.kotlin.bignum.decimal
 import com.ionspin.kotlin.bignum.BigNumber
 import com.ionspin.kotlin.bignum.CommonBigNumberOperations
 import com.ionspin.kotlin.bignum.integer.BigInteger
-import com.ionspin.kotlin.bignum.integer.BigInteger.Companion.TEN
-import com.ionspin.kotlin.bignum.integer.BigInteger.Companion.TWO
-import com.ionspin.kotlin.bignum.integer.BigInteger.Companion.ZERO
 import com.ionspin.kotlin.bignum.integer.Sign
 import com.ionspin.kotlin.bignum.integer.toBigInteger
 import kotlin.math.absoluteValue
 import kotlin.math.max
-import kotlin.math.sqrt
 
 /**
  * Implementation of floating-point arbitrary precision arithmetic.
@@ -55,9 +51,10 @@ class BigDecimal private constructor(
     val precision = significand.numberOfDecimalDigits()
 
     companion object : BigNumber.Creator<BigDecimal> {
-        val ZERO = BigDecimal(BigInteger.ZERO)
-        val ONE = BigDecimal(BigInteger.ONE)
-        val TWO = BigDecimal(BigInteger.TWO)
+        override val ZERO = BigDecimal(BigInteger.ZERO)
+        override val ONE = BigDecimal(BigInteger.ONE)
+        override val TWO = BigDecimal(BigInteger.TWO)
+        override val TEN = BigDecimal(BigInteger.TEN)
 
         var useToStringExpanded : Boolean = false
 
@@ -84,7 +81,7 @@ class BigDecimal private constructor(
 
             val toDiscard = significand.numberOfDecimalDigits() - decimalMode.decimalPrecision
             var result = if (toDiscard > 0) {
-                (significand divrem TEN.pow(toDiscard)).quotient
+                (significand divrem BigInteger.TEN.pow(toDiscard)).quotient
             } else {
                 significand
             }
@@ -97,7 +94,8 @@ class BigDecimal private constructor(
                 if (discarded == BigInteger.ZERO) {
                     BigInteger.ZERO
                 } else {
-                    (discarded / (discarded.numberOfDecimalDigits())).abs() + (significand divrem TEN.pow(toDiscard)).remainder * TEN.pow(
+                    (discarded / (discarded.numberOfDecimalDigits())).abs() +
+                            (significand divrem BigInteger.TEN.pow(toDiscard)).remainder * BigInteger.TEN.pow(
                         toDiscard
                     )
                 }
@@ -227,11 +225,11 @@ class BigDecimal private constructor(
             val desiredPrecision = decimalMode.decimalPrecision
             return when {
                 desiredPrecision > significandDigits -> {
-                    val extendedSignificand = significand * TEN.pow(desiredPrecision - significandDigits)
+                    val extendedSignificand = significand * BigInteger.TEN.pow(desiredPrecision - significandDigits)
                     BigDecimal(extendedSignificand, exponent, decimalMode)
                 }
                 desiredPrecision < significandDigits -> {
-                    val divRem = significand divrem TEN.pow(significandDigits - desiredPrecision)
+                    val divRem = significand divrem BigInteger.TEN.pow(significandDigits - desiredPrecision)
                     val newSignificand = roundDiscarded(divRem.quotient, divRem.remainder, decimalMode)
                     BigDecimal(newSignificand, exponent, decimalMode)
 

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

@@ -87,10 +87,10 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
     companion object : BigNumber.Creator<BigInteger>, BigNumber.Util<BigInteger> {
         private val arithmetic: BigIntegerArithmetic<WordArray, Word> = chosenArithmetic
 
-        val ZERO = BigInteger(arithmetic.ZERO, Sign.ZERO)
-        val ONE = BigInteger(arithmetic.ONE, Sign.POSITIVE)
-        val TWO = BigInteger(arithmetic.TWO, Sign.POSITIVE)
-        val TEN = BigInteger(arithmetic.TEN, Sign.POSITIVE)
+        override val ZERO = BigInteger(arithmetic.ZERO, Sign.ZERO)
+        override val ONE = BigInteger(arithmetic.ONE, Sign.POSITIVE)
+        override val TWO = BigInteger(arithmetic.TWO, Sign.POSITIVE)
+        override val TEN = BigInteger(arithmetic.TEN, Sign.POSITIVE)
 
         val LOG_10_OF_2 = log10(2.0)
 
@@ -536,7 +536,11 @@ class BigInteger internal constructor(wordArray: WordArray, val sign: Sign) : Bi
     }
 
     override infix fun shr(places: Int): BigInteger {
-        return BigInteger(arithmetic.shiftRight(this.magnitude, places), sign)
+        val result = BigInteger(arithmetic.shiftRight(this.magnitude, places), sign)
+        if (result.magnitude == arithmetic.ZERO) {
+            return ZERO
+        }
+        return result
     }
 
     override operator fun unaryMinus(): BigInteger = negate()

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

@@ -22,7 +22,6 @@ import com.ionspin.kotlin.bignum.CommonBigNumberOperations
 import com.ionspin.kotlin.bignum.ModularQuotientAndRemainder
 import com.ionspin.kotlin.bignum.NarrowingOperations
 import com.ionspin.kotlin.bignum.integer.BigInteger
-import com.ionspin.kotlin.bignum.integer.BigInteger.Companion.ONE
 import com.ionspin.kotlin.bignum.integer.Sign
 
 /**
@@ -60,6 +59,12 @@ class ModularBigInteger @ExperimentalUnsignedTypes constructor(
 
         fun creatorForModulo(modulo: BigInteger) : BigNumber.Creator<ModularBigInteger> {
             return object : BigNumber.Creator<ModularBigInteger> {
+                override val ZERO = ModularBigInteger(BigInteger.ZERO, modulo, this)
+                override val ONE = ModularBigInteger(BigInteger.ONE, modulo, this)
+                override val TWO = ModularBigInteger(BigInteger.TWO, modulo, this)
+                override val TEN = ModularBigInteger(BigInteger.TEN, modulo, this)
+
+
                 override fun fromBigInteger(bigInteger: BigInteger): ModularBigInteger {
                     return ModularBigInteger(bigInteger.prep(), modulo, this)
                 }
@@ -207,11 +212,26 @@ class ModularBigInteger @ExperimentalUnsignedTypes constructor(
     }
 
     fun pow(exponent: ModularBigInteger): ModularBigInteger {
-        return ModularBigInteger(residue.pow(exponent.residue) % modulus, modulus, creator)
+        return pow(exponent.residue)
     }
 
     fun pow(exponent: BigInteger): ModularBigInteger {
-        return ModularBigInteger(residue.pow(exponent) % modulus, modulus, creator)
+        var e = exponent
+        return if (this.modulus == BigInteger.ONE) {
+            creator.ZERO
+        } else {
+            var residue = BigInteger.ONE
+            var base = this.residue
+            while (e > 0) {
+                if (e % 2 == BigInteger.ONE) {
+                    residue = (residue * base) % modulus
+                }
+                e = e shr 1
+                base = base.pow(2) % modulus
+            }
+            ModularBigInteger(residue, modulus, creator)
+        }
+
     }
 
     override fun pow(exponent: Long): ModularBigInteger {
@@ -281,7 +301,7 @@ class ModularBigInteger @ExperimentalUnsignedTypes constructor(
     }
 
     private fun checkIfDivisible(other : ModularBigInteger) {
-        if (other.residue.gcd(modulus) != ONE) {
+        if (other.residue.gcd(modulus) != BigInteger.ONE) {
             throw ArithmeticException("BigInteger is not invertible. This and modulus are not relatively prime (coprime)")
         }
     }

bignum/src/commonTest/kotlin/com/ionspin/kotlin/bignum/modular/ModularBigIntegerExponentiationTest.kt

@@ -0,0 +1,39 @@
+/*
+ *    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.modular
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+/**
+ * Created by Ugljesa Jovanovic
+ * [email protected]
+ * on 28-Jul-2019
+ */
+@ExperimentalUnsignedTypes
+class ModularBigIntegerExponentiationTest {
+    @Test
+    fun testExponentiation() {
+        val base = 5
+        val modulus = 100
+        val exponent = 3
+        val creator = ModularBigInteger.creatorForModulo(modulus)
+        val result = creator.fromInt(base).pow(exponent)
+        assertEquals(result, creator.fromInt(25))
+    }
+}

bignum/src/jvmTest/kotlin/com/ionspin/kotlin/bignum/modular/JvmModularBigIntegerExponentiationTest.kt

@@ -0,0 +1,81 @@
+/*
+ *    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.modular
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+import com.ionspin.kotlin.bignum.integer.Sign
+import com.ionspin.kotlin.bignum.integer.base63.toJavaBigInteger
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlin.random.Random
+import kotlin.random.nextULong
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+/**
+ * Created by Ugljesa Jovanovic
+ * [email protected]
+ * on 28-Jul-2019
+ */
+@ExperimentalUnsignedTypes
+class JvmModularBigIntegerExponentiationTest {
+    @Test
+    fun testRandomModularExponentiation() {
+        val seed = 1
+        val random = Random(seed)
+        val jobList: MutableList<Job> = mutableListOf()
+        for (i in 1..1000) {
+            val aLength = random.nextInt(1, 500)
+            val a = ULongArray(aLength) {
+                random.nextULong() shr 1
+            }
+
+            val modulo = ULongArray(random.nextInt(1, 50)) {
+                random.nextULong() shr 1
+            }
+
+            val creator = ModularBigInteger.creatorForModulo(BigInteger(modulo, Sign.POSITIVE))
+
+            val b = creator.fromInt(random.nextInt(500))
+
+            val job = GlobalScope.launch {
+                try {
+                    val aMod = creator.fromBigInteger(BigInteger(a, Sign.POSITIVE))
+                    singleDivisionTest(aMod, b)
+                } catch (exception: Exception) {
+                    exception.printStackTrace()
+                }
+            }
+            jobList.add(job)
+
+        }
+        runBlocking {
+            jobList.forEach { it.join() }
+        }
+    }
+
+    fun singleDivisionTest(a : ModularBigInteger, b : ModularBigInteger) {
+        assertTrue {
+            val result = a.pow(b)
+            val javaResult = a.residue.toJavaBigInteger().modPow(b.residue.toJavaBigInteger(), b.modulus.toJavaBigInteger())
+            result.toBigInteger().toJavaBigInteger() == javaResult
+        }
+    }
+}