Converts this value considering it was in the range srcMin..srcMax into dstMin..dstMax, if the value is not inside the range the output value will be outside the destination range

convertRangeClamped

fun Double.convertRangeClamped(srcMin: Double, srcMax: Double, dstMin: Double, dstMax: Double): Double

fun Float.convertRangeClamped(srcMin: Float, srcMax: Float, dstMin: Float, dstMax: Float): Float

fun Int.convertRangeClamped(srcMin: Int, srcMax: Int, dstMin: Int, dstMax: Int): Int

fun Long.convertRangeClamped(srcMin: Long, srcMax: Long, dstMin: Long, dstMax: Long): Long

Converts this value considering it was in the range srcMin..srcMax into dstMin..dstMax, if the value is not inside the range the output value will be clamped to the nearest bound

cycle

fun Int.cycle(min: Int, max: Int): Int

cycleSteps

fun Int.cycleSteps(min: Int, max: Int): Int

divCeil

infix fun Int.divCeil(that: Int): Int

Divides this into that rounding to the ceil

infix fun Long.divCeil(other: Long): Long

divFloor

infix fun Int.divFloor(that: Int): Int

Divides this into that rounding to the floor

divRound

infix fun Int.divRound(that: Int): Int

Divides this into that rounding to the round

fract

inline fun fract(value: Double): Double

inline fun fract(value: Float): Float

ilog2

fun ilog2(v: Int): Int

Performs a fast integral logarithmic of base two

ilog2Ceil

fun ilog2Ceil(v: Int): Int

isAlignedTo

fun Double.isAlignedTo(alignment: Double): Boolean

Returns whether this is multiple of alignment

fun Float.isAlignedTo(alignment: Float): Boolean

Returns whether this is multiple of alignment

fun Int.isAlignedTo(alignment: Int): Boolean

Returns whether this is multiple of alignment

fun Long.isAlignedTo(alignment: Long): Boolean

Returns whether this is multiple of alignment

isAlmostEquals

fun Double.isAlmostEquals(other: Double, epsilon: Double = 1.0E-6): Boolean

fun Float.isAlmostEquals(other: Float, epsilon: Float = 1.0E-6f): Boolean

isAlmostZero

fun Double.isAlmostZero(): Boolean

fun Float.isAlmostZero(): Boolean

isEquivalent

fun isEquivalent(a: Double, b: Double, epsilon: Double = 1.0E-4): Boolean

isMultipleOf

fun Double.isMultipleOf(multiple: Double): Boolean

fun Int.isMultipleOf(multiple: Int): Boolean

fun Long.isMultipleOf(multiple: Long): Boolean

isNanOrInfinite

fun Double.isNanOrInfinite(): Boolean

fun Float.isNanOrInfinite(): Boolean

fun ln(v: Int): Int

log

fun log(v: Int, base: Int): Int

log10

fun log10(v: Int): Int

log2

fun log2(v: Int): Int

max

fun max(a: Double, b: Double, c: Double): Double

fun max(a: Float, b: Float, c: Float): Float

fun max(a: Int, b: Int, c: Int): Int

fun max(a: Double, b: Double, c: Double, d: Double): Double

fun max(a: Float, b: Float, c: Float, d: Float): Float

fun max(a: Int, b: Int, c: Int, d: Int): Int

fun max(a: Double, b: Double, c: Double, d: Double, e: Double): Double

fun max(a: Float, b: Float, c: Float, d: Float, e: Float): Float

fun max(a: Int, b: Int, c: Int, d: Int, e: Int): Int

min

fun min(a: Double, b: Double, c: Double): Double

fun min(a: Float, b: Float, c: Float): Float

fun min(a: Int, b: Int, c: Int): Int

fun min(a: Double, b: Double, c: Double, d: Double): Double

fun min(a: Float, b: Float, c: Float, d: Float): Float

fun min(a: Int, b: Int, c: Int, d: Int): Int

fun min(a: Double, b: Double, c: Double, d: Double, e: Double): Double

fun min(a: Float, b: Float, c: Float, d: Float, e: Float): Float

fun min(a: Int, b: Int, c: Int, d: Int, e: Int): Int

nearestAlignedTo

fun Double.nearestAlignedTo(align: Double): Double

Returns the previous or next value of this that is multiple of align. If this is already multiple, returns itself.

fun Float.nearestAlignedTo(align: Float): Float

Returns the previous or next value of this that is multiple of align. If this is already multiple, returns itself.

nextAlignedTo

fun Double.nextAlignedTo(align: Double): Double

Returns the next value of this that is multiple of align. If this is already multiple, returns itself.

fun Float.nextAlignedTo(align: Float): Float

Returns the next value of this that is multiple of align. If this is already multiple, returns itself.

fun Int.nextAlignedTo(align: Int): Int

Returns the next value of this that is multiple of align. If this is already multiple, returns itself.

fun Long.nextAlignedTo(align: Long): Long

Returns the next value of this that is multiple of align. If this is already multiple, returns itself.

nextMultipleOf

fun Double.nextMultipleOf(multiple: Double): Double

fun Int.nextMultipleOf(multiple: Int): Int

fun Long.nextMultipleOf(multiple: Long): Long

normalizeAlmostZero

fun Float.normalizeAlmostZero(): Float

normalizeZero

fun Double.normalizeZero(): Double

fun Float.normalizeZero(): Float

numberOfDigits

fun Int.numberOfDigits(radix: Int = 10): Int

fun Long.numberOfDigits(radix: Int = 10): Int

prevAlignedTo

fun Double.prevAlignedTo(align: Double): Double

Returns the previous value of this that is multiple of align. If this is already multiple, returns itself.

fun Float.prevAlignedTo(align: Float): Float

Returns the previous value of this that is multiple of align. If this is already multiple, returns itself.

fun Int.prevAlignedTo(align: Int): Int

Returns the previous value of this that is multiple of align. If this is already multiple, returns itself.

fun Long.prevAlignedTo(align: Long): Long

Returns the previous value of this that is multiple of align. If this is already multiple, returns itself.

prevMultipleOf

fun Double.prevMultipleOf(multiple: Double): Double

fun Int.prevMultipleOf(multiple: Int): Int

fun Long.prevMultipleOf(multiple: Long): Long

roundDecimalPlaces

fun Double.roundDecimalPlaces(places: Int): Double

fun Float.roundDecimalPlaces(places: Int): Float

signNonZeroM1

fun signNonZeroM1(x: Double): Int

fun signNonZeroM1(x: Float): Int

fun signNonZeroM1(x: Int): Int

Signs of the value. Zero will be converted into -1

signNonZeroP1

fun signNonZeroP1(x: Double): Int

fun signNonZeroP1(x: Float): Int

fun signNonZeroP1(x: Int): Int

Signs of the value. Zero will be converted into +1

smoothstep

fun Double.smoothstep(edge0: Double, edge1: Double): Double

fun sq(v: Double): Double

fun sq(v: Float): Float

fun sq(v: Int): Int

squared

fun Double.squared(): Double

fun Float.squared(): Float

fun Int.squared(): Int

toBoolean

inline fun Byte.toBoolean(): Boolean

toByte

inline fun Boolean.toByte(): Byte

toByteClamped

fun Int.toByteClamped(): Byte

toInt

inline fun Boolean.toInt(): Int

Converts this Boolean into integer: 1 for true, 0 for false

toIntCeil

fun Double.toIntCeil(): Int

Converts this into Int rounding to the ceiling

fun Float.toIntCeil(): Int

Converts this into Int rounding to the ceiling

toIntClamp

fun Long.toIntClamp(min: Int = Int.MIN_VALUE, max: Int = Int.MAX_VALUE): Int

Clamps this value into the range min and max converting it into Int. The default parameters will cover the whole range of values.

toIntFloor

fun Double.toIntFloor(): Int

Converts this into Int rounding to the floor

fun Float.toIntFloor(): Int

Converts this into Int rounding to the floor

toIntRound

fun Double.toIntRound(): Int

Converts this into Int rounding to the nearest

fun Float.toIntRound(): Int

Converts this into Int rounding to the nearest

toIntSafe

fun Long.toIntSafe(): Int

Convert this Long into an Int but throws an IllegalArgumentException in the case that operation would produce an overflow

toLongRound

fun Double.toLongRound(): Long

Converts this into Int rounding to the nearest

fun Float.toLongRound(): Long

Converts this into Int rounding to the nearest

toShortClamped

fun Int.toShortClamped(): Short

toUintClamp

fun Long.toUintClamp(min: Int = 0, max: Int = Int.MAX_VALUE): Int

Clamps this value into the range min and max converting it into Int (where min must be zero or positive). The default parameters will cover the whole range of positive and zero values.

umod

infix fun Double.umod(other: Double): Double

Performs the unsigned modulo between this and other (negative values would wrap)

infix fun Float.umod(other: Float): Float

infix fun Int.umod(other: Int): Int

Performs the unsigned modulo between this and other (negative values would wrap)