2

我尝试使用 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] val e = c + d ^ 类型的证据参数的隐含值

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

4

1 回答 1

9

看起来您没有正确使用 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或某物）来定义某些东西。

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

查看您的代码，我也不确定您的实际数字类型是否正确。如果我想将两个具有不同值的数字相加会发生什么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对该类型进行参数化。这样您就可以确保没有人会尝试进行无效的添加。

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

于 2013-10-03T15:58:33.840 回答