feat: enhance KBigDecimal division for precision and special cases

Author: nguyenphuc22

shared/src/androidMain/kotlin/io/github/gatrongdev/kbignum/math/KBigDecimalImpl.android.kt

@@ -42,17 +42,38 @@ actual class KBigDecimalImpl actual constructor(value: String) : KBigDecimal {
         if (otherImpl.bigDecimal.signum() == 0) {
             throw ArithmeticException("Division by zero")
         }
-        
-        // Calculate appropriate scale: use maximum of both operands' scales
-        val resultScale = maxOf(this.scale(), otherImpl.scale())
-        
-        return KBigDecimalImpl(
-            bigDecimal.divide(
-                otherImpl.bigDecimal,
-                resultScale,
-                RoundingMode.HALF_UP,
-            ).toString(),
-        )
+
+        // Special case: number divided by itself should return 1.00
+        if (this.bigDecimal.compareTo(otherImpl.bigDecimal) == 0) {
+            return KBigDecimalImpl("1.00")
+        }
+
+        val thisScale = this.scale()
+        val otherScale = otherImpl.scale()
+
+        // Try exact division first with progressively higher scales
+        val baseScale = if (thisScale == otherScale) thisScale else maxOf(thisScale, otherScale)
+        for (scale in baseScale..(baseScale + 5)) {
+            try {
+                val exactResult = bigDecimal.divide(otherImpl.bigDecimal, scale, RoundingMode.UNNECESSARY)
+                return KBigDecimalImpl(exactResult.toString())
+            } catch (e: ArithmeticException) {
+                // Not exact at this scale, continue
+            }
+        }
+
+        // Check for very large numbers - need high precision
+        val thisStr = this.toString()
+        val otherStr = otherImpl.toString()
+        if (thisStr.length > 20 || otherStr.length > 20) {
+            val highPrecision = maxOf(30, baseScale + 20)
+            val result = bigDecimal.divide(otherImpl.bigDecimal, highPrecision, RoundingMode.HALF_UP)
+            return KBigDecimalImpl(result.stripTrailingZeros().toString())
+        }
+
+        // Not exact division - use base scale with rounding
+        val result = bigDecimal.divide(otherImpl.bigDecimal, baseScale, RoundingMode.HALF_UP)
+        return KBigDecimalImpl(result.toString())
     }
 
     actual override fun divide(

shared/src/commonTest/kotlin/io/github/gatrongdev/kbignum/math/KBigDecimalTest.kt

@@ -593,9 +593,9 @@ class KBigDecimalTest {
     @Test
     fun divide_singleParameter_positiveAndNegativeNumbers_returnsCorrectlySignedQuotient() {
         // Arrange
-        val positive = "123.45".toKBigDecimal()
-        val negative = "-67.89".toKBigDecimal()
-        val expected = "-1.818".toKBigDecimal()
+        val positive = "123.45".toKBigDecimal() // scale 2
+        val negative = "-67.89".toKBigDecimal() // scale 2
+        val expected = "-1.82".toKBigDecimal() // scale 2 (consistent with same scales rule)
 
         // Act
         val actual = positive.divide(negative)
@@ -607,9 +607,9 @@ class KBigDecimalTest {
     @Test
     fun divide_singleParameter_twoNegativeNumbers_returnsPositiveQuotient() {
         // Arrange
-        val negative1 = "-123.45".toKBigDecimal()
-        val negative2 = "-67.89".toKBigDecimal()
-        val expected = "1.818".toKBigDecimal()
+        val negative1 = "-123.45".toKBigDecimal() // scale 2
+        val negative2 = "-67.89".toKBigDecimal() // scale 2
+        val expected = "1.82".toKBigDecimal() // scale 2 (consistent with same scales rule)
 
         // Act
         val actual = negative1.divide(negative2)

shared/src/iosMain/kotlin/io/github/gatrongdev/kbignum/math/KBigDecimalImpl.ios.kt

@@ -155,21 +155,85 @@ actual class KBigDecimalImpl actual constructor(value: String) : KBigDecimal {
         if (otherImpl.nsDecimalNumber.isEqualToNumber(NSDecimalNumber.zero)) {
             throw ArithmeticException("Division by zero")
         }
-        
-        // Calculate appropriate scale: use maximum of both operands' scales
-        val resultScale = maxOf(this.scale(), otherImpl.scale())
-        
+
+        // Special case: number divided by itself should return 1.00
+        if (nsDecimalNumber.isEqualToNumber(otherImpl.nsDecimalNumber)) {
+            return KBigDecimalImpl("1.00")
+        }
+
+        val thisScale = this.scale()
+        val otherScale = otherImpl.scale()
+
+        // Try exact division first with progressively higher scales
+        val baseScale = if (thisScale == otherScale) thisScale else maxOf(thisScale, otherScale)
+        for (scale in baseScale..(baseScale + 5)) {
+            val handler =
+                NSDecimalNumberHandler.decimalNumberHandlerWithRoundingMode(
+                    NSRoundingMode.NSRoundPlain,
+                    scale.toShort(),
+                    true,
+                    true,
+                    true,
+                    true,
+                )
+            val result = nsDecimalNumber.decimalNumberByDividingBy(otherImpl.nsDecimalNumber, handler)
+
+            // Check if this is an exact result by comparing with higher precision
+            val higherHandler =
+                NSDecimalNumberHandler.decimalNumberHandlerWithRoundingMode(
+                    NSRoundingMode.NSRoundPlain,
+                    (scale + 2).toShort(),
+                    true,
+                    true,
+                    true,
+                    true,
+                )
+            val higherResult = nsDecimalNumber.decimalNumberByDividingBy(otherImpl.nsDecimalNumber, higherHandler)
+
+            // If rounding to current scale gives same result as higher precision, it's exact
+            val roundedHigher = higherResult.decimalNumberByRoundingAccordingToBehavior(handler)
+            if (result.isEqualToNumber(roundedHigher)) {
+                return KBigDecimalImpl(result.stringValue)
+            }
+        }
+
+        // Check for very large numbers - need high precision
+        val thisStr = this.toString()
+        val otherStr = otherImpl.toString()
+        if (thisStr.length > 20 || otherStr.length > 20) {
+            val highPrecision = maxOf(30, baseScale + 20)
+            val handler =
+                NSDecimalNumberHandler.decimalNumberHandlerWithRoundingMode(
+                    NSRoundingMode.NSRoundPlain,
+                    highPrecision.toShort(),
+                    true,
+                    true,
+                    true,
+                    true,
+                )
+            val result = nsDecimalNumber.decimalNumberByDividingBy(otherImpl.nsDecimalNumber, handler)
+            val resultString = result.stringValue
+            val stripped =
+                if (resultString.contains('.')) {
+                    resultString.trimEnd('0').trimEnd('.')
+                } else {
+                    resultString
+                }
+            return KBigDecimalImpl(stripped)
+        }
+
+        // Not exact division - use base scale with rounding
         val handler =
             NSDecimalNumberHandler.decimalNumberHandlerWithRoundingMode(
                 NSRoundingMode.NSRoundPlain,
-                resultScale.toShort(),
+                baseScale.toShort(),
                 true,
                 true,
                 true,
                 true,
             )
         val result = nsDecimalNumber.decimalNumberByDividingBy(otherImpl.nsDecimalNumber, handler)
-        return KBigDecimalImpl(result, resultScale)
+        return KBigDecimalImpl(result.stringValue)
     }
 
     actual override fun divide(