azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Floor division and remainder for numeric types KT-26234

Browse Source 
- floorDiv/mod for unsigned types
- floorDiv/mod for signed types
- mod for floating point types

- mod return type: same as divisor for integer types

- Update JS API dump
- Avoid triggering division overflow in tests due to K/N
- Workaround failing test in JS-legacy
This commit is contained in:
Ilya Gorbunov
2021-02-20 04:24:45 +03:00
parent 284e6f5bb3
commit 50d4979531
14 changed files with 1308 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/stdlib/test/numbers/FloorDivModTest.kt
+283
View File
@@ -0,0 +1,283 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package test.numbers
import kotlin.math.pow
import kotlin.math.sign
import kotlin.random.Random
import kotlin.test.*
class FloorDivModTest {
@Test
fun intDivMod() {
fun check(a: Int, b: Int, expectedFd: Int? = null, expectedMod: Int? = null) {
if (a == Int.MIN_VALUE && b == -1) return // do not test, due to native KT-45136
val div = a / b
val rem = a % b
val fd = a.floorDiv(b)
val mod = a.mod(b)
try {
expectedFd?.let { assertEquals(it, fd) }
expectedMod?.let { assertEquals(it, mod) }
assertEquals(div - if (a.sign != b.sign && rem != 0) 1 else 0, fd)
assertEquals(a - b * fd, mod)
} catch (e: AssertionError) {
fail("a: $a, b: $b, div: $div, rem: $rem, floorDiv: $fd, mod: $mod", e)
}
}
check(10, -3, -4, -2)
check(10, 3, 3, 1)
check(-10, 3, -4, 2)
check(-10, -3, 3, -1)
val values = listOf(1, -1, 2, -2, 3, -3, Int.MIN_VALUE, Int.MAX_VALUE)
for (a in values + 0) {
for (b in values) {
check(a, b)
}
}
repeat(1000) {
val a = Random.nextInt()
val b = Random.nextInt().let { if (it == 0) 1 else it }
check(a, b)
}
}
@Test
fun longDivMod() {
fun check(a: Long, b: Long, expectedFd: Long? = null, expectedMod: Long? = null) {
if (a == Long.MIN_VALUE && b == -1L) return // do not test, due to native KT-45136
val div = a / b
val rem = a % b
val fd = a.floorDiv(b)
val mod = a.mod(b)
try {
expectedFd?.let { assertEquals(it, fd) }
expectedMod?.let { assertEquals(it, mod) }
assertEquals(div - if (a.sign != b.sign && rem != 0L) 1 else 0, fd)
assertEquals(a - b * fd, mod)
} catch (e: AssertionError) {
fail("a: $a, b: $b, div: $div, rem: $rem, floorDiv: $fd, mod: $mod", e)
}
}
check(10, -3, -4, -2)
check(10, 3, 3, 1)
check(-10, 3, -4, 2)
check(-10, -3, 3, -1)
val values = listOf(1, -1, 2, -2, 3, -3, Long.MIN_VALUE, Long.MAX_VALUE)
for (a in values + 0) {
for (b in values) {
check(a, b)
}
}
repeat(1000) {
val a = Random.nextLong()
val b = Random.nextLong().let { if (it == 0L) 1 else it }
check(a, b)
}
}
@Test
fun byteDivMod() {
fun check(a: Byte, b: Byte, expectedFd: Int? = null, expectedMod: Byte? = null) {
val div = a / b
val rem = a % b
val fd = a.floorDiv(b)
val mod = a.mod(b)
try {
expectedFd?.let { assertEquals(it, fd) }
expectedMod?.let { assertEquals(it, mod) }
assertEquals(div - if (a.toInt().sign != b.toInt().sign && rem != 0) 1 else 0, fd)
assertEquals(a - b * fd, mod.toInt())
} catch (e: AssertionError) {
fail("a: $a, b: $b, div: $div, rem: $rem, floorDiv: $fd, mod: $mod", e)
}
}
check(10, -3, -4, -2)
check(10, 3, 3, 1)
check(-10, 3, -4, 2)
check(-10, -3, 3, -1)
val values = listOf(1, -1, 2, -2, 3, -3, Byte.MIN_VALUE, Byte.MAX_VALUE)
for (a in values + 0) {
for (b in values) {
check(a, b)
}
}
repeat(1000) {
val a = Random.nextInt().toByte()
val b = Random.nextInt().toByte().let { if (it == 0.toByte()) 1 else it }
check(a, b)
}
}
@Test
fun shortDivMod() {
fun check(a: Short, b: Short, expectedFd: Int? = null, expectedMod: Short? = null) {
val div = a / b
val rem = a % b
val fd = a.floorDiv(b)
val mod = a.mod(b)
try {
expectedFd?.let { assertEquals(it, fd) }
expectedMod?.let { assertEquals(it, mod) }
assertEquals(div - if (a.toInt().sign != b.toInt().sign && rem != 0) 1 else 0, fd)
assertEquals(a - b * fd, mod.toInt())
} catch (e: AssertionError) {
fail("a: $a, b: $b, div: $div, rem: $rem, floorDiv: $fd, mod: $mod", e)
}
}
check(10, -3, -4, -2)
check(10, 3, 3, 1)
check(-10, 3, -4, 2)
check(-10, -3, 3, -1)
val values = listOf(1, -1, 2, -2, 3, -3, Short.MIN_VALUE, Short.MAX_VALUE)
for (a in values + 0) {
for (b in values) {
check(a, b)
}
}
repeat(1000) {
val a = Random.nextInt().toShort()
val b = Random.nextInt().toShort().let { if (it == 0.toShort()) 1 else it }
check(a, b)
}
}
@Test
fun longIntMod() {
fun check(a: Long, b: Int, expectedFd: Long? = null, expectedMod: Int? = null) {
val div = a / b
val rem = a % b
val fd = a.floorDiv(b)
val mod = a.mod(b)
try {
expectedFd?.let { assertEquals(it, fd) }
expectedMod?.let { assertEquals(it, mod) }
assertEquals(div - if (a.sign != b.sign && rem != 0L) 1 else 0, fd)
assertEquals(a - b * fd, mod.toLong())
} catch (e: AssertionError) {
fail("a: $a, b: $b, div: $div, rem: $rem, floorDiv: $fd, mod: $mod", e)
}
}
check(Long.MAX_VALUE, 2, Long.MAX_VALUE / 2, 1)
check(Long.MAX_VALUE, 1.shl(30), expectedMod = 1.shl(30) - 1)
check(-1L, 1.shl(30), expectedMod = 1.shl(30) - 1)
check(Long.MAX_VALUE, Int.MAX_VALUE, expectedMod = 1)
check(Long.MAX_VALUE, Int.MIN_VALUE, expectedMod = -1)
}
@Test
fun shortIntMod() {
fun check(a: Short, b: Int, expectedFd: Int? = null, expectedMod: Int? = null) {
val div = a / b
val rem = a % b
val fd = a.floorDiv(b)
val mod = a.mod(b)
try {
expectedFd?.let { assertEquals(it, fd) }
expectedMod?.let { assertEquals(it, mod) }
assertEquals(div - if (a.toInt().sign != b.sign && rem != 0) 1 else 0, fd)
assertEquals(a.toInt() - b * fd, mod) // a.toInt() to workaround Int-out-of-range in JS legacy
} catch (e: AssertionError) {
fail("a: $a, b: $b, div: $div, rem: $rem, floorDiv: $fd, mod: $mod", e)
}
}
check(Short.MAX_VALUE, Int.MAX_VALUE, 0, Short.MAX_VALUE.toInt())
check(Short.MAX_VALUE, Int.MIN_VALUE, -1, Int.MIN_VALUE + Short.MAX_VALUE)
check((-1).toShort(), 1.shl(30), -1, 1.shl(30) - 1)
}
@Test
fun doubleMod() {
fun check(a: Double, b: Double, expectedMod: Double? = null) {
val rem = a % b
val mod = a.mod(b)
try {
expectedMod?.let { assertEquals(it, mod) }
assertEquals(if (rem.sign == mod.sign) rem else rem + b, mod)
} catch (e: AssertionError) {
fail("a: $a, b: $b, rem: $rem, mod: $mod", e)
}
}
check(10.125, -0.5, -0.375)
check(10.125, 0.5, 0.125)
check(-10.125, 0.5, 0.375)
check(-10.125, -0.5, -0.125)
val large = 2.0.pow(53)
check(0.025, large, 0.025)
check(-0.025, large, expectedMod = large)
check(0.025, -large, expectedMod = -large)
check(1.0, Double.NaN, Double.NaN)
check(Double.NaN, 1.0, Double.NaN)
check(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN)
val values = listOf(1.0, -1.0, 3.0, -3.0, large, -large, Double.MIN_VALUE, Double.MAX_VALUE,
Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN)
for (a in values + 0.0) {
for (b in values) {
check(a, b)
}
}
repeat(1000) {
val a = Random.nextDouble()
val b = Random.nextDouble().let { if (it == 0.0) 1.0 else it }
check(a, b)
}
}
@Test
fun floatMod() {
fun check(a: Float, b: Float, expectedMod: Float? = null) {
val rem = a % b
val mod = a.mod(b)
try {
expectedMod?.let { assertEquals(it, mod) }
assertEquals(if (rem.sign == mod.sign) rem else rem + b, mod)
} catch (e: AssertionError) {
fail("a: $a, b: $b, rem: $rem, mod: $mod", e)
}
}
check(10.125f, -0.5f, -0.375f)
check(10.125f, 0.5f, 0.125f)
check(-10.125f, 0.5f, 0.375f)
check(-10.125f, -0.5f, -0.125f)
val large = 2.0f.pow(53)
check(0.025f, large, 0.025f)
check(-0.025f, large, expectedMod = large)
check(0.025f, -large, expectedMod = -large)
check(1.0f, Float.NaN, Float.NaN)
check(Float.NaN, 1.0f, Float.NaN)
check(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, Float.NaN)
val values = listOf(1.0f, -1.0f, 3.0f, -3.0f, large, -large, Float.MIN_VALUE, Float.MAX_VALUE,
Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, Float.NaN)
for (a in values + 0.0f) {
for (b in values) {
check(a, b)
}
}
repeat(1000) {
val a = Random.nextFloat()
val b = Random.nextFloat().let { if (it == 0.0f) 1.0f else it }
check(a, b)
}
}
}
libraries/stdlib/test/unsigned/UIntTest.kt
+39 -6
View File
@@ -1,15 +1,12 @@
/*
* Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package test.unsigned
import kotlin.math.nextDown
import kotlin.math.nextUp
import kotlin.math.pow
import kotlin.math.sign
import kotlin.random.Random
import kotlin.math.*
import kotlin.random.*
import kotlin.test.*
class UIntTest {
@@ -69,6 +66,42 @@ class UIntTest {
testToString("4294967295", UInt.MAX_VALUE)
}
@Test
fun operations() {
assertEquals(2_147_483_648u, Int.MAX_VALUE.toUInt() + identity(1u))
assertEquals(11u, UInt.MAX_VALUE + identity(12u))
assertEquals(UInt.MAX_VALUE - 99u, 45u - identity(145u))
assertEquals(UInt.MAX_VALUE - 1u, Int.MAX_VALUE.toUInt() * identity(2u))
assertEquals(2_147_483_645u, Int.MAX_VALUE.toUInt() * identity(3u))
testMulDivRem(125u, 3u, 41u, 2u)
testMulDivRem(210u, 5u, 42u, 0u)
testMulDivRem(UInt.MAX_VALUE, 256u, 16777215u, 255u)
testMulDivRem(UInt.MAX_VALUE - 1u, UInt.MAX_VALUE, 0u, UInt.MAX_VALUE - 1u)
testMulDivRem(UInt.MAX_VALUE, UInt.MAX_VALUE - 1u, 1u, 1u)
testMulDivRem(UInt.MAX_VALUE, Int.MAX_VALUE.toUInt(), 2u, 1u)
}
private fun testMulDivRem(number: UInt, divisor: UInt, div: UInt, rem: UInt) {
assertEquals(div, number / divisor)
assertEquals(rem, number % divisor)
assertEquals(div, number.floorDiv(divisor))
assertEquals(rem, number.mod(divisor))
assertEquals(number, div * divisor + rem)
assertTrue(rem < divisor)
assertTrue(div < number)
}
@Test
fun divRem() = repeat(1000) {
val number = Random.nextUInt()
val divisor = Random.nextUInt(until = UInt.MAX_VALUE) + 1u
testMulDivRem(number, divisor, number / divisor, number % divisor)
}
@Test
fun comparisons() {
fun <T> compare(op1: Comparable<T>, op2: T) = op1.compareTo(op2)
libraries/stdlib/test/unsigned/ULongTest.kt
+39 -3
View File
@@ -1,12 +1,12 @@
/*
* Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package test.unsigned
import kotlin.math.*
import kotlin.random.Random
import kotlin.random.*
import kotlin.test.*
class ULongTest {
@@ -66,6 +66,42 @@ class ULongTest {
testToString("18446744073709551615", ULong.MAX_VALUE)
}
@Test
fun operations() {
assertEquals(9223372036854775808u, Long.MAX_VALUE.toULong() + identity(1u))
assertEquals(11u, ULong.MAX_VALUE + identity(12u))
assertEquals(ULong.MAX_VALUE - 99u, 45u - identity(145u))
assertEquals(ULong.MAX_VALUE - 1u, Long.MAX_VALUE.toULong() * identity(2u))
assertEquals(9223372036854775805u, Long.MAX_VALUE.toULong() * identity(3u))
testMulDivRem(125u, 3u, 41u, 2u)
testMulDivRem(210u, 5u, 42u, 0u)
testMulDivRem(ULong.MAX_VALUE, 65536uL * 65536u, 4294967295u, 4294967295u)
testMulDivRem(ULong.MAX_VALUE - 1u, ULong.MAX_VALUE, 0u, ULong.MAX_VALUE - 1u)
testMulDivRem(ULong.MAX_VALUE, ULong.MAX_VALUE - 1u, 1u, 1u)
testMulDivRem(ULong.MAX_VALUE, Long.MAX_VALUE.toULong(), 2u, 1u)
}
private fun testMulDivRem(number: ULong, divisor: ULong, div: ULong, rem: ULong) {
assertEquals(div, number / divisor)
assertEquals(rem, number % divisor)
assertEquals(div, number.floorDiv(divisor))
assertEquals(rem, number.mod(divisor))
assertEquals(number, div * divisor + rem)
assertTrue(rem < divisor)
assertTrue(div < number)
}
@Test
fun divRem() = repeat(1000) {
val number = Random.nextULong()
val divisor = Random.nextULong(until = ULong.MAX_VALUE) + 1u
testMulDivRem(number, divisor, number / divisor, number % divisor)
}
@Test
fun comparisons() {
fun <T> compare(op1: Comparable<T>, op2: T) = op1.compareTo(op2)
@@ -150,7 +186,7 @@ class ULongTest {
assertTrue(diff <= actual.ulp, "$actual should be within one ulp (${actual.ulp}) from the expected $expected")
}
fun testRounding(from: ULong, count: UInt) {
fun testRounding(from: ULong, count: ULong) {
for (x in from..(from + count)) {
val double = x.toDouble()
val v = double.toULong()