scala 的 spire 框架 : I am unable to operate on a group

Question

我尝试使用 spire，一种数学框架，但出现错误消息:

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)

}

程序本应加 1+2√2 和 3+4√2，但我却出现了这个错误:

找不到类型为 spire.algebra.AdditiveSemigroup[Rationnel_Quadratique] 的证据参数的隐式值 值(value) e = c + d ^

我认为我错过了一些重要的东西(隐式的使用？)

Answer 1

看来您没有正确使用 Spire。

Spire 已经有一个 AbGroup 类型，所以你应该使用它而不是重新定义你自己的。下面是一个使用我创建的名为 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

请注意，对于群(以及半群和幺半群)，您将使用 |+| 而不是 +。要获得加号，您需要使用 AdditiveSemigroup(例如 Semiring、Ring 或 Field 来定义一些东西> 或其他东西)。

如果有意义的话，您还将使用 .inverse 和 |-| 而不是一元和二进制 -。

查看您的代码，我也不确定您的实际数字类型是否正确。如果我想将两个具有不同 n 值的数字相加会怎样？

无论如何，希望这能为您解决一些问题。

编辑:由于您似乎也对 Scala 语法着迷，所以让我尝试勾勒出一些可能有效的设计。首先，总有一个更通用的解决方案:

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)
  }
}

这允许您毫无问题地将不同的根添加在一起，但代价是一些间接性。您还可以通过以下方式更贴近您的设计:

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)
  }
}

此方法会创建一个假类型来表示您正在使用的任何部首(例如√2)并在该类型上参数化 QR。这样您就可以确保没有人会尝试进行无效的添加。

希望其中一种方法对您有用。