Complex

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(r: Double): Complex

Multiply a complex numbers times double.

def *(c: Complex): Complex

Multiply two complex numbers.

def +(r: Double): Complex

Add a complex number plus double.

def +(c: Complex): Complex

Add two complex numbers.

def -(r: Double): Complex

Subtract: a complex number minus double.

def -(c: Complex): Complex

Subtract two complex numbers.

def /(r: Double): Complex

Divide a complex numbers div double.

def /(c: Complex): Complex

Divide two complex numbers.

def <(that: Complex): Boolean

def <=(that: Complex): Boolean

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def >(that: Complex): Boolean

def >=(that: Complex): Boolean

def abs: Complex

Return the absolute value of this complex number.

def abs(x: Complex): Complex

def angle: Double

Return the angle of the complex number as a vector in the re-im plane.

final def asInstanceOf[T0]: T0

def bar: Complex

Return the complex conjugate: if z = (a + bi) then z.

def canEqual(arg0: Any): Boolean

def clone(): AnyRef

def compare(d: Complex): Int

Compare this complex number with that complex number d.

def compare(c: Complex, d: Complex): Int

Compare two complex numbers (negative for <, zero for ==, positive for >).

def compareTo(that: Complex): Int

def div(c: Complex, r: Double): Complex

def div(c: Complex, d: Complex): Complex

final def eq(arg0: AnyRef): Boolean

def equals(c: Any): Boolean

Override equals to determine whether this complex number equals complex c.

def equiv(x: Complex, y: Complex): Boolean

def finalize(): Unit

def fromDouble(x: Double): Complex

Create a complex number from a Double.

def fromFloat(x: Float): Complex

Create a complex number from a Float.

def fromInt(n: Int): Complex

Create a complex number from an Int.

def fromLong(n: Long): Complex

Create a complex number from a Long.

final def getClass(): java.lang.Class[_]

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

def gteq(x: Complex, y: Complex): Boolean

def hashCode(): Int

Must also override hashCode to be be compatible with equals.

val im: Double

the imaginary part

final def isInstanceOf[T0]: Boolean

def isRe: Boolean

Determine whether this complex number is real (no imaginary part).

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

def lteq(x: Complex, y: Complex): Boolean

def max(c: Complex): Complex

Return the maximum of this and that complex numbers.

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

def min(c: Complex): Complex

Return the minimum of this and that complex numbers.

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

def minus(c: Complex, r: Double): Complex

def minus(c: Complex, d: Complex): Complex

implicit def mkNumericOps(lhs: Complex): FractionalOps

implicit def mkOrderingOps(lhs: Complex): Ops

final def ne(arg0: AnyRef): Boolean

def negate(c: Complex): Complex

final def notify(): Unit

final def notifyAll(): Unit

def on[U](f: (U) ⇒ Complex): Ordering[U]

def one: Complex

def plus(c: Complex, r: Double): Complex

def plus(c: Complex, d: Complex): Complex

def polar: (Double, Double)

Return the complex number in polar coordinates (radius, angle).

def pow(c: Complex, r: Double): Complex

def productArity: Int

def productElement(arg0: Int): Any

def productIterator: Iterator[Any]

def productPrefix: String

def radius: Double

Return the radius of the complex number as a vector in the re-im plane.

val re: Double

the real part

def reverse: Ordering[Complex]

def signum(x: Complex): Int

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

def times(c: Complex, r: Double): Complex

def times(c: Complex, d: Complex): Complex

def toDouble: Double

def toDouble(c: Complex): Double

Convert that/this complex number to a Double.

def toFloat: Float

def toFloat(c: Complex): Float

Convert that/this complex number to a Float.

def toInt: Int

def toInt(c: Complex): Int

Convert that/this complex number to an Int.

def toLong: Long

def toLong(c: Complex): Long

Convert this complex number to a Long.

def toString(): String

Convert this complex number to a String.

def tryCompare(x: Complex, y: Complex): Some[Int]

def unary_-(): Complex

Compute the unary minus (-).

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zero: Complex

def ~^(r: Double): Complex

Raise a complex to the r-th power (a double) using polar coordinates.

def productElements: Iterator[Any]