FieldProduct7

implicit abstract def structure1: Field[A]

implicit abstract def structure2: Field[B]

implicit abstract def structure3: Field[C]

implicit abstract def structure4: Field[D]

implicit abstract def structure5: Field[E]

implicit abstract def structure6: Field[F]

implicit abstract def structure7: Field[G]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def additive: AbGroup[(A, B, C, D, E, F, G)]

final def asInstanceOf[T0]: T0

def ceil(x0: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def clone(): AnyRef

def div(x0: (A, B, C, D, E, F, G), x1: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def euclid(a: (A, B, C, D, E, F, G), b: (A, B, C, D, E, F, G))(implicit eq: Eq[(A, B, C, D, E, F, G)]): (A, B, C, D, E, F, G)

def finalize(): Unit

def floor(x0: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def fromDouble(a: Double): (A, B, C, D, E, F, G)

This is implemented in terms of basic Field ops.

def fromInt(x0: Int): (A, B, C, D, E, F, G)

def gcd(x0: (A, B, C, D, E, F, G), x1: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isWhole(x: (A, B, C, D, E, F, G)): Boolean

def lcm(a: (A, B, C, D, E, F, G), b: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def minus(x: (A, B, C, D, E, F, G), y: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def mod(x0: (A, B, C, D, E, F, G), x1: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def multiplicative: AbGroup[(A, B, C, D, E, F, G)]

final def ne(arg0: AnyRef): Boolean

def negate(x0: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

final def notify(): Unit

final def notifyAll(): Unit

def one: (A, B, C, D, E, F, G)

def plus(x0: (A, B, C, D, E, F, G), x1: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def pow(x0: (A, B, C, D, E, F, G), x1: Int): (A, B, C, D, E, F, G)

def quot(x0: (A, B, C, D, E, F, G), x1: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def quotmod(a: (A, B, C, D, E, F, G), b: (A, B, C, D, E, F, G)): ((A, B, C, D, E, F, G), (A, B, C, D, E, F, G))

def reciprocal(x: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def round(x0: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

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

def times(x0: (A, B, C, D, E, F, G), x1: (A, B, C, D, E, F, G)): (A, B, C, D, E, F, G)

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zero: (A, B, C, D, E, F, G)