Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
Basic overview of open issues for bug bash participants. Doesn't currently include links to issues, but every item should have a (tagged) open issue.

Bugs, Features, and Ideas for Future Work

Note that some exotic types and features may need to go into spire-contrib first to see how widely-used they are.

There is a obviously a balance between ultra-minimal and kitchen-sink approaches, although the math community seems to favor kitchen-sink. In general we are happy to accept new functionality provided that it seems to fit into the overall pattern of what's already there.


These are relatively simple, self-contained tasks. They are relatively straightforward and shouldn't require a lot of overall context to get right. Mostly they relate to plugging small gaps or oversights, or just improving the reader experience.

  1. Improving tests, port to property-based where possible
  2. Ensure Javadoc comments for all non-trivial (*) methods
  3. More sophisticated benchmarking examples
  4. Export Gen/Arbitrary ScalaCheck instances for Spire types
  5. Standardize methods/operators across number types
  6. Verify existing documentation (reading and executing)

Needs improvement

These are a bit subtle. They usually relate to problems with the existing design, or shortcomings, or missing pieces. These are a bit harder to take on unless you've used the types, or are willing to do a little bit of back and forth.

  1. Commutativity problems
  2. Characterize types in terms of precision/approximation
  3. Characterize types in terms of presumed vs actual associativity
  4. General support for infinite sequences, series
  5. Generalize, expand, and rationalize literal syntax macros
  6. Better and more uniform approximation contexts
  7. More work on non/algebra
  8. Either make FPFilter package private, or clean up and document it
  9. Look into ways to reduce allocations on SafeLong and Rational

Extending features

These issues are cases where we can extend an existing strategy out in a new direction. They generally require a bit of context but should be relatively self-contained tasks in many cases.

  1. Add type class instances for types like Future?
  2. Iterating over Intervals with steps (a la range)
  3. Add macro support for zero-cost implicits on literals
  4. Spire bindings for other libraries
  5. Support generalized strategies for mean, standard deviation, etc.
  6. Add larger WELL RNG implementations
  7. Other stats methods?
  8. More random distributions
  9. Use functions to/from Real to make arbitrary instance of Trig, NRoot, etc
  10. Proxy type for easily wrapping numeric types (possibly using macros)
  11. Consider adding FixedDecimal, like FixedPoint but constrained to decimal values.

Possible new features

Hello, greenfield! These tasks are relatively unconstrained by the existing design (although they should try to be harmonious where possible). They tend to be a bit involved in terms of needing some up-front design, and motivating examples. Tests are crucial.

  1. Breeze integration (* see GSOC)
  2. Algebird integration (* needs 2.10)
  3. Look into support DFTs and FFTs
  4. Look into supporting efficient array storage of boxed types
  5. Consider supporting PartialOrder[A]
  6. Support concrete Complex/Quaternion types?
  7. Consider more exotic algebras: Clifford algebras,
  8. Symbolic numbers a la Sympy, Mathematica, etc (?)
  9. Work on fleshing out and profiling soc's BigInt type
  10. Create better BigDecimal type

Additional types

Adding a new type is a bit more straightforward than adding a new feature, since typically the design space is a bit smaller. Like new features, this work does require writing tests (and possibly benchmarks) to be sure that the new type works well.

  1. Add Multi-variate polynomials
  2. Add Skew Field (division ring)
  3. Add finite fields
  4. Add jet (dual number) support (for automatic differentiation)
  5. Add primality testing (e.g. Miller-Rabin, Lucas)
  6. Add more prime factoring methods (e.g. Dixon, Quadratic Sieve, etc)
  7. Add continued fractions
  8. Add ModN/Residue class (possibly with singleton types, e.g. Int(3))
  9. Add Quad or DoubleDouble implementation
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment