Common Lisp is a superb tool. Unfortunately, its ecosystem vastly lags behind mainstream languages like Python. As one of my past-times, I have been working to provide facilities for calling Python functions and callables from Lisp. There are two major approaches to this:

• Through interprocess communication (builds upon bendudson/py4cl)
• By embedding python using its C-API

The former is robust but slow. The latter is fast but relatively brittle. I'm certainly not the first one to attempt this. You can find more about the latter approach - as well as the open issues - from this paper.

Common Lisp actually has several numerical computing libraries. While many of them use BLAS/LAPACK/GSLL for linear algebra operations, there are no optimized operations in these libraries for basic mathematics. By basic mathematics, I mean addition, subtraction, multiplication, division. But even beyond them, there are other operations including floor, ceiling, round, absolute-value, exponentiation, logarithmic, as well as trigonometric, inverse trigonometric and their hyperbolic counterparts.

Moreover, most libraries (including in non Common Lisp ecosystems) fall short of my wishlist. Thus, I have been developing numericals and dense-numericals to fulfil this itch. I widely adopt:

• BMAS backed by SLEEF, which uses SIMD operations to speed things up
• and more recently, Eigen backed by BLAS and LAPACK

This is further coupled with multithreading using lparallel and the C-library builtin OpenMP.

numericals works with standard Common Lisp arrays, this means, you can use it in conjunction with any other Lisp array computing library that also works with Lisp arrays. You can read more about numericals and dense-numericals here.

This line of work has actually spanned two C libraries. So, if you are a C developer and are looking for projects to contribute, here are two such projects.

• BMAS: The ultimate goal is to provide a certain set of math operations across different SIMD platforms and for strided vectors. Currently, full support is only limited to AVX256.
• ceigen_lite: Eigen is an excellent C++ library for numerical computing with vectors and matrices. ceigen_lite aims to provide a C interface to some of the common tasks that Eigen is capable of. In some sense, this will be a higher level interface to BLAS and LAPACK. Currently, this is just 20% complete. Besides, the compile times are enormous, so distributing the library as a binary would be great! But this has only so far been done for linux-amd64. Porting to other OS and architectures remains.

Despite being a great language, I have run into several issues while using Common Lisp to develop the numerical computing library described above:

1. CLOS methods dispatch over common lisp classes but not types. There does not seem to be any trivial way to adapt MOP to dispatch on types instead of classes. Thus, there is no way for ANSI common lisp to dispatch over specialized array types.
2. ANSI common lisp does not allow defining user-defined compound types similar to the builtin (vector &optional element-type) or (integer &optional lower-limit higher-limit). Types defined using CL:DEFTYPE are what CLHS calls derived type specifiers, that is, mere abbreviations and simple combinations of existing types.
3. CLOS-based multiple dispatch might not be the best way to implement adhoc polymorphism compared to traits.
4. cl:coerce is non-extensible.

These issues were previously addressed using polymorphic-functions, extensible-compound-types, extensible-optimizing-coerce, coupled with a number of add-ons and supporting libraries. Over time, these projects became more closely related than what was originally envisioned. Thus, PELTADOT is an attempt to bring all of them together to make maintenance, version control and dependency management easier. See here for more information.