Artem Kobzar
218 lines
8.3 KiB
Kotlin
218 lines
8.3 KiB
Kotlin
/*
|
|
* 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 kotlin
|
|
|
|
/**
|
|
* Returns `true` if the specified number is a
|
|
* Not-a-Number (NaN) value, `false` otherwise.
|
|
*/
|
|
public actual fun Double.isNaN(): Boolean = this != this
|
|
|
|
/**
|
|
* Returns `true` if the specified number is a
|
|
* Not-a-Number (NaN) value, `false` otherwise.
|
|
*/
|
|
public actual fun Float.isNaN(): Boolean = this != this
|
|
|
|
/**
|
|
* Returns `true` if this value is infinitely large in magnitude.
|
|
*/
|
|
public actual fun Double.isInfinite(): Boolean = this == Double.POSITIVE_INFINITY || this == Double.NEGATIVE_INFINITY
|
|
|
|
/**
|
|
* Returns `true` if this value is infinitely large in magnitude.
|
|
*/
|
|
public actual fun Float.isInfinite(): Boolean = this == Float.POSITIVE_INFINITY || this == Float.NEGATIVE_INFINITY
|
|
|
|
/**
|
|
* Returns `true` if the argument is a finite floating-point value; returns `false` otherwise (for `NaN` and infinity arguments).
|
|
*/
|
|
public actual fun Double.isFinite(): Boolean = !isInfinite() && !isNaN()
|
|
|
|
/**
|
|
* Returns `true` if the argument is a finite floating-point value; returns `false` otherwise (for `NaN` and infinity arguments).
|
|
*/
|
|
public actual fun Float.isFinite(): Boolean = !isInfinite() && !isNaN()
|
|
|
|
|
|
/**
|
|
* Counts the number of set bits in the binary representation of this [Int] number.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Int.countOneBits(): Int {
|
|
// Hacker's Delight 5-1 algorithm
|
|
var v = this
|
|
v = (v and 0x55555555) + (v.ushr(1) and 0x55555555)
|
|
v = (v and 0x33333333) + (v.ushr(2) and 0x33333333)
|
|
v = (v and 0x0F0F0F0F) + (v.ushr(4) and 0x0F0F0F0F)
|
|
v = (v and 0x00FF00FF) + (v.ushr(8) and 0x00FF00FF)
|
|
v = (v and 0x0000FFFF) + (v.ushr(16))
|
|
return v
|
|
}
|
|
|
|
/**
|
|
* Counts the number of consecutive most significant bits that are zero in the binary representation of this [Int] number.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun Int.countLeadingZeroBits(): Int = nativeClz32(this)
|
|
|
|
/**
|
|
* Counts the number of consecutive least significant bits that are zero in the binary representation of this [Int] number.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Int.countTrailingZeroBits(): Int =
|
|
// Hacker's Delight 5-4 algorithm for expressing countTrailingZeroBits with countLeadingZeroBits
|
|
Int.SIZE_BITS - (this or -this).inv().countLeadingZeroBits()
|
|
|
|
/**
|
|
* Returns a number having a single bit set in the position of the most significant set bit of this [Int] number,
|
|
* or zero, if this number is zero.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Int.takeHighestOneBit(): Int =
|
|
if (this == 0) 0 else 1.shl(Int.SIZE_BITS - 1 - countLeadingZeroBits())
|
|
|
|
/**
|
|
* Returns a number having a single bit set in the position of the least significant set bit of this [Int] number,
|
|
* or zero, if this number is zero.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Int.takeLowestOneBit(): Int =
|
|
// Hacker's Delight 2-1 algorithm for isolating rightmost 1-bit
|
|
this and -this
|
|
|
|
/**
|
|
* Rotates the binary representation of this [Int] number left by the specified [bitCount] number of bits.
|
|
* The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.
|
|
*
|
|
* Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:
|
|
* `number.rotateLeft(-n) == number.rotateRight(n)`
|
|
*
|
|
* Rotating by a multiple of [Int.SIZE_BITS] (32) returns the same number, or more generally
|
|
* `number.rotateLeft(n) == number.rotateLeft(n % 32)`
|
|
*/
|
|
@SinceKotlin("1.6")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Int.rotateLeft(bitCount: Int): Int =
|
|
shl(bitCount) or ushr(Int.SIZE_BITS - bitCount)
|
|
|
|
|
|
/**
|
|
* Rotates the binary representation of this [Int] number right by the specified [bitCount] number of bits.
|
|
* The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.
|
|
*
|
|
* Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:
|
|
* `number.rotateRight(-n) == number.rotateLeft(n)`
|
|
*
|
|
* Rotating by a multiple of [Int.SIZE_BITS] (32) returns the same number, or more generally
|
|
* `number.rotateRight(n) == number.rotateRight(n % 32)`
|
|
*/
|
|
@SinceKotlin("1.6")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Int.rotateRight(bitCount: Int): Int =
|
|
shl(Int.SIZE_BITS - bitCount) or ushr(bitCount)
|
|
|
|
|
|
/**
|
|
* Counts the number of set bits in the binary representation of this [Long] number.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Long.countOneBits(): Int =
|
|
high.countOneBits() + low.countOneBits()
|
|
|
|
/**
|
|
* Counts the number of consecutive most significant bits that are zero in the binary representation of this [Long] number.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Long.countLeadingZeroBits(): Int =
|
|
when (val high = this.high) {
|
|
0 -> Int.SIZE_BITS + low.countLeadingZeroBits()
|
|
else -> high.countLeadingZeroBits()
|
|
}
|
|
|
|
/**
|
|
* Counts the number of consecutive least significant bits that are zero in the binary representation of this [Long] number.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Long.countTrailingZeroBits(): Int =
|
|
when (val low = this.low) {
|
|
0 -> Int.SIZE_BITS + high.countTrailingZeroBits()
|
|
else -> low.countTrailingZeroBits()
|
|
}
|
|
|
|
/**
|
|
* Returns a number having a single bit set in the position of the most significant set bit of this [Long] number,
|
|
* or zero, if this number is zero.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Long.takeHighestOneBit(): Long =
|
|
when (val high = this.high) {
|
|
0 -> Long(low.takeHighestOneBit(), 0)
|
|
else -> Long(0, high.takeHighestOneBit())
|
|
}
|
|
|
|
/**
|
|
* Returns a number having a single bit set in the position of the least significant set bit of this [Long] number,
|
|
* or zero, if this number is zero.
|
|
*/
|
|
@SinceKotlin("1.4")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Long.takeLowestOneBit(): Long =
|
|
when (val low = this.low) {
|
|
0 -> Long(0, high.takeLowestOneBit())
|
|
else -> Long(low.takeLowestOneBit(), 0)
|
|
}
|
|
|
|
/**
|
|
* Rotates the binary representation of this [Long] number left by the specified [bitCount] number of bits.
|
|
* The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.
|
|
*
|
|
* Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:
|
|
* `number.rotateLeft(-n) == number.rotateRight(n)`
|
|
*
|
|
* Rotating by a multiple of [Long.SIZE_BITS] (64) returns the same number, or more generally
|
|
* `number.rotateLeft(n) == number.rotateLeft(n % 64)`
|
|
*/
|
|
@SinceKotlin("1.6")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
public actual fun Long.rotateLeft(bitCount: Int): Long {
|
|
if ((bitCount and 31) != 0) {
|
|
val low = this.low
|
|
val high = this.high
|
|
val newLow = low.shl(bitCount) or high.ushr(-bitCount)
|
|
val newHigh = high.shl(bitCount) or low.ushr(-bitCount)
|
|
return if ((bitCount and 32) == 0) Long(newLow, newHigh) else Long(newHigh, newLow)
|
|
} else {
|
|
return if ((bitCount and 32) == 0) this else Long(high, low)
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Rotates the binary representation of this [Long] number right by the specified [bitCount] number of bits.
|
|
* The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.
|
|
*
|
|
* Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:
|
|
* `number.rotateRight(-n) == number.rotateLeft(n)`
|
|
*
|
|
* Rotating by a multiple of [Long.SIZE_BITS] (64) returns the same number, or more generally
|
|
* `number.rotateRight(n) == number.rotateRight(n % 64)`
|
|
*/
|
|
@SinceKotlin("1.6")
|
|
@WasExperimental(ExperimentalStdlibApi::class)
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun Long.rotateRight(bitCount: Int): Long = rotateLeft(-bitCount)
|