diff --git a/algebird-core/src/main/scala/com/twitter/algebird/AdaptiveVector.scala b/algebird-core/src/main/scala/com/twitter/algebird/AdaptiveVector.scala index 08db1226d..8ccf398d2 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/AdaptiveVector.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/AdaptiveVector.scala @@ -18,36 +18,36 @@ package com.twitter.algebird import scala.annotation.tailrec -/** Some functions to create or convert AdaptiveVectors +/** + * Some functions to create or convert AdaptiveVectors */ object AdaptiveVector { - /** When density >= this value * size, we switch to dense vectors + /** + * When density >= this value * size, we switch to dense vectors */ val THRESHOLD = 0.25 - def fill[V](size: Int)(sparse: V): AdaptiveVector[V] = SparseVector(Map.empty[Int,V], sparse, size) + def fill[V](size: Int)(sparse: V): AdaptiveVector[V] = SparseVector(Map.empty[Int, V], sparse, size) def fromVector[V](v: Vector[V], sparseVal: V): AdaptiveVector[V] = { - if(v.size == 0) { + if (v.size == 0) { fill[V](0)(sparseVal) - } - else { + } else { val denseCount = v.count { _ != sparseVal } val sz = v.size - if(denseCount < sz * THRESHOLD) + if (denseCount < sz * THRESHOLD) SparseVector(toMap(v, sparseVal), sparseVal, sz) else DenseVector(v, sparseVal, denseCount) } } def fromMap[V](m: Map[Int, V], sparseVal: V, sizeOfDense: Int): AdaptiveVector[V] = { - if(m.size == 0) { + if (m.size == 0) { fill[V](sizeOfDense)(sparseVal) - } - else { + } else { val maxIdx = m.keys.max - require(maxIdx < sizeOfDense, "Max key (" + maxIdx +") exceeds valid for size (" + sizeOfDense +")") + require(maxIdx < sizeOfDense, "Max key (" + maxIdx + ") exceeds valid for size (" + sizeOfDense + ")") val denseCount = m.count { _._2 != sparseVal } - if(denseCount < sizeOfDense * THRESHOLD) + if (denseCount < sizeOfDense * THRESHOLD) SparseVector(m, sparseVal, sizeOfDense) else DenseVector(toVector(m, sparseVal, sizeOfDense), sparseVal, denseCount) @@ -63,12 +63,12 @@ object AdaptiveVector { def toMap[V](iseq: IndexedSeq[V], sparse: V): Map[Int, V] = iseq.view.zipWithIndex.filter { _._1 != sparse }.map { _.swap }.toMap - def toVector[V](m: Map[Int,V], sparse: V, size: Int): Vector[V] = { + def toVector[V](m: Map[Int, V], sparse: V, size: Int): Vector[V] = { // Mutable local variable to optimize performance import scala.collection.mutable.Buffer val buf = Buffer.fill[V](size)(sparse) m.foreach { case (idx, v) => buf(idx) = v } - Vector( buf :_* ) + Vector(buf: _*) } def toVector[V](v: AdaptiveVector[V]): Vector[V] = @@ -78,34 +78,33 @@ object AdaptiveVector { } private def withSparse[V](v: AdaptiveVector[V], sv: V): AdaptiveVector[V] = - if(v.sparseValue == sv) v + if (v.sparseValue == sv) v else fromVector(toVector(v), sv) - private class AVSemigroup[V:Semigroup] extends Semigroup[AdaptiveVector[V]] { + private class AVSemigroup[V: Semigroup] extends Semigroup[AdaptiveVector[V]] { private def valueIsNonZero(v: V): Boolean = implicitly[Semigroup[V]] match { case m: Monoid[_] => m.isNonZero(v) case _ => true } def plus(left: AdaptiveVector[V], right: AdaptiveVector[V]) = { - if(left.sparseValue != right.sparseValue) { - if(left.denseCount > right.denseCount) plus(withSparse(left, right.sparseValue), right) + if (left.sparseValue != right.sparseValue) { + if (left.denseCount > right.denseCount) plus(withSparse(left, right.sparseValue), right) else plus(left, withSparse(right, left.sparseValue)) - } - else { + } else { // they have the same sparse value val maxSize = Ordering[Int].max(left.size, right.size) (left, right) match { case (DenseVector(lv, ls, ld), DenseVector(rv, rs, rd)) => val vec = Semigroup.plus[IndexedSeq[V]](lv, rv) match { case v: Vector[_] => v.asInstanceOf[Vector[V]] - case notV => Vector(notV : _*) + case notV => Vector(notV: _*) } fromVector(vec, ls) case _ if valueIsNonZero(left.sparseValue) => - fromVector(Vector(Semigroup.plus(toVector(left):IndexedSeq[V], - toVector(right):IndexedSeq[V]):_*), + fromVector(Vector(Semigroup.plus(toVector(left): IndexedSeq[V], + toVector(right): IndexedSeq[V]): _*), left.sparseValue) case _ => // sparse is zero: fromMap(Semigroup.plus(toMap(left), toMap(right)), @@ -115,36 +114,36 @@ object AdaptiveVector { } } } - private class AVMonoid[V:Monoid] extends AVSemigroup[V] with Monoid[AdaptiveVector[V]] { + private class AVMonoid[V: Monoid] extends AVSemigroup[V] with Monoid[AdaptiveVector[V]] { val zero = AdaptiveVector.fill[V](0)(Monoid.zero[V]) override def isNonZero(v: AdaptiveVector[V]) = !isZero(v) def isZero(v: AdaptiveVector[V]) = (v.size == 0) || { - val sparseAreZero = if(Monoid.isNonZero(v.sparseValue)) (v.denseCount == v.size) else true + val sparseAreZero = if (Monoid.isNonZero(v.sparseValue)) (v.denseCount == v.size) else true sparseAreZero && v.denseIterator.forall { idxv => !Monoid.isNonZero(idxv._2) } } } - private class AVGroup[V:Group] extends AVMonoid[V] with Group[AdaptiveVector[V]] { + private class AVGroup[V: Group] extends AVMonoid[V] with Group[AdaptiveVector[V]] { override def negate(v: AdaptiveVector[V]) = fromVector(toVector(v).map(Group.negate(_)), Group.negate(v.sparseValue)) } - implicit def semigroup[V:Semigroup]: Semigroup[AdaptiveVector[V]] = new AVSemigroup[V] - implicit def monoid[V:Monoid]: Monoid[AdaptiveVector[V]] = new AVMonoid[V] - implicit def group[V:Group]: Group[AdaptiveVector[V]] = new AVGroup[V] + implicit def semigroup[V: Semigroup]: Semigroup[AdaptiveVector[V]] = new AVSemigroup[V] + implicit def monoid[V: Monoid]: Monoid[AdaptiveVector[V]] = new AVMonoid[V] + implicit def group[V: Group]: Group[AdaptiveVector[V]] = new AVGroup[V] /* * Equality when considering only the dense values (so size doesn't matter) */ - def denseEquiv[V:Equiv]: Equiv[AdaptiveVector[V]] = Equiv.fromFunction[AdaptiveVector[V]] { (l, r) => + def denseEquiv[V: Equiv]: Equiv[AdaptiveVector[V]] = Equiv.fromFunction[AdaptiveVector[V]] { (l, r) => val (lit, rit) = (l.denseIterator, r.denseIterator) @tailrec def iteq: Boolean = (lit.hasNext, rit.hasNext) match { case (true, true) => val (lnext, rnext) = (lit.next, rit.next) - if(lnext._1 == rnext._1 && Equiv[V].equiv(lnext._2, rnext._2)) + if (lnext._1 == rnext._1 && Equiv[V].equiv(lnext._2, rnext._2)) iteq else false @@ -154,14 +153,15 @@ object AdaptiveVector { Equiv[V].equiv(l.sparseValue, r.sparseValue) && iteq } - implicit def equiv[V:Equiv]: Equiv[AdaptiveVector[V]] = + implicit def equiv[V: Equiv]: Equiv[AdaptiveVector[V]] = Equiv.fromFunction[AdaptiveVector[V]] { (l, r) => (l.size == r.size) && (denseEquiv[V].equiv(l, r) || toVector(l).view.zip(toVector(r)).forall { case (lv, rv) => Equiv[V].equiv(lv, rv) }) } } -/** An IndexedSeq that automatically switches representation between dense and sparse depending on sparsity +/** + * An IndexedSeq that automatically switches representation between dense and sparse depending on sparsity * Should be an efficient representation for all sizes, and it should not be necessary to special case * immutable algebras based on the sparsity of the vectors. */ @@ -176,7 +176,7 @@ sealed trait AdaptiveVector[V] extends IndexedSeq[V] { /** Grow by adding count sparse values to the end */ def extend(count: Int): AdaptiveVector[V] /** Iterator of indices and values of all non-sparse values */ - def denseIterator: Iterator[(Int,V)] + def denseIterator: Iterator[(Int, V)] /* * Note that IndexedSeq provides hashCode and equals that * work correctly based on length and apply. @@ -189,24 +189,22 @@ case class DenseVector[V](iseq: Vector[V], override val sparseValue: V, override override def size = iseq.size def apply(idx: Int) = iseq(idx) def updated(idx: Int, v: V): AdaptiveVector[V] = { - val oldIsSparse = if(iseq(idx) == sparseValue) 1 else 0 - val newIsSparse = if(v == sparseValue) 1 else 0 + val oldIsSparse = if (iseq(idx) == sparseValue) 1 else 0 + val newIsSparse = if (v == sparseValue) 1 else 0 val newCount = denseCount - newIsSparse + oldIsSparse - if( denseCount < size * AdaptiveVector.THRESHOLD ) { + if (denseCount < size * AdaptiveVector.THRESHOLD) { // Go sparse SparseVector(AdaptiveVector.toMap(iseq, sparseValue), sparseValue, size) - } - else { + } else { DenseVector(iseq.updated(idx, v), sparseValue, newCount) } } def extend(cnt: Int) = { val newSize = size + cnt - if(denseCount < newSize * AdaptiveVector.THRESHOLD) { + if (denseCount < newSize * AdaptiveVector.THRESHOLD) { // Go sparse SparseVector(AdaptiveVector.toMap(iseq, sparseValue), sparseValue, newSize) - } - else { + } else { // Stay dense DenseVector(iseq ++ Vector.fill(cnt)(sparseValue), sparseValue, denseCount) } @@ -216,8 +214,7 @@ case class DenseVector[V](iseq: Vector[V], override val sparseValue: V, override iseq.view.zipWithIndex.filter { _._1 != sparseValue }.map { _.swap }.iterator } -case class SparseVector[V](map: Map[Int, V], override val sparseValue: V, override val size: Int) extends - AdaptiveVector[V] { +case class SparseVector[V](map: Map[Int, V], override val sparseValue: V, override val size: Int) extends AdaptiveVector[V] { def denseCount: Int = map.size def apply(idx: Int) = { @@ -225,16 +222,14 @@ case class SparseVector[V](map: Map[Int, V], override val sparseValue: V, overri map.getOrElse(idx, sparseValue) } def updated(idx: Int, v: V): AdaptiveVector[V] = { - if(v == sparseValue) { + if (v == sparseValue) { SparseVector(map - idx, sparseValue, size) - } - else { + } else { val newM = map + (idx -> v) - if(newM.size >= size * AdaptiveVector.THRESHOLD) { + if (newM.size >= size * AdaptiveVector.THRESHOLD) { // Go dense: DenseVector(AdaptiveVector.toVector(newM, sparseValue, size), sparseValue, newM.size) - } - else { + } else { SparseVector(newM, sparseValue, size) } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/AffineFunction.scala b/algebird-core/src/main/scala/com/twitter/algebird/AffineFunction.scala index 96c758ce3..db540a2dc 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/AffineFunction.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/AffineFunction.scala @@ -21,8 +21,8 @@ package com.twitter.algebird * f(x) = slope * x + intercept */ case class AffineFunction[R](slope: R, intercept: R) extends java.io.Serializable { - def toFn(implicit ring: Ring[R]): Function1[R,R] = {x => this.apply(x)(ring) } - def apply(x:R)(implicit ring: Ring[R]) = ring.plus(ring.times(slope, x), intercept) + def toFn(implicit ring: Ring[R]): Function1[R, R] = { x => this.apply(x)(ring) } + def apply(x: R)(implicit ring: Ring[R]) = ring.plus(ring.times(slope, x), intercept) } /** @@ -46,5 +46,5 @@ class AffineFunctionMonoid[R](implicit ring: Ring[R]) extends Monoid[AffineFunct } object AffineFunction extends java.io.Serializable { - implicit def monoid[R:Ring]: Monoid[AffineFunction[R]] = new AffineFunctionMonoid[R] + implicit def monoid[R: Ring]: Monoid[AffineFunction[R]] = new AffineFunctionMonoid[R] } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Aggregator.scala b/algebird-core/src/main/scala/com/twitter/algebird/Aggregator.scala index 9104be803..cb20b0550 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Aggregator.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Aggregator.scala @@ -8,79 +8,80 @@ package com.twitter.algebird * GeneratedTupleAggregator.from2((agg1, agg2)) */ object Aggregator extends java.io.Serializable { - /** Using Aggregator.prepare,present you can add to this aggregator + /** + * Using Aggregator.prepare,present you can add to this aggregator */ - def fromReduce[T](red: (T,T) => T): Aggregator[T,T,T] = new Aggregator[T,T,T] { - def prepare(input : T) = input - def reduce(l : T, r : T) = red(l, r) - def present(reduction : T) = reduction + def fromReduce[T](red: (T, T) => T): Aggregator[T, T, T] = new Aggregator[T, T, T] { + def prepare(input: T) = input + def reduce(l: T, r: T) = red(l, r) + def present(reduction: T) = reduction } - def fromSemigroup[T](implicit sg: Semigroup[T]): Aggregator[T,T,T] = new Aggregator[T,T,T] { - def prepare(input : T) = input - def reduce(l : T, r : T) = sg.plus(l, r) - def present(reduction : T) = reduction + def fromSemigroup[T](implicit sg: Semigroup[T]): Aggregator[T, T, T] = new Aggregator[T, T, T] { + def prepare(input: T) = input + def reduce(l: T, r: T) = sg.plus(l, r) + def present(reduction: T) = reduction } - def fromMonoid[T](implicit mon: Monoid[T]): MonoidAggregator[T,T,T] = fromMonoid[T,T](mon,identity[T]) + def fromMonoid[T](implicit mon: Monoid[T]): MonoidAggregator[T, T, T] = fromMonoid[T, T](mon, identity[T]) // Uses the product from the ring - def fromRing[T](implicit rng: Ring[T]): RingAggregator[T,T,T] = fromRing[T,T](rng,identity[T]) + def fromRing[T](implicit rng: Ring[T]): RingAggregator[T, T, T] = fromRing[T, T](rng, identity[T]) - def fromMonoid[F,T](implicit mon: Monoid[T],prep: F=>T): MonoidAggregator[F,T,T] = new MonoidAggregator[F,T,T] { - def prepare(input : F) = prep(input) + def fromMonoid[F, T](implicit mon: Monoid[T], prep: F => T): MonoidAggregator[F, T, T] = new MonoidAggregator[F, T, T] { + def prepare(input: F) = prep(input) def monoid = mon - def present(reduction : T) = reduction + def present(reduction: T) = reduction } // Uses the product from the ring - def fromRing[F,T](implicit rng: Ring[T],prep: F=>T): RingAggregator[F,T,T] = new RingAggregator[F,T,T] { - def prepare(input : F) = prep(input) + def fromRing[F, T](implicit rng: Ring[T], prep: F => T): RingAggregator[F, T, T] = new RingAggregator[F, T, T] { + def prepare(input: F) = prep(input) def ring = rng - def present(reduction : T) = reduction + def present(reduction: T) = reduction } } -trait Aggregator[-A,B,+C] extends java.io.Serializable { self => - def prepare(input : A) : B - def reduce(l : B, r : B) : B - def present(reduction : B) : C +trait Aggregator[-A, B, +C] extends java.io.Serializable { self => + def prepare(input: A): B + def reduce(l: B, r: B): B + def present(reduction: B): C - def reduce(items : TraversableOnce[B]) : B = items.reduce{reduce(_,_)} - def apply(inputs : TraversableOnce[A]) : C = present(reduce(inputs.map{prepare(_)})) + def reduce(items: TraversableOnce[B]): B = items.reduce{ reduce(_, _) } + def apply(inputs: TraversableOnce[A]): C = present(reduce(inputs.map{ prepare(_) })) - def append(l: B,r: A): B=reduce(l,prepare(r)) + def append(l: B, r: A): B = reduce(l, prepare(r)) def appendAll(old: B, items: TraversableOnce[A]): B = if (items.isEmpty) old else reduce(old, reduce(items.map(prepare))) /** Like calling andThen on the present function */ - def andThenPresent[D](present2: C => D): Aggregator[A,B,D] = - new Aggregator[A,B,D] { - def prepare(input : A) = self.prepare(input) - def reduce(l : B, r : B) = self.reduce(l, r) - def present(reduction : B) = present2(self.present(reduction)) + def andThenPresent[D](present2: C => D): Aggregator[A, B, D] = + new Aggregator[A, B, D] { + def prepare(input: A) = self.prepare(input) + def reduce(l: B, r: B) = self.reduce(l, r) + def present(reduction: B) = present2(self.present(reduction)) } /** Like calling compose on the prepare function */ - def composePrepare[A1](prepare2: A1 => A): Aggregator[A1,B,C] = - new Aggregator[A1,B,C] { - def prepare(input : A1) = self.prepare(prepare2(input)) - def reduce(l : B, r : B) = self.reduce(l, r) - def present(reduction : B) = self.present(reduction) + def composePrepare[A1](prepare2: A1 => A): Aggregator[A1, B, C] = + new Aggregator[A1, B, C] { + def prepare(input: A1) = self.prepare(prepare2(input)) + def reduce(l: B, r: B) = self.reduce(l, r) + def present(reduction: B) = self.present(reduction) } } -trait MonoidAggregator[-A,B,+C] extends Aggregator[A,B,C] { - def monoid : Monoid[B] - final def reduce(l : B, r : B) : B = monoid.plus(l, r) - final override def reduce(items : TraversableOnce[B]) : B = +trait MonoidAggregator[-A, B, +C] extends Aggregator[A, B, C] { + def monoid: Monoid[B] + final def reduce(l: B, r: B): B = monoid.plus(l, r) + final override def reduce(items: TraversableOnce[B]): B = monoid.sum(items) - def appendAll(items:TraversableOnce[A]): B=appendAll(monoid.zero,items) + def appendAll(items: TraversableOnce[A]): B = appendAll(monoid.zero, items) } -trait RingAggregator[-A,B,+C] extends Aggregator[A,B,C] { +trait RingAggregator[-A, B, +C] extends Aggregator[A, B, C] { def ring: Ring[B] - final def reduce(l: B, r: B): B = ring.times(l,r) - final override def reduce(items : TraversableOnce[B]) : B = - if(items.isEmpty) ring.one // There are several pseudo-rings, so avoid one if you can + final def reduce(l: B, r: B): B = ring.times(l, r) + final override def reduce(items: TraversableOnce[B]): B = + if (items.isEmpty) ring.one // There are several pseudo-rings, so avoid one if you can else items.reduceLeft(reduce _) - def appendAll(items:TraversableOnce[A]): B=appendAll(ring.one,items) + def appendAll(items: TraversableOnce[A]): B = appendAll(ring.one, items) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Approximate.scala b/algebird-core/src/main/scala/com/twitter/algebird/Approximate.scala index 7a841d13d..3a714fcc4 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Approximate.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Approximate.scala @@ -30,26 +30,24 @@ case class ApproximateBoolean(isTrue: Boolean, withProb: Double) { } def ||(that: ApproximateBoolean): ApproximateBoolean = { - if(isTrue || that.isTrue) { + if (isTrue || that.isTrue) { // We need at least one of them to be true: val newP = List(this, that) .filter { _.isTrue } .map { _.withProb } .max ApproximateBoolean(true, newP) - } - else { + } else { // We need both of these to be correct to believe it is false: ApproximateBoolean(false, withProb * that.withProb) } } def &&(that: ApproximateBoolean): ApproximateBoolean = { - if(isTrue && that.isTrue) { + if (isTrue && that.isTrue) { // We need both to be correct: ApproximateBoolean(true, withProb * that.withProb) - } - else { + } else { // Our confidence is the maximum confidence of the false cases: val newP = List(this, that) .filterNot { _.isTrue } @@ -67,57 +65,56 @@ object ApproximateBoolean { } // Note the probWithinBounds is a LOWER BOUND (at least this probability) -case class Approximate[N](min: N, estimate: N, max: N, probWithinBounds: Double) - (implicit val numeric: Numeric[N]) { - // Is this value contained within the bounds: - def boundsContain(v: N): Boolean = numeric.lteq(min, v) && numeric.lteq(v, max) - def contains(v: N): ApproximateBoolean = - ApproximateBoolean(boundsContain(v), probWithinBounds) - /* +case class Approximate[N](min: N, estimate: N, max: N, probWithinBounds: Double)(implicit val numeric: Numeric[N]) { + // Is this value contained within the bounds: + def boundsContain(v: N): Boolean = numeric.lteq(min, v) && numeric.lteq(v, max) + def contains(v: N): ApproximateBoolean = + ApproximateBoolean(boundsContain(v), probWithinBounds) + /* * This is so you can do: val x = Approximate(1.0, 1.1, 1.2, 0.99) * and then x ~ 1.05 returns true */ - def ~(v:N): Boolean = boundsContain(v) - /* + def ~(v: N): Boolean = boundsContain(v) + /* * Contract is: * Prob(boundsContain(estimate)) >= probWithinBounds */ - def isExact: Boolean = (probWithinBounds == 1.0) && numeric.equiv(min, max) - def +(right: Approximate[N]): Approximate[N] = { - val n = numeric - Approximate(n.plus(min, right.min), - n.plus(estimate, right.estimate), - n.plus(max, right.max), - probWithinBounds * right.probWithinBounds) - } - def -(right: Approximate[N]): Approximate[N] = { - this.+(right.negate) - } - /** This is not distributive, because: - * a*(b+c) has two probability multiplications - * while (a*b + a*b) has three - * Some kind of general formula solver could possibly - * make this distributive, but in the mean time, it's only - * a group - */ - def *(right: Approximate[N]): Approximate[N] = - if(right.isZero || isOne) { - right - } - else if(isZero || right.isOne) { - this - } - else { - val n = numeric - val ends = for(leftv <- List(min, max); - rightv <- List(right.min, right.max)) - yield n.times(leftv, rightv) - - val newProb = probWithinBounds * right.probWithinBounds - - Approximate(ends.min, n.times(estimate, right.estimate), - ends.max, newProb) - } + def isExact: Boolean = (probWithinBounds == 1.0) && numeric.equiv(min, max) + def +(right: Approximate[N]): Approximate[N] = { + val n = numeric + Approximate(n.plus(min, right.min), + n.plus(estimate, right.estimate), + n.plus(max, right.max), + probWithinBounds * right.probWithinBounds) + } + def -(right: Approximate[N]): Approximate[N] = { + this.+(right.negate) + } + /** + * This is not distributive, because: + * a*(b+c) has two probability multiplications + * while (a*b + a*b) has three + * Some kind of general formula solver could possibly + * make this distributive, but in the mean time, it's only + * a group + */ + def *(right: Approximate[N]): Approximate[N] = + if (right.isZero || isOne) { + right + } else if (isZero || right.isOne) { + this + } else { + val n = numeric + val ends = for ( + leftv <- List(min, max); + rightv <- List(right.min, right.max) + ) yield n.times(leftv, rightv) + + val newProb = probWithinBounds * right.probWithinBounds + + Approximate(ends.min, n.times(estimate, right.estimate), + ends.max, newProb) + } def isZero: Boolean = isExact && numeric.equiv(estimate, numeric.zero) @@ -130,27 +127,25 @@ case class Approximate[N](min: N, estimate: N, max: N, probWithinBounds: Double) // Assert that we definitely know the lower bound is better than m def withMin(m: N): Approximate[N] = { require(numeric.lteq(m, max)) - if(numeric.lteq(m, min) ) { + if (numeric.lteq(m, min)) { this - } - else { + } else { Approximate(m, numeric.max(m, estimate), max, probWithinBounds) } } // Assert that we definitely know the upper bound is at most m def withMax(m: N): Approximate[N] = { require(numeric.lteq(min, m)) - if(numeric.lteq(max, m) ) { + if (numeric.lteq(max, m)) { this - } - else { + } else { Approximate(min, numeric.min(m, estimate), m, probWithinBounds) } } } object Approximate { - def exact[N:Numeric](v: N) = Approximate(v,v,v,1.0) + def exact[N: Numeric](v: N) = Approximate(v, v, v, 1.0) def zero[N](implicit n: Numeric[N]) = exact(n.zero) def one[N](implicit n: Numeric[N]) = exact(n.one) // Not a group/ring: diff --git a/algebird-core/src/main/scala/com/twitter/algebird/AveragedValue.scala b/algebird-core/src/main/scala/com/twitter/algebird/AveragedValue.scala index 3f9384e2b..239ed67fb 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/AveragedValue.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/AveragedValue.scala @@ -18,14 +18,13 @@ package com.twitter.algebird object AveragedValue { implicit val group = AveragedGroup - implicit val aggregator: Aggregator[Double,AveragedValue,Double] = Averager + implicit val aggregator: Aggregator[Double, AveragedValue, Double] = Averager - def apply[V <% Double](v : V) = new AveragedValue(1L, v) - def apply[V <% Double](c : Long, v : V) = new AveragedValue(c, v) + def apply[V <% Double](v: V) = new AveragedValue(1L, v) + def apply[V <% Double](c: Long, v: V) = new AveragedValue(c, v) } - -case class AveragedValue(count : Long, value : Double) +case class AveragedValue(count: Long, value: Double) object AveragedGroup extends Group[AveragedValue] { // When combining averages, if the counts sizes are too close we should use a different @@ -40,31 +39,29 @@ object AveragedGroup extends Group[AveragedValue] { */ val zero = AveragedValue(0L, 0.0) - override def isNonZero(av : AveragedValue) = (av.count != 0L) + override def isNonZero(av: AveragedValue) = (av.count != 0L) - override def negate(av : AveragedValue) = AveragedValue(-av.count, av.value) + override def negate(av: AveragedValue) = AveragedValue(-av.count, av.value) - def plus(cntAve1 : AveragedValue, cntAve2 : AveragedValue) : AveragedValue = { + def plus(cntAve1: AveragedValue, cntAve2: AveragedValue): AveragedValue = { val (big, small) = if (cntAve1.count >= cntAve2.count) - (cntAve1, cntAve2) - else - (cntAve2, cntAve1) + (cntAve1, cntAve2) + else + (cntAve2, cntAve1) val n = big.count val k = small.count val newCnt = n + k if (newCnt == n) { // Handle zero without allocation big - } - else if (newCnt == 0L) { + } else if (newCnt == 0L) { zero - } - else { + } else { val an = big.value val ak = small.value - val scaling = k.toDouble/newCnt + val scaling = k.toDouble / newCnt // a_n + (a_k - a_n)*(k/(n+k)) is only stable if n is not approximately k - val newAve = if (scaling < STABILITY_CONSTANT) (an + (ak - an)*scaling) else (n*an + k*ak)/newCnt + val newAve = if (scaling < STABILITY_CONSTANT) (an + (ak - an) * scaling) else (n * an + k * ak) / newCnt new AveragedValue(newCnt, newAve) } } @@ -72,6 +69,6 @@ object AveragedGroup extends Group[AveragedValue] { object Averager extends MonoidAggregator[Double, AveragedValue, Double] { val monoid = AveragedGroup - def prepare(value : Double) = AveragedValue(value) - def present(average : AveragedValue) = average.value + def prepare(value: Double) = AveragedValue(value) + def present(average: AveragedValue) = average.value } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/BloomFilter.scala b/algebird-core/src/main/scala/com/twitter/algebird/BloomFilter.scala index ecccc137f..f68246b89 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/BloomFilter.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/BloomFilter.scala @@ -19,30 +19,30 @@ package com.twitter.algebird import scala.collection.immutable.BitSet import scala.collection.JavaConverters._ -import com.googlecode.javaewah.{EWAHCompressedBitmap => CBitSet} +import com.googlecode.javaewah.{ EWAHCompressedBitmap => CBitSet } object RichCBitSet { - def apply(x : Int*) = { - CBitSet.bitmapOf(x.sorted : _*) + def apply(x: Int*) = { + CBitSet.bitmapOf(x.sorted: _*) } - implicit def cb2rcb(cb : CBitSet) : RichCBitSet = new RichCBitSet(cb) + implicit def cb2rcb(cb: CBitSet): RichCBitSet = new RichCBitSet(cb) } // An enrichment to give some scala-like operators to the compressed // bit set. -class RichCBitSet(val cb : CBitSet) { - def ++(b : CBitSet) : CBitSet = cb.or(b) +class RichCBitSet(val cb: CBitSet) { + def ++(b: CBitSet): CBitSet = cb.or(b) - def ==(b : CBitSet) : Boolean = cb.equals(b) + def ==(b: CBitSet): Boolean = cb.equals(b) - def toBitSet(width : Int) : BitSet = { - val a = new Array[Long]((width+63)/64) - cb.asScala.foreach{ i : java.lang.Integer => a(i.intValue / 64) |= 1L << (i.intValue % 64) } + def toBitSet(width: Int): BitSet = { + val a = new Array[Long]((width + 63) / 64) + cb.asScala.foreach{ i: java.lang.Integer => a(i.intValue / 64) |= 1L << (i.intValue % 64) } BitSet.fromArray(a) } } -object BloomFilter{ +object BloomFilter { def apply(numEntries: Int, fpProb: Double, seed: Int = 0) = { val width = BloomFilter.optimalWidth(numEntries, fpProb) @@ -50,7 +50,6 @@ object BloomFilter{ BloomFilterMonoid(numHashes, width, seed) } - // Compute optimal number of hashes: k = m/n ln(2) def optimalNumHashes(numEntries: Int, width: Int): Int = math.ceil(width / numEntries * math.log(2)).toInt @@ -68,13 +67,11 @@ object BloomFilter{ * http://en.wikipedia.org/wiki/Bloom_filter * */ -case class BloomFilterMonoid(numHashes: Int, width: Int, seed: Int) extends Monoid[BF]{ +case class BloomFilterMonoid(numHashes: Int, width: Int, seed: Int) extends Monoid[BF] { val hashes: BFHash = BFHash(numHashes, width, seed) val zero: BF = BFZero(hashes, width) - - /** * Assume the bloom filters are compatible (same width and same hashing functions). This * is the union of the 2 bloom filters. @@ -86,7 +83,6 @@ case class BloomFilterMonoid(numHashes: Int, width: Int, seed: Int) extends Mono */ def create(item: String): BF = BFItem(item, hashes, width) - /** * Create a bloom filter with multiple items. */ @@ -95,18 +91,17 @@ case class BloomFilterMonoid(numHashes: Int, width: Int, seed: Int) extends Mono } } - /** * Bloom Filter data structure */ -sealed abstract class BF extends java.io.Serializable{ +sealed abstract class BF extends java.io.Serializable { val numHashes: Int val width: Int - def ++ (other: BF): BF + def ++(other: BF): BF - def + (other: String): BF + def +(other: String): BF def contains(item: String): ApproximateBoolean @@ -123,7 +118,7 @@ case class BFZero(hashes: BFHash, width: Int) extends BF { def ++(other: BF) = other - def + (other: String) = BFItem(other, hashes, width) + def +(other: String) = BFItem(other, hashes, width) def contains(item: String) = ApproximateBoolean.exactFalse @@ -138,49 +133,49 @@ case class BFItem(item: String, hashes: BFHash, width: Int) extends BF { def ++(other: BF): BF = { other match { - case bf@BFZero(_,_) => this - case bf@BFItem(otherItem,_,_) => BFSparse(hashes,RichCBitSet(hashes(item) : _*),width) + otherItem + case bf @ BFZero(_, _) => this + case bf @ BFItem(otherItem, _, _) => BFSparse(hashes, RichCBitSet(hashes(item): _*), width) + otherItem case _ => other + item } } - def + (other: String) = this ++ BFItem(other, hashes, width) + def +(other: String) = this ++ BFItem(other, hashes, width) def contains(x: String) = ApproximateBoolean.exact(item == x) def size = Approximate.exact[Long](1) } -case class BFSparse(hashes : BFHash, bits : CBitSet, width : Int) extends BF { +case class BFSparse(hashes: BFHash, bits: CBitSet, width: Int) extends BF { import RichCBitSet._ lazy val numHashes: Int = hashes.size - @transient lazy val dense : BFInstance = BFInstance(hashes, bits.toBitSet(width), width) + @transient lazy val dense: BFInstance = BFInstance(hashes, bits.toBitSet(width), width) - def ++ (other: BF): BF = { + def ++(other: BF): BF = { require(this.width == other.width) require(this.numHashes == other.numHashes) other match { - case bf@BFZero(_,_) => this - case bf@BFItem(item,_,_) => this + item - case bf@BFSparse(_,otherBits,_) => { + case bf @ BFZero(_, _) => this + case bf @ BFItem(item, _, _) => this + item + case bf @ BFSparse(_, otherBits, _) => { // assume same hashes used BFSparse(hashes, - bits ++ otherBits, - width) + bits ++ otherBits, + width) } case _ => other ++ this } } - def + (item: String): BF = { - val bitsToActivate = RichCBitSet(hashes(item) : _*) + def +(item: String): BF = { + val bitsToActivate = RichCBitSet(hashes(item): _*) BFSparse(hashes, - bits ++ bitsToActivate, - width) + bits ++ bitsToActivate, + width) } def contains(item: String): ApproximateBoolean = dense.contains(item) @@ -191,42 +186,42 @@ case class BFSparse(hashes : BFHash, bits : CBitSet, width : Int) extends BF { /* * Bloom filter with multiple values */ -case class BFInstance(hashes : BFHash, bits: BitSet, width: Int) extends BF { +case class BFInstance(hashes: BFHash, bits: BitSet, width: Int) extends BF { lazy val numHashes: Int = hashes.size lazy val numBits: Int = bits.size - def ++ (other: BF) = { + def ++(other: BF) = { require(this.width == other.width) require(this.numHashes == other.numHashes) other match { - case bf@BFZero(_,_) => this - case bf@BFItem(item,_,_) => this + item - case bf@BFSparse(_,_,_) => this ++ bf.dense - case bf@BFInstance(_,otherBits,_) => { + case bf @ BFZero(_, _) => this + case bf @ BFItem(item, _, _) => this + item + case bf @ BFSparse(_, _, _) => this ++ bf.dense + case bf @ BFInstance(_, otherBits, _) => { // assume same hashes used BFInstance(hashes, - bits ++ otherBits, - width) + bits ++ otherBits, + width) } } } - def + (item: String): BFInstance = { - val bitsToActivate = BitSet(hashes(item) : _*) + def +(item: String): BFInstance = { + val bitsToActivate = BitSet(hashes(item): _*) BFInstance(hashes, - bits ++ bitsToActivate, - width) + bits ++ bitsToActivate, + width) } - def bitSetContains(bs : BitSet, il : Int*) : Boolean = { - il.map{i : Int => bs.contains(i)}.reduce{_&&_} + def bitSetContains(bs: BitSet, il: Int*): Boolean = { + il.map{ i: Int => bs.contains(i) }.reduce{ _ && _ } } def contains(item: String) = { - if (bitSetContains(bits, hashes(item) : _*)) { + if (bitSetContains(bits, hashes(item): _*)) { // The false positive probability (the probability that the Bloom filter erroneously // claims that an element x is in the set when x is not) is roughly // p = (1 - e^(-numHashes * setCardinality / width))^numHashes @@ -265,8 +260,8 @@ case class BFInstance(hashes : BFHash, bits: BitSet, width: Int) extends BF { * (min, estimate, max) = * ((1 - approxWidth) * estimate, estimate, (1 + approxWidth) * estimate) */ - lazy val size : Approximate[Long] = size(approximationWidth = 0.05) - def size(approximationWidth : Double = 0.05) : Approximate[Long] = { + lazy val size: Approximate[Long] = size(approximationWidth = 0.05) + def size(approximationWidth: Double = 0.05): Approximate[Long] = { assert(0 <= approximationWidth && approximationWidth < 1, "approximationWidth must lie in [0, 1)") // Variable names correspond to those used in the paper. @@ -278,9 +273,9 @@ case class BFInstance(hashes : BFHash, bits: BitSet, width: Int) extends BF { val nr = scala.math.max(sInverse(t + 1).ceil, (1 + approximationWidth) * n).toInt val prob = 1 - - scala.math.exp(t - 1 - s(nl)) * - scala.math.pow(s(nl) / (t - 1), t - 1) - - scala.math.exp(-scala.math.pow(t + 1 - s(nr), 2) / (2 * s(nr))) + scala.math.exp(t - 1 - s(nl)) * + scala.math.pow(s(nl) / (t - 1), t - 1) - + scala.math.exp(-scala.math.pow(t + 1 - s(nr), 2) / (2 * s(nr))) Approximate[Long](nl, n, nr, scala.math.max(0, prob)) } @@ -290,7 +285,7 @@ case class BFInstance(hashes : BFHash, bits: BitSet, width: Int) extends BF { * n elements have been inserted into the Bloom filter. * This is \hat{S}(n) in the cardinality estimation paper used above. */ - private def s(n : Int) : Double = { + private def s(n: Int): Double = { width * (1 - scala.math.pow(1 - 1.0 / width, numHashes * n)) } @@ -299,18 +294,18 @@ case class BFInstance(hashes : BFHash, bits: BitSet, width: Int) extends BF { * that have been inserted into the Bloom filter when it has t bits set to true. * This is \hat{S}^{-1}(t) in the cardinality estimation paper used above. */ - private def sInverse(t : Int) : Double = { + private def sInverse(t: Int): Double = { scala.math.log(1 - t.toDouble / width) / (numHashes * scala.math.log(1 - 1.0 / width)) } } -object BFInstance{ +object BFInstance { def apply(hashes: BFHash, width: Int): BFInstance = BFInstance(hashes, BitSet.empty, width) } -case class BFHash(numHashes: Int, width: Int, seed: Long = 0L) extends Function1[String, Iterable[Int]]{ +case class BFHash(numHashes: Int, width: Int, seed: Long = 0L) extends Function1[String, Iterable[Int]] { val size = numHashes def apply(s: String) = nextHash(s.getBytes, numHashes) @@ -327,15 +322,15 @@ case class BFHash(numHashes: Int, width: Int, seed: Long = 0L) extends Function1 } private def nextHash(bytes: Array[Byte], k: Int, digested: Seq[Int] = Seq.empty): Stream[Int] = { - if(k == 0) + if (k == 0) Stream.empty - else{ - val d = if(digested.isEmpty){ + else { + val d = if (digested.isEmpty) { val (a, b) = MurmurHash128(k)(bytes) val (x1, x2) = splitLong(a) val (x3, x4) = splitLong(b) Seq(x1, x2, x3, x4) - }else + } else digested Stream.cons(d(0) % width, nextHash(bytes, k - 1, d.drop(1))) @@ -343,7 +338,7 @@ case class BFHash(numHashes: Int, width: Int, seed: Long = 0L) extends Function1 } } -case class BloomFilterAggregator(bfMonoid: BloomFilterMonoid) extends MonoidAggregator[String, BF, BF] { +case class BloomFilterAggregator(bfMonoid: BloomFilterMonoid) extends MonoidAggregator[String, BF, BF] { val monoid = bfMonoid def prepare(value: String) = monoid.create(value) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/BufferedOperation.scala b/algebird-core/src/main/scala/com/twitter/algebird/BufferedOperation.scala index 5cbaf31bc..b7b471712 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/BufferedOperation.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/BufferedOperation.scala @@ -18,7 +18,8 @@ package com.twitter.algebird import scala.collection.mutable.ArrayBuffer -/** Represents something that consumes I and may emit O. Has some internal +/** + * Represents something that consumes I and may emit O. Has some internal * state that may be used to improve performance. * Generally used to model folds or reduces (see BufferedReduce) */ @@ -37,12 +38,12 @@ abstract class ArrayBufferedOperation[I, O](size: Int) extends Buffered[I, O] { def put(item: I): Option[O] = { buffer += item - if(buffer.size >= size) flush + if (buffer.size >= size) flush else None } def flush: Option[O] = - if(buffer.isEmpty) None + if (buffer.isEmpty) None else { val res = operate(buffer) buffer.clear @@ -60,7 +61,7 @@ trait BufferedReduce[V] extends Buffered[V, V] { abstract override def put(item: V) = { val res = super.put(item) // avoiding closures for performance critical code: - if(res.isDefined) put(res.get) + if (res.isDefined) put(res.get) else None } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Combinator.scala b/algebird-core/src/main/scala/com/twitter/algebird/Combinator.scala index a205f1cbb..238058779 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Combinator.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Combinator.scala @@ -19,7 +19,8 @@ import scala.annotation.tailrec import scala.annotation.implicitNotFound import scala.math.Equiv -/** This is a combinator on semigroups, after you do the plus, you transform B with a fold function +/** + * This is a combinator on semigroups, after you do the plus, you transform B with a fold function * This will not be valid for all fold functions. You need to prove that it is still associative. * * Clearly only values of (a,b) are valid if fold(a,b) == b, so keep that in mind. @@ -35,13 +36,13 @@ import scala.math.Equiv * * Seems like an open topic here.... you are obliged to think on your own about this. */ -class SemigroupCombinator[A:Semigroup,B:Semigroup](fold: (A,B) => B) extends Semigroup[(A,B)] { - def plus(left: (A,B), right: (A,B)) = { +class SemigroupCombinator[A: Semigroup, B: Semigroup](fold: (A, B) => B) extends Semigroup[(A, B)] { + def plus(left: (A, B), right: (A, B)) = { val first = Semigroup.plus(left._1, right._1) (first, fold(first, Semigroup.plus(left._2, right._2))) } } -class MonoidCombinator[A:Monoid,B:Monoid](fold: (A,B) => B) extends SemigroupCombinator[A,B](fold) with Monoid[(A,B)] { +class MonoidCombinator[A: Monoid, B: Monoid](fold: (A, B) => B) extends SemigroupCombinator[A, B](fold) with Monoid[(A, B)] { def zero = (Monoid.zero[A], Monoid.zero[B]) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/CountMinSketch.scala b/algebird-core/src/main/scala/com/twitter/algebird/CountMinSketch.scala index ce2ec511e..b87058e74 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/CountMinSketch.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/CountMinSketch.scala @@ -69,8 +69,8 @@ import scala.collection.immutable.SortedSet * @heavyHittersPct A threshold for finding heavy hitters, i.e., elements that appear at least * (heavyHittersPct * totalCount) times in the stream. */ -class CountMinSketchMonoid(eps : Double, delta : Double, seed : Int, - heavyHittersPct : Double = 0.01) extends Monoid[CMS] { +class CountMinSketchMonoid(eps: Double, delta: Double, seed: Int, + heavyHittersPct: Double = 0.01) extends Monoid[CMS] { assert(0 < eps && eps < 1, "eps must lie in (0, 1)") assert(0 < delta && delta < 1, "delta must lie in (0, 1)") @@ -85,7 +85,7 @@ class CountMinSketchMonoid(eps : Double, delta : Double, seed : Int, // so we omit it and simply use hash functions of the form // // h_i(x) = a_i * x (mod p) - val hashes : Seq[CMSHash] = { + val hashes: Seq[CMSHash] = { val r = new scala.util.Random(seed) val numHashes = CMS.depth(delta) val numCounters = CMS.width(eps) @@ -94,27 +94,27 @@ class CountMinSketchMonoid(eps : Double, delta : Double, seed : Int, val params = CMSParams(hashes, eps, delta, heavyHittersPct) - val zero : CMS = CMSZero(params) + val zero: CMS = CMSZero(params) /** * We assume the Count-Min sketches on the left and right use the same hash functions. */ - def plus(left : CMS, right : CMS) : CMS = left ++ right + def plus(left: CMS, right: CMS): CMS = left ++ right /** * Create a Count-Min sketch out of a single item or data stream. */ - def create(item : Long) : CMS = CMSItem(item, params) - def create(data : Seq[Long]) : CMS = { + def create(item: Long): CMS = CMSItem(item, params) + def create(data: Seq[Long]): CMS = { data.foldLeft(zero) { case (acc, x) => plus(acc, create(x)) } } } object CMS { - def monoid(eps : Double, delta : Double, seed : Int, heavyHittersPct : Double = 0.01): CountMinSketchMonoid = + def monoid(eps: Double, delta: Double, seed: Int, heavyHittersPct: Double = 0.01): CountMinSketchMonoid = new CountMinSketchMonoid(eps, delta, seed, heavyHittersPct) - def monoid(depth : Int, width : Int, seed : Int, heavyHittersPct : Double): CountMinSketchMonoid = + def monoid(depth: Int, width: Int, seed: Int, heavyHittersPct: Double): CountMinSketchMonoid = new CountMinSketchMonoid(CMS.eps(width), CMS.delta(depth), seed, heavyHittersPct) def aggregator(eps: Double, delta: Double, seed: Int, heavyHittersPct: Double = 0.01): CountMinSketchAggregator = { @@ -122,7 +122,7 @@ object CMS { new CountMinSketchAggregator(monoid) } - def aggregator(depth : Int, width : Int, seed : Int, heavyHittersPct : Double): CountMinSketchAggregator = { + def aggregator(depth: Int, width: Int, seed: Int, heavyHittersPct: Double): CountMinSketchAggregator = { val monoid = new CountMinSketchMonoid(CMS.eps(width), CMS.delta(depth), seed, heavyHittersPct) new CountMinSketchAggregator(monoid) } @@ -132,10 +132,10 @@ object CMS { * depth = ceil(ln 1/delta) * width = ceil(e / eps) */ - def eps(width : Int) = scala.math.exp(1.0) / width - def delta(depth : Int) = 1.0 / scala.math.exp(depth) - def depth(delta : Double) = scala.math.ceil(scala.math.log(1.0 / delta)).toInt - def width(eps : Double) = scala.math.ceil(scala.math.exp(1) / eps).toInt + def eps(width: Int) = scala.math.exp(1.0) / width + def delta(depth: Int) = 1.0 / scala.math.exp(depth) + def depth(delta: Double) = scala.math.ceil(scala.math.log(1.0 / delta)).toInt + def width(eps: Double) = scala.math.ceil(scala.math.exp(1) / eps).toInt } /** @@ -144,15 +144,15 @@ object CMS { sealed abstract class CMS extends java.io.Serializable { // Parameters used to bound confidence in error estimates. - def eps : Double - def delta : Double + def eps: Double + def delta: Double // Number of hash functions. - def depth : Int = CMS.depth(delta) + def depth: Int = CMS.depth(delta) // Number of counters per hash function. - def width : Int = CMS.width(eps) + def width: Int = CMS.width(eps) - def ++(other : CMS) : CMS + def ++(other: CMS): CMS /** * Returns an estimate of the total number of times this item has been seen @@ -191,29 +191,29 @@ sealed abstract class CMS extends java.io.Serializable { * elements, so keeping track of all elements that appear more than (say) 1% of the * time requires tracking at most 100 items. */ - def heavyHittersPct : Double - def heavyHitters : Set[Long] + def heavyHittersPct: Double + def heavyHitters: Set[Long] // Total number of elements seen in the data stream so far. - def totalCount : Long + def totalCount: Long // The first frequency moment is the total number of elements in the stream. - def f1 : Long = totalCount + def f1: Long = totalCount // The second frequency moment is \sum a_i^2, where a_i is the count of the ith element. - def f2 : Approximate[Long] = innerProduct(this) + def f2: Approximate[Long] = innerProduct(this) } /** * Used for initialization. */ -case class CMSZero(params : CMSParams) extends CMS { - def eps : Double = params.eps - def delta : Double = params.delta - def heavyHittersPct : Double = params.heavyHittersPct +case class CMSZero(params: CMSParams) extends CMS { + def eps: Double = params.eps + def delta: Double = params.delta + def heavyHittersPct: Double = params.heavyHittersPct def totalCount = 0L - def ++(other : CMS) = other - def frequency(item : Long) = Approximate.exact(0L) - def innerProduct(other : CMS) = Approximate.exact(0L) + def ++(other: CMS) = other + def frequency(item: Long) = Approximate.exact(0L) + def innerProduct(other: CMS) = Approximate.exact(0L) def heavyHitters = Set[Long]() } @@ -221,24 +221,24 @@ case class CMSZero(params : CMSParams) extends CMS { * Used for holding a single element, to avoid repeatedly adding elements from * sparse counts tables. */ -case class CMSItem(item : Long, params : CMSParams) extends CMS { - def eps : Double = params.eps - def delta : Double = params.delta - def heavyHittersPct : Double = params.heavyHittersPct +case class CMSItem(item: Long, params: CMSParams) extends CMS { + def eps: Double = params.eps + def delta: Double = params.delta + def heavyHittersPct: Double = params.heavyHittersPct def totalCount = 1L - def ++(other : CMS) : CMS = { + def ++(other: CMS): CMS = { other match { - case other : CMSZero => this - case other : CMSItem => CMSInstance(params) + item + other.item - case other : CMSInstance => other + item + case other: CMSZero => this + case other: CMSItem => CMSInstance(params) + item + other.item + case other: CMSInstance => other + item } } - def frequency(x : Long) = if (item == x) Approximate.exact(1L) else Approximate.exact(0L) + def frequency(x: Long) = if (item == x) Approximate.exact(1L) else Approximate.exact(0L) - def innerProduct(other : CMS) : Approximate[Long] = other.frequency(item) + def innerProduct(other: CMS): Approximate[Long] = other.frequency(item) def heavyHitters = Set(item) } @@ -246,18 +246,18 @@ case class CMSItem(item : Long, params : CMSParams) extends CMS { /** * The general Count-Min sketch structure, used for holding any number of elements. */ -case class CMSInstance(countsTable : CMSCountsTable, totalCount : Long, - hhs : HeavyHitters, params : CMSParams) extends CMS { +case class CMSInstance(countsTable: CMSCountsTable, totalCount: Long, + hhs: HeavyHitters, params: CMSParams) extends CMS { - def eps : Double = params.eps - def delta : Double = params.delta - def heavyHittersPct : Double = params.heavyHittersPct + def eps: Double = params.eps + def delta: Double = params.delta + def heavyHittersPct: Double = params.heavyHittersPct - def ++(other : CMS) : CMS = { + def ++(other: CMS): CMS = { other match { - case other : CMSZero => this - case other : CMSItem => this + other.item - case other : CMSInstance => { + case other: CMSZero => this + case other: CMSItem => this + other.item + case other: CMSInstance => { val newTotalCount = totalCount + other.totalCount val newHhs = (hhs ++ other.hhs).dropCountsBelow(params.heavyHittersPct * newTotalCount) CMSInstance(countsTable ++ other.countsTable, newTotalCount, newHhs, params) @@ -266,18 +266,18 @@ case class CMSInstance(countsTable : CMSCountsTable, totalCount : Long, } private def makeApprox(est: Long): Approximate[Long] = { - if(est == 0L) { + if (est == 0L) { Approximate.exact(0L) - } - else { + } else { val lower = math.max(0L, est - (eps * totalCount).toLong) Approximate(lower, est, est, 1 - delta) } } - def frequency(item : Long) : Approximate[Long] = { - val estimates = countsTable.counts.zipWithIndex.map { case (row, i) => - row(params.hashes(i)(item)) + def frequency(item: Long): Approximate[Long] = { + val estimates = countsTable.counts.zipWithIndex.map { + case (row, i) => + row(params.hashes(i)(item)) } makeApprox(estimates.min) } @@ -289,14 +289,14 @@ case class CMSInstance(countsTable : CMSCountsTable, totalCount : Long, * between their rows: * estimatedInnerProduct = min_j (\sum_k count_A[j, k] * count_B[j, k]) */ - def innerProduct(other : CMS) : Approximate[Long] = { + def innerProduct(other: CMS): Approximate[Long] = { other match { - case other : CMSInstance => { + case other: CMSInstance => { assert((other.depth, other.width) == (depth, width), "Tables must have the same dimensions.") - def innerProductAtDepth(d : Int) = (0 to (width - 1)).map { w => - countsTable.getCount(d, w) * other.countsTable.getCount(d, w) - }.sum + def innerProductAtDepth(d: Int) = (0 to (width - 1)).map { w => + countsTable.getCount(d, w) * other.countsTable.getCount(d, w) + }.sum val est = (0 to (depth - 1)).map { innerProductAtDepth(_) }.min Approximate(est - (eps * totalCount * other.totalCount).toLong, est, est, 1 - delta) @@ -305,21 +305,22 @@ case class CMSInstance(countsTable : CMSCountsTable, totalCount : Long, } } - def heavyHitters : Set[Long] = hhs.items + def heavyHitters: Set[Long] = hhs.items /** * Updates the sketch with a new element from the data stream. */ - def +(item : Long) : CMSInstance = this + (item, 1L) - def +(item : Long, count : Long) : CMSInstance = { + def +(item: Long): CMSInstance = this + (item, 1L) + def +(item: Long, count: Long): CMSInstance = { if (count < 0) { throw new Exception("Negative counts not implemented") } else { val newHhs = updateHeavyHitters(item, count) val newCountsTable = - (0 to (depth - 1)).foldLeft(countsTable) { case (table, row) => - val pos = (row, params.hashes(row)(item)) - table + (pos, count) + (0 to (depth - 1)).foldLeft(countsTable) { + case (table, row) => + val pos = (row, params.hashes(row)(item)) + table + (pos, count) } CMSInstance(newCountsTable, totalCount + count, newHhs, params) @@ -330,7 +331,7 @@ case class CMSInstance(countsTable : CMSCountsTable, totalCount : Long, * Updates the data structure of heavy hitters when a new item (with associated count) * enters the stream. */ - private def updateHeavyHitters(item : Long, count : Long) : HeavyHitters = { + private def updateHeavyHitters(item: Long, count: Long): HeavyHitters = { val oldItemCount = frequency(item).estimate val newItemCount = oldItemCount + count val newTotalCount = totalCount + count @@ -350,7 +351,7 @@ case class CMSInstance(countsTable : CMSCountsTable, totalCount : Long, object CMSInstance { // Initializes a CMSInstance with all zeroes. - def apply(params : CMSParams) : CMSInstance = { + def apply(params: CMSParams): CMSInstance = { val countsTable = CMSCountsTable(CMS.depth(params.delta), CMS.width(params.eps)) CMSInstance(countsTable, 0, HeavyHitters(), params) } @@ -362,14 +363,14 @@ object CMSInstance { * * h(x) = [a * x + b (mod p)] (mod m) */ -case class CMSHash(a : Int, b : Int, width : Int) { +case class CMSHash(a: Int, b: Int, width: Int) { val PRIME_MODULUS = (1L << 31) - 1 /** * Returns a * x + b (mod p) (mod width) */ - def apply(x : Long) : Int = { + def apply(x: Long): Int = { val unmodded = a * x + b // Apparently a super fast way of computing x mod 2^p-1 @@ -389,14 +390,14 @@ case class CMSHash(a : Int, b : Int, width : Int) { * Each row corresponds to a particular hash function. * TODO: implement a dense matrix type, and use it here */ -case class CMSCountsTable(counts : Vector[Vector[Long]]) { +case class CMSCountsTable(counts: Vector[Vector[Long]]) { assert(depth > 0, "Table must have at least 1 row.") assert(width > 0, "Table must have at least 1 column.") - def depth : Int = counts.size - def width : Int = counts(0).size + def depth: Int = counts.size + def width: Int = counts(0).size - def getCount(pos : (Int, Int)) : Long = { + def getCount(pos: (Int, Int)): Long = { val (row, col) = pos assert(row < depth && col < width, "Position must be within the bounds of this table.") @@ -407,7 +408,7 @@ case class CMSCountsTable(counts : Vector[Vector[Long]]) { /** * Updates the count of a single cell in the table. */ - def +(pos : (Int, Int), count : Long) : CMSCountsTable = { + def +(pos: (Int, Int), count: Long): CMSCountsTable = { val (row, col) = pos val currCount = getCount(pos) val newCounts = counts.updated(row, counts(row).updated(col, currCount + count)) @@ -418,7 +419,7 @@ case class CMSCountsTable(counts : Vector[Vector[Long]]) { /** * Adds another counts table to this one, through elementwise addition. */ - def ++(other : CMSCountsTable) : CMSCountsTable = { + def ++(other: CMSCountsTable): CMSCountsTable = { assert((depth, width) == (other.depth, other.width), "Tables must have the same dimensions.") val iil = Monoid.plus[IndexedSeq[IndexedSeq[Long]]](counts, other.counts) def toVector[V](is: IndexedSeq[V]): Vector[V] = { @@ -432,45 +433,45 @@ case class CMSCountsTable(counts : Vector[Vector[Long]]) { } object CMSCountsTable { - // Creates a new CMSCountsTable with counts initialized to all zeroes. - def apply(depth : Int, width : Int) : CMSCountsTable = CMSCountsTable(Vector.fill[Long](depth, width)(0L)) + // Creates a new CMSCountsTable with counts initialized to all zeroes. + def apply(depth: Int, width: Int): CMSCountsTable = CMSCountsTable(Vector.fill[Long](depth, width)(0L)) } /** * Convenience class for holding constant parameters of a Count-Min sketch. */ -case class CMSParams(hashes : Seq[CMSHash], eps : Double, delta : Double, heavyHittersPct : Double) +case class CMSParams(hashes: Seq[CMSHash], eps: Double, delta: Double, heavyHittersPct: Double) /** * Containers for holding heavy hitter items and their associated counts. */ case class HeavyHitters( - hhs : SortedSet[HeavyHitter] = SortedSet[HeavyHitter]()(HeavyHitter.ordering)) { + hhs: SortedSet[HeavyHitter] = SortedSet[HeavyHitter]()(HeavyHitter.ordering)) { - def -(hh : HeavyHitter) = HeavyHitters(hhs - hh) - def +(hh : HeavyHitter) = HeavyHitters(hhs + hh) + def -(hh: HeavyHitter) = HeavyHitters(hhs - hh) + def +(hh: HeavyHitter) = HeavyHitters(hhs + hh) - def ++(other : HeavyHitters) = HeavyHitters(hhs ++ other.hhs) + def ++(other: HeavyHitters) = HeavyHitters(hhs ++ other.hhs) - def items : Set[Long] = hhs.map { _.item } + def items: Set[Long] = hhs.map { _.item } - def dropCountsBelow(minCount : Double) : HeavyHitters = { + def dropCountsBelow(minCount: Double): HeavyHitters = { HeavyHitters(hhs.dropWhile { _.count < minCount }) } } -case class HeavyHitter(item : Long, count : Long) +case class HeavyHitter(item: Long, count: Long) object HeavyHitter { - val ordering = Ordering.by { hh : HeavyHitter => (hh.count, hh.item) } + val ordering = Ordering.by { hh: HeavyHitter => (hh.count, hh.item) } } /** - * An Aggregator for the CountMinSketch. - * Can be created using CMS.aggregator - */ -case class CountMinSketchAggregator(cmsMonoid : CountMinSketchMonoid) extends MonoidAggregator[Long, CMS, CMS] { + * An Aggregator for the CountMinSketch. + * Can be created using CMS.aggregator + */ +case class CountMinSketchAggregator(cmsMonoid: CountMinSketchMonoid) extends MonoidAggregator[Long, CMS, CMS] { val monoid = cmsMonoid - def prepare(value : Long) = monoid.create(value) - def present(cms : CMS) = cms + def prepare(value: Long) = monoid.create(value) + def present(cms: CMS) = cms } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/DecayedValue.scala b/algebird-core/src/main/scala/com/twitter/algebird/DecayedValue.scala index f07cd7714..7e7c221ec 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/DecayedValue.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/DecayedValue.scala @@ -23,47 +23,43 @@ package com.twitter.algebird // t in seconds, 1 day half life means: t => t * ln(2)/(86400.0) object DecayedValue extends java.io.Serializable { - def build[V <% Double](value : V, time : Double, halfLife : Double) = { - DecayedValue(value, time * scala.math.log(2.0)/halfLife) + def build[V <% Double](value: V, time: Double, halfLife: Double) = { + DecayedValue(value, time * scala.math.log(2.0) / halfLife) } val zero = DecayedValue(0.0, Double.NegativeInfinity) - - def scale(newv : DecayedValue, oldv : DecayedValue, eps : Double) = { + def scale(newv: DecayedValue, oldv: DecayedValue, eps: Double) = { val newValue = newv.value + scala.math.exp(oldv.scaledTime - newv.scaledTime) * oldv.value - if( scala.math.abs(newValue) > eps ) { + if (scala.math.abs(newValue) > eps) { DecayedValue(newValue, newv.scaledTime) - } - else { + } else { zero } } - def monoidWithEpsilon(eps : Double): Monoid[DecayedValue] - = new DecayedValueMonoid(eps) + def monoidWithEpsilon(eps: Double): Monoid[DecayedValue] = new DecayedValueMonoid(eps) } -case class DecayedValueMonoid(eps:Double) extends Monoid[DecayedValue] { +case class DecayedValueMonoid(eps: Double) extends Monoid[DecayedValue] { override val zero = DecayedValue(0.0, Double.NegativeInfinity) - override def plus(left : DecayedValue, right : DecayedValue) = + override def plus(left: DecayedValue, right: DecayedValue) = if (left < right) { // left is older: DecayedValue.scale(right, left, eps) - } - else { + } else { // right is older DecayedValue.scale(left, right, eps) } // Returns value if timestamp is less than value's timestamp - def valueAsOf(value : DecayedValue, halfLife : Double, timestamp : Double): Double = { + def valueAsOf(value: DecayedValue, halfLife: Double, timestamp: Double): Double = { plus(DecayedValue.build(0, timestamp, halfLife), value).value } } -case class DecayedValue(value : Double, scaledTime : Double) extends Ordered[DecayedValue] { - def compare(that : DecayedValue) : Int = { +case class DecayedValue(value: Double, scaledTime: Double) extends Ordered[DecayedValue] { + def compare(that: DecayedValue): Int = { scaledTime.compareTo(that.scaledTime) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/DecayedVector.scala b/algebird-core/src/main/scala/com/twitter/algebird/DecayedVector.scala index 94a650ddc..0b3b4343d 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/DecayedVector.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/DecayedVector.scala @@ -26,11 +26,10 @@ object DecayedVector { DecayedVector(vector, time * scala.math.log(2.0) / halfLife) } - def monoidWithEpsilon[C[_]](eps: Double) - (implicit vs: VectorSpace[Double, C], metric: Metric[C[Double]]) = new Monoid[DecayedVector[C]] { + def monoidWithEpsilon[C[_]](eps: Double)(implicit vs: VectorSpace[Double, C], metric: Metric[C[Double]]) = new Monoid[DecayedVector[C]] { override val zero = DecayedVector(vs.group.zero, Double.NegativeInfinity) override def plus(left: DecayedVector[C], right: DecayedVector[C]) = { - if(left.scaledTime <= right.scaledTime) { + if (left.scaledTime <= right.scaledTime) { scaledPlus(right, left, eps) } else { scaledPlus(left, right, eps) @@ -38,27 +37,24 @@ object DecayedVector { } } - def forMap[K](m: Map[K, Double], scaledTime: Double) = DecayedVector[({type x[a]=Map[K, a]})#x](m, scaledTime) + def forMap[K](m: Map[K, Double], scaledTime: Double) = DecayedVector[({ type x[a] = Map[K, a] })#x](m, scaledTime) def forMapWithHalflife[K](m: Map[K, Double], time: Double, halfLife: Double) = forMap(m, time * scala.math.log(2.0) / halfLife) - def mapMonoidWithEpsilon[K](eps: Double) - (implicit vs: VectorSpace[Double, ({type x[a]=Map[K, a]})#x], metric: Metric[Map[K, Double]]) = - monoidWithEpsilon[({type x[a]=Map[K, a]})#x](eps) + def mapMonoidWithEpsilon[K](eps: Double)(implicit vs: VectorSpace[Double, ({ type x[a] = Map[K, a] })#x], metric: Metric[Map[K, Double]]) = + monoidWithEpsilon[({ type x[a] = Map[K, a] })#x](eps) // This is the default monoid that never thresholds. // If you want to set a specific accuracy you need to implicitly override this implicit def monoid[F, C[_]](implicit vs: VectorSpace[F, C], metric: Metric[C[F]], ord: Ordering[F]) = monoidWithEpsilon(-1.0) - implicit def mapMonoid[K] - (implicit vs: VectorSpace[Double, ({type x[a]=Map[K, a]})#x], metric: Metric[Map[K, Double]]) = + implicit def mapMonoid[K](implicit vs: VectorSpace[Double, ({ type x[a] = Map[K, a] })#x], metric: Metric[Map[K, Double]]) = mapMonoidWithEpsilon(-1.0) - def scaledPlus[C[_]](newVal: DecayedVector[C], oldVal: DecayedVector[C], eps: Double) - (implicit vs: VectorSpace[Double, C], metric: Metric[C[Double]]): DecayedVector[C] = { + def scaledPlus[C[_]](newVal: DecayedVector[C], oldVal: DecayedVector[C], eps: Double)(implicit vs: VectorSpace[Double, C], metric: Metric[C[Double]]): DecayedVector[C] = { implicit val mon: Monoid[C[Double]] = vs.group val expFactor = scala.math.exp(oldVal.scaledTime - newVal.scaledTime) val newVector = Monoid.plus(newVal.vector, vs.scale(expFactor, oldVal.vector)) - if(eps < 0.0 || Metric.norm(newVector) > eps) { + if (eps < 0.0 || Metric.norm(newVector) > eps) { DecayedVector(newVector, newVal.scaledTime) } else { DecayedVector(mon.zero, Double.NegativeInfinity) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Eventually.scala b/algebird-core/src/main/scala/com/twitter/algebird/Eventually.scala index 4604d93e0..f2c207591 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Eventually.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Eventually.scala @@ -35,8 +35,7 @@ package com.twitter.algebird * @param E eventual type * @param O original type */ -class EventuallySemigroup[E, O](convert: O => E)(mustConvert: O => Boolean) - (implicit eventualSemigroup: Semigroup[E], originalSemigroup: Semigroup[O]) extends Semigroup[Either[E, O]] { +class EventuallySemigroup[E, O](convert: O => E)(mustConvert: O => Boolean)(implicit eventualSemigroup: Semigroup[E], originalSemigroup: Semigroup[O]) extends Semigroup[Either[E, O]] { import scala.collection.mutable.Buffer @@ -58,7 +57,7 @@ class EventuallySemigroup[E, O](convert: O => E)(mustConvert: O => Boolean) /** * used to avoid materializing the entire input in memory */ - private[this] final def checkSize[T:Semigroup](buffer: Buffer[T]) { + private[this] final def checkSize[T: Semigroup](buffer: Buffer[T]) { if (buffer.size > maxBuffer) { val sum = Semigroup.sumOption(buffer) buffer.clear @@ -102,8 +101,8 @@ class EventuallySemigroup[E, O](convert: O => E)(mustConvert: O => Boolean) } } }) match { // finally apply sumOption accordingly - case Left(be) => Semigroup.sumOption(be).map(left(_)) - case Right(bo) => Semigroup.sumOption(bo).map(conditionallyConvert(_)) // and optionally convert + case Left(be) => Semigroup.sumOption(be).map(left(_)) + case Right(bo) => Semigroup.sumOption(bo).map(conditionallyConvert(_)) // and optionally convert } } @@ -123,8 +122,7 @@ class EventuallySemigroup[E, O](convert: O => E)(mustConvert: O => Boolean) /** * @see EventuallySemigroup */ -class EventuallyMonoid[E, O](convert: O => E)(mustConvert: O => Boolean) - (implicit lSemigroup: Semigroup[E], rMonoid: Monoid[O]) extends EventuallySemigroup[E, O](convert)(mustConvert) +class EventuallyMonoid[E, O](convert: O => E)(mustConvert: O => Boolean)(implicit lSemigroup: Semigroup[E], rMonoid: Monoid[O]) extends EventuallySemigroup[E, O](convert)(mustConvert) with Monoid[Either[E, O]] { override def zero = Right(Monoid.zero[O]) @@ -134,8 +132,7 @@ class EventuallyMonoid[E, O](convert: O => E)(mustConvert: O => Boolean) /** * @see EventuallySemigroup */ -class EventuallyGroup[E, O](convert: O => E)(mustConvert: O => Boolean) - (implicit lGroup: Group[E], rGroup: Group[O]) extends EventuallyMonoid[E, O](convert)(mustConvert) +class EventuallyGroup[E, O](convert: O => E)(mustConvert: O => Boolean)(implicit lGroup: Group[E], rGroup: Group[O]) extends EventuallyMonoid[E, O](convert)(mustConvert) with Group[Either[E, O]] { override def negate(x: Either[E, O]) = { @@ -152,8 +149,7 @@ class EventuallyGroup[E, O](convert: O => E)(mustConvert: O => Boolean) /** * @see EventuallySemigroup */ -class EventuallyRing[E, O](convert: O => E)(mustConvert: O => Boolean) - (implicit lRing: Ring[E], rRing: Ring[O]) extends EventuallyGroup[E, O](convert)(mustConvert) +class EventuallyRing[E, O](convert: O => E)(mustConvert: O => Boolean)(implicit lRing: Ring[E], rRing: Ring[O]) extends EventuallyGroup[E, O](convert)(mustConvert) with Ring[Either[E, O]] { override def one = Right(Ring.one[O]) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Field.scala b/algebird-core/src/main/scala/com/twitter/algebird/Field.scala index b924842a8..2402e0a5a 100755 --- a/algebird-core/src/main/scala/com/twitter/algebird/Field.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Field.scala @@ -18,8 +18,8 @@ package com.twitter.algebird import scala.annotation.tailrec import scala.annotation.implicitNotFound -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} -import java.util.{List => JList, Map => JMap} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } +import java.util.{ List => JList, Map => JMap } /** * Field: Ring + division. It is a generalization of Ring and adds support for inversion and @@ -27,14 +27,14 @@ import java.util.{List => JList, Map => JMap} */ @implicitNotFound(msg = "Cannot find Field type class for ${T}") -trait Field[@specialized(Int,Long,Float,Double) T] extends Ring[T] { +trait Field[@specialized(Int, Long, Float, Double) T] extends Ring[T] { // default implementation uses div YOU MUST OVERRIDE ONE OF THESE - def inverse(v : T) : T = { + def inverse(v: T): T = { assertNotZero(v) div(one, v) } // default implementation uses inverse: - def div(l : T, r : T) : T = { + def div(l: T, r: T): T = { assertNotZero(r) times(l, inverse(r)) } @@ -46,11 +46,11 @@ abstract class AbstractField[T] extends Field[T] object FloatField extends Field[Float] { override def one = 1.0f override def zero = 0.0f - override def negate(v : Float) = -v - override def plus(l : Float, r : Float) = l + r - override def minus(l : Float, r : Float) = l - r - override def times(l : Float, r : Float) = l * r - override def div(l : Float, r : Float) = { + override def negate(v: Float) = -v + override def plus(l: Float, r: Float) = l + r + override def minus(l: Float, r: Float) = l - r + override def times(l: Float, r: Float) = l * r + override def div(l: Float, r: Float) = { assertNotZero(r) l / r } @@ -59,11 +59,11 @@ object FloatField extends Field[Float] { object DoubleField extends Field[Double] { override def one = 1.0 override def zero = 0.0 - override def negate(v : Double) = -v - override def plus(l : Double, r : Double) = l + r - override def minus(l : Double, r : Double) = l - r - override def times(l : Double, r : Double) = l * r - override def div(l : Double, r : Double) = { + override def negate(v: Double) = -v + override def plus(l: Double, r: Double) = l + r + override def minus(l: Double, r: Double) = l - r + override def times(l: Double, r: Double) = l * r + override def div(l: Double, r: Double) = { assertNotZero(r) l / r } @@ -72,15 +72,15 @@ object DoubleField extends Field[Double] { object BooleanField extends Field[Boolean] { override def one = true override def zero = false - override def negate(v : Boolean) = v - override def plus(l : Boolean, r : Boolean) = l ^ r - override def minus(l : Boolean, r : Boolean) = l ^ r - override def times(l : Boolean, r : Boolean) = l && r - override def inverse(l : Boolean) = { + override def negate(v: Boolean) = v + override def plus(l: Boolean, r: Boolean) = l ^ r + override def minus(l: Boolean, r: Boolean) = l ^ r + override def times(l: Boolean, r: Boolean) = l && r + override def inverse(l: Boolean) = { assertNotZero(l) true } - override def div(l : Boolean, r : Boolean) = { + override def div(l: Boolean, r: Boolean) = { assertNotZero(r) l } @@ -88,12 +88,12 @@ object BooleanField extends Field[Boolean] { object Field { // This pattern is really useful for typeclasses - def div[T](l : T, r : T)(implicit fld : Field[T]) = fld.div(l,r) + def div[T](l: T, r: T)(implicit fld: Field[T]) = fld.div(l, r) - implicit val boolField : Field[Boolean] = BooleanField - implicit val jboolField : Field[JBool] = JBoolField - implicit val floatField : Field[Float] = FloatField - implicit val jfloatField : Field[JFloat] = JFloatField - implicit val doubleField : Field[Double] = DoubleField - implicit val jdoubleField : Field[JDouble] = JDoubleField + implicit val boolField: Field[Boolean] = BooleanField + implicit val jboolField: Field[JBool] = JBoolField + implicit val floatField: Field[Float] = FloatField + implicit val jfloatField: Field[JFloat] = JFloatField + implicit val doubleField: Field[Double] = DoubleField + implicit val jdoubleField: Field[JDouble] = JDoubleField } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/GeneratedAbstractAlgebra.scala b/algebird-core/src/main/scala/com/twitter/algebird/GeneratedAbstractAlgebra.scala index f5b9a8e29..f1a83ea49 100755 --- a/algebird-core/src/main/scala/com/twitter/algebird/GeneratedAbstractAlgebra.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/GeneratedAbstractAlgebra.scala @@ -2,11 +2,11 @@ package com.twitter.algebird /** -* Combine 2 semigroups into a product semigroup -*/ -class Tuple2Semigroup[A, B](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B]) extends Semigroup[(A, B)] { - override def plus(l : (A, B), r : (A, B)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2)) - override def sumOption(to : TraversableOnce[(A, B)]) = { + * Combine 2 semigroups into a product semigroup + */ +class Tuple2Semigroup[A, B](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B]) extends Semigroup[(A, B)] { + override def plus(l: (A, B), r: (A, B)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2)) + override def sumOption(to: TraversableOnce[(A, B)]) = { val buf = new ArrayBufferedOperation[(A, B), (A, B)](1000) with BufferedReduce[(A, B)] { def operate(items: Seq[(A, B)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get) @@ -17,40 +17,40 @@ class Tuple2Semigroup[A, B](implicit asemigroup : Semigroup[A], bsemigroup : Sem } /** -* Combine 2 monoids into a product monoid -*/ -class Tuple2Monoid[A, B](implicit amonoid : Monoid[A], bmonoid : Monoid[B]) extends Monoid[(A, B)] { + * Combine 2 monoids into a product monoid + */ +class Tuple2Monoid[A, B](implicit amonoid: Monoid[A], bmonoid: Monoid[B]) extends Monoid[(A, B)] { override def zero = (amonoid.zero, bmonoid.zero) - override def plus(l : (A, B), r : (A, B)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2)) + override def plus(l: (A, B), r: (A, B)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2)) } /** -* Combine 2 groups into a product group -*/ -class Tuple2Group[A, B](implicit agroup : Group[A], bgroup : Group[B]) extends Group[(A, B)] { + * Combine 2 groups into a product group + */ +class Tuple2Group[A, B](implicit agroup: Group[A], bgroup: Group[B]) extends Group[(A, B)] { override def zero = (agroup.zero, bgroup.zero) - override def negate(v : (A, B)) = (agroup.negate(v._1), bgroup.negate(v._2)) - override def plus(l : (A, B), r : (A, B)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2)) - override def minus(l : (A, B), r : (A, B)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2)) + override def negate(v: (A, B)) = (agroup.negate(v._1), bgroup.negate(v._2)) + override def plus(l: (A, B), r: (A, B)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2)) + override def minus(l: (A, B), r: (A, B)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2)) } /** -* Combine 2 rings into a product ring -*/ -class Tuple2Ring[A, B](implicit aring : Ring[A], bring : Ring[B]) extends Ring[(A, B)] { + * Combine 2 rings into a product ring + */ +class Tuple2Ring[A, B](implicit aring: Ring[A], bring: Ring[B]) extends Ring[(A, B)] { override def zero = (aring.zero, bring.zero) override def one = (aring.one, bring.one) - override def negate(v : (A, B)) = (aring.negate(v._1), bring.negate(v._2)) - override def plus(l : (A, B), r : (A, B)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2)) - override def minus(l : (A, B), r : (A, B)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2)) - override def times(l : (A, B), r : (A, B)) = (aring.times(l._1, r._1), bring.times(l._2, r._2)) + override def negate(v: (A, B)) = (aring.negate(v._1), bring.negate(v._2)) + override def plus(l: (A, B), r: (A, B)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2)) + override def minus(l: (A, B), r: (A, B)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2)) + override def times(l: (A, B), r: (A, B)) = (aring.times(l._1, r._1), bring.times(l._2, r._2)) } /** -* Combine 3 semigroups into a product semigroup -*/ -class Tuple3Semigroup[A, B, C](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C]) extends Semigroup[(A, B, C)] { - override def plus(l : (A, B, C), r : (A, B, C)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3)) - override def sumOption(to : TraversableOnce[(A, B, C)]) = { + * Combine 3 semigroups into a product semigroup + */ +class Tuple3Semigroup[A, B, C](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C]) extends Semigroup[(A, B, C)] { + override def plus(l: (A, B, C), r: (A, B, C)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3)) + override def sumOption(to: TraversableOnce[(A, B, C)]) = { val buf = new ArrayBufferedOperation[(A, B, C), (A, B, C)](1000) with BufferedReduce[(A, B, C)] { def operate(items: Seq[(A, B, C)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get) @@ -61,40 +61,40 @@ class Tuple3Semigroup[A, B, C](implicit asemigroup : Semigroup[A], bsemigroup : } /** -* Combine 3 monoids into a product monoid -*/ -class Tuple3Monoid[A, B, C](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C]) extends Monoid[(A, B, C)] { + * Combine 3 monoids into a product monoid + */ +class Tuple3Monoid[A, B, C](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C]) extends Monoid[(A, B, C)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero) - override def plus(l : (A, B, C), r : (A, B, C)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3)) + override def plus(l: (A, B, C), r: (A, B, C)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3)) } /** -* Combine 3 groups into a product group -*/ -class Tuple3Group[A, B, C](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C]) extends Group[(A, B, C)] { + * Combine 3 groups into a product group + */ +class Tuple3Group[A, B, C](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C]) extends Group[(A, B, C)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero) - override def negate(v : (A, B, C)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3)) - override def plus(l : (A, B, C), r : (A, B, C)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3)) - override def minus(l : (A, B, C), r : (A, B, C)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3)) + override def negate(v: (A, B, C)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3)) + override def plus(l: (A, B, C), r: (A, B, C)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3)) + override def minus(l: (A, B, C), r: (A, B, C)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3)) } /** -* Combine 3 rings into a product ring -*/ -class Tuple3Ring[A, B, C](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C]) extends Ring[(A, B, C)] { + * Combine 3 rings into a product ring + */ +class Tuple3Ring[A, B, C](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C]) extends Ring[(A, B, C)] { override def zero = (aring.zero, bring.zero, cring.zero) override def one = (aring.one, bring.one, cring.one) - override def negate(v : (A, B, C)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3)) - override def plus(l : (A, B, C), r : (A, B, C)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3)) - override def minus(l : (A, B, C), r : (A, B, C)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3)) - override def times(l : (A, B, C), r : (A, B, C)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3)) + override def negate(v: (A, B, C)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3)) + override def plus(l: (A, B, C), r: (A, B, C)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3)) + override def minus(l: (A, B, C), r: (A, B, C)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3)) + override def times(l: (A, B, C), r: (A, B, C)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3)) } /** -* Combine 4 semigroups into a product semigroup -*/ -class Tuple4Semigroup[A, B, C, D](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D]) extends Semigroup[(A, B, C, D)] { - override def plus(l : (A, B, C, D), r : (A, B, C, D)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4)) - override def sumOption(to : TraversableOnce[(A, B, C, D)]) = { + * Combine 4 semigroups into a product semigroup + */ +class Tuple4Semigroup[A, B, C, D](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D]) extends Semigroup[(A, B, C, D)] { + override def plus(l: (A, B, C, D), r: (A, B, C, D)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4)) + override def sumOption(to: TraversableOnce[(A, B, C, D)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D), (A, B, C, D)](1000) with BufferedReduce[(A, B, C, D)] { def operate(items: Seq[(A, B, C, D)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get) @@ -105,40 +105,40 @@ class Tuple4Semigroup[A, B, C, D](implicit asemigroup : Semigroup[A], bsemigroup } /** -* Combine 4 monoids into a product monoid -*/ -class Tuple4Monoid[A, B, C, D](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D]) extends Monoid[(A, B, C, D)] { + * Combine 4 monoids into a product monoid + */ +class Tuple4Monoid[A, B, C, D](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D]) extends Monoid[(A, B, C, D)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero) - override def plus(l : (A, B, C, D), r : (A, B, C, D)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4)) + override def plus(l: (A, B, C, D), r: (A, B, C, D)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4)) } /** -* Combine 4 groups into a product group -*/ -class Tuple4Group[A, B, C, D](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D]) extends Group[(A, B, C, D)] { + * Combine 4 groups into a product group + */ +class Tuple4Group[A, B, C, D](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D]) extends Group[(A, B, C, D)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero) - override def negate(v : (A, B, C, D)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4)) - override def plus(l : (A, B, C, D), r : (A, B, C, D)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4)) - override def minus(l : (A, B, C, D), r : (A, B, C, D)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4)) + override def negate(v: (A, B, C, D)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4)) + override def plus(l: (A, B, C, D), r: (A, B, C, D)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4)) + override def minus(l: (A, B, C, D), r: (A, B, C, D)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4)) } /** -* Combine 4 rings into a product ring -*/ -class Tuple4Ring[A, B, C, D](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D]) extends Ring[(A, B, C, D)] { + * Combine 4 rings into a product ring + */ +class Tuple4Ring[A, B, C, D](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D]) extends Ring[(A, B, C, D)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero) override def one = (aring.one, bring.one, cring.one, dring.one) - override def negate(v : (A, B, C, D)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4)) - override def plus(l : (A, B, C, D), r : (A, B, C, D)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4)) - override def minus(l : (A, B, C, D), r : (A, B, C, D)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4)) - override def times(l : (A, B, C, D), r : (A, B, C, D)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4)) + override def negate(v: (A, B, C, D)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4)) + override def plus(l: (A, B, C, D), r: (A, B, C, D)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4)) + override def minus(l: (A, B, C, D), r: (A, B, C, D)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4)) + override def times(l: (A, B, C, D), r: (A, B, C, D)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4)) } /** -* Combine 5 semigroups into a product semigroup -*/ -class Tuple5Semigroup[A, B, C, D, E](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E]) extends Semigroup[(A, B, C, D, E)] { - override def plus(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E)]) = { + * Combine 5 semigroups into a product semigroup + */ +class Tuple5Semigroup[A, B, C, D, E](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E]) extends Semigroup[(A, B, C, D, E)] { + override def plus(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E), (A, B, C, D, E)](1000) with BufferedReduce[(A, B, C, D, E)] { def operate(items: Seq[(A, B, C, D, E)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get) @@ -149,40 +149,40 @@ class Tuple5Semigroup[A, B, C, D, E](implicit asemigroup : Semigroup[A], bsemigr } /** -* Combine 5 monoids into a product monoid -*/ -class Tuple5Monoid[A, B, C, D, E](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E]) extends Monoid[(A, B, C, D, E)] { + * Combine 5 monoids into a product monoid + */ +class Tuple5Monoid[A, B, C, D, E](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E]) extends Monoid[(A, B, C, D, E)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero) - override def plus(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5)) + override def plus(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5)) } /** -* Combine 5 groups into a product group -*/ -class Tuple5Group[A, B, C, D, E](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E]) extends Group[(A, B, C, D, E)] { + * Combine 5 groups into a product group + */ +class Tuple5Group[A, B, C, D, E](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E]) extends Group[(A, B, C, D, E)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero) - override def negate(v : (A, B, C, D, E)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5)) - override def plus(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5)) - override def minus(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5)) + override def negate(v: (A, B, C, D, E)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5)) + override def plus(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5)) + override def minus(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5)) } /** -* Combine 5 rings into a product ring -*/ -class Tuple5Ring[A, B, C, D, E](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E]) extends Ring[(A, B, C, D, E)] { + * Combine 5 rings into a product ring + */ +class Tuple5Ring[A, B, C, D, E](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E]) extends Ring[(A, B, C, D, E)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one) - override def negate(v : (A, B, C, D, E)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5)) - override def plus(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5)) - override def minus(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5)) - override def times(l : (A, B, C, D, E), r : (A, B, C, D, E)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5)) + override def negate(v: (A, B, C, D, E)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5)) + override def plus(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5)) + override def minus(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5)) + override def times(l: (A, B, C, D, E), r: (A, B, C, D, E)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5)) } /** -* Combine 6 semigroups into a product semigroup -*/ -class Tuple6Semigroup[A, B, C, D, E, F](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F]) extends Semigroup[(A, B, C, D, E, F)] { - override def plus(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F)]) = { + * Combine 6 semigroups into a product semigroup + */ +class Tuple6Semigroup[A, B, C, D, E, F](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F]) extends Semigroup[(A, B, C, D, E, F)] { + override def plus(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F), (A, B, C, D, E, F)](1000) with BufferedReduce[(A, B, C, D, E, F)] { def operate(items: Seq[(A, B, C, D, E, F)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get) @@ -193,40 +193,40 @@ class Tuple6Semigroup[A, B, C, D, E, F](implicit asemigroup : Semigroup[A], bsem } /** -* Combine 6 monoids into a product monoid -*/ -class Tuple6Monoid[A, B, C, D, E, F](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F]) extends Monoid[(A, B, C, D, E, F)] { + * Combine 6 monoids into a product monoid + */ +class Tuple6Monoid[A, B, C, D, E, F](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F]) extends Monoid[(A, B, C, D, E, F)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero) - override def plus(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6)) + override def plus(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6)) } /** -* Combine 6 groups into a product group -*/ -class Tuple6Group[A, B, C, D, E, F](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F]) extends Group[(A, B, C, D, E, F)] { + * Combine 6 groups into a product group + */ +class Tuple6Group[A, B, C, D, E, F](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F]) extends Group[(A, B, C, D, E, F)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero) - override def negate(v : (A, B, C, D, E, F)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6)) - override def plus(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6)) - override def minus(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6)) + override def negate(v: (A, B, C, D, E, F)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6)) + override def plus(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6)) + override def minus(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6)) } /** -* Combine 6 rings into a product ring -*/ -class Tuple6Ring[A, B, C, D, E, F](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F]) extends Ring[(A, B, C, D, E, F)] { + * Combine 6 rings into a product ring + */ +class Tuple6Ring[A, B, C, D, E, F](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F]) extends Ring[(A, B, C, D, E, F)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one) - override def negate(v : (A, B, C, D, E, F)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6)) - override def plus(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6)) - override def minus(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6)) - override def times(l : (A, B, C, D, E, F), r : (A, B, C, D, E, F)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6)) + override def negate(v: (A, B, C, D, E, F)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6)) + override def plus(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6)) + override def minus(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6)) + override def times(l: (A, B, C, D, E, F), r: (A, B, C, D, E, F)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6)) } /** -* Combine 7 semigroups into a product semigroup -*/ -class Tuple7Semigroup[A, B, C, D, E, F, G](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G]) extends Semigroup[(A, B, C, D, E, F, G)] { - override def plus(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G)]) = { + * Combine 7 semigroups into a product semigroup + */ +class Tuple7Semigroup[A, B, C, D, E, F, G](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G]) extends Semigroup[(A, B, C, D, E, F, G)] { + override def plus(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G), (A, B, C, D, E, F, G)](1000) with BufferedReduce[(A, B, C, D, E, F, G)] { def operate(items: Seq[(A, B, C, D, E, F, G)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get) @@ -237,40 +237,40 @@ class Tuple7Semigroup[A, B, C, D, E, F, G](implicit asemigroup : Semigroup[A], b } /** -* Combine 7 monoids into a product monoid -*/ -class Tuple7Monoid[A, B, C, D, E, F, G](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G]) extends Monoid[(A, B, C, D, E, F, G)] { + * Combine 7 monoids into a product monoid + */ +class Tuple7Monoid[A, B, C, D, E, F, G](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G]) extends Monoid[(A, B, C, D, E, F, G)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7)) + override def plus(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7)) } /** -* Combine 7 groups into a product group -*/ -class Tuple7Group[A, B, C, D, E, F, G](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G]) extends Group[(A, B, C, D, E, F, G)] { + * Combine 7 groups into a product group + */ +class Tuple7Group[A, B, C, D, E, F, G](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G]) extends Group[(A, B, C, D, E, F, G)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero) - override def negate(v : (A, B, C, D, E, F, G)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7)) - override def plus(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7)) - override def minus(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7)) + override def negate(v: (A, B, C, D, E, F, G)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7)) + override def plus(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7)) + override def minus(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7)) } /** -* Combine 7 rings into a product ring -*/ -class Tuple7Ring[A, B, C, D, E, F, G](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G]) extends Ring[(A, B, C, D, E, F, G)] { + * Combine 7 rings into a product ring + */ +class Tuple7Ring[A, B, C, D, E, F, G](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G]) extends Ring[(A, B, C, D, E, F, G)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one) - override def negate(v : (A, B, C, D, E, F, G)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7)) - override def plus(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7)) - override def minus(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7)) - override def times(l : (A, B, C, D, E, F, G), r : (A, B, C, D, E, F, G)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7)) + override def negate(v: (A, B, C, D, E, F, G)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7)) + override def plus(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7)) + override def minus(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7)) + override def times(l: (A, B, C, D, E, F, G), r: (A, B, C, D, E, F, G)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7)) } /** -* Combine 8 semigroups into a product semigroup -*/ -class Tuple8Semigroup[A, B, C, D, E, F, G, H](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H]) extends Semigroup[(A, B, C, D, E, F, G, H)] { - override def plus(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H)]) = { + * Combine 8 semigroups into a product semigroup + */ +class Tuple8Semigroup[A, B, C, D, E, F, G, H](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H]) extends Semigroup[(A, B, C, D, E, F, G, H)] { + override def plus(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H), (A, B, C, D, E, F, G, H)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H)] { def operate(items: Seq[(A, B, C, D, E, F, G, H)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get) @@ -281,40 +281,40 @@ class Tuple8Semigroup[A, B, C, D, E, F, G, H](implicit asemigroup : Semigroup[A] } /** -* Combine 8 monoids into a product monoid -*/ -class Tuple8Monoid[A, B, C, D, E, F, G, H](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H]) extends Monoid[(A, B, C, D, E, F, G, H)] { + * Combine 8 monoids into a product monoid + */ +class Tuple8Monoid[A, B, C, D, E, F, G, H](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H]) extends Monoid[(A, B, C, D, E, F, G, H)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8)) + override def plus(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8)) } /** -* Combine 8 groups into a product group -*/ -class Tuple8Group[A, B, C, D, E, F, G, H](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H]) extends Group[(A, B, C, D, E, F, G, H)] { + * Combine 8 groups into a product group + */ +class Tuple8Group[A, B, C, D, E, F, G, H](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H]) extends Group[(A, B, C, D, E, F, G, H)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8)) - override def plus(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8)) - override def minus(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8)) + override def negate(v: (A, B, C, D, E, F, G, H)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8)) + override def plus(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8)) + override def minus(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8)) } /** -* Combine 8 rings into a product ring -*/ -class Tuple8Ring[A, B, C, D, E, F, G, H](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H]) extends Ring[(A, B, C, D, E, F, G, H)] { + * Combine 8 rings into a product ring + */ +class Tuple8Ring[A, B, C, D, E, F, G, H](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H]) extends Ring[(A, B, C, D, E, F, G, H)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one) - override def negate(v : (A, B, C, D, E, F, G, H)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8)) - override def plus(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8)) - override def minus(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8)) - override def times(l : (A, B, C, D, E, F, G, H), r : (A, B, C, D, E, F, G, H)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8)) + override def negate(v: (A, B, C, D, E, F, G, H)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8)) + override def plus(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8)) + override def minus(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8)) + override def times(l: (A, B, C, D, E, F, G, H), r: (A, B, C, D, E, F, G, H)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8)) } /** -* Combine 9 semigroups into a product semigroup -*/ -class Tuple9Semigroup[A, B, C, D, E, F, G, H, I](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I]) extends Semigroup[(A, B, C, D, E, F, G, H, I)] { - override def plus(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I)]) = { + * Combine 9 semigroups into a product semigroup + */ +class Tuple9Semigroup[A, B, C, D, E, F, G, H, I](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I]) extends Semigroup[(A, B, C, D, E, F, G, H, I)] { + override def plus(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I), (A, B, C, D, E, F, G, H, I)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get) @@ -325,40 +325,40 @@ class Tuple9Semigroup[A, B, C, D, E, F, G, H, I](implicit asemigroup : Semigroup } /** -* Combine 9 monoids into a product monoid -*/ -class Tuple9Monoid[A, B, C, D, E, F, G, H, I](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I]) extends Monoid[(A, B, C, D, E, F, G, H, I)] { + * Combine 9 monoids into a product monoid + */ +class Tuple9Monoid[A, B, C, D, E, F, G, H, I](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I]) extends Monoid[(A, B, C, D, E, F, G, H, I)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9)) + override def plus(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9)) } /** -* Combine 9 groups into a product group -*/ -class Tuple9Group[A, B, C, D, E, F, G, H, I](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I]) extends Group[(A, B, C, D, E, F, G, H, I)] { + * Combine 9 groups into a product group + */ +class Tuple9Group[A, B, C, D, E, F, G, H, I](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I]) extends Group[(A, B, C, D, E, F, G, H, I)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9)) - override def plus(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9)) - override def minus(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9)) + override def negate(v: (A, B, C, D, E, F, G, H, I)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9)) + override def plus(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9)) + override def minus(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9)) } /** -* Combine 9 rings into a product ring -*/ -class Tuple9Ring[A, B, C, D, E, F, G, H, I](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I]) extends Ring[(A, B, C, D, E, F, G, H, I)] { + * Combine 9 rings into a product ring + */ +class Tuple9Ring[A, B, C, D, E, F, G, H, I](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I]) extends Ring[(A, B, C, D, E, F, G, H, I)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9)) - override def plus(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9)) - override def minus(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9)) - override def times(l : (A, B, C, D, E, F, G, H, I), r : (A, B, C, D, E, F, G, H, I)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9)) + override def negate(v: (A, B, C, D, E, F, G, H, I)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9)) + override def plus(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9)) + override def minus(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9)) + override def times(l: (A, B, C, D, E, F, G, H, I), r: (A, B, C, D, E, F, G, H, I)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9)) } /** -* Combine 10 semigroups into a product semigroup -*/ -class Tuple10Semigroup[A, B, C, D, E, F, G, H, I, J](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J)]) = { + * Combine 10 semigroups into a product semigroup + */ +class Tuple10Semigroup[A, B, C, D, E, F, G, H, I, J](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J), (A, B, C, D, E, F, G, H, I, J)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get) @@ -369,40 +369,40 @@ class Tuple10Semigroup[A, B, C, D, E, F, G, H, I, J](implicit asemigroup : Semig } /** -* Combine 10 monoids into a product monoid -*/ -class Tuple10Monoid[A, B, C, D, E, F, G, H, I, J](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J]) extends Monoid[(A, B, C, D, E, F, G, H, I, J)] { + * Combine 10 monoids into a product monoid + */ +class Tuple10Monoid[A, B, C, D, E, F, G, H, I, J](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J]) extends Monoid[(A, B, C, D, E, F, G, H, I, J)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10)) } /** -* Combine 10 groups into a product group -*/ -class Tuple10Group[A, B, C, D, E, F, G, H, I, J](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J]) extends Group[(A, B, C, D, E, F, G, H, I, J)] { + * Combine 10 groups into a product group + */ +class Tuple10Group[A, B, C, D, E, F, G, H, I, J](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J]) extends Group[(A, B, C, D, E, F, G, H, I, J)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10)) } /** -* Combine 10 rings into a product ring -*/ -class Tuple10Ring[A, B, C, D, E, F, G, H, I, J](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J]) extends Ring[(A, B, C, D, E, F, G, H, I, J)] { + * Combine 10 rings into a product ring + */ +class Tuple10Ring[A, B, C, D, E, F, G, H, I, J](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J]) extends Ring[(A, B, C, D, E, F, G, H, I, J)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10)) - override def times(l : (A, B, C, D, E, F, G, H, I, J), r : (A, B, C, D, E, F, G, H, I, J)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10)) + override def times(l: (A, B, C, D, E, F, G, H, I, J), r: (A, B, C, D, E, F, G, H, I, J)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10)) } /** -* Combine 11 semigroups into a product semigroup -*/ -class Tuple11Semigroup[A, B, C, D, E, F, G, H, I, J, K](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K)]) = { + * Combine 11 semigroups into a product semigroup + */ +class Tuple11Semigroup[A, B, C, D, E, F, G, H, I, J, K](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K), (A, B, C, D, E, F, G, H, I, J, K)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get) @@ -413,40 +413,40 @@ class Tuple11Semigroup[A, B, C, D, E, F, G, H, I, J, K](implicit asemigroup : Se } /** -* Combine 11 monoids into a product monoid -*/ -class Tuple11Monoid[A, B, C, D, E, F, G, H, I, J, K](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K)] { + * Combine 11 monoids into a product monoid + */ +class Tuple11Monoid[A, B, C, D, E, F, G, H, I, J, K](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11)) } /** -* Combine 11 groups into a product group -*/ -class Tuple11Group[A, B, C, D, E, F, G, H, I, J, K](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K]) extends Group[(A, B, C, D, E, F, G, H, I, J, K)] { + * Combine 11 groups into a product group + */ +class Tuple11Group[A, B, C, D, E, F, G, H, I, J, K](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K]) extends Group[(A, B, C, D, E, F, G, H, I, J, K)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11)) } /** -* Combine 11 rings into a product ring -*/ -class Tuple11Ring[A, B, C, D, E, F, G, H, I, J, K](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K)] { + * Combine 11 rings into a product ring + */ +class Tuple11Ring[A, B, C, D, E, F, G, H, I, J, K](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K), r : (A, B, C, D, E, F, G, H, I, J, K)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K), r: (A, B, C, D, E, F, G, H, I, J, K)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11)) } /** -* Combine 12 semigroups into a product semigroup -*/ -class Tuple12Semigroup[A, B, C, D, E, F, G, H, I, J, K, L](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L)]) = { + * Combine 12 semigroups into a product semigroup + */ +class Tuple12Semigroup[A, B, C, D, E, F, G, H, I, J, K, L](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L), (A, B, C, D, E, F, G, H, I, J, K, L)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get) @@ -457,40 +457,40 @@ class Tuple12Semigroup[A, B, C, D, E, F, G, H, I, J, K, L](implicit asemigroup : } /** -* Combine 12 monoids into a product monoid -*/ -class Tuple12Monoid[A, B, C, D, E, F, G, H, I, J, K, L](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L)] { + * Combine 12 monoids into a product monoid + */ +class Tuple12Monoid[A, B, C, D, E, F, G, H, I, J, K, L](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12)) } /** -* Combine 12 groups into a product group -*/ -class Tuple12Group[A, B, C, D, E, F, G, H, I, J, K, L](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L)] { + * Combine 12 groups into a product group + */ +class Tuple12Group[A, B, C, D, E, F, G, H, I, J, K, L](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12)) } /** -* Combine 12 rings into a product ring -*/ -class Tuple12Ring[A, B, C, D, E, F, G, H, I, J, K, L](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L)] { + * Combine 12 rings into a product ring + */ +class Tuple12Ring[A, B, C, D, E, F, G, H, I, J, K, L](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L), r : (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L), r: (A, B, C, D, E, F, G, H, I, J, K, L)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12)) } /** -* Combine 13 semigroups into a product semigroup -*/ -class Tuple13Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M)]) = { + * Combine 13 semigroups into a product semigroup + */ +class Tuple13Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M), (A, B, C, D, E, F, G, H, I, J, K, L, M)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get) @@ -501,40 +501,40 @@ class Tuple13Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit asemigrou } /** -* Combine 13 monoids into a product monoid -*/ -class Tuple13Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { + * Combine 13 monoids into a product monoid + */ +class Tuple13Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13)) } /** -* Combine 13 groups into a product group -*/ -class Tuple13Group[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { + * Combine 13 groups into a product group + */ +class Tuple13Group[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13)) } /** -* Combine 13 rings into a product ring -*/ -class Tuple13Ring[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { + * Combine 13 rings into a product ring + */ +class Tuple13Ring[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M), r : (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M), r: (A, B, C, D, E, F, G, H, I, J, K, L, M)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13)) } /** -* Combine 14 semigroups into a product semigroup -*/ -class Tuple14Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]) = { + * Combine 14 semigroups into a product semigroup + */ +class Tuple14Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N), (A, B, C, D, E, F, G, H, I, J, K, L, M, N)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get) @@ -545,40 +545,40 @@ class Tuple14Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit asemig } /** -* Combine 14 monoids into a product monoid -*/ -class Tuple14Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { + * Combine 14 monoids into a product monoid + */ +class Tuple14Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14)) } /** -* Combine 14 groups into a product group -*/ -class Tuple14Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { + * Combine 14 groups into a product group + */ +class Tuple14Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14)) } /** -* Combine 14 rings into a product ring -*/ -class Tuple14Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { + * Combine 14 rings into a product ring + */ +class Tuple14Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14)) } /** -* Combine 15 semigroups into a product semigroup -*/ -class Tuple15Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]) = { + * Combine 15 semigroups into a product semigroup + */ +class Tuple15Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get) @@ -589,40 +589,40 @@ class Tuple15Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit ase } /** -* Combine 15 monoids into a product monoid -*/ -class Tuple15Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { + * Combine 15 monoids into a product monoid + */ +class Tuple15Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15)) } /** -* Combine 15 groups into a product group -*/ -class Tuple15Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { + * Combine 15 groups into a product group + */ +class Tuple15Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15)) } /** -* Combine 15 rings into a product ring -*/ -class Tuple15Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { + * Combine 15 rings into a product ring + */ +class Tuple15Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15)) } /** -* Combine 16 semigroups into a product semigroup -*/ -class Tuple16Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]) = { + * Combine 16 semigroups into a product semigroup + */ +class Tuple16Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get) @@ -633,40 +633,40 @@ class Tuple16Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit } /** -* Combine 16 monoids into a product monoid -*/ -class Tuple16Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { + * Combine 16 monoids into a product monoid + */ +class Tuple16Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16)) } /** -* Combine 16 groups into a product group -*/ -class Tuple16Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { + * Combine 16 groups into a product group + */ +class Tuple16Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16)) } /** -* Combine 16 rings into a product ring -*/ -class Tuple16Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { + * Combine 16 rings into a product ring + */ +class Tuple16Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16)) } /** -* Combine 17 semigroups into a product semigroup -*/ -class Tuple17Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]) = { + * Combine 17 semigroups into a product semigroup + */ +class Tuple17Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get, qsemigroup.sumOption(items.iterator.map(_._17)).get) @@ -677,40 +677,40 @@ class Tuple17Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implic } /** -* Combine 17 monoids into a product monoid -*/ -class Tuple17Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { + * Combine 17 monoids into a product monoid + */ +class Tuple17Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17)) } /** -* Combine 17 groups into a product group -*/ -class Tuple17Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { + * Combine 17 groups into a product group + */ +class Tuple17Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17)) } /** -* Combine 17 rings into a product ring -*/ -class Tuple17Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { + * Combine 17 rings into a product ring + */ +class Tuple17Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17)) } /** -* Combine 18 semigroups into a product semigroup -*/ -class Tuple18Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]) = { + * Combine 18 semigroups into a product semigroup + */ +class Tuple18Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get, qsemigroup.sumOption(items.iterator.map(_._17)).get, rsemigroup.sumOption(items.iterator.map(_._18)).get) @@ -721,40 +721,40 @@ class Tuple18Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](imp } /** -* Combine 18 monoids into a product monoid -*/ -class Tuple18Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { + * Combine 18 monoids into a product monoid + */ +class Tuple18Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18)) } /** -* Combine 18 groups into a product group -*/ -class Tuple18Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { + * Combine 18 groups into a product group + */ +class Tuple18Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18)) } /** -* Combine 18 rings into a product ring -*/ -class Tuple18Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { + * Combine 18 rings into a product ring + */ +class Tuple18Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18)) } /** -* Combine 19 semigroups into a product semigroup -*/ -class Tuple19Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]) = { + * Combine 19 semigroups into a product semigroup + */ +class Tuple19Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get, qsemigroup.sumOption(items.iterator.map(_._17)).get, rsemigroup.sumOption(items.iterator.map(_._18)).get, ssemigroup.sumOption(items.iterator.map(_._19)).get) @@ -765,40 +765,40 @@ class Tuple19Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]( } /** -* Combine 19 monoids into a product monoid -*/ -class Tuple19Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { + * Combine 19 monoids into a product monoid + */ +class Tuple19Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19)) } /** -* Combine 19 groups into a product group -*/ -class Tuple19Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { + * Combine 19 groups into a product group + */ +class Tuple19Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19)) } /** -* Combine 19 rings into a product ring -*/ -class Tuple19Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { + * Combine 19 rings into a product ring + */ +class Tuple19Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19)) } /** -* Combine 20 semigroups into a product semigroup -*/ -class Tuple20Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19), tsemigroup.plus(l._20, r._20)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]) = { + * Combine 20 semigroups into a product semigroup + */ +class Tuple20Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19), tsemigroup.plus(l._20, r._20)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get, qsemigroup.sumOption(items.iterator.map(_._17)).get, rsemigroup.sumOption(items.iterator.map(_._18)).get, ssemigroup.sumOption(items.iterator.map(_._19)).get, tsemigroup.sumOption(items.iterator.map(_._20)).get) @@ -809,40 +809,40 @@ class Tuple20Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, } /** -* Combine 20 monoids into a product monoid -*/ -class Tuple20Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { + * Combine 20 monoids into a product monoid + */ +class Tuple20Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero, tmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19), tmonoid.plus(l._20, r._20)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19), tmonoid.plus(l._20, r._20)) } /** -* Combine 20 groups into a product group -*/ -class Tuple20Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { + * Combine 20 groups into a product group + */ +class Tuple20Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero, tgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19), tgroup.negate(v._20)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19), tgroup.plus(l._20, r._20)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19), tgroup.minus(l._20, r._20)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19), tgroup.negate(v._20)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19), tgroup.plus(l._20, r._20)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19), tgroup.minus(l._20, r._20)) } /** -* Combine 20 rings into a product ring -*/ -class Tuple20Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { + * Combine 20 rings into a product ring + */ +class Tuple20Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero, tring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one, tring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19), tring.negate(v._20)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19), tring.plus(l._20, r._20)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19), tring.minus(l._20, r._20)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19), tring.times(l._20, r._20)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19), tring.negate(v._20)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19), tring.plus(l._20, r._20)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19), tring.minus(l._20, r._20)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19), tring.times(l._20, r._20)) } /** -* Combine 21 semigroups into a product semigroup -*/ -class Tuple21Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19), tsemigroup.plus(l._20, r._20), usemigroup.plus(l._21, r._21)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]) = { + * Combine 21 semigroups into a product semigroup + */ +class Tuple21Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19), tsemigroup.plus(l._20, r._20), usemigroup.plus(l._21, r._21)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get, qsemigroup.sumOption(items.iterator.map(_._17)).get, rsemigroup.sumOption(items.iterator.map(_._18)).get, ssemigroup.sumOption(items.iterator.map(_._19)).get, tsemigroup.sumOption(items.iterator.map(_._20)).get, usemigroup.sumOption(items.iterator.map(_._21)).get) @@ -853,40 +853,40 @@ class Tuple21Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, } /** -* Combine 21 monoids into a product monoid -*/ -class Tuple21Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { + * Combine 21 monoids into a product monoid + */ +class Tuple21Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero, tmonoid.zero, umonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19), tmonoid.plus(l._20, r._20), umonoid.plus(l._21, r._21)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19), tmonoid.plus(l._20, r._20), umonoid.plus(l._21, r._21)) } /** -* Combine 21 groups into a product group -*/ -class Tuple21Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { + * Combine 21 groups into a product group + */ +class Tuple21Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero, tgroup.zero, ugroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19), tgroup.negate(v._20), ugroup.negate(v._21)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19), tgroup.plus(l._20, r._20), ugroup.plus(l._21, r._21)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19), tgroup.minus(l._20, r._20), ugroup.minus(l._21, r._21)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19), tgroup.negate(v._20), ugroup.negate(v._21)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19), tgroup.plus(l._20, r._20), ugroup.plus(l._21, r._21)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19), tgroup.minus(l._20, r._20), ugroup.minus(l._21, r._21)) } /** -* Combine 21 rings into a product ring -*/ -class Tuple21Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { + * Combine 21 rings into a product ring + */ +class Tuple21Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero, tring.zero, uring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one, tring.one, uring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19), tring.negate(v._20), uring.negate(v._21)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19), tring.plus(l._20, r._20), uring.plus(l._21, r._21)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19), tring.minus(l._20, r._20), uring.minus(l._21, r._21)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19), tring.times(l._20, r._20), uring.times(l._21, r._21)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19), tring.negate(v._20), uring.negate(v._21)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19), tring.plus(l._20, r._20), uring.plus(l._21, r._21)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19), tring.minus(l._20, r._20), uring.minus(l._21, r._21)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19), tring.times(l._20, r._20), uring.times(l._21, r._21)) } /** -* Combine 22 semigroups into a product semigroup -*/ -class Tuple22Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U], vsemigroup : Semigroup[V]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19), tsemigroup.plus(l._20, r._20), usemigroup.plus(l._21, r._21), vsemigroup.plus(l._22, r._22)) - override def sumOption(to : TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]) = { + * Combine 22 semigroups into a product semigroup + */ +class Tuple22Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U], vsemigroup: Semigroup[V]) extends Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (asemigroup.plus(l._1, r._1), bsemigroup.plus(l._2, r._2), csemigroup.plus(l._3, r._3), dsemigroup.plus(l._4, r._4), esemigroup.plus(l._5, r._5), fsemigroup.plus(l._6, r._6), gsemigroup.plus(l._7, r._7), hsemigroup.plus(l._8, r._8), isemigroup.plus(l._9, r._9), jsemigroup.plus(l._10, r._10), ksemigroup.plus(l._11, r._11), lsemigroup.plus(l._12, r._12), msemigroup.plus(l._13, r._13), nsemigroup.plus(l._14, r._14), osemigroup.plus(l._15, r._15), psemigroup.plus(l._16, r._16), qsemigroup.plus(l._17, r._17), rsemigroup.plus(l._18, r._18), ssemigroup.plus(l._19, r._19), tsemigroup.plus(l._20, r._20), usemigroup.plus(l._21, r._21), vsemigroup.plus(l._22, r._22)) + override def sumOption(to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]) = { val buf = new ArrayBufferedOperation[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)](1000) with BufferedReduce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { def operate(items: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]) = (asemigroup.sumOption(items.iterator.map(_._1)).get, bsemigroup.sumOption(items.iterator.map(_._2)).get, csemigroup.sumOption(items.iterator.map(_._3)).get, dsemigroup.sumOption(items.iterator.map(_._4)).get, esemigroup.sumOption(items.iterator.map(_._5)).get, fsemigroup.sumOption(items.iterator.map(_._6)).get, gsemigroup.sumOption(items.iterator.map(_._7)).get, hsemigroup.sumOption(items.iterator.map(_._8)).get, isemigroup.sumOption(items.iterator.map(_._9)).get, jsemigroup.sumOption(items.iterator.map(_._10)).get, ksemigroup.sumOption(items.iterator.map(_._11)).get, lsemigroup.sumOption(items.iterator.map(_._12)).get, msemigroup.sumOption(items.iterator.map(_._13)).get, nsemigroup.sumOption(items.iterator.map(_._14)).get, osemigroup.sumOption(items.iterator.map(_._15)).get, psemigroup.sumOption(items.iterator.map(_._16)).get, qsemigroup.sumOption(items.iterator.map(_._17)).get, rsemigroup.sumOption(items.iterator.map(_._18)).get, ssemigroup.sumOption(items.iterator.map(_._19)).get, tsemigroup.sumOption(items.iterator.map(_._20)).get, usemigroup.sumOption(items.iterator.map(_._21)).get, vsemigroup.sumOption(items.iterator.map(_._22)).get) @@ -897,378 +897,378 @@ class Tuple22Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, } /** -* Combine 22 monoids into a product monoid -*/ -class Tuple22Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U], vmonoid : Monoid[V]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { + * Combine 22 monoids into a product monoid + */ +class Tuple22Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U], vmonoid: Monoid[V]) extends Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { override def zero = (amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero, tmonoid.zero, umonoid.zero, vmonoid.zero) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19), tmonoid.plus(l._20, r._20), umonoid.plus(l._21, r._21), vmonoid.plus(l._22, r._22)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (amonoid.plus(l._1, r._1), bmonoid.plus(l._2, r._2), cmonoid.plus(l._3, r._3), dmonoid.plus(l._4, r._4), emonoid.plus(l._5, r._5), fmonoid.plus(l._6, r._6), gmonoid.plus(l._7, r._7), hmonoid.plus(l._8, r._8), imonoid.plus(l._9, r._9), jmonoid.plus(l._10, r._10), kmonoid.plus(l._11, r._11), lmonoid.plus(l._12, r._12), mmonoid.plus(l._13, r._13), nmonoid.plus(l._14, r._14), omonoid.plus(l._15, r._15), pmonoid.plus(l._16, r._16), qmonoid.plus(l._17, r._17), rmonoid.plus(l._18, r._18), smonoid.plus(l._19, r._19), tmonoid.plus(l._20, r._20), umonoid.plus(l._21, r._21), vmonoid.plus(l._22, r._22)) } /** -* Combine 22 groups into a product group -*/ -class Tuple22Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U], vgroup : Group[V]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { + * Combine 22 groups into a product group + */ +class Tuple22Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U], vgroup: Group[V]) extends Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { override def zero = (agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero, tgroup.zero, ugroup.zero, vgroup.zero) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19), tgroup.negate(v._20), ugroup.negate(v._21), vgroup.negate(v._22)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19), tgroup.plus(l._20, r._20), ugroup.plus(l._21, r._21), vgroup.plus(l._22, r._22)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19), tgroup.minus(l._20, r._20), ugroup.minus(l._21, r._21), vgroup.minus(l._22, r._22)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (agroup.negate(v._1), bgroup.negate(v._2), cgroup.negate(v._3), dgroup.negate(v._4), egroup.negate(v._5), fgroup.negate(v._6), ggroup.negate(v._7), hgroup.negate(v._8), igroup.negate(v._9), jgroup.negate(v._10), kgroup.negate(v._11), lgroup.negate(v._12), mgroup.negate(v._13), ngroup.negate(v._14), ogroup.negate(v._15), pgroup.negate(v._16), qgroup.negate(v._17), rgroup.negate(v._18), sgroup.negate(v._19), tgroup.negate(v._20), ugroup.negate(v._21), vgroup.negate(v._22)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (agroup.plus(l._1, r._1), bgroup.plus(l._2, r._2), cgroup.plus(l._3, r._3), dgroup.plus(l._4, r._4), egroup.plus(l._5, r._5), fgroup.plus(l._6, r._6), ggroup.plus(l._7, r._7), hgroup.plus(l._8, r._8), igroup.plus(l._9, r._9), jgroup.plus(l._10, r._10), kgroup.plus(l._11, r._11), lgroup.plus(l._12, r._12), mgroup.plus(l._13, r._13), ngroup.plus(l._14, r._14), ogroup.plus(l._15, r._15), pgroup.plus(l._16, r._16), qgroup.plus(l._17, r._17), rgroup.plus(l._18, r._18), sgroup.plus(l._19, r._19), tgroup.plus(l._20, r._20), ugroup.plus(l._21, r._21), vgroup.plus(l._22, r._22)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (agroup.minus(l._1, r._1), bgroup.minus(l._2, r._2), cgroup.minus(l._3, r._3), dgroup.minus(l._4, r._4), egroup.minus(l._5, r._5), fgroup.minus(l._6, r._6), ggroup.minus(l._7, r._7), hgroup.minus(l._8, r._8), igroup.minus(l._9, r._9), jgroup.minus(l._10, r._10), kgroup.minus(l._11, r._11), lgroup.minus(l._12, r._12), mgroup.minus(l._13, r._13), ngroup.minus(l._14, r._14), ogroup.minus(l._15, r._15), pgroup.minus(l._16, r._16), qgroup.minus(l._17, r._17), rgroup.minus(l._18, r._18), sgroup.minus(l._19, r._19), tgroup.minus(l._20, r._20), ugroup.minus(l._21, r._21), vgroup.minus(l._22, r._22)) } /** -* Combine 22 rings into a product ring -*/ -class Tuple22Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U], vring : Ring[V]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { + * Combine 22 rings into a product ring + */ +class Tuple22Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U], vring: Ring[V]) extends Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] { override def zero = (aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero, tring.zero, uring.zero, vring.zero) override def one = (aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one, tring.one, uring.one, vring.one) - override def negate(v : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19), tring.negate(v._20), uring.negate(v._21), vring.negate(v._22)) - override def plus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19), tring.plus(l._20, r._20), uring.plus(l._21, r._21), vring.plus(l._22, r._22)) - override def minus(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19), tring.minus(l._20, r._20), uring.minus(l._21, r._21), vring.minus(l._22, r._22)) - override def times(l : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r : (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19), tring.times(l._20, r._20), uring.times(l._21, r._21), vring.times(l._22, r._22)) + override def negate(v: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.negate(v._1), bring.negate(v._2), cring.negate(v._3), dring.negate(v._4), ering.negate(v._5), fring.negate(v._6), gring.negate(v._7), hring.negate(v._8), iring.negate(v._9), jring.negate(v._10), kring.negate(v._11), lring.negate(v._12), mring.negate(v._13), nring.negate(v._14), oring.negate(v._15), pring.negate(v._16), qring.negate(v._17), rring.negate(v._18), sring.negate(v._19), tring.negate(v._20), uring.negate(v._21), vring.negate(v._22)) + override def plus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.plus(l._1, r._1), bring.plus(l._2, r._2), cring.plus(l._3, r._3), dring.plus(l._4, r._4), ering.plus(l._5, r._5), fring.plus(l._6, r._6), gring.plus(l._7, r._7), hring.plus(l._8, r._8), iring.plus(l._9, r._9), jring.plus(l._10, r._10), kring.plus(l._11, r._11), lring.plus(l._12, r._12), mring.plus(l._13, r._13), nring.plus(l._14, r._14), oring.plus(l._15, r._15), pring.plus(l._16, r._16), qring.plus(l._17, r._17), rring.plus(l._18, r._18), sring.plus(l._19, r._19), tring.plus(l._20, r._20), uring.plus(l._21, r._21), vring.plus(l._22, r._22)) + override def minus(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.minus(l._1, r._1), bring.minus(l._2, r._2), cring.minus(l._3, r._3), dring.minus(l._4, r._4), ering.minus(l._5, r._5), fring.minus(l._6, r._6), gring.minus(l._7, r._7), hring.minus(l._8, r._8), iring.minus(l._9, r._9), jring.minus(l._10, r._10), kring.minus(l._11, r._11), lring.minus(l._12, r._12), mring.minus(l._13, r._13), nring.minus(l._14, r._14), oring.minus(l._15, r._15), pring.minus(l._16, r._16), qring.minus(l._17, r._17), rring.minus(l._18, r._18), sring.minus(l._19, r._19), tring.minus(l._20, r._20), uring.minus(l._21, r._21), vring.minus(l._22, r._22)) + override def times(l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)) = (aring.times(l._1, r._1), bring.times(l._2, r._2), cring.times(l._3, r._3), dring.times(l._4, r._4), ering.times(l._5, r._5), fring.times(l._6, r._6), gring.times(l._7, r._7), hring.times(l._8, r._8), iring.times(l._9, r._9), jring.times(l._10, r._10), kring.times(l._11, r._11), lring.times(l._12, r._12), mring.times(l._13, r._13), nring.times(l._14, r._14), oring.times(l._15, r._15), pring.times(l._16, r._16), qring.times(l._17, r._17), rring.times(l._18, r._18), sring.times(l._19, r._19), tring.times(l._20, r._20), uring.times(l._21, r._21), vring.times(l._22, r._22)) } trait GeneratedSemigroupImplicits { - implicit def semigroup2[A, B](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B]) : Semigroup[(A, B)] = { + implicit def semigroup2[A, B](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B]): Semigroup[(A, B)] = { new Tuple2Semigroup[A, B]()(asemigroup, bsemigroup) } - implicit def semigroup3[A, B, C](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C]) : Semigroup[(A, B, C)] = { + implicit def semigroup3[A, B, C](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C]): Semigroup[(A, B, C)] = { new Tuple3Semigroup[A, B, C]()(asemigroup, bsemigroup, csemigroup) } - implicit def semigroup4[A, B, C, D](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D]) : Semigroup[(A, B, C, D)] = { + implicit def semigroup4[A, B, C, D](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D]): Semigroup[(A, B, C, D)] = { new Tuple4Semigroup[A, B, C, D]()(asemigroup, bsemigroup, csemigroup, dsemigroup) } - implicit def semigroup5[A, B, C, D, E](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E]) : Semigroup[(A, B, C, D, E)] = { + implicit def semigroup5[A, B, C, D, E](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E]): Semigroup[(A, B, C, D, E)] = { new Tuple5Semigroup[A, B, C, D, E]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup) } - implicit def semigroup6[A, B, C, D, E, F](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F]) : Semigroup[(A, B, C, D, E, F)] = { + implicit def semigroup6[A, B, C, D, E, F](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F]): Semigroup[(A, B, C, D, E, F)] = { new Tuple6Semigroup[A, B, C, D, E, F]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup) } - implicit def semigroup7[A, B, C, D, E, F, G](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G]) : Semigroup[(A, B, C, D, E, F, G)] = { + implicit def semigroup7[A, B, C, D, E, F, G](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G]): Semigroup[(A, B, C, D, E, F, G)] = { new Tuple7Semigroup[A, B, C, D, E, F, G]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup) } - implicit def semigroup8[A, B, C, D, E, F, G, H](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H]) : Semigroup[(A, B, C, D, E, F, G, H)] = { + implicit def semigroup8[A, B, C, D, E, F, G, H](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H]): Semigroup[(A, B, C, D, E, F, G, H)] = { new Tuple8Semigroup[A, B, C, D, E, F, G, H]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup) } - implicit def semigroup9[A, B, C, D, E, F, G, H, I](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I]) : Semigroup[(A, B, C, D, E, F, G, H, I)] = { + implicit def semigroup9[A, B, C, D, E, F, G, H, I](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I]): Semigroup[(A, B, C, D, E, F, G, H, I)] = { new Tuple9Semigroup[A, B, C, D, E, F, G, H, I]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup) } - implicit def semigroup10[A, B, C, D, E, F, G, H, I, J](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J]) : Semigroup[(A, B, C, D, E, F, G, H, I, J)] = { + implicit def semigroup10[A, B, C, D, E, F, G, H, I, J](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J]): Semigroup[(A, B, C, D, E, F, G, H, I, J)] = { new Tuple10Semigroup[A, B, C, D, E, F, G, H, I, J]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup) } - implicit def semigroup11[A, B, C, D, E, F, G, H, I, J, K](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K)] = { + implicit def semigroup11[A, B, C, D, E, F, G, H, I, J, K](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K)] = { new Tuple11Semigroup[A, B, C, D, E, F, G, H, I, J, K]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup) } - implicit def semigroup12[A, B, C, D, E, F, G, H, I, J, K, L](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L)] = { + implicit def semigroup12[A, B, C, D, E, F, G, H, I, J, K, L](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L)] = { new Tuple12Semigroup[A, B, C, D, E, F, G, H, I, J, K, L]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup) } - implicit def semigroup13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { + implicit def semigroup13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { new Tuple13Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup) } - implicit def semigroup14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { + implicit def semigroup14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { new Tuple14Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup) } - implicit def semigroup15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { + implicit def semigroup15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { new Tuple15Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup) } - implicit def semigroup16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { + implicit def semigroup16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { new Tuple16Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup) } - implicit def semigroup17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { + implicit def semigroup17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { new Tuple17Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup) } - implicit def semigroup18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { + implicit def semigroup18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { new Tuple18Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup) } - implicit def semigroup19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { + implicit def semigroup19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { new Tuple19Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup) } - implicit def semigroup20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { + implicit def semigroup20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { new Tuple20Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup, tsemigroup) } - implicit def semigroup21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { + implicit def semigroup21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { new Tuple21Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup, tsemigroup, usemigroup) } - implicit def semigroup22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U], vsemigroup : Semigroup[V]) : Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { + implicit def semigroup22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U], vsemigroup: Semigroup[V]): Semigroup[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { new Tuple22Semigroup[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]()(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup, tsemigroup, usemigroup, vsemigroup) } } trait GeneratedMonoidImplicits { - implicit def monoid2[A, B](implicit amonoid : Monoid[A], bmonoid : Monoid[B]) : Monoid[(A, B)] = { + implicit def monoid2[A, B](implicit amonoid: Monoid[A], bmonoid: Monoid[B]): Monoid[(A, B)] = { new Tuple2Monoid[A, B]()(amonoid, bmonoid) } - implicit def monoid3[A, B, C](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C]) : Monoid[(A, B, C)] = { + implicit def monoid3[A, B, C](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C]): Monoid[(A, B, C)] = { new Tuple3Monoid[A, B, C]()(amonoid, bmonoid, cmonoid) } - implicit def monoid4[A, B, C, D](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D]) : Monoid[(A, B, C, D)] = { + implicit def monoid4[A, B, C, D](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D]): Monoid[(A, B, C, D)] = { new Tuple4Monoid[A, B, C, D]()(amonoid, bmonoid, cmonoid, dmonoid) } - implicit def monoid5[A, B, C, D, E](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E]) : Monoid[(A, B, C, D, E)] = { + implicit def monoid5[A, B, C, D, E](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E]): Monoid[(A, B, C, D, E)] = { new Tuple5Monoid[A, B, C, D, E]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid) } - implicit def monoid6[A, B, C, D, E, F](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F]) : Monoid[(A, B, C, D, E, F)] = { + implicit def monoid6[A, B, C, D, E, F](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F]): Monoid[(A, B, C, D, E, F)] = { new Tuple6Monoid[A, B, C, D, E, F]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid) } - implicit def monoid7[A, B, C, D, E, F, G](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G]) : Monoid[(A, B, C, D, E, F, G)] = { + implicit def monoid7[A, B, C, D, E, F, G](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G]): Monoid[(A, B, C, D, E, F, G)] = { new Tuple7Monoid[A, B, C, D, E, F, G]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid) } - implicit def monoid8[A, B, C, D, E, F, G, H](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H]) : Monoid[(A, B, C, D, E, F, G, H)] = { + implicit def monoid8[A, B, C, D, E, F, G, H](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H]): Monoid[(A, B, C, D, E, F, G, H)] = { new Tuple8Monoid[A, B, C, D, E, F, G, H]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid) } - implicit def monoid9[A, B, C, D, E, F, G, H, I](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I]) : Monoid[(A, B, C, D, E, F, G, H, I)] = { + implicit def monoid9[A, B, C, D, E, F, G, H, I](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I]): Monoid[(A, B, C, D, E, F, G, H, I)] = { new Tuple9Monoid[A, B, C, D, E, F, G, H, I]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid) } - implicit def monoid10[A, B, C, D, E, F, G, H, I, J](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J]) : Monoid[(A, B, C, D, E, F, G, H, I, J)] = { + implicit def monoid10[A, B, C, D, E, F, G, H, I, J](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J]): Monoid[(A, B, C, D, E, F, G, H, I, J)] = { new Tuple10Monoid[A, B, C, D, E, F, G, H, I, J]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid) } - implicit def monoid11[A, B, C, D, E, F, G, H, I, J, K](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K)] = { + implicit def monoid11[A, B, C, D, E, F, G, H, I, J, K](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K]): Monoid[(A, B, C, D, E, F, G, H, I, J, K)] = { new Tuple11Monoid[A, B, C, D, E, F, G, H, I, J, K]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid) } - implicit def monoid12[A, B, C, D, E, F, G, H, I, J, K, L](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L)] = { + implicit def monoid12[A, B, C, D, E, F, G, H, I, J, K, L](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L)] = { new Tuple12Monoid[A, B, C, D, E, F, G, H, I, J, K, L]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid) } - implicit def monoid13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { + implicit def monoid13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { new Tuple13Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid) } - implicit def monoid14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { + implicit def monoid14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { new Tuple14Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid) } - implicit def monoid15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { + implicit def monoid15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { new Tuple15Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid) } - implicit def monoid16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { + implicit def monoid16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { new Tuple16Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid) } - implicit def monoid17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { + implicit def monoid17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { new Tuple17Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid) } - implicit def monoid18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { + implicit def monoid18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { new Tuple18Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid) } - implicit def monoid19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { + implicit def monoid19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { new Tuple19Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid) } - implicit def monoid20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { + implicit def monoid20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { new Tuple20Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid, tmonoid) } - implicit def monoid21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { + implicit def monoid21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { new Tuple21Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid, tmonoid, umonoid) } - implicit def monoid22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U], vmonoid : Monoid[V]) : Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { + implicit def monoid22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U], vmonoid: Monoid[V]): Monoid[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { new Tuple22Monoid[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]()(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid, tmonoid, umonoid, vmonoid) } } trait GeneratedGroupImplicits { - implicit def group2[A, B](implicit agroup : Group[A], bgroup : Group[B]) : Group[(A, B)] = { + implicit def group2[A, B](implicit agroup: Group[A], bgroup: Group[B]): Group[(A, B)] = { new Tuple2Group[A, B]()(agroup, bgroup) } - implicit def group3[A, B, C](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C]) : Group[(A, B, C)] = { + implicit def group3[A, B, C](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C]): Group[(A, B, C)] = { new Tuple3Group[A, B, C]()(agroup, bgroup, cgroup) } - implicit def group4[A, B, C, D](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D]) : Group[(A, B, C, D)] = { + implicit def group4[A, B, C, D](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D]): Group[(A, B, C, D)] = { new Tuple4Group[A, B, C, D]()(agroup, bgroup, cgroup, dgroup) } - implicit def group5[A, B, C, D, E](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E]) : Group[(A, B, C, D, E)] = { + implicit def group5[A, B, C, D, E](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E]): Group[(A, B, C, D, E)] = { new Tuple5Group[A, B, C, D, E]()(agroup, bgroup, cgroup, dgroup, egroup) } - implicit def group6[A, B, C, D, E, F](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F]) : Group[(A, B, C, D, E, F)] = { + implicit def group6[A, B, C, D, E, F](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F]): Group[(A, B, C, D, E, F)] = { new Tuple6Group[A, B, C, D, E, F]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup) } - implicit def group7[A, B, C, D, E, F, G](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G]) : Group[(A, B, C, D, E, F, G)] = { + implicit def group7[A, B, C, D, E, F, G](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G]): Group[(A, B, C, D, E, F, G)] = { new Tuple7Group[A, B, C, D, E, F, G]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup) } - implicit def group8[A, B, C, D, E, F, G, H](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H]) : Group[(A, B, C, D, E, F, G, H)] = { + implicit def group8[A, B, C, D, E, F, G, H](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H]): Group[(A, B, C, D, E, F, G, H)] = { new Tuple8Group[A, B, C, D, E, F, G, H]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup) } - implicit def group9[A, B, C, D, E, F, G, H, I](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I]) : Group[(A, B, C, D, E, F, G, H, I)] = { + implicit def group9[A, B, C, D, E, F, G, H, I](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I]): Group[(A, B, C, D, E, F, G, H, I)] = { new Tuple9Group[A, B, C, D, E, F, G, H, I]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup) } - implicit def group10[A, B, C, D, E, F, G, H, I, J](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J]) : Group[(A, B, C, D, E, F, G, H, I, J)] = { + implicit def group10[A, B, C, D, E, F, G, H, I, J](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J]): Group[(A, B, C, D, E, F, G, H, I, J)] = { new Tuple10Group[A, B, C, D, E, F, G, H, I, J]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup) } - implicit def group11[A, B, C, D, E, F, G, H, I, J, K](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K]) : Group[(A, B, C, D, E, F, G, H, I, J, K)] = { + implicit def group11[A, B, C, D, E, F, G, H, I, J, K](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K]): Group[(A, B, C, D, E, F, G, H, I, J, K)] = { new Tuple11Group[A, B, C, D, E, F, G, H, I, J, K]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup) } - implicit def group12[A, B, C, D, E, F, G, H, I, J, K, L](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L)] = { + implicit def group12[A, B, C, D, E, F, G, H, I, J, K, L](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L]): Group[(A, B, C, D, E, F, G, H, I, J, K, L)] = { new Tuple12Group[A, B, C, D, E, F, G, H, I, J, K, L]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup) } - implicit def group13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { + implicit def group13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { new Tuple13Group[A, B, C, D, E, F, G, H, I, J, K, L, M]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup) } - implicit def group14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { + implicit def group14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { new Tuple14Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup) } - implicit def group15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { + implicit def group15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { new Tuple15Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup) } - implicit def group16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { + implicit def group16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { new Tuple16Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup) } - implicit def group17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { + implicit def group17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { new Tuple17Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup) } - implicit def group18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { + implicit def group18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { new Tuple18Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup) } - implicit def group19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { + implicit def group19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { new Tuple19Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup) } - implicit def group20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { + implicit def group20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { new Tuple20Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup, tgroup) } - implicit def group21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { + implicit def group21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { new Tuple21Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup, tgroup, ugroup) } - implicit def group22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U], vgroup : Group[V]) : Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { + implicit def group22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U], vgroup: Group[V]): Group[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { new Tuple22Group[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]()(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup, tgroup, ugroup, vgroup) } } trait GeneratedRingImplicits { - implicit def ring2[A, B](implicit aring : Ring[A], bring : Ring[B]) : Ring[(A, B)] = { + implicit def ring2[A, B](implicit aring: Ring[A], bring: Ring[B]): Ring[(A, B)] = { new Tuple2Ring[A, B]()(aring, bring) } - implicit def ring3[A, B, C](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C]) : Ring[(A, B, C)] = { + implicit def ring3[A, B, C](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C]): Ring[(A, B, C)] = { new Tuple3Ring[A, B, C]()(aring, bring, cring) } - implicit def ring4[A, B, C, D](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D]) : Ring[(A, B, C, D)] = { + implicit def ring4[A, B, C, D](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D]): Ring[(A, B, C, D)] = { new Tuple4Ring[A, B, C, D]()(aring, bring, cring, dring) } - implicit def ring5[A, B, C, D, E](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E]) : Ring[(A, B, C, D, E)] = { + implicit def ring5[A, B, C, D, E](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E]): Ring[(A, B, C, D, E)] = { new Tuple5Ring[A, B, C, D, E]()(aring, bring, cring, dring, ering) } - implicit def ring6[A, B, C, D, E, F](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F]) : Ring[(A, B, C, D, E, F)] = { + implicit def ring6[A, B, C, D, E, F](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F]): Ring[(A, B, C, D, E, F)] = { new Tuple6Ring[A, B, C, D, E, F]()(aring, bring, cring, dring, ering, fring) } - implicit def ring7[A, B, C, D, E, F, G](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G]) : Ring[(A, B, C, D, E, F, G)] = { + implicit def ring7[A, B, C, D, E, F, G](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G]): Ring[(A, B, C, D, E, F, G)] = { new Tuple7Ring[A, B, C, D, E, F, G]()(aring, bring, cring, dring, ering, fring, gring) } - implicit def ring8[A, B, C, D, E, F, G, H](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H]) : Ring[(A, B, C, D, E, F, G, H)] = { + implicit def ring8[A, B, C, D, E, F, G, H](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H]): Ring[(A, B, C, D, E, F, G, H)] = { new Tuple8Ring[A, B, C, D, E, F, G, H]()(aring, bring, cring, dring, ering, fring, gring, hring) } - implicit def ring9[A, B, C, D, E, F, G, H, I](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I]) : Ring[(A, B, C, D, E, F, G, H, I)] = { + implicit def ring9[A, B, C, D, E, F, G, H, I](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I]): Ring[(A, B, C, D, E, F, G, H, I)] = { new Tuple9Ring[A, B, C, D, E, F, G, H, I]()(aring, bring, cring, dring, ering, fring, gring, hring, iring) } - implicit def ring10[A, B, C, D, E, F, G, H, I, J](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J]) : Ring[(A, B, C, D, E, F, G, H, I, J)] = { + implicit def ring10[A, B, C, D, E, F, G, H, I, J](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J]): Ring[(A, B, C, D, E, F, G, H, I, J)] = { new Tuple10Ring[A, B, C, D, E, F, G, H, I, J]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring) } - implicit def ring11[A, B, C, D, E, F, G, H, I, J, K](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K]) : Ring[(A, B, C, D, E, F, G, H, I, J, K)] = { + implicit def ring11[A, B, C, D, E, F, G, H, I, J, K](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K]): Ring[(A, B, C, D, E, F, G, H, I, J, K)] = { new Tuple11Ring[A, B, C, D, E, F, G, H, I, J, K]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring) } - implicit def ring12[A, B, C, D, E, F, G, H, I, J, K, L](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L)] = { + implicit def ring12[A, B, C, D, E, F, G, H, I, J, K, L](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L)] = { new Tuple12Ring[A, B, C, D, E, F, G, H, I, J, K, L]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring) } - implicit def ring13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { + implicit def ring13[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M)] = { new Tuple13Ring[A, B, C, D, E, F, G, H, I, J, K, L, M]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring) } - implicit def ring14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { + implicit def ring14[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] = { new Tuple14Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring) } - implicit def ring15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { + implicit def ring15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] = { new Tuple15Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring) } - implicit def ring16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { + implicit def ring16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] = { new Tuple16Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring) } - implicit def ring17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { + implicit def ring17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] = { new Tuple17Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring) } - implicit def ring18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { + implicit def ring18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] = { new Tuple18Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring) } - implicit def ring19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { + implicit def ring19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] = { new Tuple19Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring) } - implicit def ring20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { + implicit def ring20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] = { new Tuple20Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring, tring) } - implicit def ring21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { + implicit def ring21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] = { new Tuple21Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring, tring, uring) } - implicit def ring22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U], vring : Ring[V]) : Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { + implicit def ring22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U], vring: Ring[V]): Ring[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] = { new Tuple22Ring[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]()(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring, tring, uring, vring) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/GeneratedProductAlgebra.scala b/algebird-core/src/main/scala/com/twitter/algebird/GeneratedProductAlgebra.scala index 76f34ad71..3e320aa5c 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/GeneratedProductAlgebra.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/GeneratedProductAlgebra.scala @@ -2,1105 +2,1105 @@ package com.twitter.algebird /** -* Combine 2 semigroups into a product semigroup -*/ -class Product2Semigroup[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2)) } + * Combine 2 semigroups into a product semigroup + */ +class Product2Semigroup[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2)) } } /** -* Combine 2 monoids into a product monoid -*/ -class Product2Monoid[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B]) extends Monoid[X] { + * Combine 2 monoids into a product monoid + */ +class Product2Monoid[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2)) } } /** -* Combine 2 groups into a product group -*/ -class Product2Group[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit agroup : Group[A], bgroup : Group[B]) extends Group[X] { + * Combine 2 groups into a product group + */ +class Product2Group[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit agroup: Group[A], bgroup: Group[B]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2)) } } /** -* Combine 2 rings into a product ring -*/ -class Product2Ring[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit aring : Ring[A], bring : Ring[B]) extends Ring[X] { + * Combine 2 rings into a product ring + */ +class Product2Ring[X, A, B](apply: (A, B) => X, unapply: X => Option[(A, B)])(implicit aring: Ring[A], bring: Ring[B]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero) override def one = apply(aring.one, bring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2)) } } /** -* Combine 3 semigroups into a product semigroup -*/ -class Product3Semigroup[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3)) } + * Combine 3 semigroups into a product semigroup + */ +class Product3Semigroup[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3)) } } /** -* Combine 3 monoids into a product monoid -*/ -class Product3Monoid[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C]) extends Monoid[X] { + * Combine 3 monoids into a product monoid + */ +class Product3Monoid[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3)) } } /** -* Combine 3 groups into a product group -*/ -class Product3Group[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C]) extends Group[X] { + * Combine 3 groups into a product group + */ +class Product3Group[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3)) } } /** -* Combine 3 rings into a product ring -*/ -class Product3Ring[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C]) extends Ring[X] { + * Combine 3 rings into a product ring + */ +class Product3Ring[X, A, B, C](apply: (A, B, C) => X, unapply: X => Option[(A, B, C)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero) override def one = apply(aring.one, bring.one, cring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3)) } } /** -* Combine 4 semigroups into a product semigroup -*/ -class Product4Semigroup[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4)) } + * Combine 4 semigroups into a product semigroup + */ +class Product4Semigroup[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4)) } } /** -* Combine 4 monoids into a product monoid -*/ -class Product4Monoid[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D]) extends Monoid[X] { + * Combine 4 monoids into a product monoid + */ +class Product4Monoid[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4)) } } /** -* Combine 4 groups into a product group -*/ -class Product4Group[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D]) extends Group[X] { + * Combine 4 groups into a product group + */ +class Product4Group[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4)) } } /** -* Combine 4 rings into a product ring -*/ -class Product4Ring[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D]) extends Ring[X] { + * Combine 4 rings into a product ring + */ +class Product4Ring[X, A, B, C, D](apply: (A, B, C, D) => X, unapply: X => Option[(A, B, C, D)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4)) } } /** -* Combine 5 semigroups into a product semigroup -*/ -class Product5Semigroup[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5)) } + * Combine 5 semigroups into a product semigroup + */ +class Product5Semigroup[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5)) } } /** -* Combine 5 monoids into a product monoid -*/ -class Product5Monoid[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E]) extends Monoid[X] { + * Combine 5 monoids into a product monoid + */ +class Product5Monoid[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5)) } } /** -* Combine 5 groups into a product group -*/ -class Product5Group[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E]) extends Group[X] { + * Combine 5 groups into a product group + */ +class Product5Group[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5)) } } /** -* Combine 5 rings into a product ring -*/ -class Product5Ring[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E]) extends Ring[X] { + * Combine 5 rings into a product ring + */ +class Product5Ring[X, A, B, C, D, E](apply: (A, B, C, D, E) => X, unapply: X => Option[(A, B, C, D, E)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5)) } } /** -* Combine 6 semigroups into a product semigroup -*/ -class Product6Semigroup[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6)) } + * Combine 6 semigroups into a product semigroup + */ +class Product6Semigroup[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6)) } } /** -* Combine 6 monoids into a product monoid -*/ -class Product6Monoid[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F]) extends Monoid[X] { + * Combine 6 monoids into a product monoid + */ +class Product6Monoid[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6)) } } /** -* Combine 6 groups into a product group -*/ -class Product6Group[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F]) extends Group[X] { + * Combine 6 groups into a product group + */ +class Product6Group[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6)) } } /** -* Combine 6 rings into a product ring -*/ -class Product6Ring[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F]) extends Ring[X] { + * Combine 6 rings into a product ring + */ +class Product6Ring[X, A, B, C, D, E, F](apply: (A, B, C, D, E, F) => X, unapply: X => Option[(A, B, C, D, E, F)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6)) } } /** -* Combine 7 semigroups into a product semigroup -*/ -class Product7Semigroup[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7)) } + * Combine 7 semigroups into a product semigroup + */ +class Product7Semigroup[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7)) } } /** -* Combine 7 monoids into a product monoid -*/ -class Product7Monoid[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G]) extends Monoid[X] { + * Combine 7 monoids into a product monoid + */ +class Product7Monoid[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7)) } } /** -* Combine 7 groups into a product group -*/ -class Product7Group[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G]) extends Group[X] { + * Combine 7 groups into a product group + */ +class Product7Group[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7)) } } /** -* Combine 7 rings into a product ring -*/ -class Product7Ring[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G]) extends Ring[X] { + * Combine 7 rings into a product ring + */ +class Product7Ring[X, A, B, C, D, E, F, G](apply: (A, B, C, D, E, F, G) => X, unapply: X => Option[(A, B, C, D, E, F, G)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7)) } } /** -* Combine 8 semigroups into a product semigroup -*/ -class Product8Semigroup[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8)) } + * Combine 8 semigroups into a product semigroup + */ +class Product8Semigroup[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8)) } } /** -* Combine 8 monoids into a product monoid -*/ -class Product8Monoid[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H]) extends Monoid[X] { + * Combine 8 monoids into a product monoid + */ +class Product8Monoid[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8)) } } /** -* Combine 8 groups into a product group -*/ -class Product8Group[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H]) extends Group[X] { + * Combine 8 groups into a product group + */ +class Product8Group[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8)) } } /** -* Combine 8 rings into a product ring -*/ -class Product8Ring[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H]) extends Ring[X] { + * Combine 8 rings into a product ring + */ +class Product8Ring[X, A, B, C, D, E, F, G, H](apply: (A, B, C, D, E, F, G, H) => X, unapply: X => Option[(A, B, C, D, E, F, G, H)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8)) } } /** -* Combine 9 semigroups into a product semigroup -*/ -class Product9Semigroup[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9)) } + * Combine 9 semigroups into a product semigroup + */ +class Product9Semigroup[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9)) } } /** -* Combine 9 monoids into a product monoid -*/ -class Product9Monoid[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I]) extends Monoid[X] { + * Combine 9 monoids into a product monoid + */ +class Product9Monoid[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9)) } } /** -* Combine 9 groups into a product group -*/ -class Product9Group[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I]) extends Group[X] { + * Combine 9 groups into a product group + */ +class Product9Group[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9)) } } /** -* Combine 9 rings into a product ring -*/ -class Product9Ring[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I]) extends Ring[X] { + * Combine 9 rings into a product ring + */ +class Product9Ring[X, A, B, C, D, E, F, G, H, I](apply: (A, B, C, D, E, F, G, H, I) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9)) } } /** -* Combine 10 semigroups into a product semigroup -*/ -class Product10Semigroup[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10)) } + * Combine 10 semigroups into a product semigroup + */ +class Product10Semigroup[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10)) } } /** -* Combine 10 monoids into a product monoid -*/ -class Product10Monoid[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J]) extends Monoid[X] { + * Combine 10 monoids into a product monoid + */ +class Product10Monoid[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10)) } } /** -* Combine 10 groups into a product group -*/ -class Product10Group[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J]) extends Group[X] { + * Combine 10 groups into a product group + */ +class Product10Group[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10)) } } /** -* Combine 10 rings into a product ring -*/ -class Product10Ring[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J]) extends Ring[X] { + * Combine 10 rings into a product ring + */ +class Product10Ring[X, A, B, C, D, E, F, G, H, I, J](apply: (A, B, C, D, E, F, G, H, I, J) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10)) } } /** -* Combine 11 semigroups into a product semigroup -*/ -class Product11Semigroup[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11)) } + * Combine 11 semigroups into a product semigroup + */ +class Product11Semigroup[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11)) } } /** -* Combine 11 monoids into a product monoid -*/ -class Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K]) extends Monoid[X] { + * Combine 11 monoids into a product monoid + */ +class Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11)) } } /** -* Combine 11 groups into a product group -*/ -class Product11Group[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K]) extends Group[X] { + * Combine 11 groups into a product group + */ +class Product11Group[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11)) } } /** -* Combine 11 rings into a product ring -*/ -class Product11Ring[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K]) extends Ring[X] { + * Combine 11 rings into a product ring + */ +class Product11Ring[X, A, B, C, D, E, F, G, H, I, J, K](apply: (A, B, C, D, E, F, G, H, I, J, K) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11)) } } /** -* Combine 12 semigroups into a product semigroup -*/ -class Product12Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12)) } + * Combine 12 semigroups into a product semigroup + */ +class Product12Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12)) } } /** -* Combine 12 monoids into a product monoid -*/ -class Product12Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L]) extends Monoid[X] { + * Combine 12 monoids into a product monoid + */ +class Product12Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12)) } } /** -* Combine 12 groups into a product group -*/ -class Product12Group[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L]) extends Group[X] { + * Combine 12 groups into a product group + */ +class Product12Group[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12)) } } /** -* Combine 12 rings into a product ring -*/ -class Product12Ring[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L]) extends Ring[X] { + * Combine 12 rings into a product ring + */ +class Product12Ring[X, A, B, C, D, E, F, G, H, I, J, K, L](apply: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12)) } } /** -* Combine 13 semigroups into a product semigroup -*/ -class Product13Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13)) } + * Combine 13 semigroups into a product semigroup + */ +class Product13Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13)) } } /** -* Combine 13 monoids into a product monoid -*/ -class Product13Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M]) extends Monoid[X] { + * Combine 13 monoids into a product monoid + */ +class Product13Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13)) } } /** -* Combine 13 groups into a product group -*/ -class Product13Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M]) extends Group[X] { + * Combine 13 groups into a product group + */ +class Product13Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13)) } } /** -* Combine 13 rings into a product ring -*/ -class Product13Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M]) extends Ring[X] { + * Combine 13 rings into a product ring + */ +class Product13Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13)) } } /** -* Combine 14 semigroups into a product semigroup -*/ -class Product14Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14)) } + * Combine 14 semigroups into a product semigroup + */ +class Product14Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14)) } } /** -* Combine 14 monoids into a product monoid -*/ -class Product14Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N]) extends Monoid[X] { + * Combine 14 monoids into a product monoid + */ +class Product14Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14)) } } /** -* Combine 14 groups into a product group -*/ -class Product14Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N]) extends Group[X] { + * Combine 14 groups into a product group + */ +class Product14Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14)) } } /** -* Combine 14 rings into a product ring -*/ -class Product14Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N]) extends Ring[X] { + * Combine 14 rings into a product ring + */ +class Product14Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14)) } } /** -* Combine 15 semigroups into a product semigroup -*/ -class Product15Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15)) } + * Combine 15 semigroups into a product semigroup + */ +class Product15Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15)) } } /** -* Combine 15 monoids into a product monoid -*/ -class Product15Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O]) extends Monoid[X] { + * Combine 15 monoids into a product monoid + */ +class Product15Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15)) } } /** -* Combine 15 groups into a product group -*/ -class Product15Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O]) extends Group[X] { + * Combine 15 groups into a product group + */ +class Product15Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15)) } } /** -* Combine 15 rings into a product ring -*/ -class Product15Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O]) extends Ring[X] { + * Combine 15 rings into a product ring + */ +class Product15Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15)) } } /** -* Combine 16 semigroups into a product semigroup -*/ -class Product16Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16)) } + * Combine 16 semigroups into a product semigroup + */ +class Product16Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16)) } } /** -* Combine 16 monoids into a product monoid -*/ -class Product16Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P]) extends Monoid[X] { + * Combine 16 monoids into a product monoid + */ +class Product16Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16)) } } /** -* Combine 16 groups into a product group -*/ -class Product16Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P]) extends Group[X] { + * Combine 16 groups into a product group + */ +class Product16Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16)) } } /** -* Combine 16 rings into a product ring -*/ -class Product16Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P]) extends Ring[X] { + * Combine 16 rings into a product ring + */ +class Product16Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16)) } } /** -* Combine 17 semigroups into a product semigroup -*/ -class Product17Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17)) } + * Combine 17 semigroups into a product semigroup + */ +class Product17Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17)) } } /** -* Combine 17 monoids into a product monoid -*/ -class Product17Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q]) extends Monoid[X] { + * Combine 17 monoids into a product monoid + */ +class Product17Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17)) } } /** -* Combine 17 groups into a product group -*/ -class Product17Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q]) extends Group[X] { + * Combine 17 groups into a product group + */ +class Product17Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16), qgroup.negate(tuple._17)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17)) } } /** -* Combine 17 rings into a product ring -*/ -class Product17Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q]) extends Ring[X] { + * Combine 17 rings into a product ring + */ +class Product17Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16), qring.negate(tuple._17)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17)) } } /** -* Combine 18 semigroups into a product semigroup -*/ -class Product18Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18)) } + * Combine 18 semigroups into a product semigroup + */ +class Product18Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18)) } } /** -* Combine 18 monoids into a product monoid -*/ -class Product18Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R]) extends Monoid[X] { + * Combine 18 monoids into a product monoid + */ +class Product18Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18)) } } /** -* Combine 18 groups into a product group -*/ -class Product18Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R]) extends Group[X] { + * Combine 18 groups into a product group + */ +class Product18Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16), qgroup.negate(tuple._17), rgroup.negate(tuple._18)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18)) } } /** -* Combine 18 rings into a product ring -*/ -class Product18Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R]) extends Ring[X] { + * Combine 18 rings into a product ring + */ +class Product18Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16), qring.negate(tuple._17), rring.negate(tuple._18)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18)) } } /** -* Combine 19 semigroups into a product semigroup -*/ -class Product19Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19)) } + * Combine 19 semigroups into a product semigroup + */ +class Product19Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19)) } } /** -* Combine 19 monoids into a product monoid -*/ -class Product19Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S]) extends Monoid[X] { + * Combine 19 monoids into a product monoid + */ +class Product19Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19)) } } /** -* Combine 19 groups into a product group -*/ -class Product19Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S]) extends Group[X] { + * Combine 19 groups into a product group + */ +class Product19Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16), qgroup.negate(tuple._17), rgroup.negate(tuple._18), sgroup.negate(tuple._19)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19)) } } /** -* Combine 19 rings into a product ring -*/ -class Product19Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S]) extends Ring[X] { + * Combine 19 rings into a product ring + */ +class Product19Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16), qring.negate(tuple._17), rring.negate(tuple._18), sring.negate(tuple._19)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19)) } } /** -* Combine 20 semigroups into a product semigroup -*/ -class Product20Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19), tsemigroup.plus(lTuple._20, rTuple._20)) } + * Combine 20 semigroups into a product semigroup + */ +class Product20Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19), tsemigroup.plus(lTuple._20, rTuple._20)) } } /** -* Combine 20 monoids into a product monoid -*/ -class Product20Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T]) extends Monoid[X] { + * Combine 20 monoids into a product monoid + */ +class Product20Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero, tmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19), tmonoid.plus(lTuple._20, rTuple._20)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19), tmonoid.plus(lTuple._20, rTuple._20)) } } /** -* Combine 20 groups into a product group -*/ -class Product20Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T]) extends Group[X] { + * Combine 20 groups into a product group + */ +class Product20Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero, tgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16), qgroup.negate(tuple._17), rgroup.negate(tuple._18), sgroup.negate(tuple._19), tgroup.negate(tuple._20)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19), tgroup.plus(lTuple._20, rTuple._20)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19), tgroup.minus(lTuple._20, rTuple._20)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19), tgroup.plus(lTuple._20, rTuple._20)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19), tgroup.minus(lTuple._20, rTuple._20)) } } /** -* Combine 20 rings into a product ring -*/ -class Product20Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T]) extends Ring[X] { + * Combine 20 rings into a product ring + */ +class Product20Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero, tring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one, tring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16), qring.negate(tuple._17), rring.negate(tuple._18), sring.negate(tuple._19), tring.negate(tuple._20)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19), tring.plus(lTuple._20, rTuple._20)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19), tring.minus(lTuple._20, rTuple._20)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19), tring.times(lTuple._20, rTuple._20)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19), tring.plus(lTuple._20, rTuple._20)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19), tring.minus(lTuple._20, rTuple._20)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19), tring.times(lTuple._20, rTuple._20)) } } /** -* Combine 21 semigroups into a product semigroup -*/ -class Product21Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19), tsemigroup.plus(lTuple._20, rTuple._20), usemigroup.plus(lTuple._21, rTuple._21)) } + * Combine 21 semigroups into a product semigroup + */ +class Product21Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19), tsemigroup.plus(lTuple._20, rTuple._20), usemigroup.plus(lTuple._21, rTuple._21)) } } /** -* Combine 21 monoids into a product monoid -*/ -class Product21Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U]) extends Monoid[X] { + * Combine 21 monoids into a product monoid + */ +class Product21Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero, tmonoid.zero, umonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19), tmonoid.plus(lTuple._20, rTuple._20), umonoid.plus(lTuple._21, rTuple._21)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19), tmonoid.plus(lTuple._20, rTuple._20), umonoid.plus(lTuple._21, rTuple._21)) } } /** -* Combine 21 groups into a product group -*/ -class Product21Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U]) extends Group[X] { + * Combine 21 groups into a product group + */ +class Product21Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero, tgroup.zero, ugroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16), qgroup.negate(tuple._17), rgroup.negate(tuple._18), sgroup.negate(tuple._19), tgroup.negate(tuple._20), ugroup.negate(tuple._21)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19), tgroup.plus(lTuple._20, rTuple._20), ugroup.plus(lTuple._21, rTuple._21)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19), tgroup.minus(lTuple._20, rTuple._20), ugroup.minus(lTuple._21, rTuple._21)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19), tgroup.plus(lTuple._20, rTuple._20), ugroup.plus(lTuple._21, rTuple._21)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19), tgroup.minus(lTuple._20, rTuple._20), ugroup.minus(lTuple._21, rTuple._21)) } } /** -* Combine 21 rings into a product ring -*/ -class Product21Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U]) extends Ring[X] { + * Combine 21 rings into a product ring + */ +class Product21Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero, tring.zero, uring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one, tring.one, uring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16), qring.negate(tuple._17), rring.negate(tuple._18), sring.negate(tuple._19), tring.negate(tuple._20), uring.negate(tuple._21)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19), tring.plus(lTuple._20, rTuple._20), uring.plus(lTuple._21, rTuple._21)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19), tring.minus(lTuple._20, rTuple._20), uring.minus(lTuple._21, rTuple._21)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19), tring.times(lTuple._20, rTuple._20), uring.times(lTuple._21, rTuple._21)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19), tring.plus(lTuple._20, rTuple._20), uring.plus(lTuple._21, rTuple._21)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19), tring.minus(lTuple._20, rTuple._20), uring.minus(lTuple._21, rTuple._21)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19), tring.times(lTuple._20, rTuple._20), uring.times(lTuple._21, rTuple._21)) } } /** -* Combine 22 semigroups into a product semigroup -*/ -class Product22Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U], vsemigroup : Semigroup[V]) extends Semigroup[X] { - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19), tsemigroup.plus(lTuple._20, rTuple._20), usemigroup.plus(lTuple._21, rTuple._21), vsemigroup.plus(lTuple._22, rTuple._22)) } + * Combine 22 semigroups into a product semigroup + */ +class Product22Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U], vsemigroup: Semigroup[V]) extends Semigroup[X] { + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(asemigroup.plus(lTuple._1, rTuple._1), bsemigroup.plus(lTuple._2, rTuple._2), csemigroup.plus(lTuple._3, rTuple._3), dsemigroup.plus(lTuple._4, rTuple._4), esemigroup.plus(lTuple._5, rTuple._5), fsemigroup.plus(lTuple._6, rTuple._6), gsemigroup.plus(lTuple._7, rTuple._7), hsemigroup.plus(lTuple._8, rTuple._8), isemigroup.plus(lTuple._9, rTuple._9), jsemigroup.plus(lTuple._10, rTuple._10), ksemigroup.plus(lTuple._11, rTuple._11), lsemigroup.plus(lTuple._12, rTuple._12), msemigroup.plus(lTuple._13, rTuple._13), nsemigroup.plus(lTuple._14, rTuple._14), osemigroup.plus(lTuple._15, rTuple._15), psemigroup.plus(lTuple._16, rTuple._16), qsemigroup.plus(lTuple._17, rTuple._17), rsemigroup.plus(lTuple._18, rTuple._18), ssemigroup.plus(lTuple._19, rTuple._19), tsemigroup.plus(lTuple._20, rTuple._20), usemigroup.plus(lTuple._21, rTuple._21), vsemigroup.plus(lTuple._22, rTuple._22)) } } /** -* Combine 22 monoids into a product monoid -*/ -class Product22Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U], vmonoid : Monoid[V]) extends Monoid[X] { + * Combine 22 monoids into a product monoid + */ +class Product22Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U], vmonoid: Monoid[V]) extends Monoid[X] { override def zero = apply(amonoid.zero, bmonoid.zero, cmonoid.zero, dmonoid.zero, emonoid.zero, fmonoid.zero, gmonoid.zero, hmonoid.zero, imonoid.zero, jmonoid.zero, kmonoid.zero, lmonoid.zero, mmonoid.zero, nmonoid.zero, omonoid.zero, pmonoid.zero, qmonoid.zero, rmonoid.zero, smonoid.zero, tmonoid.zero, umonoid.zero, vmonoid.zero) - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19), tmonoid.plus(lTuple._20, rTuple._20), umonoid.plus(lTuple._21, rTuple._21), vmonoid.plus(lTuple._22, rTuple._22)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(amonoid.plus(lTuple._1, rTuple._1), bmonoid.plus(lTuple._2, rTuple._2), cmonoid.plus(lTuple._3, rTuple._3), dmonoid.plus(lTuple._4, rTuple._4), emonoid.plus(lTuple._5, rTuple._5), fmonoid.plus(lTuple._6, rTuple._6), gmonoid.plus(lTuple._7, rTuple._7), hmonoid.plus(lTuple._8, rTuple._8), imonoid.plus(lTuple._9, rTuple._9), jmonoid.plus(lTuple._10, rTuple._10), kmonoid.plus(lTuple._11, rTuple._11), lmonoid.plus(lTuple._12, rTuple._12), mmonoid.plus(lTuple._13, rTuple._13), nmonoid.plus(lTuple._14, rTuple._14), omonoid.plus(lTuple._15, rTuple._15), pmonoid.plus(lTuple._16, rTuple._16), qmonoid.plus(lTuple._17, rTuple._17), rmonoid.plus(lTuple._18, rTuple._18), smonoid.plus(lTuple._19, rTuple._19), tmonoid.plus(lTuple._20, rTuple._20), umonoid.plus(lTuple._21, rTuple._21), vmonoid.plus(lTuple._22, rTuple._22)) } } /** -* Combine 22 groups into a product group -*/ -class Product22Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U], vgroup : Group[V]) extends Group[X] { + * Combine 22 groups into a product group + */ +class Product22Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U], vgroup: Group[V]) extends Group[X] { override def zero = apply(agroup.zero, bgroup.zero, cgroup.zero, dgroup.zero, egroup.zero, fgroup.zero, ggroup.zero, hgroup.zero, igroup.zero, jgroup.zero, kgroup.zero, lgroup.zero, mgroup.zero, ngroup.zero, ogroup.zero, pgroup.zero, qgroup.zero, rgroup.zero, sgroup.zero, tgroup.zero, ugroup.zero, vgroup.zero) override def negate(v: X) = { val tuple = unapply(v).get; apply(agroup.negate(tuple._1), bgroup.negate(tuple._2), cgroup.negate(tuple._3), dgroup.negate(tuple._4), egroup.negate(tuple._5), fgroup.negate(tuple._6), ggroup.negate(tuple._7), hgroup.negate(tuple._8), igroup.negate(tuple._9), jgroup.negate(tuple._10), kgroup.negate(tuple._11), lgroup.negate(tuple._12), mgroup.negate(tuple._13), ngroup.negate(tuple._14), ogroup.negate(tuple._15), pgroup.negate(tuple._16), qgroup.negate(tuple._17), rgroup.negate(tuple._18), sgroup.negate(tuple._19), tgroup.negate(tuple._20), ugroup.negate(tuple._21), vgroup.negate(tuple._22)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19), tgroup.plus(lTuple._20, rTuple._20), ugroup.plus(lTuple._21, rTuple._21), vgroup.plus(lTuple._22, rTuple._22)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19), tgroup.minus(lTuple._20, rTuple._20), ugroup.minus(lTuple._21, rTuple._21), vgroup.minus(lTuple._22, rTuple._22)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.plus(lTuple._1, rTuple._1), bgroup.plus(lTuple._2, rTuple._2), cgroup.plus(lTuple._3, rTuple._3), dgroup.plus(lTuple._4, rTuple._4), egroup.plus(lTuple._5, rTuple._5), fgroup.plus(lTuple._6, rTuple._6), ggroup.plus(lTuple._7, rTuple._7), hgroup.plus(lTuple._8, rTuple._8), igroup.plus(lTuple._9, rTuple._9), jgroup.plus(lTuple._10, rTuple._10), kgroup.plus(lTuple._11, rTuple._11), lgroup.plus(lTuple._12, rTuple._12), mgroup.plus(lTuple._13, rTuple._13), ngroup.plus(lTuple._14, rTuple._14), ogroup.plus(lTuple._15, rTuple._15), pgroup.plus(lTuple._16, rTuple._16), qgroup.plus(lTuple._17, rTuple._17), rgroup.plus(lTuple._18, rTuple._18), sgroup.plus(lTuple._19, rTuple._19), tgroup.plus(lTuple._20, rTuple._20), ugroup.plus(lTuple._21, rTuple._21), vgroup.plus(lTuple._22, rTuple._22)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(agroup.minus(lTuple._1, rTuple._1), bgroup.minus(lTuple._2, rTuple._2), cgroup.minus(lTuple._3, rTuple._3), dgroup.minus(lTuple._4, rTuple._4), egroup.minus(lTuple._5, rTuple._5), fgroup.minus(lTuple._6, rTuple._6), ggroup.minus(lTuple._7, rTuple._7), hgroup.minus(lTuple._8, rTuple._8), igroup.minus(lTuple._9, rTuple._9), jgroup.minus(lTuple._10, rTuple._10), kgroup.minus(lTuple._11, rTuple._11), lgroup.minus(lTuple._12, rTuple._12), mgroup.minus(lTuple._13, rTuple._13), ngroup.minus(lTuple._14, rTuple._14), ogroup.minus(lTuple._15, rTuple._15), pgroup.minus(lTuple._16, rTuple._16), qgroup.minus(lTuple._17, rTuple._17), rgroup.minus(lTuple._18, rTuple._18), sgroup.minus(lTuple._19, rTuple._19), tgroup.minus(lTuple._20, rTuple._20), ugroup.minus(lTuple._21, rTuple._21), vgroup.minus(lTuple._22, rTuple._22)) } } /** -* Combine 22 rings into a product ring -*/ -class Product22Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U], vring : Ring[V]) extends Ring[X] { + * Combine 22 rings into a product ring + */ +class Product22Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](apply: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapply: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U], vring: Ring[V]) extends Ring[X] { override def zero = apply(aring.zero, bring.zero, cring.zero, dring.zero, ering.zero, fring.zero, gring.zero, hring.zero, iring.zero, jring.zero, kring.zero, lring.zero, mring.zero, nring.zero, oring.zero, pring.zero, qring.zero, rring.zero, sring.zero, tring.zero, uring.zero, vring.zero) override def one = apply(aring.one, bring.one, cring.one, dring.one, ering.one, fring.one, gring.one, hring.one, iring.one, jring.one, kring.one, lring.one, mring.one, nring.one, oring.one, pring.one, qring.one, rring.one, sring.one, tring.one, uring.one, vring.one) override def negate(v: X) = { val tuple = unapply(v).get; apply(aring.negate(tuple._1), bring.negate(tuple._2), cring.negate(tuple._3), dring.negate(tuple._4), ering.negate(tuple._5), fring.negate(tuple._6), gring.negate(tuple._7), hring.negate(tuple._8), iring.negate(tuple._9), jring.negate(tuple._10), kring.negate(tuple._11), lring.negate(tuple._12), mring.negate(tuple._13), nring.negate(tuple._14), oring.negate(tuple._15), pring.negate(tuple._16), qring.negate(tuple._17), rring.negate(tuple._18), sring.negate(tuple._19), tring.negate(tuple._20), uring.negate(tuple._21), vring.negate(tuple._22)) } - override def plus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19), tring.plus(lTuple._20, rTuple._20), uring.plus(lTuple._21, rTuple._21), vring.plus(lTuple._22, rTuple._22)) } - override def minus(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19), tring.minus(lTuple._20, rTuple._20), uring.minus(lTuple._21, rTuple._21), vring.minus(lTuple._22, rTuple._22)) } - override def times(l : X, r : X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19), tring.times(lTuple._20, rTuple._20), uring.times(lTuple._21, rTuple._21), vring.times(lTuple._22, rTuple._22)) } + override def plus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.plus(lTuple._1, rTuple._1), bring.plus(lTuple._2, rTuple._2), cring.plus(lTuple._3, rTuple._3), dring.plus(lTuple._4, rTuple._4), ering.plus(lTuple._5, rTuple._5), fring.plus(lTuple._6, rTuple._6), gring.plus(lTuple._7, rTuple._7), hring.plus(lTuple._8, rTuple._8), iring.plus(lTuple._9, rTuple._9), jring.plus(lTuple._10, rTuple._10), kring.plus(lTuple._11, rTuple._11), lring.plus(lTuple._12, rTuple._12), mring.plus(lTuple._13, rTuple._13), nring.plus(lTuple._14, rTuple._14), oring.plus(lTuple._15, rTuple._15), pring.plus(lTuple._16, rTuple._16), qring.plus(lTuple._17, rTuple._17), rring.plus(lTuple._18, rTuple._18), sring.plus(lTuple._19, rTuple._19), tring.plus(lTuple._20, rTuple._20), uring.plus(lTuple._21, rTuple._21), vring.plus(lTuple._22, rTuple._22)) } + override def minus(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.minus(lTuple._1, rTuple._1), bring.minus(lTuple._2, rTuple._2), cring.minus(lTuple._3, rTuple._3), dring.minus(lTuple._4, rTuple._4), ering.minus(lTuple._5, rTuple._5), fring.minus(lTuple._6, rTuple._6), gring.minus(lTuple._7, rTuple._7), hring.minus(lTuple._8, rTuple._8), iring.minus(lTuple._9, rTuple._9), jring.minus(lTuple._10, rTuple._10), kring.minus(lTuple._11, rTuple._11), lring.minus(lTuple._12, rTuple._12), mring.minus(lTuple._13, rTuple._13), nring.minus(lTuple._14, rTuple._14), oring.minus(lTuple._15, rTuple._15), pring.minus(lTuple._16, rTuple._16), qring.minus(lTuple._17, rTuple._17), rring.minus(lTuple._18, rTuple._18), sring.minus(lTuple._19, rTuple._19), tring.minus(lTuple._20, rTuple._20), uring.minus(lTuple._21, rTuple._21), vring.minus(lTuple._22, rTuple._22)) } + override def times(l: X, r: X) = { val lTuple = unapply(l).get; val rTuple = unapply(r).get; apply(aring.times(lTuple._1, rTuple._1), bring.times(lTuple._2, rTuple._2), cring.times(lTuple._3, rTuple._3), dring.times(lTuple._4, rTuple._4), ering.times(lTuple._5, rTuple._5), fring.times(lTuple._6, rTuple._6), gring.times(lTuple._7, rTuple._7), hring.times(lTuple._8, rTuple._8), iring.times(lTuple._9, rTuple._9), jring.times(lTuple._10, rTuple._10), kring.times(lTuple._11, rTuple._11), lring.times(lTuple._12, rTuple._12), mring.times(lTuple._13, rTuple._13), nring.times(lTuple._14, rTuple._14), oring.times(lTuple._15, rTuple._15), pring.times(lTuple._16, rTuple._16), qring.times(lTuple._17, rTuple._17), rring.times(lTuple._18, rTuple._18), sring.times(lTuple._19, rTuple._19), tring.times(lTuple._20, rTuple._20), uring.times(lTuple._21, rTuple._21), vring.times(lTuple._22, rTuple._22)) } } trait ProductSemigroups { - def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B]): Semigroup[X] = { + def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B]): Semigroup[X] = { new Product2Semigroup[X, A, B](applyX, unapplyX)(asemigroup, bsemigroup) } - def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C]): Semigroup[X] = { + def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C]): Semigroup[X] = { new Product3Semigroup[X, A, B, C](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup) } - def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D]): Semigroup[X] = { + def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D]): Semigroup[X] = { new Product4Semigroup[X, A, B, C, D](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup) } - def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E]): Semigroup[X] = { + def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E]): Semigroup[X] = { new Product5Semigroup[X, A, B, C, D, E](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup) } - def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F]): Semigroup[X] = { new Product6Semigroup[X, A, B, C, D, E, F](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup) } - def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G]): Semigroup[X] = { new Product7Semigroup[X, A, B, C, D, E, F, G](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup) } - def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H]): Semigroup[X] = { new Product8Semigroup[X, A, B, C, D, E, F, G, H](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I]): Semigroup[X] = { new Product9Semigroup[X, A, B, C, D, E, F, G, H, I](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J]): Semigroup[X] = { new Product10Semigroup[X, A, B, C, D, E, F, G, H, I, J](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K]): Semigroup[X] = { new Product11Semigroup[X, A, B, C, D, E, F, G, H, I, J, K](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L]): Semigroup[X] = { new Product12Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M]): Semigroup[X] = { new Product13Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N]): Semigroup[X] = { new Product14Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O]): Semigroup[X] = { new Product15Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P]): Semigroup[X] = { new Product16Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q]): Semigroup[X] = { new Product17Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R]): Semigroup[X] = { new Product18Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S]): Semigroup[X] = { new Product19Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T]): Semigroup[X] = { new Product20Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup, tsemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U]): Semigroup[X] = { new Product21Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup, tsemigroup, usemigroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit asemigroup : Semigroup[A], bsemigroup : Semigroup[B], csemigroup : Semigroup[C], dsemigroup : Semigroup[D], esemigroup : Semigroup[E], fsemigroup : Semigroup[F], gsemigroup : Semigroup[G], hsemigroup : Semigroup[H], isemigroup : Semigroup[I], jsemigroup : Semigroup[J], ksemigroup : Semigroup[K], lsemigroup : Semigroup[L], msemigroup : Semigroup[M], nsemigroup : Semigroup[N], osemigroup : Semigroup[O], psemigroup : Semigroup[P], qsemigroup : Semigroup[Q], rsemigroup : Semigroup[R], ssemigroup : Semigroup[S], tsemigroup : Semigroup[T], usemigroup : Semigroup[U], vsemigroup : Semigroup[V]): Semigroup[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit asemigroup: Semigroup[A], bsemigroup: Semigroup[B], csemigroup: Semigroup[C], dsemigroup: Semigroup[D], esemigroup: Semigroup[E], fsemigroup: Semigroup[F], gsemigroup: Semigroup[G], hsemigroup: Semigroup[H], isemigroup: Semigroup[I], jsemigroup: Semigroup[J], ksemigroup: Semigroup[K], lsemigroup: Semigroup[L], msemigroup: Semigroup[M], nsemigroup: Semigroup[N], osemigroup: Semigroup[O], psemigroup: Semigroup[P], qsemigroup: Semigroup[Q], rsemigroup: Semigroup[R], ssemigroup: Semigroup[S], tsemigroup: Semigroup[T], usemigroup: Semigroup[U], vsemigroup: Semigroup[V]): Semigroup[X] = { new Product22Semigroup[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX, unapplyX)(asemigroup, bsemigroup, csemigroup, dsemigroup, esemigroup, fsemigroup, gsemigroup, hsemigroup, isemigroup, jsemigroup, ksemigroup, lsemigroup, msemigroup, nsemigroup, osemigroup, psemigroup, qsemigroup, rsemigroup, ssemigroup, tsemigroup, usemigroup, vsemigroup) } } trait ProductMonoids { - def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B]): Monoid[X] = { + def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B]): Monoid[X] = { new Product2Monoid[X, A, B](applyX, unapplyX)(amonoid, bmonoid) } - def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C]): Monoid[X] = { + def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C]): Monoid[X] = { new Product3Monoid[X, A, B, C](applyX, unapplyX)(amonoid, bmonoid, cmonoid) } - def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D]): Monoid[X] = { + def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D]): Monoid[X] = { new Product4Monoid[X, A, B, C, D](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid) } - def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E]): Monoid[X] = { + def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E]): Monoid[X] = { new Product5Monoid[X, A, B, C, D, E](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid) } - def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F]): Monoid[X] = { + def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F]): Monoid[X] = { new Product6Monoid[X, A, B, C, D, E, F](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid) } - def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G]): Monoid[X] = { new Product7Monoid[X, A, B, C, D, E, F, G](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid) } - def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H]): Monoid[X] = { new Product8Monoid[X, A, B, C, D, E, F, G, H](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I]): Monoid[X] = { new Product9Monoid[X, A, B, C, D, E, F, G, H, I](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J]): Monoid[X] = { new Product10Monoid[X, A, B, C, D, E, F, G, H, I, J](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K]): Monoid[X] = { new Product11Monoid[X, A, B, C, D, E, F, G, H, I, J, K](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L]): Monoid[X] = { new Product12Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M]): Monoid[X] = { new Product13Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N]): Monoid[X] = { new Product14Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O]): Monoid[X] = { new Product15Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P]): Monoid[X] = { new Product16Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q]): Monoid[X] = { new Product17Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R]): Monoid[X] = { new Product18Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S]): Monoid[X] = { new Product19Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T]): Monoid[X] = { new Product20Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid, tmonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U]): Monoid[X] = { new Product21Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid, tmonoid, umonoid) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit amonoid : Monoid[A], bmonoid : Monoid[B], cmonoid : Monoid[C], dmonoid : Monoid[D], emonoid : Monoid[E], fmonoid : Monoid[F], gmonoid : Monoid[G], hmonoid : Monoid[H], imonoid : Monoid[I], jmonoid : Monoid[J], kmonoid : Monoid[K], lmonoid : Monoid[L], mmonoid : Monoid[M], nmonoid : Monoid[N], omonoid : Monoid[O], pmonoid : Monoid[P], qmonoid : Monoid[Q], rmonoid : Monoid[R], smonoid : Monoid[S], tmonoid : Monoid[T], umonoid : Monoid[U], vmonoid : Monoid[V]): Monoid[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit amonoid: Monoid[A], bmonoid: Monoid[B], cmonoid: Monoid[C], dmonoid: Monoid[D], emonoid: Monoid[E], fmonoid: Monoid[F], gmonoid: Monoid[G], hmonoid: Monoid[H], imonoid: Monoid[I], jmonoid: Monoid[J], kmonoid: Monoid[K], lmonoid: Monoid[L], mmonoid: Monoid[M], nmonoid: Monoid[N], omonoid: Monoid[O], pmonoid: Monoid[P], qmonoid: Monoid[Q], rmonoid: Monoid[R], smonoid: Monoid[S], tmonoid: Monoid[T], umonoid: Monoid[U], vmonoid: Monoid[V]): Monoid[X] = { new Product22Monoid[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX, unapplyX)(amonoid, bmonoid, cmonoid, dmonoid, emonoid, fmonoid, gmonoid, hmonoid, imonoid, jmonoid, kmonoid, lmonoid, mmonoid, nmonoid, omonoid, pmonoid, qmonoid, rmonoid, smonoid, tmonoid, umonoid, vmonoid) } } trait ProductGroups { - def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit agroup : Group[A], bgroup : Group[B]): Group[X] = { + def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit agroup: Group[A], bgroup: Group[B]): Group[X] = { new Product2Group[X, A, B](applyX, unapplyX)(agroup, bgroup) } - def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C]): Group[X] = { + def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C]): Group[X] = { new Product3Group[X, A, B, C](applyX, unapplyX)(agroup, bgroup, cgroup) } - def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D]): Group[X] = { + def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D]): Group[X] = { new Product4Group[X, A, B, C, D](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup) } - def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E]): Group[X] = { + def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E]): Group[X] = { new Product5Group[X, A, B, C, D, E](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup) } - def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F]): Group[X] = { + def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F]): Group[X] = { new Product6Group[X, A, B, C, D, E, F](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup) } - def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G]): Group[X] = { + def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G]): Group[X] = { new Product7Group[X, A, B, C, D, E, F, G](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup) } - def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H]): Group[X] = { new Product8Group[X, A, B, C, D, E, F, G, H](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup) } - def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I]): Group[X] = { new Product9Group[X, A, B, C, D, E, F, G, H, I](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J]): Group[X] = { new Product10Group[X, A, B, C, D, E, F, G, H, I, J](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K]): Group[X] = { new Product11Group[X, A, B, C, D, E, F, G, H, I, J, K](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L]): Group[X] = { new Product12Group[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M]): Group[X] = { new Product13Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N]): Group[X] = { new Product14Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O]): Group[X] = { new Product15Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P]): Group[X] = { new Product16Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q]): Group[X] = { new Product17Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R]): Group[X] = { new Product18Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S]): Group[X] = { new Product19Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T]): Group[X] = { new Product20Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup, tgroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U]): Group[X] = { new Product21Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup, tgroup, ugroup) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit agroup : Group[A], bgroup : Group[B], cgroup : Group[C], dgroup : Group[D], egroup : Group[E], fgroup : Group[F], ggroup : Group[G], hgroup : Group[H], igroup : Group[I], jgroup : Group[J], kgroup : Group[K], lgroup : Group[L], mgroup : Group[M], ngroup : Group[N], ogroup : Group[O], pgroup : Group[P], qgroup : Group[Q], rgroup : Group[R], sgroup : Group[S], tgroup : Group[T], ugroup : Group[U], vgroup : Group[V]): Group[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit agroup: Group[A], bgroup: Group[B], cgroup: Group[C], dgroup: Group[D], egroup: Group[E], fgroup: Group[F], ggroup: Group[G], hgroup: Group[H], igroup: Group[I], jgroup: Group[J], kgroup: Group[K], lgroup: Group[L], mgroup: Group[M], ngroup: Group[N], ogroup: Group[O], pgroup: Group[P], qgroup: Group[Q], rgroup: Group[R], sgroup: Group[S], tgroup: Group[T], ugroup: Group[U], vgroup: Group[V]): Group[X] = { new Product22Group[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX, unapplyX)(agroup, bgroup, cgroup, dgroup, egroup, fgroup, ggroup, hgroup, igroup, jgroup, kgroup, lgroup, mgroup, ngroup, ogroup, pgroup, qgroup, rgroup, sgroup, tgroup, ugroup, vgroup) } } trait ProductRings { - def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit aring : Ring[A], bring : Ring[B]): Ring[X] = { + def apply[X, A, B](applyX: (A, B) => X, unapplyX: X => Option[(A, B)])(implicit aring: Ring[A], bring: Ring[B]): Ring[X] = { new Product2Ring[X, A, B](applyX, unapplyX)(aring, bring) } - def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C]): Ring[X] = { + def apply[X, A, B, C](applyX: (A, B, C) => X, unapplyX: X => Option[(A, B, C)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C]): Ring[X] = { new Product3Ring[X, A, B, C](applyX, unapplyX)(aring, bring, cring) } - def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D]): Ring[X] = { + def apply[X, A, B, C, D](applyX: (A, B, C, D) => X, unapplyX: X => Option[(A, B, C, D)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D]): Ring[X] = { new Product4Ring[X, A, B, C, D](applyX, unapplyX)(aring, bring, cring, dring) } - def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E]): Ring[X] = { + def apply[X, A, B, C, D, E](applyX: (A, B, C, D, E) => X, unapplyX: X => Option[(A, B, C, D, E)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E]): Ring[X] = { new Product5Ring[X, A, B, C, D, E](applyX, unapplyX)(aring, bring, cring, dring, ering) } - def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F]): Ring[X] = { + def apply[X, A, B, C, D, E, F](applyX: (A, B, C, D, E, F) => X, unapplyX: X => Option[(A, B, C, D, E, F)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F]): Ring[X] = { new Product6Ring[X, A, B, C, D, E, F](applyX, unapplyX)(aring, bring, cring, dring, ering, fring) } - def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G](applyX: (A, B, C, D, E, F, G) => X, unapplyX: X => Option[(A, B, C, D, E, F, G)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G]): Ring[X] = { new Product7Ring[X, A, B, C, D, E, F, G](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring) } - def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H](applyX: (A, B, C, D, E, F, G, H) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H]): Ring[X] = { new Product8Ring[X, A, B, C, D, E, F, G, H](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring) } - def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I](applyX: (A, B, C, D, E, F, G, H, I) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I]): Ring[X] = { new Product9Ring[X, A, B, C, D, E, F, G, H, I](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring) } - def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J](applyX: (A, B, C, D, E, F, G, H, I, J) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J]): Ring[X] = { new Product10Ring[X, A, B, C, D, E, F, G, H, I, J](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K](applyX: (A, B, C, D, E, F, G, H, I, J, K) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K]): Ring[X] = { new Product11Ring[X, A, B, C, D, E, F, G, H, I, J, K](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX: (A, B, C, D, E, F, G, H, I, J, K, L) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L]): Ring[X] = { new Product12Ring[X, A, B, C, D, E, F, G, H, I, J, K, L](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M]): Ring[X] = { new Product13Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N]): Ring[X] = { new Product14Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O]): Ring[X] = { new Product15Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P]): Ring[X] = { new Product16Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q]): Ring[X] = { new Product17Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R]): Ring[X] = { new Product18Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S]): Ring[X] = { new Product19Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T]): Ring[X] = { new Product20Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring, tring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U]): Ring[X] = { new Product21Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring, tring, uring) } - def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit aring : Ring[A], bring : Ring[B], cring : Ring[C], dring : Ring[D], ering : Ring[E], fring : Ring[F], gring : Ring[G], hring : Ring[H], iring : Ring[I], jring : Ring[J], kring : Ring[K], lring : Ring[L], mring : Ring[M], nring : Ring[N], oring : Ring[O], pring : Ring[P], qring : Ring[Q], rring : Ring[R], sring : Ring[S], tring : Ring[T], uring : Ring[U], vring : Ring[V]): Ring[X] = { + def apply[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => X, unapplyX: X => Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)])(implicit aring: Ring[A], bring: Ring[B], cring: Ring[C], dring: Ring[D], ering: Ring[E], fring: Ring[F], gring: Ring[G], hring: Ring[H], iring: Ring[I], jring: Ring[J], kring: Ring[K], lring: Ring[L], mring: Ring[M], nring: Ring[N], oring: Ring[O], pring: Ring[P], qring: Ring[Q], rring: Ring[R], sring: Ring[S], tring: Ring[T], uring: Ring[U], vring: Ring[V]): Ring[X] = { new Product22Ring[X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](applyX, unapplyX)(aring, bring, cring, dring, ering, fring, gring, hring, iring, jring, kring, lring, mring, nring, oring, pring, qring, rring, sring, tring, uring, vring) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Group.scala b/algebird-core/src/main/scala/com/twitter/algebird/Group.scala index 1d0351f3d..760eece3c 100755 --- a/algebird-core/src/main/scala/com/twitter/algebird/Group.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Group.scala @@ -15,8 +15,8 @@ limitations under the License. */ package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} -import java.util.{List => JList, Map => JMap} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } +import java.util.{ List => JList, Map => JMap } import scala.annotation.implicitNotFound import scala.math.Equiv @@ -26,10 +26,10 @@ import scala.math.Equiv */ @implicitNotFound(msg = "Cannot find Group type class for ${T}") -trait Group[@specialized(Int,Long,Float,Double) T] extends Monoid[T] { +trait Group[@specialized(Int, Long, Float, Double) T] extends Monoid[T] { // must override negate or minus (or both) - def negate(v : T) : T = minus(zero, v) - def minus(l : T, r : T) : T = plus(l, negate(r)) + def negate(v: T): T = minus(zero, v) + def minus(l: T, r: T): T = plus(l, negate(r)) } // For Java interop so they get the default methods @@ -40,10 +40,10 @@ abstract class AbstractGroup[T] extends Group[T] // for all instances t1,t2 of type T). class ConstantGroup[T](constant: T) extends Group[T] { override def zero = constant - override def negate(u : T) = constant - override def plus(l : T, r : T) = constant + override def negate(u: T) = constant + override def plus(l: T, r: T) = constant override def sumOption(iter: TraversableOnce[T]): Option[T] = - if(iter.isEmpty) None + if (iter.isEmpty) None else Some(constant) } @@ -60,7 +60,7 @@ object NullGroup extends ConstantGroup[Null](null) * Note: Some(0) and None are equivalent under this Group */ class OptionGroup[T](implicit group: Group[T]) extends OptionMonoid[T] - with Group[Option[T]] { + with Group[Option[T]] { override def isNonZero(opt: Option[T]): Boolean = opt.exists{ group.isNonZero(_) } @@ -71,39 +71,37 @@ class OptionGroup[T](implicit group: Group[T]) extends OptionMonoid[T] object Group extends GeneratedGroupImplicits with ProductGroups { // This pattern is really useful for typeclasses - def negate[T](x : T)(implicit grp : Group[T]) = grp.negate(x) - def minus[T](l : T, r : T)(implicit grp : Group[T]) = grp.minus(l,r) + def negate[T](x: T)(implicit grp: Group[T]) = grp.negate(x) + def minus[T](l: T, r: T)(implicit grp: Group[T]) = grp.minus(l, r) // nonZero and subtraction give an equiv, useful for Map[K,V] def equiv[T](implicit grp: Group[T]): Equiv[T] = Equiv.fromFunction[T] { (a, b) => !grp.isNonZero(grp.minus(a, b)) } /** Same as v + v + v .. + v (i times in total) */ def intTimes[T](i: BigInt, v: T)(implicit grp: Group[T]): T = - if(i < 0) { + if (i < 0) { Monoid.intTimes(-i, grp.negate(v)) - } - else { + } else { Monoid.intTimes(i, v)(grp) } - - implicit val nullGroup : Group[Null] = NullGroup - implicit val unitGroup : Group[Unit] = UnitGroup - implicit val boolGroup : Group[Boolean] = BooleanField - implicit val jboolGroup : Group[JBool] = JBoolField - implicit val intGroup : Group[Int] = IntRing - implicit val jintGroup : Group[JInt] = JIntRing - implicit val shortGroup : Group[Short] = ShortRing - implicit val jshortGroup : Group[JShort] = JShortRing - implicit val longGroup : Group[Long] = LongRing - implicit val bigIntGroup : Group[BigInt] = BigIntRing - implicit val jlongGroup : Group[JLong] = JLongRing - implicit val floatGroup : Group[Float] = FloatField - implicit val jfloatGroup : Group[JFloat] = JFloatField - implicit val doubleGroup : Group[Double] = DoubleField - implicit val jdoubleGroup : Group[JDouble] = JDoubleField - implicit def optionGroup[T:Group] = new OptionGroup[T] - implicit def indexedSeqGroup[T:Group]: Group[IndexedSeq[T]] = new IndexedSeqGroup[T] - implicit def mapGroup[K,V](implicit group : Group[V]) = new MapGroup[K,V]()(group) - implicit def scMapGroup[K,V](implicit group : Group[V]) = new ScMapGroup[K,V]()(group) + implicit val nullGroup: Group[Null] = NullGroup + implicit val unitGroup: Group[Unit] = UnitGroup + implicit val boolGroup: Group[Boolean] = BooleanField + implicit val jboolGroup: Group[JBool] = JBoolField + implicit val intGroup: Group[Int] = IntRing + implicit val jintGroup: Group[JInt] = JIntRing + implicit val shortGroup: Group[Short] = ShortRing + implicit val jshortGroup: Group[JShort] = JShortRing + implicit val longGroup: Group[Long] = LongRing + implicit val bigIntGroup: Group[BigInt] = BigIntRing + implicit val jlongGroup: Group[JLong] = JLongRing + implicit val floatGroup: Group[Float] = FloatField + implicit val jfloatGroup: Group[JFloat] = JFloatField + implicit val doubleGroup: Group[Double] = DoubleField + implicit val jdoubleGroup: Group[JDouble] = JDoubleField + implicit def optionGroup[T: Group] = new OptionGroup[T] + implicit def indexedSeqGroup[T: Group]: Group[IndexedSeq[T]] = new IndexedSeqGroup[T] + implicit def mapGroup[K, V](implicit group: Group[V]) = new MapGroup[K, V]()(group) + implicit def scMapGroup[K, V](implicit group: Group[V]) = new ScMapGroup[K, V]()(group) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/HashingTrick.scala b/algebird-core/src/main/scala/com/twitter/algebird/HashingTrick.scala index 70211c3af..fe15b7172 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/HashingTrick.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/HashingTrick.scala @@ -16,21 +16,21 @@ limitations under the License. package com.twitter.algebird -class HashingTrickMonoid[V:Group](bits : Int, seed : Int = 123456) extends Monoid[AdaptiveVector[V]] { - val vectorSize = 1 << bits - val bitMask = vectorSize - 1 - val hash = MurmurHash128(seed) +class HashingTrickMonoid[V: Group](bits: Int, seed: Int = 123456) extends Monoid[AdaptiveVector[V]] { + val vectorSize = 1 << bits + val bitMask = vectorSize - 1 + val hash = MurmurHash128(seed) - val zero = AdaptiveVector.fill[V](vectorSize)(Monoid.zero[V]) + val zero = AdaptiveVector.fill[V](vectorSize)(Monoid.zero[V]) - def plus(left : AdaptiveVector[V], right : AdaptiveVector[V]) = Monoid.plus(left, right) + def plus(left: AdaptiveVector[V], right: AdaptiveVector[V]) = Monoid.plus(left, right) - def init[K <% Array[Byte]](kv : (K,V)) : AdaptiveVector[V] = { - val (long1, long2) = hash(kv._1) - val index = (long1 & bitMask).toInt - val isNegative = (long2 & 1) == 1 + def init[K <% Array[Byte]](kv: (K, V)): AdaptiveVector[V] = { + val (long1, long2) = hash(kv._1) + val index = (long1 & bitMask).toInt + val isNegative = (long2 & 1) == 1 - val signedValue = if(isNegative) Group.negate(kv._2) else kv._2 - AdaptiveVector.fromMap[V](Map(index -> signedValue), Monoid.zero[V], vectorSize) - } + val signedValue = if (isNegative) Group.negate(kv._2) else kv._2 + AdaptiveVector.fromMap[V](Map(index -> signedValue), Monoid.zero[V], vectorSize) + } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/HyperLogLog.scala b/algebird-core/src/main/scala/com/twitter/algebird/HyperLogLog.scala index 53148d2fe..c457b879f 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/HyperLogLog.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/HyperLogLog.scala @@ -16,22 +16,23 @@ limitations under the License. package com.twitter.algebird - import java.nio.ByteBuffer /** A super lightweight (hopefully) version of BitSet */ case class BitSetLite(in: Array[Byte]) { def contains(x: Int): Boolean = { - /** Pretend 'in' is little endian so that the bitstring b0b1b2b3 is such that if b0 == 1, then + /** + * Pretend 'in' is little endian so that the bitstring b0b1b2b3 is such that if b0 == 1, then * 0 is in the bitset, if b1 == 1, then 1 is in the bitset. */ - val arrayIdx = x/8 - val remainder = x%8 + val arrayIdx = x / 8 + val remainder = x % 8 ((in(arrayIdx) >> (7 - remainder)) & 1) == 1 } } -/** Implementation of the HyperLogLog approximate counting as a Monoid +/** + * Implementation of the HyperLogLog approximate counting as a Monoid * @link http://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf * * HyperLogLog: the analysis of a near-optimal cardinality estimation algorithm @@ -42,7 +43,7 @@ object HyperLogLog { /* Size of the hash in bits */ val hashSize = 128 - def hash(input : Array[Byte]) : Array[Byte] = { + def hash(input: Array[Byte]): Array[Byte] = { val seed = 12345678 val (l0, l1) = MurmurHash128(seed)(input) val buf = new Array[Byte](16) @@ -53,7 +54,7 @@ object HyperLogLog { buf } - implicit def int2Bytes(i : Int) = { + implicit def int2Bytes(i: Int) = { val buf = new Array[Byte](4) ByteBuffer .wrap(buf) @@ -61,7 +62,7 @@ object HyperLogLog { buf } - implicit def long2Bytes(i : Long) = { + implicit def long2Bytes(i: Long) = { val buf = new Array[Byte](8) ByteBuffer .wrap(buf) @@ -69,9 +70,10 @@ object HyperLogLog { buf } - def twopow(i : Int) : Double = scala.math.pow(2.0, i) + def twopow(i: Int): Double = scala.math.pow(2.0, i) - /** the value 'j' is equal to + /** + * the value 'j' is equal to * TODO: We could read in a byte at a time. */ def j(bsl: BitSetLite, bits: Int): Int = { @@ -88,7 +90,8 @@ object HyperLogLog { loop(0, 0) } - /** The value 'w' is equal to . The function rho counts the number of leading + /** + * The value 'w' is equal to . The function rho counts the number of leading * zeroes in 'w'. We can calculate rho(w) at once with the method rhoW. */ def rhoW(bsl: BitSetLite, bits: Int): Byte = { @@ -99,7 +102,8 @@ object HyperLogLog { loop(bits, 1).toByte } - /** We are computing j and \rho(w) from the paper, + /** + * We are computing j and \rho(w) from the paper, * sorry for the name, but it allows someone to compare to the paper extremely low probability * rhow (position of the leftmost one bit) is > 127, so we use a Byte to store it * Given a hash the value 'j' is equal to and @@ -111,20 +115,19 @@ object HyperLogLog { (j(onBits, bits), rhoW(onBits, bits)) } - - def toBytes(h : HLL) : Array[Byte] = { + def toBytes(h: HLL): Array[Byte] = { h match { - case SparseHLL(bits,maxRhow) => - val jLen = (bits+7)/8 + case SparseHLL(bits, maxRhow) => + val jLen = (bits + 7) / 8 assert(jLen >= 1) assert(jLen <= 3) - val buf = new Array[Byte](1 + 1 + (jLen+1)*maxRhow.size) + val buf = new Array[Byte](1 + 1 + (jLen + 1) * maxRhow.size) val byteBuf = ByteBuffer .wrap(buf) - .put(3 : Byte) + .put(3: Byte) .put(bits.toByte) maxRhow.foldLeft(byteBuf) { (bb, jrhow) => - val (j,rhow) = jrhow + val (j, rhow) = jrhow bb.put((j & 0xff).toByte) if (jLen >= 2) bb.put(((j >> 8) & 0xff).toByte) if (jLen >= 3) bb.put(((j >> 16) & 0xff).toByte) @@ -132,12 +135,12 @@ object HyperLogLog { } buf - case DenseHLL(bits,v) => ((2 : Byte) +: bits.toByte +: v).toArray + case DenseHLL(bits, v) => ((2: Byte) +: bits.toByte +: v).toArray } } // Make sure to be reversible so fromBytes(toBytes(x)) == x - def fromBytes(bytes : Array[Byte]) : HLL = { + def fromBytes(bytes: Array[Byte]): HLL = { val bb = ByteBuffer.wrap(bytes) bb.get.toInt match { case 2 => DenseHLL(bb.get, bytes.toIndexedSeq.tail.tail) @@ -146,7 +149,7 @@ object HyperLogLog { } } - def fromByteBuffer(bb : ByteBuffer) : HLL = { + def fromByteBuffer(bb: ByteBuffer): HLL = { bb.get.toInt match { case 2 => val bits = bb.get @@ -158,11 +161,11 @@ object HyperLogLog { } } - private def sparseFromByteBuffer(bb : ByteBuffer) : SparseHLL = { + private def sparseFromByteBuffer(bb: ByteBuffer): SparseHLL = { val bits = bb.get - val jLen = (bits+7)/8 - assert(bb.remaining % (jLen+1) == 0, "Invalid byte array") - val maxRhow = (1 to bb.remaining/(jLen+1)).map { _ => + val jLen = (bits + 7) / 8 + assert(bb.remaining % (jLen + 1) == 0, "Invalid byte array") + val maxRhow = (1 to bb.remaining / (jLen + 1)).map { _ => val j = jLen match { case 1 => (bb.get.toInt & 0xff) case 2 => (bb.get.toInt & 0xff) + ((bb.get.toInt & 0xff) << 8) @@ -179,22 +182,22 @@ object HyperLogLog { case 4 => 0.673 case 5 => 0.697 case 6 => 0.709 - case _ => 0.7213 / (1.0 + 1.079/(1< 0.7213 / (1.0 + 1.079 / (1 << bits).toDouble) } - def error(bits: Int): Double = 1.04/scala.math.sqrt(twopow(bits)) + def error(bits: Int): Double = 1.04 / scala.math.sqrt(twopow(bits)) } sealed abstract class HLL extends java.io.Serializable { import HyperLogLog._ - def bits : Int - def size : Int - def zeroCnt : Int - def z : Double - def +(other : HLL) : HLL - def toDenseHLL : DenseHLL + def bits: Int + def size: Int + def zeroCnt: Int + def z: Double + def +(other: HLL): HLL + def toDenseHLL: DenseHLL def approximateSize = asApprox(initialEstimate) @@ -208,16 +211,15 @@ sealed abstract class HLL extends java.io.Serializable { // there was pathalogically bad results. See https://github.com/twitter/algebird/issues/284 if (e <= smallE) { smallEstimate(e) - } - else { + } else { e } } private def asApprox(v: Double): Approximate[Long] = { val stdev = error(bits) - val lowerBound = math.floor(math.max(v*(1.0 - 3*stdev), 0.0)).toLong - val upperBound = math.ceil(v*(1.0 + 3*stdev)).toLong + val lowerBound = math.floor(math.max(v * (1.0 - 3 * stdev), 0.0)).toLong + val upperBound = math.ceil(v * (1.0 + 3 * stdev)).toLong // Lower bound. see: http://en.wikipedia.org/wiki/68-95-99.7_rule val prob3StdDev = 0.9972 Approximate(lowerBound, v.toLong, upperBound, prob3StdDev) @@ -227,11 +229,10 @@ sealed abstract class HLL extends java.io.Serializable { private def smallE = 5 * size / 2.0 - private def smallEstimate(e : Double) : Double = { + private def smallEstimate(e: Double): Double = { if (zeroCnt == 0) { e - } - else { + } else { size * scala.math.log(size.toDouble / zeroCnt) } } @@ -241,7 +242,7 @@ sealed abstract class HLL extends java.io.Serializable { def updateInto(buffer: Array[Byte]): Unit } -case class SparseHLL(bits : Int, maxRhow : Map[Int,Max[Byte]]) extends HLL { +case class SparseHLL(bits: Int, maxRhow: Map[Int, Max[Byte]]) extends HLL { assert(bits > 3, "Use at least 4 bits (2^(bits) = bytes consumed)") @@ -251,11 +252,11 @@ case class SparseHLL(bits : Int, maxRhow : Map[Int,Max[Byte]]) extends HLL { lazy val z = 1.0 / (zeroCnt.toDouble + maxRhow.values.map { mj => HyperLogLog.twopow(-mj.get) }.sum) - def +(other : HLL) = { + def +(other: HLL) = { other match { - case sparse@SparseHLL(_, oMaxRhow) => + case sparse @ SparseHLL(_, oMaxRhow) => assert(sparse.size == size, "Incompatible HLL size: " + sparse.size + " != " + size) val allMaxRhow = Monoid.plus(maxRhow, oMaxRhow) if (allMaxRhow.size * 16 <= size) { @@ -266,29 +267,31 @@ case class SparseHLL(bits : Int, maxRhow : Map[Int,Max[Byte]]) extends HLL { case DenseHLL(bits, oldV) => assert(oldV.size == size, "Incompatible HLL size: " + oldV.size + " != " + size) - val newV = maxRhow.foldLeft(oldV) { case (v,(j,rhow)) => - if (rhow.get > v(j)) { - v.updated(j, rhow.get) - } else { - v - } + val newV = maxRhow.foldLeft(oldV) { + case (v, (j, rhow)) => + if (rhow.get > v(j)) { + v.updated(j, rhow.get) + } else { + v + } } DenseHLL(bits, newV) } } - def sparseMapToSequence(values : Map[Int,Max[Byte]]) : IndexedSeq[Byte] = { - val array = Array.fill[Byte](size)(0:Byte) - values.foreach { case (j,rhow) => array.update(j, rhow.get) } + def sparseMapToSequence(values: Map[Int, Max[Byte]]): IndexedSeq[Byte] = { + val array = Array.fill[Byte](size)(0: Byte) + values.foreach { case (j, rhow) => array.update(j, rhow.get) } array.toIndexedSeq } lazy val toDenseHLL = DenseHLL(bits, sparseMapToSequence(maxRhow)) def updateInto(buffer: Array[Byte]): Unit = { assert(buffer.length == size, "Length mismatch") - maxRhow.foreach { case (idx, maxb) => - buffer.update(idx, buffer(idx) max (maxb.get)) + maxRhow.foreach { + case (idx, maxb) => + buffer.update(idx, buffer(idx) max (maxb.get)) } } } @@ -296,9 +299,9 @@ case class SparseHLL(bits : Int, maxRhow : Map[Int,Max[Byte]]) extends HLL { /** * These are the individual instances which the Monoid knows how to add */ -case class DenseHLL(bits : Int, v : IndexedSeq[Byte]) extends HLL { +case class DenseHLL(bits: Int, v: IndexedSeq[Byte]) extends HLL { - assert(v.size == (1< HyperLogLog.twopow(-mj) }.sum) - def +(other : HLL) : HLL = { + def +(other: HLL): HLL = { other match { - case SparseHLL(_,_) => (other + this) + case SparseHLL(_, _) => (other + this) - case DenseHLL(_,ov) => + case DenseHLL(_, ov) => assert(ov.size == v.size, "Incompatible HLL size: " + ov.size + " != " + v.size) DenseHLL(bits, v - .view - .zip(ov) - .map { case (rhow,oRhow) => rhow max oRhow } - .toIndexedSeq - ) + .view + .zip(ov) + .map { case (rhow, oRhow) => rhow max oRhow } + .toIndexedSeq) } } @@ -348,18 +350,18 @@ class IndexedSeqArrayByte(buf: Array[Byte]) extends scala.collection.IndexedSeq[ * Error is about 1.04/sqrt(2^{bits}), so you want something like 12 bits for 1% error * which means each HLLInstance is about 2^{12} = 4kb per instance. */ -class HyperLogLogMonoid(val bits : Int) extends Monoid[HLL] { +class HyperLogLogMonoid(val bits: Int) extends Monoid[HLL] { import HyperLogLog._ assert(bits > 3, "Use at least 4 bits (2^(bits) = bytes consumed)") val size = 1 << bits - def apply[T <% Array[Byte]](t : T) = create(t) + def apply[T <% Array[Byte]](t: T) = create(t) - val zero : HLL = SparseHLL(bits, Monoid.zero[Map[Int,Max[Byte]]]) + val zero: HLL = SparseHLL(bits, Monoid.zero[Map[Int, Max[Byte]]]) - def plus(left : HLL, right : HLL) = left + right + def plus(left: HLL, right: HLL) = left + right private[this] final def denseUpdate(existing: HLL, iter: Iterator[HLL]): HLL = { val buffer = new Array[Byte](size) @@ -370,33 +372,32 @@ class HyperLogLogMonoid(val bits : Int) extends Monoid[HLL] { } override def sumOption(items: TraversableOnce[HLL]): Option[HLL] = - if(items.isEmpty) { + if (items.isEmpty) { None } else { val iter = items.toIterator.buffered var curValue = iter.next - while(iter.hasNext) { + while (iter.hasNext) { curValue = (curValue, iter.head) match { case (DenseHLL(_, _), _) => denseUpdate(curValue, iter) case (_, DenseHLL(_, _)) => denseUpdate(curValue, iter) - case _ => curValue + iter.next + case _ => curValue + iter.next } } Some(curValue) } - - def create(example : Array[Byte]) : HLL = { + def create(example: Array[Byte]): HLL = { val hashed = hash(example) - val (j,rhow) = jRhoW(hashed, bits) + val (j, rhow) = jRhoW(hashed, bits) SparseHLL(bits, Map(j -> Max(rhow))) } - def batchCreate[T <% Array[Byte]](instances: Iterable[T]) : HLL = { + def batchCreate[T <% Array[Byte]](instances: Iterable[T]): HLL = { val allMaxRhow = instances .map { x => jRhoW(hash(x), bits) } .groupBy { case (j, rhow) => j } - .mapValues { _.maxBy { case (j, rhow) => rhow} } + .mapValues { _.maxBy { case (j, rhow) => rhow } } .mapValues { case (j, rhow) => Max(rhow) } if (allMaxRhow.size * 16 <= size) { SparseHLL(bits, allMaxRhow) @@ -405,7 +406,7 @@ class HyperLogLogMonoid(val bits : Int) extends Monoid[HLL] { } } - final def estimateSize(hll : HLL) : Double = { + final def estimateSize(hll: HLL): Double = { hll.estimatedSize } @@ -413,7 +414,7 @@ class HyperLogLogMonoid(val bits : Int) extends Monoid[HLL] { hll.approximateSize } - final def estimateIntersectionSize(his : Seq[HLL]) : Double = { + final def estimateIntersectionSize(his: Seq[HLL]): Double = { intersectionSize(his).estimate.toDouble } @@ -430,8 +431,8 @@ class HyperLogLogMonoid(val bits : Int) extends Monoid[HLL] { sizeOf(head) + intersectionSize(tail) - intersectionSize(tail.map { _ + head }) } - .map { _.withMin(0L) } // We always know the intersection is >= 0 - .getOrElse(Approximate.exact(0L)) // Empty lists have no intersection + .map { _.withMin(0L) } // We always know the intersection is >= 0 + .getOrElse(Approximate.exact(0L)) // Empty lists have no intersection } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/IndexedSeq.scala b/algebird-core/src/main/scala/com/twitter/algebird/IndexedSeq.scala index cf6fa4f8d..ad1bba5af 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/IndexedSeq.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/IndexedSeq.scala @@ -16,7 +16,8 @@ limitations under the License. package com.twitter.algebird -/** Note that this works similar to Semigroup[Map[Int,T]] not like Semigroup[List[T]] +/** + * Note that this works similar to Semigroup[Map[Int,T]] not like Semigroup[List[T]] * This does element-wise operations, like standard vector math, not concatenation, * like Semigroup[String] or Semigroup[List[T]] * @@ -29,12 +30,12 @@ class IndexedSeqSemigroup[T](implicit semi: Semigroup[T]) extends Semigroup[Inde // We need summands to be the same length val (leftSummand, rightSummand, remainder) = if (left.size > right.size) { (left.view(0, right.size), - right, - left.view(right.size, left.size)) + right, + left.view(right.size, left.size)) } else { (left, - right.view(0, left.size), - right.view(left.size, right.size)) + right.view(0, left.size), + right.view(left.size, right.size)) } val sum = leftSummand @@ -45,8 +46,7 @@ class IndexedSeqSemigroup[T](implicit semi: Semigroup[T]) extends Semigroup[Inde } } -class IndexedSeqMonoid[T](implicit mont: Monoid[T]) extends IndexedSeqSemigroup[T] with - Monoid[IndexedSeq[T]] { +class IndexedSeqMonoid[T](implicit mont: Monoid[T]) extends IndexedSeqSemigroup[T] with Monoid[IndexedSeq[T]] { def zero = IndexedSeq.empty[T] override def isNonZero(v: IndexedSeq[T]) = v.exists { t => mont.isNonZero(t) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Interval.scala b/algebird-core/src/main/scala/com/twitter/algebird/Interval.scala index 61482451b..492585a2b 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Interval.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Interval.scala @@ -18,7 +18,8 @@ package com.twitter.algebird // TODO this is clearly more general than summingbird, and should be extended to be a ring (add union, etc...) -/** Represents a single interval on a T with an Ordering +/** + * Represents a single interval on a T with an Ordering */ sealed trait Interval[T] extends java.io.Serializable { def contains(t: T): Boolean @@ -27,24 +28,25 @@ sealed trait Interval[T] extends java.io.Serializable { def apply(t: T) = contains(t) def &&(that: Interval[T]) = intersect(that) - /** Map the Interval with a non-decreasing function. + /** + * Map the Interval with a non-decreasing function. * If you use a non-monotonic function (like x^2) * then the result is meaningless. * TODO: It might be good to have types for these properties in algebird. */ - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] } case class Universe[T]() extends Interval[T] { def contains(t: T): Boolean = true def intersect(that: Interval[T]): Interval[T] = that - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = Universe() + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = Universe() } case class Empty[T]() extends Interval[T] { def contains(t: T): Boolean = false def intersect(that: Interval[T]): Interval[T] = this - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = Empty() + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = Empty() } object Interval extends java.io.Serializable { @@ -57,19 +59,19 @@ object Interval extends java.io.Serializable { implicit def monoid[T]: Monoid[Interval[T]] = Monoid.from[Interval[T]](Universe[T]()) { _ && _ } // Automatically convert from an either - implicit def fromEither[L[t] <: Interval[t], R[t] <: Interval[t], T](either: Either[L[T],R[T]]): Interval[T] = + implicit def fromEither[L[t] <: Interval[t], R[t] <: Interval[t], T](either: Either[L[T], R[T]]): Interval[T] = either match { case Right(i) => i case Left(i) => i } - def leftClosedRightOpen[T:Ordering](lower: T, upper: T): Either[Empty[T], InLowExUp[T]] = - if(Ordering[T].lt(lower, upper)) + def leftClosedRightOpen[T: Ordering](lower: T, upper: T): Either[Empty[T], InLowExUp[T]] = + if (Ordering[T].lt(lower, upper)) Right(Intersection(InclusiveLower(lower), ExclusiveUpper(upper))) else Left(Empty()) - def leftOpenRightClosed[T:Ordering](lower: T, upper: T): Either[Empty[T], ExLowInUp[T]] = - if(Ordering[T].lt(lower, upper)) + def leftOpenRightClosed[T: Ordering](lower: T, upper: T): Either[Empty[T], ExLowInUp[T]] = + if (Ordering[T].lt(lower, upper)) Right(Intersection(ExclusiveLower(lower), InclusiveUpper(upper))) else Left(Empty()) } @@ -93,7 +95,8 @@ sealed trait Lower[T] extends Interval[T] { */ def least(implicit s: Successible[T]): Option[T] def strictLowerBound(implicit p: Predecessible[T]): Option[T] - /** Iterates all the items in this Lower[T] from lowest to highest + /** + * Iterates all the items in this Lower[T] from lowest to highest */ def toIterable(implicit s: Successible[T]): Iterable[T] = least match { @@ -111,7 +114,8 @@ sealed trait Upper[T] extends Interval[T] { def greatest(implicit p: Predecessible[T]): Option[T] // The smallest value that is not present def strictUpperBound(implicit s: Successible[T]): Option[T] - /** Iterates all the items in this Upper[T] from highest to lowest + /** + * Iterates all the items in this Upper[T] from highest to lowest */ def toIterable(implicit p: Predecessible[T]): Iterable[T] = greatest match { @@ -125,12 +129,12 @@ case class InclusiveLower[T](lower: T)(implicit val ordering: Ordering[T]) exten def intersect(that: Interval[T]): Interval[T] = that match { case Universe() => this case Empty() => that - case ub@InclusiveUpper(upper) => + case ub @ InclusiveUpper(upper) => if (intersects(ub)) Intersection(this, ub) else Empty() - case ub@ExclusiveUpper(upper) => + case ub @ ExclusiveUpper(upper) => if (intersects(ub)) Intersection(this, ub) else Empty() - case lb@InclusiveLower(thatlb) => if (lb.ordering.gt(lower, thatlb)) this else that - case lb@ExclusiveLower(thatlb) => if (lb.ordering.gt(lower, thatlb)) this else that + case lb @ InclusiveLower(thatlb) => if (lb.ordering.gt(lower, thatlb)) this else that + case lb @ ExclusiveLower(thatlb) => if (lb.ordering.gt(lower, thatlb)) this else that case Intersection(thatL, thatU) => (this && thatL) && thatU } def intersects(u: Upper[T]): Boolean = u match { @@ -139,19 +143,19 @@ case class InclusiveLower[T](lower: T)(implicit val ordering: Ordering[T]) exten } def least(implicit s: Successible[T]): Option[T] = Some(lower) def strictLowerBound(implicit p: Predecessible[T]): Option[T] = p.prev(lower) - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = InclusiveLower(fn(lower)) + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = InclusiveLower(fn(lower)) } case class ExclusiveLower[T](lower: T)(implicit val ordering: Ordering[T]) extends Interval[T] with Lower[T] { def contains(t: T): Boolean = ordering.lt(lower, t) def intersect(that: Interval[T]): Interval[T] = that match { case Universe() => this case Empty() => that - case ub@InclusiveUpper(upper) => + case ub @ InclusiveUpper(upper) => if (intersects(ub)) Intersection(this, ub) else Empty() - case ub@ExclusiveUpper(upper) => + case ub @ ExclusiveUpper(upper) => if (intersects(ub)) Intersection(this, ub) else Empty() - case lb@InclusiveLower(thatlb) => if (lb.ordering.gteq(lower, thatlb)) this else that - case lb@ExclusiveLower(thatlb) => if (lb.ordering.gteq(lower, thatlb)) this else that + case lb @ InclusiveLower(thatlb) => if (lb.ordering.gteq(lower, thatlb)) this else that + case lb @ ExclusiveLower(thatlb) => if (lb.ordering.gteq(lower, thatlb)) this else that case Intersection(thatL, thatU) => (this && thatL) && thatU } def intersects(u: Upper[T]): Boolean = u match { @@ -160,7 +164,7 @@ case class ExclusiveLower[T](lower: T)(implicit val ordering: Ordering[T]) exten } def least(implicit s: Successible[T]): Option[T] = s.next(lower) def strictLowerBound(implicit p: Predecessible[T]): Option[T] = Some(lower) - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = ExclusiveLower(fn(lower)) + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = ExclusiveLower(fn(lower)) } case class InclusiveUpper[T](upper: T)(implicit val ordering: Ordering[T]) extends Interval[T] with Upper[T] { def contains(t: T): Boolean = ordering.lteq(t, upper) @@ -170,17 +174,17 @@ case class InclusiveUpper[T](upper: T)(implicit val ordering: Ordering[T]) exten def intersect(that: Interval[T]): Interval[T] = that match { case Universe() => this case Empty() => that - case lb@InclusiveLower(lower) => + case lb @ InclusiveLower(lower) => if (lb.intersects(this)) Intersection(lb, this) else Empty() - case lb@ExclusiveLower(lower) => + case lb @ ExclusiveLower(lower) => if (lb.intersects(this)) Intersection(lb, this) else Empty() - case ub@InclusiveUpper(thatub) => + case ub @ InclusiveUpper(thatub) => if (ub.ordering.lt(upper, thatub)) this else that - case ub@ExclusiveUpper(thatub) => + case ub @ ExclusiveUpper(thatub) => if (ub.ordering.lt(upper, thatub)) this else that case Intersection(thatL, thatU) => thatL && (this && thatU) } - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = InclusiveUpper(fn(upper)) + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = InclusiveUpper(fn(upper)) } case class ExclusiveUpper[T](upper: T)(implicit val ordering: Ordering[T]) extends Interval[T] with Upper[T] { def contains(t: T): Boolean = ordering.lt(t, upper) @@ -190,17 +194,17 @@ case class ExclusiveUpper[T](upper: T)(implicit val ordering: Ordering[T]) exten def intersect(that: Interval[T]): Interval[T] = that match { case Universe() => this case Empty() => that - case lb@InclusiveLower(lower) => + case lb @ InclusiveLower(lower) => if (lb.intersects(this)) Intersection(lb, this) else Empty() - case lb@ExclusiveLower(lower) => + case lb @ ExclusiveLower(lower) => if (lb.intersects(this)) Intersection(lb, this) else Empty() - case ub@InclusiveUpper(thatub) => + case ub @ InclusiveUpper(thatub) => if (ub.ordering.lteq(upper, thatub)) this else that - case ub@ExclusiveUpper(thatub) => + case ub @ ExclusiveUpper(thatub) => if (ub.ordering.lteq(upper, thatub)) this else that case Intersection(thatL, thatU) => thatL && (this && thatU) } - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = ExclusiveUpper(fn(upper)) + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = ExclusiveUpper(fn(upper)) } case class Intersection[L[t] <: Lower[t], U[t] <: Upper[t], T](lower: L[T], upper: U[T]) extends Interval[T] { @@ -209,16 +213,17 @@ case class Intersection[L[t] <: Lower[t], U[t] <: Upper[t], T](lower: L[T], uppe def intersect(that: Interval[T]): Interval[T] = that match { case Universe() => this case Empty() => that - case lb@InclusiveLower(_) => (lb && lower) && upper - case lb@ExclusiveLower(_) => (lb && lower) && upper - case ub@InclusiveUpper(_) => lower && (ub && upper) - case ub@ExclusiveUpper(_) => lower && (ub && upper) + case lb @ InclusiveLower(_) => (lb && lower) && upper + case lb @ ExclusiveLower(_) => (lb && lower) && upper + case ub @ InclusiveUpper(_) => lower && (ub && upper) + case ub @ ExclusiveUpper(_) => lower && (ub && upper) case Intersection(thatL, thatU) => (lower && thatL) && (upper && thatU) } - def mapNonDecreasing[U:Ordering](fn: T => U): Interval[U] = + def mapNonDecreasing[U: Ordering](fn: T => U): Interval[U] = lower.mapNonDecreasing(fn) && upper.mapNonDecreasing(fn) - /** Goes from lowest to highest for all items + /** + * Goes from lowest to highest for all items * that are contained in this Intersection */ def leastToGreatest(implicit s: Successible[T]): Iterable[T] = { @@ -229,7 +234,8 @@ case class Intersection[L[t] <: Lower[t], U[t] <: Upper[t], T](lower: L[T], uppe def iterator = lower.toIterable.iterator.takeWhile(self.upper.contains(_)) } } - /** Goes from highest to lowest for all items + /** + * Goes from highest to lowest for all items * that are contained in this Intersection */ def greatestToLeast(implicit p: Predecessible[T]): Iterable[T] = { diff --git a/algebird-core/src/main/scala/com/twitter/algebird/JavaMonoids.scala b/algebird-core/src/main/scala/com/twitter/algebird/JavaMonoids.scala index f97679db1..280d40b53 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/JavaMonoids.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/JavaMonoids.scala @@ -15,75 +15,76 @@ limitations under the License. */ package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} -import java.util.{Map => JMap, List => JList} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } +import java.util.{ Map => JMap, List => JList } import scala.collection.JavaConverters._ object JIntRing extends Ring[JInt] { override val zero = JInt.valueOf(0) override val one = JInt.valueOf(1) - override def plus(x : JInt, y : JInt) = x + y - override def negate(x : JInt) : JInt = -x - override def minus(x : JInt, y : JInt) = x - y - override def times(x : JInt, y : JInt) = x * y + override def plus(x: JInt, y: JInt) = x + y + override def negate(x: JInt): JInt = -x + override def minus(x: JInt, y: JInt) = x - y + override def times(x: JInt, y: JInt) = x * y } object JShortRing extends Ring[JShort] { override val zero = Short.box(0) override val one = Short.box(1) - override def plus(x : JShort, y : JShort) = (x + y).toShort - override def negate(x : JShort) = (-x).toShort - override def minus(x : JShort, y : JShort) = (x - y).toShort - override def times(x : JShort, y : JShort) = (x * y).toShort + override def plus(x: JShort, y: JShort) = (x + y).toShort + override def negate(x: JShort) = (-x).toShort + override def minus(x: JShort, y: JShort) = (x - y).toShort + override def times(x: JShort, y: JShort) = (x * y).toShort } object JLongRing extends Ring[JLong] { override val zero = JLong.valueOf(0L) override val one = JLong.valueOf(1L) - override def plus(x : JLong, y : JLong) = x + y - override def negate(x : JLong) : JLong = -x - override def minus(x : JLong, y : JLong) = x - y - override def times(x : JLong, y : JLong) = x * y + override def plus(x: JLong, y: JLong) = x + y + override def negate(x: JLong): JLong = -x + override def minus(x: JLong, y: JLong) = x - y + override def times(x: JLong, y: JLong) = x * y } object JFloatField extends Field[JFloat] { override val zero = JFloat.valueOf(0.0f) override val one = JFloat.valueOf(1.0f) - override def plus(x : JFloat, y : JFloat) = x + y - override def negate(x : JFloat) : JFloat = -x - override def minus(x : JFloat, y : JFloat) = x - y - override def times(x : JFloat, y : JFloat) = x * y - override def div(x : JFloat, y : JFloat) = { assertNotZero(y); x / y } + override def plus(x: JFloat, y: JFloat) = x + y + override def negate(x: JFloat): JFloat = -x + override def minus(x: JFloat, y: JFloat) = x - y + override def times(x: JFloat, y: JFloat) = x * y + override def div(x: JFloat, y: JFloat) = { assertNotZero(y); x / y } } object JDoubleField extends Field[JDouble] { override val zero = JDouble.valueOf(0.0) override val one = JDouble.valueOf(1.0) - override def plus(x : JDouble, y : JDouble) = x + y - override def negate(x : JDouble) : JDouble = -x - override def minus(x : JDouble, y : JDouble) = x - y - override def times(x : JDouble, y : JDouble) = x * y - override def div(x : JDouble, y : JDouble) = { assertNotZero(y); x / y } + override def plus(x: JDouble, y: JDouble) = x + y + override def negate(x: JDouble): JDouble = -x + override def minus(x: JDouble, y: JDouble) = x - y + override def times(x: JDouble, y: JDouble) = x * y + override def div(x: JDouble, y: JDouble) = { assertNotZero(y); x / y } } object JBoolField extends Field[JBool] { override val zero = JBool.FALSE override val one = JBool.TRUE - override def plus(x : JBool, y : JBool) = JBool.valueOf(x.booleanValue ^ y.booleanValue) - override def negate(x : JBool) = x - override def minus(x : JBool, y : JBool) = plus(x,y) - override def times(x : JBool, y : JBool) = JBool.valueOf(x.booleanValue & y.booleanValue) - override def div(x : JBool, y : JBool) = { assertNotZero(y); x } + override def plus(x: JBool, y: JBool) = JBool.valueOf(x.booleanValue ^ y.booleanValue) + override def negate(x: JBool) = x + override def minus(x: JBool, y: JBool) = plus(x, y) + override def times(x: JBool, y: JBool) = JBool.valueOf(x.booleanValue & y.booleanValue) + override def div(x: JBool, y: JBool) = { assertNotZero(y); x } } -/** Since Lists are mutable, this always makes a full copy. Prefer scala immutable Lists +/** + * Since Lists are mutable, this always makes a full copy. Prefer scala immutable Lists * if you use scala immutable lists, the tail of the result of plus is always the right argument */ class JListMonoid[T] extends Monoid[JList[T]] { - override def isNonZero(x : JList[T]) = !x.isEmpty + override def isNonZero(x: JList[T]) = !x.isEmpty override lazy val zero = new java.util.ArrayList[T](0) - override def plus(x : JList[T], y : JList[T]) = { + override def plus(x: JList[T], y: JList[T]) = { val res = new java.util.ArrayList[T](x.size + y.size) res.addAll(x) res.addAll(y) @@ -91,19 +92,20 @@ class JListMonoid[T] extends Monoid[JList[T]] { } } -/** Since maps are mutable, this always makes a full copy. Prefer scala immutable maps +/** + * Since maps are mutable, this always makes a full copy. Prefer scala immutable maps * if you use scala immutable maps, this operation is much faster * TODO extend this to Group, Ring */ -class JMapMonoid[K,V:Semigroup] extends Monoid[JMap[K,V]] { - override lazy val zero = new java.util.HashMap[K,V](0) +class JMapMonoid[K, V: Semigroup] extends Monoid[JMap[K, V]] { + override lazy val zero = new java.util.HashMap[K, V](0) val nonZero: (V => Boolean) = implicitly[Semigroup[V]] match { case mon: Monoid[_] => mon.isNonZero(_) case _ => (_ => true) } - override def isNonZero(x : JMap[K,V]) = + override def isNonZero(x: JMap[K, V]) = !x.isEmpty && (implicitly[Semigroup[V]] match { case mon: Monoid[_] => x.values.asScala.exists { v => @@ -111,17 +113,17 @@ class JMapMonoid[K,V:Semigroup] extends Monoid[JMap[K,V]] { } case _ => true }) - override def plus(x : JMap[K,V], y : JMap[K,V]) = { - val (big, small, bigOnLeft) = if(x.size > y.size) { (x,y,true) } else { (y,x,false) } + override def plus(x: JMap[K, V], y: JMap[K, V]) = { + val (big, small, bigOnLeft) = if (x.size > y.size) { (x, y, true) } else { (y, x, false) } val vsemi = implicitly[Semigroup[V]] - val result = new java.util.HashMap[K,V](big.size + small.size) + val result = new java.util.HashMap[K, V](big.size + small.size) result.putAll(big) small.entrySet.asScala.foreach { kv => val smallK = kv.getKey val smallV = kv.getValue - if(big.containsKey(smallK)) { + if (big.containsKey(smallK)) { val bigV = big.get(smallK) - val newV = if(bigOnLeft) vsemi.plus(bigV, smallV) else vsemi.plus(smallV, bigV) + val newV = if (bigOnLeft) vsemi.plus(bigV, smallV) else vsemi.plus(smallV, bigV) if (nonZero(newV)) result.put(smallK, newV) else diff --git a/algebird-core/src/main/scala/com/twitter/algebird/MapAlgebra.scala b/algebird-core/src/main/scala/com/twitter/algebird/MapAlgebra.scala index 4f7969810..60ce15340 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/MapAlgebra.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/MapAlgebra.scala @@ -15,24 +15,24 @@ limitations under the License. */ package com.twitter.algebird -import scala.collection.{Map => ScMap} -import scala.collection.mutable.{Map => MMap} +import scala.collection.{ Map => ScMap } +import scala.collection.mutable.{ Map => MMap } trait MapOperations[K, V, M <: ScMap[K, V]] { - def add(oldMap: M, kv: (K,V)): M + def add(oldMap: M, kv: (K, V)): M def remove(oldMap: M, k: K): M def fromMutable(mut: MMap[K, V]): M } abstract class GenericMapMonoid[K, V, M <: ScMap[K, V]](implicit val semigroup: Semigroup[V]) - extends Monoid[M] with MapOperations[K, V, M] { + extends Monoid[M] with MapOperations[K, V, M] { val nonZero: (V => Boolean) = semigroup match { case mon: Monoid[_] => mon.isNonZero(_) case _ => (_ => true) } - override def isNonZero(x : M) = + override def isNonZero(x: M) = !x.isEmpty && (semigroup match { case mon: Monoid[_] => x.valuesIterator.exists { v => mon.isNonZero(v) @@ -40,25 +40,25 @@ abstract class GenericMapMonoid[K, V, M <: ScMap[K, V]](implicit val semigroup: case _ => true }) - override def plus(x : M, y : M) = { + override def plus(x: M, y: M) = { // Scala maps can reuse internal structure, so don't copy just add into the bigger one: // This really saves computation when adding lots of small maps into big ones (common) - val (big, small, bigOnLeft) = if(x.size > y.size) { (x,y,true) } else { (y,x,false) } + val (big, small, bigOnLeft) = if (x.size > y.size) { (x, y, true) } else { (y, x, false) } small match { // Mutable maps create new copies of the underlying data on add so don't use the // handleImmutable method. // Cannot have a None so 'get' is safe here. - case mmap: MMap[_,_] => sumOption(Seq(big, small)).get + case mmap: MMap[_, _] => sumOption(Seq(big, small)).get case _ => handleImmutable(big, small, bigOnLeft) } } - private def handleImmutable(big: M, small:M, bigOnLeft: Boolean) = { + private def handleImmutable(big: M, small: M, bigOnLeft: Boolean) = { small.foldLeft(big) { (oldMap, kv) => val newV = big .get(kv._1) .map { bigV => - if(bigOnLeft) + if (bigOnLeft) semigroup.plus(bigV, kv._2) else semigroup.plus(kv._2, bigV) @@ -71,39 +71,40 @@ abstract class GenericMapMonoid[K, V, M <: ScMap[K, V]](implicit val semigroup: } } override def sumOption(items: TraversableOnce[M]): Option[M] = - if(items.isEmpty) None + if (items.isEmpty) None else { - val mutable = MMap[K,V]() + val mutable = MMap[K, V]() items.foreach { m => - m.foreach { case (k, v) => - val oldVOpt = mutable.get(k) - // sorry for the micro optimization here: avoiding a closure - val newV = if(oldVOpt.isEmpty) v else Semigroup.plus(oldVOpt.get, v) - if (nonZero(newV)) - mutable.update(k, newV) - else - mutable.remove(k) + m.foreach { + case (k, v) => + val oldVOpt = mutable.get(k) + // sorry for the micro optimization here: avoiding a closure + val newV = if (oldVOpt.isEmpty) v else Semigroup.plus(oldVOpt.get, v) + if (nonZero(newV)) + mutable.update(k, newV) + else + mutable.remove(k) } } Some(fromMutable(mutable)) } } -class MapMonoid[K,V](implicit semigroup: Semigroup[V]) extends GenericMapMonoid[K, V, Map[K,V]] { - override lazy val zero = Map[K,V]() - override def add(oldMap: Map[K,V], kv: (K, V)) = oldMap + kv - override def remove(oldMap: Map[K,V], k: K) = oldMap - k - override def fromMutable(mut: MMap[K, V]): Map[K,V] = new MutableBackedMap(mut) +class MapMonoid[K, V](implicit semigroup: Semigroup[V]) extends GenericMapMonoid[K, V, Map[K, V]] { + override lazy val zero = Map[K, V]() + override def add(oldMap: Map[K, V], kv: (K, V)) = oldMap + kv + override def remove(oldMap: Map[K, V], k: K) = oldMap - k + override def fromMutable(mut: MMap[K, V]): Map[K, V] = new MutableBackedMap(mut) } -class ScMapMonoid[K,V](implicit semigroup: Semigroup[V]) extends GenericMapMonoid[K, V, ScMap[K,V]] { - override lazy val zero = ScMap[K,V]() - override def add(oldMap: ScMap[K,V], kv: (K, V)) = oldMap + kv - override def remove(oldMap: ScMap[K,V], k: K) = oldMap - k - override def fromMutable(mut: MMap[K, V]): ScMap[K,V] = new MutableBackedMap(mut) +class ScMapMonoid[K, V](implicit semigroup: Semigroup[V]) extends GenericMapMonoid[K, V, ScMap[K, V]] { + override lazy val zero = ScMap[K, V]() + override def add(oldMap: ScMap[K, V], kv: (K, V)) = oldMap + kv + override def remove(oldMap: ScMap[K, V], k: K) = oldMap - k + override def fromMutable(mut: MMap[K, V]): ScMap[K, V] = new MutableBackedMap(mut) } -private[this] class MutableBackedMap[K,V](val backingMap: MMap[K,V]) extends Map[K,V] { +private[this] class MutableBackedMap[K, V](val backingMap: MMap[K, V]) extends Map[K, V] { def get(key: K) = backingMap.get(key) def iterator = backingMap.iterator @@ -113,57 +114,59 @@ private[this] class MutableBackedMap[K,V](val backingMap: MMap[K,V]) extends Map def -(key: K) = backingMap.toMap - key } -/** You can think of this as a Sparse vector group +/** + * You can think of this as a Sparse vector group */ -class MapGroup[K,V](implicit val group : Group[V]) extends MapMonoid[K,V]()(group) - with Group[Map[K,V]] { - override def negate(kv : Map[K,V]) = kv.mapValues { v => group.negate(v) } +class MapGroup[K, V](implicit val group: Group[V]) extends MapMonoid[K, V]()(group) + with Group[Map[K, V]] { + override def negate(kv: Map[K, V]) = kv.mapValues { v => group.negate(v) } } -class ScMapGroup[K,V](implicit val group : Group[V]) extends ScMapMonoid[K,V]()(group) - with Group[ScMap[K,V]] { - override def negate(kv : ScMap[K,V]) = kv.mapValues { v => group.negate(v) } +class ScMapGroup[K, V](implicit val group: Group[V]) extends ScMapMonoid[K, V]()(group) + with Group[ScMap[K, V]] { + override def negate(kv: ScMap[K, V]) = kv.mapValues { v => group.negate(v) } } -/** You can think of this as a Sparse vector ring +/** + * You can think of this as a Sparse vector ring */ trait GenericMapRing[K, V, M <: ScMap[K, V]] extends Ring[M] with MapOperations[K, V, M] { - implicit def ring : Ring[V] + implicit def ring: Ring[V] // It is possible to implement this, but we need a special "identity map" which we // deal with as if it were map with all possible keys (.get(x) == ring.one for all x). // Then we have to manage the delta from this map as we add elements. That said, it // is not actually needed in matrix multiplication, so we are punting on it for now. override def one = sys.error("multiplicative identity for Map unimplemented") - override def times(x : M, y : M) : M = { - val (big, small, bigOnLeft) = if(x.size > y.size) { (x,y,true) } else { (y,x,false) } + override def times(x: M, y: M): M = { + val (big, small, bigOnLeft) = if (x.size > y.size) { (x, y, true) } else { (y, x, false) } small.foldLeft(zero) { (oldMap, kv) => val bigV = big.getOrElse(kv._1, ring.zero) - val newV = if(bigOnLeft) ring.times(bigV, kv._2) else ring.times(kv._2, bigV) + val newV = if (bigOnLeft) ring.times(bigV, kv._2) else ring.times(kv._2, bigV) if (ring.isNonZero(newV)) { add(oldMap, (kv._1 -> newV)) - } - else { + } else { remove(oldMap, kv._1) } } } } -class MapRing[K,V](implicit val ring : Ring[V]) extends MapGroup[K,V]()(ring) +class MapRing[K, V](implicit val ring: Ring[V]) extends MapGroup[K, V]()(ring) with GenericMapRing[K, V, Map[K, V]] -class ScMapRing[K,V](implicit val ring : Ring[V]) extends ScMapGroup[K,V]()(ring) +class ScMapRing[K, V](implicit val ring: Ring[V]) extends ScMapGroup[K, V]()(ring) with GenericMapRing[K, V, ScMap[K, V]] object MapAlgebra { - def rightContainsLeft[K,V: Equiv](l: Map[K, V], r: Map[K, V]): Boolean = - l.forall { case (k, v) => - r.get(k).exists(Equiv[V].equiv(_, v)) + def rightContainsLeft[K, V: Equiv](l: Map[K, V], r: Map[K, V]): Boolean = + l.forall { + case (k, v) => + r.get(k).exists(Equiv[V].equiv(_, v)) } - implicit def sparseEquiv[K,V: Monoid: Equiv]: Equiv[Map[K, V]] = { + implicit def sparseEquiv[K, V: Monoid: Equiv]: Equiv[Map[K, V]] = { Equiv.fromFunction { (m1, m2) => val cleanM1 = removeZeros(m1) val cleanM2 = removeZeros(m2) @@ -179,41 +182,44 @@ object MapAlgebra { } // Returns a new map with zero-value entries removed - def removeZeros[K,V:Monoid](m: Map[K,V]): Map[K,V] = - m filter { case (_,v) => Monoid.isNonZero(v) } + def removeZeros[K, V: Monoid](m: Map[K, V]): Map[K, V] = + m filter { case (_, v) => Monoid.isNonZero(v) } // groupBy ks, sum all the vs - def sumByKey[K,V:Semigroup](pairs: TraversableOnce[(K,V)]): Map[K,V] = + def sumByKey[K, V: Semigroup](pairs: TraversableOnce[(K, V)]): Map[K, V] = Monoid.sum(pairs map { Map(_) }) // Consider this as edges from k -> v, produce a Map[K,Set[V]] - def toGraph[K,V](pairs: TraversableOnce[(K,V)]): Map[K, Set[V]] = - Monoid.sum(pairs.map { case (k,v) => Map(k -> Set(v)) }) + def toGraph[K, V](pairs: TraversableOnce[(K, V)]): Map[K, Set[V]] = + Monoid.sum(pairs.map { case (k, v) => Map(k -> Set(v)) }) /** join the keys of two maps (similar to outer-join in a DB) */ - def join[K,V,W](map1: Map[K,V], map2: Map[K,W]): Map[K,(Option[V],Option[W])] = + def join[K, V, W](map1: Map[K, V], map2: Map[K, W]): Map[K, (Option[V], Option[W])] = Monoid.plus(map1.mapValues { v => (List(v), List[W]()) }, map2.mapValues { w => (List[V](), List(w)) }) - .mapValues { case (v,w) => (v.headOption, w.headOption) } + .mapValues { case (v, w) => (v.headOption, w.headOption) } - /** Reverses a graph losslessly + /** + * Reverses a graph losslessly * None key is for v's with no sources. */ - def invertExact[K,V](m: Map[Option[K], Set[V]]): Map[Option[V], Set[K]] = { + def invertExact[K, V](m: Map[Option[K], Set[V]]): Map[Option[V], Set[K]] = { def nonEmptyIter[T](i: Iterable[T]): Iterable[Option[T]] = - if(i.isEmpty) Iterable(None) else { i.map { Some(_) } } + if (i.isEmpty) Iterable(None) else { i.map { Some(_) } } Monoid.sum { - for((k, sv) <- m.view.toIterable; - v <- nonEmptyIter(sv)) yield Map(v -> k.toSet) + for ( + (k, sv) <- m.view.toIterable; + v <- nonEmptyIter(sv) + ) yield Map(v -> k.toSet) } } - /** Invert the Common case of exactly one value for each key + /** + * Invert the Common case of exactly one value for each key */ - def invert[K,V](m: Map[K,V]): Map[V, Set[K]] = - Monoid.sum(m.view.toIterable.map { case (k,v) => Map(v -> Set(k)) }) + def invert[K, V](m: Map[K, V]): Map[V, Set[K]] = + Monoid.sum(m.view.toIterable.map { case (k, v) => Map(v -> Set(k)) }) - def dot[K,V](left : Map[K,V], right : Map[K,V]) - (implicit mring: Ring[Map[K,V]], mon: Monoid[V]): V = + def dot[K, V](left: Map[K, V], right: Map[K, V])(implicit mring: Ring[Map[K, V]], mon: Monoid[V]): V = Monoid.sum(mring.times(left, right).values) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Metric.scala b/algebird-core/src/main/scala/com/twitter/algebird/Metric.scala index 984dff51d..0d366de9d 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Metric.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Metric.scala @@ -16,7 +16,7 @@ limitations under the License. package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } import scala.annotation.implicitNotFound /** @@ -31,14 +31,14 @@ import scala.annotation.implicitNotFound * */ object Metric { - def apply[V : Metric](v1: V, v2: V): Double = implicitly[Metric[V]].apply(v1, v2) - def norm[V : Metric : Monoid](v: V) = apply(v, Monoid.zero[V]) + def apply[V: Metric](v1: V, v2: V): Double = implicitly[Metric[V]].apply(v1, v2) + def norm[V: Metric: Monoid](v: V) = apply(v, Monoid.zero[V]) def from[V](f: (V, V) => Double) = new Metric[V] { def apply(v1: V, v2: V) = f(v1, v2) } // See http://en.wikipedia.org/wiki/Minkowski_distance - def minkowskiIterable[V : Monoid : Metric](p: Double): Metric[Iterable[V]] = Metric.from{ + def minkowskiIterable[V: Monoid: Metric](p: Double): Metric[Iterable[V]] = Metric.from{ (a: Iterable[V], b: Iterable[V]) => // TODO: copied from IndexedSeq.scala @@ -46,27 +46,27 @@ object Metric { val maxSize = scala.math.max(a.size, b.size) def pad(v: Iterable[V]) = { val diff = maxSize - v.size - if(diff > 0) { + if (diff > 0) { v ++ (Iterator.fill(diff)(Monoid.zero[V])) - } - else { + } else { v } } - val outP = pad(a).view + val outP = pad(a).view .zip(pad(b)) - .map { case(i, j) => - math.pow(implicitly[Metric[V]].apply(i, j), p) + .map { + case (i, j) => + math.pow(implicitly[Metric[V]].apply(i, j), p) }.sum math.pow(outP, 1.0 / p) } - def L1Iterable[V : Monoid : Metric] = minkowskiIterable[V](1.0) - def L2Iterable[V : Monoid : Metric] = minkowskiIterable[V](2.0) + def L1Iterable[V: Monoid: Metric] = minkowskiIterable[V](1.0) + def L2Iterable[V: Monoid: Metric] = minkowskiIterable[V](2.0) // TODO: Implement Linf, using an ordering on V - def minkowskiMap[K, V : Monoid : Metric](p: Double): Metric[Map[K, V]] = Metric.from{ + def minkowskiMap[K, V: Monoid: Metric](p: Double): Metric[Map[K, V]] = Metric.from{ (a: Map[K, V], b: Map[K, V]) => val outP = (a.keySet ++ b.keySet) .map{ key: K => @@ -78,8 +78,8 @@ object Metric { math.pow(outP, 1.0 / p) } - def L1Map[K, V : Monoid : Metric] = minkowskiMap[K, V](1.0) - def L2Map[K, V : Monoid : Metric] = minkowskiMap[K, V](2.0) + def L1Map[K, V: Monoid: Metric] = minkowskiMap[K, V](1.0) + def L2Map[K, V: Monoid: Metric] = minkowskiMap[K, V](2.0) // Implicit values implicit val doubleMetric = Metric.from((a: Double, b: Double) => math.abs(a - b)) @@ -87,20 +87,20 @@ object Metric { implicit val longMetric = Metric.from((a: Long, b: Long) => math.abs((a - b).toDouble)) implicit val floatMetric = Metric.from((a: Float, b: Float) => math.abs((a.toDouble - b.toDouble))) implicit val shortMetric = Metric.from((a: Short, b: Short) => math.abs((a - b).toDouble)) - implicit val boolMetric = Metric.from((x: Boolean, y: Boolean) => if(x ^ y) 1.0 else 0.0 ) + implicit val boolMetric = Metric.from((x: Boolean, y: Boolean) => if (x ^ y) 1.0 else 0.0) implicit val jDoubleMetric = Metric.from((a: JDouble, b: JDouble) => math.abs(a - b)) implicit val jIntMetric = Metric.from((a: JInt, b: JInt) => math.abs((a - b).toDouble)) implicit val jLongMetric = Metric.from((a: JLong, b: JLong) => math.abs((a - b).toDouble)) implicit val jFloatMetric = Metric.from((a: JFloat, b: JFloat) => math.abs((a.toDouble - b.toDouble))) implicit val jShortMetric = Metric.from((a: JShort, b: JShort) => math.abs((a - b).toDouble)) - implicit val jBoolMetric = Metric.from((x: JBool, y: JBool) => if(x ^ y) 1.0 else 0.0 ) + implicit val jBoolMetric = Metric.from((x: JBool, y: JBool) => if (x ^ y) 1.0 else 0.0) // If you don't want to use L2 as your default metrics, you need to override these - implicit def iterableMetric[V : Monoid : Metric] = L2Iterable[V] - implicit def mapMetric[K, V : Monoid : Metric] = L2Map[K, V] + implicit def iterableMetric[V: Monoid: Metric] = L2Iterable[V] + implicit def mapMetric[K, V: Monoid: Metric] = L2Map[K, V] } @implicitNotFound(msg = "Cannot find Metric type class for ${V}") -trait Metric[@specialized(Int,Long,Float,Double) -V] extends java.io.Serializable { +trait Metric[@specialized(Int, Long, Float, Double) -V] extends java.io.Serializable { def apply(v1: V, v2: V): Double } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/MinHasher.scala b/algebird-core/src/main/scala/com/twitter/algebird/MinHasher.scala index f059e8f34..5785c8078 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/MinHasher.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/MinHasher.scala @@ -12,15 +12,15 @@ case class MinHashSignature(bytes: Array[Byte]) object MinHasher { /** Numerically solve the inverse of estimatedThreshold, given numBands*numRows */ - def pickBands(threshold : Double, hashes : Int) = { + def pickBands(threshold: Double, hashes: Int) = { val target = hashes * -1 * math.log(threshold) var bands = 1 - while(bands * math.log(bands) < target) + while (bands * math.log(bands) < target) bands += 1 bands } - def pickHashesAndBands(threshold : Double, maxHashes : Int) = { + def pickHashesAndBands(threshold: Double, maxHashes: Int) = { val bands = pickBands(threshold, maxHashes) val hashes = (maxHashes / bands) * bands (hashes, bands) @@ -29,35 +29,35 @@ object MinHasher { } /** - * Instances of MinHasher can create, combine, and compare fixed-sized signatures of - * arbitrarily sized sets. - * - * A signature is represented by a byte array of approx maxBytes size. - * You can initialize a signature with a single element, usually a Long or String. - * You can combine any two set's signatures to produce the signature of their union. - * You can compare any two set's signatures to estimate their Jaccard similarity. - * You can use a set's signature to estimate the number of distinct values in the set. - * You can also use a combination of the above to estimate the size of the intersection of - * two sets from their signatures. - * The more bytes in the signature, the more accurate all of the above will be. - * - * You can also use these signatures to quickly find similar sets without doing - * n^2 comparisons. Each signature is assigned to several buckets; sets whose signatures - * end up in the same bucket are likely to be similar. The targetThreshold controls - * the desired level of similarity - the higher the threshold, the more efficiently - * you can find all the similar sets. - * - * This abstract superclass is generic with regards to the size of the hash used. - * Depending on the number of unique values in the domain of the sets, you may want - * a MinHasher16, a MinHasher32, or a new custom subclass. - * - * This implementation is modeled after Chapter 3 of Ullman and Rajaraman's Mining of Massive Datasets: - * http://infolab.stanford.edu/~ullman/mmds/ch3a.pdf -**/ -abstract class MinHasher[H](val numHashes : Int, val numBands : Int)(implicit n : Numeric[H]) extends Monoid[MinHashSignature] { + * Instances of MinHasher can create, combine, and compare fixed-sized signatures of + * arbitrarily sized sets. + * + * A signature is represented by a byte array of approx maxBytes size. + * You can initialize a signature with a single element, usually a Long or String. + * You can combine any two set's signatures to produce the signature of their union. + * You can compare any two set's signatures to estimate their Jaccard similarity. + * You can use a set's signature to estimate the number of distinct values in the set. + * You can also use a combination of the above to estimate the size of the intersection of + * two sets from their signatures. + * The more bytes in the signature, the more accurate all of the above will be. + * + * You can also use these signatures to quickly find similar sets without doing + * n^2 comparisons. Each signature is assigned to several buckets; sets whose signatures + * end up in the same bucket are likely to be similar. The targetThreshold controls + * the desired level of similarity - the higher the threshold, the more efficiently + * you can find all the similar sets. + * + * This abstract superclass is generic with regards to the size of the hash used. + * Depending on the number of unique values in the domain of the sets, you may want + * a MinHasher16, a MinHasher32, or a new custom subclass. + * + * This implementation is modeled after Chapter 3 of Ullman and Rajaraman's Mining of Massive Datasets: + * http://infolab.stanford.edu/~ullman/mmds/ch3a.pdf + */ +abstract class MinHasher[H](val numHashes: Int, val numBands: Int)(implicit n: Numeric[H]) extends Monoid[MinHashSignature] { /** The number of bytes used for each hash in the signature */ - def hashSize : Int + def hashSize: Int /** For explanation of the "bands" and "rows" see Ullman and Rajaraman */ val numBytes = numHashes * hashSize @@ -66,47 +66,47 @@ abstract class MinHasher[H](val numHashes : Int, val numBands : Int)(implicit n /** This seed could be anything */ private val seed = 123456789 - /** We always use a 128 bit hash function, so the number of hash functions is different - * (and usually smaller) than the number of hashes in the signature. - **/ + /** + * We always use a 128 bit hash function, so the number of hash functions is different + * (and usually smaller) than the number of hashes in the signature. + */ private val hashFunctions = { val r = new scala.util.Random(seed) val numHashFunctions = math.ceil(numBytes / 16.0).toInt - (1 to numHashFunctions).map{i => MurmurHash128(r.nextLong)} + (1 to numHashFunctions).map{ i => MurmurHash128(r.nextLong) } } /** Signature for empty set, needed to be a proper Monoid */ - val zero : MinHashSignature = MinHashSignature(buildArray{maxHash}) + val zero: MinHashSignature = MinHashSignature(buildArray{ maxHash }) /** Set union */ - def plus(left : MinHashSignature, right : MinHashSignature) : MinHashSignature = MinHashSignature( - buildArray(left.bytes, right.bytes){(l, r) => n.min(l, r)} - ) + def plus(left: MinHashSignature, right: MinHashSignature): MinHashSignature = MinHashSignature( + buildArray(left.bytes, right.bytes){ (l, r) => n.min(l, r) }) /** Esimate Jaccard similarity (size of union / size of intersection) */ - def similarity(left : MinHashSignature, right : MinHashSignature) : Double = - buildArray(left.bytes,right.bytes){(l,r) => if(l == r) n.one else n.zero} - .map{_.toDouble}.sum / numHashes + def similarity(left: MinHashSignature, right: MinHashSignature): Double = + buildArray(left.bytes, right.bytes){ (l, r) => if (l == r) n.one else n.zero } + .map{ _.toDouble }.sum / numHashes /** Bucket keys to use for quickly finding other similar items via locality sensitive hashing */ - def buckets(sig : MinHashSignature) : List[Long] = + def buckets(sig: MinHashSignature): List[Long] = sig.bytes.grouped(numRows * hashSize) - .filter{_.size == numRows * hashSize} - .map{hashFunctions.head(_)._1} + .filter{ _.size == numRows * hashSize } + .map{ hashFunctions.head(_)._1 } .toList /** Create a signature for a single Long value */ - def init(value : Long) : MinHashSignature = init{_(value)} + def init(value: Long): MinHashSignature = init{ _(value) } /** Create a signature for a single String value */ - def init(value : String) : MinHashSignature = init{_(value)} + def init(value: String): MinHashSignature = init{ _(value) } /** Create a signature for an arbitrary value */ - def init(fn : MurmurHash128 => (Long,Long)) : MinHashSignature = { + def init(fn: MurmurHash128 => (Long, Long)): MinHashSignature = { val bytes = new Array[Byte](numBytes) val buffer = ByteBuffer.allocate(hashFunctions.size * 16) val longBuffer = buffer.asLongBuffer - hashFunctions.foreach{h => + hashFunctions.foreach{ h => val (long1, long2) = fn(h) longBuffer.put(long1) longBuffer.put(long2) @@ -117,72 +117,72 @@ abstract class MinHasher[H](val numHashes : Int, val numBands : Int)(implicit n } /** Useful for understanding the effects of numBands and numRows */ - val estimatedThreshold = math.pow(1.0/numBands, 1.0/numRows) + val estimatedThreshold = math.pow(1.0 / numBands, 1.0 / numRows) /** Useful for understanding the effects of numBands and numRows */ - def probabilityOfInclusion(sim : Double) = 1.0 - math.pow(1.0 - math.pow(sim, numRows), numBands) + def probabilityOfInclusion(sim: Double) = 1.0 - math.pow(1.0 - math.pow(sim, numRows), numBands) /** Maximum value the hash can take on (not 2*hashSize because of signed types) */ - def maxHash : H + def maxHash: H /** Initialize a byte array by generating hash values */ - protected def buildArray(fn: => H) : Array[Byte] + protected def buildArray(fn: => H): Array[Byte] /** Decode two signatures into hash values, combine them somehow, and produce a new array */ - protected def buildArray(left : Array[Byte], right : Array[Byte])(fn: (H, H) => H) : Array[Byte] + protected def buildArray(left: Array[Byte], right: Array[Byte])(fn: (H, H) => H): Array[Byte] } -class MinHasher32(numHashes : Int, numBands : Int) extends MinHasher[Int](numHashes, numBands) { +class MinHasher32(numHashes: Int, numBands: Int) extends MinHasher[Int](numHashes, numBands) { - private def this(x : (Int, Int)) = this(x._1, x._2) + private def this(x: (Int, Int)) = this(x._1, x._2) - def this(targetThreshold : Double, maxBytes : Int) = this(MinHasher.pickHashesAndBands(targetThreshold, maxBytes / 4)) + def this(targetThreshold: Double, maxBytes: Int) = this(MinHasher.pickHashesAndBands(targetThreshold, maxBytes / 4)) override def hashSize = 4 override def maxHash = Int.MaxValue - override protected def buildArray(fn: => Int) : Array[Byte] = { + override protected def buildArray(fn: => Int): Array[Byte] = { val byteBuffer = ByteBuffer.allocate(numBytes) val writeBuffer = byteBuffer.asIntBuffer - 1.to(numHashes).foreach{i => writeBuffer.put(fn)} + 1.to(numHashes).foreach{ i => writeBuffer.put(fn) } byteBuffer.array } - override protected def buildArray(left : Array[Byte], right : Array[Byte])(fn: (Int,Int) => Int) : Array[Byte] = { + override protected def buildArray(left: Array[Byte], right: Array[Byte])(fn: (Int, Int) => Int): Array[Byte] = { val leftBuffer = ByteBuffer.wrap(left).asIntBuffer val rightBuffer = ByteBuffer.wrap(right).asIntBuffer - buildArray{fn(leftBuffer.get, rightBuffer.get)} + buildArray{ fn(leftBuffer.get, rightBuffer.get) } } /** Seems to work, but experimental and not generic yet */ - def approxCount(sig : Array[Byte]) = { + def approxCount(sig: Array[Byte]) = { val buffer = ByteBuffer.wrap(sig).asIntBuffer - val mean = 1.to(numHashes).map{i => buffer.get.toLong}.sum / numHashes + val mean = 1.to(numHashes).map{ i => buffer.get.toLong }.sum / numHashes (2L << 31) / (mean.toLong + (2L << 30)) } } -class MinHasher16(numHashes : Int, numBands : Int) extends MinHasher[Char](numHashes, numBands) { +class MinHasher16(numHashes: Int, numBands: Int) extends MinHasher[Char](numHashes, numBands) { - private def this(x : (Int, Int)) = this(x._1, x._2) + private def this(x: (Int, Int)) = this(x._1, x._2) - def this(targetThreshold : Double, maxBytes : Int) = this(MinHasher.pickHashesAndBands(targetThreshold, maxBytes / 2)) + def this(targetThreshold: Double, maxBytes: Int) = this(MinHasher.pickHashesAndBands(targetThreshold, maxBytes / 2)) override def hashSize = 2 override def maxHash = Char.MaxValue - override protected def buildArray(fn: => Char) : Array[Byte] = { + override protected def buildArray(fn: => Char): Array[Byte] = { val byteBuffer = ByteBuffer.allocate(numBytes) val writeBuffer = byteBuffer.asCharBuffer - 1.to(numHashes).foreach{i => writeBuffer.put(fn)} + 1.to(numHashes).foreach{ i => writeBuffer.put(fn) } byteBuffer.array } - override protected def buildArray(left : Array[Byte], right : Array[Byte])(fn: (Char,Char) => Char) : Array[Byte] = { + override protected def buildArray(left: Array[Byte], right: Array[Byte])(fn: (Char, Char) => Char): Array[Byte] = { val leftBuffer = ByteBuffer.wrap(left).asCharBuffer val rightBuffer = ByteBuffer.wrap(right).asCharBuffer - buildArray{fn(leftBuffer.get, rightBuffer.get)} + buildArray{ fn(leftBuffer.get, rightBuffer.get) } } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/MinPlus.scala b/algebird-core/src/main/scala/com/twitter/algebird/MinPlus.scala index f9a5f40f3..69c5acc70 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/MinPlus.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/MinPlus.scala @@ -41,7 +41,7 @@ class MinPlusSemiring[V](implicit monoid: Monoid[V], ord: Ordering[V]) extends R (left, right) match { case (MinPlusZero, _) => right case (_, MinPlusZero) => left - case (MinPlusValue(lv), MinPlusValue(rv)) => if(ord.lteq(lv, rv)) left else right + case (MinPlusValue(lv), MinPlusValue(rv)) => if (ord.lteq(lv, rv)) left else right } // a*b = a+b @@ -54,5 +54,5 @@ class MinPlusSemiring[V](implicit monoid: Monoid[V], ord: Ordering[V]) extends R } object MinPlus extends java.io.Serializable { - implicit def semiring[V:Monoid:Ordering]: Ring[MinPlus[V]] = new MinPlusSemiring[V] + implicit def semiring[V: Monoid: Ordering]: Ring[MinPlus[V]] = new MinPlusSemiring[V] } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/MomentsGroup.scala b/algebird-core/src/main/scala/com/twitter/algebird/MomentsGroup.scala index 8bc6042ae..05a206e06 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/MomentsGroup.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/MomentsGroup.scala @@ -23,19 +23,19 @@ package com.twitter.algebird * * m{i} denotes the ith central moment. */ -case class Moments(m0 : Long, m1 : Double, m2 : Double, m3 : Double, m4 : Double) { +case class Moments(m0: Long, m1: Double, m2: Double, m3: Double, m4: Double) { def count = m0 - + def mean = m1 - + // Population variance, not sample variance. def variance = m2 / count - + // Population standard deviation, not sample standard deviation. def stddev = math.sqrt(variance) - + def skewness = math.sqrt(count) * m3 / math.pow(m2, 1.5) - + def kurtosis = count * m4 / math.pow(m2, 2) - 3 } @@ -45,9 +45,9 @@ object Moments { // Create a Moments object given a single value. This is useful for // initializing moment calculations at the start of a stream. - def apply[V <% Double](value : V) = new Moments(1L, value, 0, 0, 0) - - def apply[V <% Double](m0 : Long, m1 : V, m2 : V, m3 : V, m4 : V) = + def apply[V <% Double](value: V) = new Moments(1L, value, 0, 0, 0) + + def apply[V <% Double](m0: Long, m1: V, m2: V, m3: V, m4: V) = new Moments(m0, m1, m2, m3, m4) } @@ -63,35 +63,35 @@ object MomentsGroup extends Group[Moments] { val zero = Moments(0L, 0.0, 0.0, 0.0, 0.0) - override def negate(a : Moments) : Moments = { + override def negate(a: Moments): Moments = { Moments(-a.count, a.m1, -a.m2, -a.m3, -a.m4) } - + // Combines the moment calculations from two streams. // See http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Higher-order_statistics // for more information on the formulas used to update the moments. - def plus(a : Moments, b : Moments) : Moments = { + def plus(a: Moments, b: Moments): Moments = { val delta = b.mean - a.mean val countCombined = a.count + b.count - if(countCombined == 0) + if (countCombined == 0) return zero - val meanCombined = getCombinedMean(a.count, a.mean, b.count, b.mean) + val meanCombined = getCombinedMean(a.count, a.mean, b.count, b.mean) - val m2 = a.m2 + b.m2 + - math.pow(delta, 2) * a.count * b.count / countCombined + val m2 = a.m2 + b.m2 + + math.pow(delta, 2) * a.count * b.count / countCombined - val m3 = a.m3 + b.m3 + - math.pow(delta, 3) * a.count * b.count * (a.count - b.count) / math.pow(countCombined, 2) + - 3 * delta * (a.count * b.m2 - b.count * a.m2) / countCombined + val m3 = a.m3 + b.m3 + + math.pow(delta, 3) * a.count * b.count * (a.count - b.count) / math.pow(countCombined, 2) + + 3 * delta * (a.count * b.m2 - b.count * a.m2) / countCombined - val m4 = a.m4 + b.m4 + - math.pow(delta, 4) * a.count * b.count * (math.pow(a.count, 2) - - a.count * b.count + math.pow(b.count, 2)) / math.pow(countCombined, 3) + - 6 * math.pow(delta, 2) * (math.pow(a.count, 2) * b.m2 + - math.pow(b.count, 2) * a.m2) / math.pow(countCombined, 2) + - 4 * delta * (a.count * b.m3 - b.count * a.m3) / countCombined + val m4 = a.m4 + b.m4 + + math.pow(delta, 4) * a.count * b.count * (math.pow(a.count, 2) - + a.count * b.count + math.pow(b.count, 2)) / math.pow(countCombined, 3) + + 6 * math.pow(delta, 2) * (math.pow(a.count, 2) * b.m2 + + math.pow(b.count, 2) * a.m2) / math.pow(countCombined, 2) + + 4 * delta * (a.count * b.m3 - b.count * a.m3) / countCombined - Moments(countCombined, meanCombined, m2, m3, m4) + Moments(countCombined, meanCombined, m2, m3, m4) } /** @@ -107,7 +107,7 @@ object MomentsGroup extends Group[Moments] { val (countBig, meanBig) = big val (countSmall, meanSmall) = small - + if (countSmall == 0) { meanBig } else { @@ -122,7 +122,7 @@ object MomentsGroup extends Group[Moments] { // Use this more stable formulation if the sizes of the two streams // are close. (countBig * meanBig + countSmall * meanSmall) / countCombined - + meanCombined } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Monad.scala b/algebird-core/src/main/scala/com/twitter/algebird/Monad.scala index 04a56f310..618f7f797 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Monad.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Monad.scala @@ -15,8 +15,8 @@ limitations under the License. */ package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} -import java.util.{List => JList, Map => JMap} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } +import java.util.{ List => JList, Map => JMap } import scala.annotation.implicitNotFound import collection.GenTraversable @@ -28,8 +28,8 @@ trait Monad[M[_]] { // in haskell, called return, but that's a reserved word // constructs a Monad instance from the given value, e.g. List(1) def apply[T](v: T): M[T] - def flatMap[T,U](m: M[T])(fn: (T) => M[U]): M[U] - def map[T,U](m: M[T])(fn: (T) => U): M[U] = flatMap(m)((t: T) => apply(fn(t))) + def flatMap[T, U](m: M[T])(fn: (T) => M[U]): M[U] + def map[T, U](m: M[T])(fn: (T) => U): M[U] = flatMap(m)((t: T) => apply(fn(t))) // Laws these must follow are: // identities: // flatMap(apply(x))(fn) == fn(x) @@ -38,58 +38,59 @@ trait Monad[M[_]] { // flatMap(flatMap(m)(f))(g) == flatMap(m) { x => flatMap(f(x))(g) } } - -/** For use from Java/minimizing code bloat in scala +/** + * For use from Java/minimizing code bloat in scala */ abstract class AbstractMonad[M[_]] extends Monad[M] -/** Follows the type-class pattern for the Monad trait +/** + * Follows the type-class pattern for the Monad trait */ object Monad { /** Get the Monad for a type, e.g: Monad[List] */ def apply[M[_]](implicit monad: Monad[M]): Monad[M] = monad - def flatMap[M[_],T,U](m: M[T])(fn: (T) => M[U])(implicit monad: Monad[M]) = monad.flatMap(m)(fn) - def map[M[_],T,U](m: M[T])(fn: (T) => U)(implicit monad: Monad[M]) = monad.map(m)(fn) - def foldM[M[_],T,U](acc: T, xs: GenTraversable[U])(fn: (T,U)=>M[T])(implicit monad: Monad[M]) : M[T] = - if(xs.isEmpty) + def flatMap[M[_], T, U](m: M[T])(fn: (T) => M[U])(implicit monad: Monad[M]) = monad.flatMap(m)(fn) + def map[M[_], T, U](m: M[T])(fn: (T) => U)(implicit monad: Monad[M]) = monad.map(m)(fn) + def foldM[M[_], T, U](acc: T, xs: GenTraversable[U])(fn: (T, U) => M[T])(implicit monad: Monad[M]): M[T] = + if (xs.isEmpty) monad.apply(acc) - else - monad.flatMap(fn(acc,xs.head)){t: T => foldM(t, xs.tail)(fn)} + else + monad.flatMap(fn(acc, xs.head)){ t: T => foldM(t, xs.tail)(fn) } // Some instances of the Monad typeclass (case for a macro): implicit val list: Monad[List] = new Monad[List] { def apply[T](v: T) = List(v); - def flatMap[T,U](m: List[T])(fn: (T) => List[U]) = m.flatMap(fn) + def flatMap[T, U](m: List[T])(fn: (T) => List[U]) = m.flatMap(fn) } implicit val option: Monad[Option] = new Monad[Option] { def apply[T](v: T) = Option(v); - def flatMap[T,U](m: Option[T])(fn: (T) => Option[U]) = m.flatMap(fn) + def flatMap[T, U](m: Option[T])(fn: (T) => Option[U]) = m.flatMap(fn) } implicit val some: Monad[Some] = new Monad[Some] { def apply[T](v: T) = Some(v); - def flatMap[T,U](m: Some[T])(fn: (T) => Some[U]) = fn(m.get) + def flatMap[T, U](m: Some[T])(fn: (T) => Some[U]) = fn(m.get) } implicit val vector: Monad[Vector] = new Monad[Vector] { def apply[T](v: T) = Vector(v); - def flatMap[T,U](m: Vector[T])(fn: (T) => Vector[U]) = m.flatMap(fn) + def flatMap[T, U](m: Vector[T])(fn: (T) => Vector[U]) = m.flatMap(fn) } implicit val set: Monad[Set] = new Monad[Set] { def apply[T](v: T) = Set(v); - def flatMap[T,U](m: Set[T])(fn: (T) => Set[U]) = m.flatMap(fn) + def flatMap[T, U](m: Set[T])(fn: (T) => Set[U]) = m.flatMap(fn) } implicit val seq: Monad[Seq] = new Monad[Seq] { def apply[T](v: T) = Seq(v); - def flatMap[T,U](m: Seq[T])(fn: (T) => Seq[U]) = m.flatMap(fn) + def flatMap[T, U](m: Seq[T])(fn: (T) => Seq[U]) = m.flatMap(fn) } implicit val indexedseq: Monad[IndexedSeq] = new Monad[IndexedSeq] { def apply[T](v: T) = IndexedSeq(v); - def flatMap[T,U](m: IndexedSeq[T])(fn: (T) => IndexedSeq[U]) = m.flatMap(fn) + def flatMap[T, U](m: IndexedSeq[T])(fn: (T) => IndexedSeq[U]) = m.flatMap(fn) } // Set up the syntax magic (allow .pure[Int] syntax and flatMap in for): // import Monad.{pureOp, operators} to get implicit def pureOp[A](a: A) = new PureOp(a) - implicit def operators[A,M[A]](m: M[A])(implicit monad: Monad[M]) = + implicit def operators[A, M[A]](m: M[A])(implicit monad: Monad[M]) = new MonadOperators(m)(monad) } @@ -100,48 +101,49 @@ class PureOp[A](a: A) { def pure[M[_]](implicit monad: Monad[M]) = monad(a) } -/** This enrichment allows us to use our Monad instances in for expressions: +/** + * This enrichment allows us to use our Monad instances in for expressions: * if (import Monad._) has been done */ -class MonadOperators[A,M[A]](m: M[A])(implicit monad: Monad[M]) { +class MonadOperators[A, M[A]](m: M[A])(implicit monad: Monad[M]) { // This is called fmap in haskell (and in Functor, not Monad) def map[U](fn: (A) => U): M[U] = monad.map(m)(fn) def flatMap[U](fn: (A) => M[U]): M[U] = monad.flatMap(m)(fn) } // This is a Semigroup, for all Monads. -class MonadSemigroup[T,M[_]](implicit monad: Monad[M], sg: Semigroup[T]) +class MonadSemigroup[T, M[_]](implicit monad: Monad[M], sg: Semigroup[T]) extends Semigroup[M[T]] { import Monad.operators - def plus(l: M[T], r: M[T]) = for(lv <- l; rv <- r) yield sg.plus(lv, rv) + def plus(l: M[T], r: M[T]) = for (lv <- l; rv <- r) yield sg.plus(lv, rv) } // This is a Monoid, for all Monads. -class MonadMonoid[T,M[_]](implicit monad: Monad[M], mon: Monoid[T]) - extends MonadSemigroup[T,M] with Monoid[M[T]] { +class MonadMonoid[T, M[_]](implicit monad: Monad[M], mon: Monoid[T]) + extends MonadSemigroup[T, M] with Monoid[M[T]] { lazy val zero = monad(mon.zero) } // Group, Ring, and Field ARE NOT AUTOMATIC. You have to check that the laws hold for your Monad. -class MonadGroup[T,M[_]](implicit monad: Monad[M], grp: Group[T]) - extends MonadMonoid[T,M] with Group[M[T]] { +class MonadGroup[T, M[_]](implicit monad: Monad[M], grp: Group[T]) + extends MonadMonoid[T, M] with Group[M[T]] { import Monad.operators override def negate(v: M[T]) = v.map { grp.negate(_) } - override def minus(l: M[T], r: M[T]) = for(lv <- l; rv <- r) yield grp.minus(lv, rv) + override def minus(l: M[T], r: M[T]) = for (lv <- l; rv <- r) yield grp.minus(lv, rv) } -class MonadRing[T,M[_]](implicit monad: Monad[M], ring: Ring[T]) - extends MonadGroup[T,M] with Ring[M[T]] { +class MonadRing[T, M[_]](implicit monad: Monad[M], ring: Ring[T]) + extends MonadGroup[T, M] with Ring[M[T]] { import Monad.operators lazy val one = monad(ring.one) - def times(l: M[T], r: M[T]) = for(lv <- l; rv <- r) yield ring.times(lv, rv) + def times(l: M[T], r: M[T]) = for (lv <- l; rv <- r) yield ring.times(lv, rv) } -class MonadField[T,M[_]](implicit monad: Monad[M], fld: Field[T]) - extends MonadRing[T,M] with Field[M[T]] { +class MonadField[T, M[_]](implicit monad: Monad[M], fld: Field[T]) + extends MonadRing[T, M] with Field[M[T]] { import Monad.operators override def inverse(v: M[T]) = v.map { fld.inverse(_) } - override def div(l: M[T], r: M[T]) = for(lv <- l; rv <- r) yield fld.div(lv, rv) + override def div(l: M[T], r: M[T]) = for (lv <- l; rv <- r) yield fld.div(lv, rv) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Monoid.scala b/algebird-core/src/main/scala/com/twitter/algebird/Monoid.scala index 6a7e757bd..263f13da8 100755 --- a/algebird-core/src/main/scala/com/twitter/algebird/Monoid.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Monoid.scala @@ -18,12 +18,11 @@ package com.twitter.algebird import scala.annotation.implicitNotFound import scala.math.Equiv -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} -import java.util.{List => JList, Map => JMap} - -import scala.collection.mutable.{Map => MMap} -import scala.collection.{Map => ScMap} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } +import java.util.{ List => JList, Map => JMap } +import scala.collection.mutable.{ Map => MMap } +import scala.collection.{ Map => ScMap } /** * Monoid (take a deep breath, and relax about the weird name): @@ -32,19 +31,18 @@ import scala.collection.{Map => ScMap} @implicitNotFound(msg = "Cannot find Monoid type class for ${T}") trait Monoid[@specialized(Int, Long, Float, Double) T] extends Semigroup[T] { - def zero : T //additive identity + def zero: T //additive identity def isNonZero(v: T): Boolean = (v != zero) - def assertNotZero(v : T) { - if(!isNonZero(v)) { + def assertNotZero(v: T) { + if (!isNonZero(v)) { throw new java.lang.IllegalArgumentException("argument should not be zero") } } - def nonZeroOption(v : T): Option[T] = { + def nonZeroOption(v: T): Option[T] = { if (isNonZero(v)) { Some(v) - } - else { + } else { None } } @@ -61,19 +59,17 @@ abstract class AbstractMonoid[T] extends Monoid[T] */ class OptionMonoid[T](implicit semi: Semigroup[T]) extends Monoid[Option[T]] { def zero = None - def plus(left : Option[T], right : Option[T]) : Option[T] = { - if(left.isEmpty) { + def plus(left: Option[T], right: Option[T]): Option[T] = { + if (left.isEmpty) { right - } - else if(right.isEmpty) { + } else if (right.isEmpty) { left - } - else { + } else { Some(semi.plus(left.get, right.get)) } } override def sumOption(items: TraversableOnce[Option[T]]): Option[Option[T]] = - if(items.isEmpty) None + if (items.isEmpty) None else Some(Semigroup.sumOption(items.filter(_.isDefined).map { _.get })) } @@ -83,37 +79,39 @@ class EitherMonoid[L, R](implicit semigroupl: Semigroup[L], monoidr: Monoid[R]) object StringMonoid extends Monoid[String] { override val zero = "" - override def plus(left : String, right : String) = left + right + override def plus(left: String, right: String) = left + right override def sumOption(items: TraversableOnce[String]): Option[String] = - if(items.isEmpty) None + if (items.isEmpty) None else Some(items.mkString("")) } -/** List concatenation monoid. +/** + * List concatenation monoid. * plus means concatenation, zero is empty list */ class ListMonoid[T] extends Monoid[List[T]] { override def zero = List[T]() - override def plus(left : List[T], right : List[T]) = left ++ right + override def plus(left: List[T], right: List[T]) = left ++ right override def sumOption(items: TraversableOnce[List[T]]): Option[List[T]] = - if(items.isEmpty) None - else Some(items.foldRight(Nil:List[T])(_ ::: _)) + if (items.isEmpty) None + else Some(items.foldRight(Nil: List[T])(_ ::: _)) } // equivalent to ListMonoid class SeqMonoid[T] extends Monoid[Seq[T]] { override def zero = Seq[T]() - override def plus(left : Seq[T], right : Seq[T]) = left ++ right + override def plus(left: Seq[T], right: Seq[T]) = left ++ right } -/** Set union monoid. +/** + * Set union monoid. * plus means union, zero is empty set */ class SetMonoid[T] extends Monoid[Set[T]] { override def zero = Set[T]() - override def plus(left : Set[T], right : Set[T]) = left ++ right + override def plus(left: Set[T], right: Set[T]) = left ++ right override def sumOption(items: TraversableOnce[Set[T]]): Option[Set[T]] = - if(items.isEmpty) None + if (items.isEmpty) None else { val mutable = scala.collection.mutable.Set[T]() items.foreach { s => mutable ++= s } @@ -121,7 +119,8 @@ class SetMonoid[T] extends Monoid[Set[T]] { } } -/** Function1 monoid. +/** + * Function1 monoid. * plus means function composition, zero is the identity function */ class Function1Monoid[T] extends Monoid[Function1[T, T]] { @@ -129,8 +128,8 @@ class Function1Monoid[T] extends Monoid[Function1[T, T]] { // (f1 + f2)(x) = f2(f1(x)) so that: // listOfFn.foldLeft(x) { (v, fn) => fn(v) } = (Monoid.sum(listOfFn))(x) - override def plus(f1 : Function1[T, T], f2 : Function1[T, T]) = { - (t : T) => f2(f1(t)) + override def plus(f1: Function1[T, T], f2: Function1[T, T]) = { + (t: T) => f2(f1(t)) } } @@ -141,7 +140,8 @@ object OrVal { implicit def monoid: Monoid[OrVal] = OrValMonoid } -/** Boolean OR monoid. +/** + * Boolean OR monoid. * plus means logical OR, zero is false. */ object OrValMonoid extends Monoid[OrVal] { @@ -156,12 +156,13 @@ object AndVal { implicit def monoid: Monoid[AndVal] = AndValMonoid } -/** Boolean AND monoid. +/** + * Boolean AND monoid. * plus means logical AND, zero is true. */ object AndValMonoid extends Monoid[AndVal] { override def zero = AndVal(true) - override def plus(l: AndVal, r: AndVal) = if(l.get) r else l + override def plus(l: AndVal, r: AndVal) = if (l.get) r else l } object Monoid extends GeneratedMonoidImplicits with ProductMonoids { @@ -174,30 +175,31 @@ object Monoid extends GeneratedMonoidImplicits with ProductMonoids { def isNonZero[T](v: T)(implicit monoid: Monoid[T]) = monoid.isNonZero(v) def nonZeroOption[T](v: T)(implicit monoid: Monoid[T]) = monoid.nonZeroOption(v) // Left sum: (((a + b) + c) + d) - def sum[T](iter : TraversableOnce[T])(implicit monoid: Monoid[T]): T = + def sum[T](iter: TraversableOnce[T])(implicit monoid: Monoid[T]): T = monoid.sum(iter) def from[T](z: => T)(associativeFn: (T, T) => T): Monoid[T] = new Monoid[T] { lazy val zero = z - def plus(l:T, r:T) = associativeFn(l, r) + def plus(l: T, r: T) = associativeFn(l, r) } - /** Return an Equiv[T] that uses isNonZero to return equality for all zeros + /** + * Return an Equiv[T] that uses isNonZero to return equality for all zeros * useful for Maps/Vectors that have many equivalent in memory representations of zero */ - def zeroEquiv[T:Equiv:Monoid]: Equiv[T] = Equiv.fromFunction { (a: T, b: T) => + def zeroEquiv[T: Equiv: Monoid]: Equiv[T] = Equiv.fromFunction { (a: T, b: T) => (!isNonZero(a) && !isNonZero(b)) || Equiv[T].equiv(a, b) } - /** Same as v + v + v .. + v (i times in total) + /** + * Same as v + v + v .. + v (i times in total) * requires i >= 0, wish we had NonnegativeBigInt as a class */ def intTimes[T](i: BigInt, v: T)(implicit mon: Monoid[T]): T = { require(i >= 0, "Cannot do negative products with a Monoid, try Group.intTimes") if (i == 0) { mon.zero - } - else { + } else { Semigroup.intTimes(i, v)(mon) } } @@ -221,7 +223,7 @@ object Monoid extends GeneratedMonoidImplicits with ProductMonoids { implicit def optionMonoid[T: Semigroup]: Monoid[Option[T]] = new OptionMonoid[T] implicit def listMonoid[T]: Monoid[List[T]] = new ListMonoid[T] implicit def seqMonoid[T]: Monoid[Seq[T]] = new SeqMonoid[T] - implicit def indexedSeqMonoid[T:Monoid]: Monoid[IndexedSeq[T]] = new IndexedSeqMonoid[T] + implicit def indexedSeqMonoid[T: Monoid]: Monoid[IndexedSeq[T]] = new IndexedSeqMonoid[T] implicit def jlistMonoid[T]: Monoid[JList[T]] = new JListMonoid[T] implicit def setMonoid[T]: Monoid[Set[T]] = new SetMonoid[T] implicit def mapMonoid[K, V: Semigroup]: Monoid[Map[K, V]] = new MapMonoid[K, V] diff --git a/algebird-core/src/main/scala/com/twitter/algebird/MurmurHash.scala b/algebird-core/src/main/scala/com/twitter/algebird/MurmurHash.scala index 4107b7e55..7dd9c2bb4 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/MurmurHash.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/MurmurHash.scala @@ -2,34 +2,34 @@ package com.twitter.algebird import java.nio._ -case class MurmurHash128(seed : Long) { - def apply(buffer : ByteBuffer, offset : Int, length : Int) : (Long,Long) = { +case class MurmurHash128(seed: Long) { + def apply(buffer: ByteBuffer, offset: Int, length: Int): (Long, Long) = { val longs = CassandraMurmurHash.hash3_x64_128(buffer, offset, length, seed) (longs(0), longs(1)) } - def apply(bytes : Array[Byte]) : (Long, Long) = apply(ByteBuffer.wrap(bytes), 0, bytes.length) - def apply(maxBytes : Int, fn : ByteBuffer => Unit) : (Long, Long) = { + def apply(bytes: Array[Byte]): (Long, Long) = apply(ByteBuffer.wrap(bytes), 0, bytes.length) + def apply(maxBytes: Int, fn: ByteBuffer => Unit): (Long, Long) = { val buffer = ByteBuffer.allocate(maxBytes) fn(buffer) apply(buffer, 0, maxBytes) } - def apply(array : Array[Char]) : (Long, Long) = apply(array.size * 2, {_.asCharBuffer.put(array)}) - def apply(array : Array[Short]) : (Long, Long) = apply(array.size * 2, {_.asShortBuffer.put(array)}) - def apply(array : Array[Int]) : (Long, Long) = apply(array.size * 4, {_.asIntBuffer.put(array)}) - def apply(array : Array[Float]) : (Long, Long) = apply(array.size * 4, {_.asFloatBuffer.put(array)}) - def apply(array : Array[Long]) : (Long, Long) = apply(array.size * 8, {_.asLongBuffer.put(array)}) - def apply(array : Array[Double]) : (Long, Long) = apply(array.size * 8, {_.asDoubleBuffer.put(array)}) + def apply(array: Array[Char]): (Long, Long) = apply(array.size * 2, { _.asCharBuffer.put(array) }) + def apply(array: Array[Short]): (Long, Long) = apply(array.size * 2, { _.asShortBuffer.put(array) }) + def apply(array: Array[Int]): (Long, Long) = apply(array.size * 4, { _.asIntBuffer.put(array) }) + def apply(array: Array[Float]): (Long, Long) = apply(array.size * 4, { _.asFloatBuffer.put(array) }) + def apply(array: Array[Long]): (Long, Long) = apply(array.size * 8, { _.asLongBuffer.put(array) }) + def apply(array: Array[Double]): (Long, Long) = apply(array.size * 8, { _.asDoubleBuffer.put(array) }) - def apply(value : Char) : (Long, Long)= apply(2, {_.asCharBuffer.put(value)}) - def apply(value : Short) : (Long, Long) = apply(2, {_.asShortBuffer.put(value)}) - def apply(value : Int) : (Long, Long) = apply(4, {_.asIntBuffer.put(value)}) - def apply(value : Float) : (Long, Long) = apply(4, {_.asFloatBuffer.put(value)}) - def apply(value : Long) : (Long, Long) = apply(8, {_.asLongBuffer.put(value)}) - def apply(value : Double) : (Long, Long) = apply(8, {_.asDoubleBuffer.put(value)}) + def apply(value: Char): (Long, Long) = apply(2, { _.asCharBuffer.put(value) }) + def apply(value: Short): (Long, Long) = apply(2, { _.asShortBuffer.put(value) }) + def apply(value: Int): (Long, Long) = apply(4, { _.asIntBuffer.put(value) }) + def apply(value: Float): (Long, Long) = apply(4, { _.asFloatBuffer.put(value) }) + def apply(value: Long): (Long, Long) = apply(8, { _.asLongBuffer.put(value) }) + def apply(value: Double): (Long, Long) = apply(8, { _.asDoubleBuffer.put(value) }) - def apply(string : CharSequence) : (Long, Long) = apply(string.length * 2, {buffer => + def apply(string: CharSequence): (Long, Long) = apply(string.length * 2, { buffer => val charBuffer = buffer.asCharBuffer - 0.to(string.length - 1).foreach{i => charBuffer.put(string.charAt(i))} + 0.to(string.length - 1).foreach{ i => charBuffer.put(string.charAt(i)) } }) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Operators.scala b/algebird-core/src/main/scala/com/twitter/algebird/Operators.scala index f0c992f8b..9dcdc468b 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Operators.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Operators.scala @@ -16,33 +16,33 @@ limitations under the License. package com.twitter.algebird object Operators { - implicit def toPlus[T : Semigroup](t : T) = new PlusOp(t) - implicit def toMinus[T : Group](t : T) = new MinusOp(t) - implicit def toTimes[T : Ring](t : T) = new TimesOp(t) - implicit def toDiv[T : Field](t : T) = new DivOp(t) - implicit def toRichTraversable[T](t : Traversable[T]) = new RichTraversable(t) + implicit def toPlus[T: Semigroup](t: T) = new PlusOp(t) + implicit def toMinus[T: Group](t: T) = new MinusOp(t) + implicit def toTimes[T: Ring](t: T) = new TimesOp(t) + implicit def toDiv[T: Field](t: T) = new DivOp(t) + implicit def toRichTraversable[T](t: Traversable[T]) = new RichTraversable(t) } -class PlusOp[T : Semigroup](t : T) { - def +(other : T) = implicitly[Semigroup[T]].plus(t, other) +class PlusOp[T: Semigroup](t: T) { + def +(other: T) = implicitly[Semigroup[T]].plus(t, other) } -class MinusOp[T : Group](t : T) { - def -(other : T) = implicitly[Group[T]].minus(t, other) +class MinusOp[T: Group](t: T) { + def -(other: T) = implicitly[Group[T]].minus(t, other) } -class TimesOp[T : Ring](t : T) { - def *(other : T) = implicitly[Ring[T]].times(t, other) +class TimesOp[T: Ring](t: T) { + def *(other: T) = implicitly[Ring[T]].times(t, other) } -class DivOp[T : Field](t : T) { - def /(other : T) = implicitly[Field[T]].div(t, other) +class DivOp[T: Field](t: T) { + def /(other: T) = implicitly[Field[T]].div(t, other) } -class RichTraversable[T](t : TraversableOnce[T]) { - def sumByKey[K,V](implicit ev: <:<[T,(K,V)], sg: Semigroup[V]): Map[K,V] = - MapAlgebra.sumByKey(t.map { _.asInstanceOf[(K,V)] }) +class RichTraversable[T](t: TraversableOnce[T]) { + def sumByKey[K, V](implicit ev: <:<[T, (K, V)], sg: Semigroup[V]): Map[K, V] = + MapAlgebra.sumByKey(t.map { _.asInstanceOf[(K, V)] }) - def monoidSum(implicit monoid : Monoid[T]) = Monoid.sum(t) - def ringProduct(implicit ring : Ring[T]) = Ring.product(t) + def monoidSum(implicit monoid: Monoid[T]) = Monoid.sum(t) + def ringProduct(implicit ring: Ring[T]) = Ring.product(t) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/OrderedSemigroup.scala b/algebird-core/src/main/scala/com/twitter/algebird/OrderedSemigroup.scala index 7aaf7df97..b4d602164 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/OrderedSemigroup.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/OrderedSemigroup.scala @@ -18,17 +18,17 @@ package com.twitter.algebird import scala.annotation.tailrec // To use the MaxSemigroup wrap your item in a Max object -case class Max[@specialized(Int,Long,Float,Double) +T](get: T) +case class Max[@specialized(Int, Long, Float, Double) +T](get: T) object Max { - implicit def semigroup[T](implicit ord:Ordering[T]) = - Semigroup.from[Max[T]] { (l,r) => if(ord.gteq(l.get, r.get)) l else r } + implicit def semigroup[T](implicit ord: Ordering[T]) = + Semigroup.from[Max[T]] { (l, r) => if (ord.gteq(l.get, r.get)) l else r } // Zero should have the property that it <= all T def monoid[T](zero: => T)(implicit ord: Ordering[T]): Monoid[Max[T]] = - Monoid.from(Max(zero)) { (l,r) => if(ord.gteq(l.get, r.get)) l else r } + Monoid.from(Max(zero)) { (l, r) => if (ord.gteq(l.get, r.get)) l else r } - def aggregator[T](implicit ord:Ordering[T]): MaxAggregator[T] = MaxAggregator()(ord) + def aggregator[T](implicit ord: Ordering[T]): MaxAggregator[T] = MaxAggregator()(ord) implicit def intMonoid: Monoid[Max[Int]] = monoid(Int.MinValue) implicit def longMonoid: Monoid[Max[Long]] = monoid(Long.MinValue) @@ -37,33 +37,33 @@ object Max { // These have a lower bound, but not an upperbound, so the Max forms a monoid: implicit def stringMonoid: Monoid[Max[String]] = monoid("") - implicit def listMonoid[T:Ordering]: Monoid[Max[List[T]]] = monoid[List[T]](Nil)(new Ordering[List[T]] { + implicit def listMonoid[T: Ordering]: Monoid[Max[List[T]]] = monoid[List[T]](Nil)(new Ordering[List[T]] { @tailrec final override def compare(left: List[T], right: List[T]): Int = { (left, right) match { case (Nil, Nil) => 0 case (Nil, _) => -1 case (_, Nil) => 1 - case (lh::lt, rh::rt) => + case (lh :: lt, rh :: rt) => val c = Ordering[T].compare(lh, rh) - if(c == 0) compare(lt, rt) else c + if (c == 0) compare(lt, rt) else c } } }) } // To use the MinSemigroup wrap your item in a Min object -case class Min[@specialized(Int,Long,Float,Double) +T](get: T) +case class Min[@specialized(Int, Long, Float, Double) +T](get: T) object Min { - implicit def semigroup[T](implicit ord:Ordering[T]) = - Semigroup.from[Min[T]] { (l,r) => if(ord.lteq(l.get, r.get)) l else r } + implicit def semigroup[T](implicit ord: Ordering[T]) = + Semigroup.from[Min[T]] { (l, r) => if (ord.lteq(l.get, r.get)) l else r } // Zero should have the property that it >= all T def monoid[T](zero: => T)(implicit ord: Ordering[T]): Monoid[Min[T]] = - Monoid.from(Min(zero)) { (l,r) => if(ord.lteq(l.get, r.get)) l else r } + Monoid.from(Min(zero)) { (l, r) => if (ord.lteq(l.get, r.get)) l else r } - def aggregator[T](implicit ord:Ordering[T]): MinAggregator[T] = MinAggregator()(ord) + def aggregator[T](implicit ord: Ordering[T]): MinAggregator[T] = MinAggregator()(ord) implicit def intMonoid: Monoid[Min[Int]] = monoid(Int.MaxValue) implicit def longMonoid: Monoid[Min[Long]] = monoid(Long.MaxValue) @@ -73,24 +73,24 @@ object Min { // Not ordered by type, but ordered by order in which we see them: -case class First[@specialized(Int,Long,Float,Double) +T](get: T) +case class First[@specialized(Int, Long, Float, Double) +T](get: T) object First { - implicit def semigroup[T] = Semigroup.from[First[T]] { (l,r) => l } + implicit def semigroup[T] = Semigroup.from[First[T]] { (l, r) => l } } -case class Last[@specialized(Int,Long,Float,Double) +T](get: T) +case class Last[@specialized(Int, Long, Float, Double) +T](get: T) object Last { - implicit def semigroup[T] = Semigroup.from[Last[T]] { (l,r) => r } + implicit def semigroup[T] = Semigroup.from[Last[T]] { (l, r) => r } } case class MinAggregator[T](implicit ord: Ordering[T]) extends Aggregator[T, T, T] { def prepare(v: T) = v - def reduce(l: T, r: T) = ord.min(l , r) + def reduce(l: T, r: T) = ord.min(l, r) def present(v: T) = v } case class MaxAggregator[T](implicit ord: Ordering[T]) extends Aggregator[T, T, T] { def prepare(v: T) = v - def reduce(l: T, r: T) = ord.max(l , r) + def reduce(l: T, r: T) = ord.max(l, r) def present(v: T) = v } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Predecessible.scala b/algebird-core/src/main/scala/com/twitter/algebird/Predecessible.scala index edc2293e0..9b4dc4547 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Predecessible.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Predecessible.scala @@ -32,8 +32,8 @@ trait Predecessible[T] extends java.io.Serializable { new AbstractIterable[T] { def iterator = Iterator.iterate[Option[T]](Some(old)) { self.prev(_) } - .takeWhile(_.isDefined) - .map(_.get) + .takeWhile(_.isDefined) + .map(_.get) } } def ordering: Ordering[T] @@ -50,7 +50,7 @@ object Predecessible extends java.io.Serializable { implicit def integralPrev[N: Integral]: Predecessible[N] = new IntegralPredecessible[N] } -class IntegralPredecessible[T:Integral] extends Predecessible[T] { +class IntegralPredecessible[T: Integral] extends Predecessible[T] { def prev(old: T) = { val numeric = implicitly[Integral[T]] val newV = numeric.minus(old, numeric.one) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/QTree.scala b/algebird-core/src/main/scala/com/twitter/algebird/QTree.scala index 371bc22c8..d45588095 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/QTree.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/QTree.scala @@ -38,7 +38,7 @@ package com.twitter.algebird */ object QTree { - def apply[A:Monoid](kv : (Double,A), level : Int = -16) : QTree[A] = { + def apply[A: Monoid](kv: (Double, A), level: Int = -16): QTree[A] = { QTree(math.floor(kv._1 / math.pow(2.0, level)).toLong, level, 1, @@ -47,7 +47,7 @@ object QTree { None) } - def apply[A:Monoid](kv : (Long,A)) : QTree[A] = { + def apply[A: Monoid](kv: (Long, A)): QTree[A] = { QTree(kv._1, 0, 1, @@ -57,39 +57,39 @@ object QTree { } /** - * The common case of wanting a count and sum for the same value - */ - def apply(k : Long) : QTree[Long] = apply(k -> k) - def apply(k : Double) : QTree[Double] = apply(k -> k) + * The common case of wanting a count and sum for the same value + */ + def apply(k: Long): QTree[Long] = apply(k -> k) + def apply(k: Double): QTree[Double] = apply(k -> k) } -class QTreeSemigroup[A:Monoid](k : Int) extends Semigroup[QTree[A]] { - def plus(left : QTree[A], right : QTree[A]) = left.merge(right).compress(k) +class QTreeSemigroup[A: Monoid](k: Int) extends Semigroup[QTree[A]] { + def plus(left: QTree[A], right: QTree[A]) = left.merge(right).compress(k) } case class QTree[A]( - offset : Long, //the range this tree covers is offset*(2^level) ... (offset+1)*(2^level) - level : Int, - count : Long, //the total count for this node and all of its children - sum : A, //the sum at just this node (*not* including its children) - lowerChild : Option[QTree[A]], - upperChild : Option[QTree[A]])(implicit monoid : Monoid[A]) { + offset: Long, //the range this tree covers is offset*(2^level) ... (offset+1)*(2^level) + level: Int, + count: Long, //the total count for this node and all of its children + sum: A, //the sum at just this node (*not* including its children) + lowerChild: Option[QTree[A]], + upperChild: Option[QTree[A]])(implicit monoid: Monoid[A]) { require(offset >= 0, "QTree can not accept negative values") - def range : Double = math.pow(2.0, level) - def lowerBound : Double = range * offset - def upperBound : Double = range * (offset + 1) + def range: Double = math.pow(2.0, level) + def lowerBound: Double = range * offset + def upperBound: Double = range * (offset + 1) - private def extendToLevel(n : Int) : QTree[A] = { - if(n <= level) + private def extendToLevel(n: Int): QTree[A] = { + if (n <= level) this else { val nextLevel = level + 1 val nextOffset = offset / 2 val parent = - if(offset % 2 == 0) + if (offset % 2 == 0) QTree[A](nextOffset, nextLevel, count, monoid.zero, Some(this), None) else QTree[A](nextOffset, nextLevel, count, monoid.zero, None, Some(this)) @@ -98,166 +98,166 @@ case class QTree[A]( } /** - * - * Find the smallest dyadic interval that contains the dyadic interval - * for this tree's root and the other tree's root, and return its - * level (that is, the power of 2 for the interval). - **/ + * + * Find the smallest dyadic interval that contains the dyadic interval + * for this tree's root and the other tree's root, and return its + * level (that is, the power of 2 for the interval). + */ - private def commonAncestorLevel(other : QTree[A]) = { + private def commonAncestorLevel(other: QTree[A]) = { val minLevel = level.min(other.level) val leftOffset = offset << (level - minLevel) val rightOffset = other.offset << (other.level - minLevel) var offsetDiff = leftOffset ^ rightOffset var ancestorLevel = minLevel - while(offsetDiff > 0) { + while (offsetDiff > 0) { ancestorLevel += 1 offsetDiff >>= 1 } ancestorLevel.max(level).max(other.level) } - def merge(other : QTree[A]) = { + def merge(other: QTree[A]) = { val commonAncestor = commonAncestorLevel(other) val left = extendToLevel(commonAncestor) val right = other.extendToLevel(commonAncestor) left.mergeWithPeer(right) } - private def mergeWithPeer(other : QTree[A]) : QTree[A] = { + private def mergeWithPeer(other: QTree[A]): QTree[A] = { assert(other.lowerBound == lowerBound, "lowerBound " + other.lowerBound + " != " + lowerBound) assert(other.level == level, "level " + other.level + " != " + level) copy(count = count + other.count, - sum = monoid.plus(sum, other.sum), - lowerChild = mergeOptions(lowerChild, other.lowerChild), - upperChild = mergeOptions(upperChild, other.upperChild)) + sum = monoid.plus(sum, other.sum), + lowerChild = mergeOptions(lowerChild, other.lowerChild), + upperChild = mergeOptions(upperChild, other.upperChild)) } - private def mergeOptions(a : Option[QTree[A]], b : Option[QTree[A]]) : Option[QTree[A]] = { - (a,b) match { + private def mergeOptions(a: Option[QTree[A]], b: Option[QTree[A]]): Option[QTree[A]] = { + (a, b) match { case (Some(qa), Some(qb)) => Some(qa.mergeWithPeer(qb)) case (None, _) => b case (_, None) => a } } - def quantileBounds(p : Double) : (Double, Double) = { + def quantileBounds(p: Double): (Double, Double) = { val rank = math.floor(count * p).toLong (findRankLowerBound(rank).get, findRankUpperBound(rank).get) } - private def findRankLowerBound(rank : Long) : Option[Double] = { - if(rank > count) + private def findRankLowerBound(rank: Long): Option[Double] = { + if (rank > count) None else { - val childCounts = mapChildrenWithDefault(0L){_.count} + val childCounts = mapChildrenWithDefault(0L){ _.count } val parentCount = count - childCounts._1 - childCounts._2 - lowerChild.flatMap{_.findRankLowerBound(rank - parentCount)}.orElse { + lowerChild.flatMap{ _.findRankLowerBound(rank - parentCount) }.orElse { val newRank = rank - childCounts._1 - parentCount - if(newRank <= 0) + if (newRank <= 0) Some(lowerBound) else - upperChild.flatMap{_.findRankLowerBound(newRank)} + upperChild.flatMap{ _.findRankLowerBound(newRank) } } } } - private def findRankUpperBound(rank : Long) : Option[Double] = { - if(rank > count) + private def findRankUpperBound(rank: Long): Option[Double] = { + if (rank > count) None else { - lowerChild.flatMap{_.findRankUpperBound(rank)}.orElse { - val lowerCount = lowerChild.map{_.count}.getOrElse(0L) - upperChild.flatMap{_.findRankUpperBound(rank - lowerCount)}.orElse(Some(upperBound)) + lowerChild.flatMap{ _.findRankUpperBound(rank) }.orElse { + val lowerCount = lowerChild.map{ _.count }.getOrElse(0L) + upperChild.flatMap{ _.findRankUpperBound(rank - lowerCount) }.orElse(Some(upperBound)) } } } - def rangeSumBounds(from : Double, to : Double) : (A,A) = { - if(from <= lowerBound && to >= upperBound) { + def rangeSumBounds(from: Double, to: Double): (A, A) = { + if (from <= lowerBound && to >= upperBound) { val s = totalSum - (s,s) - } else if(from < upperBound && to >= lowerBound) { - val ((lower1,upper1),(lower2,upper2)) = - mapChildrenWithDefault((monoid.zero,monoid.zero)){_.rangeSumBounds(from,to)} + (s, s) + } else if (from < upperBound && to >= lowerBound) { + val ((lower1, upper1), (lower2, upper2)) = + mapChildrenWithDefault((monoid.zero, monoid.zero)){ _.rangeSumBounds(from, to) } (monoid.plus(lower1, lower2), - monoid.plus(sum, monoid.plus(upper1, upper2))) + monoid.plus(sum, monoid.plus(upper1, upper2))) } else { - (monoid.zero,monoid.zero) + (monoid.zero, monoid.zero) } } - def rangeCountBounds(from : Double, to : Double) : (Long,Long) = { - if(from <= lowerBound && to >= upperBound) { + def rangeCountBounds(from: Double, to: Double): (Long, Long) = { + if (from <= lowerBound && to >= upperBound) { val s = count - (s,s) - } else if(from < upperBound && to >= lowerBound) { - val ((lower1,upper1),(lower2,upper2)) = - mapChildrenWithDefault((0L,0L)){_.rangeCountBounds(from,to)} + (s, s) + } else if (from < upperBound && to >= lowerBound) { + val ((lower1, upper1), (lower2, upper2)) = + mapChildrenWithDefault((0L, 0L)){ _.rangeCountBounds(from, to) } (lower1 + lower2, parentCount + upper1 + upper2) } else { (0L, 0L) } } - def compress(k : Int) = { + def compress(k: Int) = { val minCount = count >> k - val (newTree, pruned) = pruneChildrenWhere{_.count < minCount} + val (newTree, pruned) = pruneChildrenWhere{ _.count < minCount } newTree } - private def pruneChildrenWhere(fn : QTree[A] => Boolean) : (QTree[A], Boolean) = { - if(fn(this)) { + private def pruneChildrenWhere(fn: QTree[A] => Boolean): (QTree[A], Boolean) = { + if (fn(this)) { (copy(sum = totalSum, lowerChild = None, upperChild = None), true) } else { val (newLower, lowerPruned) = pruneChildWhere(lowerChild, fn) val (newUpper, upperPruned) = pruneChildWhere(upperChild, fn) - if(!lowerPruned && !upperPruned) + if (!lowerPruned && !upperPruned) (this, false) else (copy(lowerChild = newLower, upperChild = newUpper), true) } } - private def pruneChildWhere(child : Option[QTree[A]], fn : QTree[A] => Boolean) : (Option[QTree[A]], Boolean) = { - val result = child.map{_.pruneChildrenWhere(fn)} - (result.map{_._1}, result.map{_._2}.getOrElse(false)) + private def pruneChildWhere(child: Option[QTree[A]], fn: QTree[A] => Boolean): (Option[QTree[A]], Boolean) = { + val result = child.map{ _.pruneChildrenWhere(fn) } + (result.map{ _._1 }, result.map{ _._2 }.getOrElse(false)) } - def size : Int = { - val childSizes = mapChildrenWithDefault(0){_.size} + def size: Int = { + val childSizes = mapChildrenWithDefault(0){ _.size } 1 + childSizes._1 + childSizes._2 } - def totalSum : A = { - val childSums = mapChildrenWithDefault(monoid.zero){_.totalSum} + def totalSum: A = { + val childSums = mapChildrenWithDefault(monoid.zero){ _.totalSum } monoid.plus(sum, monoid.plus(childSums._1, childSums._2)) } - private def mapChildrenWithDefault[T](default : T)(fn : QTree[A] => T) : (T,T) = { + private def mapChildrenWithDefault[T](default: T)(fn: QTree[A] => T): (T, T) = { (lowerChild.map(fn).getOrElse(default), - upperChild.map(fn).getOrElse(default)) + upperChild.map(fn).getOrElse(default)) } private def parentCount = { - val childCounts = mapChildrenWithDefault(0L){_.count} + val childCounts = mapChildrenWithDefault(0L){ _.count } count - childCounts._1 - childCounts._2 } def dump { - for(i <- (20 to level by -1)) + for (i <- (20 to level by -1)) print(" ") print(lowerBound + " - " + upperBound + ": " + count) - if(lowerChild.isDefined || upperChild.isDefined) { + if (lowerChild.isDefined || upperChild.isDefined) { print(" (" + parentCount + ")") } println(" {" + sum + "}") - lowerChild.foreach{_.dump} - upperChild.foreach{_.dump} + lowerChild.foreach{ _.dump } + upperChild.foreach{ _.dump } } - def interQuartileMean(implicit n : Numeric[A]) : (Double,Double) = { + def interQuartileMean(implicit n: Numeric[A]): (Double, Double) = { val (l25, u25) = quantileBounds(0.25) val (l75, u75) = quantileBounds(0.75) val (ll, lu) = rangeSumBounds(l25, l75) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/ResetAlgebra.scala b/algebird-core/src/main/scala/com/twitter/algebird/ResetAlgebra.scala index 811471fe1..b1d48bc10 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/ResetAlgebra.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/ResetAlgebra.scala @@ -15,7 +15,8 @@ limitations under the License. */ package com.twitter.algebird -/** Used to represent cases where we need to periodically reset +/** + * Used to represent cases where we need to periodically reset * a + b = a + b * |a + b = |(a + b) * a + |b = |b @@ -26,7 +27,7 @@ case class SetValue[+A](get: A) extends ResetState[A] case class ResetValue[+A](get: A) extends ResetState[A] object ResetState { - implicit def monoid[A:Monoid]: Monoid[ResetState[A]] = new ResetStateMonoid[A] + implicit def monoid[A: Monoid]: Monoid[ResetState[A]] = new ResetStateMonoid[A] } class ResetStateMonoid[A](implicit monoid: Monoid[A]) extends Monoid[ResetState[A]] { diff --git a/algebird-core/src/main/scala/com/twitter/algebird/RightFolded.scala b/algebird-core/src/main/scala/com/twitter/algebird/RightFolded.scala index e73a1578d..664057908 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/RightFolded.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/RightFolded.scala @@ -25,24 +25,24 @@ package com.twitter.algebird * so this forms a kind of reset of the fold. */ object RightFolded { - def monoid[In,Out](foldfn : (In,Out) => Out) = - new Monoid[RightFolded[In,Out]] { - - val zero = RightFoldedZero - - def plus(left : RightFolded[In,Out], right : RightFolded[In,Out]) = left match { - case RightFoldedValue(_) => left - case RightFoldedZero => right - case RightFoldedToFold(lList) => right match { - case RightFoldedZero => RightFoldedToFold(lList) - case RightFoldedValue(vr) => RightFoldedValue(lList.foldRight(vr)(foldfn)) - case RightFoldedToFold(rList) => RightFoldedToFold(lList ++ rList) + def monoid[In, Out](foldfn: (In, Out) => Out) = + new Monoid[RightFolded[In, Out]] { + + val zero = RightFoldedZero + + def plus(left: RightFolded[In, Out], right: RightFolded[In, Out]) = left match { + case RightFoldedValue(_) => left + case RightFoldedZero => right + case RightFoldedToFold(lList) => right match { + case RightFoldedZero => RightFoldedToFold(lList) + case RightFoldedValue(vr) => RightFoldedValue(lList.foldRight(vr)(foldfn)) + case RightFoldedToFold(rList) => RightFoldedToFold(lList ++ rList) + } } } - } } -sealed abstract class RightFolded[+In,+Out] -case object RightFoldedZero extends RightFolded[Nothing,Nothing] -case class RightFoldedValue[+Out](v : Out) extends RightFolded[Nothing,Out] -case class RightFoldedToFold[+In](in : List[In]) extends RightFolded[In,Nothing] +sealed abstract class RightFolded[+In, +Out] +case object RightFoldedZero extends RightFolded[Nothing, Nothing] +case class RightFoldedValue[+Out](v: Out) extends RightFolded[Nothing, Out] +case class RightFoldedToFold[+In](in: List[In]) extends RightFolded[In, Nothing] diff --git a/algebird-core/src/main/scala/com/twitter/algebird/RightFolded2.scala b/algebird-core/src/main/scala/com/twitter/algebird/RightFolded2.scala index 54d801826..b3dcf5309 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/RightFolded2.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/RightFolded2.scala @@ -33,39 +33,37 @@ package com.twitter.algebird * sent to a single reducer and all the Accs are added up. */ object RightFolded2 { - def monoid[In,Out:Group](foldfn : (In,Out) => Out) = - new RightFolded2Monoid[In,Out,Out](foldfn, identity _) + def monoid[In, Out: Group](foldfn: (In, Out) => Out) = + new RightFolded2Monoid[In, Out, Out](foldfn, identity _) - def monoid[In,Out,Acc:Group](trans: (Out) => Acc)(foldfn: (In,Out) => Out) = - new RightFolded2Monoid[In,Out,Acc](foldfn, trans) + def monoid[In, Out, Acc: Group](trans: (Out) => Acc)(foldfn: (In, Out) => Out) = + new RightFolded2Monoid[In, Out, Acc](foldfn, trans) } -class RightFolded2Monoid[In,Out,Acc](foldfn: (In,Out) => Out, accfn: (Out) => Acc) - (implicit grpAcc: Group[Acc]) - extends Monoid[RightFolded2[In,Out,Acc]] { +class RightFolded2Monoid[In, Out, Acc](foldfn: (In, Out) => Out, accfn: (Out) => Acc)(implicit grpAcc: Group[Acc]) + extends Monoid[RightFolded2[In, Out, Acc]] { val zero = RightFoldedZero2 - def init(i: Out) = RightFoldedValue2[In,Out,Acc](i, accfn(i), Nil) + def init(i: Out) = RightFoldedValue2[In, Out, Acc](i, accfn(i), Nil) def toFold(v: In) = RightFoldedToFold2(List(v)) - protected def doFold(vals: List[In], init: Out, acc: Acc) : (Out,Acc) = { + protected def doFold(vals: List[In], init: Out, acc: Acc): (Out, Acc) = { val newV = vals.foldRight(init)(foldfn) val delta = grpAcc.plus(accfn(newV), grpAcc.negate(accfn(init))) (newV, grpAcc.plus(delta, acc)) } - def plus(left: RightFolded2[In,Out,Acc], right : RightFolded2[In,Out,Acc]) = left match { - case RightFoldedValue2(leftV,leftAcc,leftRvals) => { + def plus(left: RightFolded2[In, Out, Acc], right: RightFolded2[In, Out, Acc]) = left match { + case RightFoldedValue2(leftV, leftAcc, leftRvals) => { right match { case RightFoldedZero2 => left case RightFoldedToFold2(in) => RightFoldedValue2(leftV, leftAcc, leftRvals ++ in) - case RightFoldedValue2(rightV,rightAcc,rightRvals) => { + case RightFoldedValue2(rightV, rightAcc, rightRvals) => { if (leftRvals.isEmpty) { // This is the case of two initial values next to each other, return the left: val newAcc = grpAcc.plus(leftAcc, rightAcc) RightFoldedValue2(leftV, newAcc, rightRvals) - } - else { + } else { val (newV, newRightAcc) = doFold(leftRvals, rightV, rightAcc) // Now actually add the left value, with the right: val newAcc = grpAcc.plus(leftAcc, newRightAcc) @@ -78,7 +76,7 @@ class RightFolded2Monoid[In,Out,Acc](foldfn: (In,Out) => Out, accfn: (Out) => Ac case RightFoldedToFold2(lList) => right match { case RightFoldedZero2 => left case RightFoldedToFold2(rList) => RightFoldedToFold2(lList ++ rList) - case RightFoldedValue2(vr,accr,valsr) => { + case RightFoldedValue2(vr, accr, valsr) => { val (newV, newAcc) = doFold(lList, vr, accr) RightFoldedValue2(newV, newAcc, valsr) } @@ -86,7 +84,7 @@ class RightFolded2Monoid[In,Out,Acc](foldfn: (In,Out) => Out, accfn: (Out) => Ac } } -sealed abstract class RightFolded2[+In,+Out,+Acc] -case object RightFoldedZero2 extends RightFolded2[Nothing,Nothing,Nothing] -case class RightFoldedValue2[+In,+Out,+Acc](v: Out, acc: Acc, rvals: List[In]) extends RightFolded2[In,Out,Acc] -case class RightFoldedToFold2[+In](in: List[In]) extends RightFolded2[In,Nothing,Nothing] +sealed abstract class RightFolded2[+In, +Out, +Acc] +case object RightFoldedZero2 extends RightFolded2[Nothing, Nothing, Nothing] +case class RightFoldedValue2[+In, +Out, +Acc](v: Out, acc: Acc, rvals: List[In]) extends RightFolded2[In, Out, Acc] +case class RightFoldedToFold2[+In](in: List[In]) extends RightFolded2[In, Nothing, Nothing] diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Ring.scala b/algebird-core/src/main/scala/com/twitter/algebird/Ring.scala index 144f3e90d..41da0b917 100755 --- a/algebird-core/src/main/scala/com/twitter/algebird/Ring.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Ring.scala @@ -15,7 +15,7 @@ limitations under the License. */ package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } import scala.annotation.implicitNotFound /** @@ -27,11 +27,11 @@ import scala.annotation.implicitNotFound */ @implicitNotFound(msg = "Cannot find Ring type class for ${T}") -trait Ring[@specialized(Int,Long,Float,Double) T] extends Group[T] { - def one : T // Multiplicative identity - def times(l : T, r : T) : T +trait Ring[@specialized(Int, Long, Float, Double) T] extends Group[T] { + def one: T // Multiplicative identity + def times(l: T, r: T): T // Left product: (((a * b) * c) * d) - def product(iter : TraversableOnce[T]): T = Ring.product(iter)(this) + def product(iter: TraversableOnce[T]): T = Ring.product(iter)(this) } // For Java interop so they get the default methods @@ -49,42 +49,42 @@ class NumericRing[T](implicit num: Numeric[T]) extends Ring[T] { object IntRing extends Ring[Int] { override def zero = 0 override def one = 1 - override def negate(v : Int) = -v - override def plus(l : Int, r : Int) = l + r - override def minus(l : Int, r : Int) = l - r - override def times(l : Int, r : Int) = l * r + override def negate(v: Int) = -v + override def plus(l: Int, r: Int) = l + r + override def minus(l: Int, r: Int) = l - r + override def times(l: Int, r: Int) = l * r } object ShortRing extends Ring[Short] { override def zero = 0.toShort override def one = 1.toShort - override def negate(v : Short) = (-v).toShort - override def plus(l : Short, r : Short) = (l + r).toShort - override def minus(l : Short, r : Short) = (l - r).toShort - override def times(l : Short, r : Short) = (l * r).toShort + override def negate(v: Short) = (-v).toShort + override def plus(l: Short, r: Short) = (l + r).toShort + override def minus(l: Short, r: Short) = (l - r).toShort + override def times(l: Short, r: Short) = (l * r).toShort } object LongRing extends Ring[Long] { override def zero = 0L override def one = 1L - override def negate(v : Long) = -v - override def plus(l : Long, r : Long) = l + r - override def minus(l : Long, r : Long) = l - r - override def times(l : Long, r : Long) = l * r + override def negate(v: Long) = -v + override def plus(l: Long, r: Long) = l + r + override def minus(l: Long, r: Long) = l - r + override def times(l: Long, r: Long) = l * r } object BigIntRing extends NumericRing[BigInt] object Ring extends GeneratedRingImplicits with ProductRings { // This pattern is really useful for typeclasses - def one[T](implicit rng : Ring[T]) = rng.one - def times[T](l : T, r : T)(implicit rng : Ring[T]) = rng.times(l,r) + def one[T](implicit rng: Ring[T]) = rng.one + def times[T](l: T, r: T)(implicit rng: Ring[T]) = rng.times(l, r) def asTimesMonoid[T](implicit ring: Ring[T]): Monoid[T] = Monoid.from[T](ring.one)(ring.times _) // Left product: (((a * b) * c) * d) - def product[T](iter : TraversableOnce[T])(implicit ring : Ring[T]) = { + def product[T](iter: TraversableOnce[T])(implicit ring: Ring[T]) = { // avoid touching one unless we need to (some items are pseudo-rings) - if(iter.isEmpty) ring.one + if (iter.isEmpty) ring.one else iter.reduceLeft(ring.times _) } // If the ring doesn't have a one, or you want to distinguish empty cases: @@ -92,20 +92,20 @@ object Ring extends GeneratedRingImplicits with ProductRings { it.reduceLeftOption(rng.times _) implicit def numericRing[T: Numeric]: Ring[T] = new NumericRing[T] - implicit val boolRing : Ring[Boolean] = BooleanField - implicit val jboolRing : Ring[JBool] = JBoolField - implicit val intRing : Ring[Int] = IntRing - implicit val jintRing : Ring[JInt] = JIntRing - implicit val shortRing : Ring[Short] = ShortRing - implicit val jshortRing : Ring[JShort] = JShortRing - implicit val longRing : Ring[Long] = LongRing - implicit val bigIntRing : Ring[BigInt] = BigIntRing - implicit val jlongRing : Ring[JLong] = JLongRing - implicit val floatRing : Ring[Float] = FloatField - implicit val jfloatRing : Ring[JFloat] = JFloatField - implicit val doubleRing : Ring[Double] = DoubleField - implicit val jdoubleRing : Ring[JDouble] = JDoubleField - implicit def indexedSeqRing[T:Ring]: Ring[IndexedSeq[T]] = new IndexedSeqRing[T] - implicit def mapRing[K,V](implicit ring : Ring[V]) = new MapRing[K,V]()(ring) - implicit def scMapRing[K,V](implicit ring : Ring[V]) = new ScMapRing[K,V]()(ring) + implicit val boolRing: Ring[Boolean] = BooleanField + implicit val jboolRing: Ring[JBool] = JBoolField + implicit val intRing: Ring[Int] = IntRing + implicit val jintRing: Ring[JInt] = JIntRing + implicit val shortRing: Ring[Short] = ShortRing + implicit val jshortRing: Ring[JShort] = JShortRing + implicit val longRing: Ring[Long] = LongRing + implicit val bigIntRing: Ring[BigInt] = BigIntRing + implicit val jlongRing: Ring[JLong] = JLongRing + implicit val floatRing: Ring[Float] = FloatField + implicit val jfloatRing: Ring[JFloat] = JFloatField + implicit val doubleRing: Ring[Double] = DoubleField + implicit val jdoubleRing: Ring[JDouble] = JDoubleField + implicit def indexedSeqRing[T: Ring]: Ring[IndexedSeq[T]] = new IndexedSeqRing[T] + implicit def mapRing[K, V](implicit ring: Ring[V]) = new MapRing[K, V]()(ring) + implicit def scMapRing[K, V](implicit ring: Ring[V]) = new ScMapRing[K, V]()(ring) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SGDMonoid.scala b/algebird-core/src/main/scala/com/twitter/algebird/SGDMonoid.scala index d08395dec..706bd88b9 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SGDMonoid.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SGDMonoid.scala @@ -23,29 +23,27 @@ object SGD { * and note that the length of the IndexedSeq in the tuple is * one less than the weights (we don't carry the constant term) */ - val linearGradient : (IndexedSeq[Double], (Double, IndexedSeq[Double])) => IndexedSeq[Double] - = { (w, pos) => + val linearGradient: (IndexedSeq[Double], (Double, IndexedSeq[Double])) => IndexedSeq[Double] = { (w, pos) => val (y, xs) = pos val xsPlusConst = xs :+ 1.0 - val err = dot(w,xsPlusConst) - y + val err = dot(w, xsPlusConst) - y // Here is the gradient xsPlusConst.map { _ * err } } - def dot(x : IndexedSeq[Double], y : IndexedSeq[Double]) : Double = - x.view.zip(y).map { case (a: Double, b: Double) => a*b }.sum + def dot(x: IndexedSeq[Double], y: IndexedSeq[Double]): Double = + x.view.zip(y).map { case (a: Double, b: Double) => a * b }.sum // Here are some step algorithms: - def constantStep(s: Double) : (Long, IndexedSeq[Double]) => Double = { (_,_) => s } + def constantStep(s: Double): (Long, IndexedSeq[Double]) => Double = { (_, _) => s } // A standard: a/(steps + b)^c - def countAdaptiveStep(a : Double, b : Double, c : Double = 1.0) : - (Long, IndexedSeq[Double]) => Double = { (cnt,_) => - a/scala.math.pow((cnt + b), c) - } + def countAdaptiveStep(a: Double, b: Double, c: Double = 1.0): (Long, IndexedSeq[Double]) => Double = { (cnt, _) => + a / scala.math.pow((cnt + b), c) + } - def weightsOf[T](s: SGD[T]) : Option[IndexedSeq[Double]] = { + def weightsOf[T](s: SGD[T]): Option[IndexedSeq[Double]] = { s match { - case SGDWeights(_,w) => Some(w) + case SGDWeights(_, w) => Some(w) case _ => None } } @@ -54,8 +52,8 @@ object SGD { sealed abstract class SGD[+Pos] case object SGDZero extends SGD[Nothing] object SGDWeights { - def apply(w : IndexedSeq[Double]) = new SGDWeights(1L, w) - def average(left : SGDWeights, right : SGDWeights) : SGDWeights = { + def apply(w: IndexedSeq[Double]) = new SGDWeights(1L, w) + def average(left: SGDWeights, right: SGDWeights): SGDWeights = { val lc = left.count val rc = right.count if (rc == 0L) left @@ -63,15 +61,16 @@ object SGDWeights { else { val newW = left.weights.view .zip(right.weights) - .map { case (l : Double, r : Double) => - (lc * l + rc * r)/((lc + rc).toDouble) + .map { + case (l: Double, r: Double) => + (lc * l + rc * r) / ((lc + rc).toDouble) } .toIndexedSeq SGDWeights(lc + rc, newW) } } } -case class SGDWeights(val count : Long, val weights : IndexedSeq[Double]) extends SGD[Nothing] +case class SGDWeights(val count: Long, val weights: IndexedSeq[Double]) extends SGD[Nothing] object SGDPos { def apply[Pos](p: Pos) = new SGDPos(List(p)) @@ -85,8 +84,8 @@ case class SGDPos[+Pos](val pos: List[Pos]) extends SGD[Pos] * before you start adding SGDPos objects. Otherwise you will * just be doing list concatenation. */ -class SGDMonoid[Pos](stepfn : (Long, IndexedSeq[Double]) => Double, - gradient : (IndexedSeq[Double],Pos) => IndexedSeq[Double]) +class SGDMonoid[Pos](stepfn: (Long, IndexedSeq[Double]) => Double, + gradient: (IndexedSeq[Double], Pos) => IndexedSeq[Double]) extends Monoid[SGD[Pos]] { @@ -96,9 +95,9 @@ class SGDMonoid[Pos](stepfn : (Long, IndexedSeq[Double]) => Double, (left, right) match { case (_, SGDZero) => left case (SGDPos(llps), SGDPos(rlps)) => SGDPos(llps ::: rlps) - case (rsw@SGDWeights(c,w), SGDPos(p)) => p.foldLeft(rsw) { (cntWeight, pos) => - newWeights(cntWeight, pos) - } + case (rsw @ SGDWeights(c, w), SGDPos(p)) => p.foldLeft(rsw) { (cntWeight, pos) => + newWeights(cntWeight, pos) + } // TODO make a RightFolded2 which folds A,B => (B,C), and a group on C. case _ => right } @@ -110,7 +109,7 @@ class SGDMonoid[Pos](stepfn : (Long, IndexedSeq[Double]) => Double, SGDWeights(sgdW.count + 1L, sgdW.weights.view .zip(grad) - .map { case (l : Double, r : Double) => l - step * r } + .map { case (l: Double, r: Double) => l - step * r } .toIndexedSeq) } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Semigroup.scala b/algebird-core/src/main/scala/com/twitter/algebird/Semigroup.scala index 7646b3073..df49fc795 100755 --- a/algebird-core/src/main/scala/com/twitter/algebird/Semigroup.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Semigroup.scala @@ -15,12 +15,12 @@ limitations under the License. */ package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} -import java.util.{List => JList, Map => JMap} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } +import java.util.{ List => JList, Map => JMap } -import scala.collection.mutable.{Map => MMap} -import scala.collection.{Map => ScMap} -import scala.annotation.{implicitNotFound, tailrec} +import scala.collection.mutable.{ Map => MMap } +import scala.collection.{ Map => ScMap } +import scala.annotation.{ implicitNotFound, tailrec } /** * Semigroup: @@ -39,7 +39,8 @@ trait Semigroup[@specialized(Int, Long, Float, Double) T] extends java.io.Serial // For Java interop so they get the default sumOption abstract class AbstractSemigroup[T] extends Semigroup[T] -/** Either semigroup is useful for error handling. +/** + * Either semigroup is useful for error handling. * if everything is correct, use Right (it's right, get it?), if something goes * wrong, use Left. plus does the normal thing for plus(Right, Right), or plus(Left, Left), * but if exactly one is Left, we return that value (to keep the error condition). @@ -48,22 +49,19 @@ abstract class AbstractSemigroup[T] extends Semigroup[T] class EitherSemigroup[L, R](implicit semigroupl: Semigroup[L], semigroupr: Semigroup[R]) extends Semigroup[Either[L, R]] { override def plus(l: Either[L, R], r: Either[L, R]) = { - if(l.isLeft) { + if (l.isLeft) { // l is Left, r may or may not be: - if(r.isRight) { + if (r.isRight) { //Avoid the allocation: l - } - else { + } else { //combine the lefts: Left(semigroupl.plus(l.left.get, r.left.get)) } - } - else if(r.isLeft) { + } else if (r.isLeft) { //l is not a Left value, so just return right: r - } - else { + } else { //both l and r are Right values: Right(semigroupr.plus(l.right.get, r.right.get)) } @@ -77,22 +75,22 @@ object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups { def sumOption[T](iter: TraversableOnce[T])(implicit sg: Semigroup[T]): Option[T] = sg.sumOption(iter) - def from[T](associativeFn: (T, T) => T): Semigroup[T] = new Semigroup[T] { def plus(l:T, r:T) = associativeFn(l, r) } + def from[T](associativeFn: (T, T) => T): Semigroup[T] = new Semigroup[T] { def plus(l: T, r: T) = associativeFn(l, r) } - /** Same as v + v + v .. + v (i times in total) + /** + * Same as v + v + v .. + v (i times in total) * requires i > 0, wish we had PositiveBigInt as a class */ def intTimes[T](i: BigInt, v: T)(implicit sg: Semigroup[T]): T = { require(i > 0, "Cannot do non-positive products with a Semigroup, try Monoid/Group.intTimes") - intTimesRec(i-1, v, 0, (v, Vector[T]())) + intTimesRec(i - 1, v, 0, (v, Vector[T]())) } @tailrec private def intTimesRec[T](i: BigInt, v: T, pow: Int, vaccMemo: (T, Vector[T]))(implicit sg: Semigroup[T]): T = { - if(i == 0) { + if (i == 0) { vaccMemo._1 - } - else { + } else { /* i2 = i % 2 * 2^pow(i*v) + acc == 2^(pow+1)((i/2)*v) + (acc + 2^pow i2 * v) */ @@ -110,17 +108,15 @@ object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups { private def timesPow2[T](power: Int, v: T, memo: Vector[T])(implicit sg: Semigroup[T]): (T, Vector[T]) = { val size = memo.size require(power >= 0, "power cannot be negative") - if(power == 0) { + if (power == 0) { (v, memo) - } - else if (power <= size) { - (memo(power-1), memo) - } - else { - var item = if(size == 0) v else memo.last + } else if (power <= size) { + (memo(power - 1), memo) + } else { + var item = if (size == 0) v else memo.last var pow = size var newMemo = memo - while(pow < power) { + while (pow < power) { // x = 2*x item = sg.plus(item, item) pow += 1 @@ -152,8 +148,8 @@ object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups { implicit def indexedSeqSemigroup[T: Semigroup]: Semigroup[IndexedSeq[T]] = new IndexedSeqSemigroup[T] implicit def jlistSemigroup[T]: Semigroup[JList[T]] = new JListMonoid[T] implicit def setSemigroup[T]: Semigroup[Set[T]] = new SetMonoid[T] - implicit def mapSemigroup[K, V:Semigroup]: Semigroup[Map[K, V]] = new MapMonoid[K, V] - implicit def scMapSemigroup[K, V:Semigroup]: Semigroup[ScMap[K, V]] = new ScMapMonoid[K, V] + implicit def mapSemigroup[K, V: Semigroup]: Semigroup[Map[K, V]] = new MapMonoid[K, V] + implicit def scMapSemigroup[K, V: Semigroup]: Semigroup[ScMap[K, V]] = new ScMapMonoid[K, V] implicit def jmapSemigroup[K, V: Semigroup]: Semigroup[JMap[K, V]] = new JMapMonoid[K, V] implicit def eitherSemigroup[L: Semigroup, R: Semigroup]: Semigroup[Either[L, R]] = new EitherSemigroup[L, R] implicit def function1Semigroup[T]: Semigroup[Function1[T, T]] = new Function1Monoid[T] diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SketchMap.scala b/algebird-core/src/main/scala/com/twitter/algebird/SketchMap.scala index 1d62948f2..827644c5c 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SketchMap.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SketchMap.scala @@ -28,8 +28,7 @@ import com.twitter.algebird.matrix.AdaptiveMatrix /** * Hashes an arbitrary key type to one that the Sketch Map can use. */ -case class SketchMapHash[K](hasher: CMSHash, seed: Int) - (implicit serialization: K => Array[Byte]) { +case class SketchMapHash[K](hasher: CMSHash, seed: Int)(implicit serialization: K => Array[Byte]) { def apply(obj: K): Int = { val (first, second) = MurmurHash128(seed)(serialization(obj)) hasher(first ^ second) @@ -39,9 +38,8 @@ case class SketchMapHash[K](hasher: CMSHash, seed: Int) /** * Responsible for creating instances of SketchMap. */ -class SketchMapMonoid[K, V](val params: SketchMapParams[K]) - (implicit valueOrdering: Ordering[V], monoid: Monoid[V]) - extends Monoid[SketchMap[K, V]] { +class SketchMapMonoid[K, V](val params: SketchMapParams[K])(implicit valueOrdering: Ordering[V], monoid: Monoid[V]) + extends Monoid[SketchMap[K, V]] { /** * A zero Sketch Map is one with zero elements. @@ -59,7 +57,7 @@ class SketchMapMonoid[K, V](val params: SketchMapParams[K]) } override def sumOption(items: TraversableOnce[SketchMap[K, V]]): Option[SketchMap[K, V]] = - if(items.isEmpty) None + if (items.isEmpty) None else { val buffer = scala.collection.mutable.Buffer[SketchMap[K, V]]() val maxBuffer = 1000 @@ -75,10 +73,10 @@ class SketchMapMonoid[K, V](val params: SketchMapParams[K]) } items.foreach { sm => - if(buffer.size > maxBuffer) sumBuffer + if (buffer.size > maxBuffer) sumBuffer buffer += sm } - if(buffer.size > 1) sumBuffer //don't bother to sum if there is only one item. + if (buffer.size > 1) sumBuffer //don't bother to sum if there is only one item. Some(buffer(0)) } @@ -95,12 +93,14 @@ class SketchMapMonoid[K, V](val params: SketchMapParams[K]) val totalValue = Monoid.sum(data.map { _._2 }) val initTable = AdaptiveMatrix.fill[V](params.depth, params.width)(monoid.zero) /* For each row, update the table for each K,V pair */ - val newTable = (0 to (params.depth - 1)).foldLeft(initTable) { case (table, row) => - data.foldLeft(table) { case (innerTable, (key, value)) => - val pos = (row, params.hashes(row)(key)) - val currValue: V = innerTable.getValue(pos) - innerTable.updated(pos, Monoid.plus(currValue, value)) - } + val newTable = (0 to (params.depth - 1)).foldLeft(initTable) { + case (table, row) => + data.foldLeft(table) { + case (innerTable, (key, value)) => + val pos = (row, params.hashes(row)(key)) + val currValue: V = innerTable.getValue(pos) + innerTable.updated(pos, Monoid.plus(currValue, value)) + } } SketchMap(newTable, params.updatedHeavyHitters(heavyHitters, newTable), totalValue) @@ -109,10 +109,10 @@ class SketchMapMonoid[K, V](val params: SketchMapParams[K]) /** * Calculates the approximate frequency for any key. */ - def frequency(sm: SketchMap[K,V], key: K): V = + def frequency(sm: SketchMap[K, V], key: K): V = params.frequency(key, sm.valuesTable) - def frequencyWithHHCache(sm: SketchMap[K,V]): K => V = { + def frequencyWithHHCache(sm: SketchMap[K, V]): K => V = { val hhMap: Map[K, V] = heavyHitters(sm).toMap (k: K) => hhMap.getOrElse(k, frequency(sm, k)) } @@ -120,19 +120,17 @@ class SketchMapMonoid[K, V](val params: SketchMapParams[K]) /** * Returns a sorted list of heavy hitter key/value tuples. */ - def heavyHitters(sm: SketchMap[K,V]) : List[(K, V)] = + def heavyHitters(sm: SketchMap[K, V]): List[(K, V)] = sm.heavyHitterKeys.map { item => (item, frequency(sm, item)) } } - /** * Convenience class for holding constant parameters of a Sketch Map. */ -case class SketchMapParams[K](seed: Int, width: Int, depth: Int, heavyHittersCount: Int) - (implicit serialization: K => Array[Byte]) { +case class SketchMapParams[K](seed: Int, width: Int, depth: Int, heavyHittersCount: Int)(implicit serialization: K => Array[Byte]) { assert(0 < width, "width must be greater than 0") assert(0 < depth, "depth must be greater than 0") - assert(0 <= heavyHittersCount , "heavyHittersCount must be greater than 0") + assert(0 <= heavyHittersCount, "heavyHittersCount must be greater than 0") lazy val hashes: Seq[K => Int] = { val r = new scala.util.Random(seed) @@ -147,7 +145,7 @@ case class SketchMapParams[K](seed: Int, width: Int, depth: Int, heavyHittersCou /** * Calculates the frequency for a key given a values table. */ - def frequency[V:Ordering](key: K, table: AdaptiveMatrix[V]): V = + def frequency[V: Ordering](key: K, table: AdaptiveMatrix[V]): V = hashes .iterator .zipWithIndex @@ -158,7 +156,7 @@ case class SketchMapParams[K](seed: Int, width: Int, depth: Int, heavyHittersCou * Returns a new set of sorted and concatenated heavy hitters given an * arbitrary list of keys. */ - def updatedHeavyHitters[V:Ordering](hitters: Seq[K], table: AdaptiveMatrix[V]): List[K] = { + def updatedHeavyHitters[V: Ordering](hitters: Seq[K], table: AdaptiveMatrix[V]): List[K] = { val mapping: Map[K, V] = hitters.map(item => (item, frequency(item, table)))(breakOut) val specificOrdering = Ordering.by[K, V] { mapping(_) }.reverse hitters.sorted(specificOrdering).take(heavyHittersCount).toList @@ -169,8 +167,7 @@ object SketchMapParams { /** * Overloaded apply method for convenience. */ - def apply[K](seed: Int, eps: Double, delta: Double, heavyHittersCount: Int) - (implicit serialization: K => Array[Byte]): SketchMapParams[K] = + def apply[K](seed: Int, eps: Double, delta: Double, heavyHittersCount: Int)(implicit serialization: K => Array[Byte]): SketchMapParams[K] = SketchMapParams[K](seed, width(eps), depth(delta), heavyHittersCount)(serialization) /** * Functions to translate between (eps, delta) and (depth, width). The translation is: @@ -183,7 +180,6 @@ object SketchMapParams { def depth(delta: Double): Int = scala.math.ceil(scala.math.log(1.0 / delta)).toInt } - /** * Data structure representing an approximation of Map[K, V], where V has an * implicit ordering and monoid. This is a more generic version of @@ -210,24 +206,22 @@ object SketchMap { def monoid[K, V](params: SketchMapParams[K])(implicit valueOrdering: Ordering[V], monoid: Monoid[V]): SketchMapMonoid[K, V] = new SketchMapMonoid(params)(valueOrdering, monoid) - def aggregator[K, V](params: SketchMapParams[K]) - (implicit valueOrdering: Ordering[V], monoid: Monoid[V]): SketchMapAggregator[K, V] = + def aggregator[K, V](params: SketchMapParams[K])(implicit valueOrdering: Ordering[V], monoid: Monoid[V]): SketchMapAggregator[K, V] = SketchMapAggregator(params, SketchMap.monoid(params)) } case class SketchMap[K, V]( val valuesTable: AdaptiveMatrix[V], val heavyHitterKeys: List[K], - val totalValue: V -) extends java.io.Serializable + val totalValue: V) extends java.io.Serializable /** - * An Aggregator for the SketchMap. - * Can be created using SketchMap.aggregator - */ -case class SketchMapAggregator[K, V](params: SketchMapParams[K], skmMonoid : SketchMapMonoid[K, V])(implicit valueOrdering: Ordering[V], valueMonoid: Monoid[V]) extends MonoidAggregator[(K, V), SketchMap[K, V], SketchMap[K, V]] { + * An Aggregator for the SketchMap. + * Can be created using SketchMap.aggregator + */ +case class SketchMapAggregator[K, V](params: SketchMapParams[K], skmMonoid: SketchMapMonoid[K, V])(implicit valueOrdering: Ordering[V], valueMonoid: Monoid[V]) extends MonoidAggregator[(K, V), SketchMap[K, V], SketchMap[K, V]] { val monoid = skmMonoid - def prepare(value: (K,V)) = monoid.create(value) + def prepare(value: (K, V)) = monoid.create(value) def present(skm: SketchMap[K, V]) = skm } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SortedTakeListMonoid.scala b/algebird-core/src/main/scala/com/twitter/algebird/SortedTakeListMonoid.scala index 1b064ff7a..d0f630338 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SortedTakeListMonoid.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SortedTakeListMonoid.scala @@ -20,26 +20,26 @@ import scala.annotation.tailrec object SortedTakeListMonoid extends java.io.Serializable { // Does a merge sort and returns the reversed list @tailrec - private[algebird] def mergeSortR[T](acc : List[T], list1 : List[T], list2 : List[T], - cnt : Int)(implicit ord: Ordering[T]) : List[T] = { + private[algebird] def mergeSortR[T](acc: List[T], list1: List[T], list2: List[T], + cnt: Int)(implicit ord: Ordering[T]): List[T] = { (list1, list2, cnt) match { case (_, _, 0) => acc case (x1 :: t1, x2 :: t2, _) => { - if( ord.lt(x1,x2) ) { - mergeSortR(x1 :: acc, t1, list2, cnt-1) - } - else { - mergeSortR(x2 :: acc, list1, t2, cnt-1) + if (ord.lt(x1, x2)) { + mergeSortR(x1 :: acc, t1, list2, cnt - 1) + } else { + mergeSortR(x2 :: acc, list1, t2, cnt - 1) } } - case (x1 :: t1, Nil, _) => mergeSortR(x1 :: acc, t1, Nil, cnt-1) - case (Nil, x2 :: t2, _) => mergeSortR(x2 :: acc, Nil, t2, cnt-1) + case (x1 :: t1, Nil, _) => mergeSortR(x1 :: acc, t1, Nil, cnt - 1) + case (Nil, x2 :: t2, _) => mergeSortR(x2 :: acc, Nil, t2, cnt - 1) case (Nil, Nil, _) => acc } } } -/** A sorted-take List monoid (not the default, you can set: +/** + * A sorted-take List monoid (not the default, you can set: * implicit val sortmon = new SortedTakeListMonoid[T](10) * to use this instead of the standard list * This returns the k least values: @@ -49,9 +49,9 @@ object SortedTakeListMonoid extends java.io.Serializable { * TODO remove this in algebird 0.2.0 */ @deprecated("Use TopKMonoid or PriorityQueueMonoid", "0.1.8") -class SortedTakeListMonoid[T](k : Int)(implicit ord : Ordering[T]) extends Monoid[List[T]] { +class SortedTakeListMonoid[T](k: Int)(implicit ord: Ordering[T]) extends Monoid[List[T]] { override def zero = List[T]() - override def plus(left : List[T], right : List[T]) : List[T] = { + override def plus(left: List[T], right: List[T]): List[T] = { //This is the internal loop that does one comparison: SortedTakeListMonoid.mergeSortR(Nil, left, right, k).reverse } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SpaceSaver.scala b/algebird-core/src/main/scala/com/twitter/algebird/SpaceSaver.scala index a3901ce58..8d409eba3 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SpaceSaver.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SpaceSaver.scala @@ -4,8 +4,8 @@ import scala.collection.immutable.SortedMap object SpaceSaver { /** - * Construct SpaceSaver with given capacity containing a single item. - */ + * Construct SpaceSaver with given capacity containing a single item. + */ def apply[T](capacity: Int, item: T): SpaceSaver[T] = SSOne(capacity, item) private[algebird] val ordering = Ordering.by[(_, (Long, Long)), (Long, Long)]{ case (item, (count, err)) => (-count, err) } @@ -14,45 +14,45 @@ object SpaceSaver { } /** - * Data structure used in the Space-Saving Algorithm to find the approximate most frequent and top-k elements. - * The algorithm is described in "Efficient Computation of Frequent and Top-k Elements in Data Streams". - * See here: www.cs.ucsb.edu/research/tech_reports/reports/2005-23.pdf - * In the paper the data structure is called StreamSummary but we chose to call it SpaceSaver instead. - * Note that the adaptation to hadoop and parallelization were not described in the article and have not been proven to be mathematically correct - * or preserve the guarantees or benefits of the algorithm. - */ + * Data structure used in the Space-Saving Algorithm to find the approximate most frequent and top-k elements. + * The algorithm is described in "Efficient Computation of Frequent and Top-k Elements in Data Streams". + * See here: www.cs.ucsb.edu/research/tech_reports/reports/2005-23.pdf + * In the paper the data structure is called StreamSummary but we chose to call it SpaceSaver instead. + * Note that the adaptation to hadoop and parallelization were not described in the article and have not been proven to be mathematically correct + * or preserve the guarantees or benefits of the algorithm. + */ sealed abstract class SpaceSaver[T] { import SpaceSaver.ordering /** - * Maximum number of counters to keep (parameter "m" in the research paper). - */ + * Maximum number of counters to keep (parameter "m" in the research paper). + */ def capacity: Int /** - * Current lowest value for count - */ + * Current lowest value for count + */ def min: Long /** - * Map of item to counter, where each counter consists of an observed count and possible over-estimation (error) - */ + * Map of item to counter, where each counter consists of an observed count and possible over-estimation (error) + */ def counters: Map[T, (Long, Long)] def ++(other: SpaceSaver[T]): SpaceSaver[T] /** - * returns the frequency estimate for the item - */ + * returns the frequency estimate for the item + */ def frequency(item: T): Approximate[Long] = { val (count, err) = counters.getOrElse(item, (min, min)) Approximate(count - err, count, count, 1.0) } /** - * Get the elements that show up more than thres times. - * Returns sorted in descending order: (item, Approximate[Long], guaranteed) - */ + * Get the elements that show up more than thres times. + * Returns sorted in descending order: (item, Approximate[Long], guaranteed) + */ def mostFrequent(thres: Int): Seq[(T, Approximate[Long], Boolean)] = counters .iterator @@ -62,9 +62,9 @@ sealed abstract class SpaceSaver[T] { .map { case (item, (count, err)) => (item, Approximate(count - err, count, count, 1.0), thres <= count - err) } /** - * Get the top-k elements. - * Returns sorted in descending order: (item, Approximate[Long], guaranteed) - */ + * Get the top-k elements. + * Returns sorted in descending order: (item, Approximate[Long], guaranteed) + */ def topK(k: Int): Seq[(T, Approximate[Long], Boolean)] = { require(k < capacity) val si = counters @@ -76,9 +76,9 @@ sealed abstract class SpaceSaver[T] { } /** - * Check consistency with other SpaceSaver, useful for testing. - * Returns boolean indicating if they are consistent - */ + * Check consistency with other SpaceSaver, useful for testing. + * Returns boolean indicating if they are consistent + */ def consistentWith(that: SpaceSaver[T]): Boolean = (counters.keys ++ that.counters.keys).forall{ item => (frequency(item) - that.frequency(item)) ~ 0 } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/StatefulSummer.scala b/algebird-core/src/main/scala/com/twitter/algebird/StatefulSummer.scala index 5d2c9a9c8..5088a1ef6 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/StatefulSummer.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/StatefulSummer.scala @@ -29,7 +29,8 @@ trait StatefulSummer[V] extends Buffered[V, V] { def semigroup: Semigroup[V] } -/** Sum the entire iterator one item at a time. Only emits on flush +/** + * Sum the entire iterator one item at a time. Only emits on flush * you should probably prefer BufferedSumAll */ class SumAll[V](implicit override val semigroup: Semigroup[V]) extends StatefulSummer[V] { diff --git a/algebird-core/src/main/scala/com/twitter/algebird/Successible.scala b/algebird-core/src/main/scala/com/twitter/algebird/Successible.scala index 76f00e720..d1c0996c2 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/Successible.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/Successible.scala @@ -24,7 +24,7 @@ package com.twitter.algebird * which our ordering is violating. This is also useful for closed sets which have a fixed * progression. */ -trait Successible[@specialized(Int,Long,Float,Double) T] { +trait Successible[@specialized(Int, Long, Float, Double) T] { def next(old: T): Option[T] def next(old: Option[T]): Option[T] = old flatMap next def iterateNext(old: T): Iterable[T] = { @@ -35,8 +35,8 @@ trait Successible[@specialized(Int,Long,Float,Double) T] { new AbstractIterable[T] { def iterator = Iterator.iterate[Option[T]](Some(old)) { self.next(_) } - .takeWhile(_.isDefined) - .map(_.get) + .takeWhile(_.isDefined) + .map(_.get) } } def ordering: Ordering[T] @@ -67,7 +67,7 @@ object Successible { } // TODO Remove Ordering. It is unused. Note Numeric and Integral extend ordering -class NumericSuccessible[@specialized(Int,Long,Float,Double) T:Numeric:Ordering] extends Successible[T] { +class NumericSuccessible[@specialized(Int, Long, Float, Double) T: Numeric: Ordering] extends Successible[T] { def next(old: T) = { val numeric = implicitly[Numeric[T]] val newV = numeric.plus(old, numeric.one) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SummingCache.scala b/algebird-core/src/main/scala/com/twitter/algebird/SummingCache.scala index 134a0274a..91f515419 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SummingCache.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SummingCache.scala @@ -23,38 +23,40 @@ package com.twitter.algebird import java.util.concurrent.ArrayBlockingQueue import java.util.{ LinkedHashMap => JLinkedHashMap, Map => JMap } -import scala.collection.mutable.{Map => MMap} +import scala.collection.mutable.{ Map => MMap } import scala.collection.JavaConverters._ import scala.annotation.tailrec object SummingCache { - def apply[K,V:Semigroup](cap: Int): SummingCache[K,V] = new SummingCache[K,V](cap) + def apply[K, V: Semigroup](cap: Int): SummingCache[K, V] = new SummingCache[K, V](cap) } -/** A Stateful Summer on Map[K,V] that keeps a cache of recent keys +/** + * A Stateful Summer on Map[K,V] that keeps a cache of recent keys */ -class SummingCache[K,V] private (capacity: Int)(implicit sgv: Semigroup[V]) - extends StatefulSummer[Map[K,V]] { +class SummingCache[K, V] private (capacity: Int)(implicit sgv: Semigroup[V]) + extends StatefulSummer[Map[K, V]] { require(capacity >= 0, "Cannot have negative capacity in SummingIterator") - override val semigroup = new MapMonoid[K,V] - protected def optNonEmpty(m: Map[K,V]) = if (m.isEmpty) None else Some(m) + override val semigroup = new MapMonoid[K, V] + protected def optNonEmpty(m: Map[K, V]) = if (m.isEmpty) None else Some(m) - override def put(m: Map[K,V]): Option[Map[K,V]] = { - val replaced = m.map { case (k, v) => - val newV = cache.get(k) - .map { oldV => sgv.plus(oldV, v) } - .getOrElse { v } - (k, newV) + override def put(m: Map[K, V]): Option[Map[K, V]] = { + val replaced = m.map { + case (k, v) => + val newV = cache.get(k) + .map { oldV => sgv.plus(oldV, v) } + .getOrElse { v } + (k, newV) } cache ++= replaced val ret = lastEvicted // Rest this var - lastEvicted = Map.empty[K,V] + lastEvicted = Map.empty[K, V] optNonEmpty(ret) } - override def flush: Option[Map[K,V]] = { + override def flush: Option[Map[K, V]] = { // Get a copy of the cache, since it is mutable val res = optNonEmpty(Map(cache.toSeq: _*)) cache.clear @@ -62,16 +64,15 @@ class SummingCache[K,V] private (capacity: Int)(implicit sgv: Semigroup[V]) } def isFlushed = cache.isEmpty - protected var lastEvicted: Map[K,V] = Map.empty[K,V] + protected var lastEvicted: Map[K, V] = Map.empty[K, V] // TODO fancier caches will give better performance: - protected lazy val cache: MMap[K,V] = (new JLinkedHashMap[K,V](capacity + 1, 0.75f, true) { - override protected def removeEldestEntry(eldest : JMap.Entry[K, V]) = - if(super.size > capacity) { - lastEvicted += (eldest.getKey -> eldest.getValue) - true - } - else { - false - } - }).asScala + protected lazy val cache: MMap[K, V] = (new JLinkedHashMap[K, V](capacity + 1, 0.75f, true) { + override protected def removeEldestEntry(eldest: JMap.Entry[K, V]) = + if (super.size > capacity) { + lastEvicted += (eldest.getKey -> eldest.getValue) + true + } else { + false + } + }).asScala } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SummingIterator.scala b/algebird-core/src/main/scala/com/twitter/algebird/SummingIterator.scala index 444fc917c..e23e31d8d 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SummingIterator.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SummingIterator.scala @@ -23,11 +23,12 @@ package com.twitter.algebird import java.util.concurrent.ArrayBlockingQueue import java.util.{ LinkedHashMap => JLinkedHashMap, Map => JMap } -import scala.collection.mutable.{Map => MMap} +import scala.collection.mutable.{ Map => MMap } import scala.collection.JavaConverters._ import scala.annotation.tailrec -/** Creates an Iterator that emits partial sums of an input Iterator[V]. +/** + * Creates an Iterator that emits partial sums of an input Iterator[V]. * Generally this is useful to change from processing individiual V's to * possibly blocks of V @see SummingQueue or a cache of recent Keys in * a V=Map[K,W] case: @see SummingCache @@ -37,7 +38,8 @@ object SummingIterator { new SummingIterator(summer, it) implicit def enrich[V](it: Iterator[V]): Enriched[V] = new Enriched(it) - /** Here to add enrichments to Iterator + /** + * Here to add enrichments to Iterator */ class Enriched[V](it: Iterator[V]) { def sumWith(summer: StatefulSummer[V]): SummingIterator[V] = SummingIterator(summer, it) @@ -59,8 +61,7 @@ class SummingIterator[V](summer: StatefulSummer[V], it: Iterator[V]) case None => nextInternal case Some(v) => v } - } - else { + } else { tailIter.next } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/SummingQueue.scala b/algebird-core/src/main/scala/com/twitter/algebird/SummingQueue.scala index b3091975c..cc2beef2e 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/SummingQueue.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/SummingQueue.scala @@ -38,7 +38,7 @@ import scala.collection.JavaConverters._ import scala.collection.mutable.ListBuffer object SummingQueue { - def apply[V:Semigroup](cap: Int): SummingQueue[V] = new SummingQueue(cap) + def apply[V: Semigroup](cap: Int): SummingQueue[V] = new SummingQueue(cap) } class SummingQueue[V] private (capacity: Int)(override implicit val semigroup: Semigroup[V]) @@ -47,18 +47,18 @@ class SummingQueue[V] private (capacity: Int)(override implicit val semigroup: S private val queueOption: Option[ArrayBlockingQueue[V]] = if (capacity > 0) Some(new ArrayBlockingQueue[V](capacity, true)) else None - /** puts an item to the queue, optionally sums up the queue and returns value + /** + * puts an item to the queue, optionally sums up the queue and returns value * This never blocks interally. It uses offer. If the queue is full, we drain, * sum the queue. */ final def put(item: V): Option[V] = if (queueOption.isDefined) { queueOption.flatMap { queue => - if(!queue.offer(item)) { + if (!queue.offer(item)) { // Queue is full, do the work: Monoid.plus(flush, Some(item)) - } - else { + } else { // We are in the queue None } @@ -67,7 +67,8 @@ class SummingQueue[V] private (capacity: Int)(override implicit val semigroup: S def apply(v: V): Option[V] = put(v) - /** drain the queue and return the sum. If empty, return None + /** + * drain the queue and return the sum. If empty, return None */ def flush: Option[V] = { queueOption.flatMap { queue => diff --git a/algebird-core/src/main/scala/com/twitter/algebird/TopKMonoid.scala b/algebird-core/src/main/scala/com/twitter/algebird/TopKMonoid.scala index 156070d5a..0e13d8a46 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/TopKMonoid.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/TopKMonoid.scala @@ -19,7 +19,8 @@ import scala.annotation.tailrec case class TopK[N](size: Int, items: List[N], max: Option[N]) -/** A top-k monoid that is much faster than SortedListTake +/** + * A top-k monoid that is much faster than SortedListTake * equivalent to: (left ++ right).sorted.take(k) * but doesn't do a total sort * You should STRONGLY prefer this to SortedTakeListMonoid which is deprecated and slow @@ -27,7 +28,7 @@ case class TopK[N](size: Int, items: List[N], max: Option[N]) * * NOTE!!!! This assumes the inputs are already sorted! resorting each time kills speed */ -class TopKMonoid[T](k : Int)(implicit ord : Ordering[T]) extends Monoid[TopK[T]] { +class TopKMonoid[T](k: Int)(implicit ord: Ordering[T]) extends Monoid[TopK[T]] { require(k > 0, "TopK requires at least K>0") @@ -36,23 +37,20 @@ class TopKMonoid[T](k : Int)(implicit ord : Ordering[T]) extends Monoid[TopK[T]] def build(t: T): TopK[T] = TopK(1, List(t), Some(t)) def build(ts: Iterable[T]): TopK[T] = ts.foldLeft(zero) { (acc, t) => plus(acc, build(t)) } - override def plus(left : TopK[T], right : TopK[T]) : TopK[T] = { - val (bigger, smaller) = if(left.size >= right.size) (left, right) else (right, left) - if(smaller.size == 0) { + override def plus(left: TopK[T], right: TopK[T]): TopK[T] = { + val (bigger, smaller) = if (left.size >= right.size) (left, right) else (right, left) + if (smaller.size == 0) { bigger - } - else if(bigger.size == k) { + } else if (bigger.size == k) { // See if we can just return the bigger: - val biggerWins = for(biggest <- bigger.max; smallest <- smaller.items.headOption) + val biggerWins = for (biggest <- bigger.max; smallest <- smaller.items.headOption) yield (ord.lteq(biggest, smallest)) - if(biggerWins.getOrElse(true)) { // smaller is small, or empty + if (biggerWins.getOrElse(true)) { // smaller is small, or empty bigger - } - else { + } else { merge(bigger, smaller) } - } - else { + } else { merge(bigger, smaller) } } @@ -62,7 +60,7 @@ class TopKMonoid[T](k : Int)(implicit ord : Ordering[T]) extends Monoid[TopK[T]] val newItems = mergeSortR(Nil, bigger.items, smaller.items, k) val max = newItems.headOption // Now reverse and get the size: - val (size, reversed) = newItems.foldLeft((0,List[T]())) { (cntItems, v) => + val (size, reversed) = newItems.foldLeft((0, List[T]())) { (cntItems, v) => val (olds, oldl) = cntItems (olds + 1, v :: oldl) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/VectorSpace.scala b/algebird-core/src/main/scala/com/twitter/algebird/VectorSpace.scala index 0f3a84de3..94deae3c1 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/VectorSpace.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/VectorSpace.scala @@ -16,7 +16,7 @@ limitations under the License. package com.twitter.algebird -import java.lang.{Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool} +import java.lang.{ Integer => JInt, Short => JShort, Long => JLong, Float => JFloat, Double => JDouble, Boolean => JBool } import scala.annotation.implicitNotFound /** @@ -30,15 +30,15 @@ object VectorSpace { def from[F, C[_]](scaleFn: (F, C[F]) => C[F])(implicit fField: Field[F], cGroup: Group[C[F]]) = new VectorSpace[F, C] { def field = fField def group = cGroup - def scale(v: F, c: C[F]) = if(field.isNonZero(v)) scaleFn(v, c) else cGroup.zero + def scale(v: F, c: C[F]) = if (field.isNonZero(v)) scaleFn(v, c) else cGroup.zero } // Implicits - implicit def indexedSeqSpace[T : Field] = - from[T, IndexedSeq]{(s, seq) => seq.map(Ring.times(s, _)) } + implicit def indexedSeqSpace[T: Field] = + from[T, IndexedSeq]{ (s, seq) => seq.map(Ring.times(s, _)) } - implicit def mapSpace[K, T : Field] = - from[T, ({type x[a]=Map[K, a]})#x] { (s, m) => m.mapValues(Ring.times(s, _))} + implicit def mapSpace[K, T: Field] = + from[T, ({ type x[a] = Map[K, a] })#x] { (s, m) => m.mapValues(Ring.times(s, _)) } // TODO: add implicits for java lists, arrays, and options } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/matrix/AdaptiveMatrix.scala b/algebird-core/src/main/scala/com/twitter/algebird/matrix/AdaptiveMatrix.scala index 8b91b178c..3d3755f5e 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/matrix/AdaptiveMatrix.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/matrix/AdaptiveMatrix.scala @@ -16,8 +16,8 @@ limitations under the License. package com.twitter.algebird.matrix -import scala.collection.mutable.{ArrayBuffer, Map => MMap} -import com.twitter.algebird.{AdaptiveVector, Monoid} +import scala.collection.mutable.{ ArrayBuffer, Map => MMap } +import com.twitter.algebird.{ AdaptiveVector, Monoid } /** * A Matrix structure that is designed to hide moving between sparse and dense representations @@ -48,7 +48,7 @@ object AdaptiveMatrix { } // The adaptive monoid to swap between sparse modes. - implicit def monoid[V:Monoid]: Monoid[AdaptiveMatrix[V]] = new Monoid[AdaptiveMatrix[V]] { + implicit def monoid[V: Monoid]: Monoid[AdaptiveMatrix[V]] = new Monoid[AdaptiveMatrix[V]] { private[this] final val innerZero = implicitly[Monoid[V]].zero override def zero: AdaptiveMatrix[V] = SparseColumnMatrix[V](IndexedSeq[AdaptiveVector[V]]()) @@ -69,11 +69,13 @@ object AdaptiveMatrix { } private def sparseUpdate(storage: IndexedSeq[MMap[Int, V]], other: SparseColumnMatrix[V]) = { - other.rowsByColumns.zipWithIndex.foreach { case (contents, indx) => - val curMap: MMap[Int, V] = storage(indx) - AdaptiveVector.toMap(contents).foreach { case (col, value) => - curMap.update(col, Monoid.plus(value, curMap.getOrElse(col, innerZero))) - } + other.rowsByColumns.zipWithIndex.foreach { + case (contents, indx) => + val curMap: MMap[Int, V] = storage(indx) + AdaptiveVector.toMap(contents).foreach { + case (col, value) => + curMap.update(col, Monoid.plus(value, curMap.getOrElse(col, innerZero))) + } } } @@ -81,40 +83,41 @@ object AdaptiveMatrix { val buffer = ArrayBuffer.fill(rows * cols)(innerZero) var row = 0 val iter = storage.iterator - while(iter.hasNext) { + while (iter.hasNext) { val curRow = iter.next - curRow.foreach { case (col, value) => - buffer(row*cols + col) = value + curRow.foreach { + case (col, value) => + buffer(row * cols + col) = value } row += 1 } denseInsert(rows, cols, buffer, remainder) } - override def sumOption(items: TraversableOnce[AdaptiveMatrix[V]]): Option[AdaptiveMatrix[V]] = - if(items.isEmpty) { - None - } else { - val iter = items.toIterator.buffered - val rows = iter.head.rows - val cols = iter.head.cols - val sparseStorage = (0 until rows).map{_ => MMap[Int, V]()}.toIndexedSeq - - while(iter.hasNext) { - val current = iter.next - current match { - case d@DenseMatrix(_, _, _) => return denseUpdate(d, iter) - case s@SparseColumnMatrix(_) => - sparseUpdate(sparseStorage, s) - if(sparseStorage(0).size > current.cols/4) { - return goDense(rows, cols, sparseStorage, iter) - } + override def sumOption(items: TraversableOnce[AdaptiveMatrix[V]]): Option[AdaptiveMatrix[V]] = + if (items.isEmpty) { + None + } else { + val iter = items.toIterator.buffered + val rows = iter.head.rows + val cols = iter.head.cols + val sparseStorage = (0 until rows).map{ _ => MMap[Int, V]() }.toIndexedSeq + + while (iter.hasNext) { + val current = iter.next + current match { + case d @ DenseMatrix(_, _, _) => return denseUpdate(d, iter) + case s @ SparseColumnMatrix(_) => + sparseUpdate(sparseStorage, s) + if (sparseStorage(0).size > current.cols / 4) { + return goDense(rows, cols, sparseStorage, iter) + } + } } - } - // Need to still be sparse to reach here, so must unpack the MMap to be used again. - Some(SparseColumnMatrix.fromSeqMap(cols, sparseStorage)) - } + // Need to still be sparse to reach here, so must unpack the MMap to be used again. + Some(SparseColumnMatrix.fromSeqMap(cols, sparseStorage)) + } } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/matrix/DenseMatrix.scala b/algebird-core/src/main/scala/com/twitter/algebird/matrix/DenseMatrix.scala index 0976cf6b7..375fbd5c1 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/matrix/DenseMatrix.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/matrix/DenseMatrix.scala @@ -15,7 +15,7 @@ limitations under the License. */ package com.twitter.algebird.matrix -import scala.collection.mutable.{ArrayBuffer, Map => MMap} +import scala.collection.mutable.{ ArrayBuffer, Map => MMap } import com.twitter.algebird.Monoid @@ -29,11 +29,10 @@ case class DenseMatrix[V: Monoid](rows: Int, cols: Int, rowsByColumns: IndexedSe override def updated(position: (Int, Int), value: V): DenseMatrix[V] = DenseMatrix[V](rows, cols, rowsByColumns.updated(tupToIndex(position), value)) - override def updateInto(buffer: ArrayBuffer[V]) { var indx = 0 val lsize = size - while(indx < lsize) { + while (indx < lsize) { buffer(indx) = valueMonoid.plus(buffer(indx), rowsByColumns(indx)) indx += 1 } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/matrix/SparseColumnMatrix.scala b/algebird-core/src/main/scala/com/twitter/algebird/matrix/SparseColumnMatrix.scala index 3cb5e67eb..051871a50 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/matrix/SparseColumnMatrix.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/matrix/SparseColumnMatrix.scala @@ -15,8 +15,8 @@ limitations under the License. */ package com.twitter.algebird.matrix -import scala.collection.mutable.{ArrayBuffer, Map => MMap} -import com.twitter.algebird.{Monoid, AdaptiveVector} +import scala.collection.mutable.{ ArrayBuffer, Map => MMap } +import com.twitter.algebird.{ Monoid, AdaptiveVector } object SparseColumnMatrix { def fromSeqMap[V: Monoid](cols: Int, data: IndexedSeq[MMap[Int, V]]) = { @@ -46,9 +46,9 @@ case class SparseColumnMatrix[V: Monoid](rowsByColumns: IndexedSeq[AdaptiveVecto override def updateInto(buffer: ArrayBuffer[V]) { val lcols = cols var row = 0 - while(row < rows) { + while (row < rows) { val iter = rowsByColumns(row).denseIterator - while(iter.hasNext) { + while (iter.hasNext) { val (col, value) = iter.next val indx = row * lcols + col buffer(indx) = valueMonoid.plus(buffer(indx), value) @@ -66,7 +66,7 @@ case class SparseColumnMatrix[V: Monoid](rowsByColumns: IndexedSeq[AdaptiveVecto override def toString: String = { val builder = new scala.collection.mutable.StringBuilder() builder ++= "Row: %d, Cols: %d. Dense elements:\n".format(rows, cols) - rowsByColumns.foreach {v => + rowsByColumns.foreach { v => builder ++= v.denseIterator.toList.toString builder ++= "\n" } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/monad/EitherMonad.scala b/algebird-core/src/main/scala/com/twitter/algebird/monad/EitherMonad.scala index 2e2d52c46..8ccfbd989 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/monad/EitherMonad.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/monad/EitherMonad.scala @@ -20,16 +20,16 @@ import com.twitter.algebird.Monad // Monad for either, used for modeling Error where L is the type of the error object EitherMonad { - class Error[L] extends Monad[({type RightType[R] = Either[L,R]})#RightType] { + class Error[L] extends Monad[({ type RightType[R] = Either[L, R] })#RightType] { def apply[R](r: R) = Right(r) - def flatMap[T,U](self: Either[L,T])(next: T => Either[L, U]): Either[L, U] = + def flatMap[T, U](self: Either[L, T])(next: T => Either[L, U]): Either[L, U] = self.right.flatMap(next) - override def map[T,U](self: Either[L,T])(fn: T => U): Either[L, U] = + override def map[T, U](self: Either[L, T])(fn: T => U): Either[L, U] = self.right.map(fn) } - implicit def monad[L]: Monad[({type RightT[R] = Either[L,R]})#RightT] = new Error[L] + implicit def monad[L]: Monad[({ type RightT[R] = Either[L, R] })#RightT] = new Error[L] - def assert[L](truth: Boolean, failure: => L): Either[L,Unit] = if(truth) Right(()) else Left(failure) + def assert[L](truth: Boolean, failure: => L): Either[L, Unit] = if (truth) Right(()) else Left(failure) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/monad/Reader.scala b/algebird-core/src/main/scala/com/twitter/algebird/monad/Reader.scala index 954aa6f5c..2e6c71df2 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/monad/Reader.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/monad/Reader.scala @@ -25,8 +25,8 @@ import com.twitter.algebird.Monad sealed trait Reader[-Env, +T] { def apply(env: Env): T - def flatMap[E1<:Env, U](next: T => Reader[E1, U]): Reader[E1, U] = - FlatMappedReader[E1,T,U](this, next) + def flatMap[E1 <: Env, U](next: T => Reader[E1, U]): Reader[E1, U] = + FlatMappedReader[E1, T, U](this, next) def map[U](thatFn: T => U): Reader[Env, U] = FlatMappedReader(this, { (t: T) => ConstantReader(thatFn(t)) }) } @@ -34,7 +34,7 @@ sealed trait Reader[-Env, +T] { final case class ConstantReader[+T](get: T) extends Reader[Any, T] { override def apply(env: Any) = get override def map[U](fn: T => U) = ConstantReader(fn(get)) - override def flatMap[E1<:Any, U](next: T => Reader[E1, U]): Reader[E1, U] = next(get) + override def flatMap[E1 <: Any, U](next: T => Reader[E1, U]): Reader[E1, U] = next(get) } final case class ReaderFn[E, +T](fn: E => T) extends Reader[E, T] { override def apply(env: E) = fn(env) @@ -60,12 +60,12 @@ final case class FlatMappedReader[E, U, +T](first: Reader[E, U], fn: U => Reader object Reader { def const[T](t: T): Reader[Any, T] = ConstantReader(t) - implicit def apply[E,T](fn: (E) => T): Reader[E, T] = ReaderFn(fn) + implicit def apply[E, T](fn: (E) => T): Reader[E, T] = ReaderFn(fn) - class ReaderM[Env] extends Monad[({type Result[T] = Reader[Env,T]})#Result] { + class ReaderM[Env] extends Monad[({ type Result[T] = Reader[Env, T] })#Result] { def apply[T](t: T) = ConstantReader(t) - def flatMap[T,U](self: Reader[Env, T])(next: T => Reader[Env, U]) = self.flatMap(next) - override def map[T,U](self: Reader[Env, T])(fn: T => U) = self.map(fn) + def flatMap[T, U](self: Reader[Env, T])(next: T => Reader[Env, U]) = self.flatMap(next) + override def map[T, U](self: Reader[Env, T])(fn: T => U) = self.map(fn) } - implicit def monad[Env]: Monad[({type Result[T] = Reader[Env,T]})#Result] = new ReaderM[Env] + implicit def monad[Env]: Monad[({ type Result[T] = Reader[Env, T] })#Result] = new ReaderM[Env] } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/monad/StateWithError.scala b/algebird-core/src/main/scala/com/twitter/algebird/monad/StateWithError.scala index 3e94cb49f..bc131121d 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/monad/StateWithError.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/monad/StateWithError.scala @@ -16,53 +16,53 @@ package com.twitter.algebird.monad -import com.twitter.algebird.{Monad, Semigroup} +import com.twitter.algebird.{ Monad, Semigroup } -/** Monad to handle mutating input state and possible failures. +/** + * Monad to handle mutating input state and possible failures. * This is used to interact in the planning phase with existing * mutable APIs (like storm or cascading), but retain the ability * to compose carefully. */ -sealed trait StateWithError[S,+F,+T] { - def join[F1 >: F, U](that: StateWithError[S,F1,U], mergeErr: (F1,F1) => F1, mergeState: (S,S) => S): - StateWithError[S,F1,(T,U)] = join(that)(Semigroup.from(mergeErr), Semigroup.from(mergeState)) - - def join[F1 >: F, U](that: StateWithError[S,F1,U])(implicit sgf: Semigroup[F1], sgs: Semigroup[S]): - // TODO: deep joins could blow the stack, not yet using trampoline here - StateWithError[S,F1,(T,U)] = StateFn( { (requested: S) => - (run(requested), that.run(requested)) match { - case (Right((s1, r1)), Right((s2, r2))) => Right((sgs.plus(s1, s2), (r1, r2))) - case (Left(err1), Left(err2)) => Left(sgf.plus(err1, err2)) // Our earlier is not ready - case (Left(err), _) => Left(err) - case (_, Left(err)) => Left(err) - } - }) +sealed trait StateWithError[S, +F, +T] { + def join[F1 >: F, U](that: StateWithError[S, F1, U], mergeErr: (F1, F1) => F1, mergeState: (S, S) => S): StateWithError[S, F1, (T, U)] = join(that)(Semigroup.from(mergeErr), Semigroup.from(mergeState)) + + def join[F1 >: F, U](that: StateWithError[S, F1, U])(implicit sgf: Semigroup[F1], sgs: Semigroup[S]): // TODO: deep joins could blow the stack, not yet using trampoline here + StateWithError[S, F1, (T, U)] = StateFn({ (requested: S) => + (run(requested), that.run(requested)) match { + case (Right((s1, r1)), Right((s2, r2))) => Right((sgs.plus(s1, s2), (r1, r2))) + case (Left(err1), Left(err2)) => Left(sgf.plus(err1, err2)) // Our earlier is not ready + case (Left(err), _) => Left(err) + case (_, Left(err)) => Left(err) + } + }) def apply(state: S): Either[F, (S, T)] = run(state) def run(state: S): Either[F, (S, T)] - def flatMap[F1 >: F, U](next: T => StateWithError[S,F1,U]): StateWithError[S,F1,U] = + def flatMap[F1 >: F, U](next: T => StateWithError[S, F1, U]): StateWithError[S, F1, U] = FlatMappedState(this, next) - def map[U](fn: (T) => U): StateWithError[S,F,U] = + def map[U](fn: (T) => U): StateWithError[S, F, U] = FlatMappedState(this, { (t: T) => StateWithError.const(fn(t)) }) } /** Simple wrapper of a function in the Monad */ -final case class StateFn[S,F,T](fn: S => Either[F, (S, T)]) extends StateWithError[S,F,T] { +final case class StateFn[S, F, T](fn: S => Either[F, (S, T)]) extends StateWithError[S, F, T] { def run(state: S) = fn(state) } -/** A Trampolining instance that should prevent stack overflow at the expense of performance +/** + * A Trampolining instance that should prevent stack overflow at the expense of performance */ -final case class FlatMappedState[S,F,T,U](start: StateWithError[S,F,T], fn: T => StateWithError[S, F, U]) extends StateWithError[S,F,U] { +final case class FlatMappedState[S, F, T, U](start: StateWithError[S, F, T], fn: T => StateWithError[S, F, U]) extends StateWithError[S, F, U] { def run(state: S): Either[F, (S, U)] = { @annotation.tailrec - def loop(inState: S, st: StateWithError[S, F, Any], stack: List[Any => StateWithError[S, F, Any]]): Any = { + def loop(inState: S, st: StateWithError[S, F, Any], stack: List[Any => StateWithError[S, F, Any]]): Any = { st match { case StateFn(fn) => fn(inState) match { - case err@Left(_) => err // bail at first error - case noError@Right((newState, out)) => + case err @ Left(_) => err // bail at first error + case noError @ Right((newState, out)) => stack match { case head :: tailStack => loop(newState, head(out), tailStack) case Nil => noError // recursion ends @@ -76,13 +76,13 @@ final case class FlatMappedState[S,F,T,U](start: StateWithError[S,F,T], fn: T => } object StateWithError { - def getState[S]: StateWithError[S,Nothing,S] = StateFn({ (state: S) => Right(state, state) }) - def putState[S](newState: S): StateWithError[S,Nothing,Unit] = StateFn({ (_: S) => Right(newState, ()) }) - def swapState[S](newState: S): StateWithError[S,Nothing,S] = StateFn({ (old: S) => Right(newState, old) }) + def getState[S]: StateWithError[S, Nothing, S] = StateFn({ (state: S) => Right(state, state) }) + def putState[S](newState: S): StateWithError[S, Nothing, Unit] = StateFn({ (_: S) => Right(newState, ()) }) + def swapState[S](newState: S): StateWithError[S, Nothing, S] = StateFn({ (old: S) => Right(newState, old) }) - def const[S,T](t: T): StateWithError[S,Nothing,T] = StateFn({ (state: S) => Right(state, t) }) - def lazyVal[S,T](t: => T): StateWithError[S,Nothing,T] = StateFn({ (state: S) => Right(state, t) }) - def failure[S,F](f: F): StateWithError[S,F,Nothing] = StateFn({ (state: S) => Left(f) }) + def const[S, T](t: T): StateWithError[S, Nothing, T] = StateFn({ (state: S) => Right(state, t) }) + def lazyVal[S, T](t: => T): StateWithError[S, Nothing, T] = StateFn({ (state: S) => Right(state, t) }) + def failure[S, F](f: F): StateWithError[S, F, Nothing] = StateFn({ (state: S) => Left(f) }) /** * Use like fromEither[Int](Right("good")) @@ -102,13 +102,13 @@ object StateWithError { // TODO this should move to Monad and work for any Monad def toKleisli[S] = new FunctionLifter[S] - implicit def apply[S, F, T](fn: S => Either[F, (S, T)]): StateWithError[S,F,T] = StateFn(fn) - implicit def monad[S,F]: Monad[({type Result[T] = StateWithError[S, F, T]})#Result] = - new StateFMonad[F,S] + implicit def apply[S, F, T](fn: S => Either[F, (S, T)]): StateWithError[S, F, T] = StateFn(fn) + implicit def monad[S, F]: Monad[({ type Result[T] = StateWithError[S, F, T] })#Result] = + new StateFMonad[F, S] - class StateFMonad[F,S] extends Monad[({type Result[T] = StateWithError[S, F, T]})#Result] { + class StateFMonad[F, S] extends Monad[({ type Result[T] = StateWithError[S, F, T] })#Result] { def apply[T](const: T) = { (s: S) => Right((s, const)) } - def flatMap[T,U](earlier: StateWithError[S,F,T])(next: T => StateWithError[S,F,U]) = earlier.flatMap(next) + def flatMap[T, U](earlier: StateWithError[S, F, T])(next: T => StateWithError[S, F, U]) = earlier.flatMap(next) } } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/monad/Trampoline.scala b/algebird-core/src/main/scala/com/twitter/algebird/monad/Trampoline.scala index 84de367f1..88ffedaa8 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/monad/Trampoline.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/monad/Trampoline.scala @@ -40,13 +40,13 @@ final case class FlatMapped[C, A](start: Trampoline[C], fn: C => Trampoline[A]) object Trampoline { val unit: Trampoline[Unit] = Done(()) def apply[A](a: A): Trampoline[A] = Done(a) - def lazyVal[A](a: => A): Trampoline[A] = FlatMapped(unit, { (u:Unit) => Done(a) }) + def lazyVal[A](a: => A): Trampoline[A] = FlatMapped(unit, { (u: Unit) => Done(a) }) /** * Use this to call to another trampoline returning function * you break the effect of this if you directly recursively call a Trampoline * returning function */ - def call[A](layzee: => Trampoline[A]): Trampoline[A] = FlatMapped(unit, { (u:Unit) => layzee }) + def call[A](layzee: => Trampoline[A]): Trampoline[A] = FlatMapped(unit, { (u: Unit) => layzee }) implicit val Monad: Monad[Trampoline] = new Monad[Trampoline] { def apply[A](a: A) = Done(a) def flatMap[A, B](start: Trampoline[A])(fn: A => Trampoline[B]) = start.flatMap(fn) diff --git a/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueAggregator.scala b/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueAggregator.scala index ec3fae0f2..25bc029bc 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueAggregator.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueAggregator.scala @@ -20,8 +20,8 @@ import scala.collection.JavaConverters._ import java.util.PriorityQueue -abstract class PriorityQueueAggregator[A,+B](max: Int)(implicit ord: Ordering[A]) - extends MonoidAggregator[A,PriorityQueue[A],B] { +abstract class PriorityQueueAggregator[A, +B](max: Int)(implicit ord: Ordering[A]) + extends MonoidAggregator[A, PriorityQueue[A], B] { /* you need to override: def present(q: PriorityQueue[A]): B @@ -35,7 +35,7 @@ abstract class PriorityQueueAggregator[A,+B](max: Int)(implicit ord: Ordering[A] * Should probably be your default Top-K implementation */ class PriorityQueueToListAggregator[A](max: Int)(implicit ord: Ordering[A]) - extends PriorityQueueAggregator[A,List[A]](max) { + extends PriorityQueueAggregator[A, List[A]](max) { def present(q: PriorityQueue[A]) = q.iterator.asScala.toList.sorted } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueMonoid.scala b/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueMonoid.scala index bcf58d559..ab4152c41 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueMonoid.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/mutable/PriorityQueueMonoid.scala @@ -22,14 +22,14 @@ import scala.collection.JavaConverters._ import java.util.PriorityQueue -/** for sort-with take and better performance over large values +/** + * for sort-with take and better performance over large values * The priority queues should be MAX queues, i.e. the ones we want least * should be in the .peek position * This is MUCH Faster for Top-K algorithms * Note this is MUTABLE. When you put something in plus, it is changed! */ -class PriorityQueueMonoid[K](max : Int)(implicit ord : Ordering[K]) extends - Monoid[PriorityQueue[K]] { +class PriorityQueueMonoid[K](max: Int)(implicit ord: Ordering[K]) extends Monoid[PriorityQueue[K]] { require(max > 0, "PriorityQueueMonoid requires keeping at least 1 item") // Java throws if you try to make a queue size 0 @@ -50,24 +50,23 @@ class PriorityQueueMonoid[K](max : Int)(implicit ord : Ordering[K]) extends q } protected def limit(q: PriorityQueue[K]) { - while(q.size > max) { q.poll() } + while (q.size > max) { q.poll() } } override def zero = new PriorityQueue[K](MINQUEUESIZE, ord.reverse) override def isNonZero(q: PriorityQueue[K]) = q.size > 0 - override def plus(left : PriorityQueue[K], right : PriorityQueue[K]): PriorityQueue[K] = { - val (bigger, smaller) = if(left.size >= right.size) (left, right) else (right, left) + override def plus(left: PriorityQueue[K], right: PriorityQueue[K]): PriorityQueue[K] = { + val (bigger, smaller) = if (left.size >= right.size) (left, right) else (right, left) var biggest = bigger.peek var next = smaller.poll - while(next != null) { - if(bigger.size < max) { + while (next != null) { + if (bigger.size < max) { // we may have increased the biggest value: biggest = ord.max(biggest, next) bigger.add(next) - } - else if (ord.lteq(next, biggest)) { + } else if (ord.lteq(next, biggest)) { // this cannot increase the biggest bigger.add(next) } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/package.scala b/algebird-core/src/main/scala/com/twitter/algebird/package.scala index cf6730475..24bbf7d42 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/package.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/package.scala @@ -17,10 +17,11 @@ package com.twitter package object algebird { - /** TODO remove these in scala 2.11 and use the standard there. + /** + * TODO remove these in scala 2.11 and use the standard there. * these are here to avoid massive bloat around these classes * https://github.com/twitter/algebird/issues/263 */ - private [algebird] abstract class AbstractIterable[T] extends Iterable[T] - private [algebird] abstract class AbstractIterator[T] extends Iterator[T] + private[algebird] abstract class AbstractIterable[T] extends Iterable[T] + private[algebird] abstract class AbstractIterator[T] extends Iterator[T] } diff --git a/algebird-core/src/main/scala/com/twitter/algebird/statistics/IterCallStatistics.scala b/algebird-core/src/main/scala/com/twitter/algebird/statistics/IterCallStatistics.scala index 602ae6f0e..86fbfef5d 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/statistics/IterCallStatistics.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/statistics/IterCallStatistics.scala @@ -44,8 +44,8 @@ private class IterCallStatistics(threadSafe: Boolean) { override def toString = distribution.zipWithIndex.map { - case (v, i) => - (if(i == maxBucket) ">" else "<" + pow2(i)) + ": " + v + case (v, i) => + (if (i == maxBucket) ">" else "<" + pow2(i)) + ": " + v }.mkString(", ") + ", avg=" + total.toDouble / count + " count=" + count } @@ -66,7 +66,7 @@ private class IterCallStatistics(threadSafe: Boolean) { } /** measures the time spent calling f on iter and the size of iter */ - def measure[T, O](iter: TraversableOnce[T]) (f: (TraversableOnce[T]) => O): O = { + def measure[T, O](iter: TraversableOnce[T])(f: (TraversableOnce[T]) => O): O = { val ci = new CountingIterator(iter.toIterator) val t0 = System.currentTimeMillis() val r = f(ci) @@ -81,6 +81,6 @@ private class IterCallStatistics(threadSafe: Boolean) { override def toString = countStats.toString + ", " + - "total time: " + totalCallTime + "ms, " + - "avg time: " + (totalCallTime.toDouble / countStats.count) + "total time: " + totalCallTime + "ms, " + + "avg time: " + (totalCallTime.toDouble / countStats.count) } \ No newline at end of file diff --git a/algebird-core/src/main/scala/com/twitter/algebird/statistics/Statistics.scala b/algebird-core/src/main/scala/com/twitter/algebird/statistics/Statistics.scala index fec421257..01df79e17 100644 --- a/algebird-core/src/main/scala/com/twitter/algebird/statistics/Statistics.scala +++ b/algebird-core/src/main/scala/com/twitter/algebird/statistics/Statistics.scala @@ -15,17 +15,17 @@ limitations under the License. */ package com.twitter.algebird.statistics -import com.twitter.algebird.{Semigroup, Monoid, Group, Ring} +import com.twitter.algebird.{ Semigroup, Monoid, Group, Ring } /** * These wrappers can be used to collect statistics around usage of monoids * They are thread safe unless false is passed to the constructor (to remove overhead when threads are not used) - * + * * @author Julien Le Dem */ /** collect statistics about the calls to the wrapped Semigroup */ -class StatisticsSemigroup[T](threadSafe: Boolean = true) (implicit wrappedSemigroup: Semigroup[T]) +class StatisticsSemigroup[T](threadSafe: Boolean = true)(implicit wrappedSemigroup: Semigroup[T]) extends Semigroup[T] { private[this] final val plusCallsCount = Counter(threadSafe) @@ -46,13 +46,13 @@ class StatisticsSemigroup[T](threadSafe: Boolean = true) (implicit wrappedSemigr override def toString = "plus calls: " + plusCallsCount + "\n" + - "sumOption calls: " + sumOptionCallsStats + "sumOption calls: " + sumOptionCallsStats } /** * @see StatisticsSemigroup */ -class StatisticsMonoid[T](threadSafe: Boolean = true) (implicit wrappedMonoid: Monoid[T]) +class StatisticsMonoid[T](threadSafe: Boolean = true)(implicit wrappedMonoid: Monoid[T]) extends StatisticsSemigroup[T](threadSafe) with Monoid[T] { private[this] final val zeroCallsCount = Counter(threadSafe) @@ -73,14 +73,14 @@ class StatisticsMonoid[T](threadSafe: Boolean = true) (implicit wrappedMonoid: M override def toString = super.toString + "\n" + - "zero calls: " + zeroCallsCount + "\n" + - "sum calls: " + sumCallsStats + "zero calls: " + zeroCallsCount + "\n" + + "sum calls: " + sumCallsStats } /** * @see StatisticsSemigroup */ -class StatisticsGroup[T](threadSafe: Boolean = true) (implicit group: Group[T]) +class StatisticsGroup[T](threadSafe: Boolean = true)(implicit group: Group[T]) extends StatisticsMonoid[T](threadSafe) with Group[T] { private[this] final val negateCallsCount = Counter(threadSafe) @@ -95,21 +95,21 @@ class StatisticsGroup[T](threadSafe: Boolean = true) (implicit group: Group[T]) Group.negate(x) } - override def minus(l : T, r : T) = { + override def minus(l: T, r: T) = { minusCallsCount.increment Group.minus(l, r) } override def toString = super.toString + "\n" + - "negate calls: " + negateCallsCount + "\n" + - "minus calls: " + minusCallsCount + "negate calls: " + negateCallsCount + "\n" + + "minus calls: " + minusCallsCount } /** * @see StatisticsSemigroup */ -class StatisticsRing[T](threadSafe: Boolean = true) (implicit ring: Ring[T]) +class StatisticsRing[T](threadSafe: Boolean = true)(implicit ring: Ring[T]) extends StatisticsGroup[T](threadSafe) with Ring[T] { private[this] final val oneCallsCount = Counter(threadSafe) @@ -132,13 +132,13 @@ class StatisticsRing[T](threadSafe: Boolean = true) (implicit ring: Ring[T]) Ring.times(x, y) } - override def product(iter : TraversableOnce[T]): T = + override def product(iter: TraversableOnce[T]): T = productCallsStats.measure(iter) { Ring.product(_) } override def toString = super.toString + "\n" + - "one calls: " + oneCallsCount + "\n" + - "time calls: " + timesCallsCount + "\n" + - "product calls: " + productCallsStats + "one calls: " + oneCallsCount + "\n" + + "time calls: " + timesCallsCount + "\n" + + "product calls: " + productCallsStats } diff --git a/algebird-test/src/main/scala/com/twitter/algebird/BaseProperties.scala b/algebird-test/src/main/scala/com/twitter/algebird/BaseProperties.scala index a06bd6940..20d6ff189 100644 --- a/algebird-test/src/main/scala/com/twitter/algebird/BaseProperties.scala +++ b/algebird-test/src/main/scala/com/twitter/algebird/BaseProperties.scala @@ -24,140 +24,140 @@ import scala.math.Equiv */ object BaseProperties { - def defaultEq[T](t0 : T, t1 : T) = t0 == t1 + def defaultEq[T](t0: T, t1: T) = t0 == t1 def isNonZero[V: Semigroup](v: V) = implicitly[Semigroup[V]] match { case mon: Monoid[_] => mon.isNonZero(v) case _ => true } - def isAssociativeEq[T: Semigroup, U <:T: Arbitrary](eqfn : (T,T) => Boolean) = { - forAll { (a : U, b : U, c : U) => + def isAssociativeEq[T: Semigroup, U <: T: Arbitrary](eqfn: (T, T) => Boolean) = { + forAll { (a: U, b: U, c: U) => val semi = implicitly[Semigroup[T]] - eqfn(semi.plus(a, semi.plus(b,c)), semi.plus(semi.plus(a,b), c)) + eqfn(semi.plus(a, semi.plus(b, c)), semi.plus(semi.plus(a, b), c)) } } - def isAssociativeDifferentTypes[T : Semigroup, U<: T :Arbitrary] = + def isAssociativeDifferentTypes[T: Semigroup, U <: T: Arbitrary] = isAssociativeEq[T, U](defaultEq _) - def isAssociative[T : Semigroup :Arbitrary] = isAssociativeDifferentTypes[T, T] + def isAssociative[T: Semigroup: Arbitrary] = isAssociativeDifferentTypes[T, T] - def semigroupSumWorks[T:Semigroup:Arbitrary:Equiv] = forAll { (in: List[T]) => + def semigroupSumWorks[T: Semigroup: Arbitrary: Equiv] = forAll { (in: List[T]) => in.isEmpty || { - Equiv[T].equiv(Semigroup.sumOption(in).get, in.reduceLeft(Semigroup.plus(_,_))) + Equiv[T].equiv(Semigroup.sumOption(in).get, in.reduceLeft(Semigroup.plus(_, _))) } } - def isCommutativeEq[T : Semigroup : Arbitrary](eqfn: (T,T) => Boolean) = forAll { (a:T,b:T)=> + def isCommutativeEq[T: Semigroup: Arbitrary](eqfn: (T, T) => Boolean) = forAll { (a: T, b: T) => val semi = implicitly[Semigroup[T]] - eqfn(semi.plus(a,b), semi.plus(b,a)) + eqfn(semi.plus(a, b), semi.plus(b, a)) } - def isCommutative[T : Semigroup : Arbitrary] = isCommutativeEq[T](defaultEq _) + def isCommutative[T: Semigroup: Arbitrary] = isCommutativeEq[T](defaultEq _) - def semigroupLaws[T : Semigroup : Arbitrary] = { + def semigroupLaws[T: Semigroup: Arbitrary] = { implicit val eq: Equiv[T] = Equiv.fromFunction(defaultEq) semigroupLawsEquiv[T] } - def semigroupLawsEq[T : Semigroup : Arbitrary](eqfn : (T,T) => Boolean) = { + def semigroupLawsEq[T: Semigroup: Arbitrary](eqfn: (T, T) => Boolean) = { implicit val eq: Equiv[T] = Equiv.fromFunction(eqfn) semigroupLawsEquiv[T] } - def semigroupLawsEquiv[T : Semigroup : Arbitrary: Equiv] = - isAssociativeEq[T,T](Equiv[T].equiv _) && semigroupSumWorks[T] + def semigroupLawsEquiv[T: Semigroup: Arbitrary: Equiv] = + isAssociativeEq[T, T](Equiv[T].equiv _) && semigroupSumWorks[T] - def commutativeSemigroupLawsEq[T : Semigroup : Arbitrary](eqfn : (T,T) => Boolean) = - isAssociativeEq[T,T](eqfn) && isCommutativeEq[T](eqfn) - def commutativeSemigroupLaws[T : Semigroup : Arbitrary] = commutativeSemigroupLawsEq[T](defaultEq _) + def commutativeSemigroupLawsEq[T: Semigroup: Arbitrary](eqfn: (T, T) => Boolean) = + isAssociativeEq[T, T](eqfn) && isCommutativeEq[T](eqfn) + def commutativeSemigroupLaws[T: Semigroup: Arbitrary] = commutativeSemigroupLawsEq[T](defaultEq _) - def isNonZeroWorksMonoid[T:Monoid:Arbitrary:Equiv] = forAll { (a: T, b: T) => - val aIsLikeZero = Monoid.zeroEquiv[T].equiv(Monoid.plus(a,b), b) + def isNonZeroWorksMonoid[T: Monoid: Arbitrary: Equiv] = forAll { (a: T, b: T) => + val aIsLikeZero = Monoid.zeroEquiv[T].equiv(Monoid.plus(a, b), b) Monoid.isNonZero(a) || aIsLikeZero } - def isNonZeroWorksRing[T:Ring:Arbitrary] = forAll { (a: T, b: T) => + def isNonZeroWorksRing[T: Ring: Arbitrary] = forAll { (a: T, b: T) => implicit val monT: Monoid[T] = implicitly[Ring[T]] - val prodZero = !monT.isNonZero(Ring.times(a,b)) + val prodZero = !monT.isNonZero(Ring.times(a, b)) (Monoid.isNonZero(a) && Monoid.isNonZero(b)) || prodZero } - def weakZeroDifferentTypes[T : Monoid, U<: T :Arbitrary] = forAll { (a : U) => + def weakZeroDifferentTypes[T: Monoid, U <: T: Arbitrary] = forAll { (a: U) => val mon = implicitly[Monoid[T]] val zero = mon.zero // Some types, e.g. Maps, are not totally equal for all inputs (i.e. zero values removed) (mon.plus(a, zero) == mon.plus(zero, a)) } - def weakZero[T : Monoid : Arbitrary] = weakZeroDifferentTypes[T,T] + def weakZero[T: Monoid: Arbitrary] = weakZeroDifferentTypes[T, T] - def validZeroEq[T : Monoid : Arbitrary](eqfn : (T,T) => Boolean) = forAll { (a : T) => + def validZeroEq[T: Monoid: Arbitrary](eqfn: (T, T) => Boolean) = forAll { (a: T) => val mon = implicitly[Monoid[T]] val zero = mon.zero - eqfn(a, mon.plus(a, zero)) && eqfn(mon.plus(zero, a), a) && eqfn(mon.plus(a,zero),mon.plus(zero,a)) + eqfn(a, mon.plus(a, zero)) && eqfn(mon.plus(zero, a), a) && eqfn(mon.plus(a, zero), mon.plus(zero, a)) } - def validZero[T : Monoid : Arbitrary] = validZeroEq[T](defaultEq _) + def validZero[T: Monoid: Arbitrary] = validZeroEq[T](defaultEq _) - def monoidLaws[T : Monoid : Arbitrary] = validZero[T] && semigroupLaws[T] && isNonZeroWorksMonoid[T] - def monoidLawsEq[T : Monoid : Arbitrary](eqfn : (T,T) => Boolean) = + def monoidLaws[T: Monoid: Arbitrary] = validZero[T] && semigroupLaws[T] && isNonZeroWorksMonoid[T] + def monoidLawsEq[T: Monoid: Arbitrary](eqfn: (T, T) => Boolean) = validZeroEq[T](eqfn) && semigroupLawsEq[T](eqfn) - def commutativeMonoidLawsEq[T : Monoid : Arbitrary](eqfn : (T,T) => Boolean) = + def commutativeMonoidLawsEq[T: Monoid: Arbitrary](eqfn: (T, T) => Boolean) = monoidLawsEq[T](eqfn) && isCommutativeEq[T](eqfn) - def commutativeMonoidLaws[T:Monoid:Arbitrary] = commutativeMonoidLawsEq[T](defaultEq _) + def commutativeMonoidLaws[T: Monoid: Arbitrary] = commutativeMonoidLawsEq[T](defaultEq _) - def hasAdditiveInversesDifferentTypes[T: Group, U<: T: Arbitrary] = forAll { (a : U) => + def hasAdditiveInversesDifferentTypes[T: Group, U <: T: Arbitrary] = forAll { (a: U) => val grp = implicitly[Group[T]] (!grp.isNonZero(grp.plus(grp.negate(a), a))) && - (!grp.isNonZero(grp.minus(a,a))) && + (!grp.isNonZero(grp.minus(a, a))) && (!grp.isNonZero(grp.plus(a, grp.negate(a)))) } - def hasAdditiveInverses[T: Group : Arbitrary] = hasAdditiveInversesDifferentTypes[T, T] + def hasAdditiveInverses[T: Group: Arbitrary] = hasAdditiveInversesDifferentTypes[T, T] - def groupLawsEq[T : Group : Arbitrary](eqfn : (T,T) => Boolean) = monoidLawsEq[T](eqfn) && hasAdditiveInverses[T] + def groupLawsEq[T: Group: Arbitrary](eqfn: (T, T) => Boolean) = monoidLawsEq[T](eqfn) && hasAdditiveInverses[T] - def groupLaws[T : Group : Arbitrary] = monoidLaws[T] && hasAdditiveInverses[T] + def groupLaws[T: Group: Arbitrary] = monoidLaws[T] && hasAdditiveInverses[T] // Here are multiplicative properties: - def validOne[T : Ring : Arbitrary] = forAll { (a : T) => + def validOne[T: Ring: Arbitrary] = forAll { (a: T) => val rng = implicitly[Ring[T]] (rng.times(rng.one, a) == rng.times(a, rng.one)) && (a == rng.times(a, rng.one)) } - def zeroAnnihilates[T:Ring:Arbitrary] = forAll { (a:T) => + def zeroAnnihilates[T: Ring: Arbitrary] = forAll { (a: T) => val ring = implicitly[Ring[T]] (!ring.isNonZero(ring.times(a, ring.zero))) && (!ring.isNonZero(ring.times(ring.zero, a))) } - def isDistributiveDifferentTypes[T: Ring,U<: T: Arbitrary] = forAll { (a : U, b : U, c : U) => + def isDistributiveDifferentTypes[T: Ring, U <: T: Arbitrary] = forAll { (a: U, b: U, c: U) => val rng = implicitly[Ring[T]] - (rng.times(a, rng.plus(b,c)) == rng.plus(rng.times(a,b), rng.times(a,c))) && - (rng.times(rng.plus(b,c),a) == rng.plus(rng.times(b,a), rng.times(c,a))) + (rng.times(a, rng.plus(b, c)) == rng.plus(rng.times(a, b), rng.times(a, c))) && + (rng.times(rng.plus(b, c), a) == rng.plus(rng.times(b, a), rng.times(c, a))) } - def isDistributive[T : Ring : Arbitrary] = isDistributiveDifferentTypes[T, T] + def isDistributive[T: Ring: Arbitrary] = isDistributiveDifferentTypes[T, T] - def timesIsAssociative[T : Ring : Arbitrary] = forAll { (a : T, b : T, c : T) => + def timesIsAssociative[T: Ring: Arbitrary] = forAll { (a: T, b: T, c: T) => val rng = implicitly[Ring[T]] - rng.times(a, rng.times(b,c)) == rng.times(rng.times(a,b),c) + rng.times(a, rng.times(b, c)) == rng.times(rng.times(a, b), c) } - def pseudoRingLaws[T:Ring:Arbitrary] = + def pseudoRingLaws[T: Ring: Arbitrary] = isDistributive[T] && timesIsAssociative[T] && groupLaws[T] && isCommutative[T] && - isNonZeroWorksRing[T] + isNonZeroWorksRing[T] - def semiringLaws[T:Ring:Arbitrary] = + def semiringLaws[T: Ring: Arbitrary] = isDistributive[T] && timesIsAssociative[T] && validOne[T] && commutativeMonoidLaws[T] && zeroAnnihilates[T] && isNonZeroWorksRing[T] - def ringLaws[T : Ring : Arbitrary] = validOne[T] && pseudoRingLaws[T] + def ringLaws[T: Ring: Arbitrary] = validOne[T] && pseudoRingLaws[T] - def hasMultiplicativeInverse[T : Field : Arbitrary] = forAll { (a : T) => + def hasMultiplicativeInverse[T: Field: Arbitrary] = forAll { (a: T) => val fld = implicitly[Field[T]] (!fld.isNonZero(a)) || { val inva = fld.inverse(a) (fld.times(inva, a) == fld.one) && (fld.times(a, inva) == fld.one) } } - def fieldLaws[T : Field : Arbitrary] = ringLaws[T] && hasMultiplicativeInverse[T] + def fieldLaws[T: Field: Arbitrary] = ringLaws[T] && hasMultiplicativeInverse[T] } diff --git a/algebird-test/src/main/scala/com/twitter/algebird/MonadLaws.scala b/algebird-test/src/main/scala/com/twitter/algebird/MonadLaws.scala index a5481d88a..a00c701f4 100644 --- a/algebird-test/src/main/scala/com/twitter/algebird/MonadLaws.scala +++ b/algebird-test/src/main/scala/com/twitter/algebird/MonadLaws.scala @@ -21,7 +21,7 @@ import org.scalacheck.Arbitrary.arbitrary import org.scalacheck.Gen.choose import org.scalacheck.Prop.forAll -import Monad.{pureOp, operators} +import Monad.{ pureOp, operators } /** * Basic Monad laws, useful for testing any monad. @@ -30,35 +30,31 @@ import Monad.{pureOp, operators} object MonadLaws { import BaseProperties._ - def defaultEq[T] = {(t0: T, t1: T) => (t0 == t1)} + def defaultEq[T] = { (t0: T, t1: T) => (t0 == t1) } - def leftIdentity[M[_],T,U](eq: (M[U],M[U]) => Boolean = defaultEq[M[U]]) - (implicit monad: Monad[M], arb: Arbitrary[T], arbfn: Arbitrary[(T) => M[U]]) = - forAll { (t: T, fn: T => M[U]) => eq(t.pure[M].flatMap(fn), fn(t)) } + def leftIdentity[M[_], T, U](eq: (M[U], M[U]) => Boolean = defaultEq[M[U]])(implicit monad: Monad[M], arb: Arbitrary[T], arbfn: Arbitrary[(T) => M[U]]) = + forAll { (t: T, fn: T => M[U]) => eq(t.pure[M].flatMap(fn), fn(t)) } - def rightIdentity[M[_],T](eq: (M[T],M[T]) => Boolean = defaultEq[M[T]]) - (implicit monad: Monad[M], arb: Arbitrary[M[T]]) = + def rightIdentity[M[_], T](eq: (M[T], M[T]) => Boolean = defaultEq[M[T]])(implicit monad: Monad[M], arb: Arbitrary[M[T]]) = forAll { (mt: M[T]) => eq(mt.flatMap { _.pure[M] }, mt) } - def associative[M[_],T,U,V](eq: (M[V],M[V]) => Boolean) - (implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) => M[U]], - fn2: Arbitrary[U => M[V]]) = forAll { (mt: M[T], f1: T => M[U], f2: U => M[V]) => + def associative[M[_], T, U, V](eq: (M[V], M[V]) => Boolean)(implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) => M[U]], + fn2: Arbitrary[U => M[V]]) = forAll { (mt: M[T], f1: T => M[U], f2: U => M[V]) => eq(mt.flatMap(f1).flatMap(f2), mt.flatMap { t => f1(t).flatMap(f2) }) } // Just generate a map and use that as a function: - implicit def fnArb[M[_],T,U](implicit map: Arbitrary[Map[T,M[U]]], - arbu: Arbitrary[M[U]]): - Arbitrary[T => M[U]] = Arbitrary { - for( m <- implicitly[Arbitrary[Map[T,M[U]]]].arbitrary; - defu <- implicitly[Arbitrary[M[U]]].arbitrary) - yield ({(t: T) => m.getOrElse(t, defu)}) - } - - def monadLaws[M[_],T,U,R](eq: (M[R],M[R]) => Boolean = defaultEq[M[R]]) - (implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) => M[U]], - arbr: Arbitrary[M[R]], fn2: Arbitrary[U => M[R]], arbu: Arbitrary[U]) = - associative[M,T,U,R](eq) && rightIdentity[M,R](eq) && leftIdentity[M,U,R](eq) + implicit def fnArb[M[_], T, U](implicit map: Arbitrary[Map[T, M[U]]], + arbu: Arbitrary[M[U]]): Arbitrary[T => M[U]] = Arbitrary { + for ( + m <- implicitly[Arbitrary[Map[T, M[U]]]].arbitrary; + defu <- implicitly[Arbitrary[M[U]]].arbitrary + ) yield ({ (t: T) => m.getOrElse(t, defu) }) + } + + def monadLaws[M[_], T, U, R](eq: (M[R], M[R]) => Boolean = defaultEq[M[R]])(implicit monad: Monad[M], arb: Arbitrary[M[T]], fn1: Arbitrary[(T) => M[U]], + arbr: Arbitrary[M[R]], fn2: Arbitrary[U => M[R]], arbu: Arbitrary[U]) = + associative[M, T, U, R](eq) && rightIdentity[M, R](eq) && leftIdentity[M, U, R](eq) implicit def indexedSeqA[T](implicit arbl: Arbitrary[List[T]]): Arbitrary[IndexedSeq[T]] = Arbitrary { arbl.arbitrary.map { _.toIndexedSeq } } diff --git a/algebird-test/src/main/scala/com/twitter/algebird/StatefulSummerLaws.scala b/algebird-test/src/main/scala/com/twitter/algebird/StatefulSummerLaws.scala index ff1a59372..ec6960b9c 100644 --- a/algebird-test/src/main/scala/com/twitter/algebird/StatefulSummerLaws.scala +++ b/algebird-test/src/main/scala/com/twitter/algebird/StatefulSummerLaws.scala @@ -20,18 +20,17 @@ object StatefulSummerLaws { import BaseProperties.isNonZero // Law1: - def zeroEquiv[V:Semigroup:Equiv](v0: Option[V], v1: Option[V]): Boolean = { + def zeroEquiv[V: Semigroup: Equiv](v0: Option[V], v1: Option[V]): Boolean = { val v0NonZero = v0.exists(isNonZero(_)) val v1NonZero = v1.exists(isNonZero(_)) - if (!(v0NonZero||v1NonZero)) { + if (!(v0NonZero || v1NonZero)) { // neither are non-zero true - } - else { - (for(a <- v0; b <- v1; eq = Equiv[V].equiv(a,b)) yield eq).getOrElse(false) + } else { + (for (a <- v0; b <- v1; eq = Equiv[V].equiv(a, b)) yield eq).getOrElse(false) } } - def sumIsPreserved[V:Semigroup:Equiv](summer: StatefulSummer[V], items: Iterable[V]): Boolean = { + def sumIsPreserved[V: Semigroup: Equiv](summer: StatefulSummer[V], items: Iterable[V]): Boolean = { summer.flush val sg = Semigroup.sumOption(items) val wsummer = Monoid.plus(Monoid.sum(items.map { summer.put(_) }.filter { _.isDefined }), summer.flush) diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/PromiseLinkMonoid.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/PromiseLinkMonoid.scala index 51f476296..f8b34a871 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/PromiseLinkMonoid.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/PromiseLinkMonoid.scala @@ -25,7 +25,7 @@ import com.twitter.util.Promise * the value just before the PromiseLink is calculated. */ class PromiseLinkMonoid[V](monoid: Monoid[V]) extends Monoid[PromiseLink[V]] { //TODo(jcoveney) rename PromiseLink - def zero = PromiseLink(new Promise, monoid.zero) + def zero = PromiseLink(new Promise, monoid.zero) def plus(older: PromiseLink[V], newer: PromiseLink[V]): PromiseLink[V] = { val (PromiseLink(p1, v1), PromiseLink(p2, v2)) = (older, newer) @@ -35,7 +35,7 @@ class PromiseLinkMonoid[V](monoid: Monoid[V]) extends Monoid[PromiseLink[V]] { / PromiseLink(p2, monoid.plus(v1, v2)) } - override def isNonZero(v: PromiseLink[V]) = monoid.isNonZero(v.value) + override def isNonZero(v: PromiseLink[V]) = monoid.isNonZero(v.value) } /** @@ -43,7 +43,7 @@ class PromiseLinkMonoid[V](monoid: Monoid[V]) extends Monoid[PromiseLink[V]] { / * fulfilling the Promise with the value just before the value is added in. */ case class PromiseLink[V](promise: Promise[V], value: V) { - def completeWithStartingValue(startingV: V)(implicit monoid: Monoid[V]):V = { + def completeWithStartingValue(startingV: V)(implicit monoid: Monoid[V]): V = { Tunnel.properPromiseUpdate(promise, startingV) monoid.plus(startingV, value) } @@ -53,5 +53,5 @@ object PromiseLink { implicit def monoid[V](implicit innerMonoid: Monoid[V]): PromiseLinkMonoid[V] = new PromiseLinkMonoid[V](innerMonoid) - def toPromiseLink[V](value:V) = PromiseLink(new Promise, value) + def toPromiseLink[V](value: V) = PromiseLink(new Promise, value) } \ No newline at end of file diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/TunnelMonoid.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/TunnelMonoid.scala index b3e72c439..51de342c1 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/TunnelMonoid.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/TunnelMonoid.scala @@ -16,11 +16,11 @@ limitations under the License. package com.twitter.algebird.util import com.twitter.algebird._ -import com.twitter.util.{ Future, Promise, Return} +import com.twitter.util.{ Future, Promise, Return } /** * This Monoid allows code to depends on the results of asynchronous - * computation. It is relatively common to have code which takes a + * computation. It is relatively common to have code which takes a * Monoid and elements, but applies the computation in an opaque way * (a cache, for example). This allows the code handing over the * elements (in this case, Tunnel objects) to depend on the result @@ -29,14 +29,14 @@ import com.twitter.util.{ Future, Promise, Return} * objects are created. This is the async analogue of Function1Monoid. */ class TunnelMonoid[V] extends Monoid[Tunnel[V]] { - def zero = { + def zero = { val promise = new Promise[V] Tunnel(promise, promise) } override def isNonZero(v: Tunnel[V]) = !(v.promise eq v.future) - def plus(older:Tunnel[V], newer:Tunnel[V]):Tunnel[V] = { + def plus(older: Tunnel[V], newer: Tunnel[V]): Tunnel[V] = { val (Tunnel(f1, p1), Tunnel(f2, p2)) = (older, newer) f2.foreach { Tunnel.properPromiseUpdate(p1, _) } Tunnel(f1, p2) @@ -50,8 +50,8 @@ class TunnelMonoid[V] extends Monoid[Tunnel[V]] { * a Tunnel in computation by a TunnelMonoid will cause the promise to be * fulfilled more than once which will most likely lead to errors. */ -case class Tunnel[V](future:Future[V], promise:Promise[V]) { - def willEqual(other:Tunnel[V]):Future[Boolean] = +case class Tunnel[V](future: Future[V], promise: Promise[V]) { + def willEqual(other: Tunnel[V]): Future[Boolean] = for { b1 <- future b2 <- other.future @@ -63,20 +63,20 @@ case class Tunnel[V](future:Future[V], promise:Promise[V]) { * only be called once. In this way, it is dangerous to reuse Tunnel * objects in Monoid code that might reuse objects. */ - def apply(v:V):Future[V] = { + def apply(v: V): Future[V] = { Tunnel.properPromiseUpdate(promise, v) future } } object Tunnel { - implicit def monoid[V]:TunnelMonoid[V] = new TunnelMonoid[V] + implicit def monoid[V]: TunnelMonoid[V] = new TunnelMonoid[V] /** * This lifts a value into a Tunnel. This is where the Monoidic * computation underlying a TunnelMonoid actually happens. */ - def toIncrement[V](v:V)(implicit monoid:Monoid[V]) = { + def toIncrement[V](v: V)(implicit monoid: Monoid[V]) = { val promise = new Promise[V] Tunnel(promise.map { monoid.plus(_, v) }, promise) } @@ -86,16 +86,15 @@ object Tunnel { * this will throw an error if the value is different from the previous * value that was used. */ - def properPromiseUpdate[V](promise:Promise[V], newV:V):Unit = { + def properPromiseUpdate[V](promise: Promise[V], newV: V): Unit = { if (!promise.updateIfEmpty(Return(newV))) { - promise.foreach { oldV => + promise.foreach { oldV => assert(oldV == newV, "Cannot set a promise multiple times with different values." + " Old value: %s New value: %s".format(oldV, newV)) } } } - def from[V](fn: V => V): Tunnel[V] = { val prom = new Promise[V] Tunnel(prom.map(fn), prom) diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/UtilAlgebras.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/UtilAlgebras.scala index 055abdb2c..ff54ccf33 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/UtilAlgebras.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/UtilAlgebras.scala @@ -28,18 +28,18 @@ object UtilAlgebras { implicit val tryMonad: Monad[Try] = new Monad[Try] { def apply[T](v: T) = Return(v) override def map[T, U](m: Try[T])(fn: T => U) = m.map(fn) - def flatMap[T,U](m: Try[T])(fn: T => Try[U]) = m.flatMap(fn) + def flatMap[T, U](m: Try[T])(fn: T => Try[U]) = m.flatMap(fn) } - implicit def futureSemigroup[T:Semigroup]: Semigroup[Future[T]] = new MonadSemigroup[T, Future] - implicit def futureMonoid[T:Monoid]: Monoid[Future[T]] = new MonadMonoid[T, Future] - implicit def futureGroup[T:Group]: Group[Future[T]] = new MonadGroup[T, Future] - implicit def futureRing[T:Ring]: Ring[Future[T]] = new MonadRing[T, Future] - implicit def futureField[T:Field]: Field[Future[T]] = new MonadField[T, Future] + implicit def futureSemigroup[T: Semigroup]: Semigroup[Future[T]] = new MonadSemigroup[T, Future] + implicit def futureMonoid[T: Monoid]: Monoid[Future[T]] = new MonadMonoid[T, Future] + implicit def futureGroup[T: Group]: Group[Future[T]] = new MonadGroup[T, Future] + implicit def futureRing[T: Ring]: Ring[Future[T]] = new MonadRing[T, Future] + implicit def futureField[T: Field]: Field[Future[T]] = new MonadField[T, Future] - implicit def trySemigroup[T:Semigroup]: Semigroup[Try[T]] = new MonadSemigroup[T, Try] - implicit def tryMonoid[T:Monoid]: Monoid[Try[T]] = new MonadMonoid[T, Try] - implicit def tryGroup[T:Group]: Group[Try[T]] = new MonadGroup[T, Try] - implicit def tryRing[T:Ring]: Ring[Try[T]] = new MonadRing[T, Try] - implicit def tryField[T:Field]: Field[Try[T]] = new MonadField[T, Try] + implicit def trySemigroup[T: Semigroup]: Semigroup[Try[T]] = new MonadSemigroup[T, Try] + implicit def tryMonoid[T: Monoid]: Monoid[Try[T]] = new MonadMonoid[T, Try] + implicit def tryGroup[T: Group]: Group[Try[T]] = new MonadGroup[T, Try] + implicit def tryRing[T: Ring]: Ring[Try[T]] = new MonadRing[T, Try] + implicit def tryField[T: Field]: Field[Try[T]] = new MonadField[T, Try] } diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListMMapSum.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListMMapSum.scala index ff8bf8da3..68e96a15f 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListMMapSum.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListMMapSum.scala @@ -16,11 +16,11 @@ limitations under the License. package com.twitter.algebird.util.summer import com.twitter.algebird._ -import com.twitter.util.{Duration, Future, FuturePool} +import com.twitter.util.{ Duration, Future, FuturePool } import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.atomic.AtomicInteger import scala.collection.JavaConverters._ -import scala.collection.mutable.{Set => MSet, ListBuffer, Map => MMap} +import scala.collection.mutable.{ Set => MSet, ListBuffer, Map => MMap } import scala.collection.breakOut /** @@ -30,25 +30,21 @@ import scala.collection.breakOut * When flushing it acquires the lock, drains the mutable map but does the compaction without holding the lock. */ - - class AsyncListMMapSum[Key, Value](bufferSize: BufferSize, - override val flushFrequency: FlushFrequency, - override val softMemoryFlush: MemoryFlushPercent, - workPool: FuturePool) - (implicit sg: Semigroup[Value]) - extends AsyncSummer[(Key, Value), Map[Key, Value]] - with WithFlushConditions[(Key, Value), Map[Key, Value]] { + override val flushFrequency: FlushFrequency, + override val softMemoryFlush: MemoryFlushPercent, + workPool: FuturePool)(implicit sg: Semigroup[Value]) + extends AsyncSummer[(Key, Value), Map[Key, Value]] + with WithFlushConditions[(Key, Value), Map[Key, Value]] { require(bufferSize.v > 0, "Use the Null summer for an empty async summer") - private[this] final val queueMap = MMap[Key, ListBuffer[Value]]() private[this] final val mutex = new Object() @volatile private[this] var presentTuples = 0 protected override val emptyResult = Map.empty[Key, Value] - override def isFlushed: Boolean = mutex.synchronized{ presentTuples == 0 } + override def isFlushed: Boolean = mutex.synchronized{ presentTuples == 0 } override def flush: Future[Map[Key, Value]] = workPool { @@ -59,8 +55,9 @@ class AsyncListMMapSum[Key, Value](bufferSize: BufferSize, queueMap.clear l } - curData.flatMap { case (k, listV) => - sg.sumOption(listV).map(v => (k, v)) + curData.flatMap { + case (k, listV) => + sg.sumOption(listV).map(v => (k, v)) }(breakOut) } @@ -68,15 +65,16 @@ class AsyncListMMapSum[Key, Value](bufferSize: BufferSize, var newlyAddedTuples = 0 mutex.synchronized { - vals.foreach { case (k, v) => - val existingV = queueMap.getOrElseUpdate(k, ListBuffer[Value]()) - existingV += v - newlyAddedTuples += 1 + vals.foreach { + case (k, v) => + val existingV = queueMap.getOrElseUpdate(k, ListBuffer[Value]()) + existingV += v + newlyAddedTuples += 1 } presentTuples += newlyAddedTuples } - if(presentTuples >= bufferSize.v) + if (presentTuples >= bufferSize.v) flush else Future.value(emptyResult) diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListSum.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListSum.scala index dd239677f..f3d9a89a5 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListSum.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncListSum.scala @@ -16,11 +16,11 @@ limitations under the License. package com.twitter.algebird.util.summer import com.twitter.algebird._ -import com.twitter.util.{Duration, Future, FuturePool} +import com.twitter.util.{ Duration, Future, FuturePool } import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.atomic.AtomicInteger import scala.collection.JavaConverters._ -import scala.collection.mutable.{Set => MSet, ListBuffer} +import scala.collection.mutable.{ Set => MSet, ListBuffer } import scala.collection.breakOut /** @@ -28,16 +28,15 @@ import scala.collection.breakOut */ class AsyncListSum[Key, Value](bufferSize: BufferSize, - override val flushFrequency: FlushFrequency, - override val softMemoryFlush: MemoryFlushPercent, - workPool: FuturePool) - (implicit sg: Semigroup[Value]) - extends AsyncSummer[(Key, Value), Map[Key, Value]] - with WithFlushConditions[(Key, Value), Map[Key, Value]] { + override val flushFrequency: FlushFrequency, + override val softMemoryFlush: MemoryFlushPercent, + workPool: FuturePool)(implicit sg: Semigroup[Value]) + extends AsyncSummer[(Key, Value), Map[Key, Value]] + with WithFlushConditions[(Key, Value), Map[Key, Value]] { require(bufferSize.v > 0, "Use the Null summer for an empty async summer") - private case class MapContainer (privBuf: List[Value], size: Int) { + private case class MapContainer(privBuf: List[Value], size: Int) { def this(v: Value) = this(List[Value](v), 1) def addValue(v: Value): MapContainer = new MapContainer(v :: privBuf, size + 1) @@ -50,7 +49,6 @@ class AsyncListSum[Key, Value](bufferSize: BufferSize, lazy val toSeq = privBuf.reverse } - protected override val emptyResult = Map.empty[Key, Value] private[this] final val queueMap = new ConcurrentHashMap[Key, MapContainer](bufferSize.v) private[this] final val elementsInCache = new AtomicInteger(0) @@ -68,11 +66,10 @@ class AsyncListSum[Key, Value](bufferSize: BufferSize, keys.flatMap { k => val retV = queueMap.remove(k) - if(retV != null) { + if (retV != null) { val newRemaining = elementsInCache.addAndGet(retV.size * -1) sg.sumOption(retV.toSeq).map(v => (k, v)) - } - else None + } else None }(breakOut) } @@ -80,7 +77,7 @@ class AsyncListSum[Key, Value](bufferSize: BufferSize, private[this] final def doInsert(key: Key, value: Value) { val success = if (queueMap.containsKey(key)) { val oldValue = queueMap.get(key) - if(oldValue != null) { + if (oldValue != null) { queueMap.replace(key, oldValue, oldValue.addValue(value)) } else { false // Removed between the check above and fetching @@ -90,7 +87,7 @@ class AsyncListSum[Key, Value](bufferSize: BufferSize, queueMap.putIfAbsent(key, new MapContainer(value)) == null } - if(success) { + if (success) { // Successful insert elementsInCache.addAndGet(1) } else { @@ -99,11 +96,12 @@ class AsyncListSum[Key, Value](bufferSize: BufferSize, } def addAll(vals: TraversableOnce[(Key, Value)]): Future[Map[Key, Value]] = { - vals.foreach { case (k, v) => - doInsert(k, v) + vals.foreach { + case (k, v) => + doInsert(k, v) } - if(elementsInCache.get >= bufferSize.v) { + if (elementsInCache.get >= bufferSize.v) { flush } else { Future.value(Map.empty) diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncMapSum.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncMapSum.scala index a532d6c30..fdaa3f28e 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncMapSum.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncMapSum.scala @@ -16,7 +16,7 @@ limitations under the License. package com.twitter.algebird.util.summer import com.twitter.algebird._ -import com.twitter.util.{Duration, Future, FuturePool} +import com.twitter.util.{ Duration, Future, FuturePool } import java.util.concurrent.ArrayBlockingQueue import scala.collection.mutable.ArrayBuffer import scala.collection.JavaConverters._ @@ -26,12 +26,11 @@ import scala.collection.JavaConverters._ */ class AsyncMapSum[Key, Value](bufferSize: BufferSize, - override val flushFrequency: FlushFrequency, - override val softMemoryFlush: MemoryFlushPercent, - workPool: FuturePool) - (implicit semigroup: Semigroup[Value]) - extends AsyncSummer[(Key, Value), Map[Key, Value]] - with WithFlushConditions[(Key, Value), Map[Key, Value]] { + override val flushFrequency: FlushFrequency, + override val softMemoryFlush: MemoryFlushPercent, + workPool: FuturePool)(implicit semigroup: Semigroup[Value]) + extends AsyncSummer[(Key, Value), Map[Key, Value]] + with WithFlushConditions[(Key, Value), Map[Key, Value]] { require(bufferSize.v > 0, "Use the Null summer for an empty async summer") @@ -51,12 +50,11 @@ class AsyncMapSum[Key, Value](bufferSize: BufferSize, def addAll(vals: TraversableOnce[(Key, Value)]): Future[Map[Key, Value]] = { val curData = Semigroup.sumOption(vals.map(Map(_))).getOrElse(Map.empty) - if(!queue.offer(curData)) { + if (!queue.offer(curData)) { flush.map { flushRes => Semigroup.plus(flushRes, curData) } - } - else { + } else { Future.value(Map.empty) } } diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncSummer.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncSummer.scala index 0fcbd70dc..67989a94e 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncSummer.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/AsyncSummer.scala @@ -16,13 +16,12 @@ limitations under the License. package com.twitter.algebird.util.summer import com.twitter.algebird._ -import com.twitter.util.{Duration, Future} +import com.twitter.util.{ Duration, Future } /** * @author Ian O Connell */ - trait AsyncSummer[T, M <: Iterable[T]] { self => def flush: Future[M] def tick: Future[M] @@ -52,17 +51,16 @@ trait AsyncSummerProxy[T, M <: Iterable[T]] extends AsyncSummer[T, M] { override def cleanup: Future[Unit] = self.cleanup } - private[summer] trait WithFlushConditions[T, M <: Iterable[T]] extends AsyncSummer[T, M] { - protected var lastDump:Long = System.currentTimeMillis + protected var lastDump: Long = System.currentTimeMillis protected def softMemoryFlush: MemoryFlushPercent protected def flushFrequency: FlushFrequency protected def emptyResult: M protected def timedOut = (System.currentTimeMillis - lastDump) >= flushFrequency.v.inMilliseconds - protected lazy val runtime = Runtime.getRuntime + protected lazy val runtime = Runtime.getRuntime - protected def didFlush {lastDump = System.currentTimeMillis} + protected def didFlush { lastDump = System.currentTimeMillis } protected def memoryWaterMark = { val used = ((runtime.totalMemory - runtime.freeMemory).toDouble * 100) / runtime.maxMemory @@ -71,9 +69,8 @@ private[summer] trait WithFlushConditions[T, M <: Iterable[T]] extends AsyncSumm def tick: Future[M] = { if (timedOut || memoryWaterMark) { - flush - } - else { + flush + } else { Future.value(emptyResult) } } diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/MemoryFlushPercent.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/MemoryFlushPercent.scala index 2c06c795b..8d740ca5b 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/MemoryFlushPercent.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/MemoryFlushPercent.scala @@ -15,7 +15,6 @@ limitations under the License. */ package com.twitter.algebird.util.summer - /** * @author Ian O Connell */ diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/NullSummer.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/NullSummer.scala index 14e230cdc..eed5896e3 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/NullSummer.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/NullSummer.scala @@ -23,7 +23,7 @@ import com.twitter.util.Future */ class NullSummer[Key, Value](implicit semigroup: Semigroup[Value]) - extends AsyncSummer[(Key, Value), Map[Key, Value]] { + extends AsyncSummer[(Key, Value), Map[Key, Value]] { def flush: Future[Map[Key, Value]] = Future.value(Map.empty) def tick: Future[Map[Key, Value]] = Future.value(Map.empty) def addAll(vals: TraversableOnce[(Key, Value)]): Future[Map[Key, Value]] = diff --git a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/SyncSummingQueue.scala b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/SyncSummingQueue.scala index 6e57aa1e5..3854d7a28 100644 --- a/algebird-util/src/main/scala/com/twitter/algebird/util/summer/SyncSummingQueue.scala +++ b/algebird-util/src/main/scala/com/twitter/algebird/util/summer/SyncSummingQueue.scala @@ -17,16 +17,15 @@ package com.twitter.algebird.util.summer import com.twitter.algebird._ import com.twitter.util.Future -import com.twitter.util.{Duration, Future} +import com.twitter.util.{ Duration, Future } /** * @author Ian O Connell */ case class SyncSummingQueue[Key, Value](bufferSize: BufferSize, - override val flushFrequency: FlushFrequency, - override val softMemoryFlush: MemoryFlushPercent) - (implicit semigroup: Semigroup[Value]) extends AsyncSummer[(Key, Value), Map[Key, Value]] with WithFlushConditions[(Key, Value), Map[Key, Value]] { + override val flushFrequency: FlushFrequency, + override val softMemoryFlush: MemoryFlushPercent)(implicit semigroup: Semigroup[Value]) extends AsyncSummer[(Key, Value), Map[Key, Value]] with WithFlushConditions[(Key, Value), Map[Key, Value]] { require(bufferSize.v > 0, "Use the Null summer for an empty async summer") protected override val emptyResult = Map.empty[Key, Value] diff --git a/project/Build.scala b/project/Build.scala index 2223652f9..5c019a775 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -4,6 +4,8 @@ import sbt._ import Keys._ import com.typesafe.tools.mima.plugin.MimaPlugin.mimaDefaultSettings import com.typesafe.tools.mima.plugin.MimaKeys.previousArtifact +import scalariform.formatter.preferences._ +import com.typesafe.sbt.SbtScalariform._ object AlgebirdBuild extends Build { def withCross(dep: ModuleID) = @@ -18,10 +20,11 @@ object AlgebirdBuild extends Build { case version if version startsWith "2.10" => "org.specs2" %% "specs2" % "1.13" % "test" } - val sharedSettings = Project.defaultSettings ++ Seq( + val sharedSettings = Project.defaultSettings ++ scalariformSettings ++ Seq( organization := "com.twitter", scalaVersion := "2.9.3", crossScalaVersions := Seq("2.9.3", "2.10.0"), + ScalariformKeys.preferences := formattingPreferences, resolvers ++= Seq( "snapshots" at "http://oss.sonatype.org/content/repositories/snapshots", @@ -82,6 +85,14 @@ object AlgebirdBuild extends Build { ) ) ++ mimaDefaultSettings + + lazy val formattingPreferences = { + import scalariform.formatter.preferences._ + FormattingPreferences(). + setPreference(AlignParameters, false). + setPreference(PreserveSpaceBeforeArguments, true) + } + /** * This returns the youngest jar we released that is compatible with * the current. @@ -154,3 +165,5 @@ object AlgebirdBuild extends Build { libraryDependencies += "com.twitter" %% "bijection-core" % "0.6.2" ).dependsOn(algebirdCore, algebirdTest % "test->compile") } + + diff --git a/project/plugins.sbt b/project/plugins.sbt index a97c98c69..dfc6f2073 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -6,3 +6,5 @@ resolvers ++= Seq( addSbtPlugin("com.typesafe.sbt" % "sbt-ghpages" % "0.5.2") addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.6") + +addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.3.0") \ No newline at end of file