FPFilterIsFractional

implicit abstract val ev: Fractional[A]

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: FPFilter[A]): FPFilter[A]

def additive: AbGroup[FPFilter[A]]

final def asInstanceOf[T0]: T0

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

def clone(): AnyRef

def compare(a: FPFilter[A], b: FPFilter[A]): Int

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eqv(a: FPFilter[A], b: FPFilter[A]): Boolean

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

def finalize(): Unit

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

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

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

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

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

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

This is implemented in terms of basic Field ops.

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

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

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

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

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

def fromType[B](a: B)(implicit arg0: ConvertableFrom[B]): FPFilter[A]

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

final def getClass(): Class[_]

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

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isNegative(x: FPFilter[A]): Boolean

def isNonzero(x: FPFilter[A]): Boolean

def isPositive(x: FPFilter[A]): Boolean

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

def isZero(x: FPFilter[A]): Boolean

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

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

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

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

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

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

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

def multiplicative: AbGroup[FPFilter[A]]

final def ne(arg0: AnyRef): Boolean

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

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

final def notify(): Unit

final def notifyAll(): Unit

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

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

def one: FPFilter[A]

def order: Fractional[A]

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

def pow(a: FPFilter[A], k: Int): FPFilter[A]

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

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

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

def reverse: Order[FPFilter[A]]

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

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

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

def sqrt(a: FPFilter[A]): FPFilter[A]

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

def times(a: FPFilter[A], b: FPFilter[A]): FPFilter[A]

def toBigDecimal(a: FPFilter[A]): BigDecimal

def toBigInt(a: FPFilter[A]): BigInt

def toByte(a: FPFilter[A]): Byte

def toDouble(a: FPFilter[A]): Double

def toFloat(a: FPFilter[A]): Float

def toInt(a: FPFilter[A]): Int

def toLong(a: FPFilter[A]): Long

def toNumber(a: FPFilter[A]): Number

def toRational(a: FPFilter[A]): Rational

def toShort(a: FPFilter[A]): Short

def toString(a: FPFilter[A]): String

def toString(): String

def toType[B](a: FPFilter[A])(implicit arg0: ConvertableTo[B]): Nothing

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zero: FPFilter[A]