# -*- mode: text; -*-

* From Femlisp-0.9.9 to Femlisp-0.9.10:

Several DX graphic windows are allowed in parallel.

General anisotropic refinement rules are allowed.

Different dimensional subparts are allowed for domains/meshes on which
different models can be solved, e.g. 1d-models coupled with 3d-models, etc.
Plotting works by extracting subparts of the domain of a certain dimension.

Introduced plotting of point distributions in the Gnuplot interface.

Femlisp has been ported to Clozure CL and also CLISP.  On CLISP, it is very
slow.  This could be improved by using LAPACK routines (e.g. by using
Matlisp) instead of routines written in Lisp for basic matrix-vector

The ALGEBRA module has been merged into the MATLISP module.  The ALGEBRA
package has been removed.

The ALGEBRA package was restructured.  Especially, @class{<sparse-matrix>}
is much more general now, and allowed for the introduction of just-in-time
calculated matrices which will be introduced in some later Femlisp version.

I separated the Femlisp ASDF system definition in @file{femlisp.asd} into
ASDF systems called "femlisp-basic", "femlisp-matlisp", and "femlisp".
Especially "femlisp-basic" can be used also from other applications, and
"femlisp-matlisp" might develop into a Matlisp replacement.  All system
definitions are still contained in @file{femlisp:femlisp.asd} (which should
therefore be linked also under the names femlisp-basic.asd and
femlisp-matlisp.asd in the ASDF systems directory, if those modules are
used separately).

Our institute has purchased a Lispworks license and I have ported Femlisp
to Lispworks.  Unfortunately, my Allegro license has expired and I cannot
test with Allegro any more at the moment.

Included code for interfacing to LAPACK in @arg{matlisp;lapack.lisp}.
Especially, an interface to the solution of generalized eigenvalue problems
is available in @arg{matlisp;hegz.lisp} and @arg{matlisp;ggev.lisp}.

The ordering of the matrix arguments of MEXTRACT has been changed to fit
better with the intuitive language "extract X from Y".  MEXTRACT and
MINJECT have been renamed to MEXTRACT! and MINJECT! to fit better with the
naming of other destructive Matlisp functions.

Restructuring of the module "basic" in @arg{femlisp.asd}.  

Properties of @class{property-mixin} instances can now be accessed using
@function{slot-value} and @function{with-slots}, in addition to
@function{get-property}.  Such property slots are always bound: if they are
not bound otherwise, they are bound to NIL.

Dropped @function{extend-matlisp-function} after a discussion in
comp.lang.lisp.  The functionality is now provided by @function{matlisp} in

Fixed an hideous bug in domain.lisp which lead to the wrong
characterization of the bottom of a cube domain.

There is a new approach of problem definition in @file{problem;pdef.lisp}
with the help of a macro @macro{create-problem}.  Old definitions are still
used, but may finally be replaced.  The performance impact should be traced
carefully when doing this step.  However, the new form in principle offers
even more possibilities for optimization.

The FE discretization of @class{<ellsys>} problems handles multiple
coefficients of the same type additively.  The Rothe time-stepping scheme
was simplified using this feature.

General elliptic systems: @class{<cdr-problem>},
@classs{<elasticity-problem>}, and @class{<navier-stokes-problem>} have
been changed into special cases of @class{<ellsys-problem>}.  This should
result finally in considerably less source code.  However, at the moment,
the old Navier-Stokes code is still used, and the new code is in a separate
package called @package{navier-stokes-ellsys}.

Generalized fe discretization: the vector form is now used everywhere but
in internal fe operations.

Structural improvement: the necessary local<->global matrix/vector
extraction information is computed lazily in @file{sparseif.lisp}, where it
is needed.

Performance improvement: avoiding to call @function{make-instance} with
keyword arguments in functions like @function{zeros}, @function{ones},
@function{ensure-matlisp} leads to a noticeably higher overall performance
(something like 20%), especially for CMUCL and SBCL.

I changed the color of 1d plots in DX, because yellow axes and white graphs
did not work in some situations (probably due to a bug in DX).

Depending on the parameter @var{fl.graphic::*show-dx-window*}, DX windows
do not pop up when plotting.

Removed a bug in force/delay.

* From Femlisp-0.9.8 to Femlisp-0.9.9:

@class{<tensorial>} was renamed to @class{<product-cell>},
@function{ensure-tensorial} to @function{ensure-simplex-product}, and
@function{tensorial-domain} to @function{simplex-product-domain}.

Vector plotting has been implemented.  Multi-component solutions are
plotted by default with vectors.

I could get rid of spurious black lines in the solution plots by switching
to hardware rendering in DX (a tip from the DX forum).  Unfortunately, this
caused system breakdown in several circumstances.  Thus, I consider it too
fragile to be on by default.  It can be activated with @code{(setq
fl.graphic::*dx-bug-workaround* t)}.

Memoization was improved, which became necessary especially for allowing
multiple parallel threads.  Now there is a combination of a macro
@macro{with-memoization} and an internal macro @macro{memoizing-let} which
allows for more flexibility and improves also the error reporting (use
@lisp{(dbg-on :memoize)}).

The shell scripts in @path{femlisp/bin} now call @path{/bin/bash} instead
of @path{/bin/sh}.  This distinction was necessary on Solaris.

A problem definition and fe discretization for quite general quasilinear
elliptic systems was introduced.  Elasticity and
convection-diffusion-reaction systems appear as special cases now.

There is some SMP support now in @path{basic/multiprocessing.lisp}.  It can
be used to split assembly work between several threads (see the use of the
WITH-WORKERS macro in @path{discretization/fedisc.lisp}).  Because solving
is not yet distributed, it does not reduce overall computational times very

In contrast to SuperLU, the current version of UMFPACK can't handle
multiple right-hand sides with one call.  In this case, the LR system is
now solved multiple times in @path{interface/umfpack.c}.

Femlisp has been ported to Windows using Allegro CL.  Many thanks go to
Franz Inc. for providing me with an evaluation license of Allegro for this

The communication of Femlisp with the external graphics engines DX and
Gnuplot was changed.  It should be much more rubust now.

Corrected a bug in @function{print-matrix} (a non-standard use of LOOP).

* From Femlisp-0.9.7 to Femlisp-0.9.8:

The Femlisp test suite is now run daily with Allegro CL, CMUCL, and SBCL.

ECL can now compile Femlisp.  Many thanks to Juan Jose Garcia Ripoll for
his help.  Unfortunately, the performance of Femlisp/ECL is still abysmal,
and apparently not all tests pass.

Removed uses of DEFINE-SYMBOL-MACRO in @path{iteration;multigrid.lisp}
because, first, GCL does not have it yet, and second, it lead to somewhat
obscure code.

Mario Mommer contributed a change which makes Femlisp loadable with ASDF.

Coefficient functions may depend on other finite element functions now.
This is used also for nonlinear time-dependent problems for incorporating a
dependency on the solution from the old timestep.

Introduced a demo and a test for solving the heat equation.

Some changes in several files for making ECL and GCL run with Femlisp.
Especially, a trivial asdf replacement is now available as
@path{external/trivial-asdf.lisp}, since standard asdf did not work with

Removed the dependency on UFFI introduced in Femlisp-0.9.7.

* From Femlisp-0.9.6 to Femlisp-0.9.7:

There is a directory @path{femlisp:private} where users can put private
stuff.  If a file @path{femlisp:private;start.lisp} is found it is loaded
when Femlisp starts up.

Dofs are CLOS classes now instead of structures in @arg{fe.lisp}.  Now
Allegro compiles without warnings.  No obvious speed reduction for SBCL.

Cosmetic changes for removing Allegro warnings.

Femlisp now works with Allegro CL on AMD-64 and Linux.  Many thanks to
Franz Inc. for allowing me to use an evaluation license of their product.

Removed a bug in the CG method which assumed that a smoother would keep the
residual intact.  Now, BPX preconditioning with Jacobi smoothing works.

Changed the representation of identifications from a list of identified
cells to a class containing a slot of identified cells.  This should remove
the following subtle bug: with list as hash-table keys, the ordering of
hash-based sparse matrices might change after GC, whereas, on the other
hand, there may be still places in Femlisp where it is implicitly assumed
that this ordering is kept.

Worked towards full ANSI compliance of Femlisp.  One important step was
checking that all array allocations have an initialization parameter
(CMUCL/SBCL do a default initialization with 0 which is not guaranteed by
the standard).

Removed an underflow bug in DX graphics by converting each value to
single-float before output.

* From Femlisp-0.9.5 to Femlisp-0.9.6:

Femlisp runs successfully on an AMD-64 platform using SBCL.  Many thanks
especially to Dan Barlow and Juho Snellman for making SBCL work on AMD.

The installation procedure was improved with a configure script.

The use of LAPACK/Matlisp for full matrices in Femlisp is now possible in a
very convenient way: if Matlisp is available, the function
@function{extend-matlisp-function} can be used to extend a Matlisp generic
function to be applicable to Femlisp matrices.

There is now an installation section for MacOS X in the manual.

If neither SuperLU nor UMFPACK is available, we use the old LU
decomposition for our own sparse matrix format.  This makes those packages
optional, although the performance may suffer for larger matrices.

General refinement rules are allowed now.  For example, although
anisotropic refinement rules are not yet created, this should be very easy
to do now.

Finite element interpolation now works for vector-valued functions.

Automatically generated matrix classes are now correctly interned in the
package @package{FL.MATLISP}.

* From Femlisp-0.9.4 to Femlisp-0.9.5:

Several enhancements for the linear algebra.  The file @path{tensor.lisp}
was moved from @package{FL.ALGEBRA} to @package{FL.MATLISP}.

Introduced a new package @package{FL.DOMAINS} in
@path{femlisp;src;applications;domains;domains-defp.lisp} for domain

Checked the demos for reasonable results.

Removed a bug in multigrid (lmgc) which made certain iterations return
wrong results (those iterations which needed the residual before, but did
not recompute it afterwards (e.g. Jacobi)).

Refinement rules have been reworked to allow for arbitrary refinements of
reference cells.  This can be used for multiscale discretizations.

Subcells are computed with automatically generated code which leads to an
acceleration of about a factor 5 for this function.

* From Femlisp-0.9.3 to Femlisp-0.9.4:

Saving a Femlisp executable using the foreign code works along the lines
pointed out by Eric Marsden in an article for cmucl-help at 18.9.2003.

Interfaces to the sparse direct solvers SuperLU and UMFPACK are available
as shared libraries generated in @path{femlisp;interface}.  Direct solving
is then also the default solving method for moderate number of unknowns.

Preliminary support for solving time-dependent problems by the Rothe method
has been incorporated.  At the moment, only an implicit Euler method is

Changed @var{manifold-dimension} to @var{embedded-dimension}.

An interface to the 2D mesh generator @program{Triangle} by J. R. Shewchuk
has been integrated.

Routines for solving eigenvalue problems by a Wielandt iteration have been
incorporated, see the files @file{problem;evp.lisp},
@file{iteration;evpsolve.lisp}, @file{strategy;fe-evp.lisp}, and

Changed the communication with the graphics programs @code{DX} and
@code{Gnuplot}.  Data is written into files @file{output.dx} and
@file{output.gnuplot}.  After these files have been read, they are moved to
backup files from within the graphics program.  Femlisp waits until this
has been done, before a new graphic is written out.

* From Femlisp-0.9.2 to Femlisp-0.9.3:

The passing of arguments for DX was corrected.  The old version did not
work with more recent versions of CMUCL/SBCL and DX, because I did not
understand the argument passing well enough (thanks to Christophe Rhodes
and Bjoern Lindberg for help on this topic).

Femlisp has now a user manual!  An important part of it is the reference
manual which is automatically built from docstrings.  This is similar to
what Rudi Schlatte did for SBCL. One difference to the SBCL approach is
that I want my docstrings to be in Texinfo format.

general PROPERTIES slot which is to be added by adding a PROPERTY-MIXIN to
the superclasses.

Finite elements of polynomial degree @math{p} are integrated now with
@math{p+1} Gauss points also for simplices.  (Otherwise, the scheme is
unstable for reaction terms.)

The functions ASSEMBLE-INTERIOR and FE-CELL-GEOMETRY handle now metric and
volume form defined as properties on the domain patches.  This can be used,
for example, to treat problems in cylinder coordinates.

The formula for the area of higher-dimensional spans in matlisp;compat.lisp
was simplified to sqrt(det(A^t A)).

The possibility to build Femlisp with MK-DEFSYSTEM was reintroduced.  The
files femlisp.asd and femlisp.system are identical.

The dependency on CL-PPCRE was removed.  CL-PPCRE is a nice package, but
Femlisp does not need it at the moment.

* From Femlisp-0.9.1 to Femlisp-0.9.2:

A Newton iteration was introduced for solving nonlinear problems, see the
file ITERATION:NLSOLVE.LISP.  Examples for solving nonlinear problems can
be found in the files APPLICATIONS;CDR;BRATU.LISP and

Levels for iteration output were introduced.  The keyword parameter OUTPUT
can be a number telling up to which depth the nested iterations print out
their status information (for example, showing convergence of the adaptive
mesh refinement, nonlinear and linear solving would need OUTPUT to be at
least 3).

The respresentation of blackboards was changed from property lists to

The class name <PROBLEM> was changed to <PDE-PROBLEM>.  <PROBLEM> is a more
general class (which contains, for example, also discrete linear or
nonlinear problems).

Femlisp now works on Mac OS X with an OpenDX from Fink/unstable. Thanks to
Ingo Heppner for testing this out and thanks to Volker Reichenberger who
gave us the hint with Fink.

I removed all method specializations on the fixnum type (because it is not
ANSI-CL compatible).

Plotting for general n-dimensional meshes now works by plotting only the
3-dimensional skeleton transformed by a linear mapping.  By default, this
transformation skips all coordinates but the first three, so (PLOT (N-CUBE
4)) will yield the same as (PLOT (N-CUBE 3)).  See the refinement demos for
the effect of the transformation mapping.

Plotting of meshes containing prism/wedge cells works.  Also demos for
refinement of wedges and computations on a wedge are now available.

* From Femlisp-0.9.0 to Femlisp-0.9.1:

The DX logfile is now written to #p"femlisp:images;"

Corrections in the files FAQ, CHANGES, INSTALL, README, and TODO.

Some extensions of general problem solving.  This is work in progress.

Femlisp now works with SBCL on Mac OS X and with CMUCL on Sparc/Solaris.
Unfortunately, the communication with Data Explorer on Mac OS X is not yet

The whole installation process is specified in more detail in INSTALL.  The
approach using the global installation script "femlisp-install" is
abandoned, because it does not make much sense for more sophisticated

For convenience, I have included the ASDF and Infix libraries with Femlisp
in the directory "femlisp/external/".  CL-PPCRE is put there as well by
executing using "make cl-ppcre" in the Femlisp main directory.

* From Femlisp-0.8.5 to Femlisp-0.9.0:

There are the beginnings of a GPS (general problem solver:-).  The generic
function SOLVE can be called on a blackboard containing a problem.  It then
tries to find a solution strategy itself.

Femlisp is almost completely ANSI-compliant now.  At least, it works on
both SBCL and CMUCL.  The platform/implementation dependent parts are
concentrated in femlisp:src;basic;port.lisp.

DOUBLE-FLOAT is the standard read format now.  Uniform DOUBLE-FLOAT vectors
can be written as #d(...).

Some packages have been renamed for avoiding name clashes with other CL
libraries, e.g. MACROS became FL.MACROS, UTILITIES became FL.UTILITIES,
etc.  I intend to do the analogous change for other Femlisp packages, too.

Femlisp now uses the ASDF system definition facility by Dan Barlow instead
of MK-DEFSYSTEM.  Thanks to Dan and thanks to Christophe Rhodes for helping
me with this change.

Femlisp is somewhat faster now (by about 10%-30%).  The main reason is the
caching of the last result of CORNERS (corners of a cell).

A replacement for Matlisp was incorporated (package FL.MATLISP) which is
sufficient for the restricted LAPACK functionality needed by Femlisp.  The
main advantages of this change are that Femlisp should be easily portable
to other CL implementations now and that these routines work much faster on
small matrices.  FL.MATLISP matrices can be written with #m(...).

* From Femlisp-0.8.4 to Femlisp-0.8.5:

The mesh module was improved.  Especially, cells are now CLOS classes
instead of structures (as it was already described in my article on Femlisp
in femlisp/doc).  The classes are automatically generated at runtime.

A new package called FEMLISP.MATLISP was introduced which acts at the
moment as an interface to MATLISP.  The next move will be to plug in my
Matlisp replacement.  (This replacement is ready up to some polishing.)

The regression test suite was improved.  Especially, all demos are now
tested as well.

Some errors were removed.

* From Femlisp-0.8.3 to Femlisp-0.8.4:

The iteration module was improved.  Iterative solvers and problem solution
stragtegies are now subclasses of iterations.  This allows for the easy
integration of nonlinear solvers and time stepping schemes.

The interface for solving has changed to the form (SOLVE SOLVER
BLACKBOARD).  That is, the problem to be solved is now defined on a
blackboard and the solution is written to this blackboard.  This is true
for both linear solvers and problem solution strategies.

Several smaller changes.

* From Femlisp-0.8.2 to Femlisp-0.8.3:

Removed a bug in the refinement of product cells which contain simplices of
dimension >=3.

Adaption to the new Matlisp.  MATRIX-REF is a macro dispatching to
MATRIX-REF-1D and MATRIX-REF-2D.  We also unexport MATLISP:REAL after
loading Matlisp, because it interferes with COMMON-LISP:REAL.