feat(core): implement log

Author: ObserverOfTime

kbigint/src/androidMain/kotlin/io/github/observeroftime/kbigint/KBigInt.kt

@@ -5,6 +5,8 @@ package io.github.observeroftime.kbigint
 import android.annotation.TargetApi
 import android.os.Build.VERSION_CODES
 import java.math.BigInteger
+import kotlin.math.floor
+import kotlin.math.log2
 
 /** A multiplatform implementation of a big integer. */
 actual class KBigInt private constructor(private var value: BigInteger) : Comparable<KBigInt> {
@@ -130,6 +132,27 @@ actual class KBigInt private constructor(private var value: BigInteger) : Compar
     @Throws(ArithmeticException::class)
     actual infix fun pow(n: Int) = KBigInt(value.pow(n))
 
+    /**
+     * Compute the integer logarithm base [b] of the number.
+     *
+     * @since 0.5.0
+     * @throws [ArithmeticException] if `this <= 0 || b < 2`
+     */
+    @ExperimentalMultiplatform
+    @Throws(ArithmeticException::class)
+    actual infix fun log(b: Int): Int {
+        if (value.signum() < 1 || b <= 1)
+            throw ArithmeticException("Non-positive KBigInt or base < 2")
+
+        val guess = floor((bitLength - 1) / log2(b.toDouble())).toInt()
+        val base = BigInteger.valueOf(b.toLong())
+        val lowerBound = base.pow(guess)
+
+        return if (lowerBound > value) guess - 1
+        else if (lowerBound.multiply(base) <= value) guess + 1
+        else guess
+    }
+
     /**
      * Compute the approximate square root of the value.
      *

kbigint/src/androidUnitTest/kotlin/io/github/observeroftime/kbigint/KBigIntTest.kt

@@ -90,6 +90,21 @@ actual class KBigIntTest {
         assertEquals(KBigInt("4611686018427387904"), long pow 2)
     }
 
+    @Test
+    @OptIn(ExperimentalMultiplatform::class)
+    actual fun testLog() {
+        assertEquals(3, KBigInt(10) log 2)
+        assertEquals(20, KBigInt("100000000000000000000") log 10)
+
+        assertFailsWith(ArithmeticException::class) {
+            KBigInt(-1) log 2
+        }
+
+        assertFailsWith(ArithmeticException::class) {
+            KBigInt(2) log 1
+        }
+    }
+
     @Test
     actual fun testSqrt() {
         assertEquals(KBigInt(46340), long.sqrt())

kbigint/src/commonMain/kotlin/io/github/observeroftime/kbigint/KBigInt.kt

@@ -102,7 +102,19 @@ expect class KBigInt : Comparable<KBigInt> {
      */
     infix fun pow(n: Int): KBigInt
 
-    /** Compute the approximate square root of the value. */
+    /**
+     * Compute the integer logarithm base [b] of the number.
+     *
+     * @since 0.5.0
+     * @throws [ArithmeticException] if `this <= 0 || b < 2`
+     */
+    infix fun log(b: Int): Int
+
+    /**
+     * Compute the approximate square root of the value.
+     *
+     * @throws [ArithmeticException] if the value is negative
+     */
     fun sqrt(): KBigInt
 
     /**

kbigint/src/commonTest/kotlin/io/github/observeroftime/kbigint/KBigIntTest.kt

@@ -16,6 +16,7 @@ expect class KBigIntTest {
     fun testGcdLcm()
     fun testPow()
     fun testSqrt()
+    fun testLog()
     fun testAbs()
     fun testCompare()
     fun testEquals()

kbigint/src/javascript/kbigint-utils.mjs

@@ -102,6 +102,23 @@ export function pow(value, n) {
     return value ** BigInt(n);
 }
 
+/**
+ * Compute the base `b` integer logarithm of the value.
+ *
+ * @param {bigint} value
+ * @param {number} b
+ * @returns {number}
+ */
+export function log(value, b) {
+    const guess = ((bitLength(value) - 1) / Math.log2(b)) | 0;
+    const base = BigInt(b)
+    const lowerBound = base ** BigInt(guess);
+
+    if (lowerBound > value) return guess - 1;
+    if (lowerBound * base <= value) return guess + 1;
+    return guess;
+}
+
 /**
  * Convert a {@link BigInt} to an {@link Int8Array}.
  *

kbigint/src/jsMain/kotlin/io/github/observeroftime/kbigint/KBigInt.kt

@@ -2,7 +2,7 @@ package io.github.observeroftime.kbigint
 
 /** A multiplatform implementation of a big integer. */
 @JsExport
-@Suppress("UNUSED_VARIABLE")
+@Suppress("UnusedVariable", "unused")
 @OptIn(ExperimentalStdlibApi::class, ExperimentalJsExport::class)
 actual class KBigInt private constructor(@JsExternalArgument private var value: BigInt) : Comparable<KBigInt> {
     /** Convert a [String] to a [KBigInt]. */
@@ -186,6 +186,19 @@ actual class KBigInt private constructor(@JsExternalArgument private var value:
         return KBigInt(KBigIntUtils.pow(value, n))
     }
 
+    /**
+     * Compute the integer logarithm base [b] of the number.
+     *
+     * @since 0.5.0
+     * @throws [ArithmeticException] if `this <= 0 || b < 2`
+     */
+    @ExperimentalMultiplatform
+    actual infix fun log(b: Int): Int {
+        if (sign < 1 || b <= 1)
+            throw ArithmeticException("Non-positive KBigInt or base < 2")
+        return KBigIntUtils.log(value, b)
+    }
+
     /**
      * Compute the approximate square root of the value.
      *

kbigint/src/jsMain/kotlin/io/github/observeroftime/kbigint/KBigIntUtils.kt

@@ -1,3 +1,5 @@
+@file:Suppress("unused")
+
 package io.github.observeroftime.kbigint
 
 internal external class BigInt {
@@ -17,6 +19,7 @@ internal external object KBigIntUtils {
     fun cmp(a: BigInt, b: BigInt): Int
     fun gcd(a: BigInt, b: BigInt): BigInt
     fun pow(value: BigInt, n: Int): BigInt
+    fun log(value: BigInt, b: Int): Int
     fun toByteArray(value: BigInt): ByteArray
     fun fromByteArray(bytes: ByteArray): BigInt
 }

kbigint/src/jsTest/kotlin/io/github/observeroftime/kbigint/KBigIntTest.kt

@@ -91,6 +91,21 @@ actual class KBigIntTest {
         assertEquals(KBigInt("4611686018427387904"), long pow 2)
     }
 
+    @Test
+    @OptIn(ExperimentalMultiplatform::class)
+    actual fun testLog() {
+        assertEquals(3, KBigInt(10) log 2)
+        assertEquals(20, KBigInt("100000000000000000000") log 10)
+
+        assertFailsWith(ArithmeticException::class) {
+            KBigInt(-1) log 2
+        }
+
+        assertFailsWith(ArithmeticException::class) {
+            KBigInt(2) log 1
+        }
+    }
+
     @Test
     @OptIn(ExperimentalMultiplatform::class)
     actual fun testSqrt() {

kbigint/src/jvmMain/kotlin/io/github/observeroftime/kbigint/KBigInt.kt

@@ -3,6 +3,8 @@
 package io.github.observeroftime.kbigint
 
 import java.math.BigInteger
+import kotlin.math.floor
+import kotlin.math.log2
 
 /** A multiplatform implementation of a big integer. */
 actual class KBigInt private constructor(private var value: BigInteger) : Comparable<KBigInt> {
@@ -128,6 +130,27 @@ actual class KBigInt private constructor(private var value: BigInteger) : Compar
     @Throws(ArithmeticException::class)
     actual infix fun pow(n: Int) = KBigInt(value.pow(n))
 
+    /**
+     * Compute the integer logarithm base [b] of the number.
+     *
+     * @since 0.5.0
+     * @throws [ArithmeticException] if `this <= 0 || b < 2`
+     */
+    @ExperimentalMultiplatform
+    @Throws(ArithmeticException::class)
+    actual infix fun log(b: Int): Int {
+        if (value.signum() < 1 || b <= 1)
+            throw ArithmeticException("Non-positive KBigInt or base < 2")
+
+        val guess = floor((bitLength - 1) / log2(b.toDouble())).toInt()
+        val base = BigInteger.valueOf(b.toLong())
+        val lowerBound = base.pow(guess)
+
+        return if (lowerBound > value) guess - 1
+        else if (lowerBound.multiply(base) <= value) guess + 1
+        else guess
+    }
+
     /**
      * Compute the approximate square root of the value.
      *

kbigint/src/jvmTest/kotlin/io/github/observeroftime/kbigint/KBigIntTest.kt

@@ -1,6 +1,7 @@
 package io.github.observeroftime.kbigint
 
 import kotlin.test.*
+import kotlin.test.Test
 
 actual class KBigIntTest {
     companion object {
@@ -90,6 +91,21 @@ actual class KBigIntTest {
         assertEquals(KBigInt("4611686018427387904"), long pow 2)
     }
 
+    @Test
+    @OptIn(ExperimentalMultiplatform::class)
+    actual fun testLog() {
+        assertEquals(3, KBigInt(10) log 2)
+        assertEquals(20, KBigInt("100000000000000000000") log 10)
+
+        assertFailsWith(ArithmeticException::class) {
+            KBigInt(-1) log 2
+        }
+
+        assertFailsWith(ArithmeticException::class) {
+            KBigInt(2) log 1
+        }
+    }
+
     @Test
     actual fun testSqrt() {
         assertEquals(KBigInt(46340), long.sqrt())