femlisp

API Reference

cl-cpu-affinity

CL-CPU-AFFINITY

  • Variable +CPU-LIMIT+
    cl-cpu-affinity::cpu-setsize
    Upper exclusive limit on the number of CPUs. Based on CPU_SETSIZE from sched.h.

ddo

No packages.

femlisp

FL.FUNCTION

  • Class <FUNCTION>
    The <function> class is an abstract class for a general function. This function will usually accept vector arguments, the dimensions of domain and image are fixed when defining the function. If the function is differentiable, the gradient matrix can be obtained by evaluating the gradient slot.
    DOMAIN-DIMENSION   Reader: DOMAIN-DIMENSION
    IMAGE-DIMENSION   Reader: IMAGE-DIMENSION
  • Generic-Function MULTIPLE-EVALUATE (func positions)
    Multiple evaluations of @arg{func} may be optimized.
  • Method MULTIPLE-EVALUATE (func positions)
    The default and unoptimized method calls simply @function{evaluate}.
  • Method MULTIPLE-EVALUATE (func positions)
    The default and unoptimized method calls simply @function{evaluate}.
  • Method MULTIPLE-EVALUATE (func positions)
    The default and unoptimized method calls simply @function{evaluate}.
  • Generic-Function EVALUATE-GRADIENT (f x)
    Generic evaluation of gradients of differentiable functions.
  • Generic-Function MULTIPLE-EVALUATE-GRADIENT (f positions)
    Multiple evaluations may be optimized.
  • Method MULTIPLE-EVALUATE-GRADIENT (f positions)
    The default and unoptimized method calls simply @function{evaluate}.
  • Method MULTIPLE-EVALUATE-GRADIENT (f positions)
    The default and unoptimized method calls simply @function{evaluate}.
  • Method MULTIPLE-EVALUATE-GRADIENT (f positions)
    The default and unoptimized method calls simply @function{evaluate}.
  • Generic-Function DIFFERENTIABLE-P (f &optional k)
    Returns t if f is differentiable or differentiable of the given degree.
  • Method DIFFERENTIABLE-P (f &optional k)
    The default method returns @code{NIL}.
  • Method DIFFERENTIABLE-P (f &optional k)
    The default method returns @code{NIL}.
  • Method DIFFERENTIABLE-P (f &optional k)
    The default method returns @code{NIL}.
  • Class <SPECIAL-FUNCTION>  (<FUNCTION>)
    A <special-function> provides its own evaluation and gradient computation.
    EVALUATOR   Reader: EVALUATOR
    GRADIENT   Reader: GRADIENT
    JET   Reader: JET
  • Function SPECIAL-1D-FUNCTION (f &optional df)
    Constructs a special function between 1D-spaces from ordinary Lisp functions.
  • Method DIFFERENTIABLE-P ((f <special-function>) &optional (k 1))
  • Method EVALUATE-GRADIENT ((f <special-function>) x)
  • Class <CONSTANT-FUNCTION>  (<FUNCTION>)
    For a <constant-function> evaluation and derivative computation are trivial.
    VALUE   Reader: VALUE
  • Method EVALUATE-GRADIENT ((f <constant-function>) x)
  • Class <LINEAR-FUNCTION>  (<FUNCTION>)
    A <linear-function> is determined by a matrix A and a vector b. It represents the map @math{x -> Ax+b}.
    A
    B
  • Method EVALUATE-GRADIENT ((f <linear-function>) x)
  • Function TRANSFORM-FUNCTION (func &key domain-transform image-transform)
  • Method DIFFERENTIABLE-P ((f <linearly-transformed-function>) &optional (k 1))
  • Method EVALUATE-GRADIENT ((func <linearly-transformed-function>) pos)
  • Function NUMERICAL-GRADIENT (func &key (shift 1.d-6))
    Computes the numerical gradient of func at pos.
  • Function NUMERICAL-COMPLEX-DERIVATIVE (f)
    Computes a very accurate real derivative for functions which can be applied to complex arguments.
  • Function NUMERICAL-COMPLEX-DERIVATIVE (f)
    Computes a very accurate real derivative for functions which can be applied to complex arguments.
  • Function INTERVAL-METHOD (func a b accuracy)
    Finds zeros of functions in 1d by the interval method.
  • Function HOMOTOPY (func1 func2)
    Returns a function which uses its first coordinate as a homotopy parameter.
  • Function ELLIPSE-MATRIX (radius excentricity phi)
    Returns a matrix A suitable for describing the ellipse as (Ax,x)=1.
  • Function PROJECT-TO-ELLIPSOID (midpoint a)
    Returns a function which projects to the ellipsoid given by Q(x-midpoint)=1 where Q is the quadratic form associated with the matrix A.
  • Function PROJECT-TO-SPHERE (midpoint radius)
    Returns a function which projects to the sphere with given midpoint and radius.
  • Function XN-DISTORTION-FUNCTION (f grad-f dim)
    Returns a function which distorts the xn-coordinate by a factor f(x'). Also grad-f has to be provided.
  • Function CIRCLE-FUNCTION (&optional (radial-distance 1.0d0) (midpoint (coerce '(0.0d0 0.0d0) 'double-vec)) (omega 1.0d0) (phi0 0.0d0))
    Returns a special function drawing a polar around @arg{midpoint} with distance given by the function or number @arg{radial-distance} with angular velocity omega. Without arguments it yields a function mapping @math{R^1} isometrically to @math{S^1}.
  • Macro SPARSE-FUNCTION (args &body components)
  • Function SPARSE-REAL-DERIVATIVE (sparse-f)
    Warning: works only for real-valued functions!
  • Function SPARSE-REAL-DERIVATIVE (sparse-f)
    Warning: works only for real-valued functions!
  • Class POLYNOMIAL  (<VECTOR>)
    Multivariate polynomial. The coefficients are represented as nested lists.
    COEFFS   Reader: COEFFICIENTS
  • Function MAKE-POLYNOMIAL (coeffs)
    Constructor which simplifies the coefficient list.
  • Generic-Function ZERO (f)
    Generates a zero of the same kind as @arg{F}.
  • Method ZERO ((f polynomial))
  • Method ZERO ((f polynomial))
  • Method ZERO ((f polynomial))
  • Method ZERO ((f list))
  • Method ZERO ((f list))
  • Method ZERO ((f list))
  • Generic-Function UNIT (f)
    Generates a unit of the same kind as @arg{F}.
  • Method UNIT ((f polynomial))
  • Method UNIT ((f polynomial))
  • Method UNIT ((f polynomial))
  • Method UNIT ((f list))
  • Method UNIT ((f list))
  • Method UNIT ((f list))
  • Generic-Function ZERO? (x)
  • Method ZERO? ((poly polynomial))
  • Method ZERO? ((poly polynomial))
  • Method ZERO? ((poly polynomial))
  • Method ZERO? ((lst list))
  • Method ZERO? ((lst list))
  • Method ZERO? ((lst list))
  • Method ZERO? ((x number))
  • Method ZERO? ((x number))
  • Method ZERO? ((x number))
  • Generic-Function UNIT? (x)
  • Method UNIT? ((poly polynomial))
  • Method UNIT? ((poly polynomial))
  • Method UNIT? ((poly polynomial))
  • Method UNIT? ((lst list))
  • Method UNIT? ((lst list))
  • Method UNIT? ((lst list))
  • Method UNIT? ((x number))
  • Method UNIT? ((x number))
  • Method UNIT? ((x number))
  • Function SHIFT-POLYNOMIAL (poly dim)
    Shifts a polynomial in dimension, e.g. x_1 becomes x_2.
  • Generic-Function DEGREE (poly)
    Degree of a polynomial
  • Method DEGREE ((poly polynomial))
  • Method DEGREE ((poly polynomial))
  • Method DEGREE ((poly polynomial))
  • Generic-Function TOTAL-DEGREE (poly)
    Degree of a multivariate polynomial
  • Method TOTAL-DEGREE ((poly polynomial))
  • Method TOTAL-DEGREE ((poly polynomial))
  • Method TOTAL-DEGREE ((poly polynomial))
  • Generic-Function PARTIAL-DEGREE (poly index)
    Partial degree in variable INDEX of a multivariate polynomial.
  • Method PARTIAL-DEGREE ((poly polynomial) (index integer))
  • Method PARTIAL-DEGREE ((poly polynomial) (index integer))
  • Method PARTIAL-DEGREE ((poly polynomial) (index integer))
  • Method PARTIAL-DEGREE ((lst list) (index integer))
  • Method PARTIAL-DEGREE ((lst list) (index integer))
  • Method PARTIAL-DEGREE ((lst list) (index integer))
  • Generic-Function VARIANCE (poly)
  • Method VARIANCE ((poly polynomial))
  • Method VARIANCE ((poly polynomial))
  • Method VARIANCE ((poly polynomial))
  • Generic-Function MAXIMAL-PARTIAL-DEGREE (poly)
    Maximal partial degree of a polynomial.
  • Method MAXIMAL-PARTIAL-DEGREE ((poly polynomial))
  • Method MAXIMAL-PARTIAL-DEGREE ((poly polynomial))
  • Method MAXIMAL-PARTIAL-DEGREE ((poly polynomial))
  • Function ELIMINATE-SMALL-COEFFICIENTS (poly &optional (threshold 1.d-12))
  • Function SPLIT-INTO-MONOMIALS (coeffs)
  • Generic-Function POLY* (p1 p2)
    Multiplies two polynomials P1 and P2.
  • Method POLY* ((g polynomial) (f number))
  • Method POLY* ((g polynomial) (f number))
  • Method POLY* ((g polynomial) (f number))
  • Method POLY* ((f number) (g polynomial))
  • Method POLY* ((f number) (g polynomial))
  • Method POLY* ((f number) (g polynomial))
  • Method POLY* ((f polynomial) (g polynomial))
  • Method POLY* ((f polynomial) (g polynomial))
  • Method POLY* ((f polynomial) (g polynomial))
  • Method POLY* ((f list) (g list))
  • Method POLY* ((f list) (g list))
  • Method POLY* ((f list) (g list))
  • Method POLY* ((g list) (f number))
  • Method POLY* ((g list) (f number))
  • Method POLY* ((g list) (f number))
  • Method POLY* ((f number) (g list))
  • Method POLY* ((f number) (g list))
  • Method POLY* ((f number) (g list))
  • Method POLY* ((f number) (g number))
  • Method POLY* ((f number) (g number))
  • Method POLY* ((f number) (g number))
  • Function POLY-EXTERIOR-PRODUCT (poly1 poly2)
  • Generic-Function POLY-EXPT (p n)
    Raises the polynomial P to power N.
  • Method POLY-EXPT ((poly polynomial) (n integer))
  • Method POLY-EXPT ((poly polynomial) (n integer))
  • Method POLY-EXPT ((poly polynomial) (n integer))
  • Method POLY-EXPT ((lst list) (n integer))
  • Method POLY-EXPT ((lst list) (n integer))
  • Method POLY-EXPT ((lst list) (n integer))
  • Generic-Function DIFFERENTIATE (poly index)
    Differentiate a multivariate polynomial wrt the variable given by INDEX.
  • Method DIFFERENTIATE ((poly polynomial) index)
  • Method DIFFERENTIATE ((poly polynomial) index)
  • Method DIFFERENTIATE ((poly polynomial) index)
  • Method DIFFERENTIATE ((lst list) index)
  • Method DIFFERENTIATE ((lst list) index)
  • Method DIFFERENTIATE ((lst list) index)
  • Method GRADIENT ((poly polynomial))
  • Method EVALUATE-GRADIENT ((poly polynomial) (x vector))
  • Function N-VARIATE-MONOMIALS-OF-DEGREE (n degree &optional (type '=))
    Returns n-variate monomials of degree being equal or being lower or equal than deg. Examples: (n-variate-monomials-of-degree 2 2) -> (x2^2 x1*x2 x1^2) (n-variate-monomials-of-degree 2 2 '<=) -> (1 x2 x1 x2^2 x1*x2 x1^2)
  • Function LAGRANGE-POLYNOMIALS (points)
  • Function INTEGRATE-SIMPLE-POLYNOMIAL (poly)
  • Class <POLYGON>  (<FUNCTION>)
    This class implements a function which maps the unit interval to a polygon.
    POINTS   Reader: POINTS
    A vector of points for the polygon.
  • Class <PERIODIC-POLYGON>  (<POLYGON>)
    This class implements a periodic polygon.
    No slots.
  • Method EVALUATE-GRADIENT ((polygon <polygon>) s)
  • Method DIFFERENTIABLE-P ((f <polygon>) &optional (k 1))
  • Function CUBIC-SPLINE (y)
    On a regular partition of the unit interval interpolating values y are given. This function returns an interpolating spline.
  • Method DOMAIN-DIMENSION ((problem <domain-problem>))

Also exports

  • FL.UTILITIES:EVALUATE

FL.MESH

This module contains the definitions of meshes and
routines for mesh management.  The meshes allowed in @femlisp{} are more
general than those of most other software for solving PDEs.  In @femlisp{},
both mesh, domain and problem definitions are defined over an underlying
abstraction, the so-called @class{<skeleton>}.  A @class{<skeleton>}
captures the mathematical idea of a "cell complex" which builds a
topological space by mapping from standard cells @class{<cell>}.  Now, a
@class{<skeleton>} can be seen as mapping the cells of such a cell complex
to arbitrary values.  Then, a @class{<domain>} is a @class{<skeleton>}
where each cell (which we call "patch" in this case) is mapped to
geometric properties, and a @class{<mesh>} is a @class{<skeleton>} where
each cell is mapped to the patch to which it belongs.

The basic entities are the class @class{<cell>}, the subclass
@class{<simplex>} which in turn contains subclasses for arbitrarily
dimensional simplices generated on demand, and the subclass
@class{<product-cell>} containing arbitrary products of simplices, e.g. square
or cube.

Meshes can be refined either uniformly or locally using the Freudenthal
algorithm as presented in @cite{JBey_2000a} and generalized to product
elements.  When local refinement is used, hanging nodes may occur.  In
contrast to most other finite element software, in @femlisp{} the
difference of refinement levels of adjacent cells may be arbitrarily large.
Up to now, anisotropic refinement of product cells has not yet been
implemented.
  • Class <CELL>
    The basic cell class.
    No slots.
  • Function CELLP (cell)
  • Class <MAPPED-CELL>
    A mixin which distinguishes cells which are mapped by a special mapping.
    MAPPING   Accessor: MAPPING
  • Function MAPPED-P (cell)
  • Function MAPPED-CELL-CLASS (class &optional distorted)
    Constructs a cell class with <mapped-cell> mixin.
  • Method MAPPING ((cell <cell>))
    No mapping for ordinary cells.
  • Class <VERTEX>  (<CELL>)
    The vertex class.
    CELL-CLASS-INFORMATION   Accessor: CELL-CLASS-INFORMATION
    POSITION   Reader: VERTEX-POSITION
  • Function VERTEX? (cell)
  • Function VERTEX-P (cell)
  • Generic-Function EMBEDDED-DIMENSION (object)
    Dimension of the embedding space for @arg{object}. If @arg{check} is T, a test is performed if the dimension is well-defined for all parts of @arg{object}. If not, NIL is returned.
  • Method EMBEDDED-DIMENSION ((vtx <vertex>))
    Anchor for recursive definition.
  • Method EMBEDDED-DIMENSION ((vtx <vertex>))
    Anchor for recursive definition.
  • Method EMBEDDED-DIMENSION ((vtx <vertex>))
    Anchor for recursive definition.
  • Method EMBEDDED-DIMENSION ((cell <cell>))
    Recursive definition, anchored at the definition for vertices.
  • Method EMBEDDED-DIMENSION ((cell <cell>))
    Recursive definition, anchored at the definition for vertices.
  • Method EMBEDDED-DIMENSION ((cell <cell>))
    Recursive definition, anchored at the definition for vertices.
  • Generic-Function VERTICES (cell)
    Returns a list of all vertices of the cell.
  • Generic-Function CORNERS (cell)
    Returns a list of corners of the cell, i.e. the global positions of the cell's vertices.
  • Method CORNERS (cell)
    Default method.
  • Method CORNERS (cell)
    Default method.
  • Method CORNERS (cell)
    Default method.
  • Generic-Function DIAMETER (cell)
    Returns the diameter of a cell.
  • Method DIAMETER (cell)
    The default method maximizes the distance between the cell's corners.
  • Method DIAMETER (cell)
    The default method maximizes the distance between the cell's corners.
  • Method DIAMETER (cell)
    The default method maximizes the distance between the cell's corners.
  • Generic-Function LOCAL->GLOBAL (cell local-pos)
    local->global checks if a mapping is given for the cell. If yes, then this mapping is evaluated. If no, then the function l2g is called which should do a multilinear interpolation from the cell's corners.
  • Generic-Function MULTIPLE-LOCAL->GLOBAL (cell local-pos)
    Applies LOCAL->GLOBAL for several positions at once.
  • Generic-Function LOCAL->DGLOBAL (cell local-pos)
    local->Dglobal checks if a mapping is given for the cell. If yes, then the gradient of this mapping is evaluated (if available). If no, then the function l2Dg is called which gives the gradient for a multilinear interpolation from the cell's corners.
  • Generic-Function MULTIPLE-LOCAL->DGLOBAL (cell local-pos)
    Applies LOCAL->DGLOBAL for several positions at once.
  • Generic-Function L2G (cell local-pos)
    Computes the global position by interpolation from the vertices.
  • Generic-Function L2DG (cell local-pos)
    Computes the gradient for a multilinear interpolation from the vertices.
  • Generic-Function LOCAL-COORDINATES-OF-MIDPOINT (cell)
    Returns the local coordinates of the cell midpoint.
  • Method L2G (cell local-pos)
    This default method uses a barycentric average of the vertex positions.
  • Method L2DG (cell local-pos)
    This default method computes an average of the barycentric coordinate gradients.
  • Generic-Function MIDPOINT (cell)
    Returns cell midpoint in global coordinates.
  • Method MIDPOINT (cell)
    Default method
  • Method MIDPOINT (cell)
    Default method
  • Method MIDPOINT (cell)
    Default method
  • Generic-Function ORIGIN (cell)
    Returns cell origin in global coordinates.
  • Method ORIGIN (cell)
    Default method.
  • Method ORIGIN (cell)
    Default method.
  • Method ORIGIN (cell)
    Default method.
  • Function FACTOR-SIMPLICES (cell)
    Returns the factor-simplices.
  • Function NR-OF-SIDES (cell)
    Returns the number of boundary faces.
  • Function NR-OF-VERTICES (cell)
    Returns the number of vertices.
  • Function NR-OF-SUBCELLS (cell)
    Returns the number of subcells.
  • Function REFINE-INFO (cell)
    Returns refinement information for the cell.
  • Generic-Function DIMENSION (cell)
    Returns the dimension of the cell.
  • Method DIMENSION ((cell <cell>))
  • Method DIMENSION ((cell <cell>))
  • Method DIMENSION ((cell <cell>))
  • Generic-Function REFERENCE-CELL (cell-or-class)
    Returns the cell's or cell-classes reference-cell.
  • Method REFERENCE-CELL ((class standard-class))
    Returns the cell information also when called for a cell class.
  • Method REFERENCE-CELL ((class standard-class))
    Returns the cell information also when called for a cell class.
  • Method REFERENCE-CELL ((class standard-class))
    Returns the cell information also when called for a cell class.
  • Method REFERENCE-CELL ((cell <cell>))
  • Method REFERENCE-CELL ((cell <cell>))
  • Method REFERENCE-CELL ((cell <cell>))
  • Function FACTOR-DIMENSIONS (cell)
  • Function REFERENCE-CELL-P (cell)
    Tests if a cell is a reference cell.
  • Generic-Function SUBCELLS (cell)
    Returns a vector containing all subcells of a given cell. The code is special to each class and often automatically generated by @function{generate-subcell-access-code}.
  • Generic-Function CELL-MAPPING (cell)
    Return the mapping for mapped cells.
  • Method CELL-MAPPING ((cell <mapped-cell>))
    Return the mapping of the mapped @arg{cell}.
  • Method CELL-MAPPING ((cell <mapped-cell>))
    Return the mapping of the mapped @arg{cell}.
  • Method CELL-MAPPING ((cell <mapped-cell>))
    Return the mapping of the mapped @arg{cell}.
  • Method CELL-MAPPING ((cell <cell>))
    For non-mapped cells, this method returns a <special-function> which can be called instead of @function{l2g} and @function{l2Dg}.
  • Method CELL-MAPPING ((cell <cell>))
    For non-mapped cells, this method returns a <special-function> which can be called instead of @function{l2g} and @function{l2Dg}.
  • Method CELL-MAPPING ((cell <cell>))
    For non-mapped cells, this method returns a <special-function> which can be called instead of @function{l2g} and @function{l2Dg}.
  • Method CELL-MAPPING (cell)
    The default result is NIL, i.e. no mapping
  • Method CELL-MAPPING (cell)
    The default result is NIL, i.e. no mapping
  • Method CELL-MAPPING (cell)
    The default result is NIL, i.e. no mapping
  • Method LOCAL->GLOBAL ((cell <cell>) local-pos)
  • Method LOCAL->GLOBAL ((cell <mapped-cell>) local-pos)
  • Method LOCAL->GLOBAL ((cell <distorted-cell>) local-pos)
  • Method MULTIPLE-LOCAL->GLOBAL ((cell <cell>) local-positions)
  • Method MULTIPLE-LOCAL->GLOBAL ((cell <mapped-cell>) local-positions)
  • Method MULTIPLE-LOCAL->GLOBAL ((cell <distorted-cell>) local-positions)
  • Method LOCAL->DGLOBAL ((cell <cell>) local-pos)
  • Method LOCAL->DGLOBAL ((cell <mapped-cell>) local-pos)
  • Method LOCAL->DGLOBAL ((cell <distorted-cell>) local-pos)
  • Method MULTIPLE-LOCAL->DGLOBAL ((cell <cell>) local-positions)
  • Method MULTIPLE-LOCAL->DGLOBAL ((cell <mapped-cell>) local-positions)
  • Method MULTIPLE-LOCAL->DGLOBAL ((cell <distorted-cell>) local-positions)
  • Generic-Function G2L (cell global-pos)
    Computes the local position inside the cell for the given global position. This function is not really used at the moment, in contrast to @function{global->local}.
  • Generic-Function GLOBAL->LOCAL (cell global-pos)
    Mainly useful for finite element evaluation: from the local position, the value of a fe function can be obtained by interpolation. This is done by a Newton iteration, which converges in one step for linear mappings. The result is NIL, if no local point could be determined.
  • Method GLOBAL->LOCAL ((cell <cell>) global-pos)
    Does a Newton iteration or a Gauss-Newton method for approximating global-pos by the cell mapping.
  • Generic-Function INSIDE-CELL? (cell global-pos &optional threshold)
    Checks if @arg{global-pos} is inside the interior of the @arg{cell}. It calls @function{global->local} to obtain local coordinates and then @function{coordinates-inside?} to check if those are inside the cell. If @arg{threshold} is a non-negative number, an additional check is performed, if the local coordinates map to @arg{global-pos} with accuracy threshold.
  • Method INSIDE-CELL? ((cell <cell>) position &optional threshold)
  • Generic-Function GLOBAL->EMBEDDED-LOCAL (cell global-pos)
    This computes a local coordinate which solves the Ausgleichsproblem of mapping to a point as near as possible to global-pos. It involves more computational work than global->local. As a second value, the distance to global-pos is returned.
  • Method GLOBAL->EMBEDDED-LOCAL ((cell <cell>) global-pos)
  • Generic-Function SKELETON (cell-or-cells)
    Returns a skeleton for the given cell or the given cells.
  • Class <SKELETON>  (PROPERTY-MIXIN)
    A skeleton is a vector of hash-tables containing the cells of a certain dimension as keys. The information stored in the values is different depending on the subclass derived from skeleton.
    DIMENSION   Accessor: DIMENSION
    ETABLES   Accessor: ETABLES
  • Generic-Function ETABLE (skel dim)
    A table for cells of dimension @arg{dim} in @arg{skel}.
  • Method ETABLE ((skel <skeleton>) dim)
  • Method ETABLE ((skel <skeleton>) dim)
  • Method ETABLE ((skel <skeleton>) dim)
  • Function ETABLE-OF-HIGHEST-DIM (skel)
  • Function MEMBER-OF-SKELETON? (cell skel)
    Returns T if @arg{cell} is in @arg{skel}, NIL otherwise.
  • Function SKEL-REF (skel cell)
    Returns the properties of @arg{cell} in @arg{skel}.
  • Function (setf SKEL-REF) (value skel cell)
    Setter for the properties of @arg{cell} in @arg{skel}.
  • Function GET-CELL-PROPERTY (cell skel property)
    Returns the value of the property.
  • Function (setf GET-CELL-PROPERTY) (value cell skel property)
    Sets the value of the property.
  • Generic-Function IDENTIFIED-CELLS (cell skel)
    Returns a list of cells in @arg{skel} which are identified with @arg{cell}.
  • Function INSERT-CELL! (skel cell &optional properties)
    Inserts @arg{cell} and if necessary also its boundary into @arg{skel}. If properties are given those are used for @arg{cell}.
  • Function INSERT-CELLS! (skel cells)
    Inserts a list of cells into a skeleton.
  • Method SKELETON ((cells sequence))
  • Method SKELETON ((cell <cell>))
  • Function SKEL-FOR-EACH (func skel &key direction dimension where with-properties)
    Loops through a skeleton applying func. When direction is :down then loops with dimension of the cells decreasing, otherwise increasing.
  • Macro DOSKEL ((looping-var skel &key (direction :up) where dimension) &body body)
    Loop through a skeleton. If looping-var is an atom, it loops through all cells, otherwise it loops through cells and properties.
  • Function NR-OF-CELLS (skel &optional dimension)
    Returns number of cells in a skeleton.
  • Function SKEL-EMPTY-P (skel)
  • Function CELLS-OF-DIM (skel dim)
    Returns the cells of @arg{skel} of dimension @arg{dim} in form of a list.
  • Function CELLS-OF-HIGHEST-DIM (skel)
    Returns the cells of @arg{skel} of highest dimension in form of a list.
  • Function MARK-SKELETON (skel prop value)
    Marks all cells of @arg{skel} with the given @arg{prop}/@arg{value} pair.
  • Generic-Function SKEL-MAP (func skel)
    Maps a skeleton with func to another skeleton having the same keys and mapped values. May be configured later on.
  • Method SKEL-MAP (func skel)
  • Method SKEL-MAP (func skel)
  • Method SKEL-MAP (func skel)
  • Function FIND-CELLS (test skel &key dimension with-properties where)
    Returns a list of cells contained in skel and satisfying test.
  • Function FIND-CELL (test skel &rest rest)
  • Generic-Function FIND-CELL-FROM-POSITION (skel pos)
    Finds a cell from @arg{skel} which contains the global position @arg{pos}.
  • Method FIND-CELL-FROM-POSITION ((skel <skeleton>) (pos array))
  • Function FIND-CELL-FROM-CORNERS (skel corners)
  • Method EMBEDDED-DIMENSION ((skel <skeleton>))
  • Generic-Function DIMENSION-OF-PART (skel part)
    Parts of a skeleton can be named with the property @symbol{:part}.
  • Method DIMENSION-OF-PART ((skel <skeleton>) part)
  • Method DIMENSION-OF-PART ((skel <skeleton>) part)
  • Method DIMENSION-OF-PART ((skel <skeleton>) part)
  • Function SKELETON-BOUNDARY (skel)
    Returns a skeleton consisting of cells of skel of dimension n-1 which have only one neighbor.
  • Function IDENTIFICATION-P (object)
  • Function CELL-IDENTIFICATION (cell skel)
    Returns @arg{cell}'s identification in @arg{skel} or NIL.
  • Function (setf CELL-IDENTIFICATION) (identification cell skel)
  • Function IDENTIFIED-P (cell skel)
    Returns @arg{cell}'s identification in @arg{skel} or NIL.
  • Generic-Function REPRESENTATIVE (obj)
    Returns a representative for this object.
  • Method REPRESENTATIVE ((id identification))
    Gets a representative cell for this identification.
  • Method REPRESENTATIVE ((id identification))
    Gets a representative cell for this identification.
  • Method REPRESENTATIVE ((id identification))
    Gets a representative cell for this identification.
  • Method REPRESENTATIVE (obj)
    This default method returns the object itself.
  • Method REPRESENTATIVE (obj)
    This default method returns the object itself.
  • Method REPRESENTATIVE (obj)
    This default method returns the object itself.
  • Method IDENTIFIED-CELLS (cell skel)
  • Function IDENTIFY (identified-cells skel)
    Identifies all cells in @arg{identified-cells} within @arg{skel}.
  • Function KEY-IS-SUBCELL-P (key1 key2)
    Checks if @arg{key1} occurs as subcell of @arg{key2}. The keys can be either cells or identifications.
  • Function BOUNDARY-IDENTIFICATIONS (identifications)
    Returns an identification list for the boundaries of the cells in identifications.
  • Function COMBINE-IDENTIFICATIONS (sets)
    Reduces identifications to maximally connected sets.
  • Function ITERATE-IDENTIFICATIONS (initial-identifications)
    Generates all identifications of the skeleton from the identifications of some higher-dimensional cells.
  • Function IDENTIFY-UNIT-CELL-FACES (skel &key (indices :all))
    This routines identifies boundary cells in skel which correspond to boundary cells in the unit cube. Warning: exact arithmetic is used to recognize identified cells. This should work for skeletons derived from the unit cell, but may create problems in other situations.
  • Class REFINEMENT-RULE
    Rule for refining reference cells. Those rules are stored in the refine-info slot of the cell class.
    NAMES   Reader: NAMES
    Names identifying the rule.
    REFCELL   Reader: REFERENCE-CELL
    Reference cell for this refinement rule.
    BOUNDARY-REFINEMENT-RULES   Reader: BOUNDARY-REFINEMENT-RULES
    Refinement rules for the sides required by this rule.
    REFINEMENT-INFO   Reader: REFINEMENT-INFO
    Vector of refinement information for the children.
  • Function GET-REFINEMENT-RULE (cell id)
    Finds the refinement rule for @arg{cell} defined by the @arg{id}. This @arg{id} can be a number (position of the rule, T (meaning 0), or some symbol which is contained in the names of some rule. Two values are returned: the rule and its position in the refinement-rule vector.
  • Function (setf GET-REFINEMENT-RULE) (rule cell id)
  • Function REFINED-P (cell skeleton)
  • Function CHILDREN (cell skeleton)
  • Function REFINEMENT (cell skeleton)
    Returns the refinement of @arg{cell} in @arg{skeleton} as two values: the rule and the children.
  • Function REFINEMENT-RULE (cell skel)
    Returns the refinement rule of @arg{cell} in @arg{skel}.
  • Function (setf CHILDREN) (child-vec cell skeleton)
  • Function PARENT (cell skeleton)
  • Function (setf PARENT) (parent cell skeleton)
  • Function REFCELL-REFINEMENT-SKELETON (refcell &optional (level 1) (rule 0) reinit)
    Returns an LEVEL times refined skeleton of REFCELL. It is partially memoized, see the documentation of *REFCELL-REFINEMENT-MEMOIZE-DEPTH*.
  • Function SUBCELL-CHILDREN (cell skeleton)
    Returns a vector of all children of the subcells of @arg{cell} in @arg{skeleton}.
  • Function INNER-REFCELL-CHILDREN (refcell rule)
    Returns the children of refcell.
  • Function REFCELL-CHILDREN (refcell rule)
    Returns the children for refcell and subcells.
  • Generic-Function REFINE (skel &key indicator &allow-other-keys)
    Refines @arg{skel} either locally or globally depending on the @function{indicator}.
  • Method REFINE ((skel <skeleton>) &key (indicator (constantly t)) highest (decouple t))
    Refines the cells of @arg{skel} indicated by @arg{indicator}. Returns two values: the first is the refined skeleton, the second is the refinement which is a skeleton for the old mesh referencing the refinement vectors. This refinement algorithm usually makes sense only for global refinements. Local refinements should be done with hierarchical-mesh structures.
  • Method BOUNDARY ((vtx <vertex>))
    Returns the empty boundary for vertices.
  • Method BOUNDARY ((vtx <vertex>))
    Returns the empty boundary for vertices.
  • Function MAKE-VERTEX (position &optional mapping)
    General vertex constructor.
  • Method VERTICES ((vtx <vertex>))
  • Method CELL-MAPPING ((vtx <vertex>))
    For vertices, this returns a <special-function> evaluating to the vertex position.
  • Method L2G ((vtx <vertex>) local-pos)
    Same as local->global for vertices.
  • Method L2DG ((vtx <vertex>) local-pos)
  • Method LOCAL->DGLOBAL ((vtx <vertex>) local-pos)
    Not perfect, should take mapping into account.
  • Method G2L ((vtx <vertex>) global-pos)
  • Method GLOBAL->LOCAL ((vtx <vertex>) global-pos)
  • Method GLOBAL->LOCAL ((vtx <mapped-vertex>) global-pos)
  • Method LOCAL-COORDINATES-OF-MIDPOINT ((cell <vertex>))
  • Function MAKE-CELL-FROM-VERTICES (cell-class vertices)
    Creates a cell of class CELL-CLASS having the given VERTICES.
  • Function MAKE-CELL-FROM-CORNERS (cell-class corners)
    Creates a cell of class CELL-CLASS having the given CORNERS.
  • Variable *REFERENCE-VERTEX*
    (let ((fl.mesh::refcell (fl.mesh:make-vertex (fl.matlisp:double-vec))))
      (fl.mesh::initialize-cell-class fl.mesh::refcell nil)
      fl.mesh::refcell)
    The reference vertex.
  • Class <SIMPLEX>
    A mixin for simplicial cells.
    No slots.
  • Function SIMPLEX-P (obj)
  • Method VERTICES ((simplex <simplex>))
  • Method L2DG ((simplex <simplex>) local-pos)
    Returns the linear transformation defined by the coordinates of the simplex corners.
  • Method LOCAL-COORDINATES-OF-MIDPOINT ((cell <simplex>))
  • Method CELL-MAPPING ((cell <simplex>))
    For non-mapped simplices, the cell mapping is linear.
  • Function SIMPLEX-CLASS (dim &optional mapped distorted)
    Returns the n-simplex class.
  • Function N-SIMPLEX (dim)
    Returns the reference simplex of the given dimension.
  • Variable *UNIT-INTERVAL*
    (fl.mesh::ensure-simplex 1)
  • Variable *UNIT-TRIANGLE*
    (fl.mesh::ensure-simplex 2)
  • Variable *UNIT-TETRAHEDRON*
    (fl.mesh::ensure-simplex 3)
  • Function MAKE-SIMPLEX (boundary &key (check t) mapping)
    Short form of creating a simplex given its boundary. An alternative is creating it from its vertices, see the functions MAKE-CELL-FROM-VERTICES and INSERT-CELL-FROM-CORNERS.
  • Function MAKE-LINE (from-vtx to-vtx &key (check t) mapping)
    Creates a line given its endpoints.
  • Class <PRODUCT-CELL>
    A mixin for simplex-product cells.
    No slots.
  • Generic-Function CARTESIAN-PRODUCT (obj1 obj2 &key &allow-other-keys)
    Computes the cartesian product of two skeletons.
  • Method CARTESIAN-PRODUCT ((cell1 <cell>) (cell2 <cell>) &key &allow-other-keys)
  • Method CARTESIAN-PRODUCT ((cell1 <cell>) (cell2 <cell>) &key &allow-other-keys)
  • Method CARTESIAN-PRODUCT ((cell1 <cell>) (cell2 <cell>) &key &allow-other-keys)
  • Method CARTESIAN-PRODUCT ((skel1 <skeleton>) (skel2 <skeleton>) &key property-combiner &allow-other-keys)
    Computes the cartesian product of two skeletons.
  • Method CARTESIAN-PRODUCT ((skel1 <skeleton>) (skel2 <skeleton>) &key property-combiner &allow-other-keys)
    Computes the cartesian product of two skeletons.
  • Method CARTESIAN-PRODUCT ((skel1 <skeleton>) (skel2 <skeleton>) &key property-combiner &allow-other-keys)
    Computes the cartesian product of two skeletons.
  • Method VERTICES ((cell <product-cell>))
  • Method LOCAL-COORDINATES-OF-MIDPOINT ((cell <product-cell>))
  • Function ENSURE-SIMPLEX-PRODUCT (factor-dims)
    Returns the reference product-cell for the given factor dimensions.
  • Function N-CUBE (dim)
    Returns the reference cube of dimension dim.
  • Function CUBE-P (cell)
    Returns T iff CELL is a cube.
  • Function CELL->CUBE (cell)
    Transforms a product-cell into a degenerated cube with the same vertices.
  • Variable *UNIT-QUADRANGLE*
    (fl.mesh:n-cube 2)
  • Variable *UNIT-CUBE*
    (fl.mesh:n-cube 3)
  • Generic-Function SUBSKELETON (skel test)
    Returns a minimal skeleton containing the cells satisfying the test.
  • Method SUBSKELETON ((skel <skeleton>) test)
  • Method SUBSKELETON ((skel <skeleton>) test)
  • Method SUBSKELETON ((skel <skeleton>) test)
  • Function SKELETON-WITHOUT-CELL (skel cell-to-remove)
    Removes a cell from a skeleton such that the rest remains a skeleton. Warning: does not handle identifications yet.
  • Function COPY-SKELETON (skel &key properties transformation)
    Copies a skeleton. Properties is a list of properties to be copied.
  • Function REFINED-SKELETON-COPY (skel &optional (refinements 0))
  • Function INSERT-CELL-FROM-CORNERS (mesh corners->cell cell-class corners properties &key (create-subcells t))
    Creates a cell of type cell-class with corners given by corners. corners->cell has to be an equalp hash-table mapping corners to the corresponding cell. It is updated by this function.
  • Function STRUCTURED-SKELETON (n h &key corners->cell)
    Create a uniform box skeleton consisting of N_1 x ... x N_dim cubes of dimensions h_1 x ... x h_dim.
  • Function SKELETON-DISJOINT-UNION (&rest skels)
    Builds a disjoint union skeleton of all skeletons.
  • Function SKEL-ADD! (skel-1 skel-2 &key (override nil) threshold active-skel-1)
    Adds @arg{skel-2} to @arg{skel-1} destructively for @arg{skel-1}. Overlaying cells are identified. @arg{override} is a list of properties which are copied from skel-2 on the overlap. @arg{active-skel-1} is used for hierarchical-meshes for selecting a level to which @arg{skel-2} is added. This function returns three values: the first is @arg{skel-1}, the second is @arg{skel-2}, the third is a hash-table mapping overlapping cells from @arg{skel-2} to their counterpart in @arg{skel-1}.
  • Function TRANSFORMED-SKELETON (skel &key transformation properties)
    Transforms skel by transforming the cell mappings resp. vertex positions.
  • Function LINEARLY-TRANSFORMED-SKELETON (skel &key a b properties)
    Transforms skel by transforming the vertex positions.
  • Function SHIFT-SKELETON (skel shift &key properties)
    Shifts skel by vec. vec has to be a vector of dimension (embedded-dimension skel).
  • Function TELESCOPE (left-skel left->right)
  • Class <DOMAIN>  (<SKELETON>, PROPERTY-MIXIN)
    A @class{<domain>} is a special @class{<skeleton>}. We call its cells @emph{patches}, and the properties of a patch carries geometric information. Properties supported up to now are: @itemize @item @code{IDENTIFIED}: @emph{list of identified patches} @item @code{EXTENSION}: @emph{extender} @item @code{METRIC}: @emph{metric tensor function} @item @code{VOLUME}: @emph{volume function} @end itemize Metric and volume should be functions depending on keyword arguments like @code{:LOCAL} and @code{:GLOBAL} and allowing arbitrary other keys.
    CLASSIFIERS
    A list of functions of two arguments -patch and classifications so far- which are called from the right to classify the patch.
  • Function DOMAIN-BOUNDARY (domain)
    The boundary of the domain as a skeleton.
  • Function PATCH-CLASSIFICATION (patch domain)
    Returns a list of classifications for @arg{patch} in @arg{domain}.
  • Function MAKE-DOMAIN (skel &rest args)
    Changes a skeleton into a domain.
  • Function TEST-CONDITION (condition classifications)
    Test if @arg{condition} holds for @arg{classifications}. @arg{condition} should be a logical combination of the keyword symbols in the list @arg{classification}.
  • Function FIND-PATCH (domain classifiers &key midpoint)
    Searches for a patch of @arg{domain} having the given list @arg{classifiers}.
  • Function MAKE-CLASSIFIER (test classification)
    Returns a classifier for patches.
  • Function DOMAIN-CHARACTERISTICS (domain)
    Returns a property list of characteristics. The property curved means that curved patches exist. The property exact is set to t if the domain mappings are exact. Otherwise, only the boundary of the domain should be assumed to be provided in an exact form.
  • Function N-SIMPLEX-DOMAIN (dim)
  • Function SIMPLEX-PRODUCT-DOMAIN (dims)
    Generates a product-cell domain for the given factor dimensions.
  • Function N-CUBE-DOMAIN (dim)
  • Function ENSURE-DOMAIN (domain)
    If @arg{domain} is an integer, return the corresponding @arg{n-cube-domain}, if @arg{domain} is a domain return it unchanged, otherwise signal an error.
  • Function BOX-DOMAIN (dimensions)
    Generates a box domain for the given dimensions. Here, dimensions is expected to be a list of 2-element lists denoting the interval along the respective axis. The algorithm works by copying the unit cube and modifying the coordinates of the vertices of the copy.
  • Function N-CELL-DOMAIN (dim)
    Generates an n-dimensional cell domain which is a n-dimensional unit cube with its opposite sides identified.
  • Function N-BALL-DOMAIN (dim)
    Generates an n-dimensional ball domain with 2^n simplex patches.
  • Function TRIANGLE-DOMAIN (corner1 corner2 corner3)
  • Function L-DOMAIN (dim)
    Creates an L-domain by cutting out cubes from the uniform refinement of the unit cube.
  • Class <MESH>  (<SKELETON>)
    A <mesh> is a special <skeleton> mapping cells to property lists with properties of the cell. The most important property of a cell is its patch in the domain. Another one could be a list of possibly identified cells. The slot parametric determines which kind of cell mappings are used for approximating the domain. These can be the nonlinear mappings used in the domain definition, but also arbitrary approximations, to those mappings, e.g. isoparametric mappings. The special value NIL means that multilinear mappings are used for all cells outside the boundaries.
    DOMAIN   Reader: DOMAIN
    The domain of the mesh.
    PARAMETRIC   Reader: PARAMETRIC
  • Function PATCH-OF-CELL (cell mesh)
  • Function (setf PATCH-OF-CELL) (value cell mesh)
  • Method DIMENSION-OF-PART ((mesh <mesh>) part)
    Parts of a skeleton can be named with the property @symbol{:part}.
  • Generic-Function MESHSIZE (mesh)
    Computes a meshsize. Please refer to the method documentations for the exact definition.
  • Method MESHSIZE ((mesh <mesh>))
    Computes a meshsize as the size of the longest edge in the mesh.
  • Method MESHSIZE ((mesh <mesh>))
    Computes a meshsize as the size of the longest edge in the mesh.
  • Method MESHSIZE ((mesh <mesh>))
    Computes a meshsize as the size of the longest edge in the mesh.
  • Class <HIERARCHICAL-MESH>  (<MESH>)
    Hierarchical-meshes are those meshes which will be used most often, because they remember the refinement history and therefore allow for refinement and coarsening. The slot levels is an array of skeletons containing the cells for different levels.
    LEVELS   Accessor: LEVELS
  • Function CELLS-ON-LEVEL (mm level)
  • Function NR-OF-LEVELS (mm)
  • Function BOTTOM-LEVEL-CELLS (mm)
  • Generic-Function TOP-LEVEL (mh)
    Top-level of a mesh hierarchy.
  • Method TOP-LEVEL ((mm <hierarchical-mesh>))
  • Method TOP-LEVEL ((mm <hierarchical-mesh>))
  • Method TOP-LEVEL ((mm <hierarchical-mesh>))
  • Function TOP-LEVEL-CELLS (mm)
  • Function LEVEL-OF-CELL (cell h-mesh)
    Returns the level of @arg{cell} in the hirearchical mesh @arg{h-mesh}.
  • Method REFINE ((h-mesh <hierarchical-mesh>) &key (indicator (constantly t)))
    Refine a hierarchical-mesh. When the argument 'test' is supplied, all cells satisfying the test are refined.
  • Function REFINEMENT-INTERFACE (h-mesh &key level)
    Returns the refined boundary subcells of unrefined cells in a skeleton. Those cells are found as all refined cells which are not part of the domain boundary. At the moment, this is a global operation. Later on, it should probably be localized.
  • Function HIERARCHICALLY-ORDERED-CELLS (h-mesh &key (where :surface) level)
    Sorts the cells up to the given level (defaulting to the last level) hierarchically for use in something similar to the nested disection method. Returns a list of the sorted cells.
  • Function FOR-EACH-CELL-OF-HIGHEST-DIMENSION-ON-SURFACE (func h-mesh)
    Calls func for each cell on the hierarchical-mesh surface.
  • Function SURFACE-CELLS-OF-DIM (h-mesh dim)
    This function returns the surface cells of a locally refined hierarchical-mesh structure.
  • Function SURFACE-CELLS-OF-HIGHEST-DIM (h-mesh)
    This function returns the surface cells of highest dimension of a locally refined hierarchical-mesh structure.
  • Function NR-OF-SURFACE-CELLS (h-mesh)
  • Method FIND-CELL-FROM-POSITION ((h-mesh <hierarchical-mesh>) (pos array))
    Hierarchical search for a leaf cell containing the given position. A result of NIL is given if no cell covering @arg{pos} is found.
  • Generic-Function MAKE-MESH-FROM (object &key &allow-other-keys)
    Makes a mesh from or for the given object.
  • Method MAKE-MESH-FROM ((domain <domain>) &key parametric (initial-mesh-refinements 0) &allow-other-keys)
    This function creates a mesh on the domain skeleton. The mesh either uses the nonlinear mappings of the domain patches (for parametric = :from-domain) or approximates those with polygonal (parametric = nil) or isoparametric mappings. Note that the boundary always uses the domain mappings. The parameter @arg{base-level} can be used when starting from a refined mesh as base-level is desired. This can be used when the mesh derived from the domin definition is too coarse which may be the case especially when it is used in the context of a domain decomposition.
  • Function COPY-MESH (mesh)
    Copies a mesh. Properties copied are only patch and identification. If necessary, one might add further properties to be copied as a keyword argument.
  • Function UNIFORMLY-REFINED-MESH (domain n &key parametric)
    Generates a mesh by refining the domain partition uniformly.
  • Function SPECIAL-MESH-ON-BOX-DOMAIN (domain patch->mesh-sizes)
    Creates a uniform mesh consisting of N_1 x ... x N_dim cells on a box domain.
  • Function UNIFORM-MESH-ON-BOX-DOMAIN (domain n)
    Creates a uniform mesh consisting of N_1 x ... x N_dim cells on a box domain.
  • Generic-Function MAKE-HIERARCHICAL-MESH-FROM-DOMAIN (domain &key &allow-other-keys)
    Construct a hierarchical-mesh from a domain.
  • Method MAKE-HIERARCHICAL-MESH-FROM-DOMAIN (domain &rest key-args &key &allow-other-keys)
    Construct a hierarchical-mesh from a domain.
  • Function MAKE-HIERARCHICAL-MESH-FROM (&rest args)
    Creates a hierarchical-mesh from the given arguments. See @function{MAKE-MESH-FROM}.
  • Method MAKE-HIERARCHICAL-MESH-FROM-DOMAIN (domain &rest key-args &key &allow-other-keys)
    Construct a hierarchical-mesh from a domain.
  • Function UNIFORMLY-REFINED-HIERARCHICAL-MESH (domain level &rest key-args &key &allow-other-keys)
  • Function COMPARE-LEXICOGRAPHICALLY (&key (fuzzy 1.d-12) direction)
    Returns a function which compares two vectors lexicographically.
  • Function SORT-LEXICOGRAPHICALLY (elist &key (fuzzy 1.d-12))
    Sorts a cell list lexicographically by the coordinates of their midpoint.
  • Function TRIANGULIZE (mesh)
    Transforms a product-cell mesh into a simplex mesh.
  • Class <BOUNDARY-CELL>  (<CELL-WITH-BOUNDARY>)
    This cell is only fuzzily defined. Its use is mostly for defining domains by their boundary. The slot @slot{midpoint} can be useful for the graphical output of the cell, the slot @slot{holes} contains a list of points lying inside holes. This is intended as help for triangulation programs.
    DIMENSION   Reader: DIMENSION
    MIDPOINT   Reader: MIDPOINT
    HOLES   Reader: HOLES
  • Method SUBCELLS ((cell <boundary-cell>))
  • Function TRIANGULATE (domain &rest args &key parametric (check-p t) &allow-other-keys)
    Triangulate @arg{domain} by successively building a mesh on the domain skeleton starting from the 0-dimensional patches.
  • Function EXTEND (mesh &key (test (constantly t)))
    Extends a mesh on all extensible cells for which test ---if provided--- yields T.
  • Function STANDARD-EXTENDER (original-cell replacement)
    Extension function replacing an original-cell with a replacement.
  • Function CUBE-EXTENDER (domain-cube direction)
    Makes domain-cube ---which should be a cube in a domain--- extensible in the given direction.

Also exports

  • FL.UTILITIES:CHECK

FL.PROBLEM

 The @package{FL.PROBLEM} package introduces the
general class @class{<problem>} and some subclasses.  The most interesting
subclass is @class{<pde-problem>}.  A @class{<pde-problem>} is defined on a
domain and provides a table mapping the domain patches to property lists
containing the coefficient functions.

Several subclasses of @class{<pde-problem>} are defined in own packages,
e.g. @class{<cdr-problem>} in @package{FL.CDR},
@class{<elasticity-problem>} in @package{FL.ELASTICITY} and
@class{<navier-stokes-problem} in @package{FL.NAVIER-STOKES}.
  • Class <PROBLEM>  (PROPERTY-MIXIN)
    Base class for all problems.
    No slots.
  • Generic-Function LINEAR-P (problem)
    Predicate determining if a problem is linear or nonlinear.
  • Method LINEAR-P ((problem <problem>))
  • Method LINEAR-P ((problem <problem>))
  • Method LINEAR-P ((problem <problem>))
  • Generic-Function ENSURE-RESIDUAL (problem blackboard)
    Ensures that the field :RESIDUAL is computed and that the flag :RESIDUAL-P is set on the blackboard.
  • Generic-Function ENSURE-SOLUTION (problem blackboard)
    Ensures that the field :SOLUTION is set on the blackboard.
  • Method ENSURE-SOLUTION (problem blackboard)
    Default method throws an error.
  • Method ENSURE-SOLUTION (problem blackboard)
    Default method throws an error.
  • Method ENSURE-SOLUTION (problem blackboard)
    Default method throws an error.
  • Method ENSURE-SOLUTION (problem blackboard)
    This :around method takes the field :SOLUTION from the blackboard.
  • Method ENSURE-RESIDUAL (problem blackboard)
    This default method handles nonlinear problems by linearizing them and computing the residual for it. The resulting problem is additionally stored in a field :LINEAR-PROBLEM.
  • Class <LSE>  (<PROBLEM>)
    Standard form of a linear system of equations.
    MATRIX   Reader: MATRIX
    RHS   Reader: RHS
  • Function LSE (&rest args)
    Constructs a standard LSE.
  • Generic-Function LINEARIZE (problem solution)
    Linearize the nonlinear problem PROBLEM at the point SOLUTION. The result should be a linear problem.
  • Method LINEARIZE (problem solution)
    This default method throws an error for nonlinear problems and is the identity on linear problems.
  • Method LINEARIZE (problem solution)
    This default method throws an error for nonlinear problems and is the identity on linear problems.
  • Method LINEARIZE (problem solution)
    This default method throws an error for nonlinear problems and is the identity on linear problems.
  • Method ENSURE-SOLUTION ((lse <lse>) blackboard)
  • Method ENSURE-RESIDUAL ((lse <lse>) blackboard)
  • Class <NONLINEAR-PROBLEM>  (<PROBLEM>)
    Class for nonlinear problems. The linearization contains a function returning a linear problem.
    LINEARIZATION
    A function linearizing the problem.
    SOLUTION
    An approximation to the solution.
  • Method LINEARIZE ((problem <nonlinear-problem>) solution)
  • Method ENSURE-SOLUTION ((nlpb <nonlinear-problem>) blackboard)
  • Class <NLSE>  (<NONLINEAR-PROBLEM>)
    Class for nonlinear system of equations.
    No slots.
  • Function NLSE (&rest args)
    Constructs a standard NLSE.
  • Class <COEFFICIENT>  (PROPERTY-MIXIN)
    The coefficient class.
    NAME   Accessor: COEFFICIENT-NAME
    DIMENSION   Reader: DIMENSION
    The dimension of the cell on which this coefficient is active. The value T means that it is active on all cells lying on the patch. The default value NIL means that it is active on cells with the same dimension as the patch.
    DEMANDS   Reader: DEMANDS
    A list indicating which information the evaluation function needs. Possible choices depend on problem and discretization, e.g. @code{:local}, @code{:global}, @code{:fe}, @code{:cell} are possible choices. One element can also be a list starting with the keyword @code{:fe-parameters} and followed by symbols indicating names of finite element functions on the discretization blackboard.
    EVAL   Accessor: COEFF-EVAL
    The evaluation funtion. It accepts a list of keyword parameters which should correspond to the list in DEMANDS.
    RESIDUAL
    T means evaluation for computing the residual.
    JACOBIAN
    T means evaluation for computing the Jacobian.
  • Function GET-COEFFICIENT (coeffs name)
    Get coefficient @arg{name} from the list @arg{coeffs}.
  • Method DEMANDS ((coeffs list))
    Returns unified demands for all coefficients in the list.
  • Function COPY-COEFFICIENT (coeff &key demands name eval)
  • Function CONSTANT-COEFFICIENT (name value &rest other-values)
    Returns a coefficient which takes the given value. Several values can be passed which is needed, for example, for returning also the type of a boundary condition.
  • Function CONSTRAINT-COEFFICIENT (components multiplicity)
    Returns a coefficient function which sets Dirichlet zero boundary conditions for all components of a PDE system.
  • Generic-Function ZERO-CONSTRAINTS (problem)
    Returns a coefficient function which constrains all system components to zero.
  • Method ZERO-CONSTRAINTS (problem)
  • Method ZERO-CONSTRAINTS (problem)
  • Method ZERO-CONSTRAINTS (problem)
  • Function IDENTIFICATION-COEFFICIENT (master mapping)
    A special coefficient used for identifying parts of the domain. The coefficient evaluation returns the master coordinates.
  • Function CONSTRAINT-P (coeff)
  • Function REQUIRED-FE-FUNCTIONS (coeffs)
    Returns a list of finite element functions required by the coefficients in the property list @arg{coeffs}.
  • Function ADD-FE-PARAMETERS-DEMAND (demands new-paras)
    Adds a list of fe-functions to the demands.
  • Function FX->COEFFICIENT (name func)
    The function argument @arg{func} is transformed into a coefficient depending on global coordinates.
  • Function FU->COEFFICIENT (name func)
    The function argument @arg{func} is transformed into a coefficient depending on the solution.
  • Function FXU->COEFFICIENT (name func)
    The function argument @arg{func} is transformed into a coefficient depending on position and solution.
  • Function FUNCTION->COEFFICIENT (name func)
  • Function ENSURE-COEFFICIENT (name obj)
    Returns @arg{obj} if it is a coefficient, converts @arg{obj} into a coefficient depending on the space variable if @arg{obj} is a function; otherwise, @arg{obj} is made into a constant coefficient.
  • Class <DOMAIN-PROBLEM>  (<PROBLEM>)
    An instance of this class describes a problem posed on @slot{domain} with coefficients given on each patch of the domain. The slot @slot{multiplicity} is a positive integer which denotes the number of right-hand sides and solutions (e.g. when computing several eigenvectors at once).
    DOMAIN   Reader: DOMAIN
    COMPONENTS   Reader: COMPONENTS
    A list whose elements are lists of the form (symbol dim) or (symbol dim type) or (symbol subcomponents) describing the components occuring in the pde. Alternatively, this slot can contain a function/dictionary mapping patches to such lists.
    MULTIPLICITY   Reader: MULTIPLICITY
    Multiplicity of the right-hand side.
    COEFFICIENTS   Accessor: COEFFICIENTS
    A function mapping patches to coefficient lists.
  • Function EXTRACTION-INFORMATION (components component)
    If @arg{component} is in @arg{components}, a triple consisting of position, length, and a flag is returned. The flag is true, if the component is a scalar.
  • Function COMPONENT-POSITION (components comp)
    Translates a symbol denoting a component to a position.
  • Generic-Function NR-OF-COMPONENTS (problem)
    Returns the number of components for @arg{problem}.
  • Method NR-OF-COMPONENTS ((problem <domain-problem>))
    Counts the number of components.
  • Method NR-OF-COMPONENTS ((problem <domain-problem>))
    Counts the number of components.
  • Method NR-OF-COMPONENTS ((problem <domain-problem>))
    Counts the number of components.
  • Function COMPONENTS-OF-PATCH (patch problem)
    Reader for the components of @arg{problem} on @arg{patch}.
  • Function (setf COMPONENTS-OF-PATCH) (value patch problem)
    Writer for the components of @arg{problem} on @arg{patch}.
  • Generic-Function COMPONENTS-OF-CELL (cell mesh problem)
    Returns the components of @arg{problem} on @arg{cell}.
  • Method COMPONENTS-OF-CELL (cell mesh problem)
  • Method COMPONENTS-OF-CELL (cell mesh problem)
  • Method COMPONENTS-OF-CELL (cell mesh problem)
  • Function COEFFICIENTS-OF-PATCH (patch problem)
    Reader for the coefficients of @arg{patch} for @arg{problem}.
  • Generic-Function COEFFICIENTS-OF-CELL (cell mesh problem)
    Returns the coefficients of @arg{problem} on @arg{cell}.
  • Method COEFFICIENTS-OF-CELL (cell mesh problem)
    Default method, returns the coefficients of the associated patch.
  • Method COEFFICIENTS-OF-CELL (cell mesh problem)
    Default method, returns the coefficients of the associated patch.
  • Method COEFFICIENTS-OF-CELL (cell mesh problem)
    Default method, returns the coefficients of the associated patch.
  • Function FILTER-APPLICABLE-COEFFICIENTS (coeffs cell patch &key (constraints t))
    Filters out the applicable coefficients for the respective cell with the given patch.
  • Class <INTERPOLATION-PROBLEM>  (<DOMAIN-PROBLEM>)
    Interpolation problem on a domain. The function which is to be interpolated is given as a coefficient with key FUNCTION in the coefficient list.
    No slots.
  • Class <PDE-PROBLEM>  (<DOMAIN-PROBLEM>)
    Base-class for a pde-problem.
    No slots.
  • Generic-Function DUAL-PROBLEM (problem functional)
    Returns the dual problem for @arg{problem} with the right-hand side given by @arg{functional}. The solution of this problem measures the sensitivity of @arg{functional} applied to the solution of problem with respect to errors in the solution.
  • Generic-Function SELF-ADJOINT-P (problem)
    Returns two values. The first says if @arg{problem} is self-adjoint, the second says if that value has really been checked.
  • Method SELF-ADJOINT-P (problem)
    The default method says that @arg{problem} is not self-adjoint and that no check has been performed.
  • Method SELF-ADJOINT-P (problem)
    The default method says that @arg{problem} is not self-adjoint and that no check has been performed.
  • Method SELF-ADJOINT-P (problem)
    The default method says that @arg{problem} is not self-adjoint and that no check has been performed.
  • Generic-Function MAKE-COEFFICIENTS-FOR (problem name patch demands evaluator)
    Generates a coefficient while dispatching on problem and coefficient name. May return a single coefficient or a list of several coefficients.
  • Function EXTRACT-FROM (solution from ncomps &optional scalar-p index)
    Extracts numbers or subvectors from the solution vector.
  • Function PREPARE-COEFFICIENT-ARGUMENTS (components args)
    Prepares arguments for the given coefficient function.
  • Method MAKE-COEFFICIENTS-FOR ((problem <pde-problem>) coeff-name patch args eval)
  • Macro COEFF (name args &body body)
    A local @mac{coeff} defines a coefficient function inside @mac{setup-coefficients}. It is defined here at the toplevel such that the Lisp editor indents the definitions correctly.
  • Macro COEFF (name args &body body)
    A local @mac{coeff} defines a coefficient function inside @mac{setup-coefficients}. It is defined here at the toplevel such that the Lisp editor indents the definitions correctly.
  • Macro SELECT-ON-PATCH ((patch) &body clauses)
  • Macro SETUP-COMPONENTS ((patch) &body patch-definitions)
    Defines components dispatching on @arg{patch}.
  • Macro SETUP-COEFFICIENTS ((patch) &body patch-definitions)
    Defines coefficients dispatching on @arg{patch}.
  • Macro CREATE-PROBLEM (type (&key domain components (multiplicity 1) properties) &body body)
    Creates a PDE problem. @arg{type} is the type of the problem which can be the name of a problem class or a list of class names. @arg{domain} is the domain for this problem, @arg{multiplicity} is the multiplicity of the solution, e.g. the number of eigenvectors we search for. In @arg{body}, patch-dependent coefficients should be defined with @mac{setup-coefficients}. It is also possible to define patch-dependent components with @mac{setup-components}.
  • Class <EVP-MIXIN>
    A mixin for eigenvalue problems.
    MULTIPLICITY   Reader: MULTIPLICITY
    The multiplicity of the eigenspace.
    EIGENVALUES
    The current approximation of the eigenvalues.
    MU
    The multiplier for the system matrix.
  • Class <EVP>  (<EVP-MIXIN>, <NONLINEAR-PROBLEM>)
    Standard class for discrete eigenvalue problems.
    No slots.
  • Class <LS-EVP>  (<EVP>)
    Generalized eigenvalue problem for matrices.
    STIFFNESS-MATRIX   Reader: STIFFNESS-MATRIX
    MASS-MATRIX   Reader: MASS-MATRIX
  • Generic-Function MASS (evp x)
    Evaluates the mass bilinear form for a generalized eigenvalue problem.
  • Method MASS ((evp <evp>) x)
  • Method MASS ((evp <evp>) x)
  • Method MASS ((evp <evp>) x)
  • Generic-Function ENERGY (evp x)
    Evaluates the energy bilinear form for a generalized eigenvalue problem.
  • Method ENERGY ((evp <evp>) x)
  • Method ENERGY ((evp <evp>) x)
  • Method ENERGY ((evp <evp>) x)
  • Class <TIME-DEPENDENT-PROBLEM>
    A mixin which should be used together with a <PDE-PROBLEM> in a call to MAKE-PROGRAMMATIC-INSTANCE.
    No slots.
  • Method SELF-ADJOINT-P ((problem <time-dependent-problem>))
  • Function STATIONARY-PROBLEM-CLASS (tdp)
    Finds the stationary pde problem for the time-dependent problem TDP.
  • Method MAKE-COEFFICIENTS-FOR ((problem <ellsys-problem>) (coeff (eql 'fl.ellsys::nonlinear-f)) patch args eval)
  • Method SELF-ADJOINT-P ((problem <cdr-problem>))
    The problem is assumed to be self-adjoint if there is no convection coefficient.
  • Method DUAL-PROBLEM ((problem <cdr-problem>) cell->rhs)
    Dual problem of a cdr problem. At the moment it works only for selfadjoint problems with the functional of interest being the load functional.
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::diffusion)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.ellsys:isotropic-diffusion)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::isotropic-resistance)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::convection)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::nc-convection)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr:scalar-source)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::reaction)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::scalar-nonlinear-source)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::scalar-constraint)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <cdr-problem>) (coeff (eql 'fl.cdr::initial-value)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <navier-stokes-problem>) (coeff (eql 'fl.navier-stokes::viscosity)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <navier-stokes-problem>) (coeff (eql 'fl.navier-stokes::reynolds)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <navier-stokes-problem>) (coeff (eql 'fl.navier-stokes::force)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <navier-stokes-problem>) (coeff (eql 'fl.navier-stokes::prescribed-velocity)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <navier-stokes-problem>) (coeff (eql 'fl.navier-stokes::no-slip)) patch args eval)
  • Method MAKE-COEFFICIENTS-FOR ((problem <navier-stokes-problem>) (coeff (eql 'fl.navier-stokes::pressure-bc)) patch args eval)
  • Generic-Function SELECT-SOLVER (object blackboard)
    Selects a solver for OBJECT. OBJECT is usually a problem with certain characteristics.
  • Method SELECT-SOLVER (object blackboard)
    If a solver is on the blackboard, use it.
  • Generic-Function SELECT-LINEAR-SOLVER (object blackboard)
    Selects a linear solver for OBJECT. OBJECT is usually a matrix or a linear problem with certain characteristics.
  • Method SELECT-SOLVER ((problem <problem>) blackboard)
    This method does a more specific search for linear problems by calling @function{select-linear-solver}.
  • Method SELECT-SOLVER ((lse <lse>) blackboard)
  • Method SELECT-LINEAR-SOLVER (object blackboard)
    If a linear solver is on the blackboard, use it.
  • Method SELECT-LINEAR-SOLVER (object blackboard)
    Default method selects LU decomposition.
  • Method SELECT-LINEAR-SOLVER ((lse <lse>) blackboard)
    Select linear solver based on the matrix.
  • Method SELECT-SOLVER ((problem <nonlinear-problem>) blackboard)
  • Method SELECT-SOLVER ((problem <evp>) blackboard)
  • Method NR-OF-COMPONENTS ((fe <scalar-fe>))
    For scalar components the number of components is 1.
  • Method COMPONENTS ((fe <scalar-fe>))
    The vector of components (which are scalar finite elements) of a vector finite element.
  • Method NR-OF-COMPONENTS ((fe <vector-fe>))
  • Method NR-OF-COMPONENTS ((vecfe-disc <vector-fe-discretization>))
  • Method NR-OF-COMPONENTS ((as <ansatz-space>))
  • Method SELECT-LINEAR-SOLVER ((asa <ansatz-space-automorphism>) blackboard)
    Select a suitable solver depending on the pde problem.
  • Method SELECT-LINEAR-SOLVER ((problem <cdr-problem>) blackboard)
  • Method SELECT-LINEAR-SOLVER ((problem <elasticity-problem>) blackboard)
  • Method SELECT-LINEAR-SOLVER ((problem <navier-stokes-problem>) blackboard)

Also exports

  • FL.UTILITIES:GET-PROPERTY
  • FL.MATLISP:MULTIPLICITY
  • FL.FUNCTION:COEFFICIENTS
  • FL.FUNCTION:DOMAIN-DIMENSION

FL.ELLSYS

This package contains the problem definition of systems
of convection-diffusion-reaction equations.  The system is given in the
following form which is suited for a fixed-point iteration:

@math{-div(a(x,u_old,nabla u_old) nabla u)
 + div(b(x,u_old,nabla u_old) u) +
 + c(x,u_old,nabla u_old) nabla u +
 + r(x,u_old,nabla u_old) u
= f(x,u_old, nabla u_old) 
- div(g(x,u_old, nabla u_old))
- div(a(x,u_old,nabla u_old) h(x,u_old, nabla u_old)) }

where @math{u:G to R^N}.  Note that the last two terms are introduced in
the variational formulation and imply a natural Neumann boundary condition
@math{derivative{u}{n} = (g+a h) cdot n} at boundaries where no Dirichlet
constraints are posed.
  • Class <ELLSYS-PROBLEM>  (<PDE-PROBLEM>)
    Systems of convection-diffusion-reaction equations. The coefficients should be vector-valued functions in this case.
    No slots.
  • Function ISOTROPIC-DIFFUSION (dim values)
    Returns a sparse diagonal diffusion tensor with isotropic diffusion in each component. @arg{value} should be a vector or a number and contains the amount of diffusion in each component.
  • Function ISOTROPIC-DIFFUSION-COEFFICIENT (dim values)
  • Function DIAGONAL-REACTION-COEFFICIENT (values)
  • Function ELLSYS-ONE-FORCE-COEFFICIENT (nr-comps multiplicity)
  • Function UNIT-VECTOR-FORCE-COEFFICIENT (direction)
  • Function ELLSYS-MODEL-PROBLEM (domain components &key a b c d r f g h (dirichlet nil dirichlet-p) initial sigma evp properties derived-class)
    Generates a rather general elliptic problem on the given domain.
  • Function LINEARIZATION (reaction-jet)
    Returns a list of two functions namely @math{u mapsto R(u)-DR(u)u} and @math{u mapsto -DR(u)} which can be used directly in the discretization as source and reaction term.

Also exports

  • FL.PROBLEM:NR-OF-COMPONENTS

FL.CDR

Defines convection-diffusion-reaction problems
  • Class <CDR-PROBLEM>  (<ELLSYS-PROBLEM>)
    Convection-diffusion-reaction problem.
    COMPONENTS
  • Function SCALAR-DIFFUSION (dim value)
  • Function SCALAR-SOURCE (value)
  • Function SCALAR-REACTION (value)
  • Function ENSURE-TENSOR-COEFFICIENT (name obj)
  • Function ENSURE-VECTOR-COEFFICIENT (name obj)
  • Function ENSURE-DIRICHLET-COEFFICIENT (obj)
  • Function CDR-MODEL-PROBLEM (domain &key (diffusion nil diffusion-p) (source nil source-p) (dirichlet nil dirichlet-p) gamma convection reaction sigma initial evp (multiplicity 1) properties)
    Generates a convection-diffusion-reaction model problem. Defaults are identity diffusion, right-hand-side equal 1, and Dirichlet zero boundary conditions. Ordinary function are converted into coefficient functions depending on a global coordinate. The first argument can be either a domain or an integer n which is interpreted as the n-dimensional unit cube.
  • Function CDR-NONLINEAR-RHS-PROBLEM (domain f &rest args &key source reaction &allow-other-keys)
    Returns the Newton linearization @math{-Delta u + F'(u) u = F'(u) u - F(u)} for the nonlinear problem @math{-Delta u +F(u) =0}.
  • Function BRATU-PROBLEM (dim)
    Returns a linearization for the Bratu problem @math{-Delta u +e^u =0}.

FL.ELASTICITY

Defines elasticity problems.
  • Class <ELASTICITY-PROBLEM>  (<ELLSYS-PROBLEM>)
    An elasticity problem is a special instance of an elliptic sytems.
    No slots.
  • Function ISOTROPIC-ELASTICITY-TENSOR (&key dim lambda mu)
    Returns the tensor corresponding to the Lam'e constants @math{lambda} and @math{mu}, i.e.: @math{A_{ij}^{kl} = lambda delta_{ik} delta_{jl} + mu (delta_{ij} delta_{kl} + delta_{kj} delta_{il})}.
  • Function CHECK-ELASTICITY-TENSOR (tensor dim &optional (threshold 1.d-6))
    Checks the symmetries in the elasticity tensor.
  • Function ISOTROPIC-ELASTICITY-TENSOR-COEFFICIENT (dim &optional (lambda 1.0d0) (mu lambda))
  • Function ELASTICITY-MODEL-PROBLEM (domain &key (lambda 1.0d0) (mu 1.0d0) force (dirichlet nil dirichlet-p))

FL.NAVIER-STOKES

Defines incompressible Navier-Stokes problems as a
special case of general elliptic systems.
  • Class <NAVIER-STOKES-PROBLEM>  (<ELLSYS-PROBLEM>)
    Navier-Stokes problem.
    No slots.
  • Function NO-SLIP-BOUNDARY (dim)
  • Function NAVIER-STOKES-VISCOSITY-COEFFICIENT (dim viscosity)
  • Function NAVIER-STOKES-PRESSURE-AND-CONTINUITY-COEFFICIENT (dim)
  • Function NAVIER-STOKES-INERTIA-COEFFICIENTS (dim reynolds)
    Yields a quasi-Newton linearization of the term @math{u . grad u} which has the form @math{a Re u0 . grad u + b Re u . grad u0 = (a + b - 1) Re u0 . grad u0} a and b are given by the values of the special variables @var{*alpha*} and @var{*beta*}.
  • Function STANDARD-NAVIER-STOKES-PROBLEM (domain &key (viscosity 1.0d0) (reynolds 0.0d0) force)
  • Function DRIVEN-CAVITY (dim &key (viscosity 1.0d0) (reynolds 0.0d0) smooth-p)
  • Function PERIODIC-CAVITY (dim &key (viscosity 1.0d0) (reynolds 0.0d0))

FL.ITERATION

The @package{FL.ITERATION} package includes the
definition for the abstract classes @class{<solver>},
@class{<iterative-solver>}, as well as the generic functions
@function{iterate} and @function{solve} which constitutes the interface for
linear and non-linear solving.  Both functions work on a blackboard which
is passed together with the iteration used as argument.

Several instances of iterative solvers are implemented, e.g. Gauss-Seidel,
SOR, ILU (in @file{linit.lisp}) and CG (in @file{krylow.lisp}).  A larger
block of code is contained in a separate package @package{FL.MULTIGRID} and
contains the multigrid iteration.  From this class, an algebraic multigrid
iteration is derived in @file{amg.lisp} and a geometric multigrid iteration
in a separate file @file{geomg.lisp} and package @package{FL.GEOMG}.
  • Class <ITERATION>
    The iteration base class.
    OBSERVE
    The initform depends on the subclass.
    OUTPUT
    A boolean indicating if output is to be done.
    SUCCESS-IF
    A form specifying a success criterion.
    FAILURE-IF
    A form specifying a failure criterion.
    START-TIME
    Start time of the iteration.
    SUCCESS-IF-FN
    Compiled success-if form.
    FAILURE-IF-FN
    Compiled failure-if form.
  • Variable *ITERATION-DEPTH*
    0
    Depth of nested iteration.
  • Variable *OUTPUT-DEPTH*
    0
    Maximum iteration depth for which status output is done.
  • Generic-Function ITER-FORMAT (stream control-string &rest args)
    Iteration output should be made using this function which respects *iteration-depth* and *output-depth*.
  • Method ITER-FORMAT (stream control-string &rest args)
    Default method.
  • Method ITER-FORMAT (stream control-string &rest args)
    Default method.
  • Method ITER-FORMAT (stream control-string &rest args)
    Default method.
  • Variable *TIME-OBSERVE*
    (list "   cpu" "~6,1f"
          #'(lambda (fl.utilities:blackboard)
              (fl.utilities:getbb fl.utilities:blackboard :time)))
    Observe time during an iteration. This should be used as element in the observe list of an iteration.
  • Variable *STEP-OBSERVE*
    (list "step" "~4d"
          #'(lambda (fl.utilities:blackboard)
              (fl.utilities:getbb fl.utilities:blackboard :step)))
    Observe step number during an iteration. This should be used as element in the observe list of an iteration.
  • Generic-Function INITIALLY (iter blackboard)
    Performs initial operations.
  • Generic-Function INTERMEDIATE (iter blackboard)
    Is called after initialization and after each step.
  • Generic-Function TERMINATE-P (iter blackboard)
    Tests terminating conditions. Returns either NIL or :success or :failure.
  • Generic-Function FINALLY (iter blackboard)
    Performs final operations.
  • Generic-Function NEXT-STEP (iter blackboard)
    Does a step of the iteration.
  • Generic-Function ITERATE (iter blackboard)
    Iterates on the data in the blackboard according to the iteration iter.
  • Method INITIALLY ((iter <iteration>) blackboard)
    Reset data on the blackboard.
  • Method INITIALLY ((iter <iteration>) blackboard)
    Default method. Prints the header line for observed quantities.
  • Method INTERMEDIATE ((iter <iteration>) blackboard)
    Default method. Prints observed quantities.
  • Method TERMINATE-P ((iter <iteration>) blackboard)
    Default method evaluating success-if and failure-if expressions.
  • Method NEXT-STEP ((iter <iteration>) blackboard)
  • Method NEXT-STEP ((iter <iteration>) blackboard)
    Increment step counter.
  • Method FINALLY ((iter <iteration>) blackboard)
    Setup a report and ensures fresh line on output.
  • Method ITERATE ((iter <iteration>) blackboard)
    Default method for performing an iteration. Increases indentation level and calls initialization, termination check, stepping, and finalization in the correct order.
  • Class <LINEAR-ITERATION>
    The <linear-iteration> class. Linear iterations are e.g. <gauss-seidel> or <multigrid>.
    DAMP
    STORE-P
    Store decomposition for multiple applications.
  • Class <ITERATOR>  (PROPERTY-MIXIN)
    An <iterator> object contains functions doing iteration work or flags indicating which work has or has not to be done for calling that iterator. It is generated by the generic function make-iterator.
    MATRIX
    The matrix on which the iterator is working.
    INITIALIZE
    NIL or an initialization function which is called with the solution, rhs, and residual as arguments.
    INITIALIZEDP
    Flag, if initialization has been done.
    ITERATE
    A function of the arguments solution, rhs, and residual which performs an update step.
    RESIDUAL-BEFORE
    T if the residual has to be up-to-date before the iteration step.
    RESIDUAL-AFTER
    T if the residual is updated through the iteration step.
  • Generic-Function MAKE-ITERATOR (linit mat)
    Constructs an iterator object given a linear iteration and a matrix.
  • Generic-Function COMPUTE-RESIDUAL (a x b r)
    Compute the residual r=b-Ax.
  • Method COMPUTE-RESIDUAL (a x b r)
    Default method for residual computation. Should work for everything for which the blas operations copy! and gemm! are defined.
  • Method COMPUTE-RESIDUAL (a x b r)
    Default method for residual computation. Should work for everything for which the blas operations copy! and gemm! are defined.
  • Method COMPUTE-RESIDUAL (a x b r)
    Default method for residual computation. Should work for everything for which the blas operations copy! and gemm! are defined.
  • Class <MULTI-ITERATION>  (<LINEAR-ITERATION>)
    One step of this iteration performs nr-steps of the base iteration.
    BASE
    Base iteration.
    NR-STEPS
    Number of steps with which the base iteration is performed.
  • Function PRODUCT-ITERATOR (iterator nr-steps)
    Returns an iterator which does several steps of the given iterator.
  • Method MAKE-ITERATOR ((multi-iter <multi-iteration>) mat)
    Construct an iterator for a multi-iteration.
  • Class <LU>  (<LINEAR-ITERATION>)
    A linear iteration interface for the LU exact solver.
    STORE-P
    Store decomposition for multiple applications.
  • Method MAKE-ITERATOR ((linit <lu>) mat)
    Default method for lu iteration.
  • Class <ILU>  (<LINEAR-ITERATION>)
    Incomplete LU iteration. omega is the modification parameter, eta is the diagonal enhancement.
    OMEGA
    ETA
    ORDERING
  • Method MAKE-ITERATOR ((linit <ilu>) mat)
    Default method for ILU iteration. Works only for our sparse matrices.
  • Class <JACOBI>  (<LINEAR-ITERATION>)
    No slots.
  • Method MAKE-ITERATOR ((jac <jacobi>) (mat <matrix>))
  • Method MAKE-ITERATOR ((jac <jacobi>) (mat <sparse-matrix>))
  • Variable *UNDAMPED-JACOBI*
    (make-instance 'fl.iteration:<jacobi>)
  • Class <SOR>  (<LINEAR-ITERATION>)
    OMEGA
    COMPARE
    Comparison function (COMPARE MAT I J) for sorting matrix indices I and J. The result is used as unknown ordering for the iteration.
  • Method MAKE-ITERATOR ((sor <sor>) (mat standard-matrix))
  • Method MAKE-ITERATOR ((sor <sor>) (mat <sparse-matrix>))
  • Class <PARALLEL-SOR>  (<SOR>)
    A parallel version of SOR.
    No slots.
  • Method MAKE-ITERATOR ((sor <parallel-sor>) (mat <sparse-matrix>))
  • Class <GAUSS-SEIDEL>  (<SOR>)
    The Gauss-Seidel iteration is SOR with omega=1.
    No slots.
  • Variable *GAUSS-SEIDEL*
    (make-instance 'fl.iteration:<gauss-seidel>)
  • Class <BLOCK-ITERATION>  (<LINEAR-ITERATION>)
    Subspace correction scheme generated by collecting overlapping blocks of unknowns.
    INNER-ITERATION   Reader: INNER-ITERATION
    Iteration which is used to solve for each block.
    ORDERING   Accessor: ORDERING
    STORE-P   Reader: STORE-P
    T if diagonal can be stored.
  • Generic-Function SETUP-BLOCKS (blockit matrix)
    Setup routine for determining the blocking of unknowns. Returns a list of blocks where each block is a vector of keys. May return a second value which is a list of pair. Each pair is of the form start-index/end-index and can be used to filter out different fe components.
  • Method SETUP-BLOCKS ((blockit <block-iteration>) (smat <sparse-matrix>))
    If a setup function is provided, it is called. The default is to use the standard blocking introduced by the block sparse matrix.
  • Method SETUP-BLOCKS ((blockit <block-iteration>) (smat <sparse-matrix>))
    A default around method for block setup does debugging output.
  • Class <PSC>  (<BLOCK-ITERATION>)
    Parallel subspace correction scheme.
    No slots.
  • Class <SSC>  (<BLOCK-ITERATION>)
    Successive subspace correction scheme.
    OMEGA
  • Class <CUSTOM-PSC>  (<SETUP-BLOCKS-MIXIN>, <PSC>)
    PSC with custom BLOCK-SETUP function slot.
    No slots.
  • Class <CUSTOM-SSC>  (<SETUP-BLOCKS-MIXIN>, <SSC>)
    SSC with custom BLOCK-SETUP function slot.
    No slots.
  • Method SETUP-BLOCKS ((blockit <setup-blocks-mixin>) (smat <sparse-matrix>))
    Use the setup function.
  • Method MAKE-ITERATOR ((iter <block-iteration>) (smat <sparse-matrix>))
  • Class <GRADIENT-METHOD>  (<LINEAR-ITERATION>)
    Gradient-method. Better use CG.
    No slots.
  • Method MAKE-ITERATOR ((linit <gradient-method>) mat)
    Iterator for the gradient method.
  • Class <CG>  (<LINEAR-ITERATION>)
    Preconditioned conjugate gradient iteration
    PRECONDITIONER
    RESTART-CYCLE   Reader: RESTART-CYCLE
  • Method MAKE-ITERATOR ((cg <cg>) mat)
    Standard method for the preconditioned conjugate-gradient iteration.
  • Class <BI-CGSTAB>  (<LINEAR-ITERATION>)
    Preconditioned Bi-CGStab iteration
    PRECONDITIONER
  • Method MAKE-ITERATOR ((it <bi-cgstab>) mat)
    Standard method for the preconditioned conjugate-gradient iteration.
  • Class <SOLVER>
    The base class of linear, nonlinear and whatever iterative solvers.
    OUTPUT   Reader: OUTPUT
  • Generic-Function SOLVE (solver &optional blackboard)
    Solve a problem specified on the blackboard. Returns a modified blackboard. The returned blackboard is guaranteed to contain at least the fields :solution and :status. :status is one of the values :success or :failure. SOLVE can also be called as (SOLVE blackboard) and will then try to figure out a suitable solver itself.
  • Class <ITERATIVE-SOLVER>  (<ITERATION>, <SOLVER>)
    Base class of all iterative solvers and solution strategies.
    No slots.
  • Method SOLVE ((itsol <iterative-solver>) &optional blackboard)
  • Variable *DISCRETE-ITERATIVE-SOLVER-OBSERVE*
    (list fl.iteration:*step-observe*
          (fl.iteration::float-quantity-observe "||residual||" :defnorm)
          (fl.iteration::float-quantity-observe "res[k]/res[k-1]" :step-reduction))
    Standard observe quantities for iterative solvers.
  • Method INITIALLY ((itsol <discrete-iterative-solver>) blackboard)
    Ensure an initial guess for the solution after other initializations have been done.
  • Method INTERMEDIATE ((itsolve <discrete-iterative-solver>) blackboard)
    Before printing information in the main method we ensure that the defect and its norm are up-to-date.
  • Method FINALLY ((itsolve <discrete-iterative-solver>) blackboard)
    Put convergence rate into report.
  • Class <LINEAR-SOLVER>  (<DISCRETE-ITERATIVE-SOLVER>)
    Class for linear iterative solvers.
    ITERATION   Reader: INNER-ITERATION, ITERATION
    The inner iteration.
  • Class <SAFE-LINEAR-SOLVER>  (<LINEAR-SOLVER>)
    If failure occurs, object of this class try an alternative iteration. Usually this will be a direct decomposition.
    FALLBACK   Reader: FALLBACK
    The fallback iteration.
    FALLBACK-P   Accessor: FALLBACK-P
  • Method NEXT-STEP ((itsolve <linear-solver>) blackboard)
    Stepping for a linear solver.
  • Method TERMINATE-P ((iter <safe-linear-solver>) blackboard)
    If failure occurs we continue iterating with a direct decomposition. Note that no other parameters on the blackboard are changed. Thus, success and failure have to be chosen more or less independent of the size of :step and :time.
  • Function LU-SOLVER (&key (output nil output-p))
    LU decomposition without pivoting.
  • Class <SPECIAL-SOLVER>  (<ITERATIVE-SOLVER>)
    If you happen to have a problem-adapted solver given as a function, you may use this base class.
    SOLVER-FUNCTION   Reader: SOLVER-FUNCTION
  • Method SOLVE ((solver <special-solver>) &optional blackboard)
  • Class <SOLVER-ITERATION>  (<LINEAR-ITERATION>)
    SOLVER
  • Method MAKE-ITERATOR ((solve-it <solver-iteration>) mat)
  • Function LINSOLVE (mat rhs &key sol res output iteration (residual-norm #'l2-norm) (threshold 1.d-12) reduction (maxsteps 100) success-if failure-if &allow-other-keys)
    Old and deprecated interface for solving linear problems.
  • Class <NEWTON>  (<NONLINEAR-SOLVER>)
    Class for the Newton iteration.
    No slots.
  • Method NEXT-STEP ((newton <newton>) blackboard)
    Simply calls the linear solver on the linearized problem.
  • Method NEXT-STEP ((wielandt <wielandt-iteration>) blackboard)
    Simply calls the linear solver on the linearized problem.
  • Method NEXT-STEP ((lobpcg <lobpcg>) blackboard)
  • Method MAKE-ITERATOR ((mg-it <mg-iteration>) (a <sparse-matrix>))
    This is the method for a multigrid iteration on a uniformly refined grid, or an algebraic multigrid iteration.
  • Method SETUP-BLOCKS ((blockit <geometric-blocking-mixin>) (asa <sparse-matrix>))
    Collects blocks consisting either of all subcells of cells in the cell-centered case or all cells to which a vertex belongs in the vertex-centered case.
  • Method SETUP-BLOCKS ((vanka <vanka>) (asa <ansatz-space-automorphism>))
    Adds to the usual vertex centered blocks all surrounding velocity degrees of freedom.
  • Method MAKE-ITERATOR ((s1-cgit <s1-coarse-grid-iterator>) (a <sparse-matrix>))
  • Method SOLVE ((strategy <strategy>) &optional blackboard)
    Solves the problem on the blackboard using the given strategy.
  • Method INITIALLY ((fe-strategy <fe-approximation>) blackboard)
    Ensures a finite element ansatz space and a first approximation to the solution on the blackboard.
  • Method INTERMEDIATE ((fe-strategy <fe-approximation>) blackboard)
    Approximates and estimates the error for the current ansatz-space.
  • Method TERMINATE-P ((fe-strategy <fe-approximation>) blackboard)
    Sets some variables before passing control to the check of termination criteria.
  • Method NEXT-STEP ((fe-strategy <fe-approximation>) blackboard)
    Enlarges the ansatz space.
  • Method INITIALLY ((rothe <rothe>) blackboard)
  • Method INTERMEDIATE ((rothe <rothe>) blackboard)
    Plots the solution initially and after each time step.
  • Method NEXT-STEP ((rothe <rothe>) blackboard)
    Do one step by solving the stationary problem.
  • Method SOLVE ((blackboard blackboard) &optional dummy)
    Implements the simplest interface for problem solving. Only a blackboard describing the problem is passed and the solution method is open.

Also exports

  • FL.UTILITIES:EVALUATE
  • FL.FUNCTION:<FUNCTION>
  • FL.FUNCTION:EVALUATE-GRADIENT
  • FL.MATLISP:BLOCKS
  • FL.FUNCTION:INTERVAL-METHOD

FL.MULTIGRID

This package contains the definition of the multigrid
iteration including algebraic multigrid (AMG).
  • Generic-Function SELECT-SMOOTHER (mg-it matrix)
    Select a suitable smoother depending on multigrid iteration and matrix.
  • Method SELECT-SMOOTHER (mg-it matrix)
    Returns the Gauss-Seidel method as default smoother.
  • Method SELECT-SMOOTHER (mg-it matrix)
    Returns the Gauss-Seidel method as default smoother.
  • Method SELECT-SMOOTHER (mg-it matrix)
    Returns the Gauss-Seidel method as default smoother.
  • Class <MG-ITERATION>  (<LINEAR-ITERATION>)
    The multigrid iteration is a linear iteration specially suited for the solution of systems of equations with elliptic terms. In ideal situations, it solves such systems with optimal complexity. It is a complicated linear iteration, which consists of applying simple linear iterators as smoothers on a hierarchy of grids. This grid hierarchy is obtained either by discretizing on successively refined meshes (geometric multigrid) or it is constructed from matrix information alone (algebraic multigrid). The <mg-iteration> is not intended to be used directly. Only incorporating mixins like <correction-scheme> or <fas> results in concrete classes like <algebraic-mg>.
    PRE-SMOOTHER   Reader: PRE-SMOOTHER
    PRE-STEPS   Reader: PRE-STEPS
    POST-SMOOTHER   Reader: POST-SMOOTHER
    POST-STEPS   Reader: POST-STEPS
    GAMMA   Reader: GAMMA
    BASE-LEVEL   Reader: BASE-LEVEL
    COARSE-GRID-ITERATION   Reader: COARSE-GRID-ITERATION
    FMG   Reader: FMG
    COMBINATION   Reader: COMBINATION-TYPE
    Switch between additive and multiplicative combination of corrections from different levels. The additive version should be used as a preconditioner.
  • Class <CORRECTION-SCHEME>
    This is a mixin-class which yields the correction scheme. It should be merged !before! <mg-iteration> for standard CLOS class precedence.
    No slots.
  • Class <FAS>
    This is a mixin-class for <mg-iteration> which yields the behaviour of Brandt's FAS scheme. It should be merged !before! <mg-iteration> or the derived class <geometric-mg> when using standard CLOS class precedence.
    No slots.
  • Generic-Function MULTILEVEL-DECOMPOSITION (mg-it a)
    The central generic function constructing the multilevel hierarchy.
  • Method MULTILEVEL-DECOMPOSITION ((amg <algebraic-mg>) mat)
    This is the standard method for building up an AMG hierarchy. Thus, it should be usable by a large variety of AMG algorithms. Its purpose is to repeat coarsening steps until either max-depth is larger than the given value or the size of the problem is smaller than min-size. The generic function 'coarsen' is called to do a single coarsening step.
  • Generic-Function COARSEN (amg mat)
    Given AMG and matrix, this generic function returns coarse-grid matrix, interpolation and restriction matrices for one coarsening step.
  • Generic-Function PREPROCESS-MATRIX (amg mat)
    Eliminates Dirichlet or slave degrees of freedom which can be handled well by smoothing.
  • Generic-Function PROLONGATION (amg mat)
    Computes a prolongation matrix from amg and mat. This is often the essence of an AMG method.
  • Generic-Function RESTRICTION (amg mat prol)
    Compute a restriction matrix from amg, mat and prolongation.
  • Generic-Function COARSE-GRID-MATRIX (amg mat prolongation restriction)
    Computes a coarse-grid matrix from amg, mat, prolongation and restriction.
  • Method COARSEN ((amg <algebraic-mg>) mat)
    This is the default method for AMG coarsening. It performs the following steps: 1. (prolongation) Build up a prolongation P. Its domain is the coarse-grid. 2. (restriction) Compute a restriction R. Usually this will be R=I^t. 3. (compute-coarse-grid-matrix) Build the coarse-grid matrix A_C by computing the Galerkin product A_C = I^t A I.
  • Function SLAVE-DOF-P (key mat)
    Checks if nothing depends on key and if key depends on other keys.
  • Function DIRICHLET-DOF-P (key mat)
    Checks if key does not depend on other keys, so that it can be kept on the fine grid.
  • Function SLAVE-OR-DIRICHLET-DOF-P (key mat)
    Checks if key is a hanging node or a Dirichlet node.
  • Method PREPROCESS-MATRIX ((amg <algebraic-mg>) mat)
    Default method which eliminates slave nodes and Dirichlet nodes for sparse matrices.
  • Method PROLONGATION (amg mat)
    General definition for construction of a prolongation. For incorporating other AMG algorithms, you should first try to keep this routinge as it is and define modifications for the called generic functions.
  • Method RESTRICTION ((amg <algebraic-mg>) mat prol)
    This is the default method for defining the restriction in AMG algorithms as the transpose of the prolongation.
  • Function GALERKIN-PRODUCT (r a p)
    Builds the Galerkin product R A P. This function works for every type of matrices for which the row- and column-loop macros are defined. This procedure should be inlined into an environment where types are known for avoiding generic arithmetic.
  • Method COARSE-GRID-MATRIX ((amg <algebraic-mg>) (a <sparse-matrix>) (p <sparse-matrix>) (r <sparse-matrix>))
    This is the standard method of generating a coarse-grid matrix.
  • Class <SELECTION-AMG>  (<ALGEBRAIC-MG>)
    This variant of algebraic multigrid coarsens in a special way by selecting coarse-grid nodes from the fine-grid nodes. This selection is kept in a table, which is then used by the method build-ip to build the actual interpolation matrix.
    No slots.
  • Class <STUEBEN>  (<SELECTION-AMG>)
    This provides something like Stueben's variant for selection amg. The original Ruge-Stueben algorithm was developed further since 1987 by Klaus Stueben and collaborators. These developments are published in .... The algorithm implemented here uses their ideas, but does not claim to be equivalent to their code which can be bought at SCAI, St. Augustin, Germany. At this point, I want to thank Tanja Clees for several discussions on AMG.
    THETA   Accessor: THETA
  • Method SELECT-SMOOTHER (mgit (matrix <ansatz-space-automorphism>))
    Choose the smoothing method as either Gauss-Seidel or SSC depending on discretization order.
  • Method SELECT-SMOOTHER (mgit (problem <pde-problem>))
    This method is called in the case of higher-order discretizations, such that we choose an SSC smoother by default.
  • Method SELECT-SMOOTHER (mgit (problem <navier-stokes-problem>))
    For discretized Navier-Stokes system, we use Vanka type smoothing.
  • Method MULTILEVEL-DECOMPOSITION ((mgit <geometric-mg>) (mat <ansatz-space-automorphism>))
    Assemble all levels below the top-level. The top level should have been already assembled. Works only for uniformly refined meshes.
  • Method MULTILEVEL-DECOMPOSITION ((mgit <geometric-fas>) (mat <ansatz-space-automorphism>))
    Add the vector of FAS restrictions to the output of this method for <geometric-mg>.
  • Method PROLONGATION ((amg <s1-reduction>) (mat <ansatz-space-automorphism>))
    Transfer to S1 finite elements.

FL.DISCRETIZATION

The @package{FL.DISCRETIZATION} package defines
@class{<discretization>} as an abstract class and
@class{<fe-discretization>} as a concrete derived class.

The key for local assembly is given by the generic function
@function{get-fe}, which yields a suitable finite element for a given cell.
The value of @function{get-fe} is a class @class{<fe>} for scalar problems
or @class{<vector-fe>} for vector-valued problems which contains
information on base functions and node functionals.  Another generic
function @function{quadrature-rule} computes memoized quadrature rules for
those finite elements.

Obviously, also non-standard finite element discretizations like hp-methods
would fit into this scheme.  The key for local assembly is given by the
generic function @function{get-fe}, which yields a suitable finite element
for a given cell.  The value of @function{get-fe} is a class @class{<fe>}
for scalar problems or @class{<vector-fe>} for vector-valued problems which
contains information on base functions and node functionals.  Another
generic function @function{quadrature-rule} computes memoized quadrature
rules for those finite elements.

The file @path{lagrange.lisp} provides Lagrange finite elements of
arbitrary order.  The evaluation points for the node functionals may be
chosen either uniformly distributed or at the Gauss-Lobatto points.  The
latter choice of points yields better stability properties but is
restricted to cube meshes.  Also functions for constructing cell mappings
by pointwise evaluation of the domain boundary are provided here, which may
be used to construct isoparametric domain approximations.

In the file @path{fedisc.lisp}, the function @function{fe-discretize} is
defined.  This function performs the standard steps for finite element
discretization: interior assembly, assembly and elimination of hanging-node
and essential-boundary constraints.  It works on a blackboard as explained
in Section @ref{Blackboards} and can reuse already available matrix-vector
structure.  There is a somewhat less flexible interface provided by the
funtion @function{discretize-globally} which calls
@function{fe-discretize}.

In the files @path{ellsys-fe.lisp}, @path{elasticity-fe.lisp} and
@path{navier-stokes.lisp} one can find methods for local assembly for the
different problems.  They are defined in own packages which use both the
package @package{FL.DISCRETIZATION} and the package for the particular
problem.
  • Class <DISCRETIZATION>  (PROPERTY-MIXIN)
    Discretization base class.
    No slots.
  • Generic-Function DISCRETIZATION-ORDER (disc)
    Returns the order of the discretization.
  • Method DISCRETIZATION-ORDER (disc)
    Default value is @code{:variable}.
  • Method DISCRETIZATION-ORDER (disc)
    Default value is @code{:variable}.
  • Method DISCRETIZATION-ORDER (disc)
    Default value is @code{:variable}.
  • Generic-Function DISCRETIZE (discretization problem blackboard)
    Calculates matrix and right-hand side for the @var{discretization} and the @var{problem}. Further parameters are provided inside the @var{blackboard}.
  • Variable *SUGGESTED-DISCRETIZATION-ORDER*
    nil
    The suggested order of discretization. In non-nil, this value should be taken into account by methods to @arg{select-discretization}.
  • Generic-Function SELECT-DISCRETIZATION (problem blackboard)
    Select a discretization for the given @var{problem} depending on the parameters on the @var{blackboard}.
  • Method SELECT-DISCRETIZATION (problem blackboard)
    Forces the use of a discretization on the blackboard.
  • Method SELECT-DISCRETIZATION (problem blackboard)
    Forces the use of a discretization on the blackboard.
  • Method SELECT-DISCRETIZATION (problem blackboard)
    Forces the use of a discretization on the blackboard.
  • Method SELECT-DISCRETIZATION (problem blackboard)
  • Method SELECT-DISCRETIZATION (problem blackboard)
  • Method SELECT-DISCRETIZATION (problem blackboard)
  • Struct <IP>
    WEIGHT
    COORDS
  • Function IP-WEIGHT (instance)
  • Function (setf IP-WEIGHT) (value instance)
  • Function IP-COORDS (instance)
  • Function (setf IP-COORDS) (value instance)
  • Function WEIGHTS-FOR-IPS (beta ips)
    Determines weights for the integration points @arg{ips} such that they integrate @math{int_{-1}^{1} (1+y)^beta ... dy} with optimal order.
  • Function PRODUCT-RULE (&rest quadrature-rules)
    Computes a product rule for several lower-dimensional quadrature rules.
  • Function GAUSS-RULE (factor-dims s)
    Returns an s-point Gauss integration rule.
  • Function GAUSS-LOBATTO-POINTS (s)
  • Function GAUSS-LOBATTO-POINTS-ON-UNIT-INTERVAL (s)
  • Function GAUSS-LOBATTO-RULE (factor-dims s)
  • Function TEST-INTEGRATION-RULE (points weights &optional (output t))
    Tests the given rule against monomials of increasing degree. As a by-product this determines the order of the rule.
  • Class DOF
    Degree of freedom in a finite element. It is defined as a functional defined by integration over a sub-cell or by evaluation at a local coordinate of a sub-cell of a reference cell.
    INDEX   Reader: DOF-INDEX
    Index of the dof in the cell-dof array
    SUBCELL   Reader: DOF-SUBCELL
    Reference subcell on which the dof is defined
    SUBCELL-INDEX   Reader: DOF-SUBCELL-INDEX
    Index of the reference subcell on which the dof is defined
    IN-VBLOCK-INDEX   Reader: DOF-IN-VBLOCK-INDEX
    Index of the dof in the subcell vblock
    COORD   Reader: DOF-COORD
    Local coordinate of the dof in the reference subcell
    GCOORD   Reader: DOF-GCOORD
    Global coordinate of the dof on the reference cell
    FUNCTIONAL   Reader: DOF-FUNCTIONAL
    A functional for functions defined on the reference cell
  • Function INTERIOR-DOF? (dof)
  • Class <SCALAR-FE>  (<FE>)
    A finite element <fe> is given for each reference cell, e.g. <2-simplex>. dofs are the degrees of freedom associated with the cell, basis is the dual basis to dofs in some polynomial space. subcell-ndofs is the number of ndofs on each subcell. subcell-indices is a list of indices for all subcells with dofs. Usually, the <scalar-fe> will occur as values of a procedure or as values in a hash-table with the reference cells as keys.
    DOFS   Reader: FE-DOFS
    The associated dofs. These are Lagrange functionals associated to the basis functions used for interpolating smooth functions.
    BASIS   Reader: FE-BASIS
    The fe's basis functions.
    ORDER   Reader: DISCRETIZATION-ORDER
  • Generic-Function NR-OF-DOFS (fe)
    Number of degrees of freedom for the (vector) finite element.
  • Method NR-OF-DOFS ((fe <scalar-fe>))
  • Method NR-OF-DOFS ((fe <scalar-fe>))
  • Method NR-OF-DOFS ((fe <scalar-fe>))
  • Generic-Function NR-OF-INNER-DOFS (fe)
    Number of inner degrees of freedom for the (vector) finite element.
  • Method NR-OF-INNER-DOFS ((fe <scalar-fe>))
  • Method NR-OF-INNER-DOFS ((fe <scalar-fe>))
  • Method NR-OF-INNER-DOFS ((fe <scalar-fe>))
  • Function SUBCELL-NDOFS (fe)
  • Function INNER-DOF-INDICES (fe)
  • Macro DO-DOF ((dof-and-shape fe &key (type :dof)) &body body)
  • Class <VECTOR-FE>  (<FE>)
    Finite element for vector functions. Components is a vector of scalar finite elements. Subcell-offsets is an array consisting of arrays which yield such an offset for every subcell.
    COMPONENTS   Accessor: COMPONENTS
    DOFS   Accessor: FE-DOFS
    BASIS   Reader: FE-BASIS
  • Method NR-OF-DOFS ((fe <vector-fe>))
  • Method NR-OF-INNER-DOFS ((fe <vector-fe>))
  • Generic-Function COMPONENT (fe comp)
    Returns the @arg{comp}-th component of the (vector) finite element @arg{fe}.
  • Method COMPONENT ((vecfe <vector-fe>) comp)
  • Method COMPONENT ((vecfe <vector-fe>) comp)
  • Method COMPONENT ((vecfe <vector-fe>) comp)
  • Method DISCRETIZATION-ORDER ((vecfe <vector-fe>))
  • Function SUBCELL-OFFSETS (fe)
    Reader for subcell-offsets. This is an array of length the number of components. Each component is an array giving the offset of this component in a sparse vector value block corresponding to the subcell.
  • Generic-Function QUADRATURE-RULE (fe)
    Computes the quadrature rule to be used for the finite element @arg{fe}.
  • Variable *QUADRATURE-ORDER*
    nil
    Quadrature order to be used. NIL determines the order automatically.
  • Method QUADRATURE-RULE ((fe <fe>))
    Standard quadrature rule for fe.
  • Generic-Function INTERPOLATE-ON-REFCELL (fe function)
    Interpolates @arg{function} on the reference cell of the finite element @arg{fe}. Returns a standard-matrix corresponding to the block in the sparse vector.
  • Method INTERPOLATE-ON-REFCELL ((fe <fe>) function)
  • Method INTERPOLATE-ON-REFCELL ((fe <fe>) function)
  • Method INTERPOLATE-ON-REFCELL ((fe <fe>) function)
  • Generic-Function IP-VALUES (fe obj)
    Returns a vector of ip values for @arg{obj} which may be a vector of integration points or a quadrature rule. Note that this function is memoized using an :around method.
  • Method IP-VALUES ((fe <scalar-fe>) (positions vector))
    Returns a list of nr-ip float-matrices of dimension (n-basis x 1).
  • Method IP-VALUES ((fe <vector-fe>) (positions vector))
    Returns a list of positions of length components.
  • Method IP-VALUES (fe (qrule <integration-rule>))
    Return the fe values for the integration points of qrule.
  • Generic-Function IP-GRADIENTS (fe obj)
    Returns a vector of local gradient matrices for @arg{obj} which may be a vector of integration points or a quadrature rule. Note that this function is memoized using an :around method.
  • Method IP-GRADIENTS ((fe <scalar-fe>) (positions vector))
    Returns a list of nr-ip float-matrices of dimension (n-basis x dim).
  • Method IP-GRADIENTS ((fe <vector-fe>) (positions vector))
  • Method IP-GRADIENTS (fe (qrule <integration-rule>))
    Return the fe values for the integration points of qrule.
  • Function CONSTRUCT-COEFF-INPUT (cell global dphi values gradients fe-parameters)
    Constructs a coefficient input list from FE data @arg{cell} is the cell, @arg{global} is the global coordinate of the integration point, @arg{values} and @arg{gradients} the values and gradients of the shape functions at the ip, and @arg{fe-parameters} are the corresponding data of fe-functions to be evalutated.
  • Function FE-CELL-GEOMETRY (cell sample-points &key weights metric volume &aux (n (length sample-points)))
    Collects cell geometry information at @arg{sample-points} inside a property list.
  • Class <FE-DISCRETIZATION>  (<DISCRETIZATION>)
    FE discretization base class.
    No slots.
  • Generic-Function GET-FE (fe-disc cell)
    Returns the finite element for the given discretization and reference cell.
  • Class <STANDARD-FE-DISCRETIZATION>  (<FE-DISCRETIZATION>)
    Finite element discretization where the finite element depends only on the cell (usually via its reference cell).
    CELL->FE
    A function mapping a cell to a finite element. Usually this will be a closure memoized over the reference cell.
  • Method GET-FE ((disc <standard-fe-discretization>) cell)
  • Class <SCALAR-FE-DISCRETIZATION>  (<STANDARD-FE-DISCRETIZATION>)
    Class for scalar fe discretizations.
    ORDER   Reader: DISCRETIZATION-ORDER
  • Class <VECTOR-FE-DISCRETIZATION>  (<STANDARD-FE-DISCRETIZATION>)
    Vector FE discretization class.
    COMPONENTS   Reader: COMPONENTS
    Either a vector of components or the symbol :variable, if the components vary across the domain as is the case for hp-FEM.
  • Method DISCRETIZATION-ORDER ((vecfe-disc <vector-fe-discretization>))
  • Method COMPONENT ((fedisc <vector-fe-discretization>) i)
  • Class <ANSATZ-SPACE>  (PROPERTY-MIXIN)
    A finite element ansatz space is determined by finite element discretization, mesh and problem. The constraints are stored in the slot @var{properties}.
    FE-CLASS   Reader: FE-CLASS
    The finite element class for this ansatz space.
    PROBLEM   Reader: PROBLEM
    The proplem for this ansatz space which determines essential constraints.
    MESH   Reader: MESH
    The mesh for this ansatz space which determines hanging-node constraints.
  • Method GET-FE ((as <ansatz-space>) cell)
  • Generic-Function HIERARCHICAL-MESH (aso)
    The hierarchical mesh for the given ansatz-space or ansatz-space object.
  • Method HIERARCHICAL-MESH ((as <ansatz-space>))
  • Method HIERARCHICAL-MESH ((as <ansatz-space>))
  • Method HIERARCHICAL-MESH ((as <ansatz-space>))
  • Method DISCRETIZATION-ORDER ((as <ansatz-space>))
  • Function MAKE-FE-ANSATZ-SPACE (fe-class problem mesh)
    Constructor of @class{<ansatz-space>}.
  • Function LAGRANGE-ANSATZ-SPACE (problem mesh &key (order 1) (type :uniform))
    A constructor for a problem-dependent Lagrange fe. Here, the number of components may vary with the respective patch.
  • Method MESH ((aso <ansatz-space-object>))
  • Method HIERARCHICAL-MESH ((aso <ansatz-space-object>))
  • Method FE-CLASS ((aso <ansatz-space-object>))
  • Method PROBLEM ((aso <ansatz-space-object>))
  • Function CELL-LAGRANGE-FE (cell order type &optional disc)
    Returns a Lagrange fe depending on reference cell, an order (which can be number or vector), and a type symbol.
  • Function LAGRANGE-FE (order &key (nr-comps 1) (type :uniform))
    Constructor for Lagrange fe. nr-comps=nil builds a scalar fe-discretization, otherwise a vector-fe-discretization is built.
  • Function LAGRANGE-MAPPING (order &optional (type :uniform))
    Returns a function which maps a cell by a polynomial which is obtained by interpolating the boundary map via Lagrange interpolation.
  • Function LOCAL-IMATRIX (rule fe &optional (type :local))
    Memoized call of compute-local-imatrix.
  • Function LOCAL-PMATRIX (rule fe)
    Memoized call of compute-local-pmatrix.
  • Function LOCAL-TRANSFER-MATRIX (fe-from fe-to)
    Computes a local transfer matrix between different FE spaces.
  • Function CELL-KEY (cell mesh)
    If cell is identified, its identification is the key.
  • Class <ANSATZ-SPACE-VECTOR>  (<ANSATZ-SPACE-OBJECT>, <HT-SPARSE-VECTOR>)
    A sparse vector which is interpreted as the ansatz-space for a specific fe-class on a given mesh.
    No slots.
  • Function MAKE-ANSATZ-SPACE-VECTOR (as &optional multiplicity)
  • Function SPECIAL-ANSATZ-SPACE-VECTOR (ansatz-space &optional (type :random) (value 1.0d0))
    Returns a ansatz space vector for @arg{ansatz-space} filled with constant or random entries. Essential constraints are satisfied.
  • Function RANDOM-ANSATZ-SPACE-VECTOR (ansatz-space)
    Returns a ansatz space vector for @arg{ansatz-space} filled with random entries. Essential constraints are satisfied.
  • Generic-Function CHOOSE-START-VECTOR (ansatz-space)
    Choose a reasonable start vector for some strategy.
  • Method CHOOSE-START-VECTOR (as)
    The default method chooses a random guess for eigenvalue problems and 0 otherwise.
  • Method CHOOSE-START-VECTOR (as)
    The default method chooses a random guess for eigenvalue problems and 0 otherwise.
  • Method CHOOSE-START-VECTOR (as)
    The default method chooses a random guess for eigenvalue problems and 0 otherwise.
  • Class <ANSATZ-SPACE-MORPHISM>
    A mapping between two ansatz-spaces.
    No slots.
  • Generic-Function DOMAIN-ANSATZ-SPACE (asm)
  • Generic-Function IMAGE-ANSATZ-SPACE (asm)
  • Function MAKE-ANSATZ-SPACE-MORPHISM (domain-as image-as)
  • Class <ANSATZ-SPACE-AUTOMORPHISM>  (<ANSATZ-SPACE-MORPHISM>, <ANSATZ-SPACE-OBJECT>)
    A automorphism of an ansatz space.
    No slots.
  • Method DOMAIN-ANSATZ-SPACE ((asa <ansatz-space-automorphism>))
  • Method IMAGE-ANSATZ-SPACE ((asa <ansatz-space-automorphism>))
  • Function MAKE-ANSATZ-SPACE-AUTOMORPHISM (as)
  • Generic-Function EXTENDED-EXTRACT (mat keys &key row? col?)
    Extract a sub-matrix from a sparse matrix for the given keys.
  • Method EXTENDED-EXTRACT ((asa <ansatz-space-automorphism>) (skel <skeleton>) &key (row? t) (col? t))
    Extracts a sub-matrix from a sparse matrix. This routine could be accelerated by taking member-checks out of the loop.
  • Function INTERPOLATION-MATRIX (ansatz-space &key level region imat (type *interpolation-type*))
    On each cell of the skeleton @arg{region} or on all cells of level @arg{level} of the mesh of @arg{ansatz-space}, a local interpolation matrix is collected into an interpolation matrix. @arg{type} is the interpolation type having a default value @var{*interpolation-type*}.
  • Function PROJECTION-MATRIX (ansatz-space &key level region pmat)
    The algorithm works as follows: On each cell of the provided cell list or the whole refinement a local projection matrix computed on the reference finite element is copied into the global projection matrix.
  • Function TRANSFER-MATRIX (domain-as image-as &key no-slaves)
    Builds a transfer matrix from domain-as to image-as.
  • Function MAKE-LOCAL-VEC (ansatz-space cell)
    Generates a local vector for local discretization.
  • Generic-Function MAKE-LOCAL-MAT (as1 cell1 &optional as2 cell2)
    Generates a local matrix discretization for the given ansatz-space(s).
  • Method MAKE-LOCAL-MAT (as1 cell1 &optional (as2 as1) (cell2 cell1))
    Try using a pool if provided
  • Method MAKE-LOCAL-MAT (as1 cell1 &optional (as2 as1) (cell2 cell1))
    Try using a pool if provided
  • Method MAKE-LOCAL-MAT (as1 cell1 &optional (as2 as1) (cell2 cell1))
    Try using a pool if provided
  • Method MAKE-LOCAL-MAT (as1 cell1 &optional (as2 as1) (cell2 cell1))
    Default method. Allocates a new matrix.
  • Method MAKE-LOCAL-MAT (as1 cell1 &optional (as2 as1) (cell2 cell1))
    Default method. Allocates a new matrix.
  • Method MAKE-LOCAL-MAT (as1 cell1 &optional (as2 as1) (cell2 cell1))
    Default method. Allocates a new matrix.
  • Generic-Function GET-LOCAL-FROM-GLOBAL-VEC (cell global-vec)
    Maps the region in global-vec determined by cell to a local vector.
  • Generic-Function SET-GLOBAL-TO-LOCAL-VEC (cell global-vec local-vec)
    Sets the region in global-vec determined by cell to the values of the local vector array.
  • Generic-Function INCREMENT-GLOBAL-BY-LOCAL-VEC (cell global-vec local-vec)
    Increments the region in global-vec determined by cell to the values of the local vector array.
  • Generic-Function GET-LOCAL-FROM-GLOBAL-MAT (global-mat cell &optional domain-cell)
    Maps the region in the global stiffness matrix determined by cell to a local matrix array.
  • Generic-Function SET-GLOBAL-TO-LOCAL-MAT (global-mat local-mat cell &optional domain-cell)
    Sets the region in global-mat determined by cell to the values of the local matrix array.
  • Generic-Function INCREMENT-GLOBAL-BY-LOCAL-MAT (global-mat local-mat cell &optional domain-cell)
    Increments the region in global-mat determined by cell to the values of local-mat.
  • Function FE-EXTRACTION-INFORMATION (fe indices)
    Computes information for extracting components out of a vector finite element.
  • Method GET-LOCAL-FROM-GLOBAL-VEC ((cell <cell>) (svec <sparse-vector>))
  • Method SET-GLOBAL-TO-LOCAL-VEC ((cell <cell>) (svec <sparse-vector>) local-vec)
  • Method INCREMENT-GLOBAL-BY-LOCAL-VEC ((cell <cell>) (svec <sparse-vector>) local-vec)
  • Function MULTIPLE-EVALUATE-LOCAL-FE (local-vec shape-values)
    Evaluates the vector given in @arg{local-vec} at multiple points. Here @arg{local-vec} should be a data vector obtained with @function{get-local-from-global-vec} and @arg{ip-values} should be a vector obtained from @function{ip-values}.
  • Method GET-LOCAL-FROM-GLOBAL-MAT ((smat <sparse-matrix>) (cell <cell>) &optional (domain-cell cell))
  • Method SET-GLOBAL-TO-LOCAL-MAT ((smat <sparse-matrix>) local-mat (cell <cell>) &optional (domain-cell cell))
  • Method INCREMENT-GLOBAL-BY-LOCAL-MAT ((smat <sparse-matrix>) local-mat (cell <cell>) &optional (domain-cell cell))
  • Generic-Function FE-LOCAL-VALUE (asv cell local-pos)
    Evaluates a FE ansatz-space-vector in @arg{cell} at @arg{local-pos}.
  • Generic-Function FE-VALUE (asv global-pos)
    Evaluates a FE ansatz-space-vector at @arg{global-pos}.
  • Generic-Function FE-LOCAL-GRADIENT (asv cell local-pos)
    Evaluates the gradient of a FE ansatz-space-vector on @arg{cell} at @arg{local-pos}.
  • Generic-Function FE-GRADIENT (asv global-pos)
    Evaluates the gradient of the FE ansatz-space-vector @arg{asv} at @arg{global-pos}.
  • Generic-Function CELL-INTEGRATE (cell object &key &allow-other-keys)
    Integrates @arg{object} on @arg{cell}.
  • Generic-Function FE-INTEGRATE (asv &key cells skeleton initial-value combiner key coeff-func)
    Integrates a finite element function over the domain. key is a transformer function, as always (e.g. #'abs if you want the L1-norm).
  • Generic-Function FE-EXTREME-VALUES (asv &key cells skeleton component)
    Computes the extreme values of a finite element function over the domain or some region. The result is a pair, the car being the minimum values and the cdr the maximum values. Each part is a matrix of the format ncomps x multiplicity.
  • Method FE-LOCAL-VALUE ((asv <ansatz-space-vector>) cell local-pos)
    Evaluates a finite element function in @arg{cell} at @arg{local-pos}.
  • Method FE-VALUE ((asv <ansatz-space-vector>) global-pos)
    Evaluates a finite element function at @arg{global-pos}.
  • Method FE-LOCAL-GRADIENT ((asv <ansatz-space-vector>) cell local-pos)
    Evaluates a finite element gradient on @arg{cell} at @arg{local-pos}.
  • Method FE-GRADIENT ((asv <ansatz-space-vector>) pos)
    Evaluates a finite element gradient at point pos.
  • Method CELL-INTEGRATE (cell (func function) &key initial-value (combiner #'m+!) (quadrature-order *quadrature-order*))
    Integrates @arg{func} over @arg{cell}.
  • Method CELL-INTEGRATE (cell (x <ansatz-space-vector>) &key initial-value (combiner #'m+!) (key #'identity) coeff-func)
    Integrates the ansatz-space vector @arg{x} on @arg{cell}. If @arg{coeff-fun} is set it should be a function which expects keyword arguments @code{:solution} and @code{:global}.
  • Method FE-INTEGRATE ((asv <ansatz-space-vector>) &key cells skeleton initial-value (combiner #'m+!) (key #'identity) coeff-func)
    Integrates a finite element function over the domain. key is a transformer function, as always (e.g. #'abs if you want the L1-norm).
  • Method FE-EXTREME-VALUES ((asv <ansatz-space-vector>) &key cells skeleton component)
    Computes the extreme values of a finite element function over the domain or some region. The result is a pair, the car being the minimum values and the cdr the maximum values. Each part is a matrix of the format ncomps x multiplicity.
  • Generic-Function ESSENTIAL-BOUNDARY-CONSTRAINTS (problem ansatz-space &key level where interface)
    Computation of essential constraints. Should probably be incorporated into the ansatz-space definition.
  • Function CONSTRAINED-INTERPOLATION-MATRIX (ansatz-space &key level where imat (type :local))
    The multigrid algorithm needs an interpolation which satisfies the constraints like essential or periodic boundary conditions.
  • Function ASSEMBLE-CONSTRAINTS (ansatz-space)
  • Function ELIMINATE-CONSTRAINTS (mat rhs constraints-p constraints-q constraints-r &key assemble-locally include-constraints)
    Constraints are given by an equation: P x = Q x + r Here x in V, P is an orthogonal projection on a subspace V_P of V, Q maps some other space which may have nonempty intersection with V_P to V_P. With S we denote the mapping Id-P. This function returns the matrix for a Galerkin method on the constrained space. It is used for treating hanging nodes and essential boundary conditions. When assemble-locally is t the sparse structure of mat is used instead of the sparse structure of the hanging node interface. When include-constraints is non-nil, the constraints are included in matrix and rhs.
  • Generic-Function DISCRETIZE-LOCALLY (problem coeffs fe qrule fe-geometry &key matrix mass-matrix rhs local-u local-v fe-parameters)
    Computes a local stiffness matrix and right-hand side. The algorithm will usually work as follows: @enumerate @item Get coefficient functions for the patch of the cell. @item Compute geometry information for all ips (values and gradients of the shape functions). @item Loop over integration points ip: @enumerate @item If necessary, compute input for coefficient functions. This input may contain values of finite element function in the property list @arg{fe-parameters}. @item Evaluate coefficient functions at ips. @item Add the contributions for matrix and right-hand side to @arg{local-mat} and @arg{local-rhs}. @end enumerate @end enumerate If @arg{local-u} and @arg{local-v} are set, then @arg{local-v}*@arg{local-mat}*@arg{local-u} and @arg{local-v}*@arg{local-rhs} is computed. This feature may be used later on for implementing matrixless computations.
  • Generic-Function ASSEMBLE-INTERIOR (ansatz-space where &key level matrix mass-matrix rhs parallel-clustering &allow-other-keys)
    Assemble the interior, i.e. ignore constraints arising from boundaries and hanging nodes. Discretization is done using the ansatz space @arg{ansatz-space} on level @arg{level}. The level argument will usually be @code{NIL} when performing a global assembly, and be equal to some number when assembling coarse level matrices for multigrid. The argument @arg{where} is a flag indicating where assembly is to be done. It should be one of the keywords @code{:surface}, @code{:refined}, @code{:all}. The arguments @arg{matrix}, @arg{rhs} should contain vectors/matrices where the local assembly is accumulated. Boundary conditions and constraints are not taken into account within this routine. In general, this function does most of the assembly work. Other steps like handling constraints are intricate, but usually of lower computational complexity.
  • Method ASSEMBLE-INTERIOR ((as <ansatz-space>) (where list) &key matrix mass-matrix rhs parallel-clustering &allow-other-keys)
  • Method ASSEMBLE-INTERIOR ((as <ansatz-space>) (where list) &key matrix mass-matrix rhs parallel-clustering &allow-other-keys)
  • Method ASSEMBLE-INTERIOR ((as <ansatz-space>) (where list) &key matrix mass-matrix rhs parallel-clustering &allow-other-keys)
  • Method ASSEMBLE-INTERIOR ((as <ansatz-space>) (where symbol) &rest args &key level parallel-clustering &allow-other-keys)
  • Method ASSEMBLE-INTERIOR ((as <ansatz-space>) (where symbol) &rest args &key level parallel-clustering &allow-other-keys)
  • Method ASSEMBLE-INTERIOR ((as <ansatz-space>) (where symbol) &rest args &key level parallel-clustering &allow-other-keys)
  • Function FE-DISCRETIZE (blackboard)
    Finite element discretization for an ansatz space provided on the blackboard.
  • Function DISCRETIZE-GLOBALLY (problem h-mesh fe-class)
    Discretize @arg{problem} on the hierarchical mesh @arg{h-mesh} using finite elments given by @arg{fe-class}.
  • Method DISCRETIZE ((fedisc <fe-discretization>) (problem <pde-problem>) blackboard)
    General discretization interface for FE.
  • Method ESSENTIAL-BOUNDARY-CONSTRAINTS ((problem <pde-problem>) (ansatz-space <ansatz-space>) &key level (where :surface) interface)
  • Method DISCRETIZE-LOCALLY ((problem <ellsys-problem>) coeffs vecfe qrule fe-geometry &key matrix rhs mass-matrix local-u local-v residual-p fe-parameters &allow-other-keys)
    Local discretization for a pde system of the form described in the documentation of the package @package{ELLSYS}.
  • Method SELECT-DISCRETIZATION ((problem <ellsys-problem>) blackboard)
  • Method SELECT-DISCRETIZATION ((problem <navier-stokes-problem>) blackboard)

Also exports

  • FL.MESH:REPRESENTATIVE

FL.ELLSYS-FE

Finite element discretization of a general second order
elliptic system, see the description in the ELLSYS package.  The result is
a local matrix A and local rhs b.  They will usually depend on u_old which
is stored in the solution vector.
No exported symbols.

FL.ELASTICITY-FE

This package specializes the discretization for systems
of elasticity.  Since elasticity is a special case of elliptic systems
which are handled in @path{ellsys-fe.lisp}, not much remains to do.
No exported symbols.

FL.NAVIER-STOKES-FE

This package specializes the finite element
discretization for Navier-Stokes problems.  Up to now, we use only
generalized Taylor hood elements.
  • Function NAVIER-STOKES-LAGRANGE-FE (order dim delta)
    Returns a generalized Taylor-Hood element @math{(Q^{k+delta})^d/Q^k} of order @math{k} in dimension @math{d}.

FL.GEOMG

The @package{FL.GEOMG} package contains iterations which
depend on geometric information, obtained for example from the
discretization.  At the moment, these are the geometric multigrid
iteration, an AMG-like scheme for preconditioning high-order
discretizations with low-order ones, and some block smoothers with
overlapping blocks.
  • Class <GEOMETRIC-PSC>  (<GEOMETRIC-BLOCKING-MIXIN>, <PSC>)
    PSC with geometry-based block choice.
    No slots.
  • Class <GEOMETRIC-SSC>  (<GEOMETRIC-BLOCKING-MIXIN>, <SSC>)
    SSC with geometry-based block choice.
    No slots.
  • Function GEOMETRIC-PSC (&rest rest)
    Constructor of a geometric parallel subspace correction.
  • Function GEOMETRIC-SSC (&rest rest)
    Constructor of a geometric successive subspace correction.
  • Class <VANKA>  (<GEOMETRIC-SSC>)
    Vanka-like smoother for @math{Q^{k+1}/Q^k} discretizations of Navier-Stokes.
    No slots.
  • Class <GEOMETRIC-CS>  (<CORRECTION-SCHEME>, <GEOMETRIC-MG>)
    Geometric multigrid of correction scheme type.
    No slots.
  • Function GEOMETRIC-CS (&rest key-args)
    Constructor of a geometric multigrid iteration of correction scheme type.
  • Class <GEOMETRIC-FAS>  (<FAS>, <GEOMETRIC-MG>)
    Brandt's FAS scheme approximates the unknowns on every level instead of using corrections. This requires slightly more work, but is better suited for handling nonlinear problems and local refinements.
    No slots.
  • Function FAS (&rest key-args)
    Constructor of a geometric multigrid iteration of FAS type.
  • Class <S1-REDUCTION>  (<SELECTION-AMG>)
    This class is useful for reducing a higher-order FE discretization to a first-order FE discretization. This can afterwards be treated by ordinary AMG steps. Even if it has the structure of a <selection-amg>, it is far from being a pure algebraic multigrid.
    No slots.
  • Class <S1-COARSE-GRID-ITERATOR>  (<LINEAR-ITERATION>)
    Calls LU directly, if the matrix was not reduced to S1 which may happen if there are only Dirichlet vertices.
    No slots.
  • Function S1-REDUCTION-AMG-SOLVER (order &key output reduction (maxsteps 100))
    This is an AMG solver which works also for Lagrange fe of order p by reducing them to P^1 first.

FL.GRAPHIC

This package provides a low-level interface to external
graphic software; at the moment both IBM's @code{OpenDX} and @code{Gnuplot}
are supported.
  • Variable *DEFAULT-GRAPHIC-PROGRAM*
    :dx
    Default graphics program.
  • Generic-Function GRAPHIC-FILE-NAME (object program &rest rest &key &allow-other-keys)
    Return a filename for the data of this plot.
  • Method GRAPHIC-FILE-NAME (object program &key system-p &allow-other-keys)
    This around-method handles the system-p flag: if true, @function{graphic-file-name} returns a filename suitable for use in external programs.
  • Method GRAPHIC-FILE-NAME (object program &key system-p &allow-other-keys)
    This around-method handles the system-p flag: if true, @function{graphic-file-name} returns a filename suitable for use in external programs.
  • Method GRAPHIC-FILE-NAME (object program &key system-p &allow-other-keys)
    This around-method handles the system-p flag: if true, @function{graphic-file-name} returns a filename suitable for use in external programs.
  • Generic-Function GRAPHIC-WRITE-DATA (stream object program &rest rest &key &allow-other-keys)
    Write the data file for @arg{program} to @arg{stream}.
  • Generic-Function GRAPHIC-COMMANDS (object program &rest rest &key &allow-other-keys)
    Returns commands for plotting to be sent to the graphics program.
  • Generic-Function SEND-GRAPHIC-COMMANDS (object program &rest rest &key &allow-other-keys)
    Routine for sending commands to the graphics server.
  • Generic-Function GRAPHIC-OUTPUT (object program &key &allow-other-keys)
    Writes the graphic commands for @arg{object} as needed by the graphic program @arg{program}.
  • Method GRAPHIC-OUTPUT (object program &rest rest)
    Calls the generic graphic interface in appropriate order.
  • Method GRAPHIC-OUTPUT (object program &rest rest)
    Calls the generic graphic interface in appropriate order.
  • Method GRAPHIC-OUTPUT (object program &rest rest)
    Calls the generic graphic interface in appropriate order.
  • Method GRAPHIC-FILE-NAME (object (program (eql :dx)) &key &allow-other-keys)
    Returns the output file for @program{dx}.
  • Method GRAPHIC-OUTPUT (object (program (eql :dx)) &key &allow-other-keys)
  • Method SEND-GRAPHIC-COMMANDS (object (program (eql :dx)) &rest paras &key dimension (background :black) (resolution 480) (width 480) (height 480) format filename (window "femlisp-image") &allow-other-keys)
  • Method GRAPHIC-FILE-NAME (object (program (eql :vtk)) &key &allow-other-keys)
    Returns the file name for the @program{vtk} data file.
  • Method SEND-GRAPHIC-COMMANDS (object (program (eql :vtk)) &rest args &key message)
    Nothing is done here, because at the moment we expect a separate Mayavi viewer to handle changes interactively.
  • Method GRAPHIC-FILE-NAME (object (program (eql :gnuplot)) &key &allow-other-keys)
    Returns the output file for @program{Gnuplot}.
  • Method SEND-GRAPHIC-COMMANDS (object (program (eql :gnuplot)) &rest paras &key left right top bottom (border t) (tics t) (terminal "x11") (output "gnuplot.ps") &allow-other-keys)
  • Method GRAPHIC-COMMANDS (object (program (eql :dx)) &key (foreground :white) dimension shape range &allow-other-keys)
    Default method for plotting objects with DX.
  • Method GRAPHIC-WRITE-DATA (stream object (program (eql :dx)) &key cells cell->values (rank 0) shape (depth 0) transformation)
    Rather general plotting procedure writing data to a file. Plots in DX format for 1D, 2D, and 3D. Can plot data either discontinuous or continuous at the cell boundaries when coefficient functions are involved. cell->values has to be either nil --meaning no data-- or some function mapping cells to a list of corner values.
  • Method GRAPHIC-COMMANDS ((skel <skeleton>) (program (eql :dx)) &key dimension tubes (glyphs t) glyph-scale background &allow-other-keys)
  • Method GRAPHIC-WRITE-DATA (stream (skel <skeleton>) (program (eql :dx)) &key (cells nil cells-p) part transformation)
    Plots a mesh. If provided, @arg{cells} should be 1-cells.
  • Method GRAPHIC-WRITE-DATA (stream (skel <skeleton>) (program (eql :vtk)) &key (cells nil cells-p) part transformation)
    Plots a mesh. If provided, @arg{cells} should be 1-cells.
  • Method GRAPHIC-COMMANDS ((asa <ansatz-space-automorphism>) (program (eql :dx)) &key &allow-other-keys)
  • Method GRAPHIC-WRITE-DATA (stream (asa <ansatz-space-automorphism>) (program (eql :dx)) &key dimension &allow-other-keys)
  • Method GRAPHIC-COMMANDS (object (program (eql :gnuplot)) &rest paras)
    Default gnuplot plotting command.
  • Method GRAPHIC-WRITE-DATA (stream (polygons list) (program (eql :gnuplot)) &key &allow-other-keys)
    Can handle either a single list of points, or a single list of the form (string . points) or a list of such lists which is interpreted as multiple graphs.
  • Method GRAPHIC-COMMANDS ((polygons list) (program (eql :gnuplot)) &key (linewidth 1) &allow-other-keys)
  • Method GRAPHIC-WRITE-DATA (stream object (program (eql :gnuplot)) &key cells cell->values (depth 0))
    Writes data in gnuplot format to a stream.
  • Method GRAPHIC-WRITE-DATA (stream object (program (eql :vtk)) &key cells cell->values shape (depth 0) transformation &allow-other-keys)

FL.PLOT

This package provides a high-level interface to
plotting.  It defines a generic function @code{PLOT} which can be used to
plot several types of objects, e.g. cells, meshes, finite element and
coefficient functions.
  • Generic-Function PLOT (object &key &allow-other-keys)
    Plot is a generic function which dispatches depending on the type of object it receives. Its behaviour can additionally be modified by keyword parameters.
  • Method PLOT (object &key &allow-other-keys)
    This around method handles the *plot* parameter and returns the object such that specialized methods do not have to care about this.
  • Method PLOT (object &key &allow-other-keys)
    This around method handles the *plot* parameter and returns the object such that specialized methods do not have to care about this.
  • Method PLOT (object &key &allow-other-keys)
    This around method handles the *plot* parameter and returns the object such that specialized methods do not have to care about this.
  • Method PLOT (object &rest key-args &key (program *default-graphic-program*) &allow-other-keys)
    Default method which might be overridden by other, e.g. for preprocessing the keyword argument list.
  • Method PLOT (object &rest key-args &key (program *default-graphic-program*) &allow-other-keys)
    Default method which might be overridden by other, e.g. for preprocessing the keyword argument list.
  • Method PLOT (object &rest key-args &key (program *default-graphic-program*) &allow-other-keys)
    Default method which might be overridden by other, e.g. for preprocessing the keyword argument list.
  • Method PLOT ((skel <skeleton>) &rest rest &key transformation &allow-other-keys)
  • Method PLOT ((cell <cell>) &rest rest)
  • Method PLOT ((asv <ansatz-space-vector>) &rest rest &key cells depth (index 0) (component 0) key transformation (rank 0) shape part &allow-other-keys)
    Plots a certain component of the ansatz space vector @arg{asv}, e.g. pressure for Navier-Stokes equations. @arg{index} chooses one of several solutions if @arg{asv} has multiplicity larger 1.
  • Method PLOT ((problem <pde-problem>) &rest rest &key mesh (refinements 0) (depth 0) (key #'identity) parametric coefficient (rank 0) shape &allow-other-keys)
    Plots a coefficient function for the problem on the given mesh. Does handle coefficients depending on finite element functions.
  • Method PLOT ((f <function>) &rest rest &key cells mesh domain parametric (depth 0) (key #'identity) (refinements 0) &allow-other-keys)
    Plots @arg{function} on the given cell list @arg{cells}. If @arg{cells} is empty, the highest-dimensional cells of @arg{mesh} are used. If this is NIL, then a temporary mesh on @arg{domain} is creatend and refined up to level @arg{refinements}. Each cell is additionally refined @arg{depth} times.
  • Method PLOT ((asa <ansatz-space-automorphism>) &rest rest)
  • Method PLOT ((polygons list) &rest rest &key &allow-other-keys)
  • Method PLOT ((pic picture) &key &allow-other-keys)

FL.PICTURE

This package provides routines for handling pictures.  A
picture is implemented as a full-tensor of rank 2 or 3.
  • Class PICTURE
    Mixin for pictures.
    No slots.
  • Function PICTURE (type)
    Construct a picture with entries of @arg{type}.
  • Function PICTURE-WIDTH (pic)
  • Function PICTURE-HEIGHT (pic)
  • Function PIC-REF (pic i j)
  • Function (setf PIC-REF) (value pic i j)
  • Function MAKE-PICTURE (width height &key (element-type 'single-float))
  • Generic-Function WRITE-PICTURE-TO-STREAM (stream pic &key &allow-other-keys)
  • Method WRITE-PICTURE-TO-STREAM (stream (pic picture) &key (type :jpg))
  • Generic-Function WRITE-PICTURE-TO-FILE (pic &key &allow-other-keys)
  • Method WRITE-PICTURE-TO-FILE (pic &key (filename *plot-picture-file*) (type :jpg))
  • Function UNSIGNED-BYTE-PICTURE (pic)

FL.STRATEGY

This package provides methods for solving problems by
adaptive FEM.
  • Class <STRATEGY>  (<ITERATIVE-SOLVER>)
    A strategy is an iteration for solving a problem defined on a blackboard.
    No slots.
  • Generic-Function ESTIMATE (error-estimator blackboard)
    Yields both local and global estimate.
  • Method ESTIMATE ((errest <error-estimator>) blackboard)
    Executes local and global error estimation in sequence.
  • Class <PROJECTION-ERROR-ESTIMATOR>  (<DIFFERENCE-WITH-PROJECTION>, <GLOBAL-AND-LOCAL-NORM>, <STANDARD-ERROR-ESTIMATOR>)
    Estimates the error by measuring the difference between the solution and a projected solution in a hierarchical mesh by a certain norm given by local-p and global-p.
    No slots.
  • Class <DUALITY-ERROR-ESTIMATOR>  (<SETUP-ENRICHED-ANSATZ-SPACE>, <SOLVE-DUAL-PROBLEM>, <LOCAL-TEST-WITH-DUAL>, <STANDARD-ERROR-ESTIMATOR>)
    Estimates the error by testing the difference z-IPz against the residual. Here z is the solution of a dual problem in an enriched finite element space.
    No slots.
  • Class <REFINEMENT-INDICATOR>
    An indicator is used as first argument in the generic functions indicate which works on a blackboard. Based on the quantities computed by an error estimator, i.e. eta, indicate puts a list of elements to be refined on the blackboard. When ensure-mesh-quality is t, the indicator ensures that the difference of mesh widths of neighboring cells does not become larger than a factor of 4.
    ENSURE-MESH-QUALITY   Accessor: ENSURE-MESH-QUALITY
  • Generic-Function INDICATE (indicator blackboard)
    Puts a list of elements to be refined on the blackboard.
  • Method INDICATE (indicator blackboard)
    This around-method refines a cell if it detects a side that is refined more than two times. Thus, a maximum of two refinement levels between side-adjacent cells is ensured.
  • Class <UNIFORM-REFINEMENT-INDICATOR>  (<REFINEMENT-INDICATOR>)
    Marks all cells for refinement.
    No slots.
  • Method INDICATE ((indicator <uniform-refinement-indicator>) blackboard)
    Marks all cells for refinement which have no parent or for which the error estimator yields a large eta.
  • Class <REGION-INDICATOR>  (<REFINEMENT-INDICATOR>)
    Marks all cells in a region for refinement.
    IN-REGION   Reader: IN-REGION
  • Method INDICATE ((indicator <region-indicator>) blackboard)
    Marks all cells for refinement which have no parent or for which the error estimator yields a large eta.
  • Method INDICATE ((indicator <isotropizing-refinement-indicator>) blackboard)
  • Class <LARGEST-ETA-INDICATOR>  (<REFINEMENT-INDICATOR>)
    Puts the fraction of the cells with the largest error contributions in the refinement table. Note that a fraction of 1.0 yields uniform refinement. Below from-level, global refinement is used. block-p indicates that all children of a parent cell have to be refined at once.
    FRACTION   Reader: FRACTION
    PIVOT-FACTOR   Reader: PIVOT-FACTOR
    FROM-LEVEL   Reader: FROM-LEVEL
    BLOCK-P   Reader: BLOCK-P
  • Method INDICATE ((indicator <largest-eta-indicator>) blackboard)
    Marks all cells for refinement which have no parent or for which the error estimator yields a large eta.
  • Variable *ETA-OBSERVE*
    (list "      eta" "~9,2,2e"
          #'(lambda (fl.utilities:blackboard)
              (fl.utilities:getbb fl.utilities:blackboard :global-eta)))
    Observe an estimate of the global error.
  • Class <FE-APPROXIMATION>  (<STRATEGY>)
    This class describes iterative finite element appoximation strategies.
    OBSERVE
    Providing initform for <iteration> slot.
    PLOT-MESH
    Plot the mesh at the beginning and after changes. Can be a function in which case it is called on the mesh to do the plotting.
    FE-CLASS   Reader: FE-CLASS
    The class of finite element. If it is not set, it is automatically chosen.
    ESTIMATOR
    The error estimator, which computes information on the error distribution in a hash-table in the :ETA-field on the blackboard, as well as a global estimate in :GLOBAL-ETA which can be used to terminate the iteration.
    INDICATOR
    The error indicator which marks cells for local refinement. Usually, this procedure will be based on the error distribution approximated in the :ETA-field on the blackboard.
  • Class <FE-INTERPOLATION>  (<FE-APPROXIMATION>)
    This class implements adaptive finite element interpolation of the given coefficient function as a variant of finite element approximation.
    COEFFICIENT
    A coefficient determining the function to be interpolated.
  • Variable *MENTRIES-OBSERVE*
    (list " mentries" "~9/fl.utilities:kmgt/"
          #'(lambda (fl.utilities:blackboard)
              (fl.macros:acond
               ((fl.utilities:getbb fl.utilities:blackboard :discretized-problem)
                (fl.matlisp:total-entries (fl.problem:matrix fl.macros:it)))
               (t nil))))
    Observe entries for the size of the matrix.
  • Variable *STATIONARY-FE-STRATEGY-OBSERVE*
    fl.strategy::*fe-approximation-observe*
    Standard observe quantities for stationary finite element strategies.
  • Class <STATIONARY-FE-STRATEGY>  (<FE-APPROXIMATION>)
    This class describes some iterative finite element solution strategies for continuous, stationary PDE problems.
    OBSERVE
    SOLVER
    The solver for solving the discretized systems.
  • Class <ROTHE>  (<ITERATION>)
    Rothe strategy for time-dependent problems. The idea of the Rothe method for solving @math{U_t +A U =f} is to do an ODE time-stepping scheme in an infinite-dimensional function space. Therefore, in every time-step, the solution has to be approximated sufficiently well in the space variable.
    MODEL-TIME   Accessor: MODEL-TIME
    Current time in the time-stepping scheme.
    TIME-STEP   Accessor: TIME-STEP
    SCHEME   Reader: TIME-STEPPING-SCHEME
    Time-stepping scheme, e.g. @code{:implicit-euler} or @code{:crank-nicolson}.
    STATIONARY-SUCCESS-IF
    STATIONARY-FAILURE-IF
    PLOT
    OBSERVE
    Providing initform for <iteration> slot.

Also exports

  • FL.UTILITIES:KMGT

FL.DOMAINS

Femlisp package for domain definitions.
  • Function CIRCLE-RING-DOMAIN (r1 r2 &key (interior-p t) (channel-breadth 0.0d0) flipped-p)
  • Function CYLINDER-DOMAIN (r h &key flipped-p)
  • Function OSCILLATING-BOUNDARY-DOMAIN (dim f &key grad-f (upper t))
    Returns a domain with an oscillating lower boundary at $x_n=-1$ where the oscillation is defined by a scaling function $f$ with values in $R^+$. Usually, also $grad-f$ should be provided, because it makes possible an enhanced domain approximation.
  • Function SINUSOIDAL-BL-CELL (dim &rest rest &key (amplitude 0.15d0) (shift 1.0d0) &allow-other-keys)
    Returns a boundary layer cell with a sinusoidally oscillating lower boundary.
  • Function SPLINE-INTERPOLATED-BL-CELL (heights)
    Boundary which is interpolated from heights.
  • Function BL-PATCH-ON-LOWER-BOUNDARY (bl-domain patch)
    Returns T if the patch is on the lower oscillating boundary.
  • Function BL-PATCH-ON-PELLET-BOUNDARY (bl-domain patch)
    Returns T if the patch is on the pellet.
  • Function BL-PATCH-ON-UPPER-BOUNDARY (bl-domain patch)
    Returns T if the patch is on the upper boundary.
  • Function BL-PATCH-ON-ARTIFICIAL-BOUNDARY (bl-domain patch)
    Returns the artificial boundary on which the distributional source acts.
  • Function N-CUBE-WITH-CUBIC-HOLE (dim)
    Generates an n-cube-domain with an n-cube hole.
  • Function N-CELL-WITH-CUBIC-HOLE (dim)
    Generates an n-dimensional cell domain with an n-cube hole.
  • Function N-CUBE-WITH-ELLIPSOIDAL-HOLE (dim &key a)
    Generates an n-cube-domain with an ellipsoidal hole satisfying (Ax,x)=1 using n-cube patches.
  • Function N-CELL-WITH-ELLIPSOIDAL-HOLE (dim &key a)
    Generates an n-dimensional cell domain with an ellipsoidal hole.
  • Function N-CUBE-WITH-BALL-HOLE (dim &key (radius 0.25d0))
    Generates an n-cube-domain with an n-ball hole using n-cube patches.
  • Function N-CELL-WITH-BALL-HOLE (dim &key (radius 0.25d0))
    Generates an n-dimensional cell domain with an n-ball hole.
  • Function PATCH-ON-INNER-BOUNDARY-P (patch)
    Checks if the patch is part of the hole boundary.
  • Function PATCH-ON-N-CUBE-BOUNDARY-P (patch)
    Returns T, if the patch is on the boundary of the n-cube.
  • Function N-CUBE-WITH-CUBIC-INLAY (dim)
    Generates an n-cube-domain with an n-cube inlay.
  • Function N-CELL-WITH-CUBIC-INLAY (dim)
    Generates an n-dimensional cell domain with an n-cube hole.
  • Function N-CUBE-WITH-BALL-INLAY (dim &key (radius 0.25d0))
    Generates an n-cube-domain with an n-ball inlay using n-cube patches.
  • Function N-CELL-WITH-BALL-INLAY (dim &key (radius 0.25d0))
    Generates an n-dimensional cell domain with an n-ball inlay.
  • Function PATCH-IN-INLAY-P (patch)
    Checks if the patch is part of the inlay including its boundary. This is done by checking if all corners lie in the interior of the unit cell.

FL.APPLICATION

This package uses most other Femlisp packages.  It is
meant to be the package a Femlisp user works in.
  • Variable *RESULT*
    nil
    Special variable used for storing the blackbboard of the last computation.
  • Macro STORING (&body body)
    Stores the result of @arg{body} in @var{*result*}.

Also exports

  • FL.PORT:QUIT

FL.KONWIHR

Special package for the KONWIHR demo problem.
  • Function KONWIHR-PAPER-MAX-LEVELS
  • Function KONWIHR-SPEED
    Returns estimated speed of the current Femlisp in MLOPS.
  • Variable *KONWIHR-INITIALIZED*
    nil
    A flag keeping track, if the setup for these tests has already been performed.
  • Function INITIALIZE-KONWIHR-PAPER-CALCULATION
  • Function HEISIG-NEUSS-2017-DEMO (problem &key order levels (output 1) distributed-p (initial-mesh-refinements 0))
    This is a slightly trimmed copy of the function @function{elasticity-interior-effective-coeff-demo}.
  • Variable *HEISIG-NEUSS-2017-DEMO*
    (fl.demo:make-demo :name "heisig-neuss-2017" :short
                       "calculations from the paper by m. heisig and n. neuss 2017"
                       :long
                       (format nil
                               "these are the benchmark calculations from a paper by
    m. heisig and n. neuss.  this paper reports work done in a
    konwihr project and was submitted to the acm jae in january
    2017.
    
    the benchmark problem considered here is calculating a 3d linear
    elasticity problem on a representative cell with a hole.  finite
    elements of order 5 are used.
    
    these calculations need a lot of memory, namely about
    8^(nr_of_levels-2) gb.  for the serial and shared-memory
    parallel calculations this must be provided at startup,
    e.g. using the --dynamic-space-size switch for sbcl/femlisp.
    
    the currently running femlisp has ~3,2f gb available, thus the
    allowed choice for the number of levels will be restricted to
    the range 1-~d."
                               (* (fl.port:dynamic-space-size) 1.d-9)
                               (fl.konwihr:konwihr-paper-max-levels)))

Also exports

  • FL.APPLICATION:ELASTICITY-INTERIOR-EFFECTIVE-COEFF-DEMO
  • FL.APPLICATION:ELASTICITY-INLAY-CELL-PROBLEM
  • FL.APPLICATION:*ARTICLES-DEMO*

femlisp-basic

FL.START

This package contains some routines called
during initialization of Femlisp.
  • Variable *FEMLISP-VERSION*
    "2.0.1"
  • Function FEMLISP-PATHNAME (&optional (namestring ""))
    Get pathname relative to the Femlisp directory.
  • Variable *DX-PATH*
    nil
    Path to the @program{DX} executable.
  • Variable *GNUPLOT-PATH*
    nil
    Path to the @program{Gnuplot} executable.
  • Variable *TETGEN-PATH*
    nil
    Path to the @program{tetgen} executable.
  • Variable *IMAGES-DIRECTORY*
    nil
    Directory where images are put by default.
  • Variable *MESHES-DIRECTORY*
    nil
    Directory where meshes are put by default.
  • Variable *BLAS-LIBRARY*
    (or (probe-file #p"femlisp:interface;mkl.so") "libblas.so")
    BLAS library path. If the value is NIL, the BLAS library is searched for in standard library paths. If the value is :none, no external BLAS routines are used.
  • Variable *LAPACK-LIBRARY*
    (or "liblapack.so")
    LAPACK library path. If the value is NIL, the LAPACK library is searched for in standard library paths. If the value is :none, no external LAPACK routines are used.
  • Variable *SUPERLU-LIBRARY*
    nil
    Wrapper for SuperLU, if available.
  • Variable *UMFPACK-LIBRARY*
    nil
    Wrapper for UMFPACK, if available.

FL.DEBUG

This package adds debugging tools to Femlisp.  This is a
slightly modified version of the debugging suite proposed in @cite{(Norvig
1992)}.
  • Function DBG-P (id)
    Returns T if @arg{id} is in the debug list, NIL otherwise.
  • Function DBG-ON (&rest ids)
    Register ids for dbg.
  • Function DBG-OFF (&rest ids)
    Stop debugging on the passed symbols. With no arguments, stop debugging altogether.
  • Macro DBG-WHEN (id &body body)
    Perform a check only if debugging @arg{id}.
  • Generic-Function DBG (id format-string &rest args)
    When debugging on @arg{id} print out the arguments @arg{args} using the format in @arg{format-string}.
  • Method DBG (id format-string &rest args)
  • Method DBG (id format-string &rest args)
  • Method DBG (id format-string &rest args)
  • Macro DBG-SHOW (id &rest args)
  • Macro DBG-PRINT (id &rest args)
  • Generic-Function DBG-INDENT (id indent format-string &rest args)
    When debugging @arg{id}, print out the arguments @arg{args} using the format in @arg{format-string} with indentation given by @arg{indent}.
  • Method DBG-INDENT (id indent format-string &rest args)
  • Method DBG-INDENT (id indent format-string &rest args)
  • Method DBG-INDENT (id indent format-string &rest args)

FL.TESTS

This package provides routines for building a simple
regression test suite.  Most files in @femlisp{} contain a test function at
the end which checks several critical features which the file or module
provides.  By calling the function @function{adjoin-test} at load time,
this function is added to a list of functions to be checked.  After loading
@femlisp{}, all functions in this list can be executed one after the other
by calling the function @function{test-femlisp}.  Errors and exceptions are
registered and finally reported.  It is very much recommended to run this
test suite before a release.
  • Function ADJOIN-TEST (fsym)
    Adjoins a test to the Femlisp test suite.
  • Macro SMALL-TEST (fsym &body body)
    At the moment small tests are ignored. One might think of collecting them when compiling a certain file.
  • Function REMOVE-TEST (fsym)
    Adjoins a test to the Femlisp test suite.
  • Function TEST-FEMLISP (&key continue package (logfile (fl.start:femlisp-pathname "fltest.log")) (demo t))
    Runs the Femlisp test suite. The result is printed to *standard-output*.

FL.PATCHES

  • Function MAKE-HASH-TABLE (&rest args)

FL.MACROS

This package contains some basic macro definitions used in Femlisp.
  • Macro WITH-GENSYMS (syms &body body)
    Standard macro providing the freshly generated symbols @arg{syms} to the code in @arg{body}.
  • Macro ONCE-ONLY (variables &rest body)
    Slightly modified macro taken from <http://groups.google.com/comp.lang.lisp/msg/2a92ad69a8185866>.
  • Function SYMCONC (&rest args)
    This function builds a symbol from its arguments and interns it. This is used in some macros.
  • Macro WHEREAS (clauses &body body)
    Own implementation of the macro @function{whereas} suggested by Erik Naggum (c.l.l., 4.12.2002).
  • Macro AIF (test-form then-form &optional else-form)
  • Macro BIF ((bindvar boundform) yup &optional nope)
    Posted to cll by Kenny Tilton 22.4.2007.
  • Macro AWHEN (test-form &body body)
    Anaphoric macro from @cite{(Graham 1993)}.
  • Macro AAND (&rest args)
    Anaphoric macro from @cite{(Graham 1993)}.
  • Macro ACOND (&rest clauses)
    Anaphoric macro from @cite{(Graham 1993)}.
  • Macro GENCASE (obj test &body clauses)
    An analog to case using @arg{test} as comparison.
  • Macro STRINGCASE (string &body clauses)
    An analog to case using string comparison.
  • Macro SYMBOL-MACROLETF ((&rest bindings) &body body &environment environment)
    Like SYMBOL-MACROLET but evaluate subforms just once up front.
  • Macro DELETEF (item sequence &rest args)
    Delets @arg{item} from @arg{sequence} destructively.
  • Macro _F (op place &rest args)
    Macro from @cite{(Graham 1993)}. Turns the operator @arg{op} into a modifying form, e.g. @code{(_f + a b) @equiv{} (incf a b)}.
  • Macro ENSURE (place newval &environment env)
    Essentially (or place (setf place newval)). Posted by Erling Alf to c.l.l. on 11.8.2004, implementing an idea of myself posted on c.l.l. on 30 Jul 2004 in a probably more ANSI conforming way.
  • Macro ECHO (ekx-id &rest body)
    Posted to cll at 17.10.2006 by Kenny Tilton.
  • Macro REMOVE-THIS-METHOD (gf-name &rest rest)
    Removes the method for the generic function @arg{gf-name} which is specified by @arg{qualifiers} and @arg{specializers}. Example: @lisp (remove-this-method m* :before ((mat <matrix>) (x <vector>))) @end lisp It should be possible to use this directly on a copied first line of a DEFMETHOD definition.
  • Macro NAMED-LET (name bindings &body body)
    Implements the named-let construct from Scheme.
  • Macro MULTI-FOR ((var start stop &key from-end) &body body)
    Loops for @arg{var} being an integer vector starting from @arg{start} upto @arg{stop}. Examples: @lisp (multi-for (x #(1 1) #(3 3)) (princ x) (terpri)) (multi-for (x #(1 1) #(3 3) :from-end t) (princ x) (terpri)) @end lisp
  • Macro MULTI-DOTIMES ((var stop) &body body)
    Special case of @func{multi-for}. Loops starting from a zero-vector to @arg{stop}. Examples: @lisp (multi-dotimes (x #(3 3)) (princ x) (terpri)) @end lisp
  • Macro WITH-ARRAYS (syms &body body)
    Improved version of a macro posted in cll by ?. A similar but more restricted macro was posted by KMP at 8.5.2007 under the name 'array-access'.
  • Macro INLINING (&rest definitions)
    Declaims the following definitions inline together with executing them.
  • Macro DEFINLINE (name &rest rest)
    Short form for defining an inlined function. It should probably be deprecated, because it won't be recognized by default by some IDEs. Better use the inlining macro directly.
  • Macro MULTIPLE-DEFGEN (names args)
    Defines multiple generic functions at once. Usually, this will only be used for helper functions.
  • Macro ?1 (&rest args)
    A macro returning the first of its arguments.
  • Macro ?2 (&rest args)
    A macro returning the second of its arguments.
  • Macro ?3 (&rest args)
    A macro returning the third of its arguments.
  • Macro ?4 (&rest args)
    A macro returning the fourth of its arguments.
  • Macro ?5 (&rest args)
    A macro returning the fifth of its arguments.
  • Macro ?6 (&rest args)
    A macro returning the sixth of its arguments.
  • Macro FLUID-LET (bindings &body body)
    Sets temporary bindings.
  • Macro SHOW-CALL (func &optional name)
    Wraps a function object inside a trace form.
  • Macro LRET (bindings &body body)
    A @function{let}-construct which returns its last binding.
  • Macro LRET* (bindings &body body)
    A @function{let*}-construct which returns its last binding.
  • Macro _ (&body body)
    Easy definition of anonymous small functions. Arguments are '_', '_1', ..., '_5'.
  • Macro QUICKLY (&body forms)
  • Macro VERY-QUICKLY (&body forms)
  • Macro SLOWLY (&body forms)
  • Variable *USUALLY*
    t
  • Macro USUALLY-QUICKLY (&body forms)
  • Macro QUICKLY-IF (test &body forms)

FL.PORT

This package should contain the implementation-dependent
parts of Femlisp with the exception of the MOP.  It serves a similar
purpose as the PORT module in CLOCC and is somewhat inspired by this
module.  It will be dropped when there is a portable and easily installable
alternative in all CL implementations we are interested in
  • Function PORTABILITY-WARNING (function &rest args)
  • Function COMPILE-SILENTLY (name source)
    Compiles @arg{source} silently.
  • Function RUNTIME-COMPILE (source)
    Calls compile on the provided @arg{source}. When :compile is activated for debugging, the source code is printed.
  • Function COMPILE-AND-EVAL (source)
    Compiles and evaluates the given @arg{source}. This should be an ANSI compatible way of ensuring method compilation.
  • Function DYNAMIC-SPACE-SIZE
    Available memory for calculations
  • Function HOSTNAME
    Returns the hostname.
  • Function FIND-EXECUTABLE (name)
    Finds an executable in the current path.
  • Function FIND-SHARED-LIBRARY (name)
    Finds a shared library.
  • Function GETENV (var)
    Return the value of the environment variable.
  • Function UNIX-CHDIR (path)
    Change the directory to @arg{path}.
  • Function SYSTEM-NAMESTRING (path)
  • Function RUN-PROGRAM (program args &key wait directory (search t) input (output nil output-p) error-output)
    Runs @arg{program} with arguments @arg{args}.
  • Function RUN-PROGRAM-REPORT-ERRORS (&rest args)
  • Function PROCESS-INPUT (process)
    Process-input for @arg{process}.
  • Function PROCESS-OUTPUT (process)
    Process-output for @arg{process}.
  • Function PROCESS-ERROR (process)
    Process-output for @arg{process}.
  • Function PROCESS-CLOSE (process)
    Closes @arg{process}.
  • Function PROCESS-STATUS (process)
    Returns the status of @arg{process}.
  • Function KILL-PROCESS (process)
    Kills the given process
  • Function RUN-PROGRAM-OUTPUT (program args)
    Returns a list of all lines of the output of @function{RUN-PROGRAM} when called with the arguments @arg{PROGRAM} and @arg{ARGS}.
  • Function LOAD-FOREIGN-LIBRARY (file)
    Loads the foreign library @arg{file}.
  • Function CONVERT-TYPE (type)
  • Macro SIMPLIFIED-DEF-FUNCTION ((c-name lisp-name) args &rest keys)
  • Macro DEF-FUNCTION (&rest args)
    Defines a foreign function. See examples in @path{alien;src;superlu.lisp}.
  • Function VECTOR-SAP (ptr)
    Returns an array pointer which can be used in a foreign call.
  • Function FOREIGN-CALL (function &rest args)
    Ensures a safe environment for a foreign function call, especially so that no GC changes array pointers obtained by @function{vector-sap}.
  • Function MAKE-WEAK-POINTER (obj)
    Creates a weak pointer pointing to @arg{obj}.
  • Function WEAK-POINTER-VALUE (wp)
    Returns the value of the weak pointer @arg{wp}.
  • Function FINALIZE (obj func)
    Sets up @arg{func} as finalizer for @arg{obj}.
  • Function GC (&rest args)
  • Function ADD-EXIT-HOOK (hook)
  • Function SAVE-FEMLISP-CORE-AND-DIE (&optional core-file-name)
    Saves Femlisp core and quits.

FL.UTILITIES

This package contains generally useful utility functions.  Several of
those functions were taken from @cite{(Graham 1996)}, the SANS function was
contributed to the @cite{comp.lang.lisp} newsgroup by Erik Naggum.
  • Function REQUIRED-ARGUMENT
    Calling this function results in an error. Such a call may be used as default form when an argument should be supplied.
  • Generic-Function EVALUATE (f x)
    Generic evaluation of functions on an argument. Numbers and arrays are treated as constants. Special evaluation is defined for multivariate polynomials on vectors and for <function> objects.
  • Method EVALUATE ((f function) x)
    Lisp functions are evaluated by @function{funcall}.
  • Method EVALUATE ((f function) x)
    Lisp functions are evaluated by @function{funcall}.
  • Method EVALUATE ((f function) x)
    Lisp functions are evaluated by @function{funcall}.
  • Method EVALUATE (object x)
    The default method treats object as a constant function. This is a dubious feature on which one should probably not rely.
  • Method EVALUATE (object x)
    The default method treats object as a constant function. This is a dubious feature on which one should probably not rely.
  • Method EVALUATE (object x)
    The default method treats object as a constant function. This is a dubious feature on which one should probably not rely.
  • Generic-Function COMPOSE-2 (f g)
    Composes two function objects @arg{f} and @arg{g}.
  • Method COMPOSE-2 (f g)
  • Method COMPOSE-2 (f g)
  • Method COMPOSE-2 (f g)
  • Function COMPOSE (&rest functions)
    Returns the composition of @arg{functions}.
  • Function CURRY (func &rest args)
    Supplies @arg{args} to @arg{func} from the left.
  • Function RCURRY (func &rest args)
    Supplies @arg{args} to @arg{func} from the right.
  • Function SANS (plist &rest keys)
    Removes the items marked by @arg{keys} from the property list @arg{plist}. This function was posted at 2.12.2002 to the @emph{comp.lang.lisp} newsgroup by Erik Naggum.
  • Function XOR (a b)
  • Function FACTORIAL (n)
    Compute the factorial of @arg{n}. @arg{n} can also be a list of numbers in which case the product of the factorials of the components is computed.
  • Function SQUARE (x)
    Return the square of @arg{x}.
  • Function BOX (object)
    Boxes an object.
  • Function UNBOX (box)
    Getter for a boxed object.
  • Function (setf UNBOX) (value box)
    Setter for a boxed object.
  • Generic-Function FOR-EACH (func collection)
    Applies @arg{func} to each element of @arg{collection}.
  • Method FOR-EACH ((func function) (seq sequence))
    Applies @arg{func} to each element of the sequence @arg{seq}.
  • Method FOR-EACH ((func function) (seq sequence))
    Applies @arg{func} to each element of the sequence @arg{seq}.
  • Method FOR-EACH ((func function) (seq sequence))
    Applies @arg{func} to each element of the sequence @arg{seq}.
  • Function PARTIAL-SUMS (seq)
    Returns a sequence of the same type as @arg{seq} consisting of its partial sums.
  • Macro MAPF (var func)
    Replaces the value of the variable @arg{var} by setting it to its map with @arg{func}.
  • Function VECTOR-MAP (func &rest vecs)
    Map @arg{vec} with @arg{func} to a vector of the same type.
  • Type POSITIVE-FIXNUM
    Positive fixnum tpye.
  • Type FIXNUM-VEC
    Vector with elements of type @code{fixnum}.
  • Function FIXNUM-VEC (&rest elements)
    Returns a @symbol{FIXNUM-VEC} constructed from the parameters.
  • Function MAKE-FIXNUM-VEC (dim &optional (init 0))
    Construct a @symbol{FIXNUM-VEC} of size @arg{dim} initialized by @arg{init}.
  • Function VECTOR-CUT (vec comp)
  • Function VECTOR-LAST (vec)
    Reader for the last element of @arg{vec}.
  • Function (setf VECTOR-LAST) (value vec)
    Writer for the last element of @arg{vec}.
  • Function CONSTANT-VECTOR (dim value)
    Returns a uniform constant vector of which all elements are @arg{value}.
  • Function ZERO-VECTOR (dim element-type)
    Returns a uniform vector for the given element type filled with zeros.
  • Function TRANSLATE (item translations)
    Performs certain translations from an association table on the string item. Example: (translate "abcdefg" '(("a" . "x") ("b" . "yz")))
  • Function MAKE-DOUBLE-FLOAT-ARRAY (size &optional (initial 0.0d0))
  • Function FOR-EACH-TUPLE (func limits)
    Calls @arg{func} on each tuple greater or equal to (0 ... 0) and below @arg{dims}.
  • Macro DOTUPLE ((index limits &optional result) &body body)
    Loops through each tuple below @arg{limits}.
  • Function ARRAY-FOR-EACH (func &rest arrays)
    Calls @arg{func} on all element tuples of the array arguments.
  • Function MAKE-FILLED-ARRAY (dims &rest args &key initializer &allow-other-keys)
  • Function SAMEP (sequence &key (test #'eql) (key #'identity))
    Returns t if @arg{sequence} consists of equal elements.
  • Function MODIFY (lst &key add remove)
  • Function SINGLE? (lst)
  • Function RANGE<= (k l)
  • Function RANGE< (k l)
  • Function TAKE (k lst)
  • Function THRICE (x)
  • Function TWICE (x)
  • Function SPLIT-BY-LENGTH (items lengths)
    Breaks the list @arg{items} in pieces of lengths determined by @arg{nrins}. Example: @lisp (split-by-length '(1 2 3 4) '(1 3)) @result{} ((1) (2 3 4)) @end lisp
  • Function MAPPEND (func &rest lists)
    Map @function{func} over @arg{lists} while appending the results.
  • Function FILTER (item seq &rest rest &key test test-not &allow-other-keys)
    The positive REMOVE - i.e. like REMOVE with :test instead of :test-not.
  • Function FILTER-IF (&rest args)
    The positive version of REMOVE-IF-NOT.
  • Function MAP-PRODUCT (func list &rest rest-lists)
    Applies @arg{func} to a product of lists. Example: @lisp (map-product #'cons '(2 3) '(1 4)) @result{} ((2 . 1) (2 . 4) (3 . 1) (3 . 4)) @end lisp
  • Function MKLIST (obj)
    Wraps @arg{obj} in a list, if it is not already a list.
  • Function FIRST-ONLY (list)
    Checks if @arg{list} is a singleton and returns its first element.
  • Function CHECK-PROPERTIES (place properties)
    Checks if all of the @arg{properties} are in the property list @arg{place}.
  • Function ON-LEAVES (func tree)
    Executes @arg{func} on the leaves of @arg{tree}.
  • Function FIND-LEAF-IF (test tree &key (key #'identity))
    Finds a leaf in @arg{tree} where @arg{test} returns true.
  • Function FIND-LEAF (atom tree &key (key #'identity) (test #'eql))
    Finds atom in @arg{tree}.
  • Function MAP-TREE (func tree)
    Maps @arg{tree} using @arg{func}. Example: @lisp (map-tree #'1+ '((1 (2)))) @result{} ((2 (3))) @end lisp
  • Function FLATTEN (tree)
    Flatten a tree. Example: @lisp (flatten '((1 2) (3) ((4)))) @result{} (1 2 3 4) @end lisp
  • Function FLATTEN-1 (lst)
  • Function TREE-UNIFORM-NUMBER-OF-BRANCHES (tree)
  • Function TREE-UNIFORMP (trees)
  • Function ON-SUBTREES (func tree)
    Calls @arg{func} on every subtree of @arg{tree}.
  • Function FIND-SUBTREE-IF (test tree &key (key #'identity))
    Finds a leaf in @arg{tree} where @arg{test} returns true.
  • Function FIND-SUBTREE (atom tree &key (key #'identity) (test #'eql))
  • Generic-Function ENQUEUE (object queue)
    Puts @arg{object} into the @arg{queue}.
  • Method ENQUEUE (object (queue queue))
  • Method ENQUEUE (object (queue queue))
  • Method ENQUEUE (object (queue queue))
  • Generic-Function EMPTYP (queue)
    Tests if @arg{queue} is empty.
  • Method EMPTYP ((queue queue))
  • Method EMPTYP ((queue queue))
  • Method EMPTYP ((queue queue))
  • Method EMPTYP ((ht hash-table))
  • Method EMPTYP ((ht hash-table))
  • Method EMPTYP ((ht hash-table))
  • Method EMPTYP ((list list))
  • Method EMPTYP ((list list))
  • Method EMPTYP ((list list))
  • Generic-Function DEQUEUE (queue)
    Pops an object from @arg{queue}. Returns as second value T if the queue was empty.
  • Method DEQUEUE ((queue queue))
  • Method DEQUEUE ((queue queue))
  • Method DEQUEUE ((queue queue))
  • Function QUEUE->LIST (queue)
    Transforms @arg{queue} to a list.
  • Function LIST->QUEUE (list)
    Transforms @arg{list} to a queue.
  • Generic-Function DEQUEUE-ALL (queue)
    Clears @arg{queue} and returns content as a list.
  • Method DEQUEUE-ALL ((queue queue))
  • Method DEQUEUE-ALL ((queue queue))
  • Method DEQUEUE-ALL ((queue queue))
  • Struct DLL-ITEM
    OBJECT
    SUCC
    PRED
  • Function DLI-OBJECT (instance)
  • Function (setf DLI-OBJECT) (value instance)
  • Function DLI-SUCC (instance)
  • Function (setf DLI-SUCC) (value instance)
  • Function DLI-PRED (instance)
  • Function (setf DLI-PRED) (value instance)
  • Class DLL
    FIRST   Accessor: DLL-FIRST
    LAST   Accessor: DLL-LAST
  • Function MAKE-DLL
  • Function DLL-FRONT-INSERT (obj dll &optional insert-item-p)
    Inserts @arg{obj} in @arg{dll}. It returns the newly created @class{dll-item}.
  • Function DLL-REAR-INSERT (obj dll &optional insert-item-p)
    Inserts @arg{obj} in @arg{dll}. It returns the newly created @class{dll-item}.
  • Function DLL-REMOVE-ITEM (item dll)
  • Function DLL-FOR-EACH (func dll &optional (direction :forward))
  • Function DLL-FIND (key dll)
  • Function DLL-REMOVE (obj dll)
  • Function DLL-PEEK-FIRST (dll)
  • Function DLL-POP-FIRST (dll)
  • Function DLL-PEEK-LAST (dll)
  • Function DLL-POP-LAST (dll)
  • Function DLL->LIST (dll)
  • Function LIST->DLL (list)
  • Function DLL-EMPTY-P (dll)
  • Macro DOHASH ((looping-var hash-table) &body body)
    Loops through @arg{hash-table}. If @arg{looping-var} is an atom @emph{key}, loop through the keys; if it is a list of the form @emph{(value)} loop through the values; if it is a list of the form @emph{(key value)} loop through key and value.
  • Function MAP-HASH-TABLE (func hash-table)
    Call @arg{func} given in the first argument on each key of @arg{hash-table}. @arg{func} must return the new key and the new value as two values. Those pairs are stored in a new hash-table.
  • Function COPY-HASH-TABLE (hash-table)
    Copy @arg{hash-table}.
  • Function DISPLAY-HT (hash-table)
    Display @arg{hash-table} in the form key1 -> value1 ...
  • Function HASH-TABLE-KEYS (hash-table)
    Collect the keys of @arg{hash-table} into a list.
  • Function HASH-TABLE-VALUES (hash-table)
    Collect the values of @arg{hash-table} into a list.
  • Function MAP-LIST-IN-HASH-TABLE (func list &optional (type 'eql))
    Maps the elements of @arg{list} in a hash-table identified by @arg{identifier}. @arg{func} is evaluated on each element and produces two values which are used as key and value for the hash-table.
  • Function GROUP-BY (characteristic seq &key (test 'eql))
    Groups elements in the sequence @arg{seq} according to @arg{characteristic} which is a function of one argument. Example: @lisp (group-by #'second '((1 2) (2 2) (3 4) (4 4))) @end lisp
  • Class RANGE
    Range of numbers for iteration.
    FROM
    Start of range, defaults to 0.
    TO
    Inclusive end of range, defaults to infinity.
    BELOW
    Exclusive end of range, defaults to infinity.
    BY
    Step size.
  • Function RANGE (&rest args &key to below)
    Constructor for a range of numbers.
  • Generic-Function ITERATOR (x)
    Returns an iterator for @arg{x}.
  • Method ITERATOR ((x range))
  • Method ITERATOR ((x range))
  • Method ITERATOR ((x range))
  • Generic-Function ITERATOR-NEXT (vec iterator)
    Returns an incremented @arg{iterator}.
  • Method ITERATOR-NEXT ((vec list) tail)
  • Method ITERATOR-NEXT ((vec list) tail)
  • Method ITERATOR-NEXT ((vec list) tail)
  • Method ITERATOR-NEXT ((vec vector) i)
  • Method ITERATOR-NEXT ((vec vector) i)
  • Method ITERATOR-NEXT ((vec vector) i)
  • Method ITERATOR-NEXT ((range range) i)
  • Method ITERATOR-NEXT ((range range) i)
  • Method ITERATOR-NEXT ((range range) i)
  • Generic-Function ITERATOR-END-P (vec iterator)
  • Method ITERATOR-END-P ((vec list) tail)
  • Method ITERATOR-END-P ((vec list) tail)
  • Method ITERATOR-END-P ((vec list) tail)
  • Method ITERATOR-END-P ((vec vector) i)
  • Method ITERATOR-END-P ((vec vector) i)
  • Method ITERATOR-END-P ((vec vector) i)
  • Method ITERATOR-END-P ((range range) i)
  • Method ITERATOR-END-P ((range range) i)
  • Method ITERATOR-END-P ((range range) i)
  • Generic-Function REFERENCE (vec iterator)
    Reader for the element of @arg{vec} referenced by @arg{iterator}.
  • Method REFERENCE ((vec list) tail)
  • Method REFERENCE ((vec list) tail)
  • Method REFERENCE ((vec list) tail)
  • Method REFERENCE ((vec vector) i)
  • Method REFERENCE ((vec vector) i)
  • Method REFERENCE ((vec vector) i)
  • Generic-Function (setf REFERENCE) (value vec iterator)
    Setter for the element of @arg{vec} referenced by @arg{iterator}.
  • Method (setf REFERENCE) (value (vec list) tail)
  • Method (setf REFERENCE) (value (vec list) tail)
  • Method (setf REFERENCE) (value (vec list) tail)
  • Method (setf REFERENCE) (value (vec vector) i)
  • Method (setf REFERENCE) (value (vec vector) i)
  • Method (setf REFERENCE) (value (vec vector) i)
  • Macro LOOP+ (items &body body)
    Iterates @arg{body} over @arg{items}. Example: @lisp (let ((x (make-array 10)) (y (make-list 10 :initial-element 1))) (loop+ ((xc x) (yc y) i) doing (setf xc (+ i yc)) finally (return x))) @end lisp
  • Function MEMOIZE-1 (func &key (test 'eql))
    Memoizes the function @arg{func} which should be a non-recursive function of one argument.
  • Function MEMOIZE-SYMBOL (funsym &key (test 'equal))
    Memoizes multi-argument functions named by the symbol @arg{funsym}.
  • Function GETA (alist key)
    An analog to @code{GETF} for association lists.
  • Class BLACKBOARD
    A blackboard where data items can be put and extracted using the function @code{GETBB}.
    ITEMS
    A property list of items on the blackboard.
  • Function BLACKBOARD (&rest items)
    Make the property list supplied in @arg{items} into a blackboard. Copies @arg{items} to make sure that no literal list is modified.
  • Function GETBB (blackboard key &optional default)
    Get the item for @arg{key} from @arg{blackboard}. If there is no such @arg{key} return @arg{default}.
  • Function (setf GETBB) (value blackboard key)
    Setter corresponding to @code{GETBB}.
  • Macro WITH-ITEMS (properties blackboard-form &body body)
    Work with the items on @arg{blackboard} corresponding to @arg{properties}. If some property is a list, the second element is the default value and the third is an alias to be used to refer to this parameter. Example: @lisp (with-items (&key sol (rhs nil rhs-high)) blackboard (setq sol rhs-high)) @end lisp
  • Function TRANSFER-BB (from-bb to-bb items &key ensure)
    Transfer @arg{items} between the blackboards @arg{from-bb} and @arg{to-bb}. When @arg{ensure} is set, an existing item is not modified.
  • Function SET-P (list)
    Checks if @arg{list} is a set, i.e. if no members occur twice.
  • Function SET-EQUAL (set1 set2 &key (test #'eql))
    Tests two sets for equality, e.g. @lisp (set-equal '(a b) '(b a)) @result{} T @end lisp
  • Function MAXIMALLY-CONNECTED (connected disconnected &key (test #'eql) (combine #'adjoin))
    Finds a maximally connected set by taking the union of the elements in connected with the sets of disconnected-sets. Returns the maximally connected sets and the remaining disconnected ones. Example: @lisp (maximally-connected '(1 2) '((3 4) (2 3) (5 6)) :test #'intersection :combine #'union) @result{} (1 2 3 4), ((5 6)) @end lisp
  • Function ORDERED-SET-DIFFERENCE (set1 set2 &key (test #'eql))
  • Function ORDERED-INTERSECTION (set1 set2 &key (test #'eql))
  • Function ORDERED-UNION (set1 set2 &key (test #'eql))
  • Function K-SUBSETS (set k)
    Returns all subsets of @arg{set} with length @arg{k}. Example: @lisp (k-subsets '(1 2 3) 2) @result{} ((1 2) (1 3) (2 3)) @end lisp
  • Function K->L-SUBSETS (set k l)
    Returns all subsets of @arg{set} with length between @arg{k} and @arg{l}. Example: @lisp (k->l-subsets '(1 2 3) 1 2) @result{} ((1) (2) (3) (1 2) (1 3) (2 3)) @end lisp
  • Function SUBSETS (set)
    Returns a list of all subsets of @arg{set}.
  • Function NONEMPTY-SUBSETS (set)
    Returns a list of all nonempty subsets of @arg{set}.
  • Function N-PARTITIONS-OF-K (n k)
    Returns a list of all ordered partitions of @arg{k} into @arg{n} natural numbers. Example: @lisp (n-partitions-of-k 2 3) @result{} ((0 3) (1 2) (2 1) (3 0)) @end lisp
  • Function POSITIVE-N-PARTITIONS-OF-K (n k)
    Returns a list of all positive ordered partitions of @arg{k} into @arg{n} natural numbers. Example: @lisp (positive-n-partitions-of-k 2 3) @result{} ((1 2) (2 1)) @end lisp
  • Function POSITIVE-PARTITIONS-OF-K (k)
    Returns a list of all positive ordered partitions of @arg{k}. Example: @lisp (positive-partitions-of-k 3) @result{} ((1 2) (2 1)) @end lisp
  • Function PERMUTATION-P (perm)
    Checks if @arg{perm} is a possible permutation vector. A permutation pi is characterized by a vector containing the indices from 0,..., @function{length}(@arg{perm})-1 in some order.
  • Function IDENTITY-PERMUTATION-P (perm)
    Checks if the permutation is the identity.
  • Function PERMUTE-INTO (perm v result)
    A permutation @arg{perm} acts on the vector @arg{v} by permuting it according to @math{result[i] = v[perm[i]]}.
  • Function PERMUTE (perm index)
    Functional version of @function{permute-into}.
  • Function PERMUTATION-INVERSE (perm-vec)
    Returns the inverse of the permutation given by @arg{perm-vec}.
  • Function PERMUTATION-SHIFTED-INVERSE (perm-vec)
  • Function PERMUTATION-SIGNUM (perm)
    Returns the sign of @arg{perm}.
  • Function SAFE-SORT (seq &rest args)
  • Generic-Function COPY-SLOTS (obj1 obj2 slots)
    Initializes the slots named in @arg{slots} from @arg{obj2} to @arg{obj1}. Returns @arg{obj1}.
  • Method COPY-SLOTS (obj1 (obj2 list) slots)
    Copies slots from a templating property list in @arg{obj2} to @arg{obj1}. Returns @arg{obj1}.
  • Method COPY-SLOTS (obj1 (obj2 list) slots)
    Copies slots from a templating property list in @arg{obj2} to @arg{obj1}. Returns @arg{obj1}.
  • Method COPY-SLOTS (obj1 (obj2 list) slots)
    Copies slots from a templating property list in @arg{obj2} to @arg{obj1}. Returns @arg{obj1}.
  • Function MAPPER-SELECT-FIRST (mapper &rest rest-args)
    Select the arguments with which a mapping construct calls a given function. E.g. @lisp (mapper-select-first #'mapc '(3 4 5) '(7 8 9)) @result{} 3,7 @end lisp
  • Function MAPPER-COLLECT (mapper &rest rest-args)
    Collects the arguments with which a mapping construct calls a given function. E.g. @lisp (mapper-collect #'mapc '(3 4 5)) @result{} (3 4 5) @end lisp
  • Function MAPPER-SOME (test mapper &rest rest-args)
    Tests if the test is fulfilled for some argument on which the mapper is called: @lisp (mapper-some #'plusp #'mapc '(-3 4 5)) @result{} T @end lisp
  • Function MAPPER-EVERY (test mapper &rest rest-args)
    Tests if the test is fulfilled for every argument on which the mapper is called: @lisp (mapper-every #'plusp #'mapc '(3 4 5)) @result{} T @end lisp
  • Function MAPPER-SUM (mapper &rest rest-args)
    Sums the arguments with which a mapping construct calls a given function. E.g. @lisp (mapper-sum #'mapc '(3 4 5)) @result{} 12 @end lisp
  • Function MAPPER-COUNT (mapper &rest rest-args)
    Counts the arguments with which a mapping construct calls a given function. E.g. @lisp (mapper-sum #'mapc '(3 4 5)) @result{} 3 @end lisp
  • Function KMGT (stream number colon-p at-p &optional w d)
  • Function MEASURE-TIME (fn &optional (count 1) real-p)
    Measures the time in seconds needed by @arg{count}-times executing @arg{fn}.
  • Macro MEASURE-TIME-FOR-BLOCK ((message &key (active-p '(dbg-p :log-times)) (real-p t)) &body block)
  • Function COMMON-LISP-SPEED (&key (memory-weight 0.5))
    Returns the speed which should be characteristic for the setting determined by @arg{memory-weight}. If this argument is 0.0 it means that all operations should be inside cache memory whereas 1.0 means that the operation are restricted by memory bandwidth available.
  • Generic-Function MAKE-ANALOG (obj)
    Generate an analogous but empty data structure.
  • Method MAKE-ANALOG (obj)
  • Method MAKE-ANALOG (obj)
  • Method MAKE-ANALOG (obj)
  • Function FILE-DOCUMENTATION (docstring)
    If the manual is sorted by file, the string handed to this function describes the use of the respective file.
  • Function CONCEPT-DOCUMENTATION (docstring)
    Documents a certain concept.
  • Class PROPERTY-MIXIN
    A mixin adding a property slot to the class.
    PROPERTIES   Accessor: PROPERTIES
    A property list for storing unstructured information about this object.
  • Function GET-PROPERTY (object property)
    Gets @arg{property} for @arg{object}. Returns NIL also if @arg{property} is not available.
  • Function (setf GET-PROPERTY) (value object property)
    Sets the property @arg{property} of @arg{problem} to @arg{value}.
  • Function CALL-HOOKS (function-name object &rest args)
    Call all hooks defined for @arg{function-name} on @arg{object} and returns @arg{object}.
  • Function ADD-HOOK (function-name hook-name hook-function)
    Add a hook with name @arg{hook-name} to the hooks for @arg{function-name}.

FL.AMOP

This package provides some MOP functionality.  These functions are
non-ANSI and may represent a problem when porting Femlisp.
  • Function FIND-PROGRAMMATIC-CLASS (superclasses &key class-name additional-slots)
    Finds and, if necessary, generates a class from the given superclasses.
  • Function MAKE-PROGRAMMATIC-INSTANCE (superclass-es &rest initargs &key class-name additional-slots &allow-other-keys)
    Makes an instance of a class denoted by a list of the names of its superclasses. This class is generated automatically, if necessary.
  • Function REMOVE-SUBCLASS-METHODS (gf template-args)
    Removes all methods dispatching on subclasses of the template arguments.

Also exports

  • SB-MOP:CLASS-DIRECT-SUPERCLASSES
  • SB-MOP:SLOT-DEFINITION-INITARGS
  • SB-MOP:CLASS-DIRECT-SUBCLASSES
  • SB-MOP:COMPUTE-SLOTS

FL.DEMO

This package provides routines for building a
demo suite.  Wherever something interesting can be demonstrated,
a small demo node should be generated with the
@function{make-demo} and added to the tree of all demos with
@function{adjoin-demo}.  After loading @femlisp{}, the whole
demo suite is available and can be run with the command
@function{femlisp-demo}.
  • Function MAKE-DEMO (&rest initargs)
  • Variable *DEMO-ROOT*
    (fl.demo:make-demo :name "demo" :short "femlisp demo suite" :long
                       "this is the root of the standard femlisp demos.  choose the
    demo you want to see by typing its name or an abbreviation.
    such abbreviations can be of the form `h-2' for
    `homogenization-2d'.
    
    type `up' or `back' to go up in the demo hierarchy, `quit' to
    quit, and '?' or 'help' for help.")
  • Variable *DEMO-TIME*
    10.0
    Suggested time for a demo which should be used as a termination criterion in demo iterations.
  • Function FEMLISP-DEMO (&optional (demo *demo-root*))
    Shows all demos below the given demo root.
  • Function ADJOIN-DEMO (demo parent)
    Adjoins the demo @arg{demo} to @arg{parent}.
  • Function REMOVE-DEMO (demo parent)
    Remove @arg{demo} from @arg{parent}.
  • Function FIND-DEMO (name parent)
  • Function USER-INPUT (prompt &optional (converter #'identity) (test-p (constantly t)))
    User input for demo functions. Reads lines until @arg{test-p} returns t on the item read.
  • Function USER-INPUT-TEXTFIELD (&optional (test-p (constantly t)))
    User textfield input for demo functions. Reads and concatenates lines until an empty line is read.
  • Function EXTRACT-DEMO-STRINGS (string &optional translations)
    Extract demo information from the documentation string of the generating function.
  • Function TEST-ALL-DEMOS (&optional (demo *demo-root*))
    Performs all demos reachable from @arg{demo}.

femlisp-ddo

No packages.

femlisp-dictionary

FL.DICTIONARY

This package contains functions for dictionaries as a general concept for
association lists, hash tables, etc.
  • Generic-Function DIC-REF (dictionary key)
    Returns the value of the entry for @arg{key} in @arg{dictionary}.
  • Method DIC-REF ((func function) key)
  • Method DIC-REF ((func function) key)
  • Method DIC-REF ((func function) key)
  • Method DIC-REF ((vec vector) index)
  • Method DIC-REF ((vec vector) index)
  • Method DIC-REF ((vec vector) index)
  • Method DIC-REF ((table hash-table) key)
  • Method DIC-REF ((table hash-table) key)
  • Method DIC-REF ((table hash-table) key)
  • Method DIC-REF ((table list) key)
  • Method DIC-REF ((table list) key)
  • Method DIC-REF ((table list) key)
  • Generic-Function (setf DIC-REF) (value dictionary key)
    Sets the entry @arg{key} in @arg{dictionary} to @arg{value}.
  • Method (setf DIC-REF) (value (vec vector) index)
  • Method (setf DIC-REF) (value (vec vector) index)
  • Method (setf DIC-REF) (value (vec vector) index)
  • Method (setf DIC-REF) (value (table hash-table) key)
  • Method (setf DIC-REF) (value (table hash-table) key)
  • Method (setf DIC-REF) (value (table hash-table) key)
  • Generic-Function DIC-FOR-EACH (function dictionary &key &allow-other-keys)
    Applies @arg{function} to each key-value pair in @arg{dictionary}.
  • Method DIC-FOR-EACH (func (vec vector) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (vec vector) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (vec vector) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic hash-table) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic hash-table) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic hash-table) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic list) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic list) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic list) &key &allow-other-keys)
  • Method DIC-FOR-EACH (function dictionary &key parallel &allow-other-keys)
  • Method DIC-FOR-EACH (function dictionary &key parallel &allow-other-keys)
  • Method DIC-FOR-EACH (function dictionary &key parallel &allow-other-keys)
  • Generic-Function DIC-FOR-EACH-KEY (function dictionary &key &allow-other-keys)
    Applies @arg{function} to each key in @arg{dictionary}.
  • Method DIC-FOR-EACH-KEY (func dic &rest args &key &allow-other-keys)
  • Method DIC-FOR-EACH-KEY (func dic &rest args &key &allow-other-keys)
  • Method DIC-FOR-EACH-KEY (func dic &rest args &key &allow-other-keys)
  • Generic-Function DIC-FOR-EACH-VALUE (function dictionary &key &allow-other-keys)
    Applies @arg{function} to each value in @arg{dictionary}.
  • Method DIC-FOR-EACH-VALUE (func dic &rest args)
  • Method DIC-FOR-EACH-VALUE (func dic &rest args)
  • Method DIC-FOR-EACH-VALUE (func dic &rest args)
  • Generic-Function DIC-REMOVE (key dictionary)
    Removes @arg{key} from @arg{dictionary}.
  • Method DIC-REMOVE (key (dic hash-table))
  • Method DIC-REMOVE (key (dic hash-table))
  • Method DIC-REMOVE (key (dic hash-table))
  • Generic-Function DIC-EMPTY-P (dictionary)
    Tests if @arg{dictionary} is empty.
  • Method DIC-EMPTY-P ((dic hash-table))
  • Method DIC-EMPTY-P ((dic hash-table))
  • Method DIC-EMPTY-P ((dic hash-table))
  • Method DIC-EMPTY-P ((list list))
  • Method DIC-EMPTY-P ((list list))
  • Method DIC-EMPTY-P ((list list))
  • Method DIC-EMPTY-P (dic)
  • Method DIC-EMPTY-P (dic)
  • Method DIC-EMPTY-P (dic)
  • Generic-Function KEYS (dic)
    Returns a list of all keys of @arg{dic}.
  • Method KEYS (dic)
  • Method KEYS (dic)
  • Method KEYS (dic)
  • Macro DODIC ((looping-var dic &key parallel) &body body)
    Loops through @arg{dic}. If @arg{looping-var} is an atom @emph{key}, loop through the keys; if it is a list of the form @emph{(value)} loop through the values; if it is a list of the form @emph{(key value)} loop through key and value.
  • Generic-Function DIC-POP (sorted-dic)
    A pop routine for sorted dictionaries or heaps.
  • Class SMALL-CACHE-DICTIONARY  (DICTIONARY)
    Implementation with lists.
    SIZE   Reader: SIZE
    TEST
    STORE   Reader: STORE
  • Method DIC-REF ((dic small-cache-dictionary) key)
  • Method (setf DIC-REF) (value (dic small-cache-dictionary) key)
  • Method DIC-FOR-EACH (func (dic small-cache-dictionary) &rest args)
  • Class SORTED-HASH-TABLE  (SORTED-DICTIONARY)
    This is a hash-table where new entries are interned FIFO-like (insertion-order=:fifo) or heap-like (insertion-order=:heap).
    TEST
    STORE
    INSERTION-ORDER
    ITEM-STORE
  • Method DIC-REF ((dic sorted-hash-table) key)
  • Method DIC-FOR-EACH (func (dic sorted-hash-table) &key (direction :forward) &allow-other-keys)
  • Method DIC-REMOVE (key (dic sorted-hash-table))
  • Method DIC-EMPTY-P ((dic sorted-hash-table))
  • Method DIC-POP ((dic sorted-hash-table))
  • Class CACHE-DICTIONARY
    This is a dictionary which can only hold a certain number of items. If more are inserted, only the most recently accessed items are kept.
    SIZE   Reader: SIZE
    TEST
    STORE
    ITEM-STORE
  • Method DIC-REF ((dic cache-dictionary) key)
  • Class COMPUTED-VALUE-DICTIONARY
    KEYS   Reader: KEYS
    COMPUTE   Reader: COMPUTE
    A (usually memoized) function computing the values
  • Method DIC-FOR-EACH-KEY (func (dic computed-value-dictionary) &key &allow-other-keys)
  • Method DIC-FOR-EACH (func (dic computed-value-dictionary) &key &allow-other-keys)
  • Method DIC-REF ((dic computed-value-dictionary) key)
  • Macro MEMOIZING-LET (bindings &body body)
    The @arg{body} is memoized for the keys given as a list of @arg{bindings}.
  • Macro MEMOIZING-LET* (bindings &body body)
    The @arg{body} is memoized for the keys given as a list of @arg{bindings}.
  • Macro MEMOIZING (defun-expr)
    As a global macro it memoizes the following function definition. Inside a @function{with-memoization} environment, it memoizes its function argument.
  • Macro WITH-MEMOIZATION ((&key (type :global) size id debug (test ''equal)) &body body)
    Sets up a memoization environment consisting of a table, and a captured symbol @symbol{memoizing-let} memoizing its body depending on the arguments. Example of usage: @lisp (with-memoization (:type :local :id 'test) (defun test (n) (memoizing-let ((k (* 2 n))) (sleep 1) (* k k)))) @end lisp If @arg{type} is :global, the table is thread-safe and the same for all threads, if @arg{type} is :local, it is special for each thread.
  • Function EXTRACT-COMPLETE-SUBGRAPH (objects get-dependents &optional result)
    Extract a complete subgraph which contains the vertices in objects. The result is a hash-table mapping vertices to lists of depending vertices. If the hash-table in @arg{result} is given it is assumed to contain a partial result of this operation.
  • Function INVERT-GRAPH (graph)
    Invert the directed graph given in @arg{graph} as a hash-table.
  • Function MAKE-PARALLEL-HEAP (objects dependents)
  • Function TAKE-OBJECT (parallel-heap)
  • Function DROP-OBJECT (object parallel-heap)
  • Macro PROCESS-IN-PARALLEL (collection arglist &body body)

Also exports

  • FL.UTILITIES:MAKE-ANALOG

femlisp-matlisp

FL.ALIEN

This package loads some foreign libraries and does set
up a Lisp interface for it.
No exported symbols.

FL.ALIENC

Imports some functions from the standard C library.
  • Function ERF (x)
  • Function ERFC (x)

FL.LAPACK

  • Function CL->LAPACK-TYPE (type &optional (error-p t))
    Converts a CL type to a LAPACK type, if possible.
  • Function LAPACK (name type)
    Ensures the CL binding to the specified LAPACK function.
  • Function CALL-LAPACK (routine &rest args)
    Call the LAPACK routine @arg{routine} with the arguments @arg{args}. NIL-arguments are discarded, arrays and standard-matrices are converted to the necessary alien representation.
  • Macro CALL-LAPACK-MACRO (routine &rest args)
    Call the LAPACK routine @arg{routine} with the arguments @arg{args}. NIL-arguments are discarded, arrays and standard-matrices are converted to the necessary alien representation.
  • Function CALL-LAPACK-WITH-ERROR-TEST (&rest args)
    Wrapper for @function{call-lapack} which tests if the routine worked satisfactorily.
  • Macro CALL-LAPACK-WITH-ERROR-TEST-MACRO (&rest args)
    Wrapper for @function{call-lapack} which tests if the routine worked satisfactorily.

FL.MATLISP

This package provides a Common Lisp version of full
  matrices with elements being numbers of a given type.  Those classes are
automatically generated when needed.  It provides also part of the BLAS and
LAPACK operations for those matrices.  The corresponding methods are
automatically compiled for the given matrix classes.  The interface is very
similar to the library Matlisp @cite{(Matlisp)}, which provides a CLOS
interface to the Fortran BLAS and LAPACK routines.
  • Type DOUBLE-VEC
    Uniform @type{double-float} vector.
  • Function DOUBLE-VEC (&rest comps)
    Returns a @class{double-vec} with the entries in @arg{comps}.
  • Function MAKE-DOUBLE-VEC (dim &optional (init 0.0d0))
    Returns a @class{double-vec} of length @arg{dim} and initial value @arg{init}.
  • Function UNIT-VECTOR (dim i)
    Returns a freshly created copy of the @arg{i}-th carthesian unit vector in dimension @arg{dim}.
  • Type UINT
  • Type INT-VEC
    Uniform @type{int} vector.
  • Type UINT-VEC
    Uniform @type{uint} vector.
  • Function MAKE-INT-VEC (dim &optional (init 0))
  • Function MAKE-UINT-VEC (dim &optional (init 0))
  • Function INT-VEC (&rest comps)
    Returns a @class{int-vec} with the entries in @arg{comps}.
  • Function UINT-VEC (&rest comps)
    Returns a @class{uint-vec} with the entries in @arg{comps}.
  • Class <VECTOR>
    General vector class.
    No slots.
  • Generic-Function VLENGTH (vec)
    Length of vector.
  • Generic-Function MULTIPLICITY (vec)
    We allow multiple vectors, for solving linear problems in parallel.
  • Method MULTIPLICITY (vec)
    The default is a multiplicity of 1.
  • Method MULTIPLICITY (vec)
    The default is a multiplicity of 1.
  • Method MULTIPLICITY (vec)
    The default is a multiplicity of 1.
  • Generic-Function RANK (tensor)
    Rank of a tensor.
  • Method RANK ((vec <vector>))
    Vectors have rank 1.
  • Method RANK ((vec <vector>))
    Vectors have rank 1.
  • Method RANK ((vec <vector>))
    Vectors have rank 1.
  • Generic-Function ELEMENT-TYPE (vector)
    Type of the elements of the vector/matrix.
  • Method ELEMENT-TYPE (vec)
    Default method returns T.
  • Method ELEMENT-TYPE (vec)
    Default method returns T.
  • Method ELEMENT-TYPE (vec)
    Default method returns T.
  • Generic-Function SCALAR-TYPE (vector)
    Type of the scalars for the vector class.
  • Method SCALAR-TYPE (vec)
    Default method returns NUMBER.
  • Method SCALAR-TYPE (vec)
    Default method returns NUMBER.
  • Method SCALAR-TYPE (vec)
    Default method returns NUMBER.
  • Generic-Function ENTRIES (object)
    List of entries.
  • Method ENTRIES ((vec <vector>))
  • Method ENTRIES ((vec <vector>))
  • Method ENTRIES ((vec <vector>))
  • Method ENTRIES ((arr array))
  • Method ENTRIES ((arr array))
  • Method ENTRIES ((arr array))
  • Method ENTRIES (vec)
    Default method
  • Method ENTRIES (vec)
    Default method
  • Method ENTRIES (vec)
    Default method
  • Generic-Function NR-OF-ENTRIES (vector)
    Total number of (block) entries for vectors.
  • Generic-Function TOTAL-ENTRIES (vector)
    Total number of entries for block vectors.
  • Generic-Function VREF (x i)
    Reader for @math{x_i}.
  • Generic-Function (setf VREF) (value x i)
    Writer for @arg{x_i}.
  • Generic-Function COPY (x)
    Returns a deep copy of X.
  • Method COPY (x)
    This default method for @function{copy} does a destructive copy to an empty analog of @arg{x}.
  • Method COPY (x)
    This default method for @function{copy} does a destructive copy to an empty analog of @arg{x}.
  • Method COPY (x)
    This default method for @function{copy} does a destructive copy to an empty analog of @arg{x}.
  • Generic-Function FILL! (x s)
    Fills X with element s.
  • Generic-Function FILL-RANDOM! (x s)
    Fills X with random values (obtained by (random s)).
  • Generic-Function SCAL! (alpha x)
    X <- alpha X
  • Generic-Function COPY! (x y)
    Y <- X
  • Generic-Function AXPY! (alpha x y)
    Y <- alpha*X + Y
  • Generic-Function M+! (x y)
    Y <- X + Y
  • Variable *MZEROP-THRESHOLD*
    0.0d0
    Threshold below which a matrix is considered to be zero.
  • Generic-Function MZEROP (x &optional threshold)
    Returns T if each entry of @arg{x} is smaller or equal than @arg{threshold}.
  • Generic-Function MEQUALP (x y)
    Returns T if X and Y have equal entries, otherwise NIL.
  • Generic-Function MAT-DIFF (x y)
    Prints a list of differences between X and Y.
  • Generic-Function DOT (x y)
    Returns the dot product of X and Y.
  • Method DOT ((x array) (y array))
  • Method DOT ((x array) (y array))
  • Method DOT ((x array) (y array))
  • Method DOT ((x list) (y list))
  • Method DOT ((x list) (y list))
  • Method DOT ((x list) (y list))
  • Generic-Function DOT-ABS (x y)
    Returns the dot product between |X| and |Y|.
  • Generic-Function NORM (x &optional p)
    Returns the @arg{p}-norm of @arg{x}.
  • Generic-Function L2-NORM (x)
    Returns the 2-norm of @arg{x}.
  • Generic-Function LP-NORM (x p)
    Returns the @arg{p}-norm of @arg{x}.
  • Generic-Function LINF-NORM (x)
    Returns the maximum norm of @arg{x}.
  • Generic-Function FOR-EACH-KEY (func vec)
    Calls @arg{func} on all indices/keys of @arg{vec}.
  • Method FOR-EACH-KEY (func vec)
    The default method calls @function{for-each-entry-and-key}.
  • Method FOR-EACH-KEY (func vec)
    The default method calls @function{for-each-entry-and-key}.
  • Method FOR-EACH-KEY (func vec)
    The default method calls @function{for-each-entry-and-key}.
  • Generic-Function FOR-EACH-ENTRY (func vec)
    Calls @arg{func} on all entries of @arg{vec}.
  • Method FOR-EACH-ENTRY (func vec)
    The default method calls @function{for-each-entry-and-key}.
  • Method FOR-EACH-ENTRY (func vec)
    The default method calls @function{for-each-entry-and-key}.
  • Method FOR-EACH-ENTRY (func vec)
    The default method calls @function{for-each-entry-and-key}.
  • Generic-Function FOR-EACH-ENTRY-AND-KEY (func object)
    Calls @arg{func} on all entries of the collection @arg{object} and their corresponding keys.
  • Generic-Function FOR-EACH-ENTRY-AND-VECTOR-INDEX (func vec)
    Calls @arg{func} on all entries of @arg{vec} and their corresponding vector indices. The index used should be unserstood by @func{vref}.
  • Method FOR-EACH-ENTRY-AND-VECTOR-INDEX (func vec)
    The default method calls @arg{for-each-entry-and-key} which works for single-indexed objects, i.e. rather general vectors.
  • Method FOR-EACH-ENTRY-AND-VECTOR-INDEX (func vec)
    The default method calls @arg{for-each-entry-and-key} which works for single-indexed objects, i.e. rather general vectors.
  • Method FOR-EACH-ENTRY-AND-VECTOR-INDEX (func vec)
    The default method calls @arg{for-each-entry-and-key} which works for single-indexed objects, i.e. rather general vectors.
  • Macro DOVEC ((loop-vars vec &optional result) &body body)
    Loops on indices and entries of a vector, matrix or tensor. Examples: @lisp (dovec (entry vec) ...) (dovec ((entry key1 ...) vec) ...) @end lisp
  • Function X<-0 (x)
    X <- 0 X. Uses SCAL!.
  • Function SCAL (alpha x)
    Returns alpha * X. Uses SCAL! and COPY.
  • Function NORMALIZE! (x &optional (p 2))
    Scales @arg{x} destructively to have @arg{p}-norm equal to 1.
  • Function NORMALIZE (x &optional (p 2))
    Scales @arg{x} to have @arg{p}-norm equal to 1.
  • Function AXPY (alpha x y)
    Returns alpha X + Y. Uses AXPY! and COPY.
  • Generic-Function M+ (x y)
    Returns @math{X} + @math{Y}.
  • Method M+ (x y)
    Default method uses M+! and COPY.
  • Function M-! (x y)
    Y - X -> Y. Uses AXPY!.
  • Function M- (x y)
    Returns X-Y. Uses AXPY.
  • Function M.* (x y)
    Returns X .* Y. Uses M.*! and COPY.
  • Method NORM (x &optional (p 2))
  • Method FILL! (x s)
    Recursive definition for FILL! usable for sparse block vectors.
  • Method FILL-RANDOM! (x s)
    Recursive definition for FILL-RANDOM! usable for sparse block vectors.
  • Method NR-OF-ENTRIES (obj)
  • Method TOTAL-ENTRIES (obj &aux (entries 0))
  • Method MZEROP (mat &optional (threshold *mzerop-threshold*))
  • Method COPY! (x y)
    Recursive definition for COPY! usable for sparse block vectors.
  • Method M+! (x y)
    Recursive definition for M+! usable for sparse block vectors.
  • Method SCAL! (s x)
  • Method AXPY! (alpha x y)
    Recursive definition for AXPY! usable for sparse block vectors.
  • Method L2-NORM (vec &aux (sum 0))
    Recursive definition for the l2-norm.
  • Method LP-NORM (vec (p number) &aux (sum 0))
    Recursive definition for the lp-norm.
  • Method LINF-NORM (vec &aux (max 0))
    Recursive definition for the linf-norm.
  • Method DOT (x y)
  • Method DOT-ABS (x y)
  • Method MEQUALP (x y)
  • Class <MATRIX>  (<VECTOR>)
    General matrix class.
    No slots.
  • Generic-Function NROWS (mat)
    Number of matrix rows.
  • Generic-Function NCOLS (mat)
    Number of matrix columns.
  • Generic-Function MREF (a i j)
    Returns the matrix element @code{A[i,j]}.
  • Method MREF ((x <vector>) i (j (eql 0)))
  • Method MREF ((x <vector>) i (j (eql 0)))
  • Method MREF ((x <vector>) i (j (eql 0)))
  • Method MREF ((x vector) i (j (eql 0)))
  • Method MREF ((x vector) i (j (eql 0)))
  • Method MREF ((x vector) i (j (eql 0)))
  • Generic-Function (setf MREF) (value a i j)
    Writes the matrix element @code{A[i,j]}.
  • Method (setf MREF) (value (x <vector>) i (j (eql 0)))
  • Method (setf MREF) (value (x <vector>) i (j (eql 0)))
  • Method (setf MREF) (value (x <vector>) i (j (eql 0)))
  • Method (setf MREF) (value (x vector) i (j (eql 0)))
  • Method (setf MREF) (value (x vector) i (j (eql 0)))
  • Method (setf MREF) (value (x vector) i (j (eql 0)))
  • Generic-Function FOR-EACH-ROW-KEY (func mat)
    Loop through row keys.
  • Generic-Function FOR-EACH-COL-KEY (func mat)
    Loop through column keys.
  • Generic-Function FOR-EACH-KEY-IN-ROW (func mat row-key)
    Loop through col-keys in row.
  • Generic-Function FOR-EACH-KEY-IN-COL (func mat col-key)
    Loop through row-keys in column col.
  • Generic-Function FOR-EACH-ENTRY-IN-ROW (func mat row-key)
    Loop through col-keys in row.
  • Generic-Function FOR-EACH-ENTRY-IN-COL (func mat col-key)
    Loop through entries in column col.
  • Generic-Function FOR-EACH-KEY-AND-ENTRY-IN-ROW (func mat row-key)
    Loop through col-keys and entries in row.
  • Generic-Function FOR-EACH-KEY-AND-ENTRY-IN-COL (func mat col-key)
    Loop through row-keys and entries in col.
  • Macro DOROWS ((key mat) &body body)
    Syntax: @slisp{(dorows (key mat) ...)}
  • Macro DOCOLS ((key mat) &body body)
    Syntax: @slisp{(docols (key mat) ...)}
  • Macro DOROW ((loop-vars mat row) &body body)
  • Macro DOCOL ((loop-vars mat col) &body body)
  • Generic-Function ROW-KEYS (mat)
    All row keys for a matrix.
  • Method ROW-KEYS ((mat <matrix>))
  • Method ROW-KEYS ((mat <matrix>))
  • Method ROW-KEYS ((mat <matrix>))
  • Generic-Function COL-KEYS (mat)
    All column keys for a matrix.
  • Method COL-KEYS ((mat <matrix>))
  • Method COL-KEYS ((mat <matrix>))
  • Method COL-KEYS ((mat <matrix>))
  • Generic-Function KEYS-OF-ROW (mat key)
    All column keys in the given row for a matrix.
  • Method KEYS-OF-ROW ((mat <matrix>) key)
  • Method KEYS-OF-ROW ((mat <matrix>) key)
  • Method KEYS-OF-ROW ((mat <matrix>) key)
  • Generic-Function KEYS-OF-COLUMN (mat key)
    All row keys in the given column for a matrix.
  • Method KEYS-OF-COLUMN ((mat <matrix>) key)
  • Method KEYS-OF-COLUMN ((mat <matrix>) key)
  • Method KEYS-OF-COLUMN ((mat <matrix>) key)
  • Method VREF ((mat <matrix>) (indices list))
    Vector referencing on matrices is done by default by matrix referencing a list of indices.
  • Method (setf VREF) (value (mat <matrix>) (indices list))
    Vector referencing on matrices is done by default by matrix referencing a list of indices.
  • Method FOR-EACH-ENTRY-AND-KEY (fn (mat <matrix>))
  • Method FOR-EACH-ENTRY-AND-VECTOR-INDEX (func (mat <matrix>))
  • Generic-Function MSQUARE-P (mat)
    Returns T, iff @arg{mat} is square.
  • Method MSQUARE-P (mat)
  • Method MSQUARE-P (mat)
  • Method MSQUARE-P (mat)
  • Generic-Function MSYMMETRIC-P (mat &key threshold output)
    Returns T, if @arg{mat} is symmetric up to a accuracy in THRESHOLD. If output is T, the differences to symmetry are reported.
  • Method MSYMMETRIC-P (mat &key (threshold 0.0d0) output)
  • Method MSYMMETRIC-P (mat &key (threshold 0.0d0) output)
  • Method MSYMMETRIC-P (mat &key (threshold 0.0d0) output)
  • Generic-Function MIDENTITY-P (number &optional threshold)
    Returns T, if @arg{mat} is the identity, i.e. if the elementwise difference to the identity is not larger than @arg{threshold}.
  • Generic-Function SHOW (matrix &key &allow-other-keys)
    Shows the contents of @arg{matrix} in a readable form.
  • Method SHOW (matrix &key (stream t) &allow-other-keys)
    The default method describes its argument.
  • Method SHOW (matrix &key (stream t) &allow-other-keys)
    The default method describes its argument.
  • Method SHOW (matrix &key (stream t) &allow-other-keys)
    The default method describes its argument.
  • Method SHOW (matrix &key &allow-other-keys)
  • Method SHOW (matrix &key &allow-other-keys)
  • Method SHOW (matrix &key &allow-other-keys)
  • Generic-Function DISPLAY (matrix &key &allow-other-keys)
    Formats the contents of @arg{matrix} in rectangular form.
  • Method DISPLAY (matrix &key (stream t) &allow-other-keys)
    The default method describes its argument.
  • Method DISPLAY (matrix &key (stream t) &allow-other-keys)
    The default method describes its argument.
  • Method DISPLAY (matrix &key (stream t) &allow-other-keys)
    The default method describes its argument.
  • Generic-Function GEMM-NN! (a x y b z)
    General matrix-matrix multiplication: @math{Z <- alpha * X * Y + beta * Z}
  • Generic-Function GEMM-NT! (a x y b z)
    General matrix-matrix multiplication: @math{Z <- alpha * X * Y' + beta * Z}
  • Generic-Function GEMM-TN! (a x y b z)
    General matrix-matrix multiplication: @math{Z <- alpha * X' * Y + beta * Z}
  • Generic-Function GEMM-TT! (a x y b z)
    General matrix-matrix multiplication: @math{Z <- alpha * X' * Y' + beta * Z}
  • Method GEMM-NN! (alpha a y beta z)
  • Method GEMM-NT! (alpha a y beta z)
  • Method GEMM-TN! (alpha a y beta z)
  • Method GEMM-TT! (alpha a y beta z)
  • Generic-Function GETRF! (a &optional ipiv)
    Computes the PA=LU decomposition of @arg{A} which is stored again in @arg{A}. @arg{ipiv} can be a pre-allocated vector which the routine fills with the indices for column pivoting, or NIL which implies that the routine allocates such a vector itself. If @arg{ipiv} is @symbol{:none}, no pivoting is done. Returns @arg{A} as the first value, the pivot vector as a second value, and a boolean as the third value indicating that the decomposition succeeded.
  • Generic-Function GETRS! (lu b &optional ipiv)
    Solves the PA=LU decomposition specified by @arg{LU} and @arg{ipiv} for the rhs @arg{b}. The result is stored in @arg{b}.
  • Generic-Function TRANSPOSE! (x y)
    Sets Y to the transpose of X.
  • Generic-Function MATRIX-TRANSPOSE-INSTANCE (x)
    Returns a zero matrix for storing the transpose of X.
  • Generic-Function MINJECT! (x y row-offset col-offset)
    Inject matrix X in matrix Y at the position given by ROW-OFFSET and COL-OFFSET.
  • Generic-Function MEXTRACT! (x y row-offset col-offset)
    Extract matrix X out of matrix Y from the position given by ROW-OFFSET and COL-OFFSET.
  • Generic-Function VECTOR-SLICE (x offset size)
    Extract a subvector of size @arg{size} out of @arg{x} starting from position @arg{offset}.
  • Generic-Function MATRIX-SLICE (x &key from-row from-col nrows ncols)
    Extract a submatrix of size @arg{nrows} @math{times} @arg{ncols} out of @arg{x} starting from position @arg{from-row}/@arg{from-col}.
  • Generic-Function SUBMATRIX (mat &key row-indices col-indices)
    General extraction of submatrices specified by non-adjacent lists of row- and column indices.
  • Generic-Function DIAGONAL (a)
    Extracts the diagonal from matrix @arg{A} as a vector.
  • Generic-Function JOIN-HORIZONTAL! (result &rest matrices)
    Joins @arg{matrices} horizontally into result.
  • Generic-Function JOIN-VERTICAL! (result &rest matrices)
    Joins @arg{matrices} vertically into result.
  • Generic-Function JOIN-INSTANCE (orientation matrix &rest matrices)
    Compute an instance for storing the join of @arg{orientation} applied to matrix and matrices.
  • Function JOIN (orientation &rest matrices)
    Joins @arg{matrices} either horizontally or vertically depending on @arg{orientation}. Due to the call to @function{zeros} this is not yet a generic function.
  • Generic-Function MAKE-DOMAIN-VECTOR-FOR (mat &optional multiplicity)
  • Generic-Function MAKE-IMAGE-VECTOR-FOR (mat &optional multiplicity)
  • Method NROWS ((mat <matrix>))
    Default and very inefficient method for computing the number of rows of a matrix.
  • Method NCOLS ((mat <matrix>))
    Default and very inefficient method for computing the number of columns of a matrix.
  • Method MULTIPLICITY ((vec <matrix>))
    If @arg{vec} should be a matrix, the multiplicity is the number of columns by default.
  • Method MATRIX-TRANSPOSE-INSTANCE (x)
  • Generic-Function TRANSPOSE (x)
    Transpose the matrix @arg{x}.
  • Method TRANSPOSE (x)
    The default method casts performs a combination of @function{transpose!} and @function{matrix-transpose-instance}.
  • Method TRANSPOSE (x)
    The default method casts performs a combination of @function{transpose!} and @function{matrix-transpose-instance}.
  • Method TRANSPOSE (x)
    The default method casts performs a combination of @function{transpose!} and @function{matrix-transpose-instance}.
  • Function GEMM! (alpha x y beta z &optional (job :nn))
    Dispatches on the optional job argument (member :nn :tn :nt :tt) and calls the corresponding generic function, e.g. GEMM-NN!.
  • Function GEMM (alpha x y beta z &optional (job :nn))
    Rewriting of GEMM in terms of GEMM!.
  • Generic-Function M*-PRODUCT-INSTANCE (x y)
    Allocates an instance for the product of X and Y.
  • Method M*-PRODUCT-INSTANCE (x y)
  • Method M*-PRODUCT-INSTANCE (x y)
  • Method M*-PRODUCT-INSTANCE (x y)
  • Generic-Function M* (x y)
    Multiply X by Y.
  • Method M* (x y)
    By default M* is rewritten in terms of GEMM!.
  • Method M* (x y)
    By default M* is rewritten in terms of GEMM!.
  • Method M* (x y)
    By default M* is rewritten in terms of GEMM!.
  • Generic-Function M*-TN-PRODUCT-INSTANCE (x y)
    Allocates an instance for the product of X^t and Y.
  • Method M*-TN-PRODUCT-INSTANCE (x y)
  • Method M*-TN-PRODUCT-INSTANCE (x y)
  • Method M*-TN-PRODUCT-INSTANCE (x y)
  • Generic-Function M*-TN (x y)
    Multiply X^t by Y.
  • Method M*-TN (x y)
    By default, M*-TN is rewritten in terms of GEMM!.
  • Method M*-TN (x y)
    By default, M*-TN is rewritten in terms of GEMM!.
  • Method M*-TN (x y)
    By default, M*-TN is rewritten in terms of GEMM!.
  • Generic-Function M*-NT (x y)
    Multiply X by Y^t.
  • Method M*-NT (x y)
    By default, M*-NT is rewritten in terms of GEMM!.
  • Method M*-NT (x y)
    By default, M*-NT is rewritten in terms of GEMM!.
  • Method M*-NT (x y)
    By default, M*-NT is rewritten in terms of GEMM!.
  • Function GETRF (x &optional ipiv)
    Rewriting for GETRF in terms of GETRF!.
  • Function GETRS (lu b &optional ipiv)
    Rewriting for GETRS in terms of GETRS!.
  • Generic-Function GESV! (a b)
    Solves a linear system A X = B for X.
  • Method GESV! (a b)
    Default method solves LSE via GETRF and GETRS!.
  • Method GESV! (a b)
    Default method solves LSE via GETRF and GETRS!.
  • Method GESV! (a b)
    Default method solves LSE via GETRF and GETRS!.
  • Function GESV (a b)
    Rewriting for GESV in terms of GESV!.
  • Method MAT-DIFF (mat1 mat2)
  • Class <SUBMATRIX>  (<MATRIX>)
    Describes an ordered submatrix of a matrix. Only a restricted set of operations is allowed for these matrices and element access is slow. They are indexed with ordinary integers.
    MATRIX
    The "supermatrix".
    ROW-KEYS   Reader: ROW-KEYS
    The row indices of the submatrix.
    COL-KEYS   Reader: COL-KEYS
    The column indices of the submatrix.
  • Method MREF ((submat <submatrix>) i j)
  • Method (setf MREF) (value (submat <submatrix>) i j)
  • Method VREF ((submat <submatrix>) k)
    A @class{<submatrix>} can be accessed as one-dimensional vector.
  • Method (setf VREF) (value (submat <submatrix>) k)
  • Method FOR-EACH-ENTRY-AND-KEY (func (mat <submatrix>))
  • Method NROWS ((mat <submatrix>))
  • Method NCOLS ((mat <submatrix>))
  • Method FOR-EACH-ENTRY (func (num number))
  • Method M* ((x number) (y number))
    Ordinary multiplication on numbers.
  • Method M+ ((x number) (y number))
    Number addition.
  • Method COPY! ((x number) (y number))
    Number copying.
  • Method M+! ((x number) (y number))
    Number addition.
  • Method FILL-RANDOM! ((x number) (s number))
  • Method SCAL! (s (x number))
  • Method AXPY! (alpha (x number) (y number))
  • Method GEMM-NN! (alpha (x number) (y number) beta (z number))
  • Method L2-NORM ((x number))
  • Method LP-NORM ((x number) p)
  • Method LINF-NORM ((x number))
  • Method DOT ((x number) (y number))
  • Method DOT-ABS ((x number) (y number))
  • Method MEQUALP ((x number) (y number))
  • Method MZEROP ((x number) &optional (threshold *mzerop-threshold*))
    Tests if the number @arg{x} is lower or equal to @arg{threshold}.
  • Method GETRF! ((x number) &optional ipiv)
  • Method GETRS! ((x number) (b number) &optional ipiv)
  • Method VLENGTH ((seq sequence))
    For sequences @function{vlength} is equivalent to @function{length}.
  • Method NROWS ((seq sequence))
    For sequences @function{nrows} is equivalent to @function{length}.
  • Method NCOLS ((seq sequence))
    For sequences @function{ncols} returns identically 1.
  • Method MULTIPLICITY ((x vector))
    Recursive definition.
  • Method ELEMENT-TYPE ((x vector))
  • Method SCALAR-TYPE ((x vector))
  • Method VREF ((vec vector) index)
  • Method (setf VREF) (val (vec vector) index)
  • Method VREF ((vec array) index)
  • Method VREF ((vec array) (index list))
  • Method (setf VREF) (val (vec array) index)
  • Method (setf VREF) (val (vec array) (index list))
  • Method MREF ((mat array) i j)
  • Method (setf MREF) (val (mat array) i j)
  • Method FOR-EACH-KEY (func (x vector))
  • Method FOR-EACH-KEY (func (array array))
  • Method FOR-EACH-ENTRY-AND-VECTOR-INDEX (func (array array))
  • Method FOR-EACH-ENTRY (func (seq sequence))
  • Method FOR-EACH-ENTRY (func (array array))
  • Method FOR-EACH-ENTRY-AND-KEY (func (x vector))
  • Method FOR-EACH-ENTRY-AND-VECTOR-INDEX (func (x vector))
  • Method COPY ((vec vector))
  • Method COPY ((vec list))
  • Method COPY ((array array) &aux (result (make-analog array)))
  • Method FOR-EACH-ENTRY-AND-KEY (func (x array))
  • Method COPY! ((x vector) (y vector))
  • Method FILL! ((x vector) (s number))
  • Method FILL! ((x vector) (s number))
  • Method FILL-RANDOM! ((x vector) (s number))
  • Method FILL-RANDOM!