diff --git a/libraries/stdlib/common/src/generated/_Comparisons.kt b/libraries/stdlib/common/src/generated/_Comparisons.kt index c869e5b5770..a4d1963e2ad 100644 --- a/libraries/stdlib/common/src/generated/_Comparisons.kt +++ b/libraries/stdlib/common/src/generated/_Comparisons.kt @@ -129,6 +129,58 @@ public fun maxOf(a: T, b: T, comparator: Comparator): T { return if (comparator.compare(a, b) >= 0) a else b } +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun > maxOf(a: T, vararg other: T): T + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun maxOf(a: Byte, vararg other: Byte): Byte + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun maxOf(a: Short, vararg other: Short): Short + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun maxOf(a: Int, vararg other: Int): Int + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun maxOf(a: Long, vararg other: Long): Long + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun maxOf(a: Float, vararg other: Float): Float + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public expect fun maxOf(a: Double, vararg other: Double): Double + +/** + * Returns the greater of given values according to the order specified by the given [comparator]. + */ +@SinceKotlin("1.4") +public fun maxOf(a: T, vararg other: T, comparator: Comparator): T { + var max = a + for (e in other) if (comparator.compare(max, e) < 0) max = e + return max +} + /** * Returns the smaller of two values. * If values are equal, returns the first one. @@ -243,3 +295,55 @@ public fun minOf(a: T, b: T, comparator: Comparator): T { return if (comparator.compare(a, b) <= 0) a else b } +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun > minOf(a: T, vararg other: T): T + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun minOf(a: Byte, vararg other: Byte): Byte + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun minOf(a: Short, vararg other: Short): Short + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun minOf(a: Int, vararg other: Int): Int + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun minOf(a: Long, vararg other: Long): Long + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun minOf(a: Float, vararg other: Float): Float + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public expect fun minOf(a: Double, vararg other: Double): Double + +/** + * Returns the smaller of given values according to the order specified by the given [comparator]. + */ +@SinceKotlin("1.4") +public fun minOf(a: T, vararg other: T, comparator: Comparator): T { + var min = a + for (e in other) if (comparator.compare(min, e) > 0) min = e + return min +} + diff --git a/libraries/stdlib/common/src/generated/_UComparisons.kt b/libraries/stdlib/common/src/generated/_UComparisons.kt index af859fc6678..008c73250e6 100644 --- a/libraries/stdlib/common/src/generated/_UComparisons.kt +++ b/libraries/stdlib/common/src/generated/_UComparisons.kt @@ -91,6 +91,50 @@ public inline fun maxOf(a: UShort, b: UShort, c: UShort): UShort { return maxOf(a, maxOf(b, c)) } +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun maxOf(a: UInt, vararg other: UInt): UInt { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun maxOf(a: ULong, vararg other: ULong): ULong { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun maxOf(a: UByte, vararg other: UByte): UByte { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun maxOf(a: UShort, vararg other: UShort): UShort { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + /** * Returns the smaller of two values. */ @@ -167,3 +211,47 @@ public inline fun minOf(a: UShort, b: UShort, c: UShort): UShort { return minOf(a, minOf(b, c)) } +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun minOf(a: UInt, vararg other: UInt): UInt { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun minOf(a: ULong, vararg other: ULong): ULong { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun minOf(a: UByte, vararg other: UByte): UByte { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +@ExperimentalUnsignedTypes +public fun minOf(a: UShort, vararg other: UShort): UShort { + var min = a + for (e in other) min = minOf(min, e) + return min +} + diff --git a/libraries/stdlib/js-ir/src/generated/_ComparisonsJs.kt b/libraries/stdlib/js-ir/src/generated/_ComparisonsJs.kt index b10786b950e..7cf47d44cd4 100644 --- a/libraries/stdlib/js-ir/src/generated/_ComparisonsJs.kt +++ b/libraries/stdlib/js-ir/src/generated/_ComparisonsJs.kt @@ -147,6 +147,76 @@ public actual inline fun maxOf(a: Double, b: Double, c: Double): Double { return Math.max(a, b, c) } +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun > maxOf(a: T, vararg other: T): T { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Byte, vararg other: Byte): Byte { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Short, vararg other: Short): Short { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Int, vararg other: Int): Int { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Long, vararg other: Long): Long { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Float, vararg other: Float): Float { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Double, vararg other: Double): Double { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + /** * Returns the smaller of two values. * If values are equal, returns the first one. @@ -282,3 +352,73 @@ public actual inline fun minOf(a: Double, b: Double, c: Double): Double { return Math.min(a, b, c) } +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun > minOf(a: T, vararg other: T): T { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Byte, vararg other: Byte): Byte { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Short, vararg other: Short): Short { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Int, vararg other: Int): Int { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Long, vararg other: Long): Long { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Float, vararg other: Float): Float { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Double, vararg other: Double): Double { + var min = a + for (e in other) min = minOf(min, e) + return min +} + diff --git a/libraries/stdlib/js/src/generated/_ComparisonsJs.kt b/libraries/stdlib/js/src/generated/_ComparisonsJs.kt index b10786b950e..7cf47d44cd4 100644 --- a/libraries/stdlib/js/src/generated/_ComparisonsJs.kt +++ b/libraries/stdlib/js/src/generated/_ComparisonsJs.kt @@ -147,6 +147,76 @@ public actual inline fun maxOf(a: Double, b: Double, c: Double): Double { return Math.max(a, b, c) } +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun > maxOf(a: T, vararg other: T): T { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Byte, vararg other: Byte): Byte { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Short, vararg other: Short): Short { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Int, vararg other: Int): Int { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Long, vararg other: Long): Long { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Float, vararg other: Float): Float { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Double, vararg other: Double): Double { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + /** * Returns the smaller of two values. * If values are equal, returns the first one. @@ -282,3 +352,73 @@ public actual inline fun minOf(a: Double, b: Double, c: Double): Double { return Math.min(a, b, c) } +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun > minOf(a: T, vararg other: T): T { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Byte, vararg other: Byte): Byte { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Short, vararg other: Short): Short { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Int, vararg other: Int): Int { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Long, vararg other: Long): Long { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Float, vararg other: Float): Float { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Double, vararg other: Double): Double { + var min = a + for (e in other) min = minOf(min, e) + return min +} + diff --git a/libraries/stdlib/jvm/src/generated/_ComparisonsJvm.kt b/libraries/stdlib/jvm/src/generated/_ComparisonsJvm.kt index f00159659f9..66823134b64 100644 --- a/libraries/stdlib/jvm/src/generated/_ComparisonsJvm.kt +++ b/libraries/stdlib/jvm/src/generated/_ComparisonsJvm.kt @@ -139,6 +139,76 @@ public actual inline fun maxOf(a: Double, b: Double, c: Double): Double { return maxOf(a, maxOf(b, c)) } +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun > maxOf(a: T, vararg other: T): T { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Byte, vararg other: Byte): Byte { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Short, vararg other: Short): Short { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Int, vararg other: Int): Int { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Long, vararg other: Long): Long { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Float, vararg other: Float): Float { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + +/** + * Returns the greater of given values. + */ +@SinceKotlin("1.4") +public actual fun maxOf(a: Double, vararg other: Double): Double { + var max = a + for (e in other) max = maxOf(max, e) + return max +} + /** * Returns the smaller of two values. * If values are equal, returns the first one. @@ -264,3 +334,73 @@ public actual inline fun minOf(a: Double, b: Double, c: Double): Double { return minOf(a, minOf(b, c)) } +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun > minOf(a: T, vararg other: T): T { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Byte, vararg other: Byte): Byte { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Short, vararg other: Short): Short { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Int, vararg other: Int): Int { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Long, vararg other: Long): Long { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Float, vararg other: Float): Float { + var min = a + for (e in other) min = minOf(min, e) + return min +} + +/** + * Returns the smaller of given values. + */ +@SinceKotlin("1.4") +public actual fun minOf(a: Double, vararg other: Double): Double { + var min = a + for (e in other) min = minOf(min, e) + return min +} + diff --git a/libraries/stdlib/test/OrderingTest.kt b/libraries/stdlib/test/OrderingTest.kt index bdac75f47cf..c32fa1e3576 100644 --- a/libraries/stdlib/test/OrderingTest.kt +++ b/libraries/stdlib/test/OrderingTest.kt @@ -20,6 +20,7 @@ class OrderingTest { val v1 = Item("wine", 9) val v2 = Item("beer", 10) val v3 = Item("apple", 20) + val v4 = Item("grape", 22) @Test fun compareByCompareTo() { @@ -154,44 +155,56 @@ class OrderingTest { fun maxOf() { assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE)) assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0)) + assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0, -1)) assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE)) assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE, 0)) + assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE, 0, -1)) assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)) assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) + assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) assertEquals(0.0, maxOf(0.0, -0.0)) assertEquals(0.0, maxOf(-0.0, 0.0)) + assertEquals(0.0, maxOf(-0.0, 0.0, 0.0, -0.0)) } @Test fun maxOfWith() { assertEquals(v1, maxOf(v1, v2, compareBy { it.name })) assertEquals(v1, maxOf(v3, v2, v1, compareBy { it.name })) + assertEquals(v1, maxOf(v4, v3, v2, v1, comparator = compareBy { it.name })) assertEquals(v2, maxOf(v1, v2, compareBy { it.rating })) assertEquals(v3, maxOf(v1, v2, v3, compareBy { it.rating })) + assertEquals(v4, maxOf(v4, v1, v2, v3, comparator = compareBy { it.rating })) } @Test fun minOf() { assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE)) assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0)) + assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0, -1)) assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE)) assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE, 0)) + assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE, 0, -1)) assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)) assertEquals(Double.MIN_VALUE, minOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) + assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) assertEquals(-0.0, minOf(0.0, -0.0)) assertEquals(-0.0, minOf(-0.0, 0.0)) + assertEquals(-0.0, minOf(-0.0, 0.0, 0.0, -0.0)) } @Test fun minOfWith() { assertEquals(v2, minOf(v1, v2, compareBy { it.name })) assertEquals(v3, minOf(v3, v2, v1, compareBy { it.name })) + assertEquals(v3, minOf(v4, v2, v3, v1, comparator = compareBy { it.name })) assertEquals(v1, minOf(v1, v2, compareBy { it.rating })) assertEquals(v1, minOf(v1, v2, v3, compareBy { it.rating })) + assertEquals(v1, minOf(v4, v1, v2, v3, comparator = compareBy { it.rating })) } } diff --git a/libraries/stdlib/test/numbers/NaNPropagationTest.kt b/libraries/stdlib/test/numbers/NaNPropagationTest.kt index 268ec03a532..29a1907996b 100644 --- a/libraries/stdlib/test/numbers/NaNPropagationTest.kt +++ b/libraries/stdlib/test/numbers/NaNPropagationTest.kt @@ -58,12 +58,30 @@ class NaNPropagationTest { propagateOf3(::minOf, ::minOf, "minOf") } + @Test + fun minOfVararg() { + propagateOf3( + { a, b, c -> minOf(a, *doubleArrayOf(b, c)) }, + { a, b, c -> minOf(a, *floatArrayOf(b, c)) }, + "minOf(a, vararg other)" + ) + } + @Test fun maxOf() { propagateOf2(::maxOf, ::maxOf, "maxOf") propagateOf3(::maxOf, ::maxOf, "maxOf") } + @Test + fun maxOfVararg() { + propagateOf3( + { a, b, c -> maxOf(a, *doubleArrayOf(b, c)) }, + { a, b, c -> maxOf(a, *floatArrayOf(b, c)) }, + "maxOf(a, vararg other)" + ) + } + @Test fun arrayMin() { propagateOf2( diff --git a/libraries/stdlib/test/unsigned/UComparisonsTest.kt b/libraries/stdlib/test/unsigned/UComparisonsTest.kt index 40edc493434..a8fc24b0578 100644 --- a/libraries/stdlib/test/unsigned/UComparisonsTest.kt +++ b/libraries/stdlib/test/unsigned/UComparisonsTest.kt @@ -26,6 +26,14 @@ class UComparisonsTest { expect(42312uL) { minOf(42312uL, 42312uL, 42312uL) } } + @Test + fun minOf_vararg() { + expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 2.toUByte(), 10.toUByte()) } + expect(55.toUShort()) { minOf(58.toUShort(), 32768.toUShort(), 55.toUShort(), 2423.toUShort()) } + expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1000u, (-1).toUInt(), Int.MAX_VALUE.toUInt()) } + expect(42312uL) { minOf(42312uL, 42312uL, 42312uL, 42312uL) } + } + @Test fun maxOf_2() { expect(2.toUByte()) { maxOf(2.toUByte(), 1.toUByte()) } @@ -41,4 +49,12 @@ class UComparisonsTest { expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u) } expect(42312uL) { maxOf(42312uL, 42312uL, 42312uL) } } + + @Test + fun maxOf_vararg() { + expect(10.toUByte()) { maxOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 2.toUByte(), 10.toUByte()) } + expect(32768.toUShort()) { maxOf(58.toUShort(), 32768.toUShort(), 55.toUShort(), 2423.toUShort()) } + expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1000u, (-1).toUInt(), Int.MAX_VALUE.toUInt()) } + expect(42312uL) { maxOf(42312uL, 42312uL, 42312uL, 42312uL) } + } } \ No newline at end of file diff --git a/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt b/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt index 783cfead2c1..f3e9088c526 100644 --- a/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt +++ b/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt @@ -2605,14 +2605,30 @@ public final class kotlin/comparisons/ComparisonsKt { public static final fun compareBy ([Lkotlin/jvm/functions/Function1;)Ljava/util/Comparator; public static final fun compareValues (Ljava/lang/Comparable;Ljava/lang/Comparable;)I public static final fun compareValuesBy (Ljava/lang/Object;Ljava/lang/Object;[Lkotlin/jvm/functions/Function1;)I + public static final fun maxOf (B[B)B + public static final fun maxOf (D[D)D + public static final fun maxOf (F[F)F + public static final fun maxOf (I[I)I + public static final fun maxOf (J[J)J public static final fun maxOf (Ljava/lang/Comparable;Ljava/lang/Comparable;)Ljava/lang/Comparable; public static final fun maxOf (Ljava/lang/Comparable;Ljava/lang/Comparable;Ljava/lang/Comparable;)Ljava/lang/Comparable; + public static final fun maxOf (Ljava/lang/Comparable;[Ljava/lang/Comparable;)Ljava/lang/Comparable; public static final fun maxOf (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)Ljava/lang/Object; public static final fun maxOf (Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)Ljava/lang/Object; + public static final fun maxOf (Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)Ljava/lang/Object; + public static final fun maxOf (S[S)S + public static final fun minOf (B[B)B + public static final fun minOf (D[D)D + public static final fun minOf (F[F)F + public static final fun minOf (I[I)I + public static final fun minOf (J[J)J public static final fun minOf (Ljava/lang/Comparable;Ljava/lang/Comparable;)Ljava/lang/Comparable; public static final fun minOf (Ljava/lang/Comparable;Ljava/lang/Comparable;Ljava/lang/Comparable;)Ljava/lang/Comparable; + public static final fun minOf (Ljava/lang/Comparable;[Ljava/lang/Comparable;)Ljava/lang/Comparable; public static final fun minOf (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)Ljava/lang/Object; public static final fun minOf (Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)Ljava/lang/Object; + public static final fun minOf (Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)Ljava/lang/Object; + public static final fun minOf (S[S)S public static final fun naturalOrder ()Ljava/util/Comparator; public static final fun nullsFirst (Ljava/util/Comparator;)Ljava/util/Comparator; public static final fun nullsLast (Ljava/util/Comparator;)Ljava/util/Comparator; @@ -2626,11 +2642,19 @@ public final class kotlin/comparisons/UComparisonsKt { public static final fun maxOf-5PvTz6A (SS)S public static final fun maxOf-J1ME1BU (II)I public static final fun maxOf-Kr8caGY (BB)B + public static final fun maxOf-Md2H83M (I[I)I + public static final fun maxOf-R03FKyM (J[J)J + public static final fun maxOf-Wr6uiD8 (B[B)B public static final fun maxOf-eb3DHEI (JJ)J + public static final fun maxOf-t1qELG4 (S[S)S public static final fun minOf-5PvTz6A (SS)S public static final fun minOf-J1ME1BU (II)I public static final fun minOf-Kr8caGY (BB)B + public static final fun minOf-Md2H83M (I[I)I + public static final fun minOf-R03FKyM (J[J)J + public static final fun minOf-Wr6uiD8 (B[B)B public static final fun minOf-eb3DHEI (JJ)J + public static final fun minOf-t1qELG4 (S[S)S } public final class kotlin/concurrent/ThreadsKt { diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt index a42299bc09a..a3f94169c3e 100644 --- a/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt @@ -12,7 +12,7 @@ object ComparableOps : TemplateGroupBase() { init { defaultBuilder { specialFor(Unsigned) { - since("1.3") + sinceAtLeast("1.3") annotation("@ExperimentalUnsignedTypes") } } @@ -259,6 +259,34 @@ object ComparableOps : TemplateGroupBase() { } } + val f_minOf_vararg = fn("minOf(a: T, vararg other: T)") { + include(Generic) + include(Primitives, numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + since("1.4") + typeParam("T : Comparable") + returns("T") + receiver("") + // TODO: Add a note about NaN propagation for floats. + doc { + """ + Returns the smaller of given values. + """ + } + body { + """ + var min = a + for (e in other) min = minOf(min, e) + return min + """ + } + specialFor(Generic, Primitives) { + on(Platform.JS) { /* just to make expect, KT-22520 */ } + } + } + val f_minOf_2_comparator = fn("minOf(a: T, b: T, comparator: Comparator)") { include(Generic) } builder { @@ -294,6 +322,27 @@ object ComparableOps : TemplateGroupBase() { } } + val f_minOf_vararg_comparator = fn("minOf(a: T, vararg other: T, comparator: Comparator)") { + include(Generic) + } builder { + sourceFile(f.sourceFileComparisons) + since("1.4") + returns("T") + receiver("") + doc { + """ + Returns the smaller of given values according to the order specified by the given [comparator]. + """ + } + body { + """ + var min = a + for (e in other) if (comparator.compare(min, e) > 0) min = e + return min + """ + } + } + val f_maxOf_2 = fn("maxOf(a: T, b: T)") { include(Generic) include(Primitives, numericPrimitives) @@ -398,6 +447,34 @@ object ComparableOps : TemplateGroupBase() { } } + val f_maxOf_vararg = fn("maxOf(a: T, vararg other: T)") { + include(Generic) + include(Primitives, numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + since("1.4") + typeParam("T : Comparable") + returns("T") + receiver("") + // TODO: Add a note about NaN propagation for floats. + doc { + """ + Returns the greater of given values. + """ + } + body { + """ + var max = a + for (e in other) max = maxOf(max, e) + return max + """ + } + specialFor(Generic, Primitives) { + on(Platform.JS) { /* just to make expect, KT-22520 */ } + } + } + val f_maxOf_2_comparator = fn("maxOf(a: T, b: T, comparator: Comparator)") { include(Generic) } builder { @@ -433,6 +510,27 @@ object ComparableOps : TemplateGroupBase() { } } + val f_maxOf_vararg_comparator = fn("maxOf(a: T, vararg other: T, comparator: Comparator)") { + include(Generic) + } builder { + sourceFile(f.sourceFileComparisons) + since("1.4") + returns("T") + receiver("") + doc { + """ + Returns the greater of given values according to the order specified by the given [comparator]. + """ + } + body { + """ + var max = a + for (e in other) if (comparator.compare(max, e) < 0) max = e + return max + """ + } + } + val f_coerceIn_min_max = fn("coerceIn(minimumValue: SELF, maximumValue: SELF)") { include(Generic)