kty/nz.adjmunro.kty/Doubly

Doubly

interface Doubly<W : Doubly<W>> : Numbery<W, Double> , RoundCastable

Inheritors

Angle

Properties

addByNumber

open override val addByNumber: MergeABtoA<Double, 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<Double, Number>

compareToSelf

open override val compareToSelf: Difference<Double>

divide

open override val divide: Merge<Double>

divideByNumber

open override val divideByNumber: MergeABtoA<Double, Number>

minus

open override val minus: Merge<Double>

multiplyByNumber

open override val multiplyByNumber: MergeABtoA<Double, Number>

plus

open override val plus: Merge<Double>

reconstruct

abstract val reconstruct: (Double) -> W

Function reference to the constructor of the value class.

remainder

open override val remainder: Merge<Double>

remainderByNumber

open override val remainderByNumber: MergeABtoA<Double, Number>

roundToInt

open override val roundToInt: () -> Int

roundToLong

open override val roundToLong: () -> Long

spec

open override val spec: (Number) -> Double

subtractByNumber

open override val subtractByNumber: MergeABtoA<Double, Number>

times

open override val times: Merge<Double>

value

abstract override val value: Double

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: Double): 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<Double>): 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<Double, 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