scala's spire framework : I am unable to operate on a group

Question

I try to use spire, a math framework, but I have an error message:

import spire.algebra._
import spire.implicits._

trait AbGroup[A] extends Group[A]

final class Rationnel_Quadratique(val n1: Int = 2)(val coef: (Int, Int)) {
  override def toString = {
    coef match {
        case (c, i) =>
            s"$c + $i√$n"
    }
  }

  def a() = coef._1

  def b() = coef._2

  def n() = n1


} 

object Rationnel_Quadratique {

  def apply(coef: (Int, Int),n: Int = 2)= {
    new Rationnel_Quadratique(n)(coef)
  }

}

object AbGroup {

  implicit object RQAbGroup extends AbGroup[Rationnel_Quadratique] {

    def +(a: Rationnel_Quadratique, b: Rationnel_Quadratique): Rationnel_Quadratique = Rationnel_Quadratique(coef=(a.a() + b.a(), a.b() + b.b()))

    def inverse(a: Rationnel_Quadratique): Rationnel_Quadratique = Rationnel_Quadratique((-a.a(), -a.b()))

    def id: Rationnel_Quadratique = Rationnel_Quadratique((0, 0))
  }

} 


object euler66_2 extends App {

  val c = Rationnel_Quadratique((1, 2))
  val d = Rationnel_Quadratique((3, 4))
  val e = c + d
  println(e)

}

the program is expected to add 1+2√2 and 3+4√2, but instead I have this error:

could not find implicit value for evidence parameter of type spire.algebra.AdditiveSemigroup[Rationnel_Quadratique] val e = c + d ^

I think there is something essential I have missed (usage of implicits?)

Answer 1

It looks like you are not using Spire correctly.

Spire already has an AbGroup type, so you should be using that instead of redefining your own. Here's an example using a simple type I created called X.

import spire.implicits._
import spire.algebra._

case class X(n: BigInt)

object X {
  implicit object XAbGroup extends AbGroup[X] {
    def id: X = X(BigInt(0))
    def op(lhs: X, rhs: X): X = X(lhs.n + rhs.n)
    def inverse(lhs: X): X = X(-lhs.n)
  }
}

def test(a: X, b: X): X = a |+| b

Note that with groups (as well as semigroups and monoids) you'd use |+| rather than +. To get plus, you'll want to define something with an AdditiveSemigroup (e.g. Semiring, or Ring, or Field or something).

You'll also use .inverse and |-| instead of unary and binary - if that makes sense.

Looking at your code, I am also not sure your actual number type is right. What will happen if I want to add two numbers with different values for n?

Anyway, hope this clears things up for you a bit.

EDIT: Since it seems like you're also getting hung up on Scala syntax, let me try to sketch a few designs that might work. First, there's always a more general solution:

import spire.implicits._
import spire.algebra._
import spire.math._

case class RQ(m: Map[Natural, SafeLong]) {
  override def toString: String = m.map {
    case (k, v) => if (k == 1) s"$v" else s"$v√$k" }.mkString(" + ")
}

object RQ {
  implicit def abgroup[R <: Radical](implicit r: R): AbGroup[RQ] =
    new AbGroup[RQ] {
      def id: RQ = RQ(Map.empty)
      def op(lhs: RQ, rhs: RQ): RQ = RQ(lhs.m + rhs.m)
      def inverse(lhs: RQ): RQ = RQ(-lhs.m)
    }
}

object Test {
  def main(args: Array[String]) {
    implicit val radical = _2
    val x = RQ(Map(Natural(1) -> 1, Natural(2) -> 2))
    val y = RQ(Map(Natural(1) -> 3, Natural(2) -> 4))
    println(x)
    println(y)
    println(x |+| y)
  }
}

This allows you to add different roots together without problem, at the cost of some indirection. You could also stick more closely to your design with something like this:

import spire.implicits._
import spire.algebra._

abstract class Radical(val n: Int) { override def toString: String = n.toString }
case object _2 extends Radical(2)
case object _3 extends Radical(3)

case class RQ[R <: Radical](a: Int, b: Int)(implicit r: R) {
  override def toString: String = s"$a + $b√$r"
}

object RQ {
  implicit def abgroup[R <: Radical](implicit r: R): AbGroup[RQ[R]] =
    new AbGroup[RQ[R]] {
      def id: RQ[R] = RQ[R](0, 0)
      def op(lhs: RQ[R], rhs: RQ[R]): RQ[R] = RQ[R](lhs.a + rhs.a, lhs.b + rhs.b)
      def inverse(lhs: RQ[R]): RQ[R] = RQ[R](-lhs.a, -lhs.b)
    }
}

object Test {
  def main(args: Array[String]) {
    implicit val radical = _2
    val x = RQ[_2.type](1, 2)
    val y = RQ[_2.type](3, 4)
    println(x)
    println(y)
    println(x |+| y)
  }
}

This approach creates a fake type to represent whatever radical you are using (e.g. √2) and parameterizes QR on that type. This way you can be sure that no one will try to do additions that are invalid.

Hopefully one of these approaches will work for you.