androidx.compose.ui.util

fun doubleFromBits(bits: Long): Double

Returns the Double value corresponding to a given bit representation.

fun fastCbrt(x: Float): Float

Fast, approximate cube root function. Returns the cube root of x; for any x fastCbrt(-x) == -fastCbrt(x).

When x is:

• Float.NaN, returns Float.NaN

• Float.POSITIVE_INFINITY, returns Float.NaN

• Float.NEGATIVE_INFINITY, returns Float.NaN

• Zero, returns a value close to 0 (~8.3e-14) with the same sign

The maximum error compared to kotlin.math.cbrt is:

• 5.9604645E-7 in the range -1f..1f

• 4.7683716E-6 in the range -256f..256f

• 3.8146973E-5 in the range -65_536f..65_536f

• 1.5258789E-4 in the range -16_777_216..16_777_216f

inline fun fastMaxOf(a: Float, b: Float, c: Float, d: Float): Float

Returns the largest of the given values. If any value is NaN, returns NaN. Preferred over kotlin.comparisons.maxOf() for 4 arguments as it avoids allocating an array because of the varargs.

inline fun fastMinOf(a: Float, b: Float, c: Float, d: Float): Float

Returns the smaller of the given values. If any value is NaN, returns NaN. Preferred over kotlin.comparisons.minfOf() for 4 arguments as it avoids allocating an array because of the varargs.

fun floatFromBits(bits: Int): Float

Returns the Float value corresponding to a given bit representation.

fun lerp(start: Float, stop: Float, fraction: Float): Float

Linearly interpolate between start and stop with fraction fraction between them.

fun lerp(start: Int, stop: Int, fraction: Float): Int

Linearly interpolate between start and stop with fraction fraction between them.

fun lerp(start: Long, stop: Long, fraction: Float): Long

Linearly interpolate between start and stop with fraction fraction between them.

inline fun normalizedAngleCos(normalizedDegrees: Float): Float

Fast, approximate sine function. Returns the sine of the angle normalizedDegrees expressed in normalized degrees. For instance, to compute the sine of 180 degrees, you should pass 0.5f (180.0f/360.0f). To compute the cosine of any angle in degrees, call the function this way:

val c = normalizedAngleCos(angleInDegrees * (1.0f / 360.0f))

If you are compute the sine and the cosine of an angle at the same time, you can reuse the normalized angle:

val normalizedAngle = angleInDegrees * (1.0f / 360.0f)
val s = normalizedAngleSin(normalizedAngle)
val c = normalizedAngleCos(normalizedAngle)

The maximum error of this function in the range 0..360 degrees (0..1 as passed to the function) is 1.63231e-3, or ~0.0935 degrees.

When normalizedDegrees is:

• Float.NaN, returns Float.NaN

• Float.POSITIVE_INFINITY, returns Float.NaN

• Float.NEGATIVE_INFINITY, returns Float.NaN

• 0f, 0.25f, 0.5f, 0.75f, or 1.0f (0, 90, 180, 360 degrees), the returned value is exact

inline fun normalizedAngleSin(normalizedDegrees: Float): Float

Fast, approximate sine function. Returns the sine of the angle normalizedDegrees expressed in normalized degrees. For instance, to compute the sine of 180 degrees, you should pass 0.5f (180.0f/360.0f). To compute the sine of any angle in degrees, call the function this way:

val s = normalizedAngleSin(angleInDegrees * (1.0f / 360.0f))

If you are compute the sine and the cosine of an angle at the same time, you can reuse the normalized angle:

val normalizedAngle = angleInDegrees * (1.0f / 360.0f)
val s = normalizedAngleSin(normalizedAngle)
val c = normalizedAngleCos(normalizedAngle)

The maximum error of this function in the range 0..360 degrees (0..1 as passed to the function) is 1.63197e-3, or ~0.0935 degrees.

When normalizedDegrees is:

• Float.NaN, returns Float.NaN

• Float.POSITIVE_INFINITY, returns Float.NaN

• Float.NEGATIVE_INFINITY, returns Float.NaN

• 0f, 0.25f, 0.5f, 0.75f, or 1.0f (0, 90, 180, 360 degrees), the returned value is exact

inline fun packFloats(val1: Float, val2: Float): Long

Packs two Float values into one Long value for use in inline classes.

inline fun packInts(val1: Int, val2: Int): Long

Packs two Int values into one Long value for use in inline classes.

inline fun unpackAbsFloat1(value: Long): Float

Unpacks the first absolute Float value in packFloats from its returned Long.

inline fun unpackAbsFloat2(value: Long): Float

Unpacks the second absolute Float value in packFloats from its returned Long.

inline fun unpackFloat1(value: Long): Float

Unpacks the first Float value in packFloats from its returned Long.

inline fun unpackFloat2(value: Long): Float

Unpacks the second Float value in packFloats from its returned Long.

inline fun unpackInt1(value: Long): Int

Unpacks the first Int value in packInts from its returned ULong.

inline fun unpackInt2(value: Long): Int

Unpacks the second Int value in packInts from its returned ULong.

inline fun <T : Any?> List<T>.fastAll(predicate: (T) -> Boolean): Boolean

Returns true if all elements match the given predicate.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastAny(predicate: (T) -> Boolean): Boolean

Returns true if at least one element matches the given predicate.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun Double.fastCoerceAtLeast(minimumValue: Double): Double

Ensures that this value is not less than the specified minimumValue.

inline fun Float.fastCoerceAtLeast(minimumValue: Float): Float

Ensures that this value is not less than the specified minimumValue.

inline fun Int.fastCoerceAtLeast(minimumValue: Int): Int

Ensures that this value is not less than the specified minimumValue.

inline fun Long.fastCoerceAtLeast(minimumValue: Long): Long

Ensures that this value is not less than the specified minimumValue.

inline fun Double.fastCoerceAtMost(maximumValue: Double): Double

Ensures that this value is not greater than the specified maximumValue.

inline fun Float.fastCoerceAtMost(maximumValue: Float): Float

Ensures that this value is not greater than the specified maximumValue.

inline fun Int.fastCoerceAtMost(maximumValue: Int): Int

Ensures that this value is not greater than the specified maximumValue.

inline fun Long.fastCoerceAtMost(maximumValue: Long): Long

Ensures that this value is not greater than the specified maximumValue.

inline fun Double.fastCoerceIn(minimumValue: Double, maximumValue: Double): Double

Returns this double value clamped in the inclusive range defined by minimumValue and maximumValue. Unlike Float.coerceIn, the range is not validated: the caller must ensure that minimumValue is less than maximumValue.

inline fun Float.fastCoerceIn(minimumValue: Float, maximumValue: Float): Float

Returns this float value clamped in the inclusive range defined by minimumValue and maximumValue. Unlike Float.coerceIn, the range is not validated: the caller must ensure that minimumValue is less than maximumValue.

inline fun Int.fastCoerceIn(minimumValue: Int, maximumValue: Int): Int

Returns this integer value clamped in the inclusive range defined by minimumValue and maximumValue. Unlike Int.coerceIn, the range is not validated: the caller must ensure that minimumValue is less than maximumValue.

inline fun Long.fastCoerceIn(minimumValue: Long, maximumValue: Long): Long

Returns this long value clamped in the inclusive range defined by minimumValue and maximumValue. Unlike Long.coerceIn, the range is not validated: the caller must ensure that minimumValue is less than maximumValue.

inline fun <T : Any?, K : Any?> List<T>.fastDistinctBy(selector: (T) -> K): List<T>

Returns a list containing only elements from the given collection having distinct keys returned by the given selector function.

The elements in the resulting list are in the same order as they were in the source collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastFilter(predicate: (T) -> Boolean): List<T>

Returns a list containing only elements matching the given predicate.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

fun <T : Any> List<T?>.fastFilterNotNull(): List<T>

Returns a list containing all elements that are not null

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastFilteredMap(
    predicate: (T) -> Boolean,
    transform: (T) -> R
): List<R>

Returns a list containing only elements matching the given predicate, applying the given transform function to each element.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastFirst(predicate: (T) -> Boolean): T

Returns the first value that predicate returns true for

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastFirstOrNull(predicate: (T) -> Boolean): T?

Returns the first value that predicate returns true for or null if nothing matches.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastFlatMap(transform: (T) -> Iterable<R>): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each element of original collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastFold(initial: R, operation: (acc, T) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.

Returns the specified initial value if the collection is empty.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastForEach(action: (T) -> Unit): Unit

Iterates through a List using the index and calls action for each item. This does not allocate an iterator like Iterable.forEach.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastForEachIndexed(action: (Int, T) -> Unit): Unit

Iterates through a List using the index and calls action for each item. This does not allocate an iterator like Iterable.forEachIndexed.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastForEachReversed(action: (T) -> Unit): Unit

Iterates through a List in reverse order using the index and calls action for each item. This does not allocate an iterator like Iterable.forEach.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun Float.fastIsFinite(): Boolean

Returns true if this float is a finite floating-point value; returns false otherwise (for NaN and infinity).

inline fun Double.fastIsFinite(): Boolean

Returns true if this double is a finite floating-point value; returns false otherwise (for NaN and infinity).

fun <T : Any?> List<T>.fastJoinToString(
    separator: CharSequence = ", ",
    prefix: CharSequence = "",
    postfix: CharSequence = "",
    limit: Int = -1,
    truncated: CharSequence = "...",
    transform: ((T) -> CharSequence)? = null
): String

Creates a string from all the elements separated using separator and using the given prefix and postfix if supplied.

If the collection could be huge, you can specify a non-negative value of limit, in which case only the first limit elements will be appended, followed by the truncated string (which defaults to "...").

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?> List<T>.fastLastOrNull(predicate: (T) -> Boolean): T?

Returns the last element matching the given predicate, or null if no such element was found.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastMap(transform: (T) -> R): List<R>

Returns a list containing the results of applying the given transform function to each element in the original collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastMapIndexed(transform: (index: Int, T) -> R): List<R>

Returns a list containing the results of applying the given transform function to each element in the original collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastMapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>

Returns a list containing the results of applying the given transform function to each element in the original collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastMapNotNull(transform: (T) -> R?): List<R>

Returns a list containing the results of applying the given transform function to each element in the original collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?, C : MutableCollection<R>> List<T>.fastMapTo(
    destination: C,
    transform: (T) -> R
): C

Applies the given transform function to each element of the original collection and appends the results to the given destination.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Comparable<R>> List<T>.fastMaxBy(selector: (T) -> R): T?

Returns the first element yielding the largest value of the given function or null if there are no elements.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Comparable<R>> List<T>.fastMaxOfOrDefault(
    defaultValue: R,
    selector: (T) -> R
): R

Returns the largest value among all values produced by selector function applied to each element in the collection or defaultValue if there are no elements.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Comparable<R>> List<T>.fastMaxOfOrNull(selector: (T) -> R): R?

Returns the largest value among all values produced by selector function applied to each element in the collection or null if there are no elements.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Comparable<R>> List<T>.fastMinByOrNull(selector: (T) -> R): T?

Returns the first element yielding the largest value of the given function or null if there are no elements.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <S : Any?, T : S> List<T>.fastReduce(operation: (acc, T) -> S): S

Accumulates value starting with the first element and applying operation from left to right to current accumulator value and each element.

Throws an exception if this collection is empty. If the collection can be empty in an expected way, please use reduceOrNull instead. It returns null when its receiver is empty.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

fun Float.fastRoundToInt(): Int

Returns the closest integer to the argument, tying rounding to positive infinity. Some values are treated differently:

• NaN becomes 0

• -Infinity or any value less than Integer.MIN_VALUE becomes Integer.MIN_VALUE.toFloat()

• +Infinity or any value greater than Integer.MAX_VALUE becomes Integer.MAX_VALUE.toFloat()

fun Double.fastRoundToInt(): Int

Returns the closest integer to the argument, tying rounding to positive infinity. Some values are treated differently:

• NaN becomes 0

• -Infinity or any value less than Integer.MIN_VALUE becomes Integer.MIN_VALUE.toFloat()

• +Infinity or any value greater than Integer.MAX_VALUE becomes Integer.MAX_VALUE.toFloat()

inline fun <T : Any?> List<T>.fastSumBy(selector: (T) -> Int): Int

Returns the sum of all values produced by selector function applied to each element in the list.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?, V : Any?> List<T>.fastZip(other: List<R>, transform: (a, b) -> V): List<V>

Returns a list of values built from the elements of this collection and the other collection with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.

inline fun <T : Any?, R : Any?> List<T>.fastZipWithNext(transform: (T, T) -> R): List<R>

Returns a list containing the results of applying the given transform function to each pair of two adjacent elements in this collection.

The returned list is empty if this collection contains less than two elements.

Do not use for collections that come from public APIs, since they may not support random access in an efficient way, and this method may actually be a lot slower. Only use for collections that are created by code we control and are known to support random access.