NumberIsFractional

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def abs(a: Number): Number

Definition Classes
NumberIsSigned → Signed
def additive: AbGroup[Number]

Definition Classes
AdditiveAbGroup → AdditiveGroup → AdditiveMonoid → AdditiveSemigroup
final def asInstanceOf[T0]: T0

Definition Classes
Any
def ceil(a: Number): Number

Definition Classes
NumberIsField → Field
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def compare(x: Number, y: Number): Int

Definition Classes
NumberOrder → Order
def div(a: Number, b: Number): Number

Definition Classes
NumberIsField → MultiplicativeGroup
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def eqv(x: Number, y: Number): Boolean

Definition Classes
NumberOrder → Order → Eq
final def euclid(a: Number, b: Number)(implicit eq: Eq[Number]): Number

Attributes
protected[this]
Definition Classes
EuclideanRing
Annotations
@tailrec()
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def floor(a: Number): Number

Definition Classes
NumberIsField → Field
def fpow(a: Number, b: Number): Number

Definition Classes
NumberIsNRoot → NRoot
def fromBigDecimal(a: BigDecimal): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromBigInt(a: BigInt): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromByte(a: Byte): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromDouble(n: Double): Number

This is implemented in terms of basic Field ops.
This is implemented in terms of basic Field ops. However, this is probably significantly less efficient than can be done with a specific type. So, it is recommended that this method is overriden.
This is possible because a Double is a rational number.

Definition Classes
NumberIsFractional → ConvertableToNumber → ConvertableTo → Field
def fromFloat(a: Float): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromInt(n: Int): Number

Definition Classes
NumberIsFractional → ConvertableToNumber → NumberIsRing → ConvertableTo → Ring
def fromLong(a: Long): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromRational(a: Rational): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromShort(a: Short): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def fromType[B](b: B)(implicit arg0: ConvertableFrom[B]): Number

Definition Classes
ConvertableToNumber → ConvertableTo
def gcd(a: Number, b: Number): Number

Definition Classes
NumberIsEuclideanRing → EuclideanRing
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def gt(x: Number, y: Number): Boolean

Definition Classes
NumberOrder → Order
def gteqv(x: Number, y: Number): Boolean

Definition Classes
NumberOrder → Order
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isNegative(x: Number): Boolean

Definition Classes
Integral
def isNonzero(x: Number): Boolean

Definition Classes
Integral
def isPositive(x: Number): Boolean

Definition Classes
Integral
def isWhole(a: Number): Boolean

Definition Classes
NumberIsField → Field
def isZero(x: Number): Boolean

Definition Classes
Integral
def lcm(a: Number, b: Number): Number

Definition Classes
EuclideanRing
def lt(x: Number, y: Number): Boolean

Definition Classes
NumberOrder → Order
def lteqv(x: Number, y: Number): Boolean

Definition Classes
NumberOrder → Order
def max(x: Number, y: Number): Number

Definition Classes
Order
def min(x: Number, y: Number): Number

Definition Classes
Order
def minus(a: Number, b: Number): Number

Definition Classes
NumberIsRing → AdditiveGroup
def mod(a: Number, b: Number): Number

Definition Classes
NumberIsEuclideanRing → EuclideanRing
def multiplicative: AbGroup[Number]

Definition Classes
MultiplicativeAbGroup → MultiplicativeGroup → MultiplicativeMonoid → MultiplicativeSemigroup
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def negate(a: Number): Number

Definition Classes
NumberIsRing → AdditiveGroup
def neqv(x: Number, y: Number): Boolean

Definition Classes
NumberOrder → Eq
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def nroot(a: Number, k: Int): Number

Definition Classes
NumberIsNRoot → NRoot
def on[B](f: (B) ⇒ Number): Order[B]

Definition Classes
Order → Eq
val one: Number

Definition Classes
NumberIsRing → MultiplicativeMonoid
def plus(a: Number, b: Number): Number

Definition Classes
NumberIsRing → AdditiveSemigroup
def pow(a: Number, b: Int): Number

Definition Classes
NumberIsRing → Rig → Semiring
def quot(a: Number, b: Number): Number

Definition Classes
NumberIsEuclideanRing → EuclideanRing
def quotmod(a: Number, b: Number): (Number, Number)

Definition Classes
NumberIsEuclideanRing → EuclideanRing
def reciprocal(x: Number): Number

Definition Classes
MultiplicativeGroup
def reverse: Order[Number]

Definition Classes
Order
def round(a: Number): Number

Definition Classes
NumberIsField → Field
def sign(a: Number): Sign

Definition Classes
Signed
def signum(a: Number): Int

Definition Classes
NumberIsSigned → Signed
def sqrt(a: Number): Number

Definition Classes
NumberIsNRoot → NRoot
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def times(a: Number, b: Number): Number

Definition Classes
NumberIsRing → MultiplicativeSemigroup
def toBigDecimal(a: Number): BigDecimal

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toBigInt(a: Number): BigInt

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toByte(a: Number): Byte

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toDouble(a: Number): Double

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toFloat(a: Number): Float

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toInt(a: Number): Int

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toLong(a: Number): Long

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toNumber(a: Number): Number

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toRational(a: Number): Rational

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toShort(a: Number): Short

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toString(a: Number): String

Definition Classes
ConvertableFromNumber → ConvertableFrom
def toString(): String

Definition Classes
AnyRef → Any
def toType[B](a: Number)(implicit arg0: ConvertableTo[B]): B

Definition Classes
ConvertableFromNumber → ConvertableFrom
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
val zero: Number

Definition Classes
NumberIsRing → AdditiveMonoid

trait NumberIsFractional extends Fractional[Number] with NumberIsField with NumberIsNRoot with ConvertableFromNumber with ConvertableToNumber with NumberOrder with NumberIsSigned

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def abs(a: Number): Number

def additive: AbGroup[Number]

final def asInstanceOf[T0]: T0

def ceil(a: Number): Number

def clone(): AnyRef

def compare(x: Number, y: Number): Int

def div(a: Number, b: Number): Number

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eqv(x: Number, y: Number): Boolean

final def euclid(a: Number, b: Number)(implicit eq: Eq[Number]): Number

def finalize(): Unit

def floor(a: Number): Number

def fpow(a: Number, b: Number): Number

def fromBigDecimal(a: BigDecimal): Number

def fromBigInt(a: BigInt): Number

def fromByte(a: Byte): Number

def fromDouble(n: Double): Number

def fromFloat(a: Float): Number

def fromInt(n: Int): Number

def fromLong(a: Long): Number

def fromRational(a: Rational): Number

def fromShort(a: Short): Number

def fromType[B](b: B)(implicit arg0: ConvertableFrom[B]): Number

def gcd(a: Number, b: Number): Number

final def getClass(): Class[_]

def gt(x: Number, y: Number): Boolean

def gteqv(x: Number, y: Number): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isNegative(x: Number): Boolean

def isNonzero(x: Number): Boolean

def isPositive(x: Number): Boolean

def isWhole(a: Number): Boolean

def isZero(x: Number): Boolean

def lcm(a: Number, b: Number): Number

def lt(x: Number, y: Number): Boolean

def lteqv(x: Number, y: Number): Boolean

def max(x: Number, y: Number): Number

def min(x: Number, y: Number): Number

def minus(a: Number, b: Number): Number

def mod(a: Number, b: Number): Number

def multiplicative: AbGroup[Number]

final def ne(arg0: AnyRef): Boolean

def negate(a: Number): Number

def neqv(x: Number, y: Number): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def nroot(a: Number, k: Int): Number

def on[B](f: (B) ⇒ Number): Order[B]

val one: Number

def plus(a: Number, b: Number): Number

def pow(a: Number, b: Int): Number

def quot(a: Number, b: Number): Number

def quotmod(a: Number, b: Number): (Number, Number)

def reciprocal(x: Number): Number

def reverse: Order[Number]

def round(a: Number): Number

def sign(a: Number): Sign

def signum(a: Number): Int

def sqrt(a: Number): Number

final def synchronized[T0](arg0: ⇒ T0): T0

def times(a: Number, b: Number): Number

def toBigDecimal(a: Number): BigDecimal

def toBigInt(a: Number): BigInt

def toByte(a: Number): Byte

def toDouble(a: Number): Double

def toFloat(a: Number): Float

def toInt(a: Number): Int

def toLong(a: Number): Long

def toNumber(a: Number): Number

def toRational(a: Number): Rational