kty/nz.adjmunro.kty/Floaty

Floaty

interface Floaty<W : Floaty<W>> : Numbery<W, Float> , RoundCastable

Properties

addByNumber

open override val addByNumber: MergeABtoA<Float, Number>

asBigDecimal

open override val asBigDecimal: BigDecimal

asBigInteger

open override val asBigInteger: BigInteger

asDouble

open override val asDouble: Double

asFloat

open override val asFloat: Float

asInt

open override val asInt: Int

asLong

open override val asLong: Long

compareByNumber

open override val compareByNumber: DifferenceAB<Float, Number>

compareToSelf

open override val compareToSelf: Difference<Float>

divide

open override val divide: Merge<Float>

divideByNumber

open override val divideByNumber: MergeABtoA<Float, Number>

minus

open override val minus: Merge<Float>

multiplyByNumber

open override val multiplyByNumber: MergeABtoA<Float, Number>

plus

open override val plus: Merge<Float>

reconstruct

abstract val reconstruct: (Float) -> W

Function reference to the constructor of the value class.

remainder

open override val remainder: Merge<Float>

remainderByNumber

open override val remainderByNumber: MergeABtoA<Float, Number>

roundToInt

open override val roundToInt: () -> Int

roundToLong

open override val roundToLong: () -> Long

spec

open override val spec: (Number) -> Float

subtractByNumber

open override val subtractByNumber: MergeABtoA<Float, Number>

times

open override val times: Merge<Float>

value

abstract override val value: Float

The backing field that is wrapped in the value class.

Functions

compareTo

@JvmName(name = "compareToActualWrapper")

open operator override fun compareTo(other: W): Int

@JvmName(name = "compareToBackingField")

open operator fun compareTo(other: Float): Int

open operator fun compareTo(num: Number): Int

div

open operator fun div(other: W): W

open operator fun div(num: Number): W

merge

open fun merge(other: W, transform: Merge<Float>): W

Merges this Boxed instance with another Boxed instance to create a new instance of the same type.

open fun merge(other: Number, transform: MergeABtoA<Float, Number>): W

minus

open operator fun minus(num: Number): W

open operator fun minus(other: W): W

plus

open operator fun plus(other: W): W

open operator fun plus(num: Number): W

rem

open operator fun rem(num: Number): W

open operator fun rem(other: W): W

times

open operator fun times(other: W): W

open operator fun times(num: Number): W