Update to algebra 2.7.0

build.sbt

@@ -20,7 +20,7 @@ lazy val scalaCheckVersion = "1.15.4"
 lazy val munit = "0.7.29"
 lazy val munitDiscipline = "1.0.9"
 
-lazy val algebraVersion = "2.2.3"
+lazy val algebraVersion = "2.7.0"
 
 lazy val apfloatVersion = "1.10.1"
 lazy val jscienceVersion = "4.3.1"

core/src/main/scala-2/spire/macros/Auto.scala

@@ -162,12 +162,12 @@ abstract class AutoAlgebra extends AutoOps { ops =>
   def EuclideanRing[A: c.WeakTypeTag](z: c.Expr[A], o: c.Expr[A])(ev: c.Expr[Eq[A]]): c.Expr[EuclideanRing[A]] = {
     c.universe.reify {
       new EuclideanRing[A] { self =>
-        // default implementations from EuclideanRing.WithEuclideanAlgorithm
+        // default implementations from EuclideanRing
         @tailrec final def euclid(a: A, b: A)(implicit ev: Eq[A]): A =
           if (isZero(b)) a else euclid(b, emod(a, b))
-        def gcd(a: A, b: A)(implicit ev: Eq[A]): A =
+        override def gcd(a: A, b: A)(implicit ev: Eq[A]): A =
           euclid(a, b)(ev)
-        def lcm(a: A, b: A)(implicit ev: Eq[A]): A =
+        override def lcm(a: A, b: A)(implicit ev: Eq[A]): A =
           if (isZero(a) || isZero(b)) zero else times(equot(a, gcd(a, b)), b)
 
         def zero: A = z.splice
@@ -186,7 +186,7 @@ abstract class AutoAlgebra extends AutoOps { ops =>
   def Field[A: c.WeakTypeTag](z: c.Expr[A], o: c.Expr[A])(ev: c.Expr[Eq[A]]): c.Expr[Field[A]] = {
     c.universe.reify {
       new Field[A] {
-        // default implementations from Field.WithDefaultGCD
+        // default implementations from Field
         override def gcd(a: A, b: A)(implicit eqA: Eq[A]): A =
           if (isZero(a) && isZero(b)) zero else one
         override def lcm(a: A, b: A)(implicit eqA: Eq[A]): A = times(a, b)

core/src/main/scala-3/spire/syntax/Ops.scala

@@ -83,7 +83,7 @@ final class SignedOps[A](a: A)(using s: Signed[A]):
   def isSignNonNegative: Boolean = s.isSignNonNegative(a)
 
 final class TruncatedDivisionOps[A](lhs: A)(using ev: TruncatedDivision[A]):
-  def toBigIntOpt: Opt[BigInt] = ev.toBigIntOpt(lhs)
+  // def toBigIntOpt: Opt[BigInt] = ev.toBigIntOpt(lhs) // TODO port to algebra?
   def tquot(rhs: A): A = ev.tquot(lhs, rhs)
   def tmod(rhs: A): A = ev.tmod(lhs, rhs)
   def tquotmod(rhs: A): (A, A) = ev.tquotmod(lhs, rhs)

core/src/main/scala/spire/algebra/Action.scala

@@ -100,3 +100,15 @@ trait MultiplicativeAction[@sp(Int) P, G] extends Any { self =>
   def gtimesl(g: G, p: P): P
   def gtimesr(p: P, g: G): P
 }
+
+object MultiplicativeAction {
+  implicit def SignAction[A](implicit A: AdditiveGroup[A]): MultiplicativeAction[A, Sign] =
+    new MultiplicativeAction[A, Sign] {
+      def gtimesl(s: Sign, a: A): A = s match {
+        case Signed.Positive => a
+        case Signed.Negative => A.negate(a)
+        case Signed.Zero     => A.zero
+      }
+      def gtimesr(a: A, s: Sign): A = gtimesl(s, a)
+    }
+}

core/src/main/scala/spire/algebra/IsReal.scala

@@ -21,7 +21,7 @@ import spire.math.{Algebraic, Rational, Real}
 /**
  * A simple type class for numeric types that are a subset of the reals.
  */
-trait IsReal[@sp A] extends Any with Signed[A] {
+trait IsReal[@sp A] extends Any with Order[A] with Signed[A] {
 
   /**
    * Rounds `a` the nearest integer that is greater than or equal to `a`.