java 1.7 compatibility

Author: elect86

src/main/kotlin/unsigned/Ubyte.kt

@@ -2,6 +2,7 @@ package unsigned
 
 import unsigned.java_1_7.compareUnsigned
 import unsigned.java_1_7.divideUnsigned
+import unsigned.java_1_7.parseUnsignedInt
 import unsigned.java_1_7.remainderUnsigned
 import java.math.BigInteger
 import kotlin.experimental.and
@@ -24,7 +25,7 @@ data class Ubyte(var v: Byte = 0) : Number() {
     }
 
     constructor(number: Number) : this(number.toByte())
-    @JvmOverloads constructor(string: String, base: Int = 10) : this(Integer.parseUnsignedInt(string.filter { it != '_' && it != '\'' }, base).toByte())
+    @JvmOverloads constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base).toByte())
 
     override fun toByte() = v
     override fun toShort() = v.toUInt().toShort()
@@ -60,11 +61,11 @@ data class Ubyte(var v: Byte = 0) : Number() {
 
     infix operator fun div(b: Ubyte) = Ubyte(toInt() / b.toInt())
     infix operator fun div(b: Byte) = Ubyte(toInt() / b.toUInt())
-    infix operator fun div(b: Int) = Ubyte(toInt().divideUnsigned(b))
+    infix operator fun div(b: Int) = Ubyte(toInt() divideUnsigned b)
 
     infix operator fun rem(b: Ubyte) = Ubyte(toInt() % b.toInt())
     infix operator fun rem(b: Byte) = Ubyte(toInt() % b.toUInt())
-    infix operator fun rem(b: Int) = Ubyte(toInt().remainderUnsigned(b))
+    infix operator fun rem(b: Int) = Ubyte(toInt() remainderUnsigned b)
 
     // TODO add counterparts with res
 
@@ -90,7 +91,7 @@ data class Ubyte(var v: Byte = 0) : Number() {
 
     fun inv() = Ubyte(v.inv())
 
-    operator fun compareTo(b: Ubyte) = toInt().compareUnsigned(b.toInt())
-    operator fun compareTo(b: Byte) = toInt().compareUnsigned(b.toUInt())
-    operator fun compareTo(b: Int) = toInt().compareUnsigned(b)
+    operator fun compareTo(b: Ubyte) = toInt() compareUnsigned b.toInt()
+    operator fun compareTo(b: Byte) = toInt() compareUnsigned b.toUInt()
+    operator fun compareTo(b: Int) = toInt() compareUnsigned b
 }

src/main/kotlin/unsigned/Uint.kt

@@ -1,5 +1,9 @@
 package unsigned
 
+import unsigned.java_1_7.compareUnsigned
+import unsigned.java_1_7.divideUnsigned
+import unsigned.java_1_7.parseUnsignedInt
+import unsigned.java_1_7.remainderUnsigned
 import java.math.BigInteger
 
 /**
@@ -21,7 +25,7 @@ data class Uint(var v: Int = 0) : Number() {
 
 
     constructor(number: Number) : this(number.toInt())
-    @JvmOverloads constructor(string: String, base: Int = 10) : this(Integer.parseUnsignedInt(string.filter { it != '_' && it != '\'' }, base))
+    @JvmOverloads constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base))
 
     override fun toByte() = v.toByte()
     override fun toShort() = v.toShort()
@@ -47,11 +51,11 @@ data class Uint(var v: Int = 0) : Number() {
     infix operator fun times(b: Uint) = Uint(v * b.v)
     infix operator fun times(b: Int) = Uint(v * b)
 
-    infix operator fun div(b: Uint) = Uint(Integer.divideUnsigned(v, b.toInt()))
-    infix operator fun div(b: Int) = Uint(Integer.divideUnsigned(v, b))
+    infix operator fun div(b: Uint) = Uint(v divideUnsigned b.toInt())
+    infix operator fun div(b: Int) = Uint(v divideUnsigned b)
 
-    infix operator fun rem(b: Uint) = Uint(Integer.remainderUnsigned(v, b.toInt()))
-    infix operator fun rem(b: Int) = Uint(Integer.remainderUnsigned(v, b))
+    infix operator fun rem(b: Uint) = Uint(v remainderUnsigned b.toInt())
+    infix operator fun rem(b: Int) = Uint(v remainderUnsigned b)
 
     infix fun and(b: Uint) = Uint(v and b.toInt())
     infix fun and(b: Int) = Uint(v and b)
@@ -70,8 +74,8 @@ data class Uint(var v: Int = 0) : Number() {
 
     fun inv() = Uint(v.inv())
 
-    operator fun compareTo(b: Uint) = Integer.compareUnsigned(v, b.toInt())
-    operator fun compareTo(b: Int) = Integer.compareUnsigned(v, b)
+    operator fun compareTo(b: Uint) = v compareUnsigned b.toInt()
+    operator fun compareTo(b: Int) = v compareUnsigned b
 
     // TODO long?
 }

src/main/kotlin/unsigned/Ulong.kt

@@ -1,5 +1,6 @@
 package unsigned
 
+import unsigned.java_1_7.*
 import java.math.BigInteger
 
 /**
@@ -20,14 +21,14 @@ data class Ulong(var v: Long = 0) : Number(), Comparable<Ulong> {
     }
 
     constructor(number: Number) : this(number.toLong())
-    constructor(string: String, base: Int = 10) : this(java.lang.Long.parseUnsignedLong(string.filter { it != '_' && it != '\'' }, base))
+    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedLong(base))
 
     override fun toByte() = v.toByte()
     override fun toShort() = v.toShort()
     override fun toInt() = v.toInt()
     override fun toLong() = v
 
-    fun toBigInt(): BigInteger = BigInteger(java.lang.Long.toUnsignedString(v))
+    fun toBigInt(): BigInteger = BigInteger(v.toUnsignedString())
 
     override fun toDouble() = toBigInt().toDouble()
     override fun toFloat() = toBigInt().toFloat()
@@ -46,11 +47,11 @@ data class Ulong(var v: Long = 0) : Number(), Comparable<Ulong> {
     infix operator fun times(b: Ulong) = Ulong(v * b.v)
     infix operator fun times(b: Long) = Ulong(v * b)
 
-    infix operator fun div(b: Ulong) = Ulong(java.lang.Long.divideUnsigned(v, b.toLong()))
-    infix operator fun div(b: Long) = Ulong(java.lang.Long.divideUnsigned(v, b))
+    infix operator fun div(b: Ulong) = Ulong(v divideUnsigned b.toLong())
+    infix operator fun div(b: Long) = Ulong(v divideUnsigned b)
 
-    infix operator fun rem(b: Ulong) = Ulong(java.lang.Long.remainderUnsigned(v, b.toLong()))
-    infix operator fun rem(b: Long) = Ulong(java.lang.Long.remainderUnsigned(v, b))
+    infix operator fun rem(b: Ulong) = Ulong(v remainderUnsigned b.toLong())
+    infix operator fun rem(b: Long) = Ulong(v remainderUnsigned b)
 
     infix fun and(b: Ulong) = Ulong(v and b.toLong())
     infix fun and(b: Long) = Ulong(v and b)
@@ -67,8 +68,8 @@ data class Ulong(var v: Long = 0) : Number(), Comparable<Ulong> {
 
     fun inv() = Ulong(v.inv())
 
-    override operator fun compareTo(other: Ulong) = java.lang.Long.compareUnsigned(v, other.toLong())
-    operator fun compareTo(other: Long) = java.lang.Long.compareUnsigned(v, other)
+    override operator fun compareTo(other: Ulong) = v compareUnsigned other.toLong()
+    operator fun compareTo(other: Long) = v compareUnsigned other
 
     // TODO others
 
@@ -78,7 +79,7 @@ data class Ulong(var v: Long = 0) : Number(), Comparable<Ulong> {
 
         override fun iterator(): Iterator<Ulong> = UlongIterator(this)
 
-        override fun contains(value: Ulong) = start <= value && value <= endInclusive
+        override fun contains(value: Ulong): Boolean = value in start..endInclusive
     }
 
     class UlongIterator(val ulongRange: UlongRange) : Iterator<Ulong> {

src/main/kotlin/unsigned/Ushort.kt

@@ -1,5 +1,9 @@
 package unsigned
 
+import unsigned.java_1_7.compareUnsigned
+import unsigned.java_1_7.divideUnsigned
+import unsigned.java_1_7.parseUnsignedInt
+import unsigned.java_1_7.remainderUnsigned
 import java.math.BigInteger
 import kotlin.experimental.and
 import kotlin.experimental.inv
@@ -25,7 +29,7 @@ data class Ushort(var v: Short = 0) : Number() {
 
     constructor(number: Number) : this(number.toShort())
     @JvmOverloads constructor(string: String, base: Int = 10) :
-            this(Integer.parseUnsignedInt(string.filter { it != '_' && it != '\'' }, base).toShort())
+            this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base).toShort())
 
     override fun toByte() = v.toByte()
     override fun toShort() = v
@@ -56,11 +60,11 @@ data class Ushort(var v: Short = 0) : Number() {
 
     infix operator fun div(b: Ushort) = Ushort(toInt() / b.toInt())
     infix operator fun div(b: Short) = Ushort(toInt() / b.toUInt())
-    infix operator fun div(b: Int) = Ushort(Integer.divideUnsigned(toInt(), b))
+    infix operator fun div(b: Int) = Ushort(toInt() divideUnsigned b)
 
     infix operator fun rem(b: Ushort) = Ushort(toInt() % b.toInt())
     infix operator fun rem(b: Short) = Ushort(toInt() % b.toUInt())
-    infix operator fun rem(b: Int) = Ushort(Integer.remainderUnsigned(toInt(), b))
+    infix operator fun rem(b: Int) = Ushort(toInt() remainderUnsigned b)
 
     infix fun and(b: Ushort) = Ushort(v and b.v)
     infix fun and(b: Short) = Ushort(v and b)
@@ -84,7 +88,7 @@ data class Ushort(var v: Short = 0) : Number() {
 
     fun inv() = Ushort(v.inv())
 
-    operator fun compareTo(b: Ushort) = Integer.compareUnsigned(toInt(), b.toInt())
-    operator fun compareTo(b: Short) = Integer.compareUnsigned(toInt(), b.toUInt())
-    operator fun compareTo(b: Int) = Integer.compareUnsigned(toInt(), b)
+    operator fun compareTo(b: Ushort) = toInt() compareUnsigned b.toInt()
+    operator fun compareTo(b: Short) = toInt() compareUnsigned b.toUInt()
+    operator fun compareTo(b: Int) = toInt() compareUnsigned b
 }

src/main/kotlin/unsigned/java_1_7/int.kt

@@ -4,32 +4,31 @@ import java.math.BigInteger
 
 
 // In lieu of tricky code, for now just use long arithmetic.
-fun Int.divideUnsigned(divisor: Int) = (toUnsignedLong() / divisor.toUnsignedLong()).toInt()
+infix fun Int.divideUnsigned(divisor: Int) = (toUnsignedLong() / divisor.toUnsignedLong()).toInt()
 
 fun Int.toUnsignedLong() = toLong() and 0xffffffffL
 
 // In lieu of tricky code, for now just use long arithmetic.
-fun Int.remainderUnsigned(divisor: Int) = (toUnsignedLong() % divisor.toUnsignedLong()).toInt()
+infix fun Int.remainderUnsigned(divisor: Int) = (toUnsignedLong() % divisor.toUnsignedLong()).toInt()
 
-fun Int.compareUnsigned(b: Int) = compare(this + Int.MIN_VALUE, b + Int.MIN_VALUE)
+infix fun Int.compareUnsigned(b: Int) = compare(this + Int.MIN_VALUE, b + Int.MIN_VALUE)
 
-fun compare(x: Int, y: Int) = if (x < y) -1 else if (x == y) 0 else 1
+fun compare(a: Int, b: Int) = if (a < b) -1 else if (a == b) 0 else 1
 
 @Throws(NumberFormatException::class)
 fun String.parseUnsignedInt(radix: Int): Int {
 
-    val len = length
-    if (len > 0) {
+    if (length > 0) {
         val firstChar = this[0]
         if (firstChar == '-')
             throw NumberFormatException(String.format("Illegal leading minus sign " + "on unsigned string %s.", this))
         else {
-            if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
-                    radix == 10 && len <= 9) // Integer.MAX_VALUE in base 10 is 10 digits
+            if (length <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
+                    radix == 10 && length <= 9) // Integer.MAX_VALUE in base 10 is 10 digits
                 return this.toInt(radix)
             else {
                 val ell = this.toLong(radix)
-                if (ell and BigInteger("0xffff_ffff_0000_0000").toLong() == 0L)
+                if (ell and BigInteger("ffffffff00000000", 16).toLong() == 0L)
                     return ell.toInt()
                 else
                     throw NumberFormatException(String.format("String value %s exceeds " + "range of unsigned int.", this))

src/main/kotlin/unsigned/java_1_7/long.kt

@@ -205,6 +205,73 @@ private fun Long.toUnsignedBigInteger(): BigInteger {
         val lower = this.toInt()
 
         // return (upper << 32) + lower
-        return BigInteger.valueOf(Integer.toUnsignedLong(upper)).shiftLeft(32).add(BigInteger.valueOf(Integer.toUnsignedLong(lower)))
+        return BigInteger.valueOf(upper.toUnsignedLong()).shiftLeft(32).add(BigInteger.valueOf(lower.toUnsignedLong()))
     }
+}
+
+@Throws(NumberFormatException::class)
+fun String.parseUnsignedLong(radix: Int = 10): Long {
+
+    if (length > 0) {
+        val firstChar = this[0]
+        if (firstChar == '-')
+            throw NumberFormatException(String.format("Illegal leading minus sign on unsigned string $this."))
+        else {
+            if (length <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
+                    radix == 10 && length <= 18) // Long.MAX_VALUE in base 10 is 19 digits
+                return this.toLong(radix)
+
+            // No need for range checks on len due to testing above.
+            val first = substring(0, length - 1).toLong(radix)
+            val second = Character.digit(this[length - 1], radix)
+            if (second < 0)
+                throw NumberFormatException("Bad digit at end of $this")
+            val result = first * radix + second
+            if (result compareUnsigned first < 0) {
+                /*  The maximum unsigned value, (2^64)-1, takes at most one more digit to represent than the maximum
+                    signed value, (2^63)-1.  Therefore, parsing (len - 1) digits will be appropriately in-range of the
+                    signed parsing.  In other words, if parsing (len -1) digits overflows signed parsing, parsing len
+                    digits will certainly overflow unsigned parsing.
+
+                    The compareUnsigned check above catches situations where an unsigned overflow occurs incorporating
+                    the contribution of the final digit.    */
+                throw NumberFormatException(String.format("String value $this exceeds range of unsigned long."))
+            }
+            return result
+        }
+    } else throw NumberFormatException("For input string: $this")
+}
+
+infix fun Long.compareUnsigned(b: Long) = compare(this + Long.MIN_VALUE, b + Long.MIN_VALUE)
+
+fun compare(a: Long, b: Long) = if (a < b) -1 else if (a == b) 0 else 1
+
+infix fun Long.divideUnsigned(divisor: Long): Long {
+    if (divisor < 0L) // signed comparison
+    // Answer must be 0 or 1 depending on relative magnitude
+    // of dividend and divisor.
+        return if (compareUnsigned(divisor) < 0) 0L else 1L
+
+    if (this > 0)
+    //  Both inputs non-negative
+        return this / divisor
+    else
+    /*
+         * For simple code, leveraging BigInteger.  Longer and faster
+         * code written directly in terms of operations on longs is
+         * possible; see "Hacker's Delight" for divide and remainder
+         * algorithms.
+         */
+        return toUnsignedBigInteger().divide(divisor.toUnsignedBigInteger()).toLong()
+}
+
+infix fun Long.remainderUnsigned(divisor: Long): Long {
+    if (this > 0 && divisor > 0) // signed comparisons
+        return this % divisor
+    else
+        if (compareUnsigned(divisor) < 0)
+        // Avoid explicit check for 0 divisor
+            return this
+        else
+            return toUnsignedBigInteger().remainder(divisor.toUnsignedBigInteger()).toLong()
 }