ComplexIsNumeric

Instance Constructors

new ComplexIsNumeric()(implicit algebra: Fractional[A], trig: Trig[A], order: IsReal[A])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
def abs(a: Complex[A]): Complex[A]

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
ComplexIsSigned → Signed
def acos(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def additive: AbGroup[Complex[A]]

Definition Classes
AdditiveAbGroup → AdditiveCMonoid → AdditiveCSemigroup → AdditiveGroup → AdditiveMonoid → AdditiveSemigroup
implicit val algebra: Fractional[A]

Definition Classes
ComplexIsNumeric → ComplexIsSigned → ConvertableToComplex → ConvertableFromComplex → ComplexIsNRoot → ComplexIsTrig → ComplexIsField → ComplexIsRing
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asin(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def atan(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def atan2(y: Complex[A], x: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def ceil(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsNumeric → IsReal
def clone(): AnyRef

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

Definition Classes
ComplexIsNumeric → Order
def cos(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def cosh(x: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def div(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsField → MultiplicativeGroup
def e: Complex[A]

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

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

Definition Classes
AnyRef → Any
def eqv(x: Complex[A], y: Complex[A]): Boolean

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

Definition Classes
ComplexIsNumeric → Order → ComplexEq → Eq
final def euclid(a: Complex[A], b: Complex[A])(implicit eq: Eq[Complex[A]]): Complex[A]

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

Definition Classes
ComplexIsTrig → Trig
def expm1(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def finalize(): Unit

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

Definition Classes
ComplexIsNumeric → IsReal
def fpow(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsNRoot → NRoot
def fromBigDecimal(a: BigDecimal): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromBigInt(a: BigInt): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromByte(a: Byte): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromDouble(n: Double): Complex[A]

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
ComplexIsNumeric → ConvertableToComplex → ConvertableTo → ComplexIsField → Field
def fromFloat(a: Float): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromInt(n: Int): Complex[A]

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
ComplexIsNumeric → ConvertableToComplex → ConvertableTo → ComplexIsRing → Ring
def fromLong(a: Long): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromRational(a: Rational): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromShort(a: Short): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def fromType[B](b: B)(implicit arg0: ConvertableFrom[B]): Complex[A]

Definition Classes
ConvertableToComplex → ConvertableTo
def gcd(a: Complex[A], b: Complex[A]): Complex[A]

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

Definition Classes
AnyRef → Any
def gt(x: Complex[A], y: Complex[A]): Boolean

Definition Classes
Order
def gteqv(x: Complex[A], y: Complex[A]): Boolean

Definition Classes
Order
def hashCode(): Int

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

Definition Classes
Any
def isWhole(a: Complex[A]): Boolean

Definition Classes
ComplexIsNumeric → IsReal
def isZero(a: Complex[A]): Boolean

Definition Classes
Signed
def lcm(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
EuclideanRing
def log(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def log1p(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def lt(x: Complex[A], y: Complex[A]): Boolean

Definition Classes
Order
def lteqv(x: Complex[A], y: Complex[A]): Boolean

Definition Classes
Order
def max(x: Complex[A], y: Complex[A]): Complex[A]

Definition Classes
Order
def min(x: Complex[A], y: Complex[A]): Complex[A]

Definition Classes
Order
def minus(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsRing → AdditiveGroup
def mod(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsField → EuclideanRing
def multiplicative: AbGroup[Complex[A]]

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

Definition Classes
AnyRef
def negate(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsRing → AdditiveGroup
def neqv(x: Complex[A], y: Complex[A]): Boolean

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

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

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def nroot(a: Complex[A], n: Int): Complex[A]

Definition Classes
ComplexIsNumeric → ComplexIsNRoot → NRoot
def nroot: NRoot[A]

Definition Classes
ComplexIsNumeric → ComplexIsSigned → ComplexIsNRoot → ComplexIsTrig
def on[B](f: (B) ⇒ Complex[A]): 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 → Eq
def one: Complex[A]

Definition Classes
ComplexIsRing → MultiplicativeMonoid
implicit val order: IsReal[A]

Definition Classes
ComplexIsNumeric → ComplexIsSigned → ComplexIsNRoot → ComplexIsTrig → ComplexIsRing
def pi: Complex[A]

Definition Classes
ComplexIsTrig → Trig
def plus(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsRing → AdditiveSemigroup
def pow(a: Complex[A], n: Int): Complex[A]

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
Rig → Semiring
def quot(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsField → EuclideanRing
def quotmod(a: Complex[A], b: Complex[A]): (Complex[A], Complex[A])

Definition Classes
ComplexIsField → EuclideanRing
def reciprocal(x: Complex[A]): Complex[A]

Definition Classes
MultiplicativeGroup
def reverse: Order[Complex[A]]

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

Definition Classes
Order
def round(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsNumeric → IsReal
def sign(a: Complex[A]): 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: Complex[A]): 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
ComplexIsSigned → Signed
def sin(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def sinh(x: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def sqrt(a: Complex[A]): Complex[A]

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

Definition Classes
AnyRef
def tan(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def tanh(x: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def times(a: Complex[A], b: Complex[A]): Complex[A]

Definition Classes
ComplexIsRing → MultiplicativeSemigroup
def toBigDecimal(a: Complex[A]): BigDecimal

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toBigInt(a: Complex[A]): BigInt

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toByte(a: Complex[A]): Byte

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toDegrees(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def toDouble(a: Complex[A]): Double

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toFloat(a: Complex[A]): Float

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toInt(a: Complex[A]): Int

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toLong(a: Complex[A]): Long

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toNumber(a: Complex[A]): Number

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toRadians(a: Complex[A]): Complex[A]

Definition Classes
ComplexIsTrig → Trig
def toRational(a: Complex[A]): Rational

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toShort(a: Complex[A]): Short

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toString(a: Complex[A]): String

Definition Classes
ConvertableFromComplex → ConvertableFrom
def toString(): String

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

Definition Classes
ConvertableFromComplex → ConvertableFrom
implicit val trig: Trig[A]

Definition Classes
ComplexIsNumeric → ComplexIsNRoot → ComplexIsTrig
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: Complex[A]

Definition Classes
ComplexIsRing → AdditiveMonoid

class ComplexIsNumeric[A] extends ComplexEq[A] with ComplexIsField[A] with Numeric[Complex[A]] with ComplexIsTrig[A] with ComplexIsNRoot[A] with ConvertableFromComplex[A] with ConvertableToComplex[A] with Order[Complex[A]] with ComplexIsSigned[A] with Serializable

Instance Constructors

new ComplexIsNumeric()(implicit algebra: Fractional[A], trig: Trig[A], order: IsReal[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def abs(a: Complex[A]): Complex[A]

def acos(a: Complex[A]): Complex[A]

def additive: AbGroup[Complex[A]]

implicit val algebra: Fractional[A]

final def asInstanceOf[T0]: T0

def asin(a: Complex[A]): Complex[A]

def atan(a: Complex[A]): Complex[A]

def atan2(y: Complex[A], x: Complex[A]): Complex[A]

def ceil(a: Complex[A]): Complex[A]

def clone(): AnyRef

def compare(x: Complex[A], y: Complex[A]): Int

def cos(a: Complex[A]): Complex[A]

def cosh(x: Complex[A]): Complex[A]

def div(a: Complex[A], b: Complex[A]): Complex[A]

def e: Complex[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eqv(x: Complex[A], y: Complex[A]): Boolean

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

def exp(a: Complex[A]): Complex[A]

def expm1(a: Complex[A]): Complex[A]

def finalize(): Unit

def floor(a: Complex[A]): Complex[A]

def fpow(a: Complex[A], b: Complex[A]): Complex[A]

def fromBigDecimal(a: BigDecimal): Complex[A]

def fromBigInt(a: BigInt): Complex[A]

def fromByte(a: Byte): Complex[A]

def fromDouble(n: Double): Complex[A]

def fromFloat(a: Float): Complex[A]

def fromInt(n: Int): Complex[A]

def fromLong(a: Long): Complex[A]

def fromRational(a: Rational): Complex[A]

def fromShort(a: Short): Complex[A]

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

def gcd(a: Complex[A], b: Complex[A]): Complex[A]

final def getClass(): Class[_]

def gt(x: Complex[A], y: Complex[A]): Boolean

def gteqv(x: Complex[A], y: Complex[A]): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isWhole(a: Complex[A]): Boolean

def isZero(a: Complex[A]): Boolean

def lcm(a: Complex[A], b: Complex[A]): Complex[A]

def log(a: Complex[A]): Complex[A]

def log1p(a: Complex[A]): Complex[A]

def lt(x: Complex[A], y: Complex[A]): Boolean

def lteqv(x: Complex[A], y: Complex[A]): Boolean

def max(x: Complex[A], y: Complex[A]): Complex[A]

def min(x: Complex[A], y: Complex[A]): Complex[A]

def minus(a: Complex[A], b: Complex[A]): Complex[A]

def mod(a: Complex[A], b: Complex[A]): Complex[A]

def multiplicative: AbGroup[Complex[A]]

final def ne(arg0: AnyRef): Boolean

def negate(a: Complex[A]): Complex[A]

def neqv(x: Complex[A], y: Complex[A]): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def nroot(a: Complex[A], n: Int): Complex[A]

def nroot: NRoot[A]

def on[B](f: (B) ⇒ Complex[A]): Order[B]

def one: Complex[A]

implicit val order: IsReal[A]

def pi: Complex[A]

def plus(a: Complex[A], b: Complex[A]): Complex[A]

def pow(a: Complex[A], n: Int): Complex[A]

def quot(a: Complex[A], b: Complex[A]): Complex[A]

def quotmod(a: Complex[A], b: Complex[A]): (Complex[A], Complex[A])

def reciprocal(x: Complex[A]): Complex[A]

def reverse: Order[Complex[A]]

def round(a: Complex[A]): Complex[A]

def sign(a: Complex[A]): Sign

def signum(a: Complex[A]): Int