I wanted to do something  just a tiny bit more serious for a change.  It has
been  a while.   Most of the world seems  to conspire  to keep  me on paltry
affairs...!

One approach to linear algebra is to build up from a collection of fortran77
subroutines  named BLAS. The iconic higher level software is LAPACK  (linear
algebra pack). But I want to try something else.

Now this  might be dubious,  but one thing I want to try is using cblas  - a
way to use legacy  BLAS from C - from Embeddable  Common Lisp, a common lisp
compiler that compiles to C and hence has good C interoperability.  The gist
is if you imagine

```ksh
pkg_add ecl cblas
```
and then for example if we try
```lblas.ecl
(ffi:clines "
#include <stdlib.h>
#include <stdio.h>

#include <cblas.h>
")

(defun 3-3-dgemv (alpha a x beta y
                 &aux (m 3) (n 3) (lda 3)) "
cblas_dgemv( .. );
currently makes a lot of assumptions (incx=1 etc
"
(ffi:c-inline (m n alpha beta lda a x y)
             (:int :int :double :double :int
              :pointer-void
              :pointer-void
              :pointer-void)
             nil "
  enum CBLAS_ORDER order;
  enum CBLAS_TRANSPOSE transa;

  order = CblasColMajor;
  transa = CblasNoTrans;
  int m = #0, n = #1, lda = #4, incx = 1, incy = 1;
  double *a = (double *)#5;
  double *x = (double *)#6;
  double *y = (double *)#7;
  double alpha = #2, beta = #3;


  cblas_dgemv( order, transa, m, n, alpha,
               a, lda, x, incx, beta, y, incy );

  @(return 0) = #7;
"))

(defun 3-dgemv (alpha va vx beta vy)
(ffi:with-foreign-object (a '(:array :double 9))
 (ffi:with-foreign-object (x '(:array :double 3))
  (ffi:with-foreign-object (y '(:array :double 3))
   (loop for v across va for c from 0 to 8 do
    (setf (ffi:deref-array a '(:array :double) c) v))
   (loop for v across vx for c from 0 to 2 do
    (setf (ffi:deref-array x '(:array :double) c) v))
   (loop for v across vy for c from 0 to 2 do
    (setf (ffi:deref-array y '(:array :double) c) v))

   (3-3-dgemv alpha a x beta y)
   (loop for c below 3 do
    (setf (aref vy c)
     (ffi:deref-array y '(:array :double) c)))
   (values vy)))))

(time (dotimes (s 10000)
(3-dgemv 1.5 #(2 0 0 0 1 0 0 0 1) #(1 1 1) 1.1 #(1 1 1))))
(print
(3-dgemv 1.5 #(2 0 0 0 1 0 0 0 1) #(1 1 1) 1.1 #(1 1 1)))
(terpri)

(quit)
```
Built by
```build.ecl
#!/usr/local/bin/ecl --shell

(ext:install-c-compiler)
(setf c:*USER-LD-FLAGS* "-lcblas -lblas")

(compile-file #p"lblas.ecl" :system-p t)

(c:build-program "lblas-test" :lisp-files '("lblas.o" ))
```
And then kinda like
```ksh
chmod +x build.ecl
/build.ecl
/lblas-test
```
```Output
real time : 0.577 secs
run time  : 0.590 secs
gc count  : 3 times
consed    : 10085808 bytes

#(4.100000023841858d0 2.600000023841858d0 2.600000023841858d0)
```
which at least seems to have done the right loop*  slowly in a
double precision float sort of way. I think  the  slowness  is
overhead from ecl. So given a big enough  algebra  problem,  I
think it could be faster than ecl on its own.

It's pretty neat. I think after finishing a thick wrapper into
cblas from ecl (-> a c lib), I will have a look at  making  my
own eigen3 or arpack.