typelevel/spire

This release significantly expands Spire's mathematical and algebraic foundations, introducing new type classes for vector spaces, actions, and partial structures, alongside robust support for fixed-point arithmetic and interval sets. The library now features a comprehensive random number generation API with multiple algorithms and distributions, while macro-based compile-time checks for arithmetic overflow and numeric literal parsing enhance safety and performance. Additionally, the update brings full Scala 3 compatibility with native platform support, alongside a major reorganization of syntax imports and typeclass instances for a cleaner developer experience.

The spire-extras module now includes a new FixedPoint value class that provides fixed-point arithmetic operations using an implicit denominator. This allows users to perform precise decimal-like calculations using unboxed Long values, with support for addition, subtraction, multiplication, division, and comparison operations, as well as overflow handling.

extras/src/main/scala/spire/math · high confidence

A new \Checked\ macro implementation for Scala 3 has been added to the \macros\ module. This introduces compile-time overflow detection for \Int\ and \Long\ operations, allowing users to safely perform arithmetic with explicit overflow handling via \checked\, \option\, and \tryOrElse\ methods.

macros/src/main/scala-3 · high confidence

New Scala 3-specific macro implementations have been added for the \cfor\ loop construct and various literal parsing utilities. The \cforMacros.scala\ file introduces a macro that generates optimized \while\ loops for integer and long ranges, including support for \to\, \to by\, and \until\ ranges, with a fallback to \foreach\ for non-optimizable cases. The \literalMacros.scala\ file adds macros for parsing byte, short, uint, ulong, rational, and SI/US-formatted integer literals, enabling compile-time validation and optimization of these literal values in Scala 3.

core/src/main/scala-3/spire/syntax/macros · high confidence

New Scala 3-specific syntax files are introduced in the \core/src/main/scala-3/spire/syntax\ directory. This includes \CforSyntax\ providing \cfor\ and \cforRange\ macros, \Ops\ defining extension methods for algebraic types (such as \EqOps\, \OrderOps\, \SemigroupOps\), and \Syntax\ traits that wire these operations into the Spire namespace for Scala 3 users.

core/src/main/scala-3/spire/syntax · high confidence

A new Scala 3-specific implementation of the \PackMacros\ utility was added to \util/src/main/scala-3\. This file provides the Scala 3 equivalent of the existing Scala 2 macros, using Scala 3's \inline\ methods and compile-time evaluation to handle integer and long byte extraction, ensuring consistent behavior across Scala 2 and Scala 3 versions.

util/src/main/scala-3 · high confidence

A new Scala 3-specific file, StdSyntax.scala, is introduced to provide extension methods for Int, Long, Double, and BigInt, including operators for division, modulo, power, factorial, and combinations with SafeLong, Natural, ULong, and Number types. Additionally, array and sequence operations are exposed via ArraySyntax and SeqSyntax traits, enabling more idiomatic usage of these types in Scala 3.

core/src/main/scala-3/spire/syntax/std · high confidence

A new Scala 3-specific file, \core/src/main/scala-3/spire/optional/unicode.scala\, introduces a suite of Unicode operators and type aliases for Spire's algebraic structures. This includes type aliases for common mathematical sets (ℝ, ℚ, ℤ, ℕ, ℂ, ℍ) and constants (π, φ, e). It also provides extension methods on generic types \A\ to support Unicode symbols for logical, arithmetic, and set operations (e.g., \⊤\, \⊥\, \¬\, \√\, \∧\, \∨\, \∈\, \∩\), enabling more idiomatic mathematical notation in Scala 3 code.

core/src/main/scala-3/spire/optional · high confidence

Three new random number generators—XorShift1024Star, XorShift128Plus, and XorShift64Star—are added to the spire-extras package. These implementations provide additional options for generating random numbers, each with their own companion objects for seeding and serialization.

extras/src/main/scala/spire/random · high confidence

The examples subproject now includes three new datasets—auto-mpg, iris, and yeast—along with their corresponding metadata files (.names). To support these, a new \DataSets.scala\ module was added to load and parse the CSV data into structured \DataSet\ objects, and a \BigStreamCompat\ trait was introduced to provide Scala collection compatibility for \BigStream\. Additionally, a \ZigguratGenerator\ example was added to demonstrate random variable generation for statistical analysis.

examples/src/main/scala · high confidence

A new sealed trait \Cmp\ and its companion object are added to \core/src/main/scala/spire/macros/fpf/Cmp.scala\. This introduces five case objects (\Lt\, \Gt\, \LtEq\, \GtEq\, \Eq\) that represent comparison operations, likely to be used by macros for generating comparison logic.

core/src/main/scala/spire/macros · high confidence

The \spire.math.poly\ package now includes a type-class-based approach to finding polynomial roots, introducing \RootFinder\ and \RootIsolator\ traits with implementations for \BigDecimal\, \Real\, and \Number\ types. This includes the \BigDecimalRootRefinement\ class for refining root approximations and the \Roots\ trait for retrieving real roots. Additionally, the library now supports generating special polynomials such as Legendre, Laguerre, Chebyshev, and Hermite polynomials via the \SpecialPolynomials\ object, and provides dense (\PolyDense\) and sparse (\PolySparse\) polynomial representations.

core/src/main/scala/spire/math/poly · high confidence

A new example file, autoalgebra.scala, was added to the Scala 2 examples directory. It demonstrates how to use Spire's Auto macros to automatically generate type class instances for Java and Scala types, including arbitrary-precision numbers and Java collections, by mapping common operator conventions to Spire's algebraic structures.

examples/src/main/scala-2 · high confidence

Users can now construct free monoids, free groups, and free abelian groups to represent algebraic structures in a generic way. FreeMonoid provides a list-based monoid with optional semigroup reduction, FreeGroup supports group operations with term cancellation, and FreeAbGroup offers abelian group functionality with support for positive and negative terms, including methods to split and run computations over these structures.

core/src/main/scala/spire/algebra/free · high confidence

A new macro implementation for floating-point filters (Fuser) has been added to the spire macros library. This introduces a mechanism to optimize and fuse floating-point filter operations, likely improving performance by reducing intermediate allocations and enabling more efficient numerical computations within the library.

core/src/main/scala-2/spire/macros/fpf · high confidence

The spire-extras module now includes new data structures for handling sets of intervals. This change introduces the \IntervalSeq\ class, which provides efficient set operations (union, intersection, difference, etc.) on sorted sequences of interval boundaries, and the \IntervalTrie\ class, which offers a tree-based implementation of interval sets with support for various numeric types (Byte, Short, Int, Long, Float, Double, Char, and unsigned types). These additions expand the library's capabilities for working with ranges and intervals.

extras/src/main/scala/spire/math/extras · high confidence

The \spire.util\ package now includes \Opt\, a value class providing a \get\ method that throws \NoSuchElementException\ when empty, and \Pack\, an object offering big-endian byte conversion methods for \Int\ and \Long\ primitives.

util/src/main/scala · high confidence

The \spire.laws\ package now includes a full suite of ScalaCheck-based property tests for verifying algebraic structures. New files define law suites for groups (semigroups, monoids, abelian groups), rings (semirings, rings, GCD rings), lattices, orderings, and partial actions. These laws validate properties such as associativity, commutativity, identity elements, and distributive laws, ensuring that typeclass implementations in the \spire.algebra\ package correctly adhere to their mathematical specifications.

laws/src/main/scala/spire/laws · high confidence

The Spire library now provides compile-time overflow checking for integer operations via the new \Checked\ macro. Users can wrap expressions with \Checked.checked\ to throw an \ArithmeticOverflowException\ on overflow, use \Checked.option\ to return \None\ instead of throwing, or use \Checked.tryOrElse\/\tryOrReturn\ to provide fallback values or return statements. This adds a new safety mechanism for detecting integer overflows at compile time.

macros/src/main/scala-2/spire/macros · high confidence

The Spire library now includes new macro implementations for automatic derivation of algebraic type classes (such as Semiring, Rig, Rng, Ring, EuclideanRing, and Field) for both Scala and Java types, as well as compile-time parsing of numeric literals in various formats (SI, US, EU, and radix). This enables more efficient numeric operations and flexible literal handling at compile time.

core/src/main/scala-2/spire/macros · high confidence

The benchmark module has been significantly expanded with new test cases to measure performance across various mathematical operations. New benchmarks have been added for Fibonacci calculations, GCD algorithms, array ordering, and polynomial arithmetic. The suite also includes comparisons of different rational number implementations (BigInt, Long, Natural) and complex number additions. Additionally, a Java-based Fibonacci benchmark was introduced to compare against the Scala implementation, and the existing Caliper-based benchmarks have been migrated to JMH.

benchmark · high confidence

Added several new files to the repository: .git-blame-ignore-revs to manage git blame history for formatting commits, .gitignore to exclude build artifacts and IDE files, .jvmopts for JVM memory settings, .scalafmt.conf for code formatting rules, and markdown files for AUTHORS, CHANGES, CONTRIBUTING, DESIGN, and README content. These changes provide essential project metadata, contributor attribution, and development guidelines for users and contributors.

(repo-wide) · high confidence

A new file, package.scala, is added to the Scala 3 source directory, introducing type aliases for scala.specialized, scala.annotation.tailrec, and scala.reflect.ClassTag, along with a val binding for ClassTag. It also introduces a NotGiven type alias that maps to scala.util.NotGiven, providing convenient access to these standard library types within the spire namespace for Scala 3.

core/src/main/scala-3/spire · high confidence

The \spire.laws.shadows\ package now includes a comprehensive set of law implementations for the \Shadow\ type, which pairs a primitive value with its 'shadow' counterpart. The diff introduces new traits and instances for \AdditiveCSemigroup\, \MultiplicativeCSemigroup\, \Eq\, \Involution\, \AdditiveCMonoid\, \PartialOrder\, \AdditiveAbGroup\, \Order\, \CSemiring\, \CRig\, \CRng\, \CRing\, \GCDRing\, \EuclideanRing\, \Signed\, and \TruncatedDivision\. These implementations ensure that the \Shadow\ type correctly adheres to the algebraic laws defined in \spire.algebra\, enabling property-based testing and verification for shadowed types.

laws/src/main/scala/spire/laws/shadows · high confidence

The Spire library now provides implicit syntax extensions for Int, Long, Double, and BigInt literals, enabling operations such as integer division (/\~), remainder (/%), power (pow/\\), factorial (!), and combination (choose) directly on these types. Additionally, syntax for Array, Seq, and IndexedSeq collections is introduced, allowing for more idiomatic functional-style operations on standard Scala collections.

core/src/main/scala-2/spire/syntax/std · high confidence

The \spire.random.rng\ package now includes a wider variety of pseudo-random number generators, adding implementations for BurtleRot, Cmwc5, DevPrng, Lcg32, Lcg64, Marsaglia32a6, MersenneTwister (32 and 64-bit), PCG-XSH-RR-64/32, SecureJava, Serial, SyncGenerator, Well1024a, and Well19937a/c. This provides users with more options for random number generation, including high-quality generators like Mersenne Twister and PCG, as well as access to system entropy sources and thread-safe wrappers.

core/src/main/scala/spire/random/rng · high confidence

Added a new \FpFilter\ abstraction that wraps exact numeric types (like \BigInt\, \Rational\, \BigDecimal\) to provide a \Double\-based approximation for faster computation of operations such as \abs\, \sqrt\, and comparisons. This allows users to perform hot-path calculations using floating-point approximations while retaining the ability to fall back to exact values when needed, improving performance for geometric and numerical algorithms.

core/src/main/scala-2/spire/syntax · high confidence

Added new numeric types including \Algebraic\ for exact algebraic numbers, \BitString\ for bit-level operations, and \FastComplex\ for high-performance complex number arithmetic. Additionally, a new \spire.compat\ package was introduced to provide Scala version compatibility helpers, such as \ScalaOrderingWrapperCompat\ and \BuilderCompat\.

core/src/main/scala/spire/math · high confidence

Adds new type classes for partial algebraic structures, including Semigroupoid, Groupoid, and PartialAction (Left, Right, and combined). These traits provide methods for partial operations and actions, allowing for optional or conditional algebraic behavior. The implementation includes default methods for identity checks and inverse operations, as well as implicit conversions from existing algebraic structures like Semigroup and Group to these new partial types.

core/src/main/scala/spire/algebra/partial · high confidence

Added a new \Platform.scala\ file for the Native target, providing a \TrieMap\ type alias and factory method that delegates to \mutable.Map\. This enables Spire to function on Native platforms by supplying the necessary collection abstractions.

platform/js-native · high confidence

A new \Ops\ trait has been added to the \spire.macros.machinist\ package, providing macro-based methods (\unop\, \binop\, \rbinop\, etc.) that rewrite implicit conversion trees to call methods directly on the implicit evidence, thereby avoiding the allocation of implicit instances at runtime.

macros/src/main/scala-2/spire/macros/machinist · high confidence

The \spire.syntax\ package now provides dedicated import objects for common Scala types, allowing users to import only the syntax they need rather than the entire \spire.syntax.\_\ namespace. Specifically, \spire.syntax.std\ exposes \int\, \long\, \double\, \bigInt\, \array\, and \seq\ as importable objects, each providing specific operations (e.g., \qsum\, \qsort\, \qsearch\) for those types. Additionally, \spire.syntax\ now includes \literals\ for numeric literal syntax and \cfor\ for loop syntax, enabling granular access to these features.

core/src/main/scala/spire/syntax · high confidence

Added new type classes and instances in the \spire.optional\ package, including a \Perm\ class representing permutations with group and action instances, a generic \Eq\ instance for all types, and several \PartialOrder\ implementations for \Interval\ (geometric, ranged, and subset-based), \Set\ (power set), and \Float\/\Double\ (total ordering). Additionally, partial groupoid and semigroupoid instances are provided for iterables, and trigonometric function instances are added for \Rational\.

core/src/main/scala/spire/optional · high confidence

The \spire.algebra\ package introduces a suite of new type classes to support advanced mathematical structures. These include \VectorSpace\, \InnerProductSpace\, and \NormedVectorSpace\ for linear algebra, alongside \LeftAction\, \RightAction\, and \Action\ for group actions. The update also adds \Torsor\ for affine-like structures, \MetricSpace\ for distance measurements, and \UniqueFactorizationDomain\ for prime factorization. Additionally, \Trig\ provides trigonometric and hyperbolic functions, while \IsReal\ and \Involution\ offer utilities for real-number properties and adjoint operations.

core/src/main/scala/spire/algebra · high confidence

Added a new \spire.math.prime\ package providing tools for prime factorization, primality testing, and generating prime numbers. This includes a \Factors\ type representing prime factorizations, a \Siever\ for generating primes via a segmented Sieve of Eratosthenes, and a \FactorHeap\ for managing prime factors. The package also exposes \isPrime\ for primality testing and \factor\ for integer factorization using the Pollard-Rho algorithm.

core/src/main/scala/spire/math/prime · high confidence

The \spire.random\ package has been restructured to introduce a new, more flexible random number generation API. This includes a new \Dist\ trait for representing probability distributions, with concrete implementations for \Gaussian\ (normal), \Exponential\, and \Uniform\ distributions. The \Generator\ class has been updated to work with these distributions, and a \Random\ monad-like structure is provided for composing random operations. Additionally, the Ziggurat algorithm is implemented for efficient generation of Gaussian and Exponential random variables.

core/src/main/scala/spire/random · high confidence

The Spire library now provides a unified entry point for all standard library typeclass instances and syntax. Users can import \spire.implicits.\\ to access all Spire typeclass instances (such as \Numeric\, \Ordering\, \PartialOrdering\, and \Equiv\) as well as all syntax extensions. This replaces the previous scattered or wildcard imports (e.g., \spire.algebra.\\, \spire.math.\_\) with a single, explicit import that ensures consistent priority-based resolution of implicit conversions and instances.

core/src/main/scala/spire · high confidence

The \spire.algebra.lattice\ package object now provides type aliases and companion objects for core lattice structures, including \Logic\, \Heyting\, \DeMorgan\, \Lattice\, \MeetSemilattice\, \JoinSemilattice\, \BoundedLattice\, \BoundedJoinSemilattice\, \BoundedMeetSemilattice\, and \MinMaxLattice\. This change simplifies imports and usage of these algebraic types within the Spire library.

core/src/main/scala/spire/algebra/lattice · high confidence

The \spire.NoImplicit\ type alias has been deprecated in favor of \spire.NotGiven\. Users relying on the \NoImplicit\ type will see a deprecation warning, as the new \NotGiven\ class provides the same functionality for ensuring a particular implicit does not exist, while \NoImplicit\ is marked as deprecated since version 0.18.0.

core/src/main/scala-2/spire · high confidence

The JVM-specific platform implementation now defines a \TrieMap\ type alias and a corresponding factory method that delegates to \scala.collection.concurrent.TrieMap\. This change provides a unified interface for concurrent map operations on the JVM, abstracting away the underlying Scala collection implementation.

platform/jvm · high confidence

The \spire.std\ package has been reorganized by moving type class instances for standard Scala and Java types into separate, dedicated files (e.g., \any.scala\, \array.scala\, \bigDecimal.scala\, \bigInt.scala\, \boolean.scala\, \byte.scala\, \char.scala\, \double.scala\, \float.scala\, \int.scala\, \iterable.scala\). This change groups related instances together, improving code structure and maintainability without altering the available functionality for users.

core/src/main/scala/spire/std · high confidence

Add FixedPoint property-based tests; Add sanity test for Spire's optional unicode module; Added FpFilterSuite tests for floating-point filtering; Added JVM-specific property-based tests for math operations; Added comprehensive test suites for algebraic and mathematical types; Added munit-based test suites for spire.util; Added new random number generator tests using MUnit; Added property-based tests for algebraic and interval types; Added property-based tests for checked arithmetic operations; Added property-based tests for prime number and factorization logic; Added test coverage for spire syntax features; Added tests for IntervalSeq and IntervalTrie; Added unit tests for Machinist macro operations.

The project's build configuration has been migrated to the sbt-typelevel plugin, which standardizes the build structure and simplifies the build.sbt file. This change updates the versions of key testing and utility libraries, including munit (1.0.0-M7), discipline-munit (2.0.0-M3), and algebra (2.9.0).

(dependencies) · high confidence

The project's build configuration has been migrated to use the sbt-typelevel plugin, which standardizes the build structure and includes plugins for Scala Native, unidoc, JMH benchmarks, and Scala.js. The SBT version has been updated to 1.9.8.

project · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 61 (+24.0)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 85 (-14.7)
• Architecture 69 → 100 (+31.0)
• Maturity 34 → 50 (+16.4)
• Readiness 30 → 67 (+37.4)
• Security 34 → 65 (+31.7)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 16 more

• Algebraic.roundPositive (cognitive 43) (core/src/main/scala/spire/math/Algebraic.scala)
• Algebraic.roundPositive (cyclomatic 23) (core/src/main/scala/spire/math/Algebraic.scala)
• BigDecimalRootRefinement.QIR (cognitive 23) (core/src/main/scala/spire/math/poly/BigDecimalRootRefinement.scala)
• BigDecimalRootRefinement.QIR (cognitive 39) (core/src/main/scala/spire/math/poly/BigDecimalRootRefinement.scala)
• BigDecimalRootRefinement.QIR (cyclomatic 18) (core/src/main/scala/spire/math/poly/BigDecimalRootRefinement.scala)
• BooleanBinaryOperator.op (cognitive 39) (extras/src/main/scala/spire/math/extras/interval/Tree.scala)
• BooleanBinaryOperator.op (cyclomatic 17) (extras/src/main/scala/spire/math/extras/interval/Tree.scala)
• Checked.checkedImpl (cognitive 78) (macros/src/main/scala-3/spire/macros/Checked.scala)
• Checked.checkedImpl (cyclomatic 42) (macros/src/main/scala-3/spire/macros/Checked.scala)
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Dormant codebase
• Duplicated block (10 lines × 2) (util/src/main/scala-2/spire/util/PackMacros.scala)
• Duplicated block (11 lines × 2) (core/src/main/scala/spire/math/Rational.scala)
• Duplicated block (11 lines × 2) (core/src/main/scala/spire/optional/partialIterable.scala)
• Duplicated block (12 lines × 2) (core/src/main/scala/spire/math/Searching.scala)
• Duplicated block (12–14 lines × 2) (core/src/main/scala/spire/random/rng/Utils.scala)
• Duplicated block (13 lines × 2) (core/src/main/scala/spire/math/Merging.scala)
• Duplicated block (17 lines × 2) (extras/src/main/scala/spire/math/extras/interval/IntervalSeq.scala)
• Duplicated block (22 lines × 2) (core/src/main/scala/spire/random/rng/Utils.scala)
• …and 164 more

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• repository

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

typelevel/spire was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.