made multiplication/addition symmetric

src/main/scala/numeric/Abelian.scala

@@ -1,8 +1,8 @@
 package numeric
 
-class Abelian { 
-  trait Magma[@specialized A] extends numeric.Magma[A] { 
-    override def dual: Magma[A] = new Magma.Dual[A] {  
+class Abelian {
+  trait Magma[@specialized A] extends numeric.Magma[A] {
+    override def dual: Magma[A] = new Magma.Dual[A] {
       override def dual: Magma[A] = Magma.this
     }
     def *[B](that: Magma[B]) = new Magma.Product[A,B] {
@@ -31,8 +31,8 @@ class Abelian {
   }
 
 
-  trait Semigroup[@specialized A] extends numeric.Semigroup[A] with Magma[A] { 
-    override def dual: Semigroup[A] = new Semigroup.Dual[A] {  
+  trait Semigroup[@specialized A] extends numeric.Semigroup[A] with Magma[A] {
+    override def dual: Semigroup[A] = new Semigroup.Dual[A] {
       override def dual: Semigroup[A] = Semigroup.this
     }
     def *[B](that: Semigroup[B]) = new Semigroup.Product[A,B] {
@@ -61,8 +61,8 @@ class Abelian {
   }
 
 
-  trait Monoid[@specialized A] extends numeric.Monoid[A] with Semigroup[A] { 
-    override def dual: Monoid[A] = new Monoid.Dual[A] {  
+  trait Monoid[@specialized A] extends numeric.Monoid[A] with Semigroup[A] {
+    override def dual: Monoid[A] = new Monoid.Dual[A] {
       override def dual: Monoid[A] = Monoid.this
     }
     def *[B](that: Monoid[B]) = new Monoid.Product[A,B] {
@@ -91,8 +91,8 @@ class Abelian {
     }
   }
 
-  trait Quasigroup[@specialized A] extends numeric.Quasigroup[A] with Magma[A] { 
-    override def dual: Quasigroup[A] = new Quasigroup.Dual[A] {  
+  trait Quasigroup[@specialized A] extends numeric.Quasigroup[A] with Magma[A] {
+    override def dual: Quasigroup[A] = new Quasigroup.Dual[A] {
       override def dual: Quasigroup[A] = Quasigroup.this
     }
     def *[B](that: Quasigroup[B]) = new Quasigroup.Product[A,B] {
@@ -122,8 +122,8 @@ class Abelian {
     }
   }
 
-  trait Loop[@specialized A] extends numeric.Loop[A] with Quasigroup[A] { 
-    override def dual: Loop[A] = new Loop.Dual[A] {  
+  trait Loop[@specialized A] extends numeric.Loop[A] with Quasigroup[A] {
+    override def dual: Loop[A] = new Loop.Dual[A] {
       override def dual: Loop[A] = Loop.this
     }
     def *[B](that: Loop[B]) = new Loop.Product[A,B] {
@@ -154,8 +154,8 @@ class Abelian {
     }
   }
 
-  trait Group[@specialized A] extends numeric.Group[A] with Loop[A] with Monoid[A] { 
-    override def dual: Group[A] = new Group.Dual[A] {  
+  trait Group[@specialized A] extends numeric.Group[A] with Loop[A] with Monoid[A] {
+    override def dual: Group[A] = new Group.Dual[A] {
       override def dual: Group[A] = Group.this
     }
     def *[B](that: Group[B]) = new Group.Product[A,B] {

src/main/scala/numeric/Group.scala

@@ -1,27 +1,27 @@
 package numeric
 
 trait Group[@specialized A] extends Loop[A] with Monoid[A] {
-  def inverse(a: A): A 
+  def inverse(a: A): A
   def over(a: A, b: A): A = this(a, inverse(b))
   def under(a: A, b: A): A = this(inverse(a), b)
-  override def dual: Group[A] = new Group.Dual[A] {  
+  override def dual: Group[A] = new Group.Dual[A] {
     override def dual: Group[A] = Group.this
   }
   def *[B](that: Group[B]) = new Group.Product[A,B] {
     def _1: Group[A] = Group.this
     def _2: Group[B] = that
   }
-  implicit override def ops(a: A): Group.Ops[A] = new Group.Ops[A] {
+  implicit override def multiplication(a: A): Group.Multiplication[A] = new Group.Multiplication[A] {
     def lhs: A = a
     def numeric: Group[A] = Group.this
   }
-  override def additive(a: A): Group.AdditiveOps[A] = new Group.AdditiveOps[A] {
+  override def addition(a: A): Group.Addition[A] = new Group.Addition[A] {
     def lhs: A = a
     def numeric: Group[A] = Group.this
   }
 }
 
-object Group { 
+object Group {
   def apply[A](
     f:(A,A) => A,
     inv: A => A,
@@ -31,11 +31,11 @@ object Group {
     def inverse(a: A) = inv(a)
     def e: A = id
   }
-  trait Ops[@specialized A] extends Loop.Ops[A] {
+  trait Multiplication[@specialized A] extends Loop.Multiplication[A] {
     protected def numeric: Group[A]
     def inverse: A = numeric.inverse(lhs)
   }
-  trait AdditiveOps[@specialized A] extends Magma.AdditiveOps[A] { 
+  trait Addition[@specialized A] extends Loop.Addition[A] {
     protected def numeric: Group[A]
     def unary_-(): A = numeric.inverse(lhs)
     def negate: A = numeric.inverse(lhs)

src/main/scala/numeric/Loop.scala

@@ -5,26 +5,30 @@ package numeric
  */
 
 trait Loop[@specialized A] extends Unital[A] with Quasigroup[A] {
-  def left_inverse(x: A): A = over(e,x)
-  def right_inverse(x: A): A = under(x,e)
-  override def dual: Loop[A] = new Loop.Dual[A] {  
+  def leftInverse(x: A): A = over(e,x)
+  def rightInverse(x: A): A = under(x,e)
+  override def dual: Loop[A] = new Loop.Dual[A] {
     override def dual: Loop[A] = Loop.this
   }
   def *[B](that: Loop[B]) = new Loop.Product[A,B] {
     def _1: Loop[A] = Loop.this
     def _2: Loop[B] = that
   }
-  implicit override def ops(a: A): Loop.Ops[A] = new Loop.Ops[A] { 
+  implicit override def multiplication(a: A): Loop.Multiplication[A] = new Loop.Multiplication[A] {
+    def lhs: A = a
+    def numeric: Loop[A] = Loop.this
+  }
+  implicit override def addition(a: A): Loop.Addition[A] = new Loop.Addition[A] {
     def lhs: A = a
     def numeric: Loop[A] = Loop.this
   }
 }
 
 
-object Loop { 
+object Loop {
   def apply[A](
     f:(A,A) => A,
-    o:(A,A) => A, 
+    o:(A,A) => A,
     u:(A,A) => A,
     id: A
   ) : Loop[A] = new Loop[A] {
@@ -34,10 +38,15 @@ object Loop {
     def e: A = id
   }
   trait Dual[@specialized A] extends Quasigroup.Dual[A] with Unital.Dual[A] with Loop[A]
-  trait Ops[@specialized A] extends Quasigroup.Ops[A] {
+  trait Multiplication[@specialized A] extends Quasigroup.Multiplication[A] {
+    protected def numeric: Loop[A]
+    def leftInverse: A = numeric.leftInverse(lhs)
+    def rightInverse: A = numeric.rightInverse(lhs)
+  }
+  trait Addition[@specialized A] extends Quasigroup.Addition[A] {
     protected def numeric: Loop[A]
-    def leftInverse: A = numeric.left_inverse(lhs)
-    def rightInverse: A = numeric.right_inverse(lhs)
+    def leftNegation: A = numeric.leftInverse(lhs)
+    def rightNegation: A = numeric.rightInverse(lhs)
   }
   trait Product[A,B] extends Quasigroup.Product[A,B] with Unital.Product[A,B] with Loop[(A,B)] {
     def _1: Loop[A]

src/main/scala/numeric/Magma.scala

@@ -2,38 +2,38 @@ package numeric
 
 trait Magma[@specialized A] {
   def apply(a: A, b: A): A
-  def dual: Magma[A] = new Magma.Dual[A] {  
+  def dual: Magma[A] = new Magma.Dual[A] {
     override def dual: Magma[A] = Magma.this
   }
   def *[B](that: Magma[B]) = new Magma.Product[A,B] {
     def _1: Magma[A] = Magma.this
     def _2: Magma[B] = that
   }
-  implicit def ops(a: A): Magma.Ops[A] = new Magma.Ops[A] {
+  implicit def multiplication(a: A): Magma.Multiplication[A] = new Magma.Multiplication[A] {
     def lhs: A = a
     def numeric: Magma[A] = Magma.this
   }
-  def additive(a: A): Magma.AdditiveOps[A] = new Magma.AdditiveOps[A] {
+  def addition(a: A): Magma.Addition[A] = new Magma.Addition[A] {
     def lhs: A = a
     def numeric: Magma[A] = Magma.this
   }
 }
 
-object Magma { 
+object Magma {
   def apply[A](f:(A,A) => A) : Magma[A] = new Magma[A] {
     def apply(a: A, b: A): A = f(a,b)
   }
-  trait Ops[@specialized A] { 
+  trait Multiplication[@specialized A] {
     protected def lhs: A
     protected def numeric: Magma[A]
     def *(rhs: A): A = numeric(lhs,rhs)
   }
-  trait AdditiveOps[@specialized A] { 
+  trait Addition[@specialized A] {
     protected def lhs: A
     protected def numeric: Magma[A]
     def +(rhs: A): A = numeric(lhs,rhs)
   }
-  trait Dual[@specialized A] extends Magma[A] { 
+  trait Dual[@specialized A] extends Magma[A] {
     def apply(a: A, b: A) = dual(b,a)
   }
   trait Product[A,B] extends Magma[(A,B)] {

src/main/scala/numeric/Monoid.scala

@@ -5,7 +5,7 @@ package numeric
  */
 
 trait Monoid[@specialized A] extends Unital[A] with Semigroup[A] {
-  override def dual: Monoid[A] = new Monoid.Dual[A] {  
+  override def dual: Monoid[A] = new Monoid.Dual[A] {
     override def dual: Monoid[A] = Monoid.this
   }
   def *[B](that: Monoid[B]) = new Monoid.Product[A,B] {
@@ -14,9 +14,9 @@ trait Monoid[@specialized A] extends Unital[A] with Semigroup[A] {
   }
 }
 
-object Monoid { 
+object Monoid {
   def apply[A](
-    f:(A,A) => A,
+    f: (A,A) => A,
     id: A
   ) : Monoid[A] = new Monoid[A] {
     def apply(a: A, b: A): A = f(a,b)

src/main/scala/numeric/Quasigroup.scala

@@ -22,17 +22,21 @@ trait Quasigroup[@specialized A] extends Magma[A] {
     def _1: Quasigroup[A] = Quasigroup.this
     def _2: Quasigroup[B] = that
   }
-  implicit override def ops(a: A): Quasigroup.Ops[A] = new Quasigroup.Ops[A] { 
+  implicit override def multiplication(a: A): Quasigroup.Multiplication[A] = new Quasigroup.Multiplication[A] { 
+    def lhs: A = a
+    def numeric: Quasigroup[A] = Quasigroup.this
+  }
+  override def addition(a: A): Quasigroup.Addition[A] = new Quasigroup.Addition[A] { 
     def lhs: A = a
     def numeric: Quasigroup[A] = Quasigroup.this
   }
 }
 
 object Quasigroup { 
   def apply[A](
-    f:(A,A) => A,
-    o:(A,A) => A,
-    u:(A,A) => A
+    f: (A,A) => A,
+    o: (A,A) => A,
+    u: (A,A) => A
   ) : Quasigroup[A] = new Quasigroup[A] {
     def apply(a: A, b: A): A = f(a,b)
     def over(a: A, b: A): A = o(a,b)
@@ -43,11 +47,16 @@ object Quasigroup {
     def over(a: A, b: A): A = dual.over(b,a)
     def under(a: A, b: A): A = dual.under(b,a)
   }
-  trait Ops[@specialized A] extends Magma.Ops[A] {
+  trait Multiplication[@specialized A] extends Magma.Multiplication[A] {
     protected def numeric: Quasigroup[A]
     def /(rhs: A): A = numeric.over(lhs,rhs)
     def \(rhs: A): A = numeric.under(lhs,rhs)
   }
+  trait Addition[@specialized A] extends Magma.Addition[A] {
+    protected def numeric: Quasigroup[A]
+    def -(rhs: A): A = numeric.over(lhs,rhs)
+    def subtract(rhs: A): A = numeric.under(lhs,rhs)
+  }
   trait Product[A,B] extends Magma.Product[A,B] with Quasigroup[(A,B)] {
     def _1: Quasigroup[A]
     def _2: Quasigroup[B]

src/main/scala/numeric/Rig.scala

@@ -5,13 +5,12 @@ trait Rig[@specialized A] extends Semiring[A] {
   def times: Monoid[A]
   def zero: A = plus.e
   def one: A = times.e
-  implicit override def ops(a: A) = times.ops(a) // no monoid ops
+  implicit override def multiplication(a: A) = times.multiplication(a) // no monoid ops
 }
 
 object Rig { 
-  def apply[A](addition: Abelian.Monoid[A], multiplication : Monoid[A]): Rig[A] = new Rig[A] {
-    def plus = addition
-    def times = multiplication
+  def apply[A](a: Abelian.Monoid[A], m: Monoid[A]): Rig[A] = new Rig[A] {
+    def plus = a
+    def times = m
   }
 }
-

src/main/scala/numeric/Ring.scala

@@ -4,14 +4,14 @@ trait Ring[@specialized A] extends Rig[A] {
   def plus: Abelian.Group[A]
   def minus(a: A, b: A): A = plus.over(a,b)
   def negate(a: A) = plus.inverse(a)
-  implicit override def ops(a: A) = times.ops(a)
-  implicit override def additiveOps(a: A) = plus.additive(a)
+  implicit override def multiplication(a: A) = times.multiplication(a)
+  implicit override def addition(a: A) = plus.addition(a)
 }
 
-object Ring { 
-  def apply[A](addition: Abelian.Group[A], multiplication : Monoid[A]): Ring[A] = new Ring[A] {
-    def plus = addition
-    def times = multiplication
+object Ring {
+  def apply[A](a: Abelian.Group[A], m: Monoid[A]): Ring[A] = new Ring[A] {
+    def plus = a
+    def times = m
   }
 }
 

src/main/scala/numeric/Ringoid.scala

@@ -1,16 +1,15 @@
 package numeric
 
-trait Ringoid[@specialized A] { 
+trait Ringoid[@specialized A] {
   def plus: Magma[A]
   def times: Magma[A]
-  implicit def ops(a: A) = times.ops(a)
-  implicit def additiveOps(a: A) = plus.additive(a)
+  implicit def multiplication(a: A) = times.multiplication(a)
+  implicit def addition(a: A) = plus.addition(a)
 }
 
-object Ringoid { 
-  def apply[A](addition: Magma[A], multiplication: Magma[A]): Ringoid[A] = new Ringoid[A] {
-    def plus = addition
-    def times = multiplication
+object Ringoid {
+  def apply[A](a: Magma[A], m: Magma[A]): Ringoid[A] = new Ringoid[A] {
+    def plus = a
+    def times = m
   }
 }
-

src/main/scala/numeric/Semigroup.scala

@@ -1,7 +1,7 @@
 package numeric
 
 trait Semigroup[@specialized A] extends Magma[A] {
-  override def dual: Semigroup[A] = new Semigroup.Dual[A] {  
+  override def dual: Semigroup[A] = new Semigroup.Dual[A] {
     override def dual: Semigroup[A] = Semigroup.this
   }
   def *[B](that: Semigroup[B]) = new Semigroup.Product[A,B] {
@@ -10,7 +10,7 @@ trait Semigroup[@specialized A] extends Magma[A] {
   }
 }
 
-object Semigroup { 
+object Semigroup {
   def apply[A](f:(A,A) => A) : Semigroup[A] = new Semigroup[A] {
     def apply(a: A, b: A): A = f(a,b)
   }

src/main/scala/numeric/Semiring.scala

@@ -1,15 +1,15 @@
 package numeric
 
-trait Semiring[@specialized A] extends Ringoid[A] { 
+trait Semiring[@specialized A] extends Ringoid[A] {
   def plus: Abelian.Semigroup[A]
   def times: Semigroup[A]
-  implicit override def ops(a: A) = times.ops(a) // no semigroup ops
+  implicit override def addition(a: A) = times.addition(a)
 }
 
-object Semiring { 
-  def apply[A](addition: Abelian.Semigroup[A], multiplication: Semigroup[A]): Semiring[A] = new Semiring[A] {
-    def plus = addition
-    def times = multiplication
+object Semiring {
+  def apply[A](a: Abelian.Semigroup[A], m: Semigroup[A]): Semiring[A] = new Semiring[A] {
+    def plus = a
+    def times = m
   }
 }