[lisplab-cvs] r124 - doc/manual
Jørn Inge Vestgården
jivestgarden at common-lisp.net
Sun Dec 20 20:42:01 UTC 2009
Author: jivestgarden
Date: Sun Dec 20 15:42:00 2009
New Revision: 124
Log:
added missing features
Modified:
doc/manual/lisplab.texi
Modified: doc/manual/lisplab.texi
==============================================================================
--- doc/manual/lisplab.texi (original)
+++ doc/manual/lisplab.texi Sun Dec 20 15:42:00 2009
@@ -57,10 +57,9 @@
and working in an free general purpose programming language. And
best of all: you can enjoy you favorite data-types in addition
to the matrices: functions, hash tables, structures,
-classes, arbitrary precision
-integers, rationals, and lists.
+classes, arbitrary precision integers, rationals, and lists.
-Note that Lisplab is not unique in building Matlab-like
+Lisplab is not unique in building Matlab-like
syntax on top of Common Lisp. Other Common Lisp matrix libraries
are Matlisp, Femlisp and NLISP. Lisplab itself was
started as a branch of Matlisp, but has now moved
@@ -151,13 +150,13 @@
@item
The generic functions of the basic algebra start with a dot:
@code{.+}, @code{.-}, @code{.*}, @code{./}, @code{.^}, @code{.sin}
- at code{.cos}, @code{.tan}, @code{.besj}, @code{.realpart}, etc.
-These functions work on numbers as the non-dotted Common Lisp functions
-and work element-vise on matrices.
+ at code{.cos}, @code{.tan}, @code{.besj}, @code{.re}, etc.
+On numbers these functions work as the non-dotted Common Lisp functions
+and on matrices they work element-vise.
@item
Linear algebra functions tend to start with @i{m}:
@code{m*}, @code{minv}, @code{mmax}, @code{mtp}, etc.,
-but this conventions is followed only to low degree.
+but this conventions is not strictly followed.
@item
The naming convention of files follow the layered structure of
Lisplab, with level0 to level3.
@@ -168,25 +167,22 @@
@section Status - past and future
-The purpose of Lisplab
-is to provide a complete mathematics programming environment,
-not just linear algebra. Currently it contains much
-matrix manipulation and linear algebra stuff,
-as well as fast Fourier transform and special functions.
-It lacks special matrices, such as diagonal, tridiagonal,
-and sparse matrices.
-
-Lisplab started as a refactoring of Matlisp (To make my simulations
-run on Windows for my professor), but
-I (Joern Inge) ended up by reimplementing most of it, keeping
-only the interfaces to Blas and Lapack. Currently,
+Lisplab contains a lot of linear algebra stuff, but
+in the future it is hope it can be broad mathematics programming environment,
+not just linear algebra.
+
+Lisplab has been developed for physics simulations and data handling.
+Lisplab started as a refactoring of Matlisp, but the code
+has been to large degree rewritten, except the
+interfaces to Blas and Lapack. Currently,
Lisplab and Matlisp have more or less the same functionality.
Lisplab differ from Matlisp in the following ways
@itemize
+ at item Implementation.
@item Layered structure (@xref{Structure}.)
@item Shorter names.
- at item Using the standard Lapack and Blas libraries, not a special build.
- at item Native Common Lisp linear algebra implementations.
+ at item Lisplab uses the standard Lapack and Blas libraries, not a special build.
+ at item Rich matrix class hierarchy.
@end itemize
The future I will mainly do minor changes and bug-fixes,
@@ -208,6 +204,45 @@
@end itemize
So it this sounds interesting, please contact if you want to contribute.
+ at section Bugs and limitations
+The purpose of Lisplab is to be a platform for
+mathematical computations. From this perspective it
+is clear it will never be complete. Also, since there is no
+spec it is not obvious what is a bug and what is not!
+
+Hence, the list in this section must be read as non-systematic gathering
+of problem features.
+ at itemize
+ at item Lisplab runs only on SBCL.
+Lisplab is mainly ANSI Common Lisp, so just minor changes
+in the build-system should make it
+run on other lisps, but the problem is that it will most
+probably be slow. It should be fast on CMUCL, though.
+ at item Lacks a formal spec.
+ at item Poorly tested.
+ at item Lacks error checks (but these should not be made before a spec!)
+ at end itemize
+
+Missing features:
+ at itemize
+ at item There is no way to iterate through the elements of
+a general matrix in a fast way. (The map functions are currently the only
+thing, but these are structure agnostic and also not fast.) There
+should maybe be an macro @code{w/matrix}.
+ at item There should be linear algebra primitives, like row exchange,
+in level 2, so that level 3 can be made entirely without knowledge about
+internal structure of matrices. (Structure similar to blas - lapack)
+ at item Integer matrices.
+ at item Vectorized execution of operations.
+ at item Numerical integration.
+ at item Symbolic math. Should be separate module, only with knowledge
+of the dotted algebra generic functions.
+ at item The dotted algebra should also work on functions
+so the one could write @code{(.+ (lambda (x) (+ x 1)) 3)}
+and get a new functions as result. It might even
+be possible to make beautiful optimizations this way.
+ at end itemize
+
@node Tutorial
@chapter Tutorial
@@ -523,8 +558,8 @@
@code{.sinh}, @code{.cosh}, @code{.sinh}, @code{.tanh},
@code{.asin}, @code{.acos}, @code{.asin}, @code{.atan},
@code{.asinh}, @code{.acosh}, @code{.asinh}, @code{.atanh},
- at code{.conj},
- at code{.realpart}, @code{.imagpart}, @code{.exp}, @code{.abs}.
+ at code{.conj}, @code{.re}, @code{.im}, @code{.abs},
+ at code{.sqrt}, @code{.exp}.
@section Special functions
@@ -547,7 +582,8 @@
@end example
The @code{w/infix} messes as little as possible with the Lisp
semantics, so that if you have a lot of formulas just wrap all
-of it inside the macro.
+of it inside the macro. The infix math also works with the
+functions @code{+, -, *, /} and @code{^}.
@node Structure
@@ -565,11 +601,13 @@
(There should be no need
for optimized math in FFIs or special languages like Maxima)
@item Every common mathematical operator and function
-is represented by a @i{CLOS generic function}. This is called the dotted algebra.
+is represented by a @i{CLOS generic function}.
+This is called the dotted algebra.
@item Modular structure (Inspired by GSL).
@item Trust the Lisp system and use foreign code as little as possible.
@item Avoid programming mathematical algorithms in macros. Despite the
-advantages (fast and generic at the same time) it is hard to understand and debug.
+advantages (fast and generic at the same time) it is hard to
+understand and debug.
@item Error checks is primarily callers responsibility, not Lisplab's!
@item To steal as much code as possible from as many as possible
(I love free software).
@@ -587,8 +625,8 @@
@section Package structure
So far, there is only one main package, called, you might guess it:
@i{lisplab}. Except from that there are only a few special packages
-for generated code and FFIs: Slatec, Blas, and FFTW. There is also
-a package @i{lisplab-user} for test code and applications.
+for generated code and FFIs: Slatec, Blas, and FFTW. For test
+code an applications you have the package @i{lisplab-user}.
@section The four levels, 0 -- 3.
More information about the lisplab-cvs
mailing list