FloatAlgebra

Instance Constructors

new FloatAlgebra()

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: Float): Float

An idempotent function that ensures an object has a non-negative sign.
An idempotent function that ensures an object has a non-negative sign.

Definition Classes
FloatIsSigned → Signed
def acos(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def additive: AbGroup[Float]

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

Definition Classes
Any
def asin(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def atan(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def atan2(y: Float, x: Float): Float

Definition Classes
FloatIsTrig → Trig
def ceil(a: Float): Float

Rounds a the nearest integer that is greater than or equal to a.
Rounds a the nearest integer that is greater than or equal to a.

Definition Classes
FloatIsReal → IsReal
def clone(): AnyRef

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

Definition Classes
FloatOrder → Order
def cos(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def cosh(x: Float): Float

Definition Classes
FloatIsTrig → Trig
def div(a: Float, b: Float): Float

Definition Classes
FloatIsField → MultiplicativeGroup
def e: Float

Definition Classes
FloatIsTrig → Trig
final def eq(arg0: AnyRef): Boolean

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

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

Returns true if x and y are equivalent, false otherwise.
Returns true if x and y are equivalent, false otherwise.

Definition Classes
FloatOrder → Order → PartialOrder → Eq
final def euclid(a: Float, b: Float)(implicit eq: Eq[Float]): Float

Attributes
protected[this]
Definition Classes
EuclideanRing
Annotations
@tailrec()
def exp(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def expm1(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def finalize(): Unit

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

Rounds a the nearest integer that is less than or equal to a.
Rounds a the nearest integer that is less than or equal to a.

Definition Classes
FloatIsReal → IsReal
def fpow(a: Float, b: Float): Float

Definition Classes
FloatIsNRoot → NRoot
def fromDouble(n: Double): Float

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
FloatIsField → Field
def fromInt(n: Int): Float

Defined to be equivalent to additive.sumn(one, n).
Defined to be equivalent to additive.sumn(one, n). That is, n repeated summations of this ring's one, or -one if n is negative.

Definition Classes
FloatIsField → Ring
final def gcd(a: Float, b: Float): Float

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

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

Definition Classes
FloatOrder → Order → PartialOrder
def gteqv(x: Float, y: Float): Boolean

Definition Classes
FloatOrder → Order → PartialOrder
def hashCode(): Int

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

Definition Classes
Any
def isOne(a: Float)(implicit ev: Eq[Float]): Boolean

Definition Classes
MultiplicativeMonoid
def isSignNegative(a: Float): Boolean

Definition Classes
Signed
def isSignNonNegative(a: Float): Boolean

Definition Classes
Signed
def isSignNonPositive(a: Float): Boolean

Definition Classes
Signed
def isSignNonZero(a: Float): Boolean

Definition Classes
Signed
def isSignPositive(a: Float): Boolean

Definition Classes
Signed
def isSignZero(a: Float): Boolean

Definition Classes
Signed
def isWhole(a: Float): Boolean

Returns true iff a is a an integer.
Returns true iff a is a an integer.

Definition Classes
FloatIsReal → IsReal
def isZero(a: Float)(implicit ev: Eq[Float]): Boolean

Tests if a is zero.
Tests if a is zero.

Definition Classes
AdditiveMonoid
def lcm(a: Float, b: Float): Float

Definition Classes
EuclideanRing
def log(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def log1p(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def lt(x: Float, y: Float): Boolean

Definition Classes
FloatOrder → Order → PartialOrder
def lteqv(x: Float, y: Float): Boolean

Definition Classes
FloatOrder → Order → PartialOrder
def max(x: Float, y: Float): Float

Definition Classes
FloatOrder → Order
def min(x: Float, y: Float): Float

Definition Classes
FloatOrder → Order
def minus(a: Float, b: Float): Float

Definition Classes
FloatIsField → AdditiveGroup
def mod(a: Float, b: Float): Float

Definition Classes
FloatIsField → EuclideanRing
def multiplicative: AbGroup[Float]

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

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

Definition Classes
FloatIsField → AdditiveGroup
def neqv(x: Float, y: Float): Boolean

Returns false if x and y are equivalent, true otherwise.
Returns false if x and y are equivalent, true otherwise.

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

Definition Classes
AnyRef
final def notifyAll(): Unit

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

Definition Classes
FloatIsNRoot → NRoot
def on[B](f: (B) ⇒ Float): Order[B]

Defines an order on B by mapping B to A using f and using As order to order B.
Defines an order on B by mapping B to A using f and using As order to order B.

Definition Classes
Order → PartialOrder → Eq
def one: Float

Definition Classes
FloatIsField → MultiplicativeMonoid
def partialCompare(x: Float, y: Float): Double

Result of comparing x with y.
Result of comparing x with y. Returns NaN if operands are not comparable. If operands are comparable, returns a Double whose sign is: - negative iff x < y - zero iff x === y - positive iff x > y

Definition Classes
Order → PartialOrder
def pi: Float

Definition Classes
FloatIsTrig → Trig
def plus(a: Float, b: Float): Float

Definition Classes
FloatIsField → AdditiveSemigroup
def pmax(x: Float, y: Float): Option[Float]

Returns Some(x) if x >= y, Some(y) if x < y, otherwise None.
Returns Some(x) if x >= y, Some(y) if x < y, otherwise None.

Definition Classes
PartialOrder
def pmin(x: Float, y: Float): Option[Float]

Returns Some(x) if x <= y, Some(y) if x > y, otherwise None.
Returns Some(x) if x <= y, Some(y) if x > y, otherwise None.

Definition Classes
PartialOrder
def pow(a: Float, b: Int): Float

This is similar to Semigroup#pow, except that a pow 0 is defined to be the multiplicative identity.
This is similar to Semigroup#pow, except that a pow 0 is defined to be the multiplicative identity.

Definition Classes
FloatIsField → Rig → Semiring
def prod(as: TraversableOnce[Float]): Float

Given a sequence of as, sum them using the monoid and return the total.
Given a sequence of as, sum them using the monoid and return the total.

Definition Classes
MultiplicativeMonoid
def prodOption(as: TraversableOnce[Float]): Option[Float]

Given a sequence of as, sum them using the semigroup and return the total.
Given a sequence of as, sum them using the semigroup and return the total.
If the sequence is empty, returns None. Otherwise, returns Some(total).

Definition Classes
MultiplicativeSemigroup
def prodn(a: Float, n: Int): Float

Return a multiplicated with itself n times.
Return a multiplicated with itself n times.

Definition Classes
MultiplicativeGroup → MultiplicativeMonoid → MultiplicativeSemigroup
def prodnAboveOne(a: Float, n: Int): Float

Attributes
protected
Definition Classes
MultiplicativeSemigroup
def quot(a: Float, b: Float): Float

Definition Classes
FloatIsField → EuclideanRing
def quotmod(a: Float, b: Float): (Float, Float)

Definition Classes
EuclideanRing
def reciprocal(x: Float): Float

Definition Classes
MultiplicativeGroup
def reverse: Order[Float]

Defines an ordering on A where all arrows switch direction.
Defines an ordering on A where all arrows switch direction.

Definition Classes
Order → PartialOrder
def round(a: Float): Float

Rounds a to the nearest integer.
Rounds a to the nearest integer.

Definition Classes
FloatIsReal → IsReal
def sign(a: Float): Sign

Returns Zero if a is 0, Positive if a is positive, and Negative is a is negative.
Returns Zero if a is 0, Positive if a is positive, and Negative is a is negative.

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

Returns 0 if a is 0, > 0 if a is positive, and < 0 is a is negative.
Returns 0 if a is 0, > 0 if a is positive, and < 0 is a is negative.

Definition Classes
FloatIsSigned → Signed
def sin(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def sinh(x: Float): Float

Definition Classes
FloatIsTrig → Trig
def sqrt(a: Float): Float

Definition Classes
FloatIsNRoot → NRoot
def sum(as: TraversableOnce[Float]): Float

Given a sequence of as, sum them using the monoid and return the total.
Given a sequence of as, sum them using the monoid and return the total.

Definition Classes
AdditiveMonoid
def sumOption(as: TraversableOnce[Float]): Option[Float]

Given a sequence of as, sum them using the semigroup and return the total.
Given a sequence of as, sum them using the semigroup and return the total.
If the sequence is empty, returns None. Otherwise, returns Some(total).

Definition Classes
AdditiveSemigroup
def sumn(a: Float, n: Int): Float

Return a added with itself n times.
Return a added with itself n times.

Definition Classes
AdditiveGroup → AdditiveMonoid → AdditiveSemigroup
def sumnAboveOne(a: Float, n: Int): Float

Attributes
protected
Definition Classes
AdditiveSemigroup
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tan(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def tanh(x: Float): Float

Definition Classes
FloatIsTrig → Trig
def times(a: Float, b: Float): Float

Definition Classes
FloatIsField → MultiplicativeSemigroup
def toAlgebraic(a: Float): Algebraic

Definition Classes
IsRational → IsAlgebraic
def toDegrees(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def toDouble(x: Float): Double

Approximates a as a Double.
Approximates a as a Double.

Definition Classes
FloatIsReal → IsReal
def toRadians(a: Float): Float

Definition Classes
FloatIsTrig → Trig
def toRational(a: Float): Rational

Definition Classes
FloatIsReal → IsRational
def toReal(a: Float): Real

Definition Classes
IsAlgebraic → IsReal
def toString(): String

Definition Classes
AnyRef → Any
def tryCompare(x: Float, y: Float): Option[Int]

Result of comparing x with y.
Result of comparing x with y. Returns None if operands are not comparable. If operands are comparable, returns Some[Int] where the Int sign is: - negative iff x < y - zero iff x == y - positive iff x > y

Definition Classes
PartialOrder
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( ... )
def zero: Float

Definition Classes
FloatIsField → AdditiveMonoid

class FloatAlgebra extends FloatIsField with FloatIsNRoot with FloatIsTrig with FloatIsReal with Serializable

Instance Constructors

new FloatAlgebra()

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: Float): Float

def acos(a: Float): Float

def additive: AbGroup[Float]

final def asInstanceOf[T0]: T0

def asin(a: Float): Float

def atan(a: Float): Float

def atan2(y: Float, x: Float): Float

def ceil(a: Float): Float

def clone(): AnyRef

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

def cos(a: Float): Float

def cosh(x: Float): Float

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

def e: Float

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

def exp(a: Float): Float

def expm1(a: Float): Float

def finalize(): Unit

def floor(a: Float): Float

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

def fromDouble(n: Double): Float

def fromInt(n: Int): Float

final def gcd(a: Float, b: Float): Float

final def getClass(): Class[_]

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

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isOne(a: Float)(implicit ev: Eq[Float]): Boolean

def isSignNegative(a: Float): Boolean

def isSignNonNegative(a: Float): Boolean

def isSignNonPositive(a: Float): Boolean

def isSignNonZero(a: Float): Boolean

def isSignPositive(a: Float): Boolean

def isSignZero(a: Float): Boolean

def isWhole(a: Float): Boolean

def isZero(a: Float)(implicit ev: Eq[Float]): Boolean

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

def log(a: Float): Float

def log1p(a: Float): Float

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

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

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

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

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

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

def multiplicative: AbGroup[Float]

final def ne(arg0: AnyRef): Boolean

def negate(a: Float): Float

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

final def notify(): Unit

final def notifyAll(): Unit

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

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

def one: Float

def partialCompare(x: Float, y: Float): Double

def pi: Float

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

def pmax(x: Float, y: Float): Option[Float]

def pmin(x: Float, y: Float): Option[Float]

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

def prod(as: TraversableOnce[Float]): Float

def prodOption(as: TraversableOnce[Float]): Option[Float]

def prodn(a: Float, n: Int): Float

def prodnAboveOne(a: Float, n: Int): Float

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

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