The femlisp Reference Manual

discretization-defp.lisp.

Public Interface

call-lapack (function).
call-lapack-macro (macro).
call-lapack-with-error-test (function).
call-lapack-with-error-test-macro (macro).
cl->lapack-type (function).
lapack (function).
lapack-available-p (function).

Internals

*hegv* (special variable).
*lapack-templates* (special variable).
*lapack-types* (special variable).
*nrm2* (special variable).
*underscore-p* (special variable).
base-type (function).
check-spec (function).
convert-to-alien-type (function).
create-lapack-function (function).
define-lapack-template (macro).
ensure-lapack-type (function).
extract-applicable-spec (function).
insert-lapack-template (function).
lapack-convert (generic function).
lapack-external-name (function).
lapack-lisp-name (function).
lapack-type-p (function).
number-type (function).
remove-all-lapack-functions (function).
test-lapack (function).
translate-types (function).

Next: fl.debug, Previous: fl.lapack, Up: Packages [Contents][Index]

5.23 `fl.application`

This package uses most other Femlisp packages. It is meant to be the package a Femlisp user works in.

Source

application-defp.lisp.

Use List

Used By List

fl.flow-application.
fl.konwihr.

Public Interface

*articles-demo* (special variable).
*boundary-coeffs-demo* (special variable).
*effcoeff-root* (special variable).
*effective-diffusion-demo* (special variable).
*equation-demo* (special variable).
*interior-coeffs-demo* (special variable).
*multigrid-demo* (special variable).
*result* (special variable).
^ (function).
correction-tensor (function).
effective-tensor (function).
storing (macro).

Internals

*adaptivity-demo* (special variable).
*amg-cdr-demo* (special variable).
*books-demo* (special variable).
*cbl-observe* (special variable).
*cdr-demo* (special variable).
*courses-demo* (special variable).
*discretization-demo* (special variable).
*effective-coeffs-demo* (special variable).
*effective-elasticity-demo* (special variable).
*eigenvalue-demo* (special variable).
*elasticity-demo* (special variable).
*heat-demo* (special variable).
*hr-delta* (special variable).
*hr-evaluation-point* (special variable).
*hr-gradx-value* (special variable).
*laplace-demo* (special variable).
*refinement-demos* (special variable).
*skew-4d-to-3d* (special variable).
*solver-demo* (special variable).
*talks-demo* (special variable).
*u_1/2-observe* (special variable).
1d-graph (function).
amg-cdr-solver (function).
average-coefficient (function).
ball-diffusion (function).
boundary-layer-cell-problem (function).
bpx-demo-computation (function).
bratu-computation (function).
bratu-tests (function).
cdr-bl-computation (function).
cdr-cell-problem (function).
cdr-interior-effective-coeff-demo (function).
cell-dimension-and-point-test (function).
cell-solve (function).
check-h-convergence (function).
check-p-convergence (function).
chequerboard-problem (function).
compute-cbl (function).
convert-elasticity-correction (function).
create-refinement-demo (function).
display-stiffness-matrix (function).
elahom-longtime-stability-test (function).
elahom-performance-calculation (function).
elahom-performance-initialize (function).
elahom-performance-test (function).
elahom-performance-tests (function).
elasticity-cell-problem-gamma (function).
elasticity-cell-problem-reaction (function).
elasticity-inlay-cell-problem (function).
elasticity-interior-effective-coeff-demo (function).
elasticity-model-problem-computation (function).
evp-cdr-test (function).
exact-1d-solution (function).
exact-2d-solution (function).
exact-3d-solution (function).
further-laplace-tests (function).
heat-equation-computation (function).
heuveline-rannacher-computation (function).
heuveline-rannacher-domain (function).
heuveline-rannacher-dual-problem (function).
heuveline-rannacher-dual-problem-fe-rhs (function).
heuveline-rannacher-dual-problem-rhs (function).
heuveline-rannacher-problem (function).
heuveline-rannacher-rhs (function).
hom-cdr-tests (function).
inlay-block-decomposition (function).
inlay-cell-problem (function).
install-electromagnetic-potential-demo (function).
iteration-test (function).
laplace-eigenvalue-computation (function).
laplace-model-problem-locally-refined (function).
m+-nil-reducer (function).
make-bpx-demo (function).
make-bratu-demo (function).
make-cdr-bl-demo (function).
make-effective-diffusion-inlay-domain-demo (function).
make-effective-diffusion-porous-domain-demo (function).
make-effective-elasticity-inlay-domain-demo (function).
make-effective-elasticity-porous-domain-demo (function).
make-elasticity-model-problem-demo (function).
make-heat-equation-demo (function).
make-heuveline-rannacher-demo (function).
make-lagrange-basis-demo (function).
make-laplace-eigenvalue-demo (function).
make-model-problem-demo (function).
make-plot-iteration-behavior-demo (function).
make-smoother-demo (function).
make-smoother-performance-graph-demo (function).
make-stiffness-matrix-demo (function).
make-two-grid-behavior-demo (function).
mconvert (function).
mg-cdr-tests (function).
model-problem-computation (function).
model-problem-discretization (function).
model-problem-stiffness-matrix (function).
plot-diffusion (function).
plot-iteration-behavior (function).
plot-lagrange-basis (function).
porous-cell-problem (function).
problem-discretization (function).
regression-test-femlisp (function).
simple-ball-inlay-cell-problem (function).
simple-square-inlay-cell-problem (function).
sinusoidal-boundary-layer-cell-problem (function).
smooth-coefficient-cell-problem (function).
smoother-demo-execute (function).
smoother-graph-execute (function).
smoother-performance-test (function).
solve-laplace (function).
solve-sturm-problem (function).
sturm-domain (function).
sturm-mesh (function).
sturm-problem (function).
test-amg-cdr (function).
test-bl-cdr (function).
test-elasticity-model-problem (function).
test-heat-equation (function).
test-heuveline-rannacher (function).
test-homogenization-elasticity (function).
test-laplace-model-problem (function).
test-multigrid-demos (function).
test-refined-laplace-problem (function).
test-sturm (function).
test-v-cycle-convergence (function).

Next: fl.elasticity, Previous: fl.application, Up: Packages [Contents][Index]

5.24 `fl.debug`

This package adds debugging tools to Femlisp. This is a
slightly modified version of the debugging suite proposed in @cite{(Norvig 1992)}.

Source

debug.lisp.

Use List

common-lisp.

Used By List

Public Interface

dbg (generic function).
dbg-indent (generic function).
dbg-off (function).
dbg-on (function).
dbg-p (function).
dbg-print (macro).
dbg-show (macro).
dbg-when (macro).
with-dbg (macro).

Internals

*dbg-ids* (special variable).
*error-for-debug-output* (special variable).

Next: fl.alien, Previous: fl.debug, Up: Packages [Contents][Index]

5.25 `fl.elasticity`

Defines elasticity problems.

Source

elasticity.lisp.

Use List

common-lisp.
fl.dictionary.
fl.ellsys.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.elasticity-fe.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Public Interface

<elasticity-problem> (class).
check-elasticity-tensor (function).
elasticity-model-problem (function).
isotropic-elasticity-tensor (function).
isotropic-elasticity-tensor-coefficient (function).

Internals

test-elasticity (function).

Next: fl.function, Previous: fl.elasticity, Up: Packages [Contents][Index]

5.26 `fl.alien`

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

Source

alien.lisp.

Use List

common-lisp.
fl.macros.
fl.port.

Internals

*foreign-code-loaders* (special variable).
*zero-vector* (special variable).
direct-solver-test (function).
enumerate (macro).
load-blas-library (function).
load-lapack-library (function).
load-superlu-library (function).
load-umfpack-library (function).
reload-foreign-code (function).
test-superlu (function).
test-umfpack (function).
when-foreign-vector-operations (macro).

Next: fl.tests, Previous: fl.alien, Up: Packages [Contents][Index]

5.27 `fl.function`

Source

function-defp.lisp.

Use List

common-lisp.
fl.dictionary.
fl.macros.
fl.matlisp.
fl.utilities.

Used By List

Public Interface

<constant-function> (class).
<function> (class).
<linear-function> (class).
<periodic-polygon> (class).
<polygon> (class).
<special-function> (class).
circle-function (function).
coefficients (slot).
coefficients (generic reader).
cubic-spline (function).
degree (generic function).
differentiable-p (generic function).
differentiate (generic function).
domain-dimension (generic function).
eliminate-small-coefficients (function).
ellipse-matrix (function).
evaluate-gradient (generic function).
factors (generic function).
gradient (generic reader).
homotopy (function).
image-dimension (generic reader).
integrate-simple-polynomial (function).
interval-method (function).
lagrange-polynomials (function).
langevin (function).
langevinx (function).
make-polynomial (function).
maximal-partial-degree (generic function).
multiple-evaluate (generic function).
multiple-evaluate-gradient (generic function).
n-variate-monomials-of-degree (function).
numerical-complex-derivative (function).
numerical-derivative (function).
numerical-gradient (function).
partial-degree (generic function).
poly* (generic function).
poly-expt (generic function).
poly-exterior-product (function).
polynomial (class).
project-to-ellipsoid (function).
project-to-sphere (function).
shift-polynomial (generic function).
sparse-function (macro).
sparse-real-derivative (function).
special-1d-function (function).
split-into-monomials (function).
total-degree (generic function).
transform-function (function).
unit? (generic function).
variance (generic function).
xn-distortion-function (function).
zero (generic function).
zero? (generic function).

Internals

*langevin-taylor-29* (special variable).
*print-polynomial-variance* (special variable).
<linearly-transformed-function> (class).
apply-1d-stencil (function).
check-and-calculate-depth-of (function).
domain-a (generic reader).
domain-b (generic reader).
evaluate-exterior-polynomial-product (function).
evaluate-k-jet (generic function).
evaluator (generic reader).
exponents->monomial-list (function).
find-segment-coordinates (function).
image-a (generic reader).
image-b (generic reader).
intermediate-coordinates (function).
jet (generic reader).
k-jet (generic function).
k-variate-zero (function).
m-times (function).
nest (function).
nr-segments (generic function).
original (generic reader).
points (generic reader).
poly+ (generic function).
poly-eval (function).
print-polynomial (function).
simplify (function).
smoothness (generic function).
solve-moment-system (function).
spline-right-hand-side (function).
test-function (function).
test-gradient (function).
test-polynom (function).
test-spline (function).
unit (generic function).
value (generic reader).
write-monomial (function).
zero-k-jet (function).

Next: fl.matlisp, Previous: fl.function, Up: Packages [Contents][Index]

5.28 `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.

Source

tests.lisp.

Use List

common-lisp.

Used By List

fl.application.
fl.flow-application.
fl.iteration.
fl.konwihr.
fl.schaefer-turek.

Public Interface

adjoin-test (function).
remove-test (function).
small-test (macro).
test-femlisp (function).

Internals

*bugs* (special variable).
*failed* (special variable).
*small-tests* (special variable).
*testing* (special variable).
*tests* (special variable).
adjoin-bug-test (function).
adjoin-test-suite (function).
clear-bug-tests (function).
clear-tests (function).
test-function (function).

Next: fl.ellsys-fe, Previous: fl.tests, Up: Packages [Contents][Index]

5.29 `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.

Source

matlisp-defp.lisp.

Use List

common-lisp.
fl.amop.
fl.debug.
fl.dictionary.
fl.lapack.
fl.macros.
fl.parallel.
fl.utilities.

Used By List

Public Interface

*mzerop-threshold* (special variable).
*parallel-vector-algebra* (special variable).
*print-matrix* (special variable).
*print-matrix-element-format* (special variable).
*print-tensor* (special variable).
*standard-matrix-default-element-type* (special variable).
<matrix> (class).
<sparse-matrix> (class).
<sparse-tensor> (class).
<sparse-vector> (class).
<submatrix> (class).
<vector> (class).
access-type (generic function).
add-svec-to-local-block (generic function).
area-of-span (function).
average (function).
axpy (generic function).
axpy! (generic function).
blocks (generic reader).
cholesky (function).
col-key->size (generic function).
col-keys (generic function).
column (function).
column-table (generic reader).
(setf column-table) (generic writer).
combined-projection (function).
compressed->matlisp (generic function).
compressed-eye (function).
compressed-matrix (function).
compressed-matrix (class).
compressed-pattern (class).
copy (generic function).
copy! (generic function).
det (generic function).
det-from-lr (function).
diag (function).
diagonal (generic function).
diagonal-sparse-tensor (function).
dimensions (generic reader).
display (generic function).
docol (macro).
docols (macro).
dorow (macro).
dorows (macro).
dot (generic function).
dot-abs (generic function).
dotensor (macro).
double-vec (function).
double-vec (type).
dovec (macro).
element-type (generic function).
elementary (function).
ensure-matlisp (generic function).
entries (generic function).
(setf entries) (generic writer).
entry-allowed-p (generic function).
extend-by-identity (function).
extract-if (generic function).
extract-value-blocks (generic function).
eye (function).
fd-laplace-matrix (function).
fill! (generic function).
fill-random! (generic function).
for-each-col-key (generic function).
for-each-entry (generic function).
for-each-entry-and-key (generic function).
for-each-entry-and-vector-index (generic function).
for-each-entry-in-col (generic function).
for-each-entry-in-row (generic function).
for-each-key (generic function).
for-each-key-and-entry-in-col (generic function).
for-each-key-and-entry-in-row (generic function).
for-each-key-in-col (generic function).
for-each-key-in-row (generic function).
for-each-row-key (generic function).
full-ccs-pattern (function).
full-compressed-pattern (function).
full-crs-pattern (function).
full-tensor (function).
full-tensor (class).
gemm (function).
gemm! (function).
gemm-nn! (generic function).
gemm-nt! (generic function).
gemm-tn! (generic function).
gemm-tt! (generic function).
gesv (function).
gesv! (generic function).
getrf (function).
getrf! (generic function).
getrs (function).
getrs! (generic function).
ggev (generic function).
hegv (generic function).
hyperplane-normal (function).
in-pattern-p (generic function).
index-range-disjoint-p (function).
indices (generic reader).
(setf indices) (generic writer).
int-vec (function).
int-vec (type).
join (function).
join-horizontal! (generic function).
join-instance (generic function).
join-vertical! (generic function).
key->size (generic function).
keys->pattern (generic function).
keys-of-column (generic function).
keys-of-row (generic function).
kronecker-product (generic function).
l2-norm (generic function).
laplace-full-matrix (function).
laplace-sparse-matrix (function).
linf-norm (generic function).
lp-norm (generic function).
m* (generic function).
m*-nt (generic function).
m*-product-instance (generic function).
m*-tn (generic function).
m*-tn-product-instance (generic function).
m+ (generic function).
m+! (generic function).
m- (function).
m-! (function).
m-incf (macro).
m.* (function).
m/ (function).
make-domain-vector-for (generic function).
make-double-vec (function).
make-full-block-analog (function).
make-full-crs-matrix (function).
make-image-vector-for (generic function).
make-int-vec (function).
make-matrix (function).
make-matrix-block (function).
make-real-matrix (function).
make-real-tensor (function).
make-real-vector (function).
make-sparse-automorphism (function).
make-sparse-matrix (function).
make-sparse-vector (function).
make-uint-vec (function).
map-matrix (generic function).
mat-diff (generic function).
matrix-block (generic function).
(setf matrix-block) (generic function).
matrix-col-p (function).
matrix-column (generic function).
(setf matrix-column) (generic function).
matrix-row (generic function).
(setf matrix-row) (generic function).
matrix-row-p (function).
matrix-slice (generic function).
matrix-transpose-instance (generic function).
mequalp (generic function).
mextract! (generic function).
midentity-p (generic function).
minject! (generic function).
mrandom (function).
mref (generic function).
(setf mref) (generic function).
msquare-p (generic function).
msymmetric-p (generic function).
multiplicity (slot).
multiplicity (slot).
multiplicity (generic function).
mzerop (generic function).
ncols (generic function).
norm (generic function).
normalize (function).
normalize! (function).
nr-of-entries (generic function).
nrows (generic function).
number-coercer (function).
number-of-nonzero-entries (generic function).
ones (function).
pattern (generic reader).
range-and-domain-disjoint-p (function).
rank (generic function).
read-compressed-matrix (function).
rearrange-tensor (function).
remove-column (generic function).
remove-key (generic function).
remove-keys (function).
remove-projection-range (generic function).
remove-row (generic function).
row (function).
row-key->size (generic function).
row-keys (generic function).
row-table (generic reader).
(setf row-table) (generic writer).
row<-id (generic function).
scal (function).
scal! (generic function).
scalar-type (generic function).
set-svec-to-local-block (generic function).
shift-diagonal-inverter (function).
shift-tensor (generic function).
show (generic function).
sizes (generic reader).
slice (generic function).
sparse-ldu (generic function).
sparse-m* (generic function).
sparse-matrix->ccs (function).
sparse-matrix->matlisp (generic function).
sparse-tensor (function).
sparse-vector->matlisp (function).
standard-matrix (function).
standard-matrix (class).
standard-matrix-p (function).
store (generic function).
store-vector (function).
store-vector (class).
submatrix (generic function).
t* (generic function).
tensor (class).
tensor-for-each (generic function).
tensor-map (generic function).
tensor-ref (generic function).
(setf tensor-ref) (generic function).
total-entries (generic function).
total-nrows (generic function).
transpose (generic function).
transpose! (generic function).
transposed-pattern (generic function).
uint (type).
uint-vec (function).
uint-vec (type).
unit-vector (function).
vector-block (generic function).
(setf vector-block) (generic function).
vector-of (function).
vector-slice (generic function).
vlength (generic function).
vref (generic function).
(setf vref) (generic function).
x<-0 (function).
zeros (function).

Internals

(<block-definition-mixin>⎵<ht-sparse-matrix>) (class).
(compressed-matrix⎵(store-vector⎵double-float⎵dynamic⎵nil)) (class).
(standard-matrix⎵double-float) (class).
(store-vector⎵double-float⎵dynamic⎵nil) (class).
*blas-macro-table* (special variable).
*blas2-operation-count* (special variable).
*blas3-operation-count* (special variable).
*cholesky-threshold* (special variable).
*crs-test-matrix* (special variable).
*crs-test-matrix-entries* (special variable).
*default-cm-solver* (special variable).
*maxrows-for-direct-solving* (special variable).
*print-matrix-pretty* (special variable).
*sparse-test-matrix* (special variable).
*test-blas-vector-generator* (special variable).
<block-definition-mixin> (class).
<ht-sparse-matrix> (class).
<ht-sparse-vector> (class).
<key->size-mixin> (class).
<ldu-sparse> (class).
<sparse-dictionary-matrix> (class).
<sparse-dictionary-vector> (class).
assert-same-size (function).
automorphism-p (generic function).
blas-macro (generic function).
canonical-number-type (function).
check-cpairs (function).
combine-real-and-imag-part (function).
combine-svec-block (function).
complex-to-real-vector (function).
complex-type (function).
compressed-eye-pattern (function).
compressed-gemm! (function).
compute-offset (function).
conditional-compile (macro).
consecutive-p (function).
decompose-offsets (function).
define-blas-macro (function).
define-blas-template (macro).
define-blas2-template (macro).
define-default-gemm! (macro).
define-matrix-matrix-operation (macro).
define-vector-blas-method (macro).
dimensions->offsets (function).
direct-solver-performance-test (function).
display-block-matrix-graph (function).
distance-numbering (function).
drop-content (generic function).
equal-type (function).
extended-mclear! (generic function).
extended-minject! (generic function).
fd-laplace-matrix-triplets (function).
find-compressed-offset (function).
find-first-position>= (function).
find-ordering (generic function).
five-point-stencil-matrix (function).
fl-matlisp->matlisp (function).
float-accuracy (function).
float-type-union (function).
for-each-index (function).
for-each-offset-pair (function).
generate-sparse-matrix-vector-gemm!-template (function).
generate-standard-matrix-gemm!-template (function).
get-place-in-tensor (function).
get-remaining-inds (function).
if-lapack-function (macro).
int (type).
key->index (function).
laplace-stencil (function).
last-key (function).
ldu-diagonal (generic reader).
list->real-tensor (function).
lower-left (generic reader).
m*-nt-product-instance (generic function).
m.*! (generic function).
make-analog-with-multiplicity (function).
make-full-compressed-matrix (function).
make-tensor-index (function).
matlisp (function).
matlisp->fl-matlisp (function).
matlisp-symbol (function).
matop-x->y! (generic function).
matop-x<-y! (generic function).
matop-y+=x! (generic function).
matop-y-=x! (generic function).
matrix-loop-expansion (function).
modify-diagonal (function).
msym-ncols (function).
msym-nrows (function).
msym-pos (function).
msym-size (function).
new-blas-method-code (function).
new-dispatcher-code (function).
number-of-stored-entries (generic function).
number-super-type (function).
numbering (function).
offset0 (generic reader).
offsets (generic reader).
ordering (generic reader).
orientation (generic reader).
pool-mixin (class).
print-element (generic function).
print-matlab-format (generic function).
print-matrix (function).
print-tensor (function).
read-matrix (generic function).
real-to-complex-vector (function).
select-linear-solver (generic function).
slice-copy (generic function).
standard-matrix-generator (function).
standard-matrix-indexing (function).
starts (generic reader).
static-store-vector (class).
stencil-matrix (function).
store-vector-generator (function).
superlu-solver (function).
swap-rows (function).
symbol-store (function).
symmetric-packed-store (function).
test-arrays (function).
test-blas (function).
test-blas-basic (function).
test-call-matlisp (function).
test-compressed (function).
test-ggev (function).
test-hegv (function).
test-matlisp-vector-combination (function).
test-number-blas (function).
test-sparse-matrix (function).
test-sparse-tensor (function).
test-sparse-vector (function).
test-sparselu (function).
test-standard-matrix (function).
test-standard-matrix-blas (function).
test-standard-matrix-lr (function).
test-store-vector-blas (function).
test-tensor (function).
test-vector (function).
test-vector-methods (function).
translate-list (function).
trsm (function).
umfpack-solver (function).
uniform-number-type (function).
upper-right (generic reader).
x<-eye (generic function).

Next: fl.plot, Previous: fl.matlisp, Up: Packages [Contents][Index]

5.30 `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.

Source

ellsys-fe.lisp.

Use List

common-lisp.
fl.debug.
fl.discretization.
fl.ellsys.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Internals

*upwinding* (special variable).
discretize-ellsys (function).
ellsys-fe-tests (function).
ensure-m-matrix-property (function).

Next: net.scipolis.relations, Previous: fl.ellsys-fe, Up: Packages [Contents][Index]

5.31 `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.

Source

plot-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.demo.
fl.dictionary.
fl.discretization.
fl.function.
fl.graphic.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.
fl.strategy.

Public Interface

plot (slot).
plot (generic function).

Internals

*dx-bug-transformation* (special variable).
*dx-shapes* (special variable).
*plot* (special variable).
*plot-transformation* (special variable).
*position-header* (special variable).
1d-surface-cells (function).
compute-all-position-component-values (function).
compute-all-position-values (function).
compute-cell-vertices (function).
compute-position-indices (function).
connections (function).
destructure-polygon (function).
dx-position-header (function).
ensure-polygons (function).
find-local-index (function).
(setf find-local-index) (function).
local-evaluation-matrix (function).
make-key (function).
meshplot-position-array (function).
nr-of-refinement-vertices (function).
plot-cells (generic function).
plot-dimension (function).
plot-transformation (function).
position-array (function).
refcell-refinement-vertex-positions (function).
refcell-refinement-vertices (function).
test-coeffplot (function).
test-function-plot (function).
test-meshplot (function).
test-plot-dx (function).
test-plot-gnuplot (function).
vertex-index-table (function).
write-positions (function).
write-vtk-positions (function).

Next: fl.alienc, Previous: fl.plot, Up: Packages [Contents][Index]

5.32 `net.scipolis.relations`

This package provides relations built upon binary trees.

Source

dictionary-defp.lisp.

Nickname

relations

Use List

common-lisp.
fl.amop.
fl.debug.
fl.macros.
fl.utilities.

Public Interface

arity (generic reader).
list-comparison (function).
make-number-relation (function).
r-insert (generic function).
r-remove (generic function).
r-select (generic function).
r-select-1 (function).
r-some (generic function).
relation (class).
tree-leaves (function).

Internals

ensure-index (function).
entries (function).
eql-relation (class).
extract-from-seq-in-order (function).
find-first-path-geq (function).
find-first-path-satisfying (function).
find-last-path-leq (function).
for-each-in-range (function).
from-key (function).
get-index (function).
index-key-function (generic function).
indices (generic reader).
inverse-direction (function).
make-index (function).
map-key (function).
needed-order (function).
new-index (function).
next (function).
test-relations (function).
to-key (function).

Next: fl.start, Previous: net.scipolis.relations, Up: Packages [Contents][Index]

5.33 `fl.alienc`

Imports some functions from the standard C library.

Source

alienc.lisp.

Use List

common-lisp.
fl.debug.
fl.macros.
fl.port.
fl.utilities.

Public Interface

erf (function).
erfc (function).

Internals

test-alienc (function).

Next: fl.discretization, Previous: fl.alienc, Up: Packages [Contents][Index]

5.34 `fl.start`

This package contains some routines called during initialization of Femlisp.

Source

setup.lisp.

Use List

common-lisp.

Public Interface

*blas-library* (special variable).
*dx-path* (special variable).
*femlisp-version* (special variable).
*gnuplot-path* (special variable).
*images-directory* (special variable).
*lapack-library* (special variable).
*meshes-directory* (special variable).
*superlu-library* (special variable).
*tetgen-path* (special variable).
*umfpack-library* (special variable).
femlisp-banner (function).
femlisp-herald (function).
femlisp-pathname (function).

Internals

*femlisp-directory* (special variable).
*femlisp-pathname* (special variable).
*triangle-path* (special variable).
femlisp-check-features (function).
femlisp-restart (function).
femlisp-version (function).
message (function).

Next: fl.port, Previous: fl.start, Up: Packages [Contents][Index]

5.35 `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.

Source

Nickname

disc

Use List

common-lisp.
fl.cdr.
fl.debug.
fl.dictionary.
fl.function.
fl.iteration.
fl.macros.
fl.matlisp.
fl.mesh.
fl.parallel.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.elasticity-fe.
fl.ellsys-fe.
fl.flow-application.
fl.geomg.
fl.konwihr.
fl.navier-stokes-fe.
fl.plot.
fl.schaefer-turek.
fl.strategy.

Public Interface

*quadrature-order* (special variable).
*suggested-discretization-order* (special variable).
<ansatz-space-automorphism> (class).
<ansatz-space-morphism> (class).
<ansatz-space-vector> (class).
<ansatz-space> (class).
<discretization> (class).
<fe-discretization> (class).
<scalar-fe-discretization> (class).
<scalar-fe> (class).
<standard-fe-discretization> (class).
<vector-fe-discretization> (class).
<vector-fe> (class).
ansatz-space (generic reader).
assemble-constraints (function).
assemble-interior (generic function).
cell-integrate (generic function).
cell-key (function).
cell-lagrange-fe (function).
choose-start-vector (generic function).
component (generic function).
constrained-interpolation-matrix (function).
construct-coeff-input (function).
discretization-order (generic function).
discretize (generic function).
discretize-globally (function).
discretize-locally (generic function).
do-dof (macro).
dof (class).
dof-component (generic reader).
dof-coord (generic reader).
dof-functional (generic reader).
dof-gcoord (generic reader).
dof-in-vblock-index (generic reader).
dof-index (generic reader).
dof-subcell-index (generic reader).
domain-ansatz-space (generic function).
eliminate-constraints (function).
essential-boundary-constraints (generic function).
extended-extract (generic function).
fe-basis (generic reader).
fe-cell-geometry (function).
fe-class (slot).
fe-class (generic function).
fe-discretize (function).
fe-dofs (generic reader).
(setf fe-dofs) (generic writer).
fe-extraction-information (function).
fe-extreme-values (generic function).
fe-gradient (generic function).
fe-integrate (generic function).
fe-local-gradient (generic function).
fe-local-value (generic function).
fe-value (generic function).
gauss-lobatto-points (function).
gauss-lobatto-points-on-unit-interval (function).
gauss-lobatto-rule (function).
gauss-rule (function).
get-fe (generic function).
get-local-from-global-mat (generic function).
get-local-from-global-vec (generic function).
hierarchical-mesh (generic function).
image-ansatz-space (generic function).
increment-global-by-local-mat (generic function).
increment-global-by-local-vec (generic function).
inner-dof-indices (function).
integration-points (generic reader).
integration-rule (function).
integration-rule (class).
integration-weights (generic reader).
interior-dof? (function).
interpolate-on-refcell (generic function).
interpolation-matrix (function).
ip-gradients (generic function).
ip-values (generic function).
lagrange-ansatz-space (function).
lagrange-fe (function).
lagrange-mapping (function).
local-imatrix (function).
local-pmatrix (function).
local-transfer-matrix (function).
make-ansatz-space-automorphism (function).
make-ansatz-space-morphism (function).
make-ansatz-space-vector (function).
make-fe-ansatz-space (function).
make-local-mat (generic function).
make-local-vec (function).
mesh (generic function).
multiple-evaluate-local-fe (function).
nr-of-dofs (generic function).
nr-of-inner-dofs (generic function).
problem (generic function).
product-rule (function).
projection-matrix (function).
quadrature-rule (generic function).
random-ansatz-space-vector (function).
select-discretization (generic function).
set-global-to-local-mat (generic function).
set-global-to-local-vec (generic function).
sort-keys-hierarchically (function).
special-ansatz-space-vector (function).
subcell-ndofs (function).
subcell-offsets (function).
transfer-matrix (function).
weights-for-ips (function).

Internals

*check-hash-table* (special variable).
*check-lock* (special variable).
*dof-precise-evaluation* (special variable).
*interpolation-type* (special variable).
*ipt-tolerance* (special variable).
*local-interpolation-matrix* (special variable).
*local-mat-pool* (special variable).
*local-projection-matrix* (special variable).
*quadrature-rule-float-type* (special variable).
*quadrature-rule-internal-precision* (special variable).
*use-pool-p* (special variable).
<ansatz-space-object> (class).
<domain-image-mixin> (class).
<fe> (class).
add-local-part! (function).
assemble-cell (function).
assembly-heap (function).
c-dirichlet-dof-p (function).
c-find-master (function).
c-slave-dof-p (function).
cell-volume (function).
children-offsets (function).
chunk-enqueue (generic function).
chunk-queue (class).
combined-constraints (function).
compute-duals (function).
compute-energy (function).
compute-essential-boundary-constraints (function).
compute-local-imatrix (generic function).
compute-local-pmatrix (generic function).
cone-rule-for-simplex (function).
copy-ip (function).
delay-possible-p (function).
discretization (generic reader).
dof-subcell (generic reader).
domain-volume (function).
eliminate-hanging-node-constraints-from-matrix (function).
ensure-constraints (function).
essential-constraints-for-key (function).
evaluate-shapes-at-points (function).
extract-ip-data (function).
fast-ip-gradients (function).
fe-discretize-linear-problem (function).
fe-factors (generic reader).
fe-secondary-information (function).
fill-local-from-global-mat (generic function).
fill-local-from-global-vec (generic function).
gauss-lobatto-family (function).
gauss-lobatto-rule-on-unit-interval (function).
gauss-points-for-weight (function).
gauss-rule-for-simplex (function).
gauss-rule-for-weight (function).
get-matrix-blocks (function).
global-local-matrix-operation (generic function).
global-local-vector-operation (generic function).
gram-matrix (function).
hanging-nodes-constraints (function).
high-precision-integration-points (function).
high-precision-integration-weights (function).
high-precision-ips (generic reader).
identification-constraints (function).
identification-matrix (function).
integrate-monomial (function).
integrate-monomial-over-simplex-product (function).
integrate-over-reference-product-cell (function).
integrate-over-reference-simplex (function).
interpolate-coefficient (function).
interpolate-function (function).
interpolation-function (generic function).
ip-coords (function).
(setf ip-coords) (function).
ip-gradients-at-point (generic function).
ip-values-at-point (generic function).
ip-weight (function).
(setf ip-weight) (function).
jacobi-polynomial (function).
key-cells (function).
lagrange-basis (function).
lagrange-basis-boundary (function).
lagrange-basis-inner (function).
lagrange-basis-simplex (function).
lagrange-boundary-dofs (function).
lagrange-coords-1d (function).
lagrange-dofs (function).
lagrange-inner-coords (generic function).
lagrange-polynomial-vector (function).
lagrange-reference-parameters (function).
legendre-polynomial (function).
local-interpolation-matrix (function).
local-projection-matrix (function).
lock (function).
make-ip (function).
new-gauss-rule-for-simplex (function).
new-vector-dof-from-dof (function).
p-nomials-of-degree (function).
precise-coord (generic reader).
precise-gcoord (generic reader).
project (function).
projection-coefficients (function).
q-nomials-of-degree (function).
rule-factors (generic reader).
safer-find-cell-from-position (function).
set-constraints (generic function).
set-lagrange-ansatz-space-vector (function).
shapes-and-dof-coords (function).
slow-ip-gradients (function).
test-assembly-heap (function).
test-constraints (function).
test-fe (function).
test-fedisc (function).
test-fetransfer (function).
test-integration-rule (function).
test-lagrange (function).
test-quadrature (function).
test-sparseas (function).
test-sparseif (function).
unlock (function).
update-cell-extreme-values (function).
vector-dof (class).
volume-of-cell (function).
work-done (function).
work-on-queue (generic function).
zeros-of-separating-family (function).

Next: fl.ellsys, Previous: fl.discretization, Up: Packages [Contents][Index]

5.36 `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

Source

port.lisp.

Use List

common-lisp.
fl.debug.

Used By List

fl.alien.
fl.alienc.
fl.lapack.

Public Interface

add-exit-hook (function).
compile-and-eval (function).
compile-silently (function).
convert-type (function).
def-function (macro).
dynamic-space-size (function).
finalize (function).
find-executable (function).
find-shared-library (function).
foreign-call (function).
gc (function).
getenv (function).
hostname (function).
kill-process (function).
load-foreign-library (function).
make-weak-pointer (function).
portability-warning (function).
process-close (function).
process-error (function).
process-exit-code (function).
process-input (function).
process-output (function).
process-status (function).
run-program (function).
run-program-output (function).
run-program-report-errors (function).
runtime-compile (function).
save-femlisp-core-and-die (function).
simplified-def-function (macro).
system-namestring (function).
unix-chdir (function).
vector-sap (function).
weak-pointer-value (function).
without-gcing (macro).

Internals

*portability-problem-handling* (special variable).
execute-thunk-with-pinned-objects (function).
foreign-convert (function).
memory-usage (function).
process-wait (function).
quit (function).
test-port (function).

Next: fl.patches, Previous: fl.port, Up: Packages [Contents][Index]

5.37 `fl.ellsys`

This package contains the problem definition of systems
of second order PDEs. The system is defined in the following quasilinear form:

@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.

Source

ellsys.lisp.

Use List

common-lisp.
fl.debug.
fl.dictionary.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.cdr.
fl.elasticity.
fl.elasticity-fe.
fl.ellsys-fe.
fl.flow-application.
fl.konwihr.
fl.navier-stokes.
fl.schaefer-turek.
fl.strategy.

Public Interface

<ellsys-problem> (class).
<multiphysics-problem> (class).
artificial-diffusion (function).
diagonal-reaction-coefficient (function).
ellsys-model-problem (function).
ellsys-one-force-coefficient (function).
initial-value-provided-p (function).
isotropic-diffusion (function).
isotropic-diffusion-coefficient (function).
time-dependent-p (function).
unit-vector-force-coefficient (function).

Internals

a (macro).
ai (macro).
b (macro).
c (macro).
define-ellsys-coefficient-macro (macro).
f (macro).
g (macro).
h (macro).
initial (macro).
r (macro).
sigma (macro).
test-ellsys (function).

Previous: fl.ellsys, Up: Packages [Contents][Index]

5.38 `fl.patches`

Source: patches.lisp.
Use List: common-lisp.
Public Interface: make-hash-table (function).

Next: Indexes, Previous: Packages, Up: The femlisp Reference Manual [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

Public Interface
Internals

Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]

Next: Macros, Previous: Public Interface, Up: Public Interface [Contents][Index]

6.1.1 Special variables

Special Variable: *articles-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *blas-library* ¶

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.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *boundary-coeffs-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *cpu-time-observe* ¶

Observe CPU time during an iteration. This should be used as element in the observe list of an iteration.

Package: fl.iteration.
Source: iterate.lisp.

Special Variable: *default-graphic-program* ¶

Default graphics program.

Package: fl.graphic.
Source: graphics.lisp.

Special Variable: *demo-root* ¶

Package: fl.demo.
Source: demo.lisp.

Special Variable: *demo-time* ¶

Suggested time for a demo which should be used as a termination criterion in demo iterations.

Package: fl.demo.
Source: demo.lisp.

Special Variable: *discrete-iterative-solver-observe* ¶

Standard observe quantities for iterative solvers.

Package: fl.iteration.
Source: solve.lisp.

Special Variable: *dx-path* ¶

Path to the @program{DX} executable.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *effcoeff-root* ¶

Package: fl.application.
Source: effcoeff.lisp.

Special Variable: *effective-diffusion-demo* ¶

Package: fl.application.
Source: hom-cdr.lisp.

Special Variable: *equation-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *eta-observe* ¶

Observe an estimate of the global error.

Package: fl.strategy.
Source: fe-approximation.lisp.

Special Variable: *fe-approximation-observe* ¶

Standard observe quantities for fe approximation.

Package: fl.strategy.
Source: fe-approximation.lisp.

Special Variable: *femlisp-version* ¶

Package: fl.start.
Source: setup.lisp.

Special Variable: *gauss-seidel* ¶

Package: fl.iteration.
Source: linit.lisp.

Special Variable: *gnuplot-path* ¶

Path to the @program{Gnuplot} executable.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *heisig-neuss-2017-demo* ¶

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Special Variable: *images-directory* ¶

Directory where images are put by default.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *interior-coeffs-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *iteration-depth* ¶

Depth of nested iteration.

Package: fl.iteration.
Source: iterate.lisp.

Special Variable: *konwihr-initialized* ¶

A flag keeping track, if the setup for these tests has already been performed.

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Special Variable: *lapack-library* ¶

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.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *mentries-observe* ¶

Observe entries for the size of the matrix.

Package: fl.strategy.
Source: fe-stationary.lisp.

Special Variable: *meshes-directory* ¶

Directory where meshes are put by default.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *model-time-observe* ¶

Package: fl.strategy.
Source: rothe.lisp.

Special Variable: *multigrid-demo* ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Special Variable: *mzerop-threshold* ¶

Threshold below which a matrix is considered to be zero.

Package: fl.matlisp.
Source: vector.lisp.

Special Variable: *navier-stokes-demo* ¶

Package: fl.flow-application.
Source: demo-ns.lisp.

Special Variable: *nr-of-cells-observe* ¶

Package: fl.strategy.
Source: fe-approximation.lisp.

Special Variable: *nr-of-dofs-observe* ¶

Package: fl.strategy.
Source: fe-approximation.lisp.

Special Variable: *output-depth* ¶

Maximum iteration depth for which status output is done.

Package: fl.iteration.
Source: iterate.lisp.

Special Variable: *parallel-vector-algebra* ¶

A switch for allowing parallel linear algebra for sparse vectors in special situations.

Package: fl.matlisp.
Source: sparse-vector.lisp.

Special Variable: *print-matrix* ¶

Maximum number of columns and/or rows to print. NIL: no elements, T: all elements.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Special Variable: *print-matrix-element-format* ¶

Format of matrix element field to be printed. A useful format is "~10,2,2E" for debugging purposes.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Special Variable: *print-tensor* ¶

Maximum number of columns and/or rows to print. Set this to NIL to print no cells (same as *PRINT-ARRAY* set to NIL). Set this to T to print all cells of the tensor.

Package: fl.matlisp.
Source: tensor.lisp.

Special Variable: *quadrature-order* ¶

Quadrature order to be used. NIL determines the order automatically.

Package: fl.discretization.
Source: fe.lisp.

Special Variable: *reference-vertex* ¶

The reference vertex.

Package: fl.mesh.
Source: vertex.lisp.

Special Variable: *result* ¶

Special variable used for storing the blackbboard of the last computation.

Package: fl.application.
Source: app-utils.lisp.

Special Variable: *rothe-observe* ¶

Standard observe quantities for Rothe.

Package: fl.strategy.
Source: rothe.lisp.

Special Variable: *standard-matrix-default-element-type* ¶

Default element type for standard matrices.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Special Variable: *stationary-fe-strategy-observe* ¶

Standard observe quantities for stationary finite element strategies.

Package: fl.strategy.
Source: fe-stationary.lisp.

Special Variable: *step-observe* ¶

Observe step number during an iteration. This should be used as element in the observe list of an iteration.

Package: fl.iteration.
Source: iterate.lisp.

Special Variable: *suggested-discretization-order* ¶

The suggested order of discretization. In non-nil, this value should be taken into account by methods to @arg{select-discretization}.

Package: fl.discretization.
Source: discretization.lisp.

Special Variable: *superlu-library* ¶

Wrapper for SuperLU, if available.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *tetgen-path* ¶

Path to the @program{tetgen} executable.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *umfpack-library* ¶

Wrapper for UMFPACK, if available.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *undamped-jacobi* ¶

Package: fl.iteration.
Source: linit.lisp.

Special Variable: *unit-cube* ¶

Package: fl.mesh.
Source: product-cell.lisp.

Special Variable: *unit-interval* ¶

Package: fl.mesh.
Source: simplex.lisp.

Special Variable: *unit-quadrangle* ¶

Package: fl.mesh.
Source: product-cell.lisp.

Special Variable: *unit-tetrahedron* ¶

Package: fl.mesh.
Source: simplex.lisp.

Special Variable: *unit-triangle* ¶

Package: fl.mesh.
Source: simplex.lisp.

Special Variable: *usually* ¶

Package: fl.macros.
Source: macros.lisp.

Next: Setf expanders, Previous: Special variables, Up: Public Interface [Contents][Index]

6.1.2 Macros

Macro: ?1 (&rest args) ¶

A macro returning the first of its arguments.

Package: fl.macros.
Source: macros.lisp.

Macro: ?2 (&rest args) ¶

A macro returning the second of its arguments.

Package: fl.macros.
Source: macros.lisp.

Macro: ?3 (&rest args) ¶

A macro returning the third of its arguments.

Package: fl.macros.
Source: macros.lisp.

Macro: ?4 (&rest args) ¶

A macro returning the fourth of its arguments.

Package: fl.macros.
Source: macros.lisp.

Macro: ?5 (&rest args) ¶

A macro returning the fifth of its arguments.

Package: fl.macros.
Source: macros.lisp.

Macro: ?6 (&rest args) ¶

A macro returning the sixth of its arguments.

Package: fl.macros.
Source: macros.lisp.

Macro: _ (&body body) ¶

Easy definition of anonymous small functions. Arguments are ’_’, ’_1’, ..., ’_5’.

Package: fl.macros.
Source: macros.lisp.

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)}.

Package: fl.macros.
Source: macros.lisp.

Macro: aand (&rest args) ¶

Anaphoric macro from @cite{(Graham 1993)}.

Package: fl.macros.
Source: macros.lisp.

Macro: accessing-exclusively (bindings &body body) ¶

Package: fl.parallel.
Source: mutex.lisp.

Macro: accessing-exclusively-without-gcing (bindings &body body) ¶

Package: fl.parallel.
Source: mutex.lisp.

Macro: acond (&rest clauses) ¶

Anaphoric macro from @cite{(Graham 1993)}.

Package: fl.macros.
Source: macros.lisp.

Macro: aif (test-form then-form &optional else-form) ¶

Anaphoric IF macro by Paul Graham. Keeps the value of the test-form in the variable named IT to be used in the then-branch.

Package: fl.macros.
Source: macros.lisp.

Macro: awhen (test-form &body body) ¶

Anaphoric macro from @cite{(Graham 1993)}.

Package: fl.macros.
Source: macros.lisp.

Macro: bif ((bindvar boundform) yup &optional nope) ¶

Posted to cll by Kenny Tilton 22.4.2007.

Package: fl.macros.
Source: macros.lisp.

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.

Package: fl.lapack.
Source: lapack.lisp.

Macro: call-lapack-with-error-test-macro (&rest args) ¶

Wrapper for @function{call-lapack} which tests if the routine worked satisfactorily.

Package: fl.lapack.
Source: lapack.lisp.

Macro: coupling-with ((sym) &rest body) ¶

Package: fl.problem.
Source: pdef.lisp.

Macro: create-problem ((&key type domain components multiplicity subproblems properties &allow-other-keys) &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}, and in the case of multiphysics problems, subproblems can be switched using @mac{subproblem}.

Package: fl.problem.
Source: pdef.lisp.

Macro: dbg-print (id &rest args) ¶

Package: fl.debug.
Source: debug.lisp.

Macro: dbg-show (id &rest args) ¶

Package: fl.debug.
Source: debug.lisp.

Macro: dbg-when (id &body body) ¶

Perform a check only if debugging @arg{id}.

Package: fl.debug.
Source: debug.lisp.

Macro: def-fgf (&rest args) ¶

Package: fl.amop.
Source: amop.lisp.

Macro: def-function (&rest args) ¶

Defines a foreign function. See examples in @path{alien;src;superlu.lisp}.

Package: fl.port.
Source: port.lisp.

Macro: def-sealable-class (&rest args) ¶

Package: fl.amop.
Source: amop.lisp.

Macro: define-coefficient-macro (problem-name coeff-name args &body body) ¶

Package: fl.problem.
Source: pdef.lisp.

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.

Package: fl.macros.
Source: macros.lisp.

Macro: deletef (item sequence &rest args) ¶

Delets @arg{item} from @arg{sequence} destructively.

Package: fl.macros.
Source: macros.lisp.

Macro: do-dof ((dof-and-shape fe &key type) &body body) ¶

Package: fl.discretization.
Source: fe.lisp.

Macro: docol ((loop-vars mat col) &body body) ¶

Package: fl.matlisp.
Source: matrix.lisp.

Macro: docols ((key mat) &body body) ¶

Syntax: @slisp{(docols (key mat) ...)}

Package: fl.matlisp.
Source: matrix.lisp.

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.

Package: fl.dictionary.
Source: dictionary.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Macro: dorow ((loop-vars mat row) &body body) ¶

Package: fl.matlisp.
Source: matrix.lisp.

Macro: dorows ((key mat) &body body) ¶

Syntax: @slisp{(dorows (key mat) ...)}

Package: fl.matlisp.
Source: matrix.lisp.

Macro: doskel ((looping-var skel &key direction 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.

Package: fl.mesh.
Source: skeleton.lisp.

Macro: dotensor ((args tensor &key depth) &body body) ¶

Usage:
(dotensor (entry tensor :depth 1) ...)
(dotensor ((index1 ... . entry) tensor :depth 1) ...) (dotensor ((index1 ...) tensor :depth 1) ...)

Package: fl.matlisp.
Source: sparse-tensor.lisp.

Macro: dotuple ((index limits &optional result) &body body) ¶

Loops through each tuple below @arg{limits}.

Package: fl.utilities.
Source: utilities.lisp.

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

Package: fl.matlisp.
Source: vector.lisp.

Macro: echo (ekx-id &rest body) ¶

Posted to cll at 17.10.2006 by Kenny Tilton.

Package: fl.macros.
Source: macros.lisp.

Macro: ensure (place newval) ¶

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.

Package: fl.macros.
Source: macros.lisp.

Macro: fluid-let (bindings &body body) ¶

Sets temporary bindings.

Package: fl.macros.
Source: macros.lisp.

Macro: gencase (obj test &body clauses) ¶

An analog to case using @arg{test} as comparison.

Package: fl.macros.
Source: macros.lisp.

Macro: inlining (&rest definitions) ¶

Declaims the following definitions inline together with executing them.

Package: fl.macros.
Source: macros.lisp.

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

Package: fl.utilities.
Source: utilities.lisp.

Macro: lret (bindings &body body) ¶

A @function{let}-construct which returns its last binding.

Package: fl.macros.
Source: macros.lisp.

Macro: lret* (bindings &body body) ¶

A @function{let*}-construct which returns its last binding.

Package: fl.macros.
Source: macros.lisp.

Macro: m-incf (result increment) ¶

Adds increment to result which should be a symbol. If its value is nil then result is set to increment.

Package: fl.matlisp.
Source: array-blas.lisp.

Macro: mapf (var func) ¶

Replaces the value of the variable @arg{var} by setting it to its map with @arg{func}.

Package: fl.utilities.
Source: utilities.lisp.

Macro: measure-time-for-block ((message &key active-p real-p) &body block) ¶

Package: fl.utilities.
Source: mflop.lisp.

Macro: memoize-expr (func+args &optional table) ¶

Memoize expr for its arguments in the table @arg{table} which should be nil or a hash-table with equal/equalp test.

Package: fl.utilities.
Source: utilities.lisp.

Macro: memoizing-let (key-vals &body body) ¶

Package: fl.dictionary.
Source: dictionary.lisp.

Macro: memoizing-let* (key-vals &body body) ¶

Package: fl.dictionary.
Source: dictionary.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

Package: fl.macros.
Source: macros.lisp.

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

Package: fl.macros.
Source: macros.lisp.

Macro: multiple-defgen (names args) ¶

Defines multiple generic functions at once. Usually, this will only be used for helper functions.

Package: fl.macros.
Source: macros.lisp.

Macro: named-let (name bindings &body body) ¶

Implements the named-let construct from Scheme.

Package: fl.macros.
Source: macros.lisp.

Macro: once-only (variables &rest body) ¶

Slightly modified macro taken from <http://groups.google.com/comp.lang.lisp/msg/2a92ad69a8185866>.

Package: fl.macros.
Source: macros.lisp.

Macro: process-in-parallel (collection arglist &body body) ¶

Package: fl.dictionary.
Source: parallel-heap.lisp.

Macro: quickly (&body forms) ¶

Package: fl.macros.
Source: macros.lisp.

Macro: quickly-if (test &body forms) ¶

Package: fl.macros.
Source: macros.lisp.

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.

Package: fl.macros.
Source: macros.lisp.

Macro: select-on-patch ((&optional patch) &body clauses) ¶

Package: fl.problem.
Source: pdef.lisp.

Macro: show-call (func &optional name) ¶

Wraps a function object inside a trace form.

Package: fl.macros.
Source: macros.lisp.

Macro: simplified-def-function ((c-name lisp-name) args &rest keys) ¶

Package: fl.port.
Source: port.lisp.

Macro: slowly (&body forms) ¶

Package: fl.macros.
Source: macros.lisp.

Macro: small-test (fsym &body body) ¶

At the moment small tests are ignored. One might think of collecting them when compiling a certain file.

Package: fl.tests.
Source: tests.lisp.

Macro: sparse-function (args &body components) ¶

Package: fl.function.
Source: function.lisp.

Macro: storing (&body body) ¶

Stores the result of @arg{body} in @var{*result*}.

Package: fl.application.
Source: app-utils.lisp.

Macro: stringcase (string &body clauses) ¶

An analog to case using string comparison.

Package: fl.macros.
Source: macros.lisp.

Macro: subproblem ((problem-name component) &body body) ¶

Package: fl.problem.
Source: pdef.lisp.

Macro: symbol-macroletf ((&rest bindings) &body body) ¶

Like SYMBOL-MACROLET but evaluate subforms just once up front.

Package: fl.macros.
Source: macros.lisp.

Macro: usually-quickly (&body forms) ¶

Package: fl.macros.
Source: macros.lisp.

Macro: very-quickly (&body forms) ¶

Package: fl.macros.
Source: macros.lisp.

Macro: whereas (clauses &body body) ¶

Own implementation of the macro @function{whereas} suggested by Erik Naggum (c.l.l., 4.12.2002).

Package: fl.macros.
Source: macros.lisp.

Macro: with-accumulators ((name initform reduce-op) &body body) ¶

This macro sets up an array of accumulators for each worker initialized with initial-element. Within each worker the symbol @arg{name} can be used for accessing the private accumulator.
After the body was executed (probably containing parallel operations), the result array is reduced using @arg{reduce-op}.

Package: fl.parallel.
Source: parallel-adaptions.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’.

Package: fl.macros.
Source: macros.lisp.

Macro: with-atomic-output (&body body) ¶

If output of a process is desired to be atomic wrap it in @arg{with-atomic-output}.

Package: fl.parallel.
Source: multiprocessing.lisp.

Macro: with-dbg ((&rest ids) &body body) ¶

Execute @arg{body} with debugging bound to ids.

Package: fl.debug.
Source: debug.lisp.

Macro: with-femlisp-workers ((work) &body body) ¶

This macro distributes work generated in body with calling the locally bound function @function{work-on} on some arguments to several working threads which call @arg{func} on those arguments.

Package: fl.parallel.
Source: multiprocessing.lisp.

Macro: with-gensyms (syms &body body) ¶

Standard macro providing the freshly generated symbols @arg{syms} to the code in @arg{body}.

Package: fl.macros.
Source: macros.lisp.

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

Package: fl.utilities.
Source: utilities.lisp.

Macro: with-memoization ((&key dictionary type size id test) &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 (:size 4 :id ’test)
(defun test (n)
(memoizing-let ((k (* 2 n)))
(sleep 1)
(* k k))))
@end lisp

Package: fl.dictionary.
Source: dictionary.lisp.

Macro: with-mutex (object &body body) ¶

Needs to be called unfortunately around push/incf/setf.

Package: fl.parallel.
Source: mutex.lisp.

Macro: with-mutual-exclusion ((obj) &body body) ¶

Execute @arg{body} on the waitqueue @arg{obj} without other threads interfering.

Package: fl.parallel.
Source: multiprocessing.lisp.

Macro: with-region ((object keys) &body body) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Macro: with-workers ((work &rest keyword-args &key &allow-other-keys) &body body) ¶

This macro distributes work generated in body with calling the locally bound function @function{work-on} on some arguments to several working threads which call @arg{func} on those arguments.

Package: fl.parallel.
Source: parallel-adaptions.lisp.

Macro: without-gcing (&body body) ¶

Package: fl.port.
Source: port.lisp.

Next: Ordinary functions, Previous: Macros, Up: Public Interface [Contents][Index]

6.1.3 Setf expanders

Setf Expander: (setf geta) (alist key) ¶

An analog to @code{(SETF GETF)} for association lists.

Package: fl.utilities.
Source: utilities.lisp.
Reader: geta (function).

Next: Generic functions, Previous: Setf expanders, Up: Public Interface [Contents][Index]

6.1.4 Ordinary functions

Function: ^ (keyword &optional blackboard) ¶

An abbreviation for accessing the entries on the @var{*result} blackboard.

Package: fl.application.
Source: app-utils.lisp.

Function: add-exit-hook (hook) ¶

Package: fl.port.
Source: port.lisp.

Function: add-fe-parameters-demand (demands new-paras) ¶

Adds a list of fe-functions to the demands.

Package: fl.problem.
Source: pde-problem.lisp.

Function: add-hook (function-name hook-name hook-function) ¶

Add a hook with name @arg{hook-name} to the hooks for @arg{function-name}.

Package: fl.utilities.
Source: general.lisp.

Function: adjoin-demo (demo parent) ¶

Adjoins the demo @arg{demo} to @arg{parent}.

Package: fl.demo.
Source: demo.lisp.

Function: adjoin-test (fsym) ¶

Adjoins a test to the Femlisp test suite.

Package: fl.tests.
Source: tests.lisp.

Function: anisotropic-rule-p (rule) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: area-of-span (mat) ¶

Computes the volume spanned by the columns of @arg{mat}.

Package: fl.matlisp.
Source: matrix.lisp.

Function: array-for-each (func &rest arrays) ¶

Calls @arg{func} on all element tuples of the array arguments.

Package: fl.utilities.
Source: utilities.lisp.

Function: artificial-diffusion (factor power) ¶

An isotropic diffusion of size factor*h^power

Package: fl.ellsys.
Source: ellsys.lisp.

Function: assemble-constraints (ansatz-space) ¶

Package: fl.discretization.
Source: constraints.lisp.

Function: average (x &rest rest) ¶

Calculates an average of its arguments which should allow for addition and scaling.

Package: fl.matlisp.
Source: vector.lisp.

Function: bl-patch-on-artificial-boundary (bl-domain patch) ¶

Returns the artificial boundary on which the distributional source acts.

Package: fl.domains.
Source: bl-cell.lisp.

Function: bl-patch-on-lower-boundary (bl-domain patch) ¶

Returns T if the patch is on the lower oscillating boundary.

Package: fl.domains.
Source: bl-cell.lisp.

Function: bl-patch-on-upper-boundary (bl-domain patch) ¶

Returns T if the patch is on the upper boundary.

Package: fl.domains.
Source: bl-cell.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Function: bottom-level-cells (mm) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: boundary-identifications (identifications) ¶

Returns an identification list for the boundaries of the cells in identifications.

Package: fl.mesh.
Source: identify.lisp.

Function: box (object) ¶

Boxes an object.

Package: fl.utilities.
Source: utilities.lisp.

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.

Package: fl.mesh.
Source: domain.lisp.

Function: bratu-problem (dim &key c a) ¶

Formulates a Newton linearization for the Bratu problem @math{-Delta u = C e^u}.

Package: fl.cdr.
Source: cdr.lisp.

Function: calculate-drag/lift (solution evaluate-force-boundary-p &key viscosity) ¶

Calculate drag/lift on a portion of the boundary determined by the predicate @arg{evaluate-force-boundary-p}.

The optional viscosity parameter allows to use this function, even if the viscosity is not available as a property of the problem, and it also allows to use it in the context of friction boundary laws with a friction coefficient different from normal viscosity. The ’viscosity’ parameter should then be equal to the friction coefficient in the boundary condition.

Package: fl.flow-application.
Source: boundary-force.lisp.

Function: call-hooks (function-name object &rest args) ¶

Call all hooks defined for @arg{function-name} on @arg{object} and returns @arg{object}.

Package: fl.utilities.
Source: general.lisp.

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.

Package: fl.lapack.
Source: lapack.lisp.

Function: call-lapack-with-error-test (&rest args) ¶

Wrapper for @function{call-lapack} which tests if the routine worked satisfactorily.

Package: fl.lapack.
Source: lapack.lisp.

Function: cdr-model-problem (domain &key diffusion source dirichlet gamma convection reaction sigma initial evp multiplicity 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.

Package: fl.cdr.
Source: cdr.lisp.

Function: cell->cube (cell) ¶

Transforms a product-cell into a degenerated cube with the same vertices.

Package: fl.mesh.
Source: product-cell.lisp.

Function: cell-identification (cell skel) ¶

Returns @arg{cell}’s identification in @arg{skel} or NIL.

Package: fl.mesh.
Source: identify.lisp.

Function: (setf cell-identification) (cell skel) ¶

Package: fl.mesh.
Source: identify.lisp.

Function: cell-key (cell mesh) ¶

If cell is identified, its identification is the key.

Package: fl.discretization.
Source: sparseas.lisp.

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.

Package: fl.discretization.
Source: lagrange.lisp.

Function: cellp (cell) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: cells-of-dim (skel dim) ¶

Returns the cells of @arg{skel} of dimension @arg{dim} in form of a list.

Package: fl.mesh.
Source: skeleton.lisp.

Function: cells-of-highest-dim (skel) ¶

Returns the cells of @arg{skel} of highest dimension in form of a list.

Package: fl.mesh.
Source: skeleton.lisp.

Function: cells-on-level (mm level) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: check-elasticity-tensor (tensor dim &optional threshold) ¶

Checks the symmetries in the elasticity tensor.

Package: fl.elasticity.
Source: elasticity.lisp.

Function: check-properties (place properties) ¶

Checks if all of the @arg{properties} are in the property list @arg{place}.

Package: fl.utilities.
Source: utilities.lisp.

Function: children (cell skeleton) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: (setf children) (cell skeleton) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: cholesky (a &key inverse compactify threshold) ¶

Package: fl.matlisp.
Source: standard-matrix-lr.lisp.

Function: circle-function (&optional radial-distance midpoint omega phi0) ¶

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}.

Package: fl.function.
Source: function.lisp.

Function: circle-ring-domain (r1 r2 &key interior-p channel-breadth flipped-p) ¶

Constructs a domain for a circle ring with inner radius r1 and outer radius r2. If r2 is NIL, then the result is a circle domain or radius r1.

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: cl->lapack-type (type &optional error-p) ¶

Converts a CL type to a LAPACK type, if possible.

Package: fl.lapack.
Source: lapack.lisp.

Function: coefficient-macros (symbol) ¶

Package: fl.problem.
Source: pdef.lisp.

Function: coefficients-of-patch (patch problem) ¶

Reader for the coefficients of @arg{patch} for @arg{problem}.

Package: fl.problem.
Source: pde-problem.lisp.

Function: column (&rest values) ¶

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: combine-identifications (sets) ¶

Reduces identifications to maximally connected sets.

Package: fl.mesh.
Source: identify.lisp.

Function: combined-projection (p1 p2) ¶

Returns a projection to the range of the given projections.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: common-lisp-speed (&key memory-weight) ¶

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.

Package: fl.utilities.
Source: mflop.lisp.

Function: compare-lexicographically (&key fuzzy direction) ¶

Returns a function which compares two vectors lexicographically.

Package: fl.mesh.
Source: meshgen.lisp.

Function: compile-and-eval (source) ¶

Compiles and evaluates the given @arg{source}. This should be an ANSI compatible way of ensuring method compilation.

Package: fl.port.
Source: port.lisp.

Function: compile-silently (name source) ¶

Compiles @arg{source} silently.

Package: fl.port.
Source: port.lisp.

Function: component-length (component) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: component-position (components component-name) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: component-symbol (comp) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: compose (&rest functions) ¶

Returns the composition of @arg{functions}.

Package: fl.utilities.
Source: utilities.lisp.

Function: compressed-eye (m &optional n type orientation) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: compressed-matrix (type) ¶

Construct a compressed sparse matrix with entries of @arg{type}.

Package: fl.matlisp.
Source: compressed.lisp.

Function: concept-documentation (docstring) ¶

Documents a certain concept.

Package: fl.utilities.
Source: general.lisp.

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.

Package: fl.problem.
Source: pde-problem.lisp.

Function: constant-vector (dim value) ¶

Returns a uniform constant vector of which all elements are @arg{value}.

Package: fl.utilities.
Source: utilities.lisp.

Function: constrained-interpolation-matrix (ansatz-space &key level where imat type) ¶

The multigrid algorithm needs an interpolation which satisfies the constraints like essential or periodic boundary conditions.

Package: fl.discretization.
Source: constraints.lisp.

Function: constraint-coefficient (nr-of-components multiplicity) ¶

Returns a coefficient function which sets Dirichlet zero boundary conditions for all components of a PDE system.

Package: fl.problem.
Source: pde-problem.lisp.

Function: constraint-p (coeff) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: construct-coeff-input (cell global dphi values gradients fe-parameters problem) ¶

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.

Package: fl.discretization.
Source: fe.lisp.

Function: convert-type (type) ¶

Package: fl.port.
Source: port.lisp.

Function: copy-coefficient (coeff &key demands name eval) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: copy-hash-table (hash-table) ¶

Copy @arg{hash-table}.

Package: fl.utilities.
Source: utilities.lisp.

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.

Package: fl.mesh.
Source: meshgen.lisp.

Function: copy-skeleton (skel &key properties transformation) ¶

Copies a skeleton. Properties is a list of properties to be copied. Returns the copy of @arg{skel} and a table mapping old cells to their copies.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: correction-tensor (solution rhs) ¶

Package: fl.application.
Source: app-utils.lisp.

Function: cube-extender (domain-cube direction) ¶

Makes domain-cube —which should be a cube in a domain— extensible in the given direction.

Package: fl.mesh.
Source: extend.lisp.

Function: cube-p (cell) ¶

Returns T iff CELL is a cube.

Package: fl.mesh.
Source: product-cell.lisp.

Function: cubic-spline (y) ¶

On a regular partition of the unit interval interpolating values y are given. This function returns an interpolating spline.

Package: fl.function.
Source: spline.lisp.

Function: curry (func &rest args) ¶

Supplies @arg{args} to @arg{func} from the left.

Package: fl.utilities.
Source: utilities.lisp.

Function: cylinder-domain (r h &key flipped-p) ¶

A domain which is a cartesian product of a circle and an interval.

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: dbg-off (&rest ids) ¶

Stop debugging on the passed symbols. With no arguments, stop debugging altogether.

Package: fl.debug.
Source: debug.lisp.

Function: dbg-on (&rest ids) ¶

Package: fl.debug.
Source: debug.lisp.

Function: dbg-p (id-or-ids) ¶

Returns T if @arg{id-or-ids} is in the debug list, NIL otherwise.
If @arg{id-or-ids} is a list, then every of its elements is checked if it is in the debug list.

Package: fl.debug.
Source: debug.lisp.

Function: dealii-n-ball-domain (dim &key radius) ¶

An alternative version of the n-ball defined by using cubic patches. This is precisely what the well-known FE library deal.ii does.

Package: fl.mesh.
Source: domain.lisp.

Function: decrease-refcount (pool object &optional decrement) ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: det-from-lr (lr pivot) ¶

This routine computes the determinant using a given LR decomposition.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: diag (vec) ¶

Returns a diagonal matrix with diagonal entries from vec.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: diagonal-reaction-coefficient (values) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Function: diagonal-sparse-tensor (values &optional ncomps) ¶

Constructs a sparse tensor of rank 2 where @arg{values} is a vector of diagonal entries. If @arg{ncomps} is given then the tensor dimension is nxn with each diagonal entry being @arg{values}.

Package: fl.matlisp.
Source: sparse-tensor.lisp.

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.

Package: fl.multigrid.
Source: amg.lisp.

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}.

Package: fl.discretization.
Source: fedisc.lisp.

Function: display-ht (hash-table) ¶

Display @arg{hash-table} in the form key1 -> value1 ...

Package: fl.utilities.
Source: utilities.lisp.

Function: dissection-compare (h-mesh &key key) ¶

Compares two cells wrt their level and their dimension.
The predicate is true if level1>level2 or the levels are equal and dim1>dim2.

Package: fl.mesh.
Source: mesh.lisp.

Reader: dli-object (instance) ¶

Writer: (setf dli-object) (instance) ¶

Package: fl.utilities.
Source: utilities.lisp.
Target Slot: object.

Reader: dli-pred (instance) ¶

Writer: (setf dli-pred) (instance) ¶

Package: fl.utilities.
Source: utilities.lisp.
Target Slot: pred.

Reader: dli-succ (instance) ¶

Writer: (setf dli-succ) (instance) ¶

Package: fl.utilities.
Source: utilities.lisp.
Target Slot: succ.

Function: dll->list (dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-empty-p (dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-find (key dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-for-each (func dll &optional direction) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-front-insert (obj dll &optional insert-item-p) ¶

Inserts @arg{obj} in @arg{dll}. It returns the newly created @class{dll-item}.

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-peek-first (dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-peek-last (dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-pop-first (dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-pop-last (dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-rear-insert (obj dll &optional insert-item-p) ¶

Inserts @arg{obj} in @arg{dll}. It returns the newly created @class{dll-item}.

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-remove (obj dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-remove-item (item dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: domain-boundary (domain) ¶

The boundary of the domain as a skeleton.

Package: fl.mesh.
Source: domain.lisp.

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.

Package: fl.mesh.
Source: domain.lisp.

Function: double-vec (&rest comps) ¶

Returns a @class{double-vec} with the entries in @arg{comps}.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: driven-cavity (dim &key viscosity reynolds eta xi smooth-p) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: drop-object (object parallel-heap) ¶

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: dynamic-space-size () ¶

Available memory for calculations

Package: fl.port.
Source: port.lisp.

Function: effective-tensor (blackboard) ¶

Package: fl.application.
Source: app-utils.lisp.

Function: elasticity-model-problem (domain &key lambda mu force dirichlet) ¶

Package: fl.elasticity.
Source: elasticity.lisp.

Function: elementary (n i j &optional type) ¶

Returns the nxn elementary matrix with 1 at position (i,j). The value is freshly allocated.

Package: fl.matlisp.
Source: standard-matrix.lisp.

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.

Package: fl.discretization.
Source: constraints.lisp.

Function: eliminate-small-coefficients (poly &optional threshold) ¶

Package: fl.function.
Source: polynom.lisp.

Function: ellipse-matrix (radius excentricity phi) ¶

Returns a matrix A suitable for describing the ellipse as (Ax,x)=1.

Package: fl.function.
Source: function.lisp.

Function: ellsys-model-problem (domain components &key a b c d r f g h dirichlet initial sigma evp properties derived-class) ¶

Generates a rather general elliptic problem on the given domain.

Package: fl.ellsys.
Source: ellsys.lisp.

Function: ellsys-one-force-coefficient (nr-comps multiplicity) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

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.

Package: fl.problem.
Source: pde-problem.lisp.

Function: ensure-dirichlet-coefficient (obj) ¶

Package: fl.cdr.
Source: cdr.lisp.

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.

Package: fl.mesh.
Source: domain.lisp.

Function: ensure-simplex-product (factor-dims) ¶

Returns the reference product-cell for the given factor dimensions.

Package: fl.mesh.
Source: product-cell.lisp.

Function: ensure-tensor-coefficient (name obj) ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: ensure-vector-coefficient (name obj) ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: erf (x) ¶

Package: fl.alienc.
Source: alienc.lisp.

Function: erfc (x) ¶

Package: fl.alienc.
Source: alienc.lisp.

Function: etable-of-highest-dim (skel) ¶

Package: fl.mesh.
Source: skeleton.lisp.

Function: extend (mesh &key test) ¶

Extends a mesh on all extensible cells for which test —if provided— yields T.

Package: fl.mesh.
Source: extend.lisp.

Function: extend-by-identity (mat extend &key ignore copy) ¶

Extends A such that the keys in extend which are not in ignore are mapped to identity.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

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.

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: extract-demo-strings (string &optional translations) ¶

Extract demo information from the documentation string of the generating function.

Package: fl.demo.
Source: demo.lisp.

Function: extract-from (solution from ncomps &optional scalar-p index) ¶

Extracts numbers or subvectors from the solution vector.

Package: fl.problem.
Source: pdef.lisp.

Function: extraction-information (components component) ¶

If @arg{component} is found, its offset, length, a scalarp-flag, and the full form of the component is returned.

Package: fl.problem.
Source: pde-problem.lisp.

Function: eye (n &optional m type) ¶

Returns the nxn identity matrix. The value is freshly allocated.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: factor-dimensions (cell) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: factor-simplices (cell) ¶

Returns the factor-simplices.

Package: fl.mesh.
Source: cell.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Function: fas (&rest key-args) ¶

Constructor of a geometric multigrid iteration of FAS type.

Package: fl.geomg.
Source: geomg.lisp.

Function: fd-laplace-matrix (dim n &rest key-args &key sample &allow-other-keys) ¶

Short version of generating an arbitrary-dimensional FD discretization of the Laplace operator.

Package: fl.matlisp.
Source: compressed.lisp.

Function: fe-cell-geometry (cell sample-points &key weights metric volume) ¶

Collects cell geometry information at @arg{sample-points} inside a property list.

Package: fl.discretization.
Source: fe.lisp.

Function: fe-discretize (blackboard) ¶

Finite element discretization for an ansatz space provided on the blackboard.

Package: fl.discretization.
Source: fedisc.lisp.

Function: fe-extraction-information (fe indices) ¶

Computes information for extracting components out of a vector finite element.

Package: fl.discretization.
Source: sparseif.lisp.

Function: femlisp-banner () ¶

Package: fl.start.
Source: finalize.lisp.

Function: femlisp-demo (&optional demo) ¶

Shows all demos below the given demo root.

Package: fl.demo.
Source: demo.lisp.

Function: femlisp-herald () ¶

Package: fl.start.
Source: finalize.lisp.

Function: femlisp-pathname (&optional namestring) ¶

Get pathname relative to the Femlisp directory.

Package: fl.start.
Source: setup.lisp.

Function: file-documentation (docstring) ¶

If the manual is sorted by file, the string handed to this function describes the use of the respective file.

Package: fl.utilities.
Source: general.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Function: filter-applicable-coefficients (coeffs cell patch &key constraints) ¶

Filters out the applicable coefficients for the respective cell with the given patch.

Package: fl.problem.
Source: pde-problem.lisp.

Function: filter-if (&rest args) ¶

The positive version of REMOVE-IF-NOT.

Package: fl.utilities.
Source: utilities.lisp.

Function: finalize (obj func) ¶

Sets up @arg{func} as finalizer for @arg{obj}.

Package: fl.port.
Source: port.lisp.

Function: find-cell (test skel &rest rest) ¶

Package: fl.mesh.
Source: skeleton.lisp.

Function: find-cell-from-corners (skel corners) ¶

Package: fl.mesh.
Source: skeleton.lisp.

Function: find-cells (test skel &key dimension with-properties where) ¶

Returns a list of cells contained in skel and satisfying test.

Package: fl.mesh.
Source: skeleton.lisp.

Function: find-coefficient (coeff-name problem) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: find-component (components component-name) ¶

Finds the component with the given name together with its offset.

Package: fl.problem.
Source: pde-problem.lisp.

Function: find-demo (name parent) ¶

Package: fl.demo.
Source: demo.lisp.

Function: find-executable (name) ¶

Finds an executable in the current path.

Package: fl.port.
Source: port.lisp.

Function: find-leaf (atom tree &key key test) ¶

Finds atom in @arg{tree}.

Package: fl.utilities.
Source: utilities.lisp.

Function: find-leaf-if (test tree &key key) ¶

Finds a leaf in @arg{tree} where @arg{test} returns true.

Package: fl.utilities.
Source: utilities.lisp.

Function: find-patch (domain classifiers &key midpoint) ¶

Searches for a patch of @arg{domain} having the given list @arg{classifiers}.

Package: fl.mesh.
Source: domain.lisp.

Function: find-programmatic-class (superclasses &key class-name package) ¶

Finds and, if necessary, generates a class from the given superclasses.

Package: fl.amop.
Source: amop.lisp.

Function: find-shared-library (name) ¶

Finds a shared library.

Package: fl.port.
Source: port.lisp.

Function: find-subtree (atom tree &key key test) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: find-subtree-if (test tree &key key) ¶

Finds a leaf in @arg{tree} where @arg{test} returns true.

Package: fl.utilities.
Source: utilities.lisp.

Function: first-only (list) ¶

Checks if @arg{list} is a singleton and returns its first element.

Package: fl.utilities.
Source: utilities.lisp.

Function: fixnum-vec (&rest elements) ¶

Returns a @symbol{FIXNUM-VEC} constructed from the parameters.

Package: fl.utilities.
Source: utilities.lisp.

Function: flatten (tree) ¶

Flatten a tree. Example:
@lisp
(flatten ’((1 2) (3) ((4)))) @result{} (1 2 3 4) @end lisp

Package: fl.utilities.
Source: utilities.lisp.

Function: flatten-1 (lst) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: for-each-cell-of-highest-dimension-on-surface (func h-mesh) ¶

Calls func for each cell on the hierarchical-mesh surface.

Package: fl.mesh.
Source: mesh.lisp.

Function: for-each-tuple (func limits) ¶

Calls @arg{func} on each tuple greater or equal to (0 ... 0) and below @arg{dims}.

Package: fl.utilities.
Source: utilities.lisp.

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}.

Package: fl.port.
Source: port.lisp.

Function: fu->coefficient (name func) ¶

The function argument @arg{func} is transformed into a coefficient depending on the solution.

Package: fl.problem.
Source: pde-problem.lisp.

Function: full-ccs-pattern (nrows ncols) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: full-compressed-pattern (nrows ncols &optional orientation) ¶

Returns a full compressed pattern.

Package: fl.matlisp.
Source: compressed.lisp.

Function: full-crs-pattern (nrows ncols) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: full-tensor (type) ¶

Construct a full tensor with entries of @arg{type}.

Package: fl.matlisp.
Source: tensor.lisp.

Function: function->coefficient (name func) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: fx->coefficient (name func &key offset) ¶

The function argument @arg{func} is transformed into a coefficient depending on global coordinates.

Package: fl.problem.
Source: pde-problem.lisp.

Function: fxu->coefficient (name func &key k) ¶

The function argument @arg{func} is transformed into a coefficient depending on position and solution. If k is different from 0 then the k-jet of f is returned as arguments.

Package: fl.problem.
Source: pde-problem.lisp.

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.

Package: fl.multigrid.
Source: amg.lisp.

Function: gauss-lobatto-points (s) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-lobatto-points-on-unit-interval (s) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-lobatto-rule (factor-dims s) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-rule (factor-dims s) ¶

Returns an s-point Gauss integration rule.

Package: fl.discretization.
Source: quadrature.lisp.

Function: gc (&key full &allow-other-keys) ¶

Package: fl.port.
Source: port.lisp.

Function: gemm (alpha x y beta z &optional job) ¶

Rewriting of GEMM in terms of GEMM!.

Package: fl.matlisp.
Source: matrix.lisp.

Function: gemm! (alpha x y beta z &optional job) ¶

Dispatches on the optional job argument (member :nn :tn :nt :tt) and calls the corresponding generic function, e.g. GEMM-NN!.

Package: fl.matlisp.
Source: matrix.lisp.

Function: geometric-cs (&rest key-args) ¶

Constructor of a geometric multigrid iteration of correction scheme type.

Package: fl.geomg.
Source: geomg.lisp.

Function: geometric-psc (&rest rest) ¶

Constructor of a geometric parallel subspace correction.

Package: fl.geomg.
Source: geoblock.lisp.

Function: geometric-ssc (&rest rest) ¶

Constructor of a geometric successive subspace correction.

Package: fl.geomg.
Source: geoblock.lisp.

Function: gesv (a b) ¶

Rewriting for GESV in terms of GESV!.

Package: fl.matlisp.
Source: matrix.lisp.

Function: get-cell-property (cell skel property) ¶

Returns the value of the property.

Package: fl.mesh.
Source: skeleton.lisp.

Function: (setf get-cell-property) (cell skel property) ¶

Sets the value of the property.

Package: fl.mesh.
Source: skeleton.lisp.

Function: get-coefficient (coeffs name) ¶

Get coefficient @arg{name} from the list @arg{coeffs}.

Package: fl.problem.
Source: pde-problem.lisp.

Function: get-coefficients (coeffs name) ¶

Get coefficients with name @arg{name} from the list @arg{coeffs}.

Package: fl.problem.
Source: pde-problem.lisp.

Function: get-property (object property) ¶

Gets @arg{property} for @arg{object}. Returns NIL also if @arg{property} is not available.

Package: fl.utilities.
Source: general.lisp.

Function: (setf get-property) (object property) ¶

Sets the property @arg{property} of @arg{problem} to @arg{value}.

Package: fl.utilities.
Source: general.lisp.

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, or even the rule itself. Two values are returned: the rule and its position in the refinement-rule vector.

Package: fl.mesh.
Source: refine.lisp.

Function: (setf get-refinement-rule) (cell id) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: geta (alist key) ¶

An analog to @code{GETF} for association lists.

Package: fl.utilities.
Source: utilities.lisp.
Setf expander for this function: (setf geta).

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}.

Package: fl.utilities.
Source: utilities.lisp.

Function: (setf getbb) (blackboard key) ¶

Setter corresponding to @code{GETBB}.

Package: fl.utilities.
Source: utilities.lisp.

Function: getenv (var) ¶

Return the value of the environment variable.

Package: fl.port.
Source: port.lisp.

Function: getrf (x &optional ipiv) ¶

Rewriting for GETRF in terms of GETRF!.

Package: fl.matlisp.
Source: matrix.lisp.

Function: getrs (lu b &optional ipiv) ¶

Rewriting for GETRS in terms of GETRS!.

Package: fl.matlisp.
Source: matrix.lisp.

Function: group-by (characteristic seq &key test) ¶

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

Package: fl.utilities.
Source: utilities.lisp.

Function: hash-table->alist (hash-table) ¶

Collect the keys of @arg{hash-table} into a list.

Package: fl.utilities.
Source: utilities.lisp.

Function: hash-table-keys (hash-table) ¶

Collect the keys of @arg{hash-table} into a list.

Package: fl.utilities.
Source: utilities.lisp.

Function: hash-table-values (hash-table) ¶

Collect the values of @arg{hash-table} into a list.

Package: fl.utilities.
Source: utilities.lisp.

Function: heisig-neuss-2017-demo (problem &key order levels output distributed-p initial-mesh-refinements) ¶

This is a slightly trimmed copy of the function @function{elasticity-interior-effective-coeff-demo}.

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Function: hierarchically-ordered-cells (h-mesh &key where) ¶

Deprecated. If you need this function, please contact me on the mailing list. NN.

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.

Package: fl.mesh.
Source: mesh.lisp.

Function: homotopy (func1 func2) ¶

Returns a function which uses its first coordinate as a homotopy parameter.

Package: fl.function.
Source: function.lisp.

Function: hostname () ¶

Returns the hostname.

Package: fl.port.
Source: port.lisp.

Function: hyperplane-normal (mat) ¶

Calculates a ’normal’ nu for the n-1-dimensional hyperplane determined by the n-1 columns of the nx(n-1)-matrix @arg{mat}. More precisely, this is a vector nu, such that det(A|nu)=|nu|^2. This construction generalizes the cross product in 3 space dimensions.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: identification-coefficient (master mapping) ¶

A special coefficient used for identifying parts of the domain. The coefficient evaluation returns the master coordinates.

Package: fl.problem.
Source: pde-problem.lisp.

Function: identification-p (object) ¶

Package: fl.mesh.
Source: identify.lisp.

Function: identified-p (cell skel) ¶

Returns @arg{cell}’s identification in @arg{skel} or NIL.

Package: fl.mesh.
Source: identify.lisp.

Function: identify (identified-cells skel) ¶

Identifies all cells in @arg{identified-cells} within @arg{skel}.

Package: fl.mesh.
Source: identify.lisp.

Function: identify-unit-cell-faces (skel &key indices) ¶

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.

Package: fl.mesh.
Source: identify.lisp.

Function: identity-permutation-p (perm) ¶

Checks if the permutation is the identity.

Package: fl.utilities.
Source: utilities.lisp.

Function: images-pathname (&optional name) ¶

Pathname of the directory for @femlisp{} images.

Package: fl.graphic.
Source: graphics.lisp.

Function: index-range-disjoint-p (mat1 mat2) ¶

Checks if the range of indices of two sparse matrices is disjoint.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: initial-value-provided-p (problem) ¶

Tests if problem is provided with an initial value. This should be normally the case for time-dependent problems, but may also be useful for stationary problems, e.g. for providing a starting guess in an iterative method.

Package: fl.ellsys.
Source: ellsys.lisp.

Function: initialize-konwihr-paper-calculation () ¶

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Function: inner-dof-indices (fe) ¶

Package: fl.discretization.
Source: fe.lisp.

Function: inner-refcell-children (refcell rule) ¶

Returns the children of refcell.

Package: fl.mesh.
Source: refine.lisp.

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}.

Package: fl.mesh.
Source: skeleton.lisp.

Function: insert-cell-from-corners (mesh corners->cell cell-class corners properties &key create-subcells) ¶

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.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: insert-cells! (skel cells) ¶

Inserts a list of cells into a skeleton.

Package: fl.mesh.
Source: skeleton.lisp.

Function: int-vec (&rest comps) ¶

Returns a @class{int-vec} with the entries in @arg{comps}.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: integrate-simple-polynomial (poly) ¶

Package: fl.function.
Source: polynom.lisp.

Function: integration-rule (cell order) ¶

Returns an integration rule for @arg{cell} of the given @arg{order}.

Package: fl.discretization.
Source: quadrature.lisp.

Function: interior-dof? (dof) ¶

Package: fl.discretization.
Source: fe.lisp.

Function: interpolation-matrix (ansatz-space &key level region imat 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*}.

Package: fl.discretization.
Source: sparseas.lisp.

Function: interval-method (func a b accuracy) ¶

Finds zeros of functions in 1d by the interval method.

Package: fl.function.
Source: function.lisp.

Function: invert-graph (graph) ¶

Invert the directed graph given in @arg{graph} as a hash-table.

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: isotropic-diffusion (dim values) ¶

Returns a sparse diagonal diffusion tensor with isotropic diffusion in each component. @arg{values} should be a vector or a number and contains the amount of diffusion in each component.

Package: fl.ellsys.
Source: ellsys.lisp.

Function: isotropic-diffusion-coefficient (dim values) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Function: isotropic-elasticity-tensor (&key dim lambda mu compressed-p) ¶

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})}.

Package: fl.elasticity.
Source: elasticity.lisp.

Function: isotropic-elasticity-tensor-coefficient (dim &optional lambda mu) ¶

Package: fl.elasticity.
Source: elasticity.lisp.

Function: iterate-identifications (initial-identifications) ¶

Generates all identifications of the skeleton from the identifications of some higher-dimensional cells.

Package: fl.mesh.
Source: identify.lisp.

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.

Package: fl.matlisp.
Source: matrix.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

Package: fl.utilities.
Source: utilities.lisp.

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

Package: fl.utilities.
Source: utilities.lisp.

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.

Package: fl.mesh.
Source: identify.lisp.

Function: kill-process (process) ¶

Kills the given process

Package: fl.port.
Source: port.lisp.

Function: kmgt (stream number colon-p at-p &optional w d) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: konwihr-paper-max-levels () ¶

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Function: konwihr-speed () ¶

Returns estimated speed of the current Femlisp in MLOPS.

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Function: l-domain (dim) ¶

Creates an L-domain by cutting out cubes from the uniform refinement of the unit cube.

Package: fl.mesh.
Source: domain.lisp.

Function: lagrange-ansatz-space (problem mesh &key order type) ¶

A constructor for a problem-dependent Lagrange fe. Here, the number of components may vary with the respective patch.

Package: fl.discretization.
Source: ansatz-space.lisp.

Function: lagrange-fe (order &key nr-comps type) ¶

Constructor for Lagrange fe. nr-comps=nil builds a scalar fe-discretization, otherwise a vector-fe-discretization is built.

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-mapping (order &optional type) ¶

Returns a function which maps a cell by a polynomial which is obtained by interpolating the boundary map via Lagrange interpolation.

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-polynomials (points) ¶

Package: fl.function.
Source: polynom.lisp.

Function: langevin (x) ¶

Calculate the Langevin function to an accuracy of about 15 digits

Package: fl.function.
Source: function.lisp.

Function: langevinx (x) ¶

Calculate the function Langevinx(x):=Langevin(x)/x

Package: fl.function.
Source: function.lisp.

Function: lapack (name type) ¶

Ensures the CL binding to the specified LAPACK function.

Package: fl.lapack.
Source: lapack.lisp.

Function: lapack-available-p () ¶

Rudimentarily memoized function testing if LAPACK is available.

Package: fl.lapack.
Source: lapack.lisp.

Function: laplace-full-matrix (n &optional dim) ¶

Generates the matrix for a @arg{dim}-dimensional Laplace problem discretized with the @math{2*@arg{dim}+1}-point stencil on a structured mesh with Dirichlet boundary conditions.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: laplace-sparse-matrix (dim n &key type sample) ¶

Generates a sparse matrix for a dim-dimensional Laplace problem discretized with the (2*dim+1)-point stencil on a structured mesh.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: level-of-cell (cell h-mesh) ¶

Returns the level of @arg{cell} in the hirearchical mesh @arg{h-mesh}.

Package: fl.mesh.
Source: mesh.lisp.

Function: linearly-transformed-skeleton (skel &key a b properties) ¶

Transforms skel by transforming the vertex positions.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: linsolve (mat rhs &key sol res output iteration residual-norm threshold reduction maxsteps success-if failure-if &allow-other-keys) ¶

Old and deprecated interface for solving linear problems.

Package: fl.iteration.
Source: linsolve.lisp.

Function: list->dll (list) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: list->queue (list) ¶

Transforms @arg{list} to a queue.

Package: fl.utilities.
Source: utilities.lisp.

Function: list-comparison (order) ¶

Returns a comparison function for comparing two lists of numbers lexicographically, but with elements ordered according to ORDER.

Package: net.scipolis.relations.
Source: relations.lisp.

Function: load-foreign-library (file) ¶

Loads the foreign library @arg{file}.

Package: fl.port.
Source: port.lisp.

Function: local-imatrix (rule fe &optional type) ¶

Memoized call of compute-local-imatrix.

Package: fl.discretization.
Source: fetransfer.lisp.

Function: local-pmatrix (rule fe) ¶

Memoized call of compute-local-pmatrix.

Package: fl.discretization.
Source: fetransfer.lisp.

Function: local-transfer-matrix (fe-from fe-to) ¶

Computes a local transfer matrix between different FE spaces.

Package: fl.discretization.
Source: fetransfer.lisp.

Function: lse (&rest args) ¶

Constructs a standard LSE.

Package: fl.problem.
Source: problem.lisp.

Function: lu-solver (&key output) ¶

LU decomposition without pivoting.

Package: fl.iteration.
Source: linsolve.lisp.

Function: m- (x y) ¶

Returns X-Y. Uses AXPY.

Package: fl.matlisp.
Source: vector.lisp.

Function: m-! (x y) ¶

Y - X -> Y. Uses AXPY!.

Package: fl.matlisp.
Source: vector.lisp.

Function: m.* (x y) ¶

Returns X .* Y. Uses M.*! and COPY.

Package: fl.matlisp.
Source: vector.lisp.

Function: m/ (x) ¶

Returns the inverse of X. Needs the identity matrix given by @function{eye} which makes this function not generally applicable.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: make-ansatz-space-automorphism (as) ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: make-ansatz-space-morphism (domain-as image-as) ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: make-ansatz-space-vector (as &optional multiplicity constraints-p) ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: make-cell-from-corners (cell-class corners) ¶

Creates a cell of class CELL-CLASS having the given CORNERS.

Package: fl.mesh.
Source: vertex.lisp.

Function: make-cell-from-vertices (cell-class vertices) ¶

Creates a cell of class CELL-CLASS having the given VERTICES.

Package: fl.mesh.
Source: vertex.lisp.

Function: make-classifier (test classification) ¶

Returns a classifier for patches.

Package: fl.mesh.
Source: domain.lisp.

Function: make-demo (&rest initargs) ¶

Package: fl.demo.
Source: demo.lisp.

Function: make-dll () ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: make-domain (skel &rest args) ¶

Changes a skeleton into a domain.

Package: fl.mesh.
Source: domain.lisp.

Function: make-double-float-array (size &optional initial) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: make-double-vec (dim &optional init) ¶

Returns a @class{double-vec} of length @arg{dim} and initial value @arg{init}.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: make-fe-ansatz-space (fe-class problem mesh) ¶

Constructor of @class{<ansatz-space>}.

Package: fl.discretization.
Source: ansatz-space.lisp.

Function: make-filled-array (dims &rest args &key initializer &allow-other-keys) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: make-fixnum-vec (dim &optional init) ¶

Construct a @symbol{FIXNUM-VEC} of size @arg{dim} initialized by @arg{init}.

Package: fl.utilities.
Source: utilities.lisp.

Function: make-full-block-analog (sm &rest key-args &key &allow-other-keys) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: make-full-crs-matrix (nrows ncols) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: make-hash-table (&rest args) ¶

Package: fl.patches.
Source: patches.lisp.

Function: make-hierarchical-mesh-from (&rest args) ¶

Creates a hierarchical-mesh from the given arguments. See @function{MAKE-MESH-FROM}.

Package: fl.mesh.
Source: meshgen.lisp.

Function: make-int-vec (dim &optional init) ¶

Package: fl.matlisp.
Source: ctypes.lisp.

Function: make-line (from-vtx to-vtx &key check mapping) ¶

Creates a line given its endpoints.

Package: fl.mesh.
Source: simplex.lisp.

Function: make-local-vec (ansatz-space cell &key multiplicity) ¶

Generates a local vector for local discretization. We allow overriding the default multiplicity for the ansatz space for special use cases.

Package: fl.discretization.
Source: sparseif.lisp.

Function: make-matrix (&rest args) ¶

Generates a standard matrix as specified by its arguments. If two arguments are provided, they should be numbers which are interpreted as rows and columns. If only one argument is provided, it should be either a number meaning the rows and columns of a square matrix or a nested list or vector structure defining the contents matrix.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: make-matrix-block (smat row-key col-key) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: make-number-relation (n) ¶

Returns a relation between n numbers.

Package: net.scipolis.relations.
Source: relations.lisp.

Function: make-parallel-heap (objects dependents) ¶

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: make-polynomial (coeffs) ¶

Constructor which simplifies the coefficient list.

Package: fl.function.
Source: polynom.lisp.

Function: make-programmatic-instance (superclass-es &rest initargs &key class-name package &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.

Package: fl.amop.
Source: amop.lisp.

Function: make-real-matrix (&rest args) ¶

Generates a real matrix as specified by its arguments.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: make-real-tensor (dimensions) ¶

Generates an instance of a tensor with DOUBLE-FLOAT entries and the given @arg{dimensions}.

Package: fl.matlisp.
Source: tensor.lisp.

Function: make-real-vector (dim &optional value) ¶

Generates a real matrix of dimension @arg{dim} x 1.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: make-simplex (boundary &key check 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.

Package: fl.mesh.
Source: simplex.lisp.

Function: make-sparse-automorphism (&rest key-args &key key->size keys->pattern &allow-other-keys) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: make-sparse-matrix (&rest args &key type &allow-other-keys) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: make-sparse-vector (&rest args &key type &allow-other-keys) ¶

Package: fl.matlisp.
Source: sparse-vector.lisp.

Function: make-uint-vec (dim &optional init) ¶

Package: fl.matlisp.
Source: ctypes.lisp.

Function: make-vertex (position &optional mapping) ¶

General vertex constructor.

Package: fl.mesh.
Source: vertex.lisp.

Function: make-weak-pointer (obj) ¶

Creates a weak pointer pointing to @arg{obj}.

Package: fl.port.
Source: port.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Function: map-list-in-hash-table (func list &optional type) ¶

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.

Package: fl.utilities.
Source: utilities.lisp.

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

Package: fl.utilities.
Source: utilities.lisp.

Function: map-tree (func tree &optional depth) ¶

Maps @arg{tree} using @arg{func}. Example: @lisp
(map-tree #’1+ ’((1 (2)))) @result{} ((2 (3))) @end lisp

Package: fl.utilities.
Source: utilities.lisp.

Function: mapped-cell-class (class &optional distorted) ¶

Constructs a cell class with <mapped-cell> mixin.

Package: fl.mesh.
Source: cell.lisp.

Function: mapped-p (cell) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: mappend (func &rest lists) ¶

Map @function{func} over @arg{lists} while appending the results.

Package: fl.utilities.
Source: utilities.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

Package: fl.utilities.
Source: utilities.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

Package: fl.utilities.
Source: utilities.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

Package: fl.utilities.
Source: utilities.lisp.

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

Package: fl.utilities.
Source: utilities.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

Package: fl.utilities.
Source: utilities.lisp.

Function: mapper-sum (mapper table &rest rest-args &key key &allow-other-keys) ¶

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

Package: fl.utilities.
Source: utilities.lisp.

Function: mark-skeleton (skel prop value) ¶

Marks all cells of @arg{skel} with the given @arg{prop}/@arg{value} pair.

Package: fl.mesh.
Source: skeleton.lisp.

Function: matrix-col-p (mat col-key) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: matrix-row-p (mat row-key) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: maximally-connected (connected disconnected &key test combine) ¶

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

Package: fl.utilities.
Source: utilities.lisp.

Function: measure-time (fn &optional count real-p) ¶

Measures the time in seconds needed by @arg{count}-times executing @arg{fn}.

Package: fl.utilities.
Source: mflop.lisp.

Function: member-of-skeleton? (cell skel) ¶

Returns T if @arg{cell} is in @arg{skel}, NIL otherwise.

Package: fl.mesh.
Source: skeleton.lisp.

Function: memoize-1 (func &key test) ¶

Memoizes the function @arg{func} which should be a non-recursive function of one argument.

Package: fl.utilities.
Source: utilities.lisp.

Function: memoize-symbol (funsym &key test) ¶

Memoizes multi-argument functions named by the symbol @arg{funsym}.

Package: fl.utilities.
Source: utilities.lisp.

Function: mklist (obj) ¶

Wraps @arg{obj} in a list, if it is not already a list.

Package: fl.utilities.
Source: utilities.lisp.

Function: modify (lst &key add remove) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: mp-dbg (id format &rest args) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: mrandom (n &optional m type range) ¶

Returns a random nxn or (if m is provided) nxm matrix. The value is freshly allocated.

Package: fl.matlisp.
Source: standard-matrix.lisp.

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}.

Package: fl.discretization.
Source: sparseif.lisp.

Function: mutex-wrap (object) ¶

Package: fl.parallel.
Source: mutex.lisp.

Function: n-ball-domain (dim) ¶

Generates an n-dimensional ball domain with 2^n simplex patches.

Package: fl.mesh.
Source: domain.lisp.

Function: n-cell-domain (dim) ¶

Generates an n-dimensional cell domain which is a n-dimensional unit cube with its opposite sides identified.

Package: fl.mesh.
Source: domain.lisp.

Function: n-cell-with-ball-hole (dim &key radius) ¶

Generates an n-dimensional cell domain with an n-ball hole.

Package: fl.domains.
Source: hole-domain.lisp.

Function: n-cell-with-ball-inlay (dim &key radius) ¶

Generates an n-dimensional cell domain with an n-ball inlay.

Package: fl.domains.
Source: inlay-domain.lisp.

Function: n-cell-with-cubic-hole (dim) ¶

Generates an n-dimensional cell domain with an n-cube hole.

Package: fl.domains.
Source: hole-domain.lisp.

Function: n-cell-with-cubic-inlay (dim) ¶

Generates an n-dimensional cell domain with an n-cube hole.

Package: fl.domains.
Source: inlay-domain.lisp.

Function: n-cell-with-ellipsoidal-hole (dim &key a) ¶

Generates an n-dimensional cell domain with an ellipsoidal hole.

Package: fl.domains.
Source: hole-domain.lisp.

Function: n-cube (dim) ¶

Returns the reference cube of dimension dim.

Package: fl.mesh.
Source: product-cell.lisp.

Function: n-cube-domain (dim) ¶

Package: fl.mesh.
Source: domain.lisp.

Function: n-cube-with-ball-hole (dim &key radius) ¶

Generates an n-cube-domain with an n-ball hole using n-cube patches.

Package: fl.domains.
Source: hole-domain.lisp.

Function: n-cube-with-ball-inlay (dim &key radius) ¶

Generates an n-cube-domain with an n-ball inlay using n-cube patches.

Package: fl.domains.
Source: inlay-domain.lisp.

Function: n-cube-with-cubic-hole (dim) ¶

Generates an n-cube-domain with an n-cube hole.

Package: fl.domains.
Source: hole-domain.lisp.

Function: n-cube-with-cubic-inlay (dim) ¶

Generates an n-cube-domain with an n-cube inlay.

Package: fl.domains.
Source: inlay-domain.lisp.

Function: n-cube-with-ellipsoidal-hole (dim &key a midpoint &allow-other-keys) ¶

Generates an n-cube-domain with an ellipsoidal hole satisfying <A(x-midpoint),(x-midpoint)>=1 using n-cube patches.

Package: fl.domains.
Source: hole-domain.lisp.

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

Package: fl.utilities.
Source: utilities.lisp.

Function: n-simplex (dim) ¶

Returns the reference simplex of the given dimension.

Package: fl.mesh.
Source: simplex.lisp.

Function: n-simplex-domain (dim) ¶

Package: fl.mesh.
Source: domain.lisp.

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)

Package: fl.function.
Source: polynom.lisp.

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*}.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

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}.

Package: fl.navier-stokes-fe.
Source: navier-stokes-fe.lisp.

Function: navier-stokes-pressure-and-continuity-coefficient (dim &key eta xi) ¶

The pressure and continuity part of the Navier-Stokes equation. These parts can be multiplied by factors @arg{eta} and @arg{xi} which can be useful for debugging, for example.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: navier-stokes-viscosity-coefficient (dim viscosity) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: new-kernel (&optional nr-threads set-affinity-p) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: nlse (&rest args) ¶

Constructs a standard NLSE.

Package: fl.problem.
Source: problem.lisp.

Function: no-slip-boundary (dim) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: nonempty-subsets (set) ¶

Returns a list of all nonempty subsets of @arg{set}.

Package: fl.utilities.
Source: utilities.lisp.

Function: normalize (x &optional p) ¶

Scales @arg{x} to have @arg{p}-norm equal to 1.

Package: fl.matlisp.
Source: vector.lisp.

Function: normalize! (x &optional p) ¶

Scales @arg{x} destructively to have @arg{p}-norm equal to 1.

Package: fl.matlisp.
Source: vector.lisp.

Function: nr-of-cells (skel &optional dimension) ¶

Returns number of cells in a skeleton.

Package: fl.mesh.
Source: skeleton.lisp.

Function: nr-of-components-of-patch (patch problem) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: nr-of-levels (mm) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: nr-of-sides (cell) ¶

Returns the number of boundary faces.

Package: fl.mesh.
Source: cell.lisp.

Function: nr-of-subcells (cell) ¶

Returns the number of subcells.

Package: fl.mesh.
Source: cell.lisp.

Function: nr-of-surface-cells (h-mesh) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: nr-of-vertices (cell) ¶

Returns the number of vertices.

Package: fl.mesh.
Source: cell.lisp.

Function: ns-cell-problem-force (dim) ¶

Package: fl.flow-application.
Source: hom-ns.lisp.

Function: ns-hole-cell-problem (dim &key viscosity reynolds) ¶

Package: fl.flow-application.
Source: hom-ns.lisp.

Function: number-coercer (number-type) ¶

Returns a function converting a number to a number of the given number-type or recursively also a vector of numbers.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: numerical-complex-derivative (f) ¶

Computes a very accurate real derivative for functions which can be applied to complex arguments.

Warning: This trick can only be applied once, i.e. derivatives of higher order cannot be computed by multiple application of this function!

Package: fl.function.
Source: function.lisp.

Function: numerical-derivative (func &key shift) ¶

Computes the numerical derivative of func at pos.

Package: fl.function.
Source: function.lisp.

Function: numerical-gradient (func &key shift) ¶

Package: fl.function.
Source: function.lisp.

Function: on-leaves (func tree) ¶

Executes @arg{func} on the leaves of @arg{tree}.

Package: fl.utilities.
Source: utilities.lisp.

Function: on-subtrees (func tree) ¶

Calls @arg{func} on every subtree of @arg{tree}.

Package: fl.utilities.
Source: utilities.lisp.

Function: ones (n &optional m type) ¶

Returns nxn or (if m is provided) nxm ones. The value is freshly allocated.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: ordered-intersection (set1 set2 &key test) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: ordered-set-difference (set1 set2 &key test) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: ordered-union (set1 set2 &key test) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: oscillating-boundary-domain (dim f &key grad-f upper) ¶

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.

Package: fl.domains.
Source: bl-cell.lisp.

Function: p-map (&rest args) ¶

Use map/pmap depending on availability of kernel. Recursive splitting of work is not done.

Package: fl.parallel.
Source: parallel.lisp.

Function: parent (cell skeleton) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: (setf parent) (cell skeleton) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: partial-sums (seq) ¶

Returns a sequence of the same type as @arg{seq} consisting of its partial sums.

Package: fl.utilities.
Source: utilities.lisp.

Function: patch-classification (patch domain) ¶

Returns a list of classifications for @arg{patch} in @arg{domain}.

Package: fl.mesh.
Source: domain.lisp.

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.

Package: fl.domains.
Source: inlay-domain.lisp.

Function: patch-of-cell (cell mesh) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: (setf patch-of-cell) (cell mesh) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: patch-on-inner-boundary-p (patch) ¶

Checks if the patch is part of the hole boundary.

Package: fl.domains.
Source: hole-domain.lisp.

Function: patch-on-n-cube-boundary-p (patch) ¶

Returns T, if the patch is on the boundary of the n-cube.

Package: fl.domains.
Source: hole-domain.lisp.

Function: periodic-cavity (dim &key viscosity reynolds) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: periodic-polygonal (positions) ¶

Constructs a periodic polygon from @arg{positions}. The result is a @class{<skeleton>}.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: permeability-tensor (blackboard) ¶

Package: fl.flow-application.
Source: hom-ns.lisp.

Function: permutation-inverse (perm-vec) ¶

Returns the inverse of the permutation given by @arg{perm-vec}.

Package: fl.utilities.
Source: utilities.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.

Package: fl.utilities.
Source: utilities.lisp.

Function: permutation-shifted-inverse (perm-vec) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: permutation-signum (perm) ¶

Returns the sign of @arg{perm}.

Package: fl.utilities.
Source: utilities.lisp.

Function: permute (perm index) ¶

Functional version of @function{permute-into}.

Package: fl.utilities.
Source: utilities.lisp.

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]]}.

Package: fl.utilities.
Source: utilities.lisp.

Function: point-observe (position &key component index) ¶

Generates an observer triple which observes the value of component @arg{component} of solution number @arg{index} at the position @arg{position}.

Package: fl.strategy.
Source: fe-approximation.lisp.

Function: poly-exterior-product (poly1 poly2) ¶

Multiply the polynomials poly1 and poly2 considered as polynomials in separate variables.

Package: fl.function.
Source: polynom.lisp.

Function: portability-warning (function &rest args) ¶

Package: fl.port.
Source: port.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

Package: fl.utilities.
Source: utilities.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

Package: fl.utilities.
Source: utilities.lisp.

Function: prepare-coefficient-arguments (components args) ¶

Prepares arguments for the given coefficient function.

Package: fl.problem.
Source: pdef.lisp.

Function: process-close (process) ¶

Closes @arg{process}.

Package: fl.port.
Source: port.lisp.

Function: process-error (process) ¶

Process-output for @arg{process}.

Package: fl.port.
Source: port.lisp.

Function: process-exit-code (process) ¶

Returns the status of @arg{process}.

Package: fl.port.
Source: port.lisp.

Function: process-input (process) ¶

Process-input for @arg{process}.

Package: fl.port.
Source: port.lisp.

Function: process-output (process) ¶

Process-output for @arg{process}.

Package: fl.port.
Source: port.lisp.

Function: process-status (process) ¶

Returns the status of @arg{process}.

Package: fl.port.
Source: port.lisp.

Function: product-cell-p (obj) ¶

Package: fl.mesh.
Source: product-cell.lisp.

Function: product-iterator (iterator nr-steps) ¶

Returns an iterator which does several steps of the given iterator.

Package: fl.iteration.
Source: linit.lisp.

Function: product-rule (&rest quadrature-rules) ¶

Computes a product rule for several lower-dimensional quadrature rules.

Package: fl.discretization.
Source: quadrature.lisp.

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.

Package: fl.function.
Source: function.lisp.

Function: project-to-sphere (midpoint radius) ¶

Returns a function which projects to the sphere with given midpoint and radius.

Package: fl.function.
Source: function.lisp.

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.

Package: fl.discretization.
Source: sparseas.lisp.

Function: put-back-in-pool (pool object) ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: pwork (task &optional arguments) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: queue->list (queue) ¶

Transforms @arg{queue} to a list.

Package: fl.utilities.
Source: utilities.lisp.

Function: r-select-1 (&rest args) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: random-ansatz-space-vector (ansatz-space) ¶

Returns a ansatz space vector for @arg{ansatz-space} filled with random entries. Essential constraints are satisfied.

Package: fl.discretization.
Source: sparseas.lisp.

Function: range (&rest args &key to below) ¶

Constructor for a range of numbers.

Package: fl.utilities.
Source: utilities.lisp.

Function: range-and-domain-disjoint-p (mat) ¶

Checks if index range and index domain of some matrix are disjoint.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: range< (k l) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: range<= (k l) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: rcurry (func &rest args) ¶

Supplies @arg{args} to @arg{func} from the right.

Package: fl.utilities.
Source: utilities.lisp.

Function: read-compressed-matrix (nrows ncols triplet-list &key orientation element-type indexing identify-p &allow-other-keys) ¶

Read a compressed matrix of type @arg{orientation} from the given list of triplets of the form (i j Aij). If identify-p is T, try to identify entries which are equal.

Package: fl.matlisp.
Source: compressed.lisp.

Function: rearrange-tensor (tensor permutation) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: refcell-children (refcell rule) ¶

Returns the children for refcell and subcells.

Package: fl.mesh.
Source: refine.lisp.

Function: refcell-refinement-skeleton (refcell &optional level rule reinit) ¶

Returns an LEVEL times refined skeleton of REFCELL. It is partially memoized, see the documentation of *REFCELL-REFINEMENT-MEMOIZE-DEPTH*.

Package: fl.mesh.
Source: refine.lisp.

Function: reference-cell-p (cell) ¶

Tests if a cell is a reference cell.

Package: fl.mesh.
Source: cell.lisp.

Function: refine-info (cell) ¶

Returns refinement information for the cell.

Package: fl.mesh.
Source: cell.lisp.

Function: refined-p (cell skeleton) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: refined-skeleton-copy (skel &optional refinements) ¶

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: refinement (cell skeleton) ¶

Returns the refinement of @arg{cell} in @arg{skeleton} as two values: the rule and the children.

Package: fl.mesh.
Source: refine.lisp.

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.

Package: fl.mesh.
Source: mesh.lisp.

Function: refinement-rule (cell skel) ¶

Returns the refinement rule of @arg{cell} in @arg{skel}.

Package: fl.mesh.
Source: refine.lisp.

Function: register-coefficient-macros (problem-symbol &rest coeff-syms) ¶

Package: fl.problem.
Source: pdef.lisp.

Function: register-in-pool (pool key object) ¶

Note that the object is only registered, but not put in the pool of free objects, because at creation time it will probably be used immediately!

Package: fl.dictionary.
Source: pool.lisp.

Function: regular-rule-p (rule) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: remove-demo (demo parent) ¶

Remove @arg{demo} from @arg{parent}.

Package: fl.demo.
Source: demo.lisp.

Function: remove-keys (sobj keys) ¶

Package: fl.matlisp.
Source: sparse-vector.lisp.

Function: remove-subclass-methods (gf template-args) ¶

Removes all methods dispatching on subclasses of the template arguments.

Package: fl.amop.
Source: amop.lisp.

Function: remove-test (fsym) ¶

Adjoins a test to the Femlisp test suite.

Package: fl.tests.
Source: tests.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Function: required-fe-functions (coeffs) ¶

Returns a list of finite element functions required by the coefficients in the property list @arg{coeffs}.

Package: fl.problem.
Source: pde-problem.lisp.

Function: rotated-square-domain () ¶

Package: fl.mesh.
Source: domain.lisp.

Function: row (&rest values) ¶

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: run-program (program args &key wait directory search input output error-output) ¶

Runs @arg{program} with arguments @arg{args}.

Package: fl.port.
Source: port.lisp.

Function: run-program-output (program args &rest keys &key &allow-other-keys) ¶

Returns a list of all lines of the output of @function{RUN-PROGRAM} when called with the arguments @arg{PROGRAM} and @arg{ARGS}.

Package: fl.port.
Source: port.lisp.

Function: run-program-report-errors (&rest args) ¶

Package: fl.port.
Source: port.lisp.

Function: runtime-compile (source) ¶

Calls compile on the provided @arg{source}. When :compile is activated for debugging, the source code is printed.

Package: fl.port.
Source: port.lisp.

Function: s1-reduction-amg-solver (order &key output reduction maxsteps) ¶

This is an AMG solver which works also for Lagrange fe of order p by reducing them to P^1 first.

Package: fl.geomg.
Source: geomg.lisp.

Function: safe-sort (seq &rest args) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: samep (sequence &key test key) ¶

Returns t if @arg{sequence} consists of equal elements.

Package: fl.utilities.
Source: utilities.lisp.

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.

Package: fl.utilities.
Source: utilities.lisp.

Function: save-femlisp-core-and-die (&optional core-file-name) ¶

Saves Femlisp core and quits.

Package: fl.port.
Source: port.lisp.

Function: scal (alpha x) ¶

Returns alpha * X. Uses SCAL! and COPY.

Package: fl.matlisp.
Source: vector.lisp.

Function: scalar-diffusion (dim value &key compressed-p) ¶

Scalar isotropic diffusion as an ellsys coefficient. value is the diffusion strength, compressed-p designates the storage form.

Package: fl.cdr.
Source: cdr.lisp.

Function: scalar-reaction (value) ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: scalar-source (value) ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: set-equal (set1 set2 &key test) ¶

Tests two sets for equality, e.g. @lisp
(set-equal ’(a b) ’(b a)) @result{} T @end lisp

Package: fl.utilities.
Source: utilities.lisp.

Function: set-p (list) ¶

Checks if @arg{list} is a set, i.e. if no members occur twice.

Package: fl.utilities.
Source: utilities.lisp.

Function: set-refcount (pool object count) ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: shift-diagonal-inverter (eta) ¶

Can be used for obtaining a diagonal modification to get ILU_mod.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: shift-skeleton (skel shift &key properties) ¶

Shifts skel by vec. vec has to be a vector of dimension (embedded-dimension skel).

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: simplex-class (dim &optional mapped distorted) ¶

Returns the n-simplex class.

Package: fl.mesh.
Source: simplex.lisp.

Function: simplex-p (obj) ¶

Package: fl.mesh.
Source: simplex.lisp.

Function: simplex-product-domain (dims) ¶

Generates a product-cell domain for the given factor dimensions.

Package: fl.mesh.
Source: domain.lisp.

Function: single? (lst) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: sinusoidal-bl-cell (dim &rest rest &key amplitude shift &allow-other-keys) ¶

Returns a boundary layer cell with a sinusoidally oscillating lower boundary.

Package: fl.domains.
Source: bl-cell.lisp.

Function: skel-add! (skel-1 skel-2 &key override 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}.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: skel-empty-p (skel) ¶

Package: fl.mesh.
Source: skeleton.lisp.

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.

Package: fl.mesh.
Source: skeleton.lisp.

Function: skel-ref (skel cell) ¶

Returns the properties of @arg{cell} in @arg{skel}.

Package: fl.mesh.
Source: skeleton.lisp.

Function: (setf skel-ref) (skel cell) ¶

Setter for the properties of @arg{cell} in @arg{skel}.

Package: fl.mesh.
Source: skeleton.lisp.

Function: skeleton-boundary (skel) ¶

Returns a skeleton consisting of cells of skel of dimension n-1 which have only one neighbor.

Package: fl.mesh.
Source: skeleton.lisp.

Function: skeleton-disjoint-union (&rest skels) ¶

Builds a disjoint union skeleton of all skeletons.

Package: fl.mesh.
Source: skeleton-build.lisp.

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.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: slave-dof-p (key mat) ¶

Checks if nothing depends on key and if key depends on other keys.

Package: fl.multigrid.
Source: amg.lisp.

Function: slave-or-dirichlet-dof-p (key mat) ¶

Checks if key is a hanging node or a Dirichlet node.

Package: fl.multigrid.
Source: amg.lisp.

Function: sort-keys-hierarchically (asa) ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: sort-lexicographically (elist &key fuzzy) ¶

Sorts a cell list lexicographically by the coordinates of their midpoint.

Package: fl.mesh.
Source: meshgen.lisp.

Function: sparse-matrix->ccs (a &key keys row-keys col-keys ranges row-ranges col-ranges) ¶

Converts the sparse matrix @arg{A} to CCS format. @arg{row-keys} and @arg{col-keys} may denote a submatrix, @arg{col-ranges} and @arg{row-ranges} may be used for extracting even subblocks of the entries.

This is a rather complicated routine which has not yet been parallelized. Theoretically, this might be a bottleneck for some applications, but, practically, an appropriate case has not yet appeared.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: sparse-real-derivative (sparse-f) ¶

Warning: works only for real-valued functions!

Package: fl.function.
Source: function.lisp.

Function: sparse-tensor (contents) ¶

Constructor for @class{sparse-tensor}. The initial contents can be provided as a list whose entries are of the form (value index_1 ... index_r).

Package: fl.matlisp.
Source: sparse-tensor.lisp.

Function: sparse-vector->matlisp (svec &optional keys ranges) ¶

Transforms all or a part of @arg{svec} corresponding to the keys in @arg{keys} and maybe the ranges in ’ranges’ to a matlisp matrix.

Package: fl.matlisp.
Source: sparse-vector.lisp.

Function: special-1d-function (f &optional df) ¶

Constructs a special function between 1D-spaces from ordinary Lisp functions.

Package: fl.function.
Source: function.lisp.

Function: special-ansatz-space-vector (ansatz-space &key type value constraints-p) ¶

Returns a ansatz space vector for @arg{ansatz-space} filled with constantly, randomly or with values obtained by evaluating a certain function. @arg{type} can be :random (then @arg{value} gives the range of the random numbers), it can be :constant (then @arg{value} contains that constant), and -NYI- it can be :function (then @arg{value} should contain an x-dependent function). Essential constraints are satisfied if constraints-p is T.

Package: fl.discretization.
Source: sparseas.lisp.

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.

Package: fl.mesh.
Source: meshgen.lisp.

Function: spline-interpolated-bl-cell (heights) ¶

Boundary which is interpolated from heights.

Package: fl.domains.
Source: bl-cell.lisp.

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

Package: fl.utilities.
Source: utilities.lisp.

Function: split-into-monomials (coeffs) ¶

Package: fl.function.
Source: polynom.lisp.

Function: square (x) ¶

Return the square of @arg{x}.

Package: fl.utilities.
Source: utilities.lisp.

Function: standard-extender (original-cell replacement) ¶

Extension function replacing an original-cell with a replacement.

Package: fl.mesh.
Source: extend.lisp.

Function: standard-matrix (type) ¶

Defines the programmatic class @class{standard-matrix} for element type @arg{type} as extensions of the programmatic class @class{store-vector}.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: standard-matrix-p (obj) ¶

Tests if @arg{obj} is a @class{standard-matrix}.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: standard-navier-stokes-problem (domain &key viscosity reynolds force) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: stationary-problem-class (tdp) ¶

Finds the stationary pde problem for the time-dependent problem TDP.

Package: fl.problem.
Source: time.lisp.

Function: stokes-darcy-demo (problem &key order levels plot output store-p delta) ¶

Stokes-Darcy - Computes a Darcy permeability tensor

Computes the effective permeability for Stokes flow in a domain with periodically distributed ball-shaped holes. The approximation is done with finite elements and blending. Uniform refinement is used, the linear solver is a geometric multigrid scheme used in a nested iteration fashion. Smoothing is done by a Vanka type smoother.

The solution to this cell problem in ~d~ dimensions consists of ~d~ velocity/pressure pairs, i.e. in total ~d~*(~d~+1) components.

Package: fl.flow-application.
Source: hom-ns.lisp.

Function: store-vector (type &key dynamic) ¶

Package: fl.matlisp.
Source: store-vector.lisp.

Function: structured-mesh-on-box-domain (domain n) ¶

Creates a uniform mesh consisting of N_1 x ... x N_dim cells on a box domain lying parallel to the coordinate axis. Instead of N_i being an integer, it can also be a vector N_i=[x0,...,xN] with numbers x0,...,xN satisfying 0=x0<...<xN=1.

Package: fl.mesh.
Source: meshgen.lisp.

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.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: subcell-children (cell skeleton) ¶

Returns a vector of all children of the subcells of @arg{cell} in @arg{skeleton}.

Package: fl.mesh.
Source: refine.lisp.

Function: subcell-ndofs (fe) ¶

Package: fl.discretization.
Source: fe.lisp.

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.

Package: fl.discretization.
Source: fe.lisp.

Function: subsets (set) ¶

Returns a list of all subsets of @arg{set}.

Package: fl.utilities.
Source: utilities.lisp.

Function: surface-cells-of-dim (h-mesh dim) ¶

This function returns the surface cells of a locally refined hierarchical-mesh structure.

Package: fl.mesh.
Source: mesh.lisp.

Function: surface-cells-of-highest-dim (h-mesh) ¶

This function returns the surface cells of highest dimension of a locally refined hierarchical-mesh structure.

Package: fl.mesh.
Source: mesh.lisp.

Function: symconc (&rest args) ¶

This function builds a symbol from its arguments and interns it. This is used in some macros.

Package: fl.macros.
Source: macros.lisp.

Function: system-namestring (path) ¶

Package: fl.port.
Source: port.lisp.

Function: take (k lst) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: take-object (parallel-heap) ¶

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: telescope (left-skel left->right) ¶

Interpolates the cells of @arg{left-skel} to the mapped cells given by the table @arg{left->right}.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: terminate-kernel (&key wait) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: test-all-demos (&optional demo) ¶

Performs all demos reachable from @arg{demo}.

Package: fl.demo.
Source: demo.lisp.

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}.

Package: fl.mesh.
Source: domain.lisp.

Function: test-femlisp (&key continue package stop title logfile demo) ¶

Runs the Femlisp test suite.

Package: fl.tests.
Source: tests.lisp.

Function: thrice (x) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: time-dependent-p (problem) ¶

Tests if problem is time-dependent, either as suggested by its class, or alternatively by its coefficients.

Package: fl.ellsys.
Source: ellsys.lisp.

Function: top-level-cells (mm) ¶

Package: fl.mesh.
Source: mesh.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.

Package: fl.utilities.
Source: utilities.lisp.

Function: transfer-matrix (domain-as image-as &key no-slaves) ¶

Builds a transfer matrix from domain-as to image-as.

Package: fl.discretization.
Source: sparseas.lisp.

Function: transform-function (func &key domain-transform image-transform) ¶

Package: fl.function.
Source: function.lisp.

Function: transformed-skeleton (skel &key transformation properties) ¶

Transforms skel by transforming the cell mappings resp. vertex positions. Returns the transformed skeleton and a table mapping old cells to their copies.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: translate (item translations) ¶

Performs certain translations from an association table on the string item. Example: (translate "abcdefg" ’(("a" . "x") ("b" . "yz")))

Package: fl.utilities.
Source: utilities.lisp.

Function: tree-leaves (tree) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: tree-uniform-number-of-branches (tree) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: tree-uniformp (trees) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: triangle-domain (corner1 corner2 corner3) ¶

Package: fl.mesh.
Source: domain.lisp.

Function: triangulate (domain &rest args &key parametric check-p &allow-other-keys) ¶

Triangulate @arg{domain} by successively building a mesh on the domain skeleton starting from the 0-dimensional patches.

Package: fl.mesh.
Source: triangulate.lisp.

Function: triangulize (mesh) ¶

Transforms a product-cell mesh into a simplex mesh.

Package: fl.mesh.
Source: meshgen.lisp.

Function: twice (x) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: uint-vec (&rest comps) ¶

Returns a @class{uint-vec} with the entries in @arg{comps}.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: unbox (box) ¶

Getter for a boxed object.

Package: fl.utilities.
Source: utilities.lisp.

Function: (setf unbox) (box) ¶

Setter for a boxed object.

Package: fl.utilities.
Source: utilities.lisp.

Function: uniformly-refined-hierarchical-mesh (domain level &rest key-args &key &allow-other-keys) ¶

Package: fl.mesh.
Source: meshgen.lisp.

Function: uniformly-refined-mesh (domain n &key parametric) ¶

Generates a mesh by refining the domain partition uniformly.

Package: fl.mesh.
Source: meshgen.lisp.

Function: unit-vector (dim i) ¶

Returns a freshly created copy of the @arg{i}-th carthesian unit vector in dimension @arg{dim}.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: unit-vector-force-coefficient (direction) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Function: unix-chdir (path) ¶

Change the directory to @arg{path}.

Package: fl.port.
Source: port.lisp.

Function: user-input (prompt &optional converter test-p) ¶

User input for demo functions. Reads lines until @arg{test-p} returns t on the item read.

Package: fl.demo.
Source: demo.lisp.

Function: user-input-textfield (&optional test-p) ¶

User textfield input for demo functions. Reads and concatenates lines until an empty line is read.

Package: fl.demo.
Source: demo.lisp.

Function: vector-cut (vec comp) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: vector-last (vec) ¶

Reader for the last element of @arg{vec}.

Package: fl.utilities.
Source: utilities.lisp.

Function: (setf vector-last) (vec) ¶

Writer for the last element of @arg{vec}.

Package: fl.utilities.
Source: utilities.lisp.

Function: vector-map (func &rest vecs) ¶

Map @arg{vec} with @arg{func} to a vector of the same type.

Package: fl.utilities.
Source: utilities.lisp.

Function: vector-of (etype) ¶

Flexible uniform vector type definition.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: vector-sap (ptr) ¶

Returns an array pointer which can be used in a foreign call.

Package: fl.port.
Source: port.lisp.

Function: vertex-p (cell) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: vertex? (cell) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: watch-velocity-and-pressure-at-point (point &key velocity-p pressure-p) ¶

Returns a observe list for watching the velocity at @arg{point}.

Package: fl.flow-application.
Source: driven-cavity.lisp.

Function: watch-velocity-at-point (point) ¶

Returns a observe list for watching the velocity at @arg{point}.

Package: fl.flow-application.
Source: driven-cavity.lisp.

Function: weak-pointer-value (wp) ¶

Returns the value of the weak pointer @arg{wp}.

Package: fl.port.
Source: port.lisp.

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.

Package: fl.discretization.
Source: quadrature.lisp.

Function: worker-count () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: worker-index () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: workers-available-p () ¶

Test if parallel sparse algebra is possible in the current context. Note that at the moment, we do not allow nested parallelization.

Package: fl.parallel.
Source: parallel.lisp.

Function: x<-0 (x) ¶

X <- 0 X. Uses SCAL!.

Package: fl.matlisp.
Source: vector.lisp.

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.

Package: fl.function.
Source: function.lisp.

Function: xor (a b) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: zero-vector (dim element-type) ¶

Returns a uniform vector for the given element type filled with zeros.

Package: fl.utilities.
Source: utilities.lisp.

Function: zeros (n &optional m type) ¶

Returns nxn or (if m is provided) nxm zeros. The value is freshly allocated.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Next: Standalone methods, Previous: Ordinary functions, Up: Public Interface [Contents][Index]

6.1.5 Generic functions

Generic Function: access-type (mat &key suggest require) ¶

If @arg{suggest} and @arg{require} are NIL, returns which of
@symbol{:row} or @symbol{:column} is prefered for @arg{mat}. Otherwise determine if the order in @arg{suggest} or @arg{require} is acceptable without serious performance hit.

Package

Source

Methods

Method: access-type ((csm <sparse-dictionary-matrix>) &key suggest require) ¶

Method: access-type (mat &key suggest require) ¶: The default selects the required or suggested access method if they are available.

Generic Function: add-svec-to-local-block (svec local-vec &optional keys ranges) ¶

Copies a local block in matlisp format into a <ht-sparse-vector>.

Package

Source

Methods

Method: add-svec-to-local-block ((svec <sparse-vector>) local-vec &optional keys ranges) ¶

Generic Reader: ansatz-space (object) ¶

Package

Methods

Reader Method: ansatz-space ((<ansatz-space-object> <ansatz-space-object>)) ¶

automatically generated reader method

Source: ansatz-space.lisp.
Target Slot: ansatz-space.

Generic Reader: arity (object) ¶

Package

Methods

Reader Method: arity ((relation relation)) ¶

automatically generated reader method

Source: relations.lisp.
Target Slot: arity.

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.

Package

Source

fedisc.lisp.

Methods

Method: assemble-interior ((as <ansatz-space>) (where symbol) &rest args &key level parallel-clustering &allow-other-keys) ¶

Method: assemble-interior ((as <ansatz-space>) (where list) &key matrix mass-matrix rhs parallel-clustering &allow-other-keys) ¶

Generic Reader: assembly-type (object) ¶

Package

Methods

Reader Method: assembly-type ((<coefficient> <coefficient>)) ¶

A list of two symbols. If :matrix is a member, it
means evaluation that the coefficient contributes to the Jacobian, if :residual is a member, it contributes to assembling the residual. As noted in the documentation of @var{*assembly-type*}, this functionality is not yet used.

Source: pde-problem.lisp.
Target Slot: assembly-type.

Generic Function: axpy (alpha x y) ¶

Returns alpha X + Y. Uses AXPY! and COPY.

Package

Source

Methods

Method: axpy ((alpha number) (x number) (y number)) ¶

Source: vector-methods.lisp.

Method: axpy (alpha x y) ¶

Source: vector-methods.lisp.

Generic Function: axpy! (alpha x y) ¶

Y <- alpha*X + Y

Package

Source

Methods

Method: axpy! (alpha (x polynomial) (y polynomial)) ¶

Source: polynom.lisp.

Method: axpy! ((alpha number) (x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: axpy! ((alpha number) (x vector) (y vector)) ¶

Source: array-blas.lisp.

Method: axpy! (alpha (x number) (y number)) ¶

Source: number-blas.lisp.

Method: axpy! ((alpha number) (x static-store-vector) (y static-store-vector)) ¶

Source: store-vector.lisp.

Method: axpy! (alpha x y) ¶

Recursive definition for AXPY! usable for sparse block vectors which return nil if no entry is set.

Source: vector-methods.lisp.

Generic Reader: base-level (object) ¶

Package

Methods

Reader Method: base-level ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: base-level.

Generic Reader: blocks (vec) ¶

Returns a dictionary mapping keys to entries for @arg{vec}.

Package

Source

Methods

Reader Method: blocks ((<ht-sparse-vector> <ht-sparse-vector>)) ¶

Table of blocks.

Target Slot: blocks.

Generic Function: boundary (object) ¶

Returns the boundary of an object (usually a cell in a mesh).

Package

Source

Methods

Method: boundary ((vtx <vertex>)) ¶

Returns the empty boundary for vertices.

Source: vertex.lisp.

Reader Method: boundary ((<standard-cell> <standard-cell>)) ¶

A vector of boundary cells.

Target Slot: boundary.

Reader Method: boundary ((<cell-with-boundary> <cell-with-boundary>)) ¶

A vector of boundary cells.

Target Slot: boundary.

Generic Function: cartesian-product (obj1 obj2 &key property-combiner &allow-other-keys) ¶

Computes the cartesian product of two skeletons.

Package

Source

Methods

Method: cartesian-product ((skel1 <skeleton>) (skel2 <skeleton>) &key property-combiner &allow-other-keys) ¶: Computes the cartesian product of two skeletons.

Method: cartesian-product ((cell1 <cell>) (cell2 <cell>) &key &allow-other-keys) ¶

Generic Function: cell-integrate (cell object &key initial-value combiner key coeff-func component no-weights-p quadrature-order &allow-other-keys) ¶

Integrates @arg{object} on @arg{cell}.

Package

Source

Methods

Method: cell-integrate (cell (x <ansatz-space-vector>) &key initial-value combiner key coeff-func component no-weights-p) ¶: 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: cell-integrate (cell (func function) &key initial-value combiner quadrature-order) ¶: Integrates @arg{func} over @arg{cell}.

Generic Function: cell-mapping (cell) ¶

Return the mapping for mapped cells.

Package

Source

Methods

Method: cell-mapping ((cell <simplex>)) ¶

For non-mapped simplices, the cell mapping is linear.

Source: simplex.lisp.

Method: cell-mapping ((vtx <vertex>)) ¶

For vertices, this returns a <special-function> evaluating to the vertex position.

Source: vertex.lisp.

Method: cell-mapping (cell) ¶: The default result is NIL, i.e. no mapping

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 <mapped-cell>)) ¶: Return the mapping of the mapped @arg{cell}.

Generic Reader: cg-max-size (object) ¶

Package

Methods

Reader Method: cg-max-size ((<algebraic-mg> <algebraic-mg>)) ¶

automatically generated reader method

Source: amg.lisp.
Target Slot: cg-max-size.

Generic Function: choose-start-vector (ansatz-space) ¶

Choose a reasonable start vector for some strategy.

Package

Source

Methods

Method: choose-start-vector (as) ¶: The default method chooses a random guess for eigenvalue problems and 0 otherwise.

Generic Reader: coarse-grid-iteration (object) ¶

Package

Methods

Reader Method: coarse-grid-iteration ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: coarse-grid-iteration.

Generic Function: coarse-grid-matrix (amg mat prolongation restriction) ¶

Computes a coarse-grid matrix from amg, mat, prolongation and restriction.

Package

Source

Methods

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.

Generic Function: coarsen (amg mat) ¶

Given AMG and matrix, this generic function returns
coarse-grid matrix, interpolation and restriction matrices for one coarsening step.

Package

Source

Methods

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.

Generic Reader: coefficient-name (object) ¶

Package

Methods

Reader Method: coefficient-name ((<coefficient> <coefficient>)) ¶

automatically generated reader method

Source: pde-problem.lisp.
Target Slot: name.

Generic Reader: coefficients (object) ¶

Package

Methods

Reader Method: coefficients ((<domain-problem> <domain-problem>)) ¶

A -usually memoized- function mapping patches to coefficient lists.

Source: pde-problem.lisp.
Target Slot: coefficients.

Reader Method: coefficients ((polynomial polynomial)) ¶

automatically generated reader method

Source: polynom.lisp.
Target Slot: coeffs.

Generic Function: coefficients-of-cell (cell mesh problem) ¶

Returns the coefficients of @arg{problem} on @arg{cell}.

Package

Source

Methods

Method: coefficients-of-cell (cell mesh problem) ¶: Default method, returns the coefficients of the associated patch.

Generic Function: col-key->size (smat) ¶

Package

Source

Methods

Method: col-key->size ((asm <ansatz-space-morphism>)) ¶

Source: sparseas.lisp.

Reader Method: col-key->size ((<block-definition-mixin> <block-definition-mixin>)) ¶

automatically generated reader method

Target Slot: col-key->size.

Method: col-key->size ((smat <sparse-matrix>)) ¶

Generic Function: col-keys (mat) ¶

All column keys for a matrix.

Package

Source

Methods

Method: col-keys ((mat <sparse-dictionary-matrix>)) ¶

Source: sparse-matrix.lisp.

Reader Method: col-keys ((<submatrix> <submatrix>)) ¶

The column indices of the submatrix.

Target Slot: col-keys.

Method: col-keys ((mat <matrix>)) ¶

Generic Reader: column-table (object) ¶

Generic Writer: (setf column-table) (object) ¶

Package

Methods

Reader Method: column-table ((<ht-sparse-matrix> <ht-sparse-matrix>)) ¶

Writer Method: (setf column-table) ((<ht-sparse-matrix> <ht-sparse-matrix>)) ¶

Table of columns

Source: sparse-matrix.lisp.
Target Slot: column-table.

Reader Method: column-table ((<sparse-dictionary-matrix> <sparse-dictionary-matrix>)) ¶

Writer Method: (setf column-table) ((<sparse-dictionary-matrix> <sparse-dictionary-matrix>)) ¶

Table of column dictionaries.

Source: sparse-matrix.lisp.
Target Slot: column-table.

Generic Function: component (fe comp) ¶

Returns the @arg{comp}-th component of the (vector) finite element @arg{fe}.

Package

Source

Methods

Method: component ((fedisc <vector-fe-discretization>) i) ¶

Source: ansatz-space.lisp.

Method: component ((vecfe <vector-fe>) comp) ¶

Generic Function: components (object) ¶

Package

Methods

Reader Method: components ((<vector-fe-discretization> <vector-fe-discretization>)) ¶

Either a vector of components or
the symbol :variable, if the components vary across the domain as is the case for hp-FEM.

Source: ansatz-space.lisp.
Target Slot: components.

Reader Method: components ((<vector-fe> <vector-fe>)) ¶

automatically generated reader method

Source: fe.lisp.
Target Slot: components.

Method: components ((fe <scalar-fe>)) ¶

The vector of components (which are scalar finite elements) of a vector finite element.

Source: fe.lisp.

Reader Method: components ((<domain-problem> <domain-problem>)) ¶

A list whose elements are symbols or lists
of the forms (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.

Source: pde-problem.lisp.
Target Slot: components.

Generic Writer: (setf components) (object) ¶

Package

Methods

Writer Method: (setf components) ((<vector-fe> <vector-fe>)) ¶

automatically generated writer method

Source: fe.lisp.
Target Slot: components.

Generic Function: components-of-cell (cell mesh problem) ¶

Returns the components of @arg{problem} on @arg{cell}.

Package

Source

Methods

Method: components-of-cell (cell mesh problem) ¶

Generic Function: components-of-patch (patch problem) ¶

Reader for the components of @arg{problem} on @arg{patch}.

Package

Source

Methods

Method: components-of-patch (patch problem) ¶

Generic Function: (setf components-of-patch) (patch problem) ¶

Writer for the components of @arg{problem} on @arg{patch}.

Package

Source

Methods

Method: (setf components-of-patch) (patch problem) ¶

Generic Function: compose-2 (f g) ¶

Composes two function objects @arg{f} and @arg{g}.

Package

Source

Methods

Method: compose-2 ((func1 <function>) (func2 <linear-function>)) ¶

Source: function.lisp.

Method: compose-2 ((func1 <linear-function>) (func2 <function>)) ¶

Source: function.lisp.

Method: compose-2 ((func1 <function>) (func2 <function>)) ¶

Source: function.lisp.

Method: compose-2 (f g) ¶

Generic Function: compressed->matlisp (cm) ¶

Converts a compressed matrix into matlisp format.

Package

Source

Methods

Method: compressed->matlisp ((cm compressed-matrix)) ¶

Generic Function: compute-residual (a x b r) ¶

Compute the residual r=b-Ax.

Package

Source

Methods

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.

Generic Function: copy (x) ¶

Returns a deep copy of X.

Package

Source

Methods

Method: copy ((poly polynomial)) ¶

Source: polynom.lisp.

Method: copy ((a compressed-matrix)) ¶

Source: compressed.lisp.

Method: copy ((tensor full-tensor)) ¶

Source: tensor.lisp.

Method: copy ((array array)) ¶

Source: array-blas.lisp.

Method: copy ((vec list)) ¶

Source: array-blas.lisp.

Method: copy ((vec vector)) ¶

Source: array-blas.lisp.

Method: copy ((x number)) ¶

Source: number-blas.lisp.

Method: copy (x) ¶

This default method for @function{copy} does a destructive copy to an empty analog of @arg{x}.

Source: vector-methods.lisp.

Generic Function: copy! (x y) ¶

Y <- X

Package

Source

Methods

Method: copy! ((x <sparse-vector>) (y <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: copy! ((a full-tensor) (b full-tensor)) ¶

Source: tensor.lisp.

Method: copy! ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: copy! ((x vector) (y vector)) ¶

Source: array-blas.lisp.

Method: copy! ((x number) (y number)) ¶

Number copying.

Source: number-blas.lisp.

Method: copy! ((x static-store-vector) (y static-store-vector)) ¶

Source: store-vector.lisp.

Method: copy! (x y) ¶

Recursive definition for COPY! usable for sparse block vectors.

Source: vector-methods.lisp.

Generic Function: copy-slots (obj1 obj2 slots) ¶

Initializes the slots named in @arg{slots} from @arg{obj2} to @arg{obj1}. Returns @arg{obj1}.

Package

Source

Methods

Method: copy-slots (obj1 obj2 slots) ¶

Method: copy-slots (obj1 (obj2 list) slots) ¶: Copies slots from a templating property list in @arg{obj2} to @arg{obj1}. Returns @arg{obj1}.

Generic Function: corners (cell) ¶

Returns a list of corners of the cell, i.e. the global positions of the cell’s vertices.

Package

Source

Methods

Method: corners (cell) ¶: Default method.

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}.

Package

fl.debug.

Source

debug.lisp.

Methods

Method: dbg :around (id format-string &rest args) ¶

Serializing of debug output.

Source: multiprocessing.lisp.

Method: dbg (id format-string &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}.

Package

fl.debug.

Source

debug.lisp.

Methods

Method: dbg-indent (id indent format-string &rest args) ¶

Generic Function: degree (poly) ¶

Degree of a polynomial

Package

Source

Methods

Method: degree ((poly polynomial)) ¶

Generic Function: demands (object) ¶

Package

Methods

Method: demands ((coeffs list)) ¶

Returns unified demands for all coefficients in the list.

Source: pde-problem.lisp.

Reader Method: demands ((<coefficient> <coefficient>)) ¶

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.

Source: pde-problem.lisp.
Target Slot: demands.

Generic Function: dequeue (queue) ¶

Pops an object from @arg{queue}. Returns as second value T if the queue was empty.

Package

Source

Methods

Method: dequeue :after ((cq chunk-queue)) ¶

Source: sparseif.lisp.

Method: dequeue :around ((pq parqueue)) ¶

Source: multiprocessing.lisp.

Method: dequeue ((queue queue)) ¶

Generic Function: dequeue-all (queue) ¶

Clears @arg{queue} and returns content as a list.

Package

Source

Methods

Method: dequeue-all ((queue queue)) ¶

Generic Function: det (mat) ¶

Returns the determinant of the square matrix @arg{mat}.

Package

Source

Methods

Method: det ((mat number)) ¶

Source: compat.lisp.

Method: det ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Generic Function: diagonal (a) ¶

Extracts the diagonal from matrix @arg{A} as a vector.

Package

Source

Methods

Method: diagonal ((a standard-matrix)) ¶

Source: standard-matrix.lisp.

Generic Function: diameter (cell) ¶

Returns the diameter of a cell.

Package

Source

Methods

Method: diameter (cell) ¶: The default method maximizes the distance between the cell’s corners.

Generic Function: dic-count (dic) ¶

Count the entries of @arg{dic}.

Package

Source

Methods

Method: dic-count (dic) ¶

Generic Function: dic-empty-p (dictionary) ¶

Tests if @arg{dictionary} is empty.

Package

Source

Methods

Method: dic-empty-p ((dic sorted-hash-table)) ¶

Method: dic-empty-p (dic) ¶

Method: dic-empty-p ((list list)) ¶

Method: dic-empty-p ((dic hash-table)) ¶

Generic Function: dic-for-each (function dictionary &key direction parallel &allow-other-keys) ¶

Applies @arg{function} to each key-value pair in @arg{dictionary}.

Package

Source

Methods

Method: dic-for-each (func (dic thread-cached-dictionary) &key &allow-other-keys) ¶

Method: dic-for-each (func (dic computed-value-dictionary) &key &allow-other-keys) ¶

Method: dic-for-each (func (dic sorted-hash-table) &key direction &allow-other-keys) ¶

Method: dic-for-each (func (dic small-cache-dictionary) &rest args) ¶

Method: dic-for-each :around (function dictionary &key parallel &allow-other-keys) ¶

Method: dic-for-each (func (dic list) &key &allow-other-keys) ¶

Method: dic-for-each (func (dic hash-table) &key &allow-other-keys) ¶

Method: dic-for-each (func (vec vector) &key &allow-other-keys) ¶

Generic Function: dic-for-each-key (function dictionary &key &allow-other-keys) ¶

Applies @arg{function} to each key in @arg{dictionary}.

Package

Source

Methods

Method: dic-for-each-key (func (dic computed-value-dictionary) &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}.

Package

Source

Methods

Method: dic-for-each-value (func dic &rest args) ¶

Generic Function: dic-pop (sorted-dic) ¶

A pop routine for sorted dictionaries or heaps.

Package

Source

Methods

Method: dic-pop ((dic sorted-hash-table)) ¶

Generic Function: dic-ref (dictionary key) ¶

Returns the value of the entry for @arg{key} in @arg{dictionary}.

Package

Source

Methods

Method: dic-ref ((dic thread-cached-dictionary) key) ¶

Method: dic-ref ((tree-dic tree-dictionary) key) ¶

Method: dic-ref ((dic computed-value-dictionary) key) ¶

Method: dic-ref ((dic cache-dictionary) key) ¶

Method: dic-ref ((dic sorted-hash-table) key) ¶

Method: dic-ref ((dic small-cache-dictionary) key) ¶

Method: dic-ref ((table list) key) ¶

Method: dic-ref ((table hash-table) key) ¶

Method: dic-ref ((vec vector) index) ¶

Method: dic-ref ((func function) key) ¶

Generic Function: (setf dic-ref) (dictionary key) ¶

Sets the entry @arg{key} in @arg{dictionary} to @arg{value}.

Package

Source

Methods

Method: (setf dic-ref) ((dic thread-cached-dictionary) key) ¶

Method: (setf dic-ref) ((tree-dic tree-dictionary) key) ¶

Method: (setf dic-ref) ((dic cache-dictionary) key) ¶

Method: (setf dic-ref) ((dic sorted-hash-table) key) ¶

Method: (setf dic-ref) ((dic small-cache-dictionary) key) ¶

Method: (setf dic-ref) ((table hash-table) key) ¶

Method: (setf dic-ref) ((vec vector) index) ¶

Generic Function: dic-remove (key dictionary) ¶

Removes @arg{key} from @arg{dictionary}.

Package

Source

Methods

Method: dic-remove (key (dic sorted-hash-table)) ¶

Method: dic-remove (key (dic hash-table)) ¶

Generic Function: differentiable-p (f &optional k) ¶

Returns t if f is differentiable or differentiable of the given degree.

Package

Source

Methods

Method: differentiable-p ((f <polygon>) &optional k) ¶

Source: spline.lisp.

Method: differentiable-p ((f <linearly-transformed-function>) &optional k) ¶

Method: differentiable-p ((f <linear-function>) &optional k) ¶

Method: differentiable-p ((f <constant-function>) &optional k) ¶

Method: differentiable-p ((f <special-function>) &optional k) ¶

Method: differentiable-p (f &optional k) ¶: The default method returns @code{NIL}.

Generic Function: differentiate (poly index) ¶

Differentiate a multivariate polynomial wrt the variable given by INDEX.

Package

Source

Methods

Method: differentiate ((list list) index) ¶

Method: differentiate ((poly number) index) ¶

Method: differentiate ((poly polynomial) index) ¶

Generic Function: dimension (cell) ¶

Returns the dimension of the cell.

Package

Source

Methods

Reader Method: dimension ((<coefficient> <coefficient>)) ¶

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.

Source: pde-problem.lisp.
Target Slot: dimension.

Reader Method: dimension ((<boundary-cell> <boundary-cell>)) ¶

automatically generated reader method

Source: triangulate.lisp.
Target Slot: dimension.

Reader Method: dimension ((<skeleton> <skeleton>)) ¶

automatically generated reader method

Source: skeleton.lisp.
Target Slot: dimension.

Method: dimension ((cell <cell>)) ¶

Generic Writer: (setf dimension) (object) ¶

Package

Methods

Writer Method: (setf dimension) ((<skeleton> <skeleton>)) ¶

automatically generated writer method

Source: skeleton.lisp.
Target Slot: dimension.

Generic Function: dimension-of-part (skel part) ¶

Parts of a skeleton can be named with the property @symbol{:part}.

Package

Source

Methods

Method: dimension-of-part ((mesh <mesh>) part) ¶

Parts of a skeleton can be named with the property @symbol{:part}.

Source: mesh.lisp.

Method: dimension-of-part ((skel <skeleton>) part) ¶

Generic Reader: dimensions (object) ¶

Package

Methods

Reader Method: dimensions ((full-tensor full-tensor)) ¶

The dimensions of the tensor.

Source: tensor.lisp.
Target Slot: dimensions.

Generic Function: discretization-order (disc) ¶

Returns the order of the discretization.

Package

Source

discretization.lisp.

Methods

Method: discretization-order ((as <ansatz-space>)) ¶

Source: ansatz-space.lisp.

Method: discretization-order ((vecfe-disc <vector-fe-discretization>)) ¶

Source: ansatz-space.lisp.

Reader Method: discretization-order ((<scalar-fe-discretization> <scalar-fe-discretization>)) ¶

automatically generated reader method

Source: ansatz-space.lisp.
Target Slot: order.

Method: discretization-order ((vecfe <vector-fe>)) ¶

Source: fe.lisp.

Reader Method: discretization-order ((<scalar-fe> <scalar-fe>)) ¶

automatically generated reader method

Source: fe.lisp.
Target Slot: order.

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}.

Package

Source

discretization.lisp.

Methods

Method: discretize ((fedisc <fe-discretization>) (problem <pde-problem>) blackboard) ¶

General discretization interface for FE.

Source: fedisc.lisp.

Generic Function: discretize-locally (problem coeffs fe qrule fe-geometry &key matrix mass-matrix rhs local-u local-v fe-parameters residual-p &allow-other-keys) ¶

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.

Package

Source

fedisc.lisp.

Methods

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}.

Source: ellsys-fe.lisp.

Generic Function: display (matrix &key row-order col-order order pattern stream &allow-other-keys) ¶

Formats the contents of @arg{matrix} in rectangular form.

Package

Source

Methods

Method: display ((smat <sparse-matrix>) &key row-order col-order order pattern stream) ¶

Display a sparse matrix. With pattern=NIL (the default), the matrix is displayed in detail. With pattern=:block, the block graph structure is displayed.

Source: sparse-matrix.lisp.

Method: display ((matrix standard-matrix) &key stream &allow-other-keys) ¶

Source: standard-matrix.lisp.

Method: display (matrix &key stream &allow-other-keys) ¶: The default method describes its argument.

Generic Reader: dll-first (object) ¶

Package

Methods

Reader Method: dll-first ((dll dll)) ¶

automatically generated reader method

Source: utilities.lisp.
Target Slot: first.

Generic Writer: (setf dll-first) (object) ¶

Package

Methods

Writer Method: (setf dll-first) ((dll dll)) ¶

automatically generated writer method

Source: utilities.lisp.
Target Slot: first.

Generic Reader: dll-last (object) ¶

Package

Methods

Reader Method: dll-last ((dll dll)) ¶

automatically generated reader method

Source: utilities.lisp.
Target Slot: last.

Generic Writer: (setf dll-last) (object) ¶

Package

Methods

Writer Method: (setf dll-last) ((dll dll)) ¶

automatically generated writer method

Source: utilities.lisp.
Target Slot: last.

Generic Reader: dof-component (object) ¶

Package

Methods

Reader Method: dof-component ((vector-dof vector-dof)) ¶

The component in the solution vector to which this @class{dof} belongs.

Source: fe.lisp.
Target Slot: component.

Generic Reader: dof-coord (object) ¶

Package

Methods

Reader Method: dof-coord ((dof dof)) ¶

Local coordinate of the dof in the reference subcell

Source: fe.lisp.
Target Slot: coord.

Generic Reader: dof-functional (object) ¶

Package

Methods

Reader Method: dof-functional ((dof dof)) ¶

A functional for functions defined on the reference cell

Source: fe.lisp.
Target Slot: functional.

Generic Reader: dof-gcoord (object) ¶

Package

Methods

Reader Method: dof-gcoord ((dof dof)) ¶

Global coordinate of the dof on the reference
cell. This is a vector in a standard floating point precision which is sufficient for function evaluation, but not sufficient for calculating stiffness matrix entries.

Source: fe.lisp.
Target Slot: gcoord.

Generic Reader: dof-in-vblock-index (object) ¶

Package

Methods

Reader Method: dof-in-vblock-index ((dof dof)) ¶

Index of the dof in the subcell vblock

Source: fe.lisp.
Target Slot: in-vblock-index.

Generic Reader: dof-index (object) ¶

Package

Methods

Reader Method: dof-index ((dof dof)) ¶

Index of the dof in the cell-dof array

Source: fe.lisp.
Target Slot: index.

Generic Reader: dof-subcell-index (object) ¶

Package

Methods

Reader Method: dof-subcell-index ((dof dof)) ¶

Index of the reference subcell on which the dof is defined

Source: fe.lisp.
Target Slot: subcell-index.

Generic Reader: domain (object) ¶

Package

Methods

Reader Method: domain ((<domain-problem> <domain-problem>)) ¶

automatically generated reader method

Source: pde-problem.lisp.
Target Slot: domain.

Reader Method: domain ((<mesh> <mesh>)) ¶

The domain of the mesh.

Source: mesh.lisp.
Target Slot: domain.

Generic Function: domain-ansatz-space (asm) ¶

Package

Source

Methods

Method: domain-ansatz-space ((asa <ansatz-space-automorphism>)) ¶

Reader Method: domain-ansatz-space ((<domain-image-mixin> <domain-image-mixin>)) ¶

automatically generated reader method

Target Slot: domain-ansatz-space.

Generic Function: domain-dimension (object) ¶

Package

Methods

Method: domain-dimension ((problem <domain-problem>)) ¶

Source: pde-problem.lisp.

Reader Method: domain-dimension ((<function> <function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: domain-dimension.

Generic Function: dot (x y) ¶

Returns the dot product of X and Y.

Package

Source

Methods

Method: dot ((x <sparse-vector>) (y <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: dot ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: dot ((x number) (y number)) ¶

Source: number-blas.lisp.

Method: dot ((x static-store-vector) (y static-store-vector)) ¶

Source: store-vector.lisp.

Method: dot (x y) ¶

Source: vector-methods.lisp.

Method: dot ((x vector) (y vector)) ¶

Source: vector-methods.lisp.

Method: dot ((x list) (y list)) ¶

Source: vector-methods.lisp.

Generic Function: dot-abs (x y) ¶

Returns the dot product between |X| and |Y|.

Package

Source

Methods

Method: dot-abs ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: dot-abs ((x number) (y number)) ¶

Source: number-blas.lisp.

Method: dot-abs ((x static-store-vector) (y static-store-vector)) ¶

Source: store-vector.lisp.

Method: dot-abs (x y) ¶

Source: vector-methods.lisp.

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.

Package

Source

Methods

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.

Source: cdr.lisp.

Generic Function: element-type (vector) ¶

Type of the elements of the vector/matrix.

Package

Source

Methods

Method: element-type ((smat <sparse-matrix>)) ¶

Source: sparse-matrix.lisp.

Method: element-type ((svec <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: element-type ((vector (store-vector⎵double-float⎵dynamic⎵nil))) ¶

Method: element-type ((x vector)) ¶

Source: array-blas.lisp.

Method: element-type (vec) ¶

Default method returns T.

Source: vector-methods.lisp.

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.

Package

Source

Methods

Method: embedded-dimension ((skel <skeleton>)) ¶

Source: skeleton.lisp.

Method: embedded-dimension ((cell <cell>)) ¶: Recursive definition, anchored at the definition for vertices.

Method: embedded-dimension ((vtx <vertex>)) ¶: Anchor for recursive definition.

Generic Function: emptyp (queue) ¶

Tests if @arg{queue} is empty.

Package

Source

Methods

Method: emptyp ((list list)) ¶

Method: emptyp ((ht hash-table)) ¶

Method: emptyp ((queue queue)) ¶

Generic Reader: end-time (object) ¶

Package

Methods

Reader Method: end-time ((<time-dependent-problem> <time-dependent-problem>)) ¶

The end time of the problem (NIL=unspecified).

Source: time.lisp.
Target Slot: end-time.

Generic Function: energy (evp x) ¶

Evaluates the energy bilinear form for a generalized eigenvalue problem.

Package

Source

Methods

Method: energy ((evp <evp>) x) ¶

Generic Function: enqueue (object queue) ¶

Puts @arg{object} into the @arg{queue}.

Package

Source

Methods

Method: enqueue :around (obj (pq parqueue)) ¶

Source: multiprocessing.lisp.

Method: enqueue (object (queue queue)) ¶

Generic Function: ensure-matlisp (obj &optional type) ¶

Tries to coerce @arg{obj} into Matlisp format.

Package

Source

Methods

Method: ensure-matlisp ((cm compressed-matrix) &optional type) ¶

Source: compressed.lisp.

Method: ensure-matlisp ((tensor <sparse-tensor>) &optional type) ¶

Source: sparse-tensor.lisp.

Method: ensure-matlisp ((obj standard-matrix) &optional type) ¶

Method: ensure-matlisp ((obj number) &optional type) ¶

Method: ensure-matlisp ((obj vector) &optional type) ¶

Method: ensure-matlisp ((obj list) &optional type) ¶

Generic Function: ensure-residual (problem blackboard) ¶

Ensures that the field :RESIDUAL is computed and that the flag :RESIDUAL-P is set on the blackboard.

Package

Source

Methods

Method: ensure-residual ((lse <lse>) 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.

Generic Function: ensure-solution (problem blackboard) ¶

Ensures that the field :SOLUTION is set on the blackboard.

Package

Source

Methods

Method: ensure-solution ((nlpb <nonlinear-problem>) blackboard) ¶

Method: ensure-solution ((lse <lse>) blackboard) ¶

Method: ensure-solution :around (problem blackboard) ¶: This :around method takes the field :SOLUTION from the blackboard.

Method: ensure-solution (problem blackboard) ¶: Default method throws an error.

Generic Function: entries (object) ¶

List of entries.

Package

Source

Methods

Reader Method: entries ((<sparse-tensor> <sparse-tensor>)) ¶

The (nonzero) entries of the first slot.

Source: sparse-tensor.lisp.
Target Slot: entries.

Method: entries ((vec <vector>)) ¶

Source: vector-methods.lisp.

Method: entries ((arr array)) ¶

Source: vector-methods.lisp.

Method: entries (vec) ¶

Default method

Source: vector-methods.lisp.

Generic Writer: (setf entries) (object) ¶

Package

Methods

Writer Method: (setf entries) ((<sparse-tensor> <sparse-tensor>)) ¶

The (nonzero) entries of the first slot.

Source: sparse-tensor.lisp.
Target Slot: entries.

Generic Function: entry-allowed-p (tensor &rest indices) ¶

Tests if an entry is allowed at this position.

Package

Source

Methods

Method: entry-allowed-p ((smat <sparse-matrix>) &rest indices) ¶

Source: sparse-matrix.lisp.

Method: entry-allowed-p ((svec <sparse-vector>) &rest indices) ¶

Source: sparse-vector.lisp.

Method: entry-allowed-p (tensor &rest indices) ¶: The default method allows entries everywhere.

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.

Package

Source

constraints.lisp.

Methods

Method: essential-boundary-constraints (problem (ansatz-space <ansatz-space>) &key level where interface) ¶

Source: system-fe.lisp.

Generic Function: estimate (error-estimator blackboard) ¶

Yields both local and global estimate.

Package

Source

Methods

Method: estimate ((errest <error-estimator>) blackboard) ¶: Executes local and global error estimation in sequence.

Generic Function: etable (skel dim) ¶

A table for cells of dimension @arg{dim} in @arg{skel}.

Package

Source

Methods

Method: etable ((skel <skeleton>) dim) ¶

Generic Reader: etables (object) ¶

Package

Methods

Reader Method: etables ((<skeleton> <skeleton>)) ¶

automatically generated reader method

Source: skeleton.lisp.
Target Slot: etables.

Generic Writer: (setf etables) (object) ¶

Package

Methods

Writer Method: (setf etables) ((<skeleton> <skeleton>)) ¶

automatically generated writer method

Source: skeleton.lisp.
Target Slot: etables.

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.

Package

Source

Methods

Method: evaluate ((dof dof) fe-func) ¶

Source: fe.lisp.

Method: evaluate ((coeff <coefficient>) (input list)) ¶

The pairing between coefficient and input.

Source: pde-problem.lisp.

Method: evaluate ((polygon <polygon>) s) ¶

Source: spline.lisp.

Method: evaluate ((poly polynomial) (x vector)) ¶

Source: polynom.lisp.

Method: evaluate ((poly polynomial) (x list)) ¶

Source: polynom.lisp.

Method: evaluate ((poly polynomial) (x number)) ¶

Source: polynom.lisp.

Method: evaluate ((func <linearly-transformed-function>) pos) ¶

Source: function.lisp.

Method: evaluate ((f <linear-function>) x) ¶

Source: function.lisp.

Method: evaluate ((f <constant-function>) x) ¶

Source: function.lisp.

Method: evaluate ((f <special-function>) x) ¶

Source: function.lisp.

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 ((f function) x) ¶: Lisp functions are evaluated by @function{funcall}.

Generic Function: evaluate-gradient (f x) ¶

Generic evaluation of gradients of differentiable functions.

Package

Source

Methods

Method: evaluate-gradient ((polygon <polygon>) s) ¶

Source: spline.lisp.

Method: evaluate-gradient ((poly polynomial) (x vector)) ¶

Source: polynom.lisp.

Method: evaluate-gradient ((func <linearly-transformed-function>) pos) ¶

Method: evaluate-gradient ((f <linear-function>) x) ¶

Method: evaluate-gradient ((f <constant-function>) x) ¶

Method: evaluate-gradient ((f <special-function>) x) ¶

Generic Function: extended-extract (mat keys &key row? col?) ¶

Extract a sub-matrix from a sparse matrix for the given keys.

Package

Source

Methods

Method: extended-extract ((asa <ansatz-space-automorphism>) (skel <skeleton>) &key row? col?) ¶: Extracts a sub-matrix from a sparse matrix. This routine could be accelerated by taking member-checks out of the loop.

Generic Function: extract-if (test svec &key &allow-other-keys) ¶

Extract a subvector or submatrix from a sparse vector/matrix. The test is a function of entry and key.

Package

Source

Methods

Method: extract-if ((test function) (smat <sparse-matrix>) &key &allow-other-keys) ¶

Extracts a sub-matrix from a sparse matrix.

Source: sparse-matrix.lisp.

Method: extract-if ((test function) (svec <vector>) &key &allow-other-keys) ¶: Default method on vectors.

Generic Function: extract-value-blocks (sobj keys &optional col-keys) ¶

Extract a vector or array of value blocks from @arg{sobj}.

Package

Source

Methods

Method: extract-value-blocks ((smat <sparse-matrix>) row-keys &optional col-keys) ¶

Source: sparse-matrix.lisp.

Method: extract-value-blocks ((svec <sparse-vector>) keys &optional col-keys) ¶

Generic Function: factors (poly) ¶

The factors if the multivariate polynomial @arg{poly} is
an exterior product of lower-variate (e.g. univariate) polynomials.

Package

Source

Methods

Reader Method: factors ((polynomial polynomial)) ¶

automatically generated reader method

Target Slot: factors.

Method: factors ((poly number)) ¶

Generic Reader: fe-basis (object) ¶

Package

Methods

Reader Method: fe-basis ((<vector-fe> <vector-fe>)) ¶

automatically generated reader method

Source: fe.lisp.
Target Slot: basis.

Reader Method: fe-basis ((<scalar-fe> <scalar-fe>)) ¶

The fe’s basis functions.

Source: fe.lisp.
Target Slot: basis.

Generic Function: fe-class (object) ¶

Package

Methods

Reader Method: fe-class ((<fe-approximation> <fe-approximation>)) ¶

The class of finite element. If it is not set, it is automatically chosen.

Source: fe-approximation.lisp.
Target Slot: fe-class.

Method: fe-class ((aso <ansatz-space-object>)) ¶

Source: ansatz-space.lisp.

Reader Method: fe-class ((<ansatz-space> <ansatz-space>)) ¶

The finite element class for this ansatz space.

Source: ansatz-space.lisp.
Target Slot: fe-class.

Generic Reader: fe-dofs (object) ¶

Package

Methods

Reader Method: fe-dofs ((<vector-fe> <vector-fe>)) ¶

automatically generated reader method

Source: fe.lisp.
Target Slot: dofs.

Reader Method: fe-dofs ((<scalar-fe> <scalar-fe>)) ¶

The dofs which are functionals satisfying dof[i](basis[j])=delta(i,j).

Source: fe.lisp.
Target Slot: dofs.

Generic Writer: (setf fe-dofs) (object) ¶

Package

Methods

Writer Method: (setf fe-dofs) ((<vector-fe> <vector-fe>)) ¶

automatically generated writer method

Source: fe.lisp.
Target Slot: dofs.

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.

Package

Source

Methods

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: fe-gradient (asv global-pos) ¶

Evaluates the gradient of the FE ansatz-space-vector @arg{asv} at @arg{global-pos}.

Package

Source

Methods

Method: fe-gradient ((asv <ansatz-space-vector>) pos) ¶: Evaluates a finite element gradient at point pos.

Generic Function: fe-integrate (asv &key cells skeleton initial-value combiner key coeff-func no-weights-p component) ¶

Integrates a finite element function over the domain. key is a transformer function, as always (e.g. #’abs if you want the L1-norm).

Package

Source

Methods

Method: fe-integrate ((asv <ansatz-space-vector>) &key cells skeleton coeff-func initial-value combiner key no-weights-p component) ¶: Integrates a finite element function over the domain. key is a transformer function, as always (e.g. #’abs if you want the L1-norm). @arg{no-weights-p} is useful for calculating maxima, minima or an L-infinity norm. @arg{combiner} will probably be something like #’max or #’min in this case.

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}.

Package

Source

Methods

Method: fe-local-gradient ((asv <ansatz-space-vector>) cell local-pos) ¶: Evaluates a finite element gradient on @arg{cell} at @arg{local-pos}.

Generic Function: fe-local-value (asv cell local-pos) ¶

Evaluates a FE ansatz-space-vector in @arg{cell} at @arg{local-pos}.

Package

Source

Methods

Method: fe-local-value ((asv <ansatz-space-vector>) cell local-pos) ¶: Evaluates a finite element function in @arg{cell} at @arg{local-pos}.

Generic Function: fe-value (asv global-pos) ¶

Evaluates a FE ansatz-space-vector at @arg{global-pos}.

Package

Source

Methods

Method: fe-value ((asv <ansatz-space-vector>) global-pos) ¶: Evaluates a finite element function at @arg{global-pos}.

Generic Function: fill! (x s) ¶

Fills X with element s.

Package

Source

Methods

Method: fill! ((x vector) (s number)) ¶

Source: array-blas.lisp.

Method: fill! ((x static-store-vector) (s number)) ¶

Source: store-vector.lisp.

Method: fill! (x s) ¶

Recursive definition for FILL! usable for sparse block vectors.

Source: vector-methods.lisp.

Generic Function: fill-random! (x s) ¶

Fills X with random values (obtained by (random s)).

Package

Source

Methods

Method: fill-random! ((x vector) (s number)) ¶

Source: array-blas.lisp.

Method: fill-random! ((x number) (s number)) ¶

Source: number-blas.lisp.

Method: fill-random! ((x static-store-vector) (s number)) ¶

Source: store-vector.lisp.

Method: fill-random! (x s) ¶

Recursive definition for FILL-RANDOM! usable for sparse block vectors.

Source: vector-methods.lisp.

Generic Function: finally (iter blackboard) ¶

Performs final operations.

Package

Source

Methods

Method: finally ((itsolve <discrete-iterative-solver>) blackboard) ¶

Put convergence rate into report.

Source: solve.lisp.

Method: finally ((iter <iteration>) blackboard) ¶: Setup a report and ensures fresh line on output.

Generic Function: find-cell-from-position (skel pos) ¶

Finds a cell from @arg{skel} which contains the global position @arg{pos}.

Package

Source

Methods

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.

Source: mesh.lisp.

Method: find-cell-from-position ((skel <skeleton>) (pos array)) ¶

Generic Reader: fmg (object) ¶

Package

Methods

Reader Method: fmg ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: fmg.

Generic Function: for-each (func collection) ¶

Applies @arg{func} to each element of @arg{collection}.

Package

Source

Methods

Method: for-each ((func function) (seq sequence)) ¶: Applies @arg{func} to each element of the sequence @arg{seq}.

Generic Function: for-each-col-key (func mat &key parallel &allow-other-keys) ¶

Loop through column keys.

Package

Source

Methods

Method: for-each-col-key (fn (smat <sparse-dictionary-matrix>) &key parallel) ¶

Loop through column keys.

Source: sparse-matrix.lisp.

Method: for-each-col-key (fn mat &key &allow-other-keys) ¶

Default: Assume that the column keys are integers from 0 upto (ncols mat).

Source: matrix-methods.lisp.

Generic Function: for-each-entry (func vec) ¶

Calls @arg{func} on all entries of @arg{vec}.

Package

Source

Methods

Method: for-each-entry (fn (svec <sparse-dictionary-vector>)) ¶

Source: sparse-vector.lisp.

Method: for-each-entry (func (tensor <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: for-each-entry (fn (mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: for-each-entry (func (array array)) ¶

Source: array-blas.lisp.

Method: for-each-entry (func (seq sequence)) ¶

Source: array-blas.lisp.

Method: for-each-entry (func (num number)) ¶

Source: number-blas.lisp.

Method: for-each-entry (func vec) ¶

The default method calls @function{for-each-entry-and-key}.

Source: vector-methods.lisp.

Generic Function: for-each-entry-and-key (func object) ¶

Calls @arg{func} on all entries of the collection @arg{object} and their corresponding keys.

Package

Source

Methods

Method: for-each-entry-and-key (fn (svec <sparse-dictionary-vector>)) ¶

Source: sparse-vector.lisp.

Method: for-each-entry-and-key ((fn function) (x compressed-matrix)) ¶

Source: compressed.lisp.

Method: for-each-entry-and-key (func (tensor <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: for-each-entry-and-key (func (tensor tensor)) ¶

Source: tensor.lisp.

Method: for-each-entry-and-key (fn (mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: for-each-entry-and-key (func (x array)) ¶

Source: array-blas.lisp.

Method: for-each-entry-and-key (func (x vector)) ¶

Source: array-blas.lisp.

Method: for-each-entry-and-key (func (x list)) ¶

Source: array-blas.lisp.

Method: for-each-entry-and-key (func (mat <submatrix>)) ¶

Source: matrix-methods.lisp.

Method: for-each-entry-and-key (fn (mat <matrix>)) ¶

Source: matrix-methods.lisp.

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}.

Package

Source

Methods

Method: for-each-entry-and-vector-index (func (tensor tensor)) ¶

Source: tensor.lisp.

Method: for-each-entry-and-vector-index (func (x vector)) ¶

Source: array-blas.lisp.

Method: for-each-entry-and-vector-index (func (array array)) ¶

Source: array-blas.lisp.

Method: for-each-entry-and-vector-index (func (mat <matrix>)) ¶

Source: matrix-methods.lisp.

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.

Source: vector-methods.lisp.

Generic Function: for-each-entry-in-col (func mat col-key) ¶

Loop through entries in column col.

Package

Source

Methods

Method: for-each-entry-in-col (fn (smat <sparse-dictionary-matrix>) key) ¶

Source: sparse-matrix.lisp.

Generic Function: for-each-entry-in-row (func mat row-key) ¶

Loop through col-keys in row.

Package

Source

Methods

Method: for-each-entry-in-row (fn (smat <sparse-dictionary-matrix>) key) ¶

Source: sparse-matrix.lisp.

Generic Function: for-each-key (func vec) ¶

Calls @arg{func} on all indices/keys of @arg{vec}.

Package

Source

Methods

Method: for-each-key (fn (svec <sparse-dictionary-vector>)) ¶

Source: sparse-vector.lisp.

Method: for-each-key (func (tensor <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: for-each-key (func (array array)) ¶

Source: array-blas.lisp.

Method: for-each-key (func (x vector)) ¶

Source: array-blas.lisp.

Method: for-each-key (func vec) ¶

The default method calls @function{for-each-entry-and-key}.

Source: vector-methods.lisp.

Generic Function: for-each-key-and-entry-in-col (func mat col-key) ¶

Loop through row-keys and entries in col.

Package

Source

Methods

Method: for-each-key-and-entry-in-col (fn (smat <sparse-dictionary-matrix>) key) ¶

Source: sparse-matrix.lisp.

Generic Function: for-each-key-and-entry-in-row (func mat row-key) ¶

Loop through col-keys and entries in row.

Package

Source

Methods

Method: for-each-key-and-entry-in-row (fn (smat <sparse-dictionary-matrix>) key) ¶

Source: sparse-matrix.lisp.

Method: for-each-key-and-entry-in-row ((fn function) (mat compressed-matrix) i) ¶

Source: compressed.lisp.

Generic Function: for-each-key-in-col (func mat col-key) ¶

Loop through row-keys in column col.

Package

Source

Methods

Method: for-each-key-in-col (fn (smat <sparse-dictionary-matrix>) key) ¶

Source: sparse-matrix.lisp.

Generic Function: for-each-key-in-row (func mat row-key) ¶

Loop through col-keys in row.

Package

Source

Methods

Method: for-each-key-in-row (fn (smat <sparse-dictionary-matrix>) key) ¶

Source: sparse-matrix.lisp.

Method: for-each-key-in-row (fn (mat standard-matrix) row-key) ¶

Source: standard-matrix.lisp.

Generic Function: for-each-row-key (func mat &key parallel &allow-other-keys) ¶

Loop through row keys.

Package

Source

Methods

Method: for-each-row-key (fn (smat <sparse-dictionary-matrix>) &key parallel) ¶

Loop through row keys.

Source: sparse-matrix.lisp.

Method: for-each-row-key (fn mat &key &allow-other-keys) ¶

Default: Assume that the row keys are integers from 0 upto (nrows mat).

Source: matrix-methods.lisp.

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}.

Package

Source

Methods

Method: g2l ((vtx <vertex>) global-pos) ¶

Source: vertex.lisp.

Generic Function: gemm-nn! (a x y b z) ¶

General matrix-matrix multiplication: @math{Z <- alpha * X * Y + beta * Z}

Package

Source

Methods

Method: gemm-nn! (alpha (x compressed-matrix) (y standard-matrix) beta (z standard-matrix)) ¶

Source: compressed.lisp.

Method: gemm-nn! (alpha (a standard-matrix) (x vector) beta (y vector)) ¶

Source: compat.lisp.

Method: gemm-nn! (alpha (x number) y beta z) ¶

This method is slightly more general than usual gemm, because it allows also y and z to be vectors even if x is a number and not a matrix.

Source: number-blas.lisp.

Method: gemm-nn! (alpha a y beta z) ¶

Source: matrix-methods.lisp.

Generic Function: gemm-nt! (a x y b z) ¶

General matrix-matrix multiplication: @math{Z <- alpha * X * Y’ + beta * Z}

Package

Source

Methods

Method: gemm-nt! (alpha (x compressed-matrix) (y standard-matrix) beta (z standard-matrix)) ¶

Source: compressed.lisp.

Method: gemm-nt! (alpha a y beta z) ¶

Source: matrix-methods.lisp.

Generic Function: gemm-tn! (a x y b z) ¶

General matrix-matrix multiplication: @math{Z <- alpha * X’ * Y + beta * Z}

Package

Source

Methods

Method: gemm-tn! (alpha (x <sparse-vector>) (y <sparse-vector>) beta (z standard-matrix)) ¶

Source: sparse-vector.lisp.

Method: gemm-tn! (alpha (x compressed-matrix) (y standard-matrix) beta (z standard-matrix)) ¶

Source: compressed.lisp.

Method: gemm-tn! (alpha (a standard-matrix) (x vector) beta (y vector)) ¶

Source: compat.lisp.

Method: gemm-tn! (alpha a y beta z) ¶

Source: matrix-methods.lisp.

Generic Function: gemm-tt! (a x y b z) ¶

General matrix-matrix multiplication: @math{Z <- alpha * X’ * Y’ + beta * Z}

Package

Source

Methods

Method: gemm-tt! (alpha (x compressed-matrix) (y standard-matrix) beta (z standard-matrix)) ¶

Source: compressed.lisp.

Method: gemm-tt! (alpha a y beta z) ¶

Source: matrix-methods.lisp.

Generic Function: gesv! (a b) ¶

Solves a linear system A X = B for X.

Package

Source

Methods

Method: gesv! ((smat <sparse-matrix>) (svec <ht-sparse-vector>)) ¶

Solve the system by calling an external sparse solver.

Source: sparselu.lisp.

Method: gesv! ((mat compressed-matrix) (vec standard-matrix)) ¶

Solve the system by calling an external sparse solver.

Source: compressed.lisp.

Method: gesv! (a b) ¶: Default method solves LSE via GETRF and GETRS!.

Generic Function: get-fe (fe-disc cell) ¶

Returns the finite element for the given discretization and reference cell.

Package

Source

Methods

Method: get-fe ((as <ansatz-space>) cell) ¶

Method: get-fe ((disc <standard-fe-discretization>) cell) ¶

Generic Function: get-from-pool (pool key) ¶

Get a suitable object from the pool. If no such object is found, NIL is returned.

Package

Source

Methods

Method: get-from-pool ((pool parpool) key) ¶

Method: get-from-pool ((pool thread-safe-pool) key) ¶

Method: get-from-pool ((pool pool) key) ¶

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.

Package

Source

Methods

Method: get-local-from-global-mat ((smat <sparse-matrix>) (cell <cell>) &optional domain-cell) ¶

Generic Function: get-local-from-global-vec (cell global-vec) ¶

Maps the region in global-vec determined by cell to a local vector.

Package

Source

Methods

Method: get-local-from-global-vec ((cell <cell>) (svec <sparse-vector>)) ¶

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.

Package

Source

Methods

Method: getrf! ((asa <ansatz-space-automorphism>) &optional ipiv) ¶

Source: sparseas.lisp.

Method: getrf! ((a <sparse-matrix>) &optional ipiv) ¶

Source: sparselu.lisp.

Method: getrf! ((mat standard-matrix) &optional ipiv) ¶

Computes the PLR decomposition with column pivoting of the matrix MAT. Note that the indexing in @arg{ipiv} is 0-based or 1-based depending on the use of LAPACK.

Source: standard-matrix-lr.lisp.

Method: getrf! ((x number) &optional ipiv) ¶

Source: number-blas.lisp.

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}.

Package

Source

Methods

Method: getrs! ((ldu <ldu-sparse>) (result <ht-sparse-vector>) &optional ipiv) ¶

Source: sparselu.lisp.

Method: getrs! ((lr standard-matrix) (b vector) &optional ipiv) ¶

Source: compat.lisp.

Method: getrs! ((lr standard-matrix) (b standard-matrix) &optional ipiv) ¶

Uses the LR decomposition computed by getrf! to solve a linear system with rhs B. LR must be a n x n - matrix, b must be a n x m matrix.

Source: standard-matrix-lr.lisp.

Method: getrs! ((x number) (b number) &optional ipiv) ¶

Source: number-blas.lisp.

Generic Function: ggev (a b &optional job) ¶

Syntax: (GGEV A B [job])

Purpose: Computes the generalized eigenvalues and left/right eigenvectors of @math{A - s B}.

1. (GGEV A B :N) => lambda

Computes the generalized eigenvalues of @math{A - s B}.

2. (GGEV A B :V) => lambda, V, W

Computes generalized eigenvalues and eigenvectors of (A - sB).

@math{ A*V = B*V*diag(lambda), \ W’*A = diag(lambda)*W’*B}
with V and W orthogonal (unitary).

Remark: The symmetric/hermitian counterpart of this routine is @function{hegv}.

Package

Source

ggev.lisp.

Methods

Method: ggev ((a standard-matrix) (b standard-matrix) &optional job) ¶

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.

Package

Source

Methods

Method: global->embedded-local ((cell <cell>) global-pos) ¶

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.

Package

Source

Methods

Method: global->local ((vtx <mapped-vertex>) global-pos) ¶

Source: vertex.lisp.

Method: global->local ((vtx <vertex>) global-pos) ¶

Source: vertex.lisp.

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 Reader: gradient (object) ¶

Package

Methods

Reader Method: gradient ((poly polynomial)) ¶

Source: polynom.lisp.
Target Slot: gradient.

Reader Method: gradient ((<special-function> <special-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: gradient.

Generic Function: graphic-commands (object program &rest rest &key linewidth dimension tubes glyphs glyph-scale background foreground shape range &allow-other-keys) ¶

Returns commands for plotting to be sent to the graphics program.

Package

Source

Methods

Method: graphic-commands ((polygons list) (program (eql :gnuplot)) &key linewidth &allow-other-keys) ¶

Source: plot-gnuplot.lisp.

Method: graphic-commands (object (program (eql :gnuplot)) &rest paras) ¶

Default gnuplot plotting command.

Source: plot-gnuplot.lisp.

Method: graphic-commands ((asa <ansatz-space-automorphism>) (program (eql :dx)) &key &allow-other-keys) ¶

Source: asaplot.lisp.

Method: graphic-commands ((skel <skeleton>) (program (eql :dx)) &key dimension tubes glyphs glyph-scale background &allow-other-keys) ¶

Source: meshplot.lisp.

Method: graphic-commands (object (program (eql :dx)) &key foreground dimension shape range &allow-other-keys) ¶

Default method for plotting objects with DX.

Source: plot-dx.lisp.

Generic Function: graphic-file-name (object program &rest rest &key filename system-p &allow-other-keys) ¶

Return a filename for the data of this plot.

Package

Source

Methods

Method: graphic-file-name (object (program (eql :gnuplot)) &key &allow-other-keys) ¶

Returns the output file for @program{Gnuplot}.

Source: gnuplot.lisp.

Method: graphic-file-name (object (program (eql :vtk)) &key filename &allow-other-keys) ¶

Returns the file name for the @program{vtk} data file.

Source: vtk.lisp.

Method: graphic-file-name (object (program (eql :dx)) &key &allow-other-keys) ¶

Returns the output file for @program{dx}.

Source: dx.lisp.

Method: graphic-file-name :around (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-output (object program &key component shape rank &allow-other-keys) ¶

Writes the graphic commands for @arg{object} as needed by the graphic program @arg{program}.

Package

Source

Methods

Method: graphic-output ((asv <ansatz-space-vector>) (program (eql :dx)) &rest args &key component shape rank &allow-other-keys) ¶

Source: feplot.lisp.

Method: graphic-output :after (object (program (eql :dx)) &key &allow-other-keys) ¶

Source: dx.lisp.

Method: graphic-output (object program &rest rest) ¶: Calls the generic graphic interface in appropriate order.

Generic Function: graphic-write-data (stream object program &rest rest &key cells cell->values component depth transformation dimension part rank shape &allow-other-keys) ¶

Write the data file for @arg{program} to @arg{stream}.

Package

Source

Methods

Method: graphic-write-data (stream object (program (eql :vtk)) &key cells cell->values component depth transformation &allow-other-keys) ¶

Source: plot-vtk.lisp.

Method: graphic-write-data (stream object (program (eql :gnuplot)) &key cells cell->values depth) ¶

Writes data in gnuplot format to a stream.

Source: plot-gnuplot.lisp.

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.

Source: plot-gnuplot.lisp.

Method: graphic-write-data (stream (asa <ansatz-space-automorphism>) (program (eql :dx)) &key dimension &allow-other-keys) ¶

Source: asaplot.lisp.

Method: graphic-write-data (stream (skel <skeleton>) (program (eql :vtk)) &key cells part transformation) ¶

Plots a mesh. If provided, @arg{cells} should be 1-cells.

Source: meshplot.lisp.

Method: graphic-write-data (stream (skel <skeleton>) (program (eql :dx)) &key cells part transformation) ¶

Plots a mesh. If provided, @arg{cells} should be 1-cells.

Source: meshplot.lisp.

Method: graphic-write-data (stream object (program (eql :dx)) &key cells cell->values rank shape depth 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.

Source: plot-dx.lisp.

Generic Function: hegv (a b &optional job) ¶

Syntax: (HEGV A B [job])

Purpose: Computes the generalized eigenvalues and left/right eigenvectors of @math{A - s B} for Hermitian matrices A and B.

1. (HEGV A B :N) => lambda

Computes the generalized eigenvalues of @math{A - s B}.

2. (HEGV A B :V) => lambda, V

Computes generalized eigenvalues and eigenvectors of (A - sB).

@math{ A*V = B*V*diag(lambda), \ W’*A = diag(lambda)*W’*B}
with V and W orthogonal (unitary).

Remark: The non-symmetric counterpart of this routine is @function{ggev}.

Package

Source

hegv.lisp.

Methods

Method: hegv ((a standard-matrix) (b standard-matrix) &optional job) ¶

Generic Function: hierarchical-mesh (aso) ¶

The hierarchical mesh for the given ansatz-space or ansatz-space object.

Package

Source

Methods

Method: hierarchical-mesh ((aso <ansatz-space-object>)) ¶

Method: hierarchical-mesh ((as <ansatz-space>)) ¶

Generic Function: identified-cells (cell skel) ¶

Returns a list of cells in @arg{skel} which are identified with @arg{cell}.

Package

Source

Methods

Method: identified-cells (cell skel) ¶

Source: identify.lisp.

Generic Function: image-ansatz-space (asm) ¶

Package

Source

Methods

Method: image-ansatz-space ((asa <ansatz-space-automorphism>)) ¶

Reader Method: image-ansatz-space ((<domain-image-mixin> <domain-image-mixin>)) ¶

automatically generated reader method

Target Slot: image-ansatz-space.

Generic Reader: image-dimension (object) ¶

Package

Methods

Reader Method: image-dimension ((<function> <function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: image-dimension.

Generic Function: in-pattern-p (tensor &rest indices) ¶

Returns T, if the indices are in the nonzero pattern.

Package

Source

Methods

Method: in-pattern-p ((smat <sparse-matrix>) &rest indices) ¶

Source: sparse-matrix.lisp.

Method: in-pattern-p ((cm compressed-matrix) &rest indices) ¶

Source: compressed.lisp.

Method: in-pattern-p ((pattern compressed-pattern) &rest rest) ¶

Source: compressed.lisp.

Method: in-pattern-p ((tensor <sparse-tensor>) &rest indices) ¶

Method: in-pattern-p (object &rest indices) ¶: The default method returns T iff no indices are given.

Method: in-pattern-p ((tensor array) &rest indices) ¶

Method: in-pattern-p ((vec <vector>) &rest indices) ¶

Method: in-pattern-p ((mat <matrix>) &rest indices) ¶

Method: in-pattern-p ((tensor full-tensor) &rest indices) ¶

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.

Package

Source

Methods

Method: increment-global-by-local-mat ((smat <sparse-matrix>) local-mat (cell <cell>) &optional domain-cell) ¶

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.

Package

Source

Methods

Method: increment-global-by-local-vec ((cell <cell>) (svec <sparse-vector>) local-vec) ¶

Generic Function: indicate (indicator blackboard) ¶

Puts a list of cells to be refined on the blackboard.

Package

Source

Methods

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.

Method: indicate :after ((indicator <refinement-indicator>) blackboard) ¶: Postprocess the refinement indication.

Method: indicate ((indicator <refinement-indicator>) blackboard) ¶: The standard way is to indicate cells depending on the result of cell-rule.

Method: indicate :before ((indicator <refinement-indicator>) blackboard) ¶: Initialize the refinement hash table on the blackboard.

Generic Reader: indices (object) ¶

Generic Writer: (setf indices) (object) ¶

Package

Methods

Reader Method: indices ((<sparse-tensor> <sparse-tensor>)) ¶

Writer Method: (setf indices) ((<sparse-tensor> <sparse-tensor>)) ¶

The (nonzero) indices of the first slot.

Source: sparse-tensor.lisp.
Target Slot: indices.

Reader Method: indices ((compressed-pattern compressed-pattern)) ¶

Vector with compressed row/column indices.

Source: compressed.lisp.
Target Slot: indices.

Generic Function: initially (iter blackboard) ¶

Performs initial operations.

Package

Source

Methods

Method: initially ((rothe <rothe>) blackboard) ¶

Source: rothe.lisp.

Method: initially :after ((fe-strategy <fe-approximation>) blackboard) ¶

Ensures a finite element ansatz space and a first approximation to the solution on the blackboard.

Source: fe-approximation.lisp.

Method: initially :after ((itsol <discrete-iterative-solver>) blackboard) ¶

Ensure an initial guess for the solution after other initializations have been done.

Source: solve.lisp.

Method: initially ((iter <iteration>) blackboard) ¶: Default method. Prints the header line for observed quantities.

Method: initially :before ((iter <iteration>) blackboard) ¶: Reset data on the blackboard.

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.

Package

Source

Methods

Method: inside-cell? ((cell <cell>) position &optional threshold) ¶

Generic Reader: integration-points (object) ¶

Package

Methods

Reader Method: integration-points ((integration-rule integration-rule)) ¶

The points of an integration rule.

Source: quadrature.lisp.
Target Slot: points.

Generic Reader: integration-weights (object) ¶

Package

Methods

Reader Method: integration-weights ((integration-rule integration-rule)) ¶

The weights of integration rule.

Source: quadrature.lisp.
Target Slot: weights.

Generic Function: intermediate (iter blackboard) ¶

Is called after initialization and after each step.

Package

Source

Methods

Method: intermediate ((rothe <rothe>) blackboard) ¶

Plots the solution initially and after each time step.

Source: rothe.lisp.

Method: intermediate ((fe-strategy <fe-approximation>) blackboard) ¶

Approximates and estimates the error for the current ansatz-space.

Source: fe-approximation.lisp.

Method: intermediate :before ((itsolve <discrete-iterative-solver>) blackboard) ¶

Before printing information in the main method we ensure that the defect and its norm are up-to-date.

Source: solve.lisp.

Method: intermediate ((iter <iteration>) blackboard) ¶: Default method. Prints observed quantities.

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.

Package

Source

Methods

Method: interpolate-on-refcell ((fe <fe>) function) ¶

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.

Package

Source

Methods

Method: ip-gradients ((fe <vector-fe>) object) ¶: Object may be an integration rule or a vector of positions.

Method: ip-gradients ((fe <scalar-fe>) (qrule integration-rule)) ¶: Return the fe values for the integration points of qrule.

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 :around (fe obj) ¶

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.

Package

Source

Methods

Method: ip-values ((fe <vector-fe>) object) ¶: Object may be an integration rule or a vector of positions.

Method: ip-values ((fe <scalar-fe>) (qrule integration-rule)) ¶: Return the fe values for the high-precision integration points of qrule.

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 :around (fe obj) ¶

Generic Function: iter-format (stream control-string &rest args) ¶

Iteration output should be made using this function which respects *iteration-depth* and *output-depth*.

Package

Source

Methods

Method: iter-format (stream control-string &rest args) ¶: Default method.

Generic Function: iterate (iter blackboard) ¶

Iterates on the data in the blackboard according to the iteration iter.

Package

Source

Methods

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.

Generic Function: iterator (x) ¶

Returns an iterator for @arg{x}.

Package

Source

Methods

Method: iterator ((x range)) ¶

Method: iterator ((x vector)) ¶

Method: iterator ((x list)) ¶

Generic Function: iterator-end-p (vec iterator) ¶

Package

Source

Methods

Method: iterator-end-p ((range range) i) ¶

Method: iterator-end-p ((vec vector) i) ¶

Method: iterator-end-p ((vec list) tail) ¶

Generic Function: iterator-next (vec iterator) ¶

Returns an incremented @arg{iterator}.

Package

Source

Methods

Method: iterator-next ((range range) i) ¶

Method: iterator-next ((vec vector) i) ¶

Method: iterator-next ((vec list) tail) ¶

Generic Function: join-horizontal! (result &rest matrices) ¶

Joins @arg{matrices} horizontally into result.

Package

Source

Methods

Method: join-horizontal! ((result <sparse-vector>) &rest vectors) ¶

Source: sparse-vector.lisp.

Method: join-horizontal! (result &rest matrices) ¶

Generic Function: join-instance (orientation matrix &rest matrices) ¶

Compute an instance for storing the join of @arg{orientation} applied to matrix and matrices.

Package

Source

Methods

Method: join-instance (orientation (x <sparse-vector>) &rest vecs) ¶

Source: sparse-vector.lisp.

Method: join-instance (orientation (matrix standard-matrix) &rest matrices) ¶

Source: standard-matrix.lisp.

Method: join-instance (orientation (vec vector) &rest vecs) ¶

Source: array-blas.lisp.

Generic Function: join-vertical! (result &rest matrices) ¶

Joins @arg{matrices} vertically into result.

Package

Source

Methods

Method: join-vertical! (result &rest matrices) ¶

Generic Function: key->size (svec) ¶

Returns NIL, if @arg{svec} cannot extend automatically when
being accessed. Otherwise returns a function mapping keys to vector block sizes.

Package

Source

Methods

Method: key->size ((asv <ansatz-space-vector>)) ¶

Source: sparseas.lisp.

Method: key->size ((ansatz-space <ansatz-space>)) ¶

Source: sparseas.lisp.

Reader Method: key->size ((<key->size-mixin> <key->size-mixin>)) ¶

Function determining the dimension of a block.

Target Slot: key->size.

Method: key->size ((svec <sparse-vector>)) ¶

Generic Function: keys (dic) ¶

Returns a list of all keys of @arg{dic}.

Package

Source

Methods

Method: keys ((vec <vector>)) ¶

Source: vector-methods.lisp.

Reader Method: keys ((computed-value-dictionary computed-value-dictionary)) ¶

automatically generated reader method

Target Slot: keys.

Method: keys (dic) ¶

Generic Function: keys->pattern (smat) ¶

Package

Source

Methods

Method: keys->pattern ((asm <ansatz-space-morphism>)) ¶

Source: sparseas.lisp.

Reader Method: keys->pattern ((<block-definition-mixin> <block-definition-mixin>)) ¶

Function determining the pattern of a block.

Target Slot: keys->pattern.

Method: keys->pattern ((smat <sparse-matrix>)) ¶

Generic Function: keys-of-column (mat key) ¶

All row keys in the given column for a matrix.

Package

Source

Methods

Method: keys-of-column ((mat <matrix>) key) ¶

Generic Function: keys-of-row (mat key) ¶

All column keys in the given row for a matrix.

Package

Source

Methods

Method: keys-of-row ((mat <matrix>) key) ¶

Generic Function: kronecker-product (a b) ¶

The Kronecker product of matrices A and B.

Package

Source

Methods

Method: kronecker-product (a b) ¶

Generic Function: l2-norm (x) ¶

Returns the 2-norm of @arg{x}.

Package

Source

Methods

Method: l2-norm ((x number)) ¶

Source: number-blas.lisp.

Method: l2-norm (vec) ¶

Recursive definition for the l2-norm.

Source: vector-methods.lisp.

Generic Function: l2dg (cell local-pos) ¶

Computes the gradient for a multilinear interpolation from the vertices.

Package

Source

Methods

Method: l2dg ((simplex <simplex>) local-pos) ¶

Returns the linear transformation defined by the coordinates of the simplex corners.

Source: simplex.lisp.

Method: l2dg ((vtx <vertex>) local-pos) ¶

Source: vertex.lisp.

Method: l2dg (cell local-pos) ¶: This default method computes an average of the barycentric coordinate gradients.

Generic Function: l2g (cell local-pos) ¶

Computes the global position by interpolation from the vertices.

Package

Source

Methods

Method: l2g ((vtx <vertex>) local-pos) ¶

Same as local->global for vertices.

Source: vertex.lisp.

Method: l2g (cell local-pos) ¶: This default method uses a barycentric average of the vertex positions.

Generic Reader: leaves (object) ¶

Generic Writer: (setf leaves) (object) ¶

Package

Methods

Reader Method: leaves ((<demo> <demo>)) ¶

Writer Method: (setf leaves) ((<demo> <demo>)) ¶

The child nodes of the demo.

Source: demo.lisp.
Target Slot: leaves.

Generic Function: linear-p (problem) ¶

Predicate determining if a problem is linear or nonlinear.

Package

Source

Methods

Method: linear-p ((problem <problem>)) ¶

Generic Function: linearize (problem solution) ¶

Linearize the nonlinear problem PROBLEM at the point SOLUTION. The result should be a linear problem.

Package

Source

Methods

Method: linearize ((problem <nonlinear-problem>) solution) ¶

Method: linearize (problem solution) ¶: This default method throws an error for nonlinear problems and is the identity on linear problems.

Generic Function: linf-norm (x) ¶

Returns the maximum norm of @arg{x}.

Package

Source

Methods

Method: linf-norm ((x number)) ¶

Source: number-blas.lisp.

Method: linf-norm (vec) ¶

Recursive definition for the linf-norm.

Source: vector-methods.lisp.

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.

Package

Source

Methods

Method: local->dglobal ((vtx <vertex>) local-pos) ¶

Not perfect, should take mapping into account.

Source: vertex.lisp.

Method: local->dglobal ((cell <distorted-cell>) local-pos) ¶

Method: local->dglobal ((cell <mapped-cell>) local-pos) ¶

Method: local->dglobal ((cell <cell>) local-pos) ¶

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.

Package

Source

Methods

Method: local->global ((cell <distorted-cell>) local-pos) ¶

Method: local->global ((cell <mapped-cell>) local-pos) ¶

Method: local->global ((cell <cell>) local-pos) ¶

Generic Function: local-coordinates-of-midpoint (cell) ¶

Returns the local coordinates of the cell midpoint.

Package

Source

Methods

Method: local-coordinates-of-midpoint ((cell <product-cell>)) ¶

Source: product-cell.lisp.

Method: local-coordinates-of-midpoint ((cell <simplex>)) ¶

Source: simplex.lisp.

Method: local-coordinates-of-midpoint ((cell <vertex>)) ¶

Source: vertex.lisp.

Generic Function: lp-norm (x p) ¶

Returns the @arg{p}-norm of @arg{x}.

Package

Source

Methods

Method: lp-norm ((x number) p) ¶

Source: number-blas.lisp.

Method: lp-norm (vec (p number)) ¶

Recursive definition for the lp-norm.

Source: vector-methods.lisp.

Generic Function: m* (x y) ¶

Multiply X by Y.

Package

Source

Methods

Method: m* ((asm <ansatz-space-morphism>) (asv <ansatz-space-vector>)) ¶

Source: sparseas.lisp.

Method: m* ((ldu <ldu-sparse>) (rhs <ht-sparse-vector>)) ¶

An ldu-decomposition is considered as an inverse.

Source: sparselu.lisp.

Method: m* ((x <sparse-vector>) (y standard-matrix)) ¶

Source: sparse-vector.lisp.

Method: m* ((mat <sparse-tensor>) vec) ¶

Source: sparse-tensor.lisp.

Method: m* ((x number) (y number)) ¶

Ordinary multiplication on numbers.

Source: number-blas.lisp.

Method: m* (x y) ¶

By default M* is rewritten in terms of GEMM!.

Source: matrix-methods.lisp.

Generic Function: m*-nt (x y) ¶

Multiply X by Y^t.

Package

Source

Methods

Method: m*-nt (x y) ¶

By default, M*-NT is rewritten in terms of GEMM!.

Source: matrix-methods.lisp.

Generic Function: m*-product-instance (x y) ¶

Allocates an instance for the product of X and Y.

Package

Source

Methods

Method: m*-product-instance ((x <ansatz-space-morphism>) (y <ansatz-space-vector>)) ¶

Source: sparseas.lisp.

Method: m*-product-instance ((a <sparse-matrix>) (y <sparse-vector>)) ¶

Source: sparse-matrix.lisp.

Method: m*-product-instance ((a compressed-matrix) (x vector)) ¶

Source: compressed.lisp.

Method: m*-product-instance ((a standard-matrix) (x vector)) ¶

Returns a CL vector as result of matrix * CL vector.

Source: compat.lisp.

Method: m*-product-instance (x y) ¶

Generic Function: m*-tn (x y) ¶

Multiply X^t by Y.

Package

Source

Methods

Method: m*-tn (x y) ¶

By default, M*-TN is rewritten in terms of GEMM!.

Source: matrix-methods.lisp.

Generic Function: m*-tn-product-instance (x y) ¶

Allocates an instance for the product of X^t and Y.

Package

Source

Methods

Method: m*-tn-product-instance ((x <ansatz-space-morphism>) (y <ansatz-space-vector>)) ¶

Source: sparseas.lisp.

Method: m*-tn-product-instance ((x <sparse-vector>) (y <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: m*-tn-product-instance ((a standard-matrix) (x vector)) ¶

Returns a CL vector as result of transpose(matrix) * CL vector.

Source: compat.lisp.

Method: m*-tn-product-instance (x y) ¶

Generic Function: m+ (x y) ¶

Returns @math{X} + @math{Y}.

Package

Source

Methods

Method: m+ ((x polynomial) (y polynomial)) ¶

Source: polynom.lisp.

Method: m+ ((t1 <sparse-tensor>) (t2 <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: m+ ((x number) (y number)) ¶

Number addition.

Source: number-blas.lisp.

Method: m+ ((x list) (y list)) ¶

Source: vector-methods.lisp.

Method: m+ (x y) ¶

Default method uses M+! and COPY.

Source: vector-methods.lisp.

Generic Function: m+! (x y) ¶

Y <- X + Y

Package

Source

Methods

Method: m+! ((x polynomial) (y polynomial)) ¶

Source: polynom.lisp.

Method: m+! ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: m+! ((x number) (y number)) ¶

Number addition.

Source: number-blas.lisp.

Method: m+! ((x static-store-vector) (y static-store-vector)) ¶

Source: store-vector.lisp.

Method: m+! (x y) ¶

Recursive definition for M+! usable for sparse block vectors.

Source: vector-methods.lisp.

Generic Function: make-analog (obj) ¶

Generate an analogous but empty data structure.

Package

Source

general.lisp.

Methods

Method: make-analog ((aso <ansatz-space-object>)) ¶

Source: ansatz-space.lisp.

Method: make-analog ((mesh <mesh>)) ¶

Source: mesh.lisp.

Method: make-analog ((skel <skeleton>)) ¶

Source: skeleton.lisp.

Method: make-analog ((smat <block-definition-mixin>)) ¶

Source: sparse-matrix.lisp.

Method: make-analog ((svec <key->size-mixin>)) ¶

Source: sparse-vector.lisp.

Method: make-analog ((tensor <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: make-analog ((tensor full-tensor)) ¶

Source: tensor.lisp.

Method: make-analog ((arr array)) ¶

Source: compat.lisp.

Method: make-analog ((x standard-matrix)) ¶

Constructs a zero matrix with the same size as X.

Source: standard-matrix.lisp.

Method: make-analog ((x number)) ¶

Source: number-blas.lisp.

Method: make-analog (obj) ¶

Generic Function: make-coefficients-for (problem name patch demands evaluator &optional offset1 offset2) ¶

Generates a coefficient while dispatching on problem and coefficient name. May return a single coefficient or a list of several coefficients.

Package

Source

pdef.lisp.

Methods

Method: make-coefficients-for ((problem <pde-problem>) coeff-name patch args eval &optional offset1 offset2) ¶

Generic Function: make-domain-vector-for (mat &optional multiplicity) ¶

Package

Source

Methods

Method: make-domain-vector-for ((a <ansatz-space-morphism>) &optional multiplicity) ¶

Source: sparseas.lisp.

Method: make-domain-vector-for :around ((a <sparse-matrix>) &optional multiplicity) ¶

Ensure sequentially all entries of the result such that the structure does not extend in parallel.

Source: sparse-matrix.lisp.

Method: make-domain-vector-for ((a <sparse-matrix>) &optional multiplicity) ¶

Source: sparse-matrix.lisp.

Method: make-domain-vector-for ((cm compressed-matrix) &optional multiplicity) ¶

Source: compressed.lisp.

Method: make-domain-vector-for ((mat standard-matrix) &optional multiplicity) ¶

Source: compat.lisp.

Generic Function: make-hierarchical-mesh-from-domain (domain &key &allow-other-keys) ¶

Construct a hierarchical-mesh from a domain.

Package

Source

meshgen.lisp.

Methods

Method: make-hierarchical-mesh-from-domain (domain &rest key-args &key &allow-other-keys) ¶: Construct a hierarchical-mesh from a domain.

Generic Function: make-image-vector-for (mat &optional multiplicity) ¶

Package

Source

Methods

Method: make-image-vector-for ((a <ansatz-space-morphism>) &optional multiplicity) ¶

Source: sparseas.lisp.

Method: make-image-vector-for :around ((a <sparse-matrix>) &optional multiplicity) ¶

Ensure sequentially all entries of the result such that the structure does not extend in parallel.

Source: sparse-matrix.lisp.

Method: make-image-vector-for ((a <sparse-matrix>) &optional multiplicity) ¶

Source: sparse-matrix.lisp.

Method: make-image-vector-for ((cm compressed-matrix) &optional multiplicity) ¶

Source: compressed.lisp.

Method: make-image-vector-for ((mat standard-matrix) &optional multiplicity) ¶

Source: compat.lisp.

Generic Function: make-iterator (linit mat) ¶

Constructs an iterator object given a linear iteration and a matrix.

Package

Source

Methods

Method: make-iterator ((s1-cgit <s1-coarse-grid-iterator>) (a <sparse-matrix>)) ¶

Source: geomg.lisp.

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.

Source: multigrid.lisp.

Method: make-iterator ((solve-it <solver-iteration>) mat) ¶

Source: linsolve.lisp.

Method: make-iterator ((it <gmres>) mat) ¶

The algorithm follows .

Source: krylow.lisp.

Method: make-iterator ((bcgs <bi-cgstab>) mat) ¶

Standard method for the preconditioned BiCGstab iteration. The algorithm follows the original article of H. A. van der Vorst in SIAM J. Sci. and Stat. Comput., 13(2), 631–644 @url{https://doi.org/10.1137/0913035}.

Source: krylow.lisp.

Method: make-iterator ((cg <cg>) mat) ¶

Standard method for the preconditioned conjugate-gradient iteration.

Source: krylow.lisp.

Method: make-iterator ((linit <gradient-method>) mat) ¶

Iterator for the gradient method.

Source: krylow.lisp.

Method: make-iterator ((iter <block-iteration>) (smat <sparse-matrix>)) ¶

Source: blockit.lisp.

Method: make-iterator ((linit <ilu>) mat) ¶: Default method for ILU iteration. Works only for our sparse matrices.

Method: make-iterator ((sor <parallel-sor>) (mat <sparse-matrix>)) ¶

Method: make-iterator ((sor <sor>) (mat <sparse-matrix>)) ¶

Method: make-iterator ((sor <sor>) (mat standard-matrix)) ¶

Method: make-iterator ((jac <jacobi>) (mat <sparse-matrix>)) ¶

Method: make-iterator ((jac <jacobi>) (mat <matrix>)) ¶: The default method should work for everything.

Method: make-iterator ((rich <richardson>) (mat <matrix>)) ¶

Method: make-iterator ((linit <lu>) mat) ¶: Default method for lu iteration.

Method: make-iterator ((multi-iter <multi-iteration>) mat) ¶: Construct an iterator for a multi-iteration.

Generic Function: make-local-mat (as1 cell1 &optional as2 cell2) ¶

Generates a local matrix discretization for the given ansatz-space(s).

Package

Source

Methods

Method: make-local-mat (as1 cell1 &optional as2 cell2) ¶: Default method. Allocates a new matrix.

Method: make-local-mat :around (as1 cell1 &optional as2 cell2) ¶: Try using a pool if provided

Generic Function: make-mesh-from (object &key parametric initial-mesh-refinements &allow-other-keys) ¶

Makes a mesh from or for the given object.

Package

Source

meshgen.lisp.

Methods

Method: make-mesh-from ((domain <domain>) &key parametric initial-mesh-refinements &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.

Generic Function: map-matrix (result mapper mat) ¶

Package

Source

Methods

Method: map-matrix (result mapper (smat <sparse-matrix>)) ¶: A mapper for sparse matrices.

Generic Function: mapping (object) ¶

Package

Methods

Method: mapping ((cell <cell>)) ¶

No mapping for ordinary cells.

Source: cell.lisp.

Reader Method: mapping ((<mapped-cell> <mapped-cell>)) ¶

automatically generated reader method

Source: cell.lisp.
Target Slot: mapping.

Generic Writer: (setf mapping) (object) ¶

Package

Methods

Writer Method: (setf mapping) ((<mapped-cell> <mapped-cell>)) ¶

automatically generated writer method

Source: cell.lisp.
Target Slot: mapping.

Generic Function: mass (evp x) ¶

Evaluates the mass bilinear form for a generalized eigenvalue problem.

Package

Source

Methods

Method: mass ((evp <evp>) x) ¶

Generic Reader: mass-matrix (object) ¶

Package

Methods

Reader Method: mass-matrix ((<ls-evp> <ls-evp>)) ¶

automatically generated reader method

Source: evp.lisp.
Target Slot: mass-matrix.

Generic Function: mat-diff (x y) ¶

Prints a list of differences between X and Y.

Package

Source

Methods

Method: mat-diff ((smat1 <sparse-matrix>) (smat2 <sparse-matrix>)) ¶

Source: sparse-matrix.lisp.

Method: mat-diff (mat1 mat2) ¶

Source: matrix.lisp.

Generic Reader: matrix (object) ¶

Package

Methods

Reader Method: matrix ((<lse> <lse>)) ¶

automatically generated reader method

Source: problem.lisp.
Target Slot: matrix.

Generic Function: matrix-block (smat row-key col-key) ¶

Low-level block lookup for a sparse block matrix.

Package

Source

Methods

Method: matrix-block ((smat <sparse-dictionary-matrix>) row-key col-key) ¶

Generic Function: (setf matrix-block) (smat row-key col-key) ¶

Low-level block insertion into a sparse block matrix.

Package

Source

Methods

Method: (setf matrix-block) ((smat <ht-sparse-matrix>) row-key col-key) ¶

Generic Function: matrix-column (mat col-key) ¶

Returns a dictionary mapping row-key to entry.

Package

Source

Methods

Method: matrix-column ((mat <sparse-dictionary-matrix>) key) ¶

Generic Function: (setf matrix-column) (mat key) ¶

Package

Source

Methods

Method: (setf matrix-column) ((mat <sparse-dictionary-matrix>) key) ¶

Generic Function: matrix-row (mat row-key) ¶

Returns a dictionary mapping col-key to entry.

Package

Source

Methods

Method: matrix-row ((mat <sparse-dictionary-matrix>) key) ¶

Generic Function: (setf matrix-row) (mat key) ¶

Package

Source

Methods

Method: (setf matrix-row) ((mat <sparse-dictionary-matrix>) key) ¶

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}.

Package

Source

Methods

Method: matrix-slice ((x <sparse-vector>) &key from-row from-col nrows ncols) ¶

Source: sparse-vector.lisp.

Method: matrix-slice ((mat standard-matrix) &key from-row from-col nrows ncols) ¶

Source: standard-matrix-blas.lisp.

Generic Function: matrix-transpose-instance (x) ¶

Returns a zero matrix for storing the transpose of X.

Package

Source

Methods

Method: matrix-transpose-instance ((smat <sparse-matrix>)) ¶

Source: sparse-matrix.lisp.

Method: matrix-transpose-instance (x) ¶

Generic Function: maximal-partial-degree (poly) ¶

Maximal partial degree of a polynomial.

Package

Source

Methods

Method: maximal-partial-degree ((poly polynomial)) ¶

Generic Function: mequalp (x y) ¶

Returns T if X and Y have equal entries, otherwise NIL.

Package

Source

Methods

Method: mequalp ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: mequalp ((x number) (y number)) ¶

Source: number-blas.lisp.

Method: mequalp ((x static-store-vector) (y static-store-vector)) ¶

Exact equality test for static-store-vector.

Source: store-vector.lisp.

Method: mequalp (x y) ¶

Source: vector-methods.lisp.

Generic Function: mesh (object) ¶

Package

Methods

Method: mesh ((aso <ansatz-space-object>)) ¶

Source: ansatz-space.lisp.

Reader Method: mesh ((<ansatz-space> <ansatz-space>)) ¶

The mesh for this ansatz space which determines hanging-node constraints.

Source: ansatz-space.lisp.
Target Slot: mesh.

Generic Function: meshsize (mesh) ¶

Computes a meshsize. Please refer to the method documentations for the exact definition.

Package

Source

Methods

Method: meshsize ((mesh <mesh>)) ¶: Computes a meshsize as the size of the longest edge in the mesh.

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.

Package

Source

Methods

Method: mextract! ((x <sparse-vector>) (y <sparse-vector>) row-off col-off) ¶

This routine can only extract from the multiplicity dimension.

Source: sparse-vector.lisp.

Method: mextract! ((x standard-matrix) (y standard-matrix) row-off col-off) ¶

Source: standard-matrix-blas.lisp.

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}.

Package

Source

Methods

Method: midentity-p (mat &optional threshold) ¶

Source: compat.lisp.

Method: midentity-p ((x number) &optional threshold) ¶

Source: compat.lisp.

Generic Function: midpoint (cell) ¶

Returns cell midpoint in global coordinates.

Package

Source

Methods

Reader Method: midpoint ((<boundary-cell> <boundary-cell>)) ¶

automatically generated reader method

Source: triangulate.lisp.
Target Slot: midpoint.

Method: midpoint (cell) ¶: Default method

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.

Package

Source

Methods

Method: minject! ((x <sparse-vector>) (y <sparse-vector>) row-off col-off) ¶

This routine can only inject in the multiplicity dimension.

Source: sparse-vector.lisp.

Method: minject! ((x standard-matrix) (y standard-matrix) row-off col-off) ¶

Source: standard-matrix-blas.lisp.

Method: minject! ((x vector) (y vector) row-off col-off) ¶

Source: array-blas.lisp.

Generic Function: mref (a i j) ¶

Returns the matrix element @code{A[i,j]}.

Package

Source

Methods

Method: mref ((smat <sparse-matrix>) row-key col-key) ¶

If the matrix-block indexed by row-key/col-key exists, it is returned. Otherwise, a new matrix block is created according to the pattern specified for this index.

Source: sparse-matrix.lisp.

Method: mref ((cm compressed-matrix) i j) ¶

Source: compressed.lisp.

Method: mref ((tensor <sparse-tensor>) i j) ¶

Source: sparse-tensor.lisp.

Method: mref ((matrix standard-matrix) i j) ¶

We choose Fortran-like column-major indexing to make the use of Matlisp routines easier. Note: access to matrix entries using this generic function is slow. Therefore, specialized BLAS routines should be used whenever possible.

Source: standard-matrix.lisp.

Method: mref ((mat array) i j) ¶

Source: array-blas.lisp.

Method: mref ((submat <submatrix>) i j) ¶

Source: matrix-methods.lisp.

Method: mref ((x <vector>) (i (eql 0)) j) ¶

Source: matrix-methods.lisp.

Method: mref ((x <vector>) i (j (eql 0))) ¶

Source: matrix-methods.lisp.

Method: mref ((x vector) (i (eql 0)) j) ¶

Source: matrix-methods.lisp.

Method: mref ((x vector) i (j (eql 0))) ¶

Source: matrix-methods.lisp.

Method: mref ((x number) (i (eql 0)) (j (eql 0))) ¶

Source: matrix-methods.lisp.

Generic Function: (setf mref) (a i j) ¶

Writes the matrix element @code{A[i,j]}.

Package

Source

Methods

Method: (setf mref) ((smat <sparse-matrix>) row-key col-key) ¶

Source: sparse-matrix.lisp.

Method: (setf mref) ((cm compressed-matrix) i j) ¶

Source: compressed.lisp.

Method: (setf mref) ((tensor <sparse-tensor>) i j) ¶

Source: sparse-tensor.lisp.

Method: (setf mref) ((matrix standard-matrix) i j) ¶

Writer for mref.

Source: standard-matrix.lisp.

Method: (setf mref) ((mat array) i j) ¶

Source: array-blas.lisp.

Method: (setf mref) ((submat <submatrix>) i j) ¶

Source: matrix-methods.lisp.

Method: (setf mref) ((x <vector>) (i (eql 0)) j) ¶

Source: matrix-methods.lisp.

Method: (setf mref) ((x <vector>) i (j (eql 0))) ¶

Source: matrix-methods.lisp.

Method: (setf mref) ((x vector) (i (eql 0)) j) ¶

Source: matrix-methods.lisp.

Method: (setf mref) ((x vector) i (j (eql 0))) ¶

Source: matrix-methods.lisp.

Generic Function: msquare-p (mat) ¶

Returns T, iff @arg{mat} is square.

Package

Source

Methods

Method: msquare-p (mat) ¶

Source: matrix-methods.lisp.

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.

Package

Source

Methods

Method: msymmetric-p ((smat <sparse-matrix>) &key threshold output) ¶

Source: sparse-matrix.lisp.

Method: msymmetric-p (mat &key threshold output) ¶

Source: matrix-methods.lisp.

Generic Function: multilevel-decomposition (mg-it a) ¶

The central generic function constructing the multilevel hierarchy.

Package

Source

Methods

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>.

Source: geomg.lisp.

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.

Source: geomg.lisp.

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.

Source: amg.lisp.

Generic Function: multiple-evaluate (func positions) ¶

Multiple evaluations of @arg{func} may be optimized.

Package

Source

Methods

Method: multiple-evaluate (func positions) ¶: The default and unoptimized method calls simply @function{evaluate}.

Generic Function: multiple-evaluate-gradient (f positions) ¶

Multiple evaluations may be optimized.

Package

Source

Methods

Method: multiple-evaluate-gradient (f positions) ¶: The default and unoptimized method calls simply @function{evaluate}.

Generic Function: multiple-local->dglobal (cell local-pos) ¶

Applies LOCAL->DGLOBAL for several positions at once.

Package

Source

Methods

Method: multiple-local->dglobal ((cell <distorted-cell>) local-positions) ¶

Method: multiple-local->dglobal ((cell <mapped-cell>) local-positions) ¶

Method: multiple-local->dglobal ((cell <cell>) local-positions) ¶

Generic Function: multiple-local->global (cell local-pos) ¶

Applies LOCAL->GLOBAL for several positions at once.

Package

Source

Methods

Method: multiple-local->global ((cell <distorted-cell>) local-positions) ¶

Method: multiple-local->global ((cell <mapped-cell>) local-positions) ¶

Method: multiple-local->global ((cell <cell>) local-positions) ¶

Generic Function: multiplicity (vec) ¶

We allow multiple vectors, for solving linear problems in parallel.

Package

Source

Methods

Method: multiplicity ((as <ansatz-space>)) ¶

Source: ansatz-space.lisp.

Reader Method: multiplicity ((<evp-mixin> <evp-mixin>)) ¶

The multiplicity of the eigenspace.

Source: evp.lisp.
Target Slot: multiplicity.

Reader Method: multiplicity ((<domain-problem> <domain-problem>)) ¶

Multiplicity of the right-hand side.

Source: pde-problem.lisp.
Target Slot: multiplicity.

Method: multiplicity ((vec <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: multiplicity ((tensor <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: multiplicity ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: multiplicity ((x vector)) ¶

Recursive definition.

Source: array-blas.lisp.

Method: multiplicity ((obj number)) ¶

Source: number-blas.lisp.

Method: multiplicity ((vec <matrix>)) ¶

If @arg{vec} should be a matrix, the multiplicity is the number of columns by default.

Source: matrix-methods.lisp.

Method: multiplicity (vec) ¶

The default is a multiplicity of 1.

Source: vector-methods.lisp.

Generic Function: mzerop (x &optional threshold) ¶

Returns T if each entry of @arg{x} is smaller or equal than @arg{threshold}.

Package

Source

Methods

Method: mzerop :around (mat &optional threshold) ¶

We do not allow parallelization of mzerop, because threads cannot handle non-local jumps.

Source: sparse-vector.lisp.

Method: mzerop ((mat standard-matrix) &optional threshold) ¶

Source: standard-matrix.lisp.

Method: mzerop ((x number) &optional threshold) ¶

Tests if the number @arg{x} is lower or equal to @arg{threshold}.

Source: number-blas.lisp.

Method: mzerop (mat &optional threshold) ¶

The default method should work for every matrix.

Source: vector-methods.lisp.

Generic Function: ncols (mat) ¶

Number of matrix columns.

Package

Source

Methods

Method: ncols ((svec <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: ncols ((cm compressed-matrix)) ¶

Source: compressed.lisp.

Method: ncols ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: ncols ((seq sequence)) ¶

For sequences @function{ncols} returns identically 1.

Source: array-blas.lisp.

Method: ncols ((obj number)) ¶

Source: number-blas.lisp.

Method: ncols ((mat <submatrix>)) ¶

Source: matrix-methods.lisp.

Method: ncols ((mat <matrix>)) ¶

Default and very inefficient method for computing the number of columns of a matrix.

Source: matrix-methods.lisp.

Generic Function: next-step (iter blackboard) ¶

Does a step of the iteration.

Package

Source

Methods

Method: next-step ((rothe <rothe>) blackboard) ¶

Do one time step by solving the stationary problem.

Source: rothe.lisp.

Method: next-step ((fe-strategy <fe-approximation>) blackboard) ¶

Enlarges the ansatz space.

Source: fe-approximation.lisp.

Method: next-step ((lobpcg <lobpcg>) blackboard) ¶

Source: evpsolve.lisp.

Method: next-step ((wielandt <wielandt-iteration>) blackboard) ¶

Simply calls the linear solver on the linearized problem.

Source: evpsolve.lisp.

Method: next-step ((newton <newton>) blackboard) ¶

Simply calls the linear solver on the linearized problem.

Source: nlsolve.lisp.

Method: next-step ((itsolve <linear-solver>) blackboard) ¶

Stepping for a linear solver.

Source: linsolve.lisp.

Method: next-step :after ((iter <iteration>) blackboard) ¶: Increment step counter.

Method: next-step ((iter <iteration>) blackboard) ¶

Generic Function: norm (x &optional p) ¶

Returns the @arg{p}-norm of @arg{x}.

Package

Source

Methods

Method: norm ((x <sparse-vector>) &optional p) ¶

Source: sparse-vector.lisp.

Method: norm (x &optional p) ¶

Source: vector-methods.lisp.

Generic Function: nr-of-components (problem) ¶

Returns the number of components for @arg{problem}.

Package

Source

Methods

Method: nr-of-components ((as <ansatz-space>)) ¶

Source: ansatz-space.lisp.

Method: nr-of-components ((vecfe-disc <vector-fe-discretization>)) ¶

Source: ansatz-space.lisp.

Method: nr-of-components ((fe-disc <scalar-fe-discretization>)) ¶

Source: ansatz-space.lisp.

Method: nr-of-components ((fe <vector-fe>)) ¶

Source: fe.lisp.

Method: nr-of-components ((fe <scalar-fe>)) ¶

For scalar components the number of components is 1.

Source: fe.lisp.

Method: nr-of-components ((problem <domain-problem>)) ¶: Counts the number of components.

Generic Function: nr-of-components-of-problem (problem domain) ¶

Returns the number of components a problem should have
which is known for many problems. A return value of NIL means that the number is not clear.

Package

Source

Methods

Method: nr-of-components-of-problem ((problem (eql fl.navier-stokes:<navier-stokes-problem>)) (domain <domain>)) ¶

Source: navier-stokes.lisp.

Method: nr-of-components-of-problem ((problem (eql fl.elasticity:<elasticity-problem>)) (domain <domain>)) ¶

Source: elasticity.lisp.

Method: nr-of-components-of-problem ((problem (eql fl.cdr:<cdr-problem>)) (domain <domain>)) ¶

A convection-diffusion-reaction equation has only 1 component - at least at the moment.

Source: cdr.lisp.

Method: nr-of-components-of-problem ((problem <pde-problem>) domain) ¶

Method: nr-of-components-of-problem ((problem symbol) domain) ¶

Generic Function: nr-of-dofs (fe) ¶

Number of degrees of freedom for the (vector) finite element.

Package

Source

Methods

Method: nr-of-dofs ((fe <vector-fe>)) ¶

Method: nr-of-dofs ((fe <scalar-fe>)) ¶

Generic Function: nr-of-entries (vector) ¶

Total number of (block) entries for vectors.

Package

Source

Methods

Method: nr-of-entries (obj) ¶

Source: vector-methods.lisp.

Generic Function: nr-of-inner-dofs (fe) ¶

Number of inner degrees of freedom for the (vector) finite element.

Package

Source

Methods

Method: nr-of-inner-dofs ((fe <vector-fe>)) ¶

Method: nr-of-inner-dofs ((fe <scalar-fe>)) ¶

Generic Function: nrows (mat) ¶

Number of matrix rows.

Package

Source

Methods

Method: nrows ((cm compressed-matrix)) ¶

Source: compressed.lisp.

Method: nrows ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: nrows ((seq sequence)) ¶

For sequences @function{nrows} is equivalent to @function{length}.

Source: array-blas.lisp.

Method: nrows ((obj number)) ¶

Source: number-blas.lisp.

Method: nrows ((mat <submatrix>)) ¶

Source: matrix-methods.lisp.

Method: nrows ((mat <matrix>)) ¶

Default and very inefficient method for computing the number of rows of a matrix.

Source: matrix-methods.lisp.

Generic Function: number-of-nonzero-entries (pattern) ¶

Number of nonzero entries of a sparse matrix pattern.

Package

Source

Methods

Method: number-of-nonzero-entries ((pattern compressed-pattern)) ¶

Generic Function: origin (cell) ¶

Returns cell origin in global coordinates.

Package

Source

Methods

Method: origin (cell) ¶: Default method.

Generic Function: partial-degree (poly index) ¶

Partial degree in variable INDEX of a multivariate polynomial.

Package

Source

Methods

Method: partial-degree ((list list) (index integer)) ¶

Method: partial-degree ((poly polynomial) (index integer)) ¶

Generic Reader: pattern (object) ¶

Package

Methods

Reader Method: pattern ((compressed-matrix compressed-matrix)) ¶

A compressed pattern.

Source: compressed.lisp.
Target Slot: pattern.

Generic Function: plot (object &key range cells mesh domain parametric depth key refinements coefficient rank shape index component transformation part program &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.

Package

fl.plot.

Source

plot.lisp.

Methods

Method: plot ((array array) &key &allow-other-keys) ¶

Source: plot-gnuplot.lisp.

Method: plot ((f function) &key range &allow-other-keys) ¶

Plot a real function similar to Gnuplot/Octave.

Source: plot-gnuplot.lisp.

Method: plot ((mat standard-matrix) &key &allow-other-keys) ¶

Plot a 2xn matrix similar to Gnuplot/Octave.

Source: plot-gnuplot.lisp.

Method: plot ((polygons list) &rest rest &key &allow-other-keys) ¶

Source: plot-gnuplot.lisp.

Method: plot ((asa <ansatz-space-automorphism>) &rest rest) ¶

Source: asaplot.lisp.

Method: plot ((f <function>) &rest rest &key cells mesh domain parametric depth key refinements &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.

Source: function-plot.lisp.

Method: plot ((problem <pde-problem>) &rest rest &key mesh refinements depth key parametric coefficient rank shape &allow-other-keys) ¶

Plots a coefficient function for the problem on the given mesh. Does handle coefficients depending on finite element functions.

Source: coeffplot.lisp.

Method: plot ((asv <ansatz-space-vector>) &rest rest &key cells depth index component key transformation part &allow-other-keys) ¶

Plots a certain component of the ansatz space vector @arg{asv},
e.g. pressure for Navier-Stokes equations. @arg{component} may also be a list of components. @arg{index} chooses one of several solutions if @arg{asv} has multiplicity larger 1.

Source: feplot.lisp.

Method: plot ((cell <cell>) &rest rest) ¶

Source: meshplot.lisp.

Method: plot ((skel <skeleton>) &rest rest &key transformation &allow-other-keys) ¶

Source: meshplot.lisp.

Method: plot (object &rest key-args &key program &allow-other-keys) ¶: Default method which might be overridden by other, e.g. for preprocessing the keyword argument list.

Method: plot :around (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.

Generic Function: poly* (p1 p2) ¶

Multiplies two polynomials P1 and P2.

Package

Source

Methods

Method: poly* ((f number) (g number)) ¶

Method: poly* ((f number) (g list)) ¶

Method: poly* ((g list) (f number)) ¶

Method: poly* ((f number) (g polynomial)) ¶

Method: poly* ((g polynomial) (f number)) ¶

Method: poly* ((f list) (g list)) ¶: The assumption is that f and g are coefficient lists with the same variance.

Method: poly* ((f polynomial) (g polynomial)) ¶

Generic Function: poly-expt (p n) ¶

Raises the polynomial P to power N.

Package

Source

Methods

Method: poly-expt ((list list) (n integer)) ¶

Method: poly-expt ((poly polynomial) (n integer)) ¶

Generic Reader: post-steps (object) ¶

Package

Methods

Reader Method: post-steps ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: post-steps.

Generic Reader: pre-steps (object) ¶

Package

Methods

Reader Method: pre-steps ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: pre-steps.

Generic Function: preprocess-matrix (amg mat) ¶

Eliminates Dirichlet or slave degrees of freedom which can be handled well by smoothing.

Package

Source

Methods

Method: preprocess-matrix ((amg <algebraic-mg>) mat) ¶: Default method which eliminates slave nodes and Dirichlet nodes for sparse matrices.

Generic Function: problem (object) ¶

Package

Methods

Method: problem ((aso <ansatz-space-object>)) ¶

Source: ansatz-space.lisp.

Reader Method: problem ((<ansatz-space> <ansatz-space>)) ¶

The proplem for this ansatz space which determines essential constraints.

Source: ansatz-space.lisp.
Target Slot: problem.

Generic Function: prolongation (amg mat) ¶

Computes a prolongation matrix from amg and mat. This is often the essence of an AMG method.

Package

Source

Methods

Method: prolongation ((amg <s1-reduction>) (mat <ansatz-space-automorphism>)) ¶

Transfer to S1 finite elements.

Source: geomg.lisp.

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.

Generic Reader: properties (object) ¶

Generic Writer: (setf properties) (object) ¶

Package

Methods

Reader Method: properties ((property-mixin property-mixin)) ¶

Writer Method: (setf properties) ((property-mixin property-mixin)) ¶

A property list for storing unstructured information about this object.

Source: general.lisp.
Target Slot: properties.

Generic Function: put-in-pool (pool key object) ¶

Put an object into the pool.

Package

Source

Methods

Method: put-in-pool ((pool thread-safe-pool) key object) ¶

Method: put-in-pool ((pool pool) key object) ¶

Generic Function: quadrature-rule (fe) ¶

Computes the quadrature rule to be used for the finite element @arg{fe}.

Package

Source

Methods

Method: quadrature-rule ((fe <fe>)) ¶: Standard quadrature rule for fe.

Generic Function: r-insert (r &rest items) ¶

Insert items in R.

Package

Source

Methods

Method: r-insert :around ((r eql-relation) &rest items) ¶

Method: r-insert :before ((r relation) &rest items) ¶

Method: r-insert ((r relation) &rest items) ¶

Generic Function: r-remove (r &rest items) ¶

Remove items from R.

Package

Source

Methods

Method: r-remove (r &rest items) ¶

Generic Function: r-select (r &rest select-items) ¶

Selects a range of tuples from the relation R.

Package

Source

Methods

Method: r-select ((r eql-relation) &rest items) ¶

Method: r-select (r &rest select-items) ¶

Generic Function: r-some (r &rest select-items) ¶

Checks if there exists some entry in R with this specification.

Package

Source

Methods

Method: r-some (r &rest select-items) ¶

Generic Function: rank (tensor) ¶

Rank of a tensor.

Package

Source

Methods

Method: rank ((tensor <sparse-tensor>)) ¶

Source: sparse-tensor.lisp.

Method: rank ((tensor full-tensor)) ¶

Source: tensor.lisp.

Method: rank ((vec <vector>)) ¶

Vectors have rank 1.

Source: vector-methods.lisp.

Generic Function: reference (vec iterator) ¶

Reader for the element of @arg{vec} referenced by @arg{iterator}.

Package

Source

Methods

Method: reference ((range range) i) ¶

Method: reference ((vec vector) i) ¶

Method: reference ((vec list) tail) ¶

Generic Function: (setf reference) (vec iterator) ¶

Setter for the element of @arg{vec} referenced by @arg{iterator}.

Package

Source

Methods

Method: (setf reference) ((vec vector) i) ¶

Method: (setf reference) ((vec list) tail) ¶

Generic Function: reference-cell (cell-or-class) ¶

Returns the cell’s or cell-classes reference-cell.

Package

Source

Methods

Reader Method: reference-cell ((<fe> <fe>)) ¶

automatically generated reader method

Source: fe.lisp.
Target Slot: refcell.

Reader Method: reference-cell ((refinement-rule refinement-rule)) ¶

Reference cell for this refinement rule.

Source: refine.lisp.
Target Slot: refcell.

Method: reference-cell ((cell <cell>)) ¶

Method: reference-cell ((class standard-class)) ¶: Returns the cell information also when called for a cell class.

Generic Function: refine (skel &key indicator highest decouple &allow-other-keys) ¶

Refines @arg{skel} either locally or globally depending on the @function{indicator}.

Package

Source

Methods

Method: refine ((h-mesh <hierarchical-mesh>) &key indicator highest) ¶

Refine a hierarchical-mesh. When the argument ’test’ is supplied, all cells satisfying the test are refined.

Source: mesh.lisp.

Method: refine ((skel <skeleton>) &key indicator highest decouple) ¶: 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.

Generic Function: remove-column (smat col-key) ¶

Removes a column of @arg{smat}.

Package

Source

Methods

Method: remove-column ((smat <sparse-matrix>) col-key) ¶

Generic Function: remove-key (sobj &rest indices) ¶

Remove the entry for @arg{key} from the sparse object.

Package

Source

Methods

Method: remove-key ((smat <sparse-dictionary-matrix>) &rest indices) ¶

Source: sparse-matrix.lisp.

Method: remove-key ((svec <sparse-dictionary-vector>) &rest indices) ¶

Generic Function: remove-projection-range (mat projection &key row-p column-p &allow-other-keys) ¶

Package

Source

Methods

Method: remove-projection-range ((mat <matrix>) projection &key row-p column-p) ¶

Method: remove-projection-range ((vec <vector>) projection &key &allow-other-keys) ¶

Generic Function: remove-row (smat row-key) ¶

Removes a row of @arg{smat}.

Package

Source

Methods

Method: remove-row ((smat <sparse-matrix>) row-key) ¶

Generic Function: representative (obj) ¶

Returns a representative for this object.

Package

Source

identify.lisp.

Methods

Method: representative (obj) ¶: This default method returns the object itself.

Method: representative ((id identification)) ¶: Gets a representative cell for this identification.

Generic Function: restriction (amg mat prol) ¶

Compute a restriction matrix from amg, mat and prolongation.

Package

Source

Methods

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.

Generic Reader: rhs (object) ¶

Package

Methods

Reader Method: rhs ((<lse> <lse>)) ¶

automatically generated reader method

Source: problem.lisp.
Target Slot: rhs.

Generic Function: row-key->size (smat) ¶

Package

Source

Methods

Method: row-key->size ((asm <ansatz-space-morphism>)) ¶

Source: sparseas.lisp.

Reader Method: row-key->size ((<block-definition-mixin> <block-definition-mixin>)) ¶

automatically generated reader method

Target Slot: row-key->size.

Method: row-key->size ((smat <sparse-matrix>)) ¶

Generic Function: row-keys (mat) ¶

All row keys for a matrix.

Package

Source

Methods

Method: row-keys ((mat <sparse-dictionary-matrix>)) ¶

Source: sparse-matrix.lisp.

Reader Method: row-keys ((<submatrix> <submatrix>)) ¶

The row indices of the submatrix.

Target Slot: row-keys.

Method: row-keys ((mat <matrix>)) ¶

Generic Reader: row-table (object) ¶

Generic Writer: (setf row-table) (object) ¶

Package

Methods

Reader Method: row-table ((<ht-sparse-matrix> <ht-sparse-matrix>)) ¶

Writer Method: (setf row-table) ((<ht-sparse-matrix> <ht-sparse-matrix>)) ¶

Table of rows

Source: sparse-matrix.lisp.
Target Slot: row-table.

Reader Method: row-table ((<sparse-dictionary-matrix> <sparse-dictionary-matrix>)) ¶

Writer Method: (setf row-table) ((<sparse-dictionary-matrix> <sparse-dictionary-matrix>)) ¶

Table of row dictionaries.

Source: sparse-matrix.lisp.
Target Slot: row-table.

Generic Function: row<-id (a key) ¶

Set the row of matrix A defined by KEY to identity

Package

Source

Methods

Method: row<-id ((a <sparse-matrix>) key) ¶

Generic Function: scal! (alpha x) ¶

X <- alpha X

Package

Source

Methods

Method: scal! (val (poly polynomial)) ¶

Source: polynom.lisp.

Method: scal! (val (array array)) ¶

Call @function{scal!} on each entry of @var{array}.

Source: array-blas.lisp.

Method: scal! (val (lst list)) ¶

Call @function{scal!} on each entry of @var{lst}. Note that the result has to be freshly consed, because @function{scal!} is a function, not a macro.

Source: array-blas.lisp.

Method: scal! (s (x number)) ¶

Source: number-blas.lisp.

Method: scal! ((alpha number) (x static-store-vector)) ¶

Source: store-vector.lisp.

Method: scal! (s x) ¶

Source: vector-methods.lisp.

Generic Function: scalar-type (vector) ¶

Type of the scalars for the vector class.

Package

Source

Methods

Method: scalar-type ((smat <sparse-matrix>)) ¶

Source: sparse-matrix.lisp.

Method: scalar-type ((svec <sparse-vector>)) ¶

Source: sparse-vector.lisp.

Method: scalar-type ((vector (store-vector⎵double-float⎵dynamic⎵nil))) ¶

Method: scalar-type ((x vector)) ¶

Source: array-blas.lisp.

Method: scalar-type (vec) ¶

Default method returns NUMBER.

Source: vector-methods.lisp.

Generic Function: select-discretization (problem blackboard) ¶

Select a discretization for the given @var{problem} depending on the parameters on the @var{blackboard}.

Package

Source

discretization.lisp.

Methods

Method: select-discretization ((problem <navier-stokes-problem>) blackboard) ¶

Source: navier-stokes-fe.lisp.

Method: select-discretization ((problem <multiphysics-problem>) blackboard) ¶

Source: ellsys-fe.lisp.

Method: select-discretization ((problem <ellsys-problem>) blackboard) ¶

Source: ellsys-fe.lisp.

Method: select-discretization (problem blackboard) ¶

Method: select-discretization :around (problem blackboard) ¶: Forces the use of a discretization on the blackboard.

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.

Package

Source

Methods

Method: select-linear-solver ((problem <navier-stokes-problem>) blackboard) ¶

Source: gps.lisp.

Method: select-linear-solver ((problem <elasticity-problem>) blackboard) ¶

Source: gps.lisp.

Method: select-linear-solver ((problem <cdr-problem>) blackboard) ¶

Source: gps.lisp.

Method: select-linear-solver ((asa <ansatz-space-automorphism>) blackboard) ¶

Select a suitable solver depending on the pde problem.

Source: sparseas.lisp.

Method: select-linear-solver ((lse <lse>) blackboard) ¶

Select linear solver based on the matrix.

Source: linsolve.lisp.

Method: select-linear-solver (object blackboard) ¶

Default method selects LU decomposition.

Source: linsolve.lisp.

Method: select-linear-solver :around (object blackboard) ¶: If a linear solver is on the blackboard, use it.

Generic Function: select-smoother (mg-it matrix) ¶

Select a suitable smoother depending on multigrid iteration and matrix.

Package

Source

Methods

Method: select-smoother (mgit (problem <navier-stokes-problem>)) ¶

For discretized Navier-Stokes system, we use Vanka type smoothing.

Source: geomg.lisp.

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.

Source: geomg.lisp.

Method: select-smoother (mgit (matrix <ansatz-space-automorphism>)) ¶

Choose the smoothing method as either Gauss-Seidel or SSC depending on discretization order.

Source: geomg.lisp.

Method: select-smoother (mg-it matrix) ¶: Returns the Gauss-Seidel method as default smoother.

Generic Function: select-solver (object blackboard) ¶

Selects a solver for OBJECT. OBJECT is usually a problem with certain characteristics.

Package

Source

Methods

Method: select-solver ((problem <time-dependent-problem>) blackboard) ¶

Source: rothe.lisp.

Method: select-solver ((problem <pde-problem>) blackboard) ¶

Source: fe-stationary.lisp.

Method: select-solver ((problem <evp>) blackboard) ¶

Source: evpsolve.lisp.

Method: select-solver ((problem <nonlinear-problem>) blackboard) ¶

Source: nlsolve.lisp.

Method: select-solver ((lse <lse>) blackboard) ¶

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 :around (object blackboard) ¶: If a solver is on the blackboard, use it.

Method: select-solver (object blackboard) ¶

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.

Package

Source

Methods

Method: self-adjoint-p ((problem <ellsys-problem>)) ¶

The problem is assumed to be self-adjoint if there are no first order coefficients.

Source: ellsys.lisp.

Method: self-adjoint-p ((problem <time-dependent-problem>)) ¶

Source: time.lisp.

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: send-graphic-commands (object program &rest rest &key left right top bottom border tics grid xlabel ylabel fontsize terminal output message dimension background resolution width height format filename window &allow-other-keys) ¶

Routine for sending commands to the graphics server.

Package

Source

Methods

Method: send-graphic-commands (object (program (eql :gnuplot)) &rest paras &key left right top bottom border tics grid xlabel ylabel fontsize terminal output &allow-other-keys) ¶

Output can be a path or a string. A string is interpreted as a file name relative to (images-pathname).

Source: gnuplot.lisp.

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.

Source: vtk.lisp.

Method: send-graphic-commands (object (program (eql :dx)) &rest paras &key dimension background resolution width height format filename window &allow-other-keys) ¶

Source: dx.lisp.

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.

Package

Source

Methods

Method: set-global-to-local-mat ((smat <sparse-matrix>) local-mat (cell <cell>) &optional domain-cell) ¶

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.

Package

Source

Methods

Method: set-global-to-local-vec ((cell <cell>) (svec <sparse-vector>) local-vec) ¶

Generic Function: set-svec-to-local-block (svec local-vec &optional keys ranges) ¶

Copies a local block in matlisp format into a <sparse-vector>.

Package

Source

Methods

Method: set-svec-to-local-block ((svec <sparse-vector>) local-vec &optional keys ranges) ¶

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.

Package

Source

Methods

Method: setup-blocks ((vanka <vanka>) (asa <ansatz-space-automorphism>)) ¶

Adds to the usual vertex centered blocks all surrounding velocity degrees of freedom.

Source: vanka.lisp.

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.

Source: geoblock.lisp.

Method: setup-blocks ((blockit <setup-blocks-mixin>) (smat <sparse-matrix>)) ¶: Use the setup function.

Method: setup-blocks :around ((blockit <block-iteration>) (smat <sparse-matrix>)) ¶: A default around method for block setup does debugging output.

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.

Generic Function: shift-polynomial (poly shift &optional from) ¶

Shifts a polynomial in dimension, i.e. variables starting from index k>=@arg{from} get index k+shift.

Package

Source

Methods

Method: shift-polynomial ((poly number) shift &optional from) ¶

Method: shift-polynomial ((poly list) shift &optional from) ¶

Method: shift-polynomial ((poly polynomial) shift &optional from) ¶

Generic Function: shift-tensor (tensor offsets) ¶

Shifts the index range of a sparse tensor or a vector.
Offsets can either be a number in which case all indices are shifted by this number or a list of the length of the tensor rank which specifies the shift for each dimension.

Package

Source

Methods

Method: shift-tensor (tensor (offsets number)) ¶

Method: shift-tensor (tensor (offsets list)) ¶

Method: shift-tensor ((vec vector) offsets) ¶: Treats the vector as a rank-1-tensor with a special index range.

Method: shift-tensor ((tensor <sparse-tensor>) offsets) ¶

Generic Function: show (matrix &key keys zeros stream &allow-other-keys) ¶

Shows the contents of @arg{matrix} in a readable form.

Package

Source

Methods

Method: show ((pq priority-queue) &key &allow-other-keys) ¶

Source: triangle.lisp.

Method: show ((smat <sparse-matrix>) &key keys zeros &allow-other-keys) ¶

Source: sparse-matrix.lisp.

Method: show ((svec <sparse-vector>) &key keys zeros &allow-other-keys) ¶

Source: sparse-vector.lisp.

Method: show ((a compressed-matrix) &key stream) ¶

Source: compressed.lisp.

Method: show ((tensor <sparse-tensor>) &key &allow-other-keys) ¶

Source: sparse-tensor.lisp.

Method: show :around (matrix &key &allow-other-keys) ¶

Method: show (matrix &key stream &allow-other-keys) ¶: The default method describes its argument.

Generic Reader: sizes (object) ¶

Package

Methods

Reader Method: sizes ((compressed-pattern compressed-pattern)) ¶

Vector of matrix sizes, at the moment only length
2 is allowed here. The first is the dimension which is not compressed, the second is the dimension which gets compressed.

Source: compressed.lisp.
Target Slot: sizes.

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.

Package

Source

Methods

Method: skel-map (func skel) ¶

Generic Function: skeleton (cell-or-cells) ¶

Returns a skeleton for the given cell or the given cells.

Package

Source

Methods

Method: skeleton ((cell <cell>)) ¶

Source: skeleton.lisp.

Method: skeleton ((cells sequence)) ¶

Source: skeleton.lisp.

Generic Function: slice (tensor fixed) ¶

Slices @arg{tensor}. @arg{fixed} determines which indices are fixed.

Package

Source

Methods

Method: slice ((tensor full-tensor) index-settings) ¶

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.

Package

Source

Methods

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.

Source: gps.lisp.

Method: solve ((strategy <strategy>) &optional blackboard) ¶

Solves the problem on the blackboard using the given strategy.

Source: strategy.lisp.

Method: solve ((solver <special-solver>) &optional blackboard) ¶

Source: linsolve.lisp.

Method: solve ((itsol <iterative-solver>) &optional blackboard) ¶

Generic Function: sparse-ldu (a &key ordering incomplete omega diagonal-inverter pool &allow-other-keys) ¶

Sparse LDU decomposition

Package

Source

Methods

Method: sparse-ldu ((a <sparse-matrix>) &key ordering incomplete omega diagonal-inverter pool) ¶

Source: sparselu.lisp.

Generic Function: sparse-m* (a b &key job sparsity) ¶

Sparse matrix-matrix or matrix-vector multiplication.
Usually, m* should be used. But in situations, where A or B are very sparse, the complexity of this routine is much lower.

Package

Source

Methods

Method: sparse-m* ((a <sparse-matrix>) (b <sparse-matrix>) &key job sparsity) ¶

Method: sparse-m* ((a <sparse-matrix>) (b <sparse-vector>) &key job sparsity) ¶

Generic Function: sparse-matrix->matlisp (mat &key keys row-keys col-keys ranges row-ranges col-ranges &allow-other-keys) ¶

Converts sparse matrices into matlisp format.

Package

Source

Methods

Method: sparse-matrix->matlisp ((a <sparse-matrix>) &key keys row-keys col-keys ranges row-ranges col-ranges) ¶

Generic Reader: start-time (object) ¶

Package

Methods

Reader Method: start-time ((<time-dependent-problem> <time-dependent-problem>)) ¶

The start time of the problem (NIL=unspecified).

Source: time.lisp.
Target Slot: start-time.

Generic Reader: stiffness-matrix (object) ¶

Package

Methods

Reader Method: stiffness-matrix ((<ls-evp> <ls-evp>)) ¶

automatically generated reader method

Source: evp.lisp.
Target Slot: stiffness-matrix.

Generic Function: store (object) ¶

Package

Methods

Method: store ((seq sequence)) ¶

For sequences @function{store} is identity.

Source: array-blas.lisp.

Reader Method: store ((store-vector store-vector)) ¶

The vector entries.

Source: store-vector.lisp.
Target Slot: store.

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}.

Package

Source

Methods

Method: subcells ((cell <boundary-cell>)) ¶

Source: triangulate.lisp.

Generic Function: submatrix (mat &key row-indices col-indices) ¶

General extraction of submatrices specified by non-adjacent lists of row- and column indices.

Package

Source

Methods

Method: submatrix ((mat standard-matrix) &key row-indices col-indices) ¶

Source: compat.lisp.

Generic Reader: subproblems (object) ¶

Package

Methods

Reader Method: subproblems ((<multiphysics-mixin> <multiphysics-mixin>)) ¶

automatically generated reader method

Source: pde-problem.lisp.
Target Slot: subproblems.

Generic Function: subskeleton (skel test) ¶

Returns a minimal skeleton containing the cells satisfying the test.

Package

Source

skeleton-build.lisp.

Methods

Method: subskeleton ((skel <skeleton>) test) ¶

Generic Function: t* (tensor1 tensor2 contraction-pairs) ¶

Contracts TENSOR1 and TENSOR2 along the pairs of indices specified by CONTRACTION-PAIRS.

Package

Source

Methods

Method: t* ((tensor1 full-tensor) (tensor2 full-tensor) contraction-pairs) ¶

Generic Function: tensor-for-each (func tensor &key job depth &allow-other-keys) ¶

Applies @arg{func} to each index of @arg{tensor} up to @arg{depth}. @arg{job} can be :entry, :index, or :both.

Package

Source

Methods

Method: tensor-for-each (func (mat standard-matrix) &key job &allow-other-keys) ¶

Method: tensor-for-each (func (tensor <sparse-tensor>) &key job depth) ¶

Generic Function: tensor-map (func tensor) ¶

Maps @arg{tensor} with @arg{func} to a tensor of the same type.

Package

Source

Methods

Method: tensor-map (func tensor) ¶: Default method.

Generic Function: tensor-ref (tensor &rest indices) ¶

Reader for a tensor entry.

Package

Source

Methods

Method: tensor-ref ((tensor <sparse-tensor>) &rest indices) ¶

Source: sparse-tensor.lisp.

Method: tensor-ref ((tensor full-tensor) &rest indices) ¶

Method: tensor-ref ((mat standard-matrix) &rest indices) ¶

Method: tensor-ref ((vec vector) &rest indices) ¶

Method: tensor-ref (object &rest indices) ¶

Method: tensor-ref :around (object &rest indices) ¶

Generic Function: (setf tensor-ref) (x &rest indices) ¶

Writer for a tensor entry.

Package

Source

Methods

Method: (setf tensor-ref) ((tensor <sparse-tensor>) &rest indices) ¶

Source: sparse-tensor.lisp.

Method: (setf tensor-ref) ((tensor full-tensor) &rest indices) ¶

Method: (setf tensor-ref) ((mat standard-matrix) &rest indices) ¶

Method: (setf tensor-ref) ((vec vector) &rest indices) ¶

Generic Function: terminate-p (iter blackboard) ¶

Tests terminating conditions. Returns either NIL or :success or :failure.

Package

Source

Methods

Method: terminate-p ((fe-strategy <fe-approximation>) blackboard) ¶

Sets some variables before passing control to the check of termination criteria.

Source: fe-approximation.lisp.

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.

Source: linsolve.lisp.

Method: terminate-p ((iter <iteration>) blackboard) ¶: Default method evaluating success-if and failure-if expressions.

Generic Function: time-dependent-problem-class (problem) ¶

Package

Source

time.lisp.

Methods

Method: time-dependent-problem-class ((problem <time-dependent-problem>)) ¶

Method: time-dependent-problem-class (problem) ¶

Generic Function: top-level (mh) ¶

Top-level of a mesh hierarchy.

Package

Source

Methods

Reader Method: top-level ((<refinement-indicator> <refinement-indicator>)) ¶

If top-level is set, no refinement beyond top-level is indicated.

Source: error-indicator.lisp.
Target Slot: top-level.

Method: top-level ((mm <hierarchical-mesh>)) ¶

Generic Function: total-degree (poly) ¶

Degree of a multivariate polynomial

Package

Source

Methods

Method: total-degree ((poly polynomial)) ¶

Generic Function: total-entries (vector) ¶

Total number of entries for block vectors.

Package

Source

Methods

Method: total-entries ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: total-entries ((obj number)) ¶

Source: number-blas.lisp.

Method: total-entries (obj) ¶

Source: vector-methods.lisp.

Generic Function: total-nrows (mat) ¶

Total number of rows for a matrix (works also for block matrices).

Package

Source

Methods

Method: total-nrows (mat) ¶

Method: total-nrows ((mat <sparse-matrix>)) ¶

Generic Function: transpose (x) ¶

Transpose the matrix @arg{x}.

Package

Source

Methods

Method: transpose ((cm compressed-matrix)) ¶

A compressed matrix can be transposed easily by transposing its pattern.

Source: compressed.lisp.

Method: transpose (x) ¶: The default method casts performs a combination of @function{transpose!} and @function{matrix-transpose-instance}.

Generic Function: transpose! (x y) ¶

Sets Y to the transpose of X.

Package

Source

Methods

Method: transpose! ((x <sparse-matrix>) (y <sparse-matrix>)) ¶

Source: sparse-matrix.lisp.

Method: transpose! ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Generic Function: transposed-pattern (pattern) ¶

Transpose a sparse matrix pattern.

Package

Source

Methods

Method: transposed-pattern ((pattern compressed-pattern)) ¶

Generic Function: unit? (x) ¶

Package

Source

Methods

Method: unit? ((x number)) ¶

Method: unit? ((list list)) ¶

Method: unit? ((poly polynomial)) ¶

Generic Function: variance (poly) ¶

Number of variables on which a polynomial depends.

Package

Source

Methods

Method: variance ((coeffs number)) ¶

Method: variance ((coeffs list)) ¶: Nestedness of the list calculated by walking down depth-first.

Method: variance ((poly polynomial)) ¶

Generic Function: vector-block (svec key) ¶

Low-level key lookup. Returns NIL if there is no block at this position.

Package

Source

Methods

Method: vector-block ((svec <sparse-dictionary-vector>) key) ¶

Generic Function: (setf vector-block) (svec key) ¶

Low-level insertion of a block without checks.

Package

Source

Methods

Method: (setf vector-block) ((svec <sparse-dictionary-vector>) key) ¶

Generic Function: vector-slice (x offset size) ¶

Extract a subvector of size @arg{size} out of @arg{x} starting from position @arg{offset}.

Package

Source

Methods

Method: vector-slice ((vec vector) offset size) ¶

Provides a convenient shorthand for constructing a displaced double-float array.

Source: compat.lisp.

Method: vector-slice ((mat standard-matrix) offset size) ¶

Source: standard-matrix-blas.lisp.

Generic Reader: vertex-position (object) ¶

Package

Methods

Reader Method: vertex-position ((<vertex> <vertex>)) ¶

automatically generated reader method

Source: cell.lisp.
Target Slot: position.

Generic Function: vertices (cell) ¶

Returns a list of all vertices of the cell.

Package

Source

Methods

Method: vertices ((cell <product-cell>)) ¶

Source: product-cell.lisp.

Method: vertices ((simplex <simplex>)) ¶

Source: simplex.lisp.

Method: vertices ((vtx <vertex>)) ¶

Source: vertex.lisp.

Generic Function: vlength (vec) ¶

Length of vector.

Package

Source

Methods

Method: vlength ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: vlength ((seq sequence)) ¶

For sequences @function{vlength} is equivalent to @function{length}.

Source: array-blas.lisp.

Generic Function: vref (x i) ¶

Reader for @math{x_i}.

Package

Source

Methods

Method: vref ((svec <sparse-vector>) key) ¶

Source: sparse-vector.lisp.

Method: vref ((tensor tensor) indices) ¶

Source: tensor.lisp.

Method: vref ((vec array) (index list)) ¶

Source: array-blas.lisp.

Method: vref ((vec array) index) ¶

Source: array-blas.lisp.

Method: vref ((vec vector) index) ¶

Source: array-blas.lisp.

Method: vref ((obj number) k) ¶

Source: number-blas.lisp.

Method: vref ((submat <submatrix>) k) ¶

A @class{<submatrix>} can be accessed as one-dimensional vector.

Source: matrix-methods.lisp.

Method: vref ((mat <matrix>) (indices list)) ¶

Vector referencing on matrices is done by default by matrix referencing a list of indices.

Source: matrix-methods.lisp.

Method: vref ((vec store-vector) i) ¶

Note: access to entries using this generic function is slow. Therefore, specialized BLAS routines should be used whenever possible.

Source: store-vector.lisp.

Generic Function: (setf vref) (x i) ¶

Writer for @arg{x_i}.

Package

Source

Methods

Method: (setf vref) ((svec <sparse-vector>) key) ¶

Source: sparse-vector.lisp.

Method: (setf vref) ((tensor tensor) indices) ¶

Source: tensor.lisp.

Method: (setf vref) ((vec array) (index list)) ¶

Source: array-blas.lisp.

Method: (setf vref) ((vec array) index) ¶

Source: array-blas.lisp.

Method: (setf vref) ((vec vector) index) ¶

Source: array-blas.lisp.

Method: (setf vref) ((submat <submatrix>) k) ¶

Source: matrix-methods.lisp.

Method: (setf vref) ((mat <matrix>) (indices list)) ¶

Vector referencing on matrices is done by default by matrix referencing a list of indices.

Source: matrix-methods.lisp.

Method: (setf vref) ((vec store-vector) i) ¶

Writer for vref.

Source: store-vector.lisp.

Generic Function: zero (f) ¶

Generates a zero of the same kind as @arg{F}.

Package

Source

Methods

Method: zero ((f number)) ¶

Method: zero ((f list)) ¶

Method: zero ((f polynomial)) ¶

Generic Function: zero? (x) ¶

Package

Source

Methods

Method: zero? ((x number)) ¶

Method: zero? ((list list)) ¶

Method: zero? ((poly polynomial)) ¶

Next: Structures, Previous: Generic functions, Up: Public Interface [Contents][Index]

6.1.6 Standalone methods

Method: describe-object :after ((ppool parpool) stream) ¶

Source: pool.lisp.

Method: describe-object :after ((pool pool) stream) ¶

Source: pool.lisp.

Method: describe-object :after ((domain <domain>) stream) ¶

Source: domain.lisp.

Method: describe-object :after ((skel <skeleton>) stream) ¶

Source: skeleton.lisp.

Method: describe-object :after ((h-mesh <hierarchical-mesh>) stream) ¶

Source: mesh.lisp.

Method: describe-object ((blackboard blackboard) stream) ¶

Source: utilities.lisp.

Method: describe-object :after ((problem <domain-problem>) stream) ¶

Source: pde-problem.lisp.

Method: initialize-instance :after ((pool parpool) &key &allow-other-keys) ¶

Source: pool.lisp.

Method: initialize-instance :after ((dic small-cache-dictionary) &key &allow-other-keys) ¶

Source: dictionary.lisp.

Method: initialize-instance :after ((dic sorted-hash-table) &key &allow-other-keys) ¶

Source: dictionary.lisp.

Method: initialize-instance :after ((pool pool) &key &allow-other-keys) ¶

Source: pool.lisp.

Method: initialize-instance :after ((dic cache-dictionary) &key &allow-other-keys) ¶

Source: dictionary.lisp.

Method: initialize-instance :after ((dic thread-cached-dictionary) &key &allow-other-keys) ¶

Source: dictionary.lisp.

Method: initialize-instance :after ((iter <iteration>) &key &allow-other-keys) ¶

Source: iterate.lisp.

Method: initialize-instance :before ((instance <gauss-seidel>) &rest initargs) ¶

Source: linit.lisp.

Method: initialize-instance :after ((domain <domain>) &key &allow-other-keys) ¶

When a domain is constructed from a list of cells, we assume that its definition is finished and setup the boundary slot.

Source: domain.lisp.

Method: initialize-instance :after ((skel <skeleton>) &key cells &allow-other-keys) ¶

The etables-list has to be initialized. Furthermore, we allow a constructor by giving a cell-list.

Source: skeleton.lisp.

Method: initialize-instance ((mesh <mesh>) &key domain &allow-other-keys) ¶

When a mesh is constructed from a domain its dimension is taken as the domain dimension by default.

Source: mesh.lisp.

Method: initialize-instance :after ((cell <mapped-vertex>) &key &allow-other-keys) ¶

Source: vertex.lisp.

Method: initialize-instance :after ((problem <evp-mixin>) &key &allow-other-keys) ¶

Source: evp.lisp.

Method: initialize-instance :after ((problem <nonlinear-problem>) &key &allow-other-keys) ¶

Source: problem.lisp.

Method: initialize-instance :after ((lse <lse>) &key &allow-other-keys) ¶

Source: problem.lisp.

Method: initialize-instance :after ((lsevp <ls-evp>) &key &allow-other-keys) ¶

Source: evp.lisp.

Method: initialize-instance :after ((rothe <rothe>) &key &allow-other-keys) ¶

Source: rothe.lisp.

Method: initialize-instance :after ((f <linear-function>) &key &allow-other-keys) ¶

Source: function.lisp.

Method: initialize-instance :after ((polygon <polygon>) &key &allow-other-keys) ¶

Source: spline.lisp.

Method: initialize-instance :after ((f <special-function>) &key &allow-other-keys) ¶

Source: function.lisp.

Method: initialize-instance ((tensor full-tensor) &key &allow-other-keys) ¶

Source: tensor.lisp.

Method: initialize-instance :after ((pattern compressed-pattern) &key pattern &allow-other-keys) ¶

This is a more elaborate compressed-pattern constructor. A sparse matrix of the form @math{ | * 0 0 0 a | | 0 a 0 0 0 | } can be described by its sizes as a vector (dimension of non-compressed, dimension/compressed) together with the pattern ’( ((* . 0) (a . 4)) ((a . 1)) ). Here, * means a non-identified value. Other symbols can be used to identify entries.

Source: compressed.lisp.

Method: initialize-instance :after ((tensor <sparse-tensor>) &key initial-contents &allow-other-keys) ¶

Source: sparse-tensor.lisp.

Method: initialize-instance :after ((cm compressed-matrix) &key &allow-other-keys) ¶

Source: compressed.lisp.

Method: initialize-instance ((matrix standard-matrix) &key content &allow-other-keys) ¶

Handles the content parameter and sets the store to a suitable vector. If content is a 2d array, the dimensions can be deduced.

Source: standard-matrix.lisp.

Method: initialize-instance :after ((svec <ht-sparse-vector>) &key &allow-other-keys) ¶

Source: sparse-vector.lisp.

Method: initialize-instance :after ((smat <ht-sparse-matrix>) &key row-access-p column-access-p &allow-other-keys) ¶

Source: sparse-matrix.lisp.

Method: initialize-instance :after ((r relation) &key &allow-other-keys) ¶

Source: relations.lisp.

Method: initialize-instance :after ((fe <scalar-fe>) &key &allow-other-keys) ¶

Source: fe.lisp.

Method: initialize-instance :after ((vecfe <vector-fe>) &key &allow-other-keys) ¶

Source: fe.lisp.

Method: initialize-instance :after ((asv <ansatz-space-vector>) &rest args &key multiplicity &allow-other-keys) ¶

Source: sparseas.lisp.

Method: initialize-instance :after ((asa <ansatz-space-automorphism>) &rest args &key &allow-other-keys) ¶

Source: sparseas.lisp.

Method: initialize-instance :after ((asm <ansatz-space-morphism>) &rest args &key &allow-other-keys) ¶

Source: sparseas.lisp.

Method: initialize-instance :after ((as <ansatz-space>) &key &allow-other-keys) ¶

Source: ansatz-space.lisp.

Method: initialize-instance :after ((disc <vector-fe-discretization>) &key &allow-other-keys) ¶

If the slot @symbol{cell->fe} is unbound, it is derived from the components vector.

Source: ansatz-space.lisp.

Method: initialize-instance :after ((problem <ellsys-problem>) &key start-time end-time &allow-other-keys) ¶

Source: ellsys.lisp.

Method: print-object :after ((iter <preconditioned-krylow>) stream) ¶

Source: krylow.lisp.

Method: print-object :after ((refrule refinement-rule) stream) ¶

Source: refine.lisp.

Method: print-object :after ((cell <cell>) stream) ¶

Printing cells.

Source: cell.lisp.

Method: print-object :after ((id identification) stream) ¶

Print the cells in the identification.

Source: identify.lisp.

Method: print-object :after ((coeff <coefficient>) stream) ¶

Prints the coefficient name.

Source: pde-problem.lisp.

Method: print-object ((poly polynomial) stream) ¶

Source: polynom.lisp.

Method: print-object ((tensor full-tensor) stream) ¶

Source: tensor.lisp.

Method: print-object :after ((svec <sparse-vector>) stream) ¶

Source: sparse-vector.lisp.

Method: print-object ((matrix standard-matrix) stream) ¶

Source: standard-matrix.lisp.

Method: shared-initialize ((problem <navier-stokes-problem>) slot-names &key &allow-other-keys) ¶

Insert default component names u and p. This is a questionable feature, because it may interfere with other names. Therefore it might be removed later on. It is also suspect, that we cannot define it as an after method, because shared-initialize/after for <domain-problem> depends on the components being bound.

Source: navier-stokes.lisp.

Method: shared-initialize :after ((object property-mixin) slot-names &rest initargs &key &allow-other-keys) ¶

Source: general.lisp.

Method: shared-initialize :after ((problem <pde-problem>) slot-names &rest args &key classify &allow-other-keys) ¶

Source: pde-problem.lisp.

Method: shared-initialize :after ((problem <domain-problem>) slot-names &key patch->coefficients &allow-other-keys) ¶

Checks @slot{components}, does @slot{coefficients} setup when the problem specification is given as a list in @arg{patch->coefficients}, and finally memoizes @slot{coefficients}.

Source: pde-problem.lisp.

Method: shared-initialize :after ((problem <elasticity-problem>) slot-names &key &allow-other-keys) ¶

Source: elasticity.lisp.

Method: shared-initialize :after ((vec static-store-vector) slot-names &key &allow-other-keys) ¶

Coerce the store to a static type.

Source: store-vector.lisp.

Method: slot-missing (class (object property-mixin) slot-name (operation (eql slot-makunbound)) &optional new-value) ¶

Source: general.lisp.

Method: slot-missing (class (object property-mixin) slot-name (operation (eql slot-boundp)) &optional new-value) ¶

Source: general.lisp.

Method: slot-missing (class (object property-mixin) slot-name (operation (eql setf)) &optional new-value) ¶

Source: general.lisp.

Method: slot-missing (class (object property-mixin) slot-name (operation (eql slot-value)) &optional new-value) ¶

Source: general.lisp.

Method: update-instance-for-different-class :after ((skel <skeleton>) (domain <domain>) &rest initargs) ¶

Sometimes a skeleton is transformed into a domain by change-class. Usually, this means that the definition is finished such that we can compute the boundary afterwards.

Source: domain.lisp.

Method: update-instance-for-different-class :after ((mesh <mesh>) (h-mesh <hierarchical-mesh>) &rest initargs) ¶

One constructor for an h-mesh is by changing the class of a one-level mesh. This method definition fills the level slot appropriately.

Source: mesh.lisp.

Next: Classes, Previous: Standalone methods, Up: Public Interface [Contents][Index]

6.1.7 Structures

Structure: dll-item ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: object ¶

Readers: dli-object.
Writers: (setf dli-object).

Slot: succ ¶

Readers: dli-succ.
Writers: (setf dli-succ).

Slot: pred ¶

Readers: dli-pred.
Writers: (setf dli-pred).

Next: Types, Previous: Structures, Up: Public Interface [Contents][Index]

6.1.8 Classes

Class: <ansatz-space-automorphism> ¶

A automorphism of an ansatz space.

Package

Source

Direct superclasses

<ansatz-space-morphism>.
<ansatz-space-object>.

Direct methods

domain-ansatz-space.
extended-extract.
getrf!.
global-local-matrix-operation.
graphic-commands.
graphic-write-data.
image-ansatz-space.
initialize-instance.
multilevel-decomposition.
multilevel-decomposition.
plot.
prolongation.
select-linear-solver.
select-smoother.
setup-blocks.

Class: <ansatz-space-morphism> ¶

A mapping between two ansatz-spaces.

Package

Source

<ansatz-space-automorphism>.

Direct subclasses

Direct methods

col-key->size.
initialize-instance.
keys->pattern.
m*.
m*-product-instance.
m*-tn-product-instance.
make-domain-vector-for.
make-image-vector-for.
row-key->size.

Class: <ansatz-space-vector> ¶

A sparse vector which is interpreted as the ansatz-space for a specific fe-class on a given mesh.

Package

Source

Direct superclasses

<ansatz-space-object>.
<ht-sparse-vector>.

Direct methods

cell-integrate.
fe-extreme-values.
fe-gradient.
fe-integrate.
fe-local-gradient.
fe-local-value.
fe-value.
graphic-output.
initialize-instance.
key->size.
m*.
m*-product-instance.
m*-tn-product-instance.
plot.

Class: <ansatz-space> ¶

A finite element ansatz space is determined by finite
element discretization, mesh and problem. The constraints are stored in the slot @var{properties}.

Package

Source

Direct superclasses

Direct methods

assemble-interior.
assemble-interior.
discretization-order.
essential-boundary-constraints.
fe-class.
get-fe.
hierarchical-mesh.
initialize-instance.
key->size.
mesh.
multiplicity.
nr-of-components.
problem.

Direct slots

Slot: fe-class ¶

The finite element class for this ansatz space.

Type: fl.discretization:<fe-discretization>
Initargs: :fe-class
Readers: fe-class.
Writers: This slot is read-only.

Slot: problem ¶

The proplem for this ansatz space which determines essential constraints.

Initargs: :problem
Readers: problem.
Writers: This slot is read-only.

Slot: mesh ¶

The mesh for this ansatz space which determines hanging-node constraints.

Type: fl.mesh:<mesh>
Initargs: :mesh
Readers: mesh.
Writers: This slot is read-only.

Class: <bi-cgstab> ¶

Preconditioned Bi-CGStab iteration

Package: fl.iteration.
Source: krylow.lisp.
Direct superclasses: <preconditioned-krylow>.
Direct methods: make-iterator.

Class: <block-iteration> ¶

Subspace correction scheme generated by collecting overlapping blocks of unknowns.

Package

Source

Direct superclasses

Direct subclasses

<psc>.
<ssc>.

Direct methods

inner-iteration.
make-iterator.
(setf ordering).
ordering.
setup-blocks.
setup-blocks.
store-p.

Direct slots

Slot: inner-iteration ¶

Iteration which is used to solve for each block.

Initargs: :inner-iteration
Readers: inner-iteration.
Writers: This slot is read-only.

Slot: ordering ¶

Initargs: :ordering
Readers: ordering.
Writers: (setf ordering).

Slot: store-p ¶

T if diagonal can be stored.

Initargs: :store-p
Readers: store-p.
Writers: This slot is read-only.

Class: <boundary-cell> ¶

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.

Package

Source

triangulate.lisp.

Direct superclasses

<cell-with-boundary>.

Direct methods

copy-cell.
dimension.
holes.
midpoint.
subcells.
transform-cell!.

Direct slots

Slot: dimension ¶

Initargs: :dimension
Readers: dimension.
Writers: This slot is read-only.

Slot: midpoint ¶

Initargs: :midpoint
Readers: midpoint.
Writers: This slot is read-only.

Slot: holes ¶

Initargs: :holes
Readers: holes.
Writers: This slot is read-only.

Class: <cdr-problem> ¶

Convection-diffusion-reaction problem.

Package

fl.cdr.

Source

cdr.lisp.

Direct superclasses

Direct methods

dual-problem.
select-indicator.
select-linear-solver.

Direct slots

Slot: components ¶

Package: fl.problem.
Initform: (quote (fl.cdr::u))
Initargs: :components

Class: <cell-rule-indicator> ¶

Calls @slot{cell-rule} on a cell for determinining its refinement rule.

Package

Source

<refinement-indicator>.

Direct superclasses

Direct methods

cell-rule.

Direct slots

Slot: cell-rule ¶

Initargs: :cell-rule

Class: <cell> ¶

The basic cell class.

Class: <cg> ¶

Preconditioned conjugate gradient iteration

Package: fl.iteration.
Source: krylow.lisp.
Direct superclasses: <preconditioned-krylow>.
Direct methods: make-iterator.

Class: <coefficient> ¶

The coefficient class.

Package

Source

Direct superclasses

Direct methods

assembly-type.
coeff-eval.
coefficient-name.
demands.
dimension.
evaluate.
print-object.

Direct slots

Slot: name ¶

Initargs: :name
Readers: coefficient-name.
Writers: This slot is read-only.

Slot: dimension ¶

Package: fl.mesh.
Initargs: :dimension
Readers: dimension.
Writers: This slot is read-only.

Slot: demands ¶

Initargs: :demands
Readers: demands.
Writers: This slot is read-only.

Slot: eval ¶

The evaluation funtion. It accepts a list of
keyword parameters which should correspond to the list in DEMANDS.

Package: common-lisp.
Type: function
Initargs: :eval
Readers: coeff-eval.
Writers: This slot is read-only.

Slot: row-offset ¶

For multiphysics problem a row offset for the component index.

Initargs: :row-offset

Slot: col-offset ¶

For multiphysics problem a column offset for the component index.

Initargs: :col-offset

Slot: assembly-type ¶

Initform: fl.problem::*assembly-type*
Initargs: :assembly-type
Readers: assembly-type.
Writers: This slot is read-only.

Class: <constant-function> ¶

For a <constant-function> evaluation and derivative computation are trivial.

Package

Source

Direct superclasses

Direct methods

differentiable-p.
evaluate.
evaluate-gradient.
evaluate-k-jet.
smoothness.
value.

Direct slots

Slot: value ¶

Initargs: :value, :value
Readers: value.
Writers: This slot is read-only.

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.

Package

Source

Direct subclasses

<algebraic-mg>.
<geometric-cs>.

Direct methods

prolongate.
restrict.

Class: <custom-psc> ¶

PSC with custom BLOCK-SETUP function slot.

Package

Source

Direct superclasses

<psc>.
<setup-blocks-mixin>.

Class: <custom-ssc> ¶

SSC with custom BLOCK-SETUP function slot.

Package

Source

Direct superclasses

<setup-blocks-mixin>.
<ssc>.

Class: <discretization> ¶

Discretization base class.

Package: fl.discretization.
Source: discretization.lisp.
Direct superclasses: property-mixin.
Direct subclasses: <fe-discretization>.

Class: <domain-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).

Package

Source

Direct superclasses

<problem>.

Direct subclasses

<interpolation-problem>.
<pde-problem>.

Direct methods

coefficients.
components.
describe-object.
domain.
domain-dimension.
multiplicity.
nr-of-components.
shared-initialize.

Direct slots

Slot: domain ¶

Package: fl.mesh.
Type: fl.mesh:<domain>
Initargs: :domain
Readers: domain.
Writers: This slot is read-only.

Slot: components ¶

Initargs: :components
Readers: components.
Writers: This slot is read-only.

Slot: multiplicity ¶

Multiplicity of the right-hand side.

Package: fl.matlisp.
Initform: 1
Initargs: :multiplicity
Readers: multiplicity.
Writers: This slot is read-only.

Slot: coefficients ¶

A -usually memoized- function mapping patches to coefficient lists.

Package: fl.function.
Initargs: :coefficients
Readers: coefficients.
Writers: This slot is read-only.

Class: <domain> ¶

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.

Package

Source

domain.lisp.

Direct superclasses

<skeleton>.
property-mixin.

Direct methods

describe-object.
initialize-instance.
make-mesh-from.
nr-of-components-of-problem.
nr-of-components-of-problem.
nr-of-components-of-problem.
update-instance-for-different-class.

Direct slots

Slot: classifiers ¶

A list of functions of two arguments -patch and classifications so far- which are called from the right to classify the patch.

Initargs: :classifiers

Class: <duality-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.

Package

Source

Direct superclasses

<local-test-with-dual>.
<setup-enriched-ansatz-space>.
<solve-dual-problem>.
<standard-error-estimator>.

Class: <elasticity-problem> ¶

An elasticity problem is a special instance of an elliptic sytems.

Package

fl.elasticity.

Source

elasticity.lisp.

Direct superclasses

Direct methods

select-linear-solver.
shared-initialize.

Class: <ellsys-problem> ¶

Systems of convection-diffusion-reaction equations. The coefficients should be vector-valued functions in this case.

Package

fl.ellsys.

Source

ellsys.lisp.

Direct superclasses

<pde-problem>.

Direct subclasses

<cdr-problem>.
<elasticity-problem>.
<multiphysics-problem>.
<navier-stokes-problem>.

Direct methods

call-with-ivip.
call-with-time-step-problem.
classify-problem.
discretize-locally.
initialize-instance.
select-discretization.
self-adjoint-p.

Class: <evp-mixin> ¶

A mixin for eigenvalue problems.

Package

Source

Direct subclasses

<evp>.

Direct methods

initialize-instance.
multiplicity.

Direct slots

Slot: multiplicity ¶

The multiplicity of the eigenspace.

Package: fl.matlisp.
Initform: 1
Initargs: :multiplicity
Readers: multiplicity.
Writers: This slot is read-only.

Slot: eigenvalues ¶

The current approximation of the eigenvalues.

Initargs: :eigenvalues

Slot: mu ¶

The multiplier for the system matrix.

Initform: (fl.utilities:box 1.0d0)
Initargs: :mu

Class: <evp> ¶

Standard class for discrete eigenvalue problems.

Package

Source

Direct superclasses

<evp-mixin>.
<nonlinear-problem>.

Direct subclasses

<ls-evp>.

Direct methods

energy.
mass.
select-solver.

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.

Package

Source

Direct subclasses

<geometric-fas>.

Direct methods

prolongate.
restrict.

Class: <fe-approximation> ¶

This class describes iterative finite element appoximation strategies.

Package

Source

fe-approximation.lisp.

Direct superclasses

<strategy>.

Direct subclasses

<fe-interpolation>.
<stationary-fe-strategy>.

Direct methods

fe-class.
initially.
intermediate.
next-step.
terminate-p.

Direct slots

Slot: observe ¶

Providing initform for <iteration> slot.

Package: fl.iteration.
Initform: fl.strategy:*fe-approximation-observe*
Initargs: :observe

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.

Initform: t
Initargs: :plot-mesh

Slot: fe-class ¶

The class of finite element. If it is not set, it is automatically chosen.

Package: fl.discretization.
Initargs: :fe-class
Readers: fe-class.
Writers: This slot is read-only.

Slot: 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.

Initargs: :estimator

Slot: 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.

Initform: (make-instance (quote fl.strategy:<uniform-refinement-indicator>))
Initargs: :indicator

Class: <fe-discretization> ¶

FE discretization base class.

Package: fl.discretization.
Source: ansatz-space.lisp.
Direct superclasses: <discretization>.
Direct subclasses: <standard-fe-discretization>.
Direct methods: discretize.

Class: <fe-interpolation> ¶

This class implements adaptive finite element
interpolation of the given coefficient function as a variant of finite element approximation.

Package

Source

fe-interpolation.lisp.

Direct superclasses

<fe-approximation>.

Direct methods

approximate.

Direct slots

Slot: coefficient ¶

A coefficient determining the function to be interpolated.

Initargs: :coefficient

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.

Package

Source

Direct subclasses

<constant-function>.
<linear-function>.
<linearly-transformed-function>.
<polygon>.
<special-function>.

Direct methods

compose-2.
compose-2.
compose-2.
domain-dimension.
image-dimension.
plot.

Direct slots

Slot: domain-dimension ¶

Initargs: :domain-dimension
Readers: domain-dimension.
Writers: This slot is read-only.

Slot: image-dimension ¶

Initargs: :image-dimension
Readers: image-dimension.
Writers: This slot is read-only.

Class: <gauss-seidel> ¶

The Gauss-Seidel iteration is SOR with omega=1.

Package: fl.iteration.
Source: linit.lisp.
Direct superclasses: <sor>.
Direct methods: initialize-instance.

Class: <geometric-cs> ¶

Geometric multigrid of correction scheme type.

Package

Source

geomg.lisp.

Direct superclasses

<correction-scheme>.
<geometric-mg>.

Direct subclasses

<local-mg>.

Class: <geometric-fas> ¶

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.

Package

multilevel-decomposition.

Source

geomg.lisp.

Direct superclasses

<fas>.
<geometric-mg>.

Direct methods

Class: <geometric-psc> ¶

PSC with geometry-based block choice.

Package

Source

geoblock.lisp.

Direct superclasses

<geometric-blocking-mixin>.
<psc>.

Class: <geometric-ssc> ¶

SSC with geometry-based block choice.

Package

Source

geoblock.lisp.

Direct superclasses

<geometric-blocking-mixin>.
<ssc>.

Direct subclasses

<vanka>.

Class: <gradient-method> ¶

Gradient-method. Better use CG.

Package: fl.iteration.
Source: krylow.lisp.
Direct superclasses: <linear-iteration>.
Direct methods: make-iterator.

Class: <hierarchical-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.

Package

Source

Direct superclasses

<mesh>.

Direct methods

check.
describe-object.
find-cell-from-position.
(setf levels).
levels.
plot-cells.
refine.
top-level.
update-instance-for-different-class.

Direct slots

Slot: levels ¶

Type: (array fl.mesh:<skeleton> (*))
Initargs: :levels
Readers: levels.
Writers: (setf levels).

Class: <ilu> ¶

Incomplete LU iteration. omega is the modification parameter, eta is the diagonal enhancement.

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: omega ¶

Initform: 0.0d0
Initargs: :omega

Slot: eta ¶

Initform: 0.0d0
Initargs: :eta

Slot: ordering ¶

Type: list
Initargs: :ordering

Class: <interpolation-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.

Package: fl.problem.
Source: pde-problem.lisp.
Direct superclasses: <domain-problem>.

Class: <iteration> ¶

The iteration base class.

Package

Source

Direct superclasses

Direct subclasses

Direct methods

finally.
initialize-instance.
initially.
initially.
intermediate.
iterate.
name.
next-step.
next-step.
output-p.
terminate-p.

Direct slots

Slot: observe ¶

The initform depends on the subclass.

Initargs: :observe

Slot: output ¶

A boolean indicating if output is to be done.

Initargs: :output

Slot: success-if ¶

A form specifying a success criterion.

Initargs: :success-if

Slot: failure-if ¶

A form specifying a failure criterion.

Initargs: :failure-if

Slot: start-time ¶

Start time of the iteration.

Package: fl.problem.

Slot: success-if-fn ¶: Compiled success-if form.

Slot: failure-if-fn ¶: Compiled failure-if form.

Class: <iterative-solver> ¶

Base class of all iterative solvers and solution strategies.

Package

Source

Direct superclasses

<iteration>.
<solver>.

Direct subclasses

<discrete-iterative-solver>.
<rothe>.
<special-solver>.
<strategy>.

Direct methods

solve.

Class: <iterator> ¶

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.

Package

Source

Direct superclasses

Direct slots

Slot: matrix ¶

The matrix on which the iterator is working.

Package: fl.problem.
Initargs: :matrix

Slot: initialize ¶

NIL or an initialization function which is called with the solution, rhs, and residual as arguments.

Initargs: :initialize

Slot: initializedp ¶: Flag, if initialization has been done.

Slot: iterate ¶

A function of
the arguments solution, rhs, and residual which performs an update step.

Type: function
Initargs: :iterate

Slot: residual-before ¶

T if the
residual has to be up-to-date before the iteration step.

Initargs: :residual-before

Slot: residual-after ¶

T if the
residual is updated through the iteration step.

Initargs: :residual-after

Class: <jacobi> ¶

Package

Source

Direct superclasses

Direct methods

make-iterator.
make-iterator.

Class: <largest-eta-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.

Package

Source

<refinement-indicator>.

Direct superclasses

Direct methods

cell-rule.
fraction.
indicate.
pivot-factor.

Direct slots

Slot: fraction ¶

Initargs: :fraction
Readers: fraction.
Writers: This slot is read-only.

Slot: pivot-factor ¶

Initform: 0.2d0
Initargs: :pivot-factor
Readers: pivot-factor.
Writers: This slot is read-only.

Class: <linear-function> ¶

A <linear-function> is determined by a matrix A and a vector b. It represents the map @math{x -> Ax+b}.

Package

Source

Direct superclasses

Direct methods

compose-2.
compose-2.
differentiable-p.
evaluate.
evaluate-gradient.
initialize-instance.
smoothness.

Direct slots

Slot: a ¶

Initargs: :a

Slot: b ¶

Initargs: :b

Class: <linear-iteration> ¶

The <linear-iteration> class. Linear iterations are e.g. <gauss-seidel> or <multigrid>.

Package

Source

Direct subclasses

<block-iteration>.
<gradient-method>.
<ilu>.
<jacobi>.
<lu>.
<mg-iteration>.
<multi-iteration>.
<preconditioned-krylow>.
<richardson>.
<s1-coarse-grid-iterator>.
<solver-iteration>.
<sor>.

Direct slots

Slot: damp ¶

Initform: 1.0d0
Initargs: :damp

Slot: store-p ¶

Store decomposition for multiple applications.

Initargs: :store-p

Class: <linear-solver> ¶

Class for linear iterative solvers.

Package

Source

<discrete-iterative-solver>.

Direct superclasses

Direct subclasses

<safe-linear-solver>.

Direct methods

inner-iteration.
iteration.
next-step.

Direct slots

Slot: iteration ¶

The inner iteration.

Initargs

:iteration

Readers

inner-iteration.
iteration.

Writers

This slot is read-only.

Class: <ls-evp> ¶

Generalized eigenvalue problem for matrices.

Package

Source

Direct superclasses

<evp>.

Direct methods

initialize-instance.
mass-matrix.
stiffness-matrix.

Direct slots

Slot: stiffness-matrix ¶

Initargs: :stiffness-matrix
Readers: stiffness-matrix.
Writers: This slot is read-only.

Slot: mass-matrix ¶

Initargs: :mass-matrix
Readers: mass-matrix.
Writers: This slot is read-only.

Class: <lse> ¶

Standard form of a linear system of equations.

Package

Source

Direct superclasses

<problem>.

Direct methods

ensure-residual.
ensure-solution.
initialize-instance.
matrix.
rhs.
select-linear-solver.
select-solver.

Direct slots

Slot: matrix ¶

Initargs: :matrix
Readers: matrix.
Writers: This slot is read-only.

Slot: rhs ¶

Initargs: :rhs
Readers: rhs.
Writers: This slot is read-only.

Class: <lu> ¶

A linear iteration interface for the LU exact solver.

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: store-p ¶

Store decomposition for multiple applications.

Initform: fl.iteration::*store-decomposition*
Initargs: :store-p

Class: <mapped-cell> ¶

A mixin which distinguishes cells which are mapped by a special mapping.

Package

Source

Direct subclasses

<mapped-1-1-product-cell>.
<mapped-1-simplex>.
<mapped-2-1-product-cell>.
<mapped-2-simplex>.
<mapped-vertex>.

Direct methods

cell-mapping.
copy-cell.
local->dglobal.
local->global.
(setf mapping).
mapping.
multiple-local->dglobal.
multiple-local->global.
transform-cell!.

Direct slots

Slot: mapping ¶

Initargs: :mapping
Readers: mapping.
Writers: (setf mapping).

Class: <matrix> ¶

General matrix class.

Package

Source

Direct superclasses

Direct subclasses

<sparse-matrix>.
<submatrix>.
compressed-matrix.
standard-matrix.

Direct methods

automorphism-p.
col-keys.
for-each-entry-and-key.
for-each-entry-and-vector-index.
in-pattern-p.
keys-of-column.
keys-of-row.
make-iterator.
make-iterator.
multiplicity.
ncols.
nrows.
remove-projection-range.
row-keys.
select-linear-solver.
(setf vref).
vref.

Class: <mesh> ¶

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.

Package

Source

Direct superclasses

<skeleton>.

Direct subclasses

<hierarchical-mesh>.

Direct methods

check.
dimension-of-part.
domain.
initialize-instance.
make-analog.
meshsize.
parametric.
refine-cell!.
update-instance-for-different-class.

Direct slots

Slot: domain ¶

The domain of the mesh.

Type: fl.mesh:<domain>
Initargs: :domain
Readers: domain.
Writers: This slot is read-only.

Slot: parametric ¶

Initargs: :parametric
Readers: parametric.
Writers: This slot is read-only.

Class: <mg-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>.

Package

Source

Direct superclasses

Direct subclasses

<algebraic-mg>.
<geometric-mg>.

Direct methods

base-level.
coarse-grid-iteration.
combination-type.
ensure-mg-residual.
ensure-sol-rhs-res.
f-cycle.
fmg.
gamma.
lmgc.
make-iterator.
post-smoother.
post-steps.
pre-smoother.
pre-steps.
prolongate.
restrict.
restrict.
smooth.

Direct slots

Slot: pre-smoother ¶

Initargs: :smoother, :pre-smoother
Readers: pre-smoother.
Writers: This slot is read-only.

Slot: pre-steps ¶

Initform: 1
Initargs: :pre-steps
Readers: pre-steps.
Writers: This slot is read-only.

Slot: post-smoother ¶

Initargs: :smoother, :post-smoother
Readers: post-smoother.
Writers: This slot is read-only.

Slot: post-steps ¶

Initform: 1
Initargs: :post-steps
Readers: post-steps.
Writers: This slot is read-only.

Slot: gamma ¶

Initform: 1
Initargs: :gamma
Readers: gamma.
Writers: This slot is read-only.

Slot: base-level ¶

Initform: 0
Initargs: :base-level
Readers: base-level.
Writers: This slot is read-only.

Slot: coarse-grid-iteration ¶

Initform: (make-instance (quote fl.iteration:<lu>))
Initargs: :coarse-grid-solver, :coarse-grid-iteration
Readers: coarse-grid-iteration.
Writers: This slot is read-only.

Slot: fmg ¶

Initargs: :fmg
Readers: fmg.
Writers: This slot is read-only.

Slot: combination ¶

Switch between additive and multiplicative
combination of corrections from different levels. The additive version should be used as a preconditioner.

Initform: :multiplicative
Initargs: :combination
Readers: combination-type.
Writers: This slot is read-only.

Class: <multi-iteration> ¶

One step of this iteration performs nr-steps of the base iteration.

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: base ¶

Base iteration.

Initargs: :base

Slot: nr-steps ¶

Number of steps with which the base iteration is performed.

Initargs: :nr-steps

Class: <multiphysics-mixin> ¶

Package

Source

<multiphysics-problem>.

Direct subclasses

Direct methods

subproblems.

Direct slots

Slot: subproblems ¶

Initargs: :subproblems
Readers: subproblems.
Writers: This slot is read-only.

Class: <multiphysics-problem> ¶

At least for the moment, multiphysics problems are a special kind of ellsys problems.

Package

fl.ellsys.

Source

ellsys.lisp.

Direct superclasses

<ellsys-problem>.
<multiphysics-mixin>.

Direct methods

select-discretization.

Class: <navier-stokes-problem> ¶

Navier-Stokes problem.

Package

fl.navier-stokes.

Source

navier-stokes.lisp.

Direct superclasses

Direct methods

select-discretization.
select-linear-solver.
select-smoother.
shared-initialize.

Class: <newton> ¶

Class for the Newton iteration.

Package

Source

nlsolve.lisp.

Direct superclasses

<nonlinear-solver>.

Direct methods

next-step.
step-control.

Direct slots

Slot: step-control ¶

NIL means that no step-control is done. If
step-control is a number, then it denotes the maximum number of halving steps which is tried before giving up.

Initargs: :step-control
Readers: step-control.
Writers: This slot is read-only.

Class: <nlse> ¶

Class for nonlinear system of equations.

Package: fl.problem.
Source: problem.lisp.
Direct superclasses: <nonlinear-problem>.

Class: <nonlinear-problem> ¶

Class for nonlinear problems. The linearization contains a function returning a linear problem.

Package

Source

Direct superclasses

<problem>.

Direct subclasses

<evp>.
<nlse>.

Direct methods

ensure-solution.
initialize-instance.
linearize.
select-solver.

Direct slots

Slot: linearization ¶

A function linearizing the problem.

Initargs: :linearization

Slot: solution ¶

An approximation to the solution.

Initargs: :solution

Class: <parallel-sor> ¶

A parallel version of SOR.

Package: fl.iteration.
Source: linit.lisp.
Direct superclasses: <sor>.
Direct methods: make-iterator.

Class: <pde-problem> ¶

Base-class for a pde-problem.

Package

Source

Direct superclasses

<domain-problem>.

Direct subclasses

Direct methods

classify-problem.
discretize.
make-coefficients-for.
nr-of-components-of-problem.
plot.
select-smoother.
select-solver.
shared-initialize.

Class: <periodic-polygon> ¶

This class implements a periodic polygon.

Package: fl.function.
Source: spline.lisp.
Direct superclasses: <polygon>.
Direct methods: nr-segments.

Class: <polygon> ¶

This class implements a function which maps the unit interval to a polygon.

Package

Source

spline.lisp.

Direct superclasses

Direct subclasses

<periodic-polygon>.

Direct methods

differentiable-p.
evaluate.
evaluate-gradient.
initialize-instance.
nr-segments.
points.

Direct slots

Slot: points ¶

A vector of points for the polygon.

Initargs: :points
Readers: points.
Writers: This slot is read-only.

Class: <problem> ¶

Base class for all problems.

Package

Source

Direct superclasses

Direct subclasses

<domain-problem>.
<lse>.
<nonlinear-problem>.

Direct methods

linear-p.
select-solver.

Class: <product-cell> ¶

A mixin for simplex-product cells.

Package

Source

Direct subclasses

<1-1-1-1-product-cell>.
<1-1-1-product-cell>.
<1-1-product-cell>.
<1-2-product-cell>.
<2-1-product-cell>.

Direct methods

barycentric-coordinates.
barycentric-gradients.
coordinates-inside?.
generate-refine-info.
lagrange-inner-coords.
local-coordinates-of-midpoint.
pseudo-vertices.
vertices.

Class: <projection-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.

Package

Source

Direct superclasses

<difference-with-projection>.
<global-and-local-norm>.
<standard-error-estimator>.

Class: <psc> ¶

Parallel subspace correction scheme.

Package

Source

Direct superclasses

<block-iteration>.

Direct subclasses

<custom-psc>.
<geometric-psc>.

Class: <refinement-indicator> ¶

An error indicator can appear as first argument in the @function{indicate} which works on a blackboard. Often, it will use quantities computed by an error estimator before.

Package

Source

Direct subclasses

<cell-rule-indicator>.
<isotropizing-indicator>.
<largest-eta-indicator>.
<uniform-refinement-indicator>.

Direct methods

block-p.
ensure-mesh-quality-p.
from-level.
indicate.
indicate.
indicate.
top-level.

Direct slots

Slot: top-level ¶

If top-level is set, no refinement beyond top-level is indicated.

Package: fl.mesh.
Initargs: :top-level
Readers: top-level.
Writers: This slot is read-only.

Slot: from-level ¶

Below from-level, global refinement is used. If
from-level=NIL, regular global refinement is indicated, if no other indication is available.

Initargs: :from-level
Readers: from-level.
Writers: This slot is read-only.

Slot: block-p ¶

If block-p is T, all children of a parent cell are indicated for refinement together.

Initargs: :block-p
Readers: block-p.
Writers: This slot is read-only.

Slot: ensure-mesh-quality-p ¶

If ensure-mesh-quality-p is T, the indicator ensures that the difference of mesh widths of neighboring cells does not become larger than a factor of 4.

Initform: t
Initargs: :ensure-mesh-quality-p
Readers: ensure-mesh-quality-p.
Writers: This slot is read-only.

Class: <rothe> ¶

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.

Package

Source

rothe.lisp.

Direct superclasses

Direct methods

forced-times.
initialize-instance.
initially.
intermediate.
maximal-time-step.
minimal-time-step.
model-time.
next-step.
old-time-step.
time-step.
time-stepping-scheme.

Direct slots

Slot: model-time ¶

Current time in the time-stepping scheme.

Initargs: :model-time
Readers: model-time.
Writers: This slot is read-only.

Slot: time-step ¶

Initargs: :time-step
Readers: time-step.
Writers: This slot is read-only.

Slot: old-time-step ¶

For use in BDF formula

Initargs: :old-time-step
Readers: old-time-step.
Writers: This slot is read-only.

Slot: minimal-time-step ¶

Initargs: :minimal-time-step
Readers: minimal-time-step.
Writers: This slot is read-only.

Slot: maximal-time-step ¶

Initargs: :maximal-time-step
Readers: maximal-time-step.
Writers: This slot is read-only.

Slot: forced-times ¶

Initargs: :forced-times
Readers: forced-times.
Writers: This slot is read-only.

Slot: scheme ¶

Time-stepping scheme, e.g. @code{:implicit-euler} or @code{:bdf2}.

Initform: :implicit-euler
Initargs: :scheme
Readers: time-stepping-scheme.
Writers: This slot is read-only.

Slot: stationary-success-if ¶

Initargs: :stationary-success-if

Slot: stationary-failure-if ¶

Initargs: :stationary-failure-if

Slot: plot ¶

Package: fl.plot.
Initargs: :plot

Slot: observe ¶

Providing initform for <iteration> slot.

Package: fl.iteration.
Initform: fl.strategy:*rothe-observe*
Initargs: :observe

Class: <s1-coarse-grid-iterator> ¶

Calls LU directly, if the matrix was not reduced to S1 which may happen if there are only Dirichlet vertices.

Package: fl.geomg.
Source: geomg.lisp.
Direct superclasses: <linear-iteration>.
Direct methods: make-iterator.

Class: <s1-reduction> ¶

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.

Package: fl.geomg.
Source: geomg.lisp.
Direct superclasses: <selection-amg>.
Direct methods: prolongation.

Class: <safe-linear-solver> ¶

If failure occurs, object of this class try an
alternative iteration. Usually this will be a direct decomposition.

Package

Source

Direct superclasses

<linear-solver>.

Direct methods

fallback.
(setf fallback-p).
fallback-p.
iteration.
terminate-p.

Direct slots

Slot: fallback ¶

The fallback iteration.

Initform: (make-instance (quote fl.iteration:<lu>))
Initargs: :fallback
Readers: fallback.
Writers: This slot is read-only.

Slot: fallback-p ¶

Readers: fallback-p.
Writers: (setf fallback-p).

Class: <scalar-fe-discretization> ¶

Class for scalar fe discretizations.

Package

Source

<standard-fe-discretization>.

Direct superclasses

Direct methods

compute-local-imatrix.
discretization-order.
nr-of-components.

Direct slots

Slot: order ¶

Initargs: :order
Readers: discretization-order.
Writers: This slot is read-only.

Class: <scalar-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.

Package

Source

Direct superclasses

<fe>.

Direct methods

components.
compute-local-imatrix.
compute-local-pmatrix.
discretization-order.
fe-basis.
fe-dofs.
initialize-instance.
interpolation-function.
ip-gradients.
ip-gradients.
ip-gradients-at-point.
ip-values.
ip-values.
ip-values-at-point.
nr-of-components.
nr-of-dofs.
nr-of-inner-dofs.

Direct slots

Slot: dofs ¶

The dofs which are functionals satisfying dof[i](basis[j])=delta(i,j).

Initargs: :dofs
Readers: fe-dofs.
Writers: This slot is read-only.

Slot: basis ¶

The fe’s basis functions.

Initargs: :basis
Readers: fe-basis.
Writers: This slot is read-only.

Slot: order ¶

Initargs: :order
Readers: discretization-order.
Writers: This slot is read-only.

Class: <selection-amg> ¶

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.

Package

Source

selection-amg.lisp.

Direct superclasses

<algebraic-mg>.

Direct subclasses

<s1-reduction>.
<stueben>.

Direct methods

improved-prolongation.
tentative-prolongation.

Class: <simplex> ¶

A mixin for simplicial cells.

Package

Source

simplex.lisp.

Direct subclasses

<1-simplex>.
<2-simplex>.
<3-simplex>.

Direct methods

barycentric-coordinates.
barycentric-gradients.
cell-mapping.
coordinates-inside?.
generate-refine-info.
l2dg.
lagrange-inner-coords.
local-coordinates-of-midpoint.
pseudo-vertices.
vertices.

Class: <skeleton> ¶

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.

Package

Source

Direct superclasses

Direct subclasses

<domain>.
<mesh>.

Direct methods

Direct slots

Slot: dimension ¶

Type: (integer -1)
Initargs: :dimension
Readers: dimension.
Writers: (setf dimension).

Slot: etables ¶

Readers: etables.
Writers: (setf etables).

Class: <solver-iteration> ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: solver ¶

Initargs: :solver

Class: <solver> ¶

The base class of linear, nonlinear and whatever iterative solvers.

Package

Source

Direct subclasses

Direct methods

output.

Direct slots

Slot: output ¶

Initargs: :output
Readers: output.
Writers: This slot is read-only.

Class: <sor> ¶

Package

Source

Direct superclasses

Direct subclasses

<gauss-seidel>.
<parallel-sor>.

Direct methods

make-iterator.
make-iterator.

Direct slots

Slot: omega ¶

Initform: 1.0d0
Initargs: :omega

Slot: compare ¶

Comparison function (COMPARE I J MAT) for
sorting matrix indices I and J. The result is used as unknown ordering for the iteration.

Initargs: :compare

Class: <sparse-matrix> ¶

Abstract class for sparse matrices.

Package

Source

Direct superclasses

<sparse-dictionary-matrix>.

Direct subclasses

Direct methods

Class: <sparse-tensor> ¶

A general sparse tensor class which is implemented as a sparse vector containing full-or sparse tensor entries.

Package

Source

Direct superclasses

tensor.

Direct methods

Direct slots

Slot: rank ¶

Tensor rank.

Type: fixnum
Initargs: :rank

Slot: indices ¶

The (nonzero) indices of the first slot.

Type: vector
Initform: (make-array 0 :element-type (quote fixnum) :adjustable t)
Initargs: :indices
Readers: indices.
Writers: (setf indices).

Slot: entries ¶

The (nonzero) entries of the first slot.

Type: vector
Initform: (make-array 0 :adjustable t)
Initargs: :entries
Readers: entries.
Writers: (setf entries).

Class: <sparse-vector> ¶

Abstract class for sparse vectors.

Package

Source

Direct superclasses

<sparse-dictionary-vector>.

Direct subclasses

Direct methods

Direct slots

Slot: multiplicity ¶

Multiplicity of the sparse vector. A
multiplicity different from 1 is used when handling multiple right-hand sides and solutions simultaneously.

Initform: 1
Initargs: :multiplicity

Class: <special-function> ¶

A <special-function> provides its own evaluation and gradient computation.

Package

Source

Direct superclasses

Direct methods

differentiable-p.
evaluate.
evaluate-gradient.
evaluate-k-jet.
evaluator.
gradient.
initialize-instance.
jet.

Direct slots

Slot: evaluator ¶

Type: (or function null)
Initargs: :evaluator
Readers: evaluator.
Writers: This slot is read-only.

Slot: gradient ¶

Type: (or function null)
Initargs: :gradient
Readers: gradient.
Writers: This slot is read-only.

Slot: jet ¶

Type: (or function null)
Initargs: :jet
Readers: jet.
Writers: This slot is read-only.

Class: <special-solver> ¶

If you happen to have a problem-adapted solver given as a function, you may use this base class.

Package

Source

Direct superclasses

Direct methods

solve.
solver-function.

Direct slots

Slot: solver-function ¶

Type: function
Initargs: :solver-function
Readers: solver-function.
Writers: This slot is read-only.

Class: <ssc> ¶

Successive subspace correction scheme.

Package

Source

Direct superclasses

<block-iteration>.

Direct subclasses

<custom-ssc>.
<geometric-ssc>.

Direct slots

Slot: omega ¶

Initform: 1.0d0
Initargs: :omega

Class: <standard-fe-discretization> ¶

Finite element discretization where the finite element depends only on the cell (usually via its reference cell).

Package

Source

Direct superclasses

<fe-discretization>.

Direct subclasses

<scalar-fe-discretization>.
<vector-fe-discretization>.

Direct methods

get-fe.

Direct slots

Slot: cell->fe ¶

A function mapping a cell to a finite element. Usually this will be a closure memoized over the reference cell.

Initargs: :cell->fe

Class: <stationary-fe-strategy> ¶

This class describes some iterative finite element solution strategies for continuous, stationary PDE problems.

Package

Source

fe-stationary.lisp.

Direct superclasses

<fe-approximation>.

Direct subclasses

<fe-evp-strategy>.

Direct methods

approximate.

Direct slots

Slot: observe ¶

Package: fl.iteration.
Initform: fl.strategy:*stationary-fe-strategy-observe*

Slot: solver ¶

The solver for solving the discretized systems.

Initargs: :solver

Class: <strategy> ¶

A strategy is an iteration for solving a problem defined on a blackboard.

Package: fl.strategy.
Source: strategy.lisp.
Direct superclasses: <iterative-solver>.
Direct subclasses: <fe-approximation>.
Direct methods: solve.

Class: <stueben> ¶

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.

Package

Source

Direct superclasses

<selection-amg>.

Direct methods

choose-coarse-grid.
filtered-matrix.
(setf theta).
theta.

Direct slots

Slot: theta ¶

Initform: 0.25d0
Initargs: :theta
Readers: theta.
Writers: (setf theta).

Class: <submatrix> ¶

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.

Package

Source

Direct superclasses

Direct methods

col-keys.
for-each-entry-and-key.
(setf mref).
mref.
ncols.
nrows.
row-keys.
(setf vref).
vref.

Direct slots

Slot: matrix ¶

The "supermatrix".

Initargs: :matrix

Slot: row-keys ¶

The row indices of the submatrix.

Type: vector
Initargs: :row-keys
Readers: row-keys.
Writers: This slot is read-only.

Slot: col-keys ¶

The column indices of the submatrix.

Type: vector
Initargs: :col-keys
Readers: col-keys.
Writers: This slot is read-only.

Class: <time-dependent-problem> ¶

A mixin which should be used together with a <PDE-PROBLEM> in a call to MAKE-PROGRAMMATIC-INSTANCE.

Package

Source

time.lisp.

Direct methods

end-time.
select-solver.
self-adjoint-p.
start-time.
time-dependent-problem-class.

Direct slots

Slot: start-time ¶

The start time of the problem (NIL=unspecified).

Initargs: :start-time
Readers: start-time.
Writers: This slot is read-only.

Slot: end-time ¶

The end time of the problem (NIL=unspecified).

Initargs: :end-time
Readers: end-time.
Writers: This slot is read-only.

Class: <uniform-refinement-indicator> ¶

Marks all cells for refinement.

Package: fl.strategy.
Source: error-indicator.lisp.
Direct superclasses: <refinement-indicator>.
Direct methods: cell-rule.

Class: <vanka> ¶

Vanka-like smoother for @math{Q^{k+1}/Q^k} discretizations of Navier-Stokes.

Package: fl.geomg.
Source: vanka.lisp.
Direct superclasses: <geometric-ssc>.
Direct methods: setup-blocks.

Class: <vector-fe-discretization> ¶

Vector FE discretization class.

Package

Source

<standard-fe-discretization>.

Direct superclasses

Direct methods

component.
components.
compute-local-imatrix.
discretization-order.
initialize-instance.
nr-of-components.

Direct slots

Slot: components ¶

Either a vector of components or
the symbol :variable, if the components vary across the domain as is the case for hp-FEM.

Package: fl.problem.
Initargs: :components
Readers: components.
Writers: This slot is read-only.

Class: <vector-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.

Package

Source

Direct superclasses

<fe>.

Direct methods

component.
(setf components).
components.
compute-local-imatrix.
compute-local-pmatrix.
discretization-order.
fe-basis.
(setf fe-dofs).
fe-dofs.
initialize-instance.
interpolation-function.
ip-gradients.
ip-gradients-at-point.
ip-values.
ip-values-at-point.
nr-of-components.
nr-of-dofs.
nr-of-inner-dofs.

Direct slots

Slot: components ¶

Package: fl.problem.
Type: simple-vector
Initargs: :components
Readers: components.
Writers: (setf components).

Slot: dofs ¶

Readers: fe-dofs.
Writers: (setf fe-dofs).

Slot: basis ¶

Readers: fe-basis.
Writers: This slot is read-only.

Class: <vector> ¶

General vector class.

Package

Source

Direct subclasses

<matrix>.
<sparse-vector>.
polynomial.
store-vector.

Direct methods

entries.
extract-if.
in-pattern-p.
keys.
(setf mref).
(setf mref).
mref.
mref.
rank.
remove-projection-range.

Class: <vertex> ¶

The vertex class.

Package

Source

Direct superclasses

<cell>.

Direct subclasses

<mapped-vertex>.

Direct methods

Direct slots

Slot: cell-class-information ¶

Allocation: :class
Readers: cell-class-information.
Writers: (setf cell-class-information).

Slot: position ¶

Package: common-lisp.
Type: vector
Initargs: :position
Readers: vertex-position.
Writers: This slot is read-only.

Class: blackboard ¶

A blackboard where data items can be put and extracted using the function @code{GETBB}.

Package

Source

Direct methods

describe-object.
solve.

Direct slots

Slot: items ¶

A property list of items on the blackboard.

Initargs: :items

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.

Package

Source

Direct methods

(setf dic-ref).
dic-ref.
initialize-instance.
size.

Direct slots

Slot: size ¶

Initform: 1
Initargs: :size
Readers: size.
Writers: This slot is read-only.

Slot: test ¶

Initform: (function eql)
Initargs: :test

Slot: store ¶

Initform: (fl.utilities:make-dll)

Slot: item-store ¶

Class: compressed-matrix ¶

A compressed sparse matrix. This is an abstract class
which is made concrete by mixing it with a store-vector containing the entries.

Package

Source

Direct superclasses

(compressed-matrix⎵(store-vector⎵double-float⎵dynamic⎵nil)).

Direct subclasses

Direct methods

Direct slots

Slot: pattern ¶

A compressed pattern.

Type: fl.matlisp:compressed-pattern
Initargs: :pattern
Readers: pattern.
Writers: This slot is read-only.

Class: compressed-pattern ¶

A compressed sparse pattern. Note: we use int32 vectors
for @slot{starts} and @slot{indices}, such that they do not have to be copied for a call to the alien sparse solvers.

Package

Source

Direct methods

in-pattern-p.
indices.
initialize-instance.
number-of-nonzero-entries.
number-of-stored-entries.
offsets.
orientation.
sizes.
starts.
transposed-pattern.

Direct slots

Slot: sizes ¶

Vector of matrix sizes, at the moment only length
2 is allowed here. The first is the dimension which is not compressed, the second is the dimension which gets compressed.

Initargs: :sizes
Readers: sizes.
Writers: This slot is read-only.

Slot: orientation ¶

Denotes if rows or columns are compressed.

Type: (member :row :column)
Initform: :row
Initargs: :orientation
Readers: orientation.
Writers: This slot is read-only.

Slot: starts ¶

Vector with start indices of compressed columns/rows.

Initargs: :starts
Readers: starts.
Writers: This slot is read-only.

Slot: indices ¶

Vector with compressed row/column indices.

Initargs: :indices
Readers: indices.
Writers: This slot is read-only.

Slot: offsets ¶

Vector of offsets. This is only non-nil, if the pattern supports identification.

Initargs: :offsets
Readers: offsets.
Writers: This slot is read-only.

Class: computed-value-dictionary ¶

Package

Source

Direct methods

compute.
dic-for-each.
dic-for-each-key.
dic-ref.
keys.

Direct slots

Slot: keys ¶

Type: sequence
Initargs: :keys
Readers: keys.
Writers: This slot is read-only.

Slot: compute ¶

A (usually memoized) function computing the values

Type: function
Initargs: :compute
Readers: compute.
Writers: This slot is read-only.

Class: dll ¶

Package

Source

Direct methods

(setf dll-first).
dll-first.
(setf dll-last).
dll-last.

Direct slots

Slot: first ¶

Package: common-lisp.
Readers: dll-first.
Writers: (setf dll-first).

Slot: last ¶

Package: common-lisp.
Readers: dll-last.
Writers: (setf dll-last).

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.

Package

Source

Direct subclasses

vector-dof.

Direct methods

dof-coord.
dof-functional.
dof-gcoord.
dof-in-vblock-index.
dof-index.
dof-subcell.
dof-subcell-index.
evaluate.
precise-coord.
precise-gcoord.

Direct slots

Slot: index ¶

Index of the dof in the cell-dof array

Type: fixnum
Initargs: :index
Readers: dof-index.
Writers: This slot is read-only.

Slot: subcell ¶

Reference subcell on which the dof is defined

Initargs: :subcell
Readers: dof-subcell.
Writers: This slot is read-only.

Slot: subcell-index ¶

Index of the reference subcell on which the dof is defined

Type: fixnum
Initargs: :subcell-index
Readers: dof-subcell-index.
Writers: This slot is read-only.

Slot: in-vblock-index ¶

Index of the dof in the subcell vblock

Type: fixnum
Initargs: :in-vblock-index
Readers: dof-in-vblock-index.
Writers: This slot is read-only.

Slot: precise-coord ¶

Local coordinate of the dof in the reference subcell in high precision.

Type: vector
Initargs: :precise-coord
Readers: precise-coord.
Writers: This slot is read-only.

Slot: coord ¶

Local coordinate of the dof in the reference subcell

Type: vector
Initargs: :coord
Readers: dof-coord.
Writers: This slot is read-only.

Slot: precise-gcoord ¶

Global coordinate of the dof on the reference cell in high precision.

Type: vector
Initargs: :precise-gcoord
Readers: precise-gcoord.
Writers: This slot is read-only.

Slot: gcoord ¶

Type: vector
Initargs: :gcoord
Readers: dof-gcoord.
Writers: This slot is read-only.

Slot: functional ¶

A functional for functions defined on the reference cell

Initargs: :functional
Readers: dof-functional.
Writers: This slot is read-only.

Class: full-tensor ¶

Mixin for full tensors.

Package

Source

Direct superclasses

tensor.

Direct methods

copy.
copy!.
dimensions.
in-pattern-p.
initialize-instance.
make-analog.
offset0.
offsets.
print-object.
rank.
slice.
slice-copy.
t*.
(setf tensor-ref).
tensor-ref.

Direct slots

Slot: dimensions ¶

The dimensions of the tensor.

Initargs: :dimensions
Readers: dimensions.
Writers: This slot is read-only.

Slot: offset0 ¶

An initial offset into the store-vector which defaults to 0.

Type: fixnum
Initform: 0
Initargs: :offset0
Readers: offset0.
Writers: This slot is read-only.

Slot: offsets ¶

The offsets for the different dimensions. This
is internal information computed at tensor construction time.

Type: fl.utilities:fixnum-vec
Initargs: :offsets
Readers: offsets.
Writers: This slot is read-only.

Class: integration-rule ¶

Package

Source

quadrature.lisp.

Direct methods

high-precision-ips.
integration-points.
integration-weights.
ip-gradients.
ip-values.
rule-factors.

Direct slots

Slot: cell ¶

Type: fl.mesh:<cell>
Initargs: :cell

Slot: order ¶

Initargs: :order

Slot: rule-factors ¶

Initargs: :rule-factors
Readers: rule-factors.
Writers: This slot is read-only.

Slot: high-precision-ips ¶

A list of ips where an <ip> is a list (weight
coordinate-vector). Both weight and coordinates are in the high precision given by @var{*quadrature-rule-internal-precision*}.

Initargs: :high-precision-ips
Readers: high-precision-ips.
Writers: This slot is read-only.

Slot: points ¶

The points of an integration rule.

Initargs: :points
Readers: integration-points.
Writers: This slot is read-only.

Slot: weights ¶

The weights of integration rule.

Initargs: :weights
Readers: integration-weights.
Writers: This slot is read-only.

Class: locked-region-mixin ¶

Package

Source

Direct superclasses

waitqueue-mixin.

Direct subclasses

<ht-sparse-matrix>.
<ht-sparse-vector>.

Direct methods

locked-region.
perform-with-locked-region.

Direct slots

Slot: locked-region ¶

Initform: (make-hash-table :test (quote equal))
Readers: locked-region.
Writers: This slot is read-only.

Class: mutex-mixin ¶

A mixin which adds a mutex to every instance of the class.

Package

Source

Direct subclasses

parpool.
thread-cached-dictionary.
thread-safe-pool.
waitqueue-mixin.

Direct methods

mutex.

Direct slots

Slot: mutex ¶

A mutex for excluding access of other threads.

Initform: (bordeaux-threads:make-recursive-lock)
Readers: mutex.
Writers: This slot is read-only.

Class: mutex-object ¶

Package

Source

mutex.lisp.

Direct slots

Slot: lock ¶

Package: bordeaux-threads.
Initform: (bordeaux-threads:make-recursive-lock "my-lock")

Slot: data ¶

Initargs: :data

Class: parpool ¶

A parallel pool of objects of a certain characteristic. Its purpose is to use massive objects multiple times without needing to create and GC them.
It is implemented as a shared hash-table where the key specifies the characteristic and the value is a list of registered free objects satisfying that characteristic. More precisely, this list consists of parpool-entries which contain pointers to the actual objects.

Package

Source

Direct superclasses

mutex-mixin.

Direct methods

describe-object.
get-from-pool.
initialize-instance.

Direct slots

Slot: table ¶: A table mapping keys to a list of parpool entries

Slot: ppes ¶

A table mapping an object to its ppe

Type: hash-table

Slot: test ¶

Initform: (quote eql)
Initargs: :test

Class: parqueue ¶

A thread-safe queue waiting for input.

Package

Source

Direct superclasses

queue.
waitqueue-mixin.

Direct subclasses

chunk-queue.

Direct methods

dequeue.
enqueue.
finish.
(setf finished-p).
finished-p.
popper.

Direct slots

Slot: finished-p ¶

Indicator for no-more-input-allowed.

Readers: finished-p.
Writers: (setf finished-p).

Slot: maximal-size ¶

Initargs: :maximal-size

Slot: current-size ¶

Initform: 0

Class: polynomial ¶

Multivariate polynomial. The coefficients are
represented as nested lists. A special case are 0-variate polynomials which are simply scalars. If factors is present, the polynomial was constructed as an exterior product of polynomials of lower variance.

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: coeffs ¶

Initargs: :coeffs
Readers: coefficients.
Writers: This slot is read-only.

Slot: factors ¶

Initargs: :factors
Readers: factors.
Writers: This slot is read-only.

Slot: gradient ¶

The gradient of a polynomial is only calculated on demand.

Readers: gradient.
Writers: This slot is read-only.

Class: pool ¶

A pool implemented via a hash table.

Package

Source

Direct subclasses

thread-safe-pool.

Direct methods

describe-object.
get-from-pool.
initialize-instance.
pool-size.
put-in-pool.

Direct slots

Slot: table ¶: A table mapping keys to a list of free objects.

Slot: test ¶

Initform: (quote equal)
Initargs: :test

Class: property-mixin ¶

A mixin adding a property slot to the class.

Package

Source

general.lisp.

Direct subclasses

<ansatz-space-object>.
<ansatz-space>.
<coefficient>.
<discretization>.
<domain>.
<fe>.
<iteration>.
<iterator>.
<problem>.
<skeleton>.

Direct methods

(setf properties).
properties.
shared-initialize.
slot-missing.
slot-missing.
slot-missing.
slot-missing.

Direct slots

Slot: properties ¶

A property list for storing unstructured information about this object.

Type: list
Initargs: :properties
Readers: properties.
Writers: (setf properties).

Class: range ¶

Range of numbers for iteration.

Package

Source

Direct methods

iterator.
iterator-end-p.
iterator-next.
reference.

Direct slots

Slot: from ¶

Start of range, defaults to 0.

Initform: 0
Initargs: :from

Slot: to ¶

Inclusive end of range, defaults to infinity.

Initargs: :to

Slot: below ¶

Exclusive end of range, defaults to infinity.

Initargs: :below

Slot: by ¶

Step size.

Initform: 1
Initargs: :by

Class: refinement-rule ¶

Rule for refining reference cells. Those rules are stored in the refine-info slot of the cell class.

Package

Source

(refinement-rule⎵<anisotropic-rule-mixin>).

Direct subclasses

Direct methods

boundary-refinement-rules.
names.
print-object.
reference-cell.
refinement-info.

Direct slots

Slot: names ¶

Names identifying the rule.

Initargs: :names
Readers: names.
Writers: This slot is read-only.

Slot: refcell ¶

Reference cell for this refinement rule.

Initargs: :reference-cell
Readers: reference-cell.
Writers: This slot is read-only.

Slot: boundary-refinement-rules ¶

Refinement rules for the sides required by this rule.

Readers: boundary-refinement-rules.
Writers: This slot is read-only.

Slot: refinement-info ¶

Vector of refinement information for the children.

Initargs: :refinement-info
Readers: refinement-info.
Writers: This slot is read-only.

Class: relation ¶

General relation

Package

Source

Direct subclasses

eql-relation.

Direct methods

arity.
indices.
initialize-instance.
r-insert.
r-insert.

Direct slots

Slot: arity ¶

Type: integer
Initargs: :arity
Readers: arity.
Writers: This slot is read-only.

Slot: indices ¶

Association list order->index

Type: list
Readers: indices.
Writers: This slot is read-only.

Class: small-cache-dictionary ¶

Implementation with lists.

Package

Source

Direct superclasses

dictionary.

Direct methods

dic-for-each.
(setf dic-ref).
dic-ref.
initialize-instance.
size.
store.

Direct slots

Slot: size ¶

Initform: 1
Initargs: :size
Readers: size.
Writers: This slot is read-only.

Slot: test ¶

Initform: (quote eql)
Initargs: :test

Slot: store ¶

Readers: store.
Writers: This slot is read-only.

Class: sorted-hash-table ¶

This is a hash-table where new entries are interned FIFO-like (insertion-order=:fifo) or heap-like (insertion-order=:heap).

Package

Source

Direct superclasses

sorted-dictionary.

Direct methods

dic-empty-p.
dic-for-each.
dic-pop.
(setf dic-ref).
dic-ref.
dic-remove.
initialize-instance.

Direct slots

Slot: test ¶

Initform: (function eql)
Initargs: :test

Slot: store ¶

Initform: (fl.utilities:make-dll)

Slot: insertion-order ¶

Initform: :fifo
Initargs: :insertion-order

Slot: item-store ¶

Class: standard-matrix ¶

Mixin for dense matrices.

Package

Source

Direct superclasses

Direct subclasses

(standard-matrix⎵double-float).

Direct methods

axpy!.
blas-macro.
blas-macro.
blas-macro.
copy!.
det.
diagonal.
display.
dot.
dot-abs.
ensure-matlisp.
extended-mclear!.
extended-minject!.
for-each-entry.
for-each-entry-and-key.
for-each-key-in-row.
gemm-nn!.
gemm-nn!.
gemm-nn!.
gemm-nt!.
gemm-nt!.
gemm-tn!.
gemm-tn!.
gemm-tn!.
gemm-tn!.
gemm-tt!.
gemm-tt!.
gesv!.
getrf!.
getrs!.
getrs!.
ggev.
hegv.
initialize-instance.
join-instance.
lapack-convert.
m*.
m*-product-instance.
m*-tn-product-instance.
m+!.
m.*!.
make-analog.
make-domain-vector-for.
make-image-vector-for.
make-iterator.
matop-x->y!.
matop-x<-y!.
matop-y+=x!.
matop-y-=x!.
matrix-slice.
mequalp.
mextract!.
minject!.
(setf mref).
mref.
multiplicity.
mzerop.
ncols.
nrows.
plot.
print-element.
print-matlab-format.
print-object.
submatrix.
tensor-for-each.
(setf tensor-ref).
tensor-ref.
total-entries.
transpose!.
vector-slice.
vlength.

Direct slots

Slot: nrows ¶

Number of rows in the matrix

Initargs: :nrows

Slot: ncols ¶

Number of columns in the matrix

Initargs: :ncols

Class: store-vector ¶

This mixin yields vector behaviour for a class
containing a store. The store is a unifom array with elements of a certain type which can be determined by the funtion @function{element-type}. It often is but does not have to be equal to the type of scalars for this vector which can be obtained by calling the function @function{scalar-type}.

Package

Source

store-vector.lisp.

Direct superclasses

Direct subclasses

static-store-vector.

Direct methods

store.
(setf vref).
vref.

Direct slots

Slot: store ¶

The vector entries.

Initargs: :store
Readers: store.
Writers: This slot is read-only.

Class: tensor ¶

Tensor superclass.

Package

Source

Direct subclasses

<sparse-tensor>.
full-tensor.

Direct methods

for-each-entry-and-key.
for-each-entry-and-vector-index.
(setf vref).
vref.

Class: thread-safe-pool ¶

A thread-safe pool.

Package

Source

Direct superclasses

mutex-mixin.
pool.

Direct methods

get-from-pool.
pool-size.
put-in-pool.

Class: waitqueue-mixin ¶

Waitqueue mixin.

Package

Source

Direct superclasses

mutex-mixin.

Direct subclasses

locked-region-mixin.
parallel-heap.
parqueue.
work-group.

Direct methods

notify.
wait.
waitqueue.

Direct slots

Slot: waitqueue ¶

Initform: (bordeaux-threads:make-condition-variable)
Readers: waitqueue.
Writers: This slot is read-only.

Previous: Classes, Up: Public Interface [Contents][Index]

6.1.9 Types

Type: double-vec () ¶

Uniform @type{double-float} vector.

Package: fl.matlisp.
Source: ctypes.lisp.

Type: fixnum-vec () ¶

Vector with elements of type @code{fixnum}.

Package: fl.utilities.
Source: utilities.lisp.

Type: int-vec () ¶

Uniform @type{int} vector.

Package: fl.matlisp.
Source: ctypes.lisp.

Type: positive-fixnum () ¶

Positive fixnum tpye.

Package: fl.utilities.
Source: utilities.lisp.

Type: uint () ¶

Package: fl.matlisp.
Source: ctypes.lisp.

Type: uint-vec () ¶

Uniform @type{uint} vector.

Package: fl.matlisp.
Source: ctypes.lisp.

Previous: Public Interface, Up: Definitions [Contents][Index]

6.2 Internals

Constants
Special variables
Macros
Ordinary functions
Generic functions
Structures
Classes
Types

Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]

6.2.1 Constants

Constant: +n-long+ ¶

Package: fl.utilities.
Source: mflop.lisp.

Constant: +n-short+ ¶

Package: fl.utilities.
Source: mflop.lisp.

Constant: +per-class-allocation-slot+ ¶

Per class slot where class means the immediate cell class, i.e. some simplex or product-cell. Ideally, this should be a mixin with :per-subclass initialization.
Alas, this does not exist in CLOS:-(

Package: fl.mesh.
Source: cell.lisp.

Next: Macros, Previous: Constants, Up: Internals [Contents][Index]

6.2.2 Special variables

Special Variable: *adaptivity-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *allow-child-patch-change* ¶

When T it is allowed for a child to have a different patch from its father. This is used at the moment for homogenization of porous domains, but it is not a standard situation.

Package: fl.mesh.
Source: mesh.lisp.

Special Variable: *alpha* ¶

Weight for the convective part in the Quasi-Newton linearization of the Navier-Stokes equation.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Special Variable: *amg-cdr-demo* ¶

Package: fl.application.
Source: amg-cdr.lisp.

Special Variable: *amg-cg-max-size* ¶

Maximum size of the coarse grid in the AMG algorithm.

Package: fl.multigrid.
Source: amg.lisp.

Special Variable: *artificial-viscosity* ¶

If *artificial-viscosity* is equal to a non-nil number eps, then an additional vicosity of size max(viscosity,eps*h) is used.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Special Variable: *assembly-type* ¶

This can be dynamically bound for making a coefficient only influence matrix assembly. The idea is to make parts of the coefficients only valid for the Jacobian calculation. This is not yet used at the moment, because it would require the discretization to calculate the residual directly and not matrix and right-hand side.

Package: fl.problem.
Source: pde-problem.lisp.

Special Variable: *beta* ¶

Weight for the reactive part in the Quasi-Newton linearization of the Navier-Stokes equation.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Special Variable: *blas-macro-table* ¶

Table of all BLAS macros.

Package: fl.matlisp.
Source: blas-basic.lisp.

Special Variable: *blas2-operation-count* ¶

Counter for BLAS level 2 operations

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Special Variable: *blas3-operation-count* ¶

Counter for BLAS level 3 operations

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Special Variable: *books-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *bugs* ¶

List of Femlisp bugs, i.e. failing tests that have not yet been fixed.

Package: fl.tests.
Source: tests.lisp.

Special Variable: *cachesize* ¶

Package: fl.parallel.
Source: parallel.lisp.

Special Variable: *cbl-observe* ¶

Observe list for Cbl.

Package: fl.application.
Source: bl-cdr.lisp.

Special Variable: *cdr-demo* ¶

Package: fl.application.
Source: problem-demos.lisp.

Special Variable: *cell->error* ¶

Internally used: A hash-table mapping cell to the local error.

Package: fl.strategy.
Source: error-indicator.lisp.

Special Variable: *cell->error-rank* ¶

Internally used: A hash-table mapping cell to a number indicating its rank with respect to the estimated error.

Package: fl.strategy.
Source: error-indicator.lisp.

Special Variable: *check-hash-table* ¶

Package: fl.discretization.
Source: sparseif.lisp.

Special Variable: *check-lock* ¶

Package: fl.discretization.
Source: sparseif.lisp.

Special Variable: *check-well-defined-embedded-dimension* ¶

Checks if embedded dimension is well-defined.

Package: fl.mesh.
Source: cell.lisp.

Special Variable: *cholesky-threshold* ¶

Package: fl.matlisp.
Source: standard-matrix-lr.lisp.

Special Variable: *coefficient-component-offsets* ¶

This may contain a list of offsets, in which case the coefficient function is shifted as a sparse tensor.

Package: fl.problem.
Source: pdef.lisp.

Special Variable: *constant-refinement-type* ¶

Standard refinement is regular refinement which has been implemented for all cell types in @femlisp{}.

Package: fl.mesh.
Source: refine.lisp.

Special Variable: *courses-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *crs-test-matrix* ¶

CRS Matrix for testing purposes. Origin: discretization of a streamline-diffusion stabilized convection problem.

Package: fl.matlisp.
Source: compressed.lisp.

Special Variable: *crs-test-matrix-entries* ¶

Package: fl.matlisp.
Source: compressed.lisp.

Special Variable: *dbg-ids* ¶

Identifiers used by dbg.

Package: fl.debug.
Source: debug.lisp.

Special Variable: *debug-lock* ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *default-cm-solver* ¶

Default solver for the CM format. At the moment this can be UMFPACK or SuperLU.

Package: fl.matlisp.
Source: compressed.lisp.

Special Variable: *demo-help* ¶

Package: fl.demo.
Source: demo.lisp.

Special Variable: *discretization-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *distribute-workload-p* ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *dof-precise-evaluation* ¶

Special variable determining if the DOF is evaluated precisely on the shape function. This is important for the accuracy of stiffness-matrices.

Package: fl.discretization.
Source: fe.lisp.

Special Variable: *dx-bug-transformation* ¶

Transformation which drops the ugly line occuring for me due to some bug either in DX or Mesa.

Package: fl.plot.
Source: plot-dx.lisp.

Special Variable: *dx-bug-workaround* ¶

If T switches on hardware rendering. This variant is problematic, although it gets rid of black lines in dx pictures in some situations. E.g. it does not do xy-graphs correctly and fails for @lisp{(plot (n-cube 1))}. It can also kill the Xwindows interface on some computers.

Package: fl.graphic.
Source: dx.lisp.

Special Variable: *dx-default-window-size* ¶

Default size and resolution of DX window. Note that changes in the size of the window require restarting DX.

Package: fl.graphic.
Source: dx.lisp.

Special Variable: *dx-name* ¶

Name of the @program{DX} binary.

Package: fl.graphic.
Source: dx.lisp.

Special Variable: *dx-process* ¶

The current @program{dx} process.

Package: fl.graphic.
Source: dx.lisp.

Special Variable: *dx-shapes* ¶

The shapes which are handled by DX plotting.

Package: fl.plot.
Source: plot-dx.lisp.

Special Variable: *dx-toggle* ¶

Depending on @var{*dx-toggle*} the cache option is switched on/off. This is a trick to make @arg{dx} redraw the picture.

Package: fl.graphic.
Source: dx.lisp.

Special Variable: *effective-coeffs-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *effective-elasticity-demo* ¶

Package: fl.application.
Source: elahom.lisp.

Special Variable: *effective-permeability-demo* ¶

Package: fl.flow-application.
Source: hom-ns.lisp.

Special Variable: *eigenvalue-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *elasticity-demo* ¶

Package: fl.application.
Source: problem-demos.lisp.

Special Variable: *error-for-debug-output* ¶

If T, stop with an error at a debug message.

Package: fl.debug.
Source: debug.lisp.

Special Variable: *evp-success* ¶

Package: fl.iteration.
Source: evpsolve.lisp.

Special Variable: *failed* ¶

List of routines which failed for last run of the test suite.

Package: fl.tests.
Source: tests.lisp.

Special Variable: *femlisp-directory* ¶

The namestring for @var{*femlisp-pathname*}.

Package: fl.start.
Source: setup.lisp.

Special Variable: *femlisp-pathname* ¶

The pathname for the Femlisp main directory. This should be the location of this file when it is loaded.

Package: fl.start.
Source: setup.lisp.

Special Variable: *find-cell-base-level* ¶

First level on which a cell is searched for containing a given position.

Package: fl.mesh.
Source: mesh.lisp.

Special Variable: *foreign-code-loaders* ¶

List of functions for loading foreign code. Each function of this list should be executed when starting a saved core.

Package: fl.alien.
Source: alien.lisp.

Special Variable: *g2l-newton-steps* ¶

Limit for the number of Newton steps for @function{global->local}. Small numbers should work for reasonable geometries and initial values.

Package: fl.mesh.
Source: cell.lisp.

Special Variable: *gnuplot-name* ¶

Pathname of the @program{Gnuplot} binary.

Package: fl.graphic.
Source: gnuplot.lisp.

Special Variable: *gnuplot-process* ¶

The current @program{Gnuplot} process.

Package: fl.graphic.
Source: gnuplot.lisp.

Special Variable: *graphics-lock* ¶

Lock for making the function @function{graphic-output} thread-safe. This lock could be integrated in the function body using LOAD-TIME-VALUE. But since it might also be used for other functions when they process the resulting graphic files, we expose it here.

Package: fl.graphic.
Source: graphics.lisp.

Special Variable: *heat-demo* ¶

Package: fl.application.
Source: problem-demos.lisp.

Special Variable: *hegv* ¶

Package: fl.lapack.
Source: lapack.lisp.

Special Variable: *hooks* ¶

Table mapping a symbol to a list of hooks.
A hook is a function which may be called on a property object for updating other properties.

Package: fl.utilities.
Source: general.lisp.

Special Variable: *hr-delta* ¶

Small positive value which is used for “smoothing” the distributional rhs.

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Special Variable: *hr-evaluation-point* ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Special Variable: *hr-gradx-value* ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Special Variable: *input-queue* ¶

The input queue of a worker job in a pipeline.

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *inside-threshold* ¶

If this is set to a threshold, the coordinate-inside? check allows for some round-off error of the threshold size.

Package: fl.mesh.
Source: cell.lisp.

Special Variable: *interpolation-type* ¶

Default value for interpolation type. @code{:local} means that interpolation extends only to the direct children, which is reasonable for standard interpolation of Lagrange finite elements. @code{:global} interpolates from highest-dimensional cells and forms an average.

Package: fl.discretization.
Source: sparseas.lisp.

Special Variable: *ipt-tolerance* ¶

Entries in interpolation, projection, and transfer matrices below this threshold are dropped.

Package: fl.discretization.
Source: fetransfer.lisp.

Special Variable: *iteration-failure-behavior* ¶

When the value of this variable is :error, then the iteration terminates with an error. When the value is :continue, it records the failure on the blackboard and terminates.

Package: fl.iteration.
Source: iterate.lisp.

Special Variable: *iteration-name* ¶

One of (:class-name :object :all).

Package: fl.iteration.
Source: iterate.lisp.

Special Variable: *konwihr-speed* ¶

For memoizing the measured CL speed (for having a nicer demo experience:-)

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Special Variable: *langevin-taylor-29* ¶

Taylor coefficients for the Langevin function around zero. Contains only the coefficients for powers x^k with uneven k and in reverse order such that it can be processed from smallest to largest coefficient.

Package: fl.function.
Source: function.lisp.

Special Variable: *lapack-templates* ¶

The table of all LAPACK templates.

Package: fl.lapack.
Source: lapack.lisp.

Special Variable: *lapack-types* ¶

The number types for which a LAPACK routine is defined.

Package: fl.lapack.
Source: lapack.lisp.

Special Variable: *laplace-demo* ¶

Package: fl.application.
Source: problem-demos.lisp.

Special Variable: *local-evaluation-memoization-table* ¶

Can be set locally for memoizing evaluation results.

Package: fl.utilities.
Source: utilities.lisp.

Special Variable: *local-interpolation-matrix* ¶

If non-NIL, it should be a function of the arguments cell, mesh, and finite element class. This function is called for computing an interpolation matrix.

Package: fl.discretization.
Source: fetransfer.lisp.

Special Variable: *local-mat-pool* ¶

Parallel pool from which local matrices may be extracted.

Package: fl.discretization.
Source: sparseif.lisp.

Special Variable: *local-projection-matrix* ¶

If non-NIL, it should be a function of the arguments cell, mesh, and finite element class. This function is called for computing a projection matrix.

Package: fl.discretization.
Source: fetransfer.lisp.

Special Variable: *maxrows-for-direct-solving* ¶

Maximum number of rows for which direct solving is applied.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Special Variable: *meshfile-basename* ¶

Basename for mesh decomposition.

Package: fl.mesh.
Source: triangle.lisp.

Special Variable: *mflop-delta* ¶

Time interval in seconds over which we measure performance.

Package: fl.utilities.
Source: mflop.lisp.

Special Variable: *nabh-cd* ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Special Variable: *nabh-cl* ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Special Variable: *nrm2* ¶

Package: fl.lapack.
Source: lapack.lisp.

Special Variable: *number-of-threads* ¶

The number of threads in which Femlisp tries to split the work for some computationally intensive tasks. If NIL, no threading is used.

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *optional-skeleton-checks* ¶

Some optional checks for skeletons.

Package: fl.mesh.
Source: skeleton.lisp.

Special Variable: *output-queue* ¶

The output queue of a worker job in a pipeline.

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *output-types* ¶

Types of output. Possible entries in this list are: - :screen
- (:images successive-pathname-producer)

Package: fl.graphic.
Source: graphics.lisp.

Special Variable: *pipeline-length* ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *pivot-max-error* ¶

Internally used: The maximal local error contribution.

Package: fl.strategy.
Source: error-indicator.lisp.

Special Variable: *plot* ¶

If set to NIL, plotting is disabled. If set to :message, a message is printed to *trace-output* instead of plotting.

Package: fl.plot.
Source: plot.lisp.

Special Variable: *plot-transformation* ¶

A transformation for the plotted object. Usually, this is calculated from the object.

Package: fl.plot.
Source: plot.lisp.

Special Variable: *portability-problem-handling* ¶

Determines which action should be taken if we encounter a portability problem for a Lisp.

Package: fl.port.
Source: port.lisp.

Special Variable: *position-header* ¶

Package: fl.plot.
Source: plot.lisp.

Special Variable: *print-cell* ¶

If set to :MIDPOINT, prints the midpoint of a cell.

Package: fl.mesh.
Source: cell.lisp.

Special Variable: *print-lock* ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Special Variable: *print-matrix-pretty* ¶

T means that a newline is printed after each row.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Special Variable: *print-polynomial-variance* ¶

If T, the polynomial variance is shown when printing a polynomial.

Package: fl.function.
Source: polynom.lisp.

Special Variable: *print-skeleton* ¶

May be nil, :cells, :cells-of-highest-dimension.

Package: fl.mesh.
Source: skeleton.lisp.

Special Variable: *print-skeleton-values* ¶

When t, prints also the values of a skeleton.

Package: fl.mesh.
Source: skeleton.lisp.

Special Variable: *quadrature-rule-float-type* ¶

Floating-point number type with which the quadrature rules is used externally.

Package: fl.discretization.
Source: quadrature.lisp.

Special Variable: *quadrature-rule-internal-precision* ¶

High precision with which weights and points in our quadrature rules are calculated internally.

Package: fl.discretization.
Source: quadrature.lisp.

Special Variable: *refcell-refinement-memoize-depth* ¶

Depth up to which we store the refinements of the reference cell. The levels 0 and 1 are always memoized, becuause these are needed for refinement operations. NIL indicates no additional memoization beyond levels 0 and 1, T indicates infinite depth.

Package: fl.mesh.
Source: refine.lisp.

Special Variable: *refcell-refinement-table* ¶

Table where refinements of reference cells are memoized.

Package: fl.mesh.
Source: refine.lisp.

Special Variable: *refinement-demos* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *select-linear-solver* ¶

If this variable is non-nil, it is funcalled for selecting a linear solver. An alternative way of handling this could be given by Pascal Costanza’s @code{AspectL}.

Package: fl.iteration.
Source: solve.lisp.

Special Variable: *set-affinity-p* ¶

Set CPU affinity for kernel processes.

Package: fl.parallel.
Source: parallel.lisp.

Special Variable: *show-dx-window* ¶

Show the DX window when something is plotted. This may be useful on Laptops when the window is hidden.

Package: fl.graphic.
Source: dx.lisp.

Special Variable: *skew-4d-to-3d* ¶

A transformation for projecting regular 4D structures from a skew perspective into 3D space. The result can then be viewed by a standard 3D plot program.

Package: fl.application.
Source: refinement-demos.lisp.

Special Variable: *small-tests* ¶

List of small Femlisp tests.

Package: fl.tests.
Source: tests.lisp.

Special Variable: *solver-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *sparse-test-matrix* ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Special Variable: *store-decomposition* ¶

Package: fl.iteration.
Source: linit.lisp.

Special Variable: *streamline-diffusion* ¶

Streamline diffusion adds a certain velocity-dependent amount of numerical viscosity which depends on the size of the element and the size of convection.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Special Variable: *streamline-diffusion* ¶

Streamline diffusion parameter for convection problems. Note that we do not modify the right-hand side at the moment, so this is more comparable to an FE upwinding and it is of O(h) only.

Package: fl.cdr.
Source: cdr.lisp.

Special Variable: *suggested-nonlinear-solver* ¶

Can be used for very rudimentary influence on GPS.

Package: fl.iteration.
Source: nlsolve.lisp.

Special Variable: *talks-demo* ¶

Package: fl.application.
Source: application-demos.lisp.

Special Variable: *test-blas-vector-generator* ¶

Function of an argument @arg{N} which returns a vector of size @arg{N} of a type that can be handled by the BLAS routines which are tested.

Package: fl.matlisp.
Source: blas-basic.lisp.

Special Variable: *testing* ¶

List of routines which still have to be tested.

Package: fl.tests.
Source: tests.lisp.

Special Variable: *tests* ¶

List of Femlisp tests.

Package: fl.tests.
Source: tests.lisp.

Special Variable: *tetgen-pathname* ¶

Pathname of the @program{tetgen} binary.

Package: fl.mesh.
Source: tetgen.lisp.

Special Variable: *triangle-path* ¶

Path to the @program{triangle} executable.

Package: fl.start.
Source: femlisp-config.lisp.

Special Variable: *triangle-pathname* ¶

Pathname of the @program{triangle} binary.

Package: fl.mesh.
Source: triangle.lisp.

Special Variable: *u_1/2-observe* ¶

Package: fl.application.
Source: bratu.lisp.

Special Variable: *u_1/4-observe* ¶

Observe the solution at position {0.25}^dim.

Package: fl.strategy.
Source: fe-approximation.lisp.

Special Variable: *underscore-p* ¶

Does the external name contain an underscore.

Package: fl.lapack.
Source: lapack.lisp.

Special Variable: *unit-prism-1-2* ¶

Package: fl.mesh.
Source: product-cell.lisp.

Special Variable: *unit-prism-2-1* ¶

Package: fl.mesh.
Source: product-cell.lisp.

Special Variable: *upwinding* ¶

Discretizes convection with upwinding when set to T.
Warning: This kind of upwinding based on ensuring the m-matrix property is questionable and should be checked, if you rely on it. For example, I have observed wrong results for outflow boundary conditions.

Package: fl.ellsys-fe.
Source: ellsys-fe.lisp.

Special Variable: *use-pool-p* ¶

T if pool should be used.

Package: fl.discretization.
Source: sparseif.lisp.

Special Variable: *use-problem-p* ¶

Package: fl.flow-application.
Source: boundary-force.lisp.

Special Variable: *user-input-stream* ¶

This is an input stream for user input which is normally bound to *standard-input*. During testing this can be bound to a string stream to provide sample input.

Package: fl.demo.
Source: demo.lisp.

Special Variable: *viscosity-model* ¶

Type of viscosity model. Can be either :GUGV or :DUDV.
The first corresponds to (grad(u), grad(v)), the second to (eps(u), eps(v)), where eps denotes the symmetrized gradient.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Special Variable: *visited-demos* ¶

Table of demos already visited during this Lisp session.

Package: fl.demo.
Source: demo.lisp.

Special Variable: *with-convection-p* ¶

Package: fl.flow-application.
Source: boundary-force.lisp.

Special Variable: *zero-vector* ¶

Package: fl.alien.
Source: alien.lisp.

Special Variable: internal-component ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-component-2 ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-components ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-dimension ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-domain ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-length ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-length-2 ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-multiplicity ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-patch ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-patch-dimension ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-patch-if ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-position ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-position-2 ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-problem ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-properties ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-subproblem-name ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-subproblem-package ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-subproblems ¶

Package: fl.problem.
Source: pdef.lisp.

Special Variable: internal-value ¶

Package: fl.problem.
Source: pdef.lisp.

Next: Ordinary functions, Previous: Special variables, Up: Internals [Contents][Index]

6.2.3 Macros

Macro: a (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: a_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: ai (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: awhile (expr &body body) ¶

Anaphoric macro from @cite{(Graham 1993)}.

Package: fl.macros.
Source: macros.lisp.

Macro: b (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: c (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: chain (arg &body expressions) ¶

Anaphoric macro on the symbol _ which allows to express a chain of operations.

Package: fl.macros.
Source: macros.lisp.

Macro: collecting (&body body) ¶

Collect objects into a list. Example: @lisp
(collecting (collect 1) (collect 2)) @end lisp

Package: fl.macros.
Source: macros.lisp.

Macro: conditional-compile (condition form1 form2) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Macro: conservative-convection (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: constraint (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: constraint (args0 &body body1) ¶

Package: fl.problem.
Source: ellsys.lisp.

Macro: continuity (&optional args &body body) ¶

Continuity equation coefficient with derivative on u. The coefficient value xi is 1.0 by default.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: convection (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: define-blas-template (name args &body body) ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Macro: define-blas2-template (name args &body body) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Macro: define-default-gemm! (name at yt) ¶

Package: fl.matlisp.
Source: matrix-methods.lisp.

Macro: define-ellsys-coefficient-macro (name rank) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: define-lapack-template (name return-value &body argument-specifications) ¶

Defines a LAPACK template. The syntax is similar to the SBCL alien interface, but keywords are used for specifying types. Furthermore, the type of the matrix elements is not yet specified, but can be refered to as :element-type, and its base-type as :base-type. There is also a :select clause which allows to include arguments only for specific
situations. :select can dispatch
on :element-type (:float, :double, :complex-float, :complex-double), :base-type (:float, :double),
:number-type (:real, :complex)

Package: fl.lapack.
Source: lapack.lisp.

Macro: define-matrix-matrix-operation (name operation) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Macro: define-vector-blas-method (symbol args &body body) ¶

Package: fl.matlisp.
Source: array-blas.lisp.

Macro: delay (form) ¶

Delays the evaluation of @arg{form}.

Package: fl.macros.
Source: macros.lisp.

Macro: derivative-source (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: diffusion (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: enumerate (name &rest items) ¶

Utility function which is not used at the moment. The idea was working around a CMUCL enum bug.

Package: fl.alien.
Source: alien.lisp.

Macro: f (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: fas-r_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: force (args &body body) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: g (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: gradp (&optional args &body body) ¶

We discretize grad(p) or div(p*I) by differentiating the test function. The coefficient value eta is 1.0 by default.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: h (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: i_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: if-lapack-function ((function type) form1 form2) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Macro: in-syntax (variable) ¶

Posted by Kent M. Pitman to cll, 13.3.2008.

Package: fl.macros.
Source: macros.lisp.

Macro: inertia (args &body body) ¶

This macro expands into a quasi-linear formulation of a quasi-Newton treatment of the momentum part of the Navier-Stokes equations. Which parts of the Newton linearization are included is determined by the special variables @var{*alpha*} and @var{*beta*}.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: initial (args &body body) ¶

Pass arguments to FL.ELLSYS::INITIAL. The values returned should fit with what is required here. Note that it can make sense to set also the pressure to some reasonable initial value, if an iterative solver is used.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: initial (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: initial (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: memoizing-let-transformer (let-type key-vals &body body) ¶

Package: fl.dictionary.
Source: dictionary.lisp.

Macro: no-slip (args &body body) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: post-smoother_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: pre-smoother_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: prescribed-velocity (args &body body) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: pressure-bc (args &body body) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: r (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: r_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: reaction (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: res_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: residual-p_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: resistance (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: rhs_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: select-components-on-patch ((&optional patch) &body clauses) ¶

Package: fl.problem.
Source: pdef.lisp.

Macro: short-remove-method (gf-name qualifiers specializers) ¶

Removes the method for the generic function @arg{gf-name} which is specified by @arg{qualifiers} and @arg{specializers}. Example: @lisp
(short-remove-method m* (:before) (<sparse-matrix> <sparse-vector>)) @end lisp

Package: fl.macros.
Source: macros.lisp.

Macro: sigma (args &body body) ¶

Pass arguments to FL.ELLSYS::SIGMA. The sparse tensor returned should fit with what is required here.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: sigma (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: sigma (args0 &body body1) ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Macro: sol_ (level) ¶

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: source (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: streamline-diffusion (args &body body) ¶

Package: fl.cdr.
Source: cdr.lisp.

Macro: symbol-macroletf-helper (store-vars writer-form reader-form) ¶

Setf Expander: (setf symbol-macroletf-helper) (store-vars writer-form reader-form) ¶

Package: fl.macros.
Source: macros.lisp.

Macro: viscosity (args &body body) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Macro: when-foreign-vector-operations (&body body) ¶

Package: fl.alien.
Source: alien.lisp.

Macro: with-array ((access array) &body body) ¶

Posted by Kent Pitman at cll,8.5.2007 as ’array-access’.

Package: fl.macros.
Source: macros.lisp.

Macro: with-cell-class-information (slots cell-class &body body) ¶

Multiple and write access to cell-information slots.

Package: fl.mesh.
Source: cell.lisp.

Macro: with-cell-information (slots cell &body body) ¶

Package: fl.mesh.
Source: cell.lisp.

Macro: with-ci-slots (slots ci &body body) ¶

Multiple and write access to cell-information slots.

Package: fl.mesh.
Source: cell.lisp.

Macro: with-coefficient-macros ((problem-symbol) &body body) ¶

Package: fl.problem.
Source: pdef.lisp.

Macro: with-current-level-data (symbols mg-data &body body) ¶

Anaphoric, because it works with the MG-DATA symbol.

Package: fl.multigrid.
Source: multigrid.lisp.

Macro: with-ivip ((problem rothe) &body body) ¶

Package: fl.strategy.
Source: rothe.lisp.

Macro: with-time-step-problem ((problem rothe) &body body) ¶

Package: fl.strategy.
Source: rothe.lisp.

Macro: zero-constraint () ¶

Package: fl.cdr.
Source: cdr.lisp.

Next: Generic functions, Previous: Macros, Up: Internals [Contents][Index]

6.2.4 Ordinary functions

Function: 1d-graph (func &key left right step) ¶

Package: fl.application.
Source: discretization-demos.lisp.

Function: 1d-surface-cells (skel &optional part) ¶

Extracts the 1D-surface cells (maybe specialized to a certain part) for drawing a wire plot of the mesh.

Package: fl.plot.
Source: plot.lisp.

Function: <child-info>-p (object) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: adapt-fill-pointer (table) ¶

Package: fl.multigrid.
Source: stueben.lisp.

Function: add-local-part! (a b index-table &key directions) ¶

Adds the parts for the specified indices from B to A. This operation is destructive for A!

Package: fl.discretization.
Source: constraints.lisp.

Function: add-new-refinement-rule (rule) ¶

Adds a new @arg{rule} to the refinement rules of @arg{cell}.

Package: fl.mesh.
Source: refine.lisp.

Function: add-pipeline-worker (job from to) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: add-worker (group) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: adjoin-bug-test (fsym) ¶

Package: fl.tests.
Source: tests.lisp.

Function: adjoin-test-suite (sym) ¶

Adjoins a fiveam test suite to the Femlisp test suite.

Package: fl.tests.
Source: tests.lisp.

Function: allowed-processors () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: amg-cdr-solver () ¶

The standard AMG solver for the demos in this file.

Package: fl.application.
Source: amg-cdr.lisp.

Function: anisotropic-boundary-refinement-rules (refcell types) ¶

Package: fl.mesh.
Source: anisotropic.lisp.

Function: anisotropic-name (types) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: anisotropic-refinement-indicator (filter-matrix) ¶

@arg{filter-matrix} projects orthogonally on the dimensions with refinement.

Package: fl.mesh.
Source: anisotropic.lisp.

Function: anisotropic-refinement-info (refcell types) ¶

Package: fl.mesh.
Source: anisotropic.lisp.

Function: anisotropic-refinement-rule (refcell types) ¶

Create an anisotropic refinement rule.

Package: fl.mesh.
Source: anisotropic.lisp.

Function: anisotropic-refinement-skeleton (dims types) ¶

Package: fl.mesh.
Source: anisotropic.lisp.

Function: apply-1d-stencil (stencil x) ¶

Package: fl.function.
Source: spline.lisp.

Function: array-contents (array) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: artificial-viscosity (dim viscosity factor) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: assemble-cell (cell ansatz-space &key matrix rhs mass-matrix) ¶

Package: fl.discretization.
Source: fedisc.lisp.

Function: assembly-heap (cells) ¶

Build up a dependency graph for each cell and makes a parallel heap for this graph. The dependency graph is such that assembly of some specific cell C
blocks all subcells of C together with all neighbors
sharing a subcell with C.

Package: fl.discretization.
Source: assembly-heap.lisp.

Function: assert-same-size (x y) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: average-coefficient (ansatz-space &key coefficient) ¶

Package: fl.application.
Source: app-utils.lisp.

Function: ball-diffusion (dim eps) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: barycentric->euclidean (s) ¶

Package: fl.mesh.
Source: blending.lisp.

Function: barycentric-coordinates-factors (factors local-pos) ¶

Compute a vector of weights which gives the global position by taking the scalar product with the list of corners.

Package: fl.mesh.
Source: product-cell.lisp.

Function: base-type (lapack-type) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: benchmark-calculation (&rest args &key dim levels output &allow-other-keys) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: benchmark-domain (&rest args &key nr-blocks &allow-other-keys) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: benchmark-problem (&rest args &key viscosity um time-dependent-p outflow start-time end-time &allow-other-keys) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: binomial (n k) ¶

Binomial coefficient

Package: fl.utilities.
Source: utilities.lisp.

Function: bisect (cells axis bcoord) ¶

Bisect a list of cells along the axis given by @arg{axis} and at the coordinate @arg{coord}.

Package: fl.mesh.
Source: rcb.lisp.

Function: bisection-parameters (box) ¶

From a given bounding box calculate a reasonable separating dimension and a separating coordinate.

Package: fl.mesh.
Source: rcb.lisp.

Function: blending-map (cell) ¶

Returns a mapping for the cell by interpolating the mappings of its boundary.

Package: fl.mesh.
Source: blending.lisp.

Function: bottom-mapping (dim f &optional grad-f) ¶

Package: fl.domains.
Source: bl-cell.lisp.

Function: boundary-layer-cell-domain (dim f &key grad-f extensible upper &allow-other-keys) ¶

Returns the domain generated by oscillating-boundary-domain with identified lateral faces.

Package: fl.domains.
Source: bl-cell.lisp.

Function: boundary-layer-cell-problem (bl-cell-domain &key &allow-other-keys) ¶

Returns a boundary layer problem for the given boundary layer cell domain. We assume that the oscillating boundary on which Dirichlet nodes are prescribed is identified by $x_n<1$ for its coordinates, and the patch for which the source is prescribed is $x_n=0$.

Package: fl.application.
Source: bl-cdr.lisp.

Function: bpx-demo-computation (problem order level &optional smoother-class) ¶

Performs the BPX demo.

Package: fl.application.
Source: multigrid-demos.lisp.

Function: bratu-computation (dim &key a plot time output base-level) ¶

Function performing the Bratu demo.

Package: fl.application.
Source: bratu.lisp.

Function: bratu-tests () ¶

Package: fl.application.
Source: bratu.lisp.

Function: build-level-table (h-mesh) ¶

Construct a hash-table where each cell is mapped to the first level where it occurs. Copies get the same level as their parent.

Package: fl.mesh.
Source: mesh.lisp.

Function: c-dirichlet-dof-p (key constraints-p constraints-q) ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: c-find-master (key mesh constraints-p constraints-q) ¶

Does work only for Lagrange fe. Otherwise there may be several masters.

Package: fl.discretization.
Source: sparseas.lisp.

Function: c-slave-dof-p (key constraints-p constraints-q) ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: calculate-bounding-box (points) ¶

Calculate a bounding box for the given point. The result is a pair of vectors where the first contains the minimal values and the second the maximal values.

Package: fl.mesh.
Source: rcb.lisp.

Function: calculate-effective-cachesize () ¶

Calculates effective cachesize in bytes.

Package: fl.parallel.
Source: parallel.lisp.

Function: calculate-multistep-weights (rothe) ¶

Package: fl.strategy.
Source: rothe-ellsys.lisp.

Function: call-tetgen (&key meshsize &allow-other-keys) ¶

Calls Hang Si’s Tetgen.

Package: fl.mesh.
Source: tetgen.lisp.

Function: call-triangle (&key mesh-size minimum-angle delaunay-p &allow-other-keys) ¶

Calls Shewchuk’s triangle program.

Package: fl.mesh.
Source: triangle.lisp.

Function: call-with-workers (worker producer &key parallel) ¶

Package: fl.parallel.
Source: parallel-adaptions.lisp.

Function: canonical-number-type (type) ¶

Returns the canonical type name, for example it might return SINGLE-FLOAT or SHORT-FLOAT for an argument SINGLE-FLOAT.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: cartesian-product-map (func1 func2) ¶

Package: fl.mesh.
Source: product-cell.lisp.

Function: cdr-bl-computation (dim/domain order max-levels &rest rest &key output plot plot-mesh solver &allow-other-keys) ¶

Performs the bl-diffusion demo.

Package: fl.application.
Source: bl-cdr.lisp.

Function: cdr-cell-problem (dim/domain &key diffusion inlay-diffusion corner-constraint-p) ¶

Returns the cell problem on the n-cell-domain of the given dimension. Gamma yields dim right hand sides of the form A e_k, i.e. the columns of the diffusion tensor.

Package: fl.application.
Source: hom-cdr.lisp.

Function: cdr-interior-effective-coeff-demo (problem order levels &key output plot) ¶

Computes an effective diffusion tensor for different configurations. The approximation is done with isoparametric finite elements. Uniform refinement is used, the linear solver is a geometric multigrid scheme used in a nested iteration fashion. The solution to the cell problem is a vector field whose components are plotted one after the other. The setting has cubic symmetry, from which one can easily see that the effective tensor must be a scalar multiple of the identity.

Package: fl.application.
Source: hom-cdr.lisp.

Function: cell-class-information-p (object) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: cell-dimension-and-point-test (dim point) ¶

Package: fl.application.
Source: locref.lisp.

Function: cell-solve (problem &key level order parametric solver) ¶

Solves the given problem and returns a result on a blackboard.

Package: fl.application.
Source: hom-cdr.lisp.

Function: cell-volume (cell) ¶

Package: fl.discretization.
Source: feeval.lisp.

Function: cells->skeleton (cells) ¶

Package: fl.mesh.
Source: skeleton.lisp.

Function: change-to-blending (cell) ¶

Package: fl.mesh.
Source: blending.lisp.

Function: check-and-calculate-depth-of (object) ¶

Calculates the depth of an object -usually a list- and asserts that it is uniform.

Package: fl.function.
Source: polynom.lisp.

Function: check-component (comp) ¶

Checks if comps is of the correct form, see the documentation of the slot @slot{components} in @class{domain-problem}.

Package: fl.problem.
Source: pde-problem.lisp.

Function: check-components (comps) ¶

Checks if comps is of the correct form, see the documentation of the slot @slot{components} in @class{domain-problem}.

Package: fl.problem.
Source: pde-problem.lisp.

Function: check-cpairs (dims1 dims2 cpairs) ¶

Checks that indices don’t appear twice, and that the dimensions of every contracted index pair fit.

Package: fl.matlisp.
Source: tensor.lisp.

Function: check-for-multiples (skel &key output) ¶

Checks for different vertices at the same location and for cells of higher dimensions connecting the same vertices in a possibly different order.
Warning: Up to now a quadratic algorithm is used.

Package: fl.mesh.
Source: skeleton.lisp.

Function: check-h-convergence (problem min-level max-level &key order position solver) ¶

Package: fl.application.
Source: tools.lisp.

Function: check-identification (skel) ¶

Should checks correct identification. At the moment, it tests only if all identification-entries are eq.

Package: fl.mesh.
Source: identify.lisp.

Function: check-p-convergence (problem min-order max-order &key level position isopar solver) ¶

Package: fl.application.
Source: tools.lisp.

Function: check-spec (arg-spec) ¶

Checks if arg-spec makes sense for the implementation. Should probably be done after replacing types for the implementation?

Package: fl.lapack.
Source: lapack.lisp.

Function: chequerboard-problem (dim eps) ¶

Returns cell problem on the n-cell-domain of the given dimension with a chequerboard pattern.

Package: fl.application.
Source: hom-cdr.lisp.

Reader: child-barycentric-corners (instance) ¶

Writer: (setf child-barycentric-corners) (instance) ¶

Package: fl.mesh.
Source: refine.lisp.
Target Slot: barycentric-corners.

Reader: child-boundary-paths (instance) ¶

Writer: (setf child-boundary-paths) (instance) ¶

Package: fl.mesh.
Source: refine.lisp.
Target Slot: boundary-paths.

Reader: child-reference-cell (instance) ¶

Writer: (setf child-reference-cell) (instance) ¶

Package: fl.mesh.
Source: refine.lisp.
Target Slot: reference-cell.

Reader: child-transform-a (instance) ¶

Writer: (setf child-transform-a) (instance) ¶

Package: fl.mesh.
Source: refine.lisp.
Target Slot: transform-a.

Reader: child-transform-b (instance) ¶

Writer: (setf child-transform-b) (instance) ¶

Package: fl.mesh.
Source: refine.lisp.
Target Slot: transform-b.

Function: children-offsets (vecfe type rule) ¶

Computes the offsets for each component in the children’s data block.

Package: fl.discretization.
Source: fetransfer.lisp.

Reader: ci-boundary-indices-of-subcells (instance) ¶

Writer: (setf ci-boundary-indices-of-subcells) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: boundary-indices-of-subcells.

Reader: ci-dimension (instance) ¶

Writer: (setf ci-dimension) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: dimension.

Reader: ci-factor-simplices (instance) ¶

Writer: (setf ci-factor-simplices) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: factor-simplices.

Reader: ci-nr-of-sides (instance) ¶

Writer: (setf ci-nr-of-sides) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: nr-of-sides.

Reader: ci-nr-of-subcells (instance) ¶

Writer: (setf ci-nr-of-subcells) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: nr-of-subcells.

Reader: ci-nr-of-vertices (instance) ¶

Writer: (setf ci-nr-of-vertices) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: nr-of-vertices.

Reader: ci-reference-cell (instance) ¶

Writer: (setf ci-reference-cell) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: reference-cell.

Reader: ci-refine-info (instance) ¶

Writer: (setf ci-refine-info) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: refine-info.

Reader: ci-refinement-rules (instance) ¶

Writer: (setf ci-refinement-rules) (instance) ¶

Package: fl.mesh.
Source: cell.lisp.
Target Slot: refinement-rules.

Function: classify-benchmark-domain (&key bottom top left right) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: classify-top-bottom-lateral (&optional bottom top left right) ¶

Returns a classifier for identifying top, bottom, and lateral parts of a cube domain.

Package: fl.mesh.
Source: domain.lisp.

Function: clear-bug-tests () ¶

Clears the Femlisp bug register.

Package: fl.tests.
Source: tests.lisp.

Function: clear-tests () ¶

Clears the Femlisp test suite.

Package: fl.tests.
Source: tests.lisp.

Function: closed? (skel) ¶

Checks if the boundary of @arg{skel} is empty. This should be the case for boundaries of skeletons.

Package: fl.mesh.
Source: skeleton.lisp.

Function: combine-real-and-imag-part (rv iv) ¶

Package: fl.matlisp.
Source: ggev.lisp.

Function: combine-svec-block (svec local-vec keys ranges operation) ¶

Puts a local block in matlisp format into a <sparse-vector>.

Package: fl.matlisp.
Source: sparse-vector.lisp.

Function: combined-constraints (old-p old-q old-r new-p new-q new-r) ¶

Constructs a combined constraint tuple given old and new constraints.

Package: fl.discretization.
Source: constraints.lisp.

Function: compile-termination-test (test) ¶

Compiles a given list expression TEST into a test function acting on a blackboard. Keywords are replaced by macros accessing the blackboard.

Package: fl.iteration.
Source: iterate.lisp.

Function: complex-to-real-vector (cvec) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: complex-type (type) ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: component-name (comp) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: compress-fe-parameters (paras) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: compressed-eye-pattern (nrows ncols &optional orientation) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: compressed-gemm! (alpha x y beta z x-transposed y-transposed) ¶

If calculations with compressed matrices become more common, this routine must be optimized.

Package: fl.matlisp.
Source: compressed.lisp.

Function: compute-all-position-component-values (cells position-indices depth cell->values components) ¶

Computes the values at all positions and for all components.

Package: fl.plot.
Source: plot.lisp.

Function: compute-all-position-values (cells position-indices depth cell->values) ¶

Computes the values at the positions. @arg{depth} can be a number representing the number of cell subdivisions, or a function which yields this number for the actual cell.

Package: fl.plot.
Source: plot.lisp.

Function: compute-block-inverse (smat keys ranges) ¶

Package: fl.iteration.
Source: blockit.lisp.

Function: compute-block-inverses (smat blocks ranges) ¶

Package: fl.iteration.
Source: blockit.lisp.

Function: compute-cbl (blackboard) ¶

Package: fl.application.
Source: bl-cdr.lisp.

Function: compute-cell-vertices (cells) ¶

Package: fl.plot.
Source: meshplot.lisp.

Function: compute-duals (vectors functionals pairing) ¶

Combines a set of vectors such that they are dual to a set of functionals wrt a given pairing.

Package: fl.discretization.
Source: fe.lisp.

Function: compute-energy (asv &key cells skeleton) ¶

Package: fl.discretization.
Source: feeval.lisp.

Function: compute-essential-boundary-constraints (ansatz-space &key level where interface) ¶

Maybe there will be a general solution somewhen, but for the moment we delegate it to the specialized assembly.

Package: fl.discretization.
Source: constraints.lisp.

Function: compute-offset (index offset0 offsets) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: compute-position-indices (cells depth) ¶

Collects all vertices of surface cells into a hash-table and indexes them. When type is :continuous, then the key is the vertex, otherwise the key is the pair cell/vertex, which allows for the plotting of functions that are discontinuous across cell boundaries. @arg{depth} can be a number representing the number of cell subdivisions, or a function which yields this number for the actual cell.

Package: fl.plot.
Source: plot.lisp.

Function: compute-raster (patch &key threshold meshsize indicator patch->raster minimal-depth maximal-depth &allow-other-keys) ¶

Computes a curvature-adapted raster on a curved line. @arg{threshold} is controlling the allowed deviation from linearity, @arg{meshsize} is a maximally allowed mesh width. The user may also pass an @arg{indicator} which should be a function of patch, local position and meshwidth, or a function @arg{patch->raster} mapping patches to complete rasters.

Package: fl.mesh.
Source: triangulate.lisp.

Function: cone-rule-for-simplex (n s) ¶

Calculates a quadrature rule for a n-simplex by considering it as a cone over an n-1-dimensional base simplex. This follows @cite{(Stroud 1971)}, page 31. The result of this function is a list of the form @lisp{( (weight coordinates) ... )}.

Package: fl.discretization.
Source: quadrature.lisp.

Function: connections (cells position-indices depth) ¶

Returns the connections in a list. Each list item is again a list consisting of the reference cell and the vertex indices extracted from the table @arg{position-indices}. @arg{depth} can be a number representing the number of cell subdivisions, or a function which yields this number for the actual cell.

Package: fl.plot.
Source: plot.lisp.

Function: consecutive-p (offsets dims) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: consistent-vertex-numbering (skel) ¶

Returns a vertex table with consistently numbered vertices - if possible.

Package: fl.mesh.
Source: triangle.lisp.

Function: convert-elasticity-correction (mat) ¶

Converts the (dim^2)x(dim^2) matrix returned as result of correction tensor into an (dim x dim)-array with (dim x dim)-matrix entries.

Package: fl.application.
Source: app-utils.lisp.

Function: convert-to-alien-type (type) ¶

Converts @arg{x} to an alien type, if possible.

Package: fl.lapack.
Source: lapack.lisp.

Function: copy-<child-info> (instance) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: copy-cell-class-information (instance) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: copy-dll-item (instance) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: copy-ip (sequence) ¶

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package: fl.discretization.
Alias for: copy-seq.

Function: copy-parpool-entry (instance) ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: copy-procinfo (sequence) ¶

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package: fl.parallel.
Alias for: copy-seq.

Function: copy-refinement-rule (refcell) ¶

Creates a new copy refinement rule.

Package: fl.mesh.
Source: anisotropic.lisp.

Function: create-boundary-paths (simplex) ¶

Create the boundary-paths for the <child-info> entry in the refine-info vector. We assume that the ordering of the simplex boundaries is opposite to the ordering of the corners.

Package: fl.mesh.
Source: simplex.lisp.

Function: create-boundary-paths-of-product-cell (cell) ¶

Create the boundary-paths for the <child-info> entry in the refine-info vector.

Package: fl.mesh.
Source: product-cell.lisp.

Function: create-lapack-function (name type) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: create-refinement-demo (name object &key transformation) ¶

Package: fl.application.
Source: refinement-demos.lisp.

Function: cube-index->product-cell-index (dims i) ¶

Transforms an index in the vertex field of the cube into the corresponding vertex index in the product-cell with the dimension DIMS of its factors.

Package: fl.mesh.
Source: product-cell.lisp.

Function: cube-index->simplex-index (i) ¶

Transforms an index in the vertex field of the cube into the corresponding vertex index in the simplex.

Package: fl.mesh.
Source: product-cell.lisp.

Function: cube-without-corner (dim) ¶

Creates a domain by cutting out one cube from the uniform refinement of the unit cube.

Package: fl.mesh.
Source: domain.lisp.

Function: cubic-channel (dim &key viscosity reynolds direction) ¶

The channel is a simple test problem which has for every Reynolds number a Hagen-Poiseuille solution with linear pressure. The corresponding velocity profile is a solution to @math{-Delta u = constant}.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: curved-triangle-domain () ¶

A quarter of a unit disk.

Package: fl.mesh.
Source: blending.lisp.

Function: daxpy (x a y n) ¶

Package: fl.utilities.
Source: mflop.lisp.

Function: daxpy-speed (n) ¶

Returns the number of daxpy-ops for vectors of size @arg{n}.

Package: fl.utilities.
Source: mflop.lisp.

Function: ddot (x y n) ¶

Package: fl.utilities.
Source: mflop.lisp.

Function: decompose-offsets (offsets) ¶

Package: fl.matlisp.
Source: sparse-tensor.lisp.

Function: decrease-priority (pq obj) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: define-blas-macro (class macro-definition) ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: delay-possible-p (keys) ¶

Package: fl.discretization.
Source: sparseif.lisp.

Function: derivative-symbol-p (sym) ¶

Package: fl.problem.
Source: pdef.lisp.

Function: destructure-polygon (polygon) ¶

A polygon is a list of the form
@lisp
([title-string] {key value}* vec1 ...)
@end lisp
This function ensures the form of a property list
(:title title-string :type type :key1 :value1 ... :data (vec1 ...))

Package: fl.plot.
Source: plot-gnuplot.lisp.

Function: dimensions->offsets (dims) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: direct-solver-performance-test (solver n &key with-constraint-p) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: direct-solver-test (solver) ¶

Tests @arg{solver} on the simple example from the SuperLU User Guide.

Package: fl.alien.
Source: alien.lisp.

Function: discretize-elasticity (dim order level) ¶

Local routine for testing purposes.

Package: fl.elasticity-fe.
Source: elasticity-fe.lisp.

Function: discretize-ellsys (dim nr-comps order level) ¶

Discretizes an elliptic system with @arg{nr-comps} components on the @arg{dim}-dimensional unit cube with Lagrange fe of @arg{order}.

Package: fl.ellsys-fe.
Source: ellsys-fe.lisp.

Function: display-block-matrix-graph (smat row-order col-order &key stream) ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: display-stiffness-matrix (&rest args) ¶

Shows the stiffness matrix of the model problem. Maybe you will have to use hscroll-mode in your Emacs buffer for comfortably looking at the matrix.

Package: fl.application.
Source: discretization-demos.lisp.

Function: distance-numbering (mat key-table key) ¶

Result is a table mapping the keys from @arg{key-table} to their distance from @arg{key}.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: div-u-coefficient (dim &optional xi) ¶

Continuity equation coefficient with derivative on u

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: dll-check-consistency (item dll) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: dll-item-p (object) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: domain-substance (domain) ¶

The substance of the domain as a hash-table of cells.

Package: fl.mesh.
Source: domain.lisp.

Function: domain-substance-boundaries (domain) ¶

The boundaries of the substance cells as a hash-table of cells.

Package: fl.mesh.
Source: domain.lisp.

Function: domain-volume (domain &optional s) ¶

Package: fl.discretization.
Source: fe.lisp.

Function: drag/lift-contribution (cell solution evaluate-force-boundary-p &key viscosity eta) ¶

The idea is to discretize locally a special problem containing the stress tensor part of the momentum equation.

Package: fl.flow-application.
Source: boundary-force.lisp.

Function: driven-cavity-upper-boundary (dim &optional smooth-p) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: drop-empty-limits (pq) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: dudv-coefficient (dim viscosity) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: dudv-tensor (dim viscosity) ¶

This is the coefficient for discretizing viscosity*eps(u):eps(v), where eps(u) is the symmetrized gradient of u. We call it DUDV like in the FEM-code Navier.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: dx-close () ¶

Package: fl.graphic.
Source: dx.lisp.

Function: dx-input-stream () ¶

Package: fl.graphic.
Source: dx.lisp.

Function: dx-output-stream () ¶

Package: fl.graphic.
Source: dx.lisp.

Function: dx-position-header (dim nr-positions) ¶

Package: fl.plot.
Source: plot-dx.lisp.

Function: elahom-longtime-stability-test (nr-of-trials &rest args &key levels threshold &allow-other-keys) ¶

Package: fl.application.
Source: elahom-performance.lisp.

Function: elahom-performance-calculation (&key levels output order threshold) ¶

Package: fl.application.
Source: elahom-performance.lisp.

Function: elahom-performance-initialize (&key order) ¶

Initializes all tables which the preceding test needs for its default parameters. After this function has been executed such performance measurements can be done in a reasonable way.

Package: fl.application.
Source: elahom-performance.lisp.

Function: elahom-performance-test (nrs-of-kernels &rest args &key initialize &allow-other-keys) ¶

Package: fl.application.
Source: elahom-performance.lisp.

Function: elahom-performance-tests () ¶

Package: fl.application.
Source: elahom-performance.lisp.

Function: elasticity-cell-problem-gamma (dim) ¶

Returns a right-hand side for an elasticity cell problem.

Package: fl.application.
Source: elahom.lisp.

Function: elasticity-cell-problem-reaction (dim value) ¶

We want to have zero at the corners.

Package: fl.application.
Source: elahom.lisp.

Function: elasticity-fe-tests () ¶

Package: fl.elasticity-fe.
Source: elasticity-fe.lisp.

Function: elasticity-inlay-cell-problem (domain &key inlay-p interior exterior) ¶

Generates the inlay cell problem. The coefficient is of the form @math{A^{ij}_{lambda mu}}$, and the equation to be solved is in variational form

@math{ 0 = partial_lambda phi^i A^{ij}_{lambda mu} (partial_mu N^j_m + Gamma^j_{mu m}) }

With @math{k,nu} being such that @math{m= k n + nu} we have @math{Gamma^{j_k}{munu}=delta_{jk}delta_{munu}} leading
to matrix-valued functions @math{N_nu} in the notation of cite{Bakhvalov-Panasenko}. We should also have @math{N^{jk}_nu = N^{jnu}_k} because of the symmetries of A. The correction to the arithmetic average has to be computed as

@math{ A_{corr}^{kr}_{iq} := int_Y A^{kl}_{ij} grad_{x_j} N^{lr}_q = int_Y div_{x_j} A^{lk}_{ji} N^{lr}_q = F[k*dim+i] cdot N[r*dim+q].}

Package: fl.application.
Source: elahom.lisp.

Function: elasticity-interior-effective-coeff-demo (problem &key order levels plot output effective-tensor-p observe) ¶

Computes the effective elasticity for a certain periodic medium. The approximation is done with finite elements and blending. Uniform refinement is used, the linear solver is a geometric multigrid scheme used in a nested iteration fashion. A subtle point here is that the coarse-grid smoother has to treat the inlay as a block to be robust against the large coefficient jump.

The solution to this cell problem is a tensor field of rank 3 with dim^3 components which are plotted one after the other.

Package: fl.application.
Source: elahom.lisp.

Function: elasticity-model-problem-computation (domain &key output plot) ¶

Performs the model problem demo.

Package: fl.application.
Source: model-problem.lisp.

Function: eliminate-hanging-node-constraints-from-matrix (a constraints &key directions) ¶

Eliminates the constraints destructively from A. directions is a list consisting of the two symbols :left and :right which determine if elimination is done wrt row or column indices. Returns t if constraints have been eliminated.

Package: fl.discretization.
Source: constraints.lisp.

Function: ellsys-fe-tests () ¶

Package: fl.ellsys-fe.
Source: ellsys-fe.lisp.

Function: ellsys-initial-value-interpolation-coefficients (rothe problem patch coeffs) ¶

Return a coefficient list for the initial value interpolation problem to be solved at the beginning.

Package: fl.strategy.
Source: rothe-ellsys.lisp.

Function: ellsys-time-step-coefficients (rothe coeffs) ¶

Return a coefficient list for the stationary problem to be solved at each time step.

Package: fl.strategy.
Source: rothe-ellsys.lisp.

Function: ensure-1-component-tensor (value) ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: ensure-1-component-vector (value) ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: ensure-ansatz-space (blackboard) ¶

Ensures a finite element ansatz space on the blackboard. If a discretization is not provided, it is selected depending on the problem. If a mesh is not provided and if the domain is curved, we use precise cell mappings if these are available. Otherwise, an isoparametric approximation is used with order @math{max(2,p+1)} where p is the discretization order. This is reasonable, because the dual problem for estimators based on duality is discretized with @math{p+1}, and because the refinement near the boundary works significantly better with @math{p>=2}.

Package: fl.strategy.
Source: fe-approximation.lisp.

Function: ensure-constraints (asv) ¶

Ensures the constraints for the ansatz space vector @arg{asv}.

Package: fl.discretization.
Source: sparseas.lisp.

Function: ensure-dx-process () ¶

Package: fl.graphic.
Source: dx.lisp.

Function: ensure-gnuplot-process () ¶

Package: fl.graphic.
Source: gnuplot.lisp.

Function: ensure-index (r order) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: ensure-lapack-type (type &optional error-p) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: ensure-m-matrix-property (mat) ¶

Problematic, because, when applied to the convection contribution, it reduces the discretization to first order accuracy.

Package: fl.ellsys-fe.
Source: ellsys-fe.lisp.

Function: ensure-polygons (polygons) ¶

Package: fl.plot.
Source: plot-gnuplot.lisp.

Function: ensure-secondary-information (domain) ¶

Preliminary. Maybe it would be better to update the boundary automatically when inserting cells. Unfortunately, it is not clear how this could be done in an easy way.

Package: fl.mesh.
Source: domain.lisp.

Function: ensure-simplex (dim) ¶

Returns the reference simplex of the given dimension.

Package: fl.mesh.
Source: simplex.lisp.

Function: ensure-solution-structure (matrix rhs solution) ¶

Package: fl.iteration.
Source: linit.lisp.

Function: ensure-thread-local-dic (dic index) ¶

Package: fl.dictionary.
Source: dictionary.lisp.

Function: entries (r) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: equal-type (type1 type2) ¶

Tests if @arg{type1} and @arg{type2} designate the same type.

Package: fl.matlisp.
Source: ctypes.lisp.

Function: essential-constraints-for-key (ansatz-space key) ¶

Package: fl.discretization.
Source: system-fe.lisp.

Function: eta->p2-vec (eta problem mesh) ¶

Maps eta into a P2 ansatz function. This is used for plotting the error distribution. Note that for tetrahedra, no cell contributions are shown.

Package: fl.strategy.
Source: error-estimator.lisp.

Function: euclidean->barycentric (pos) ¶

Package: fl.mesh.
Source: simplex.lisp.

Function: evaluate-exterior-polynomial-product (factors x &optional memoization-table) ¶

Package: fl.function.
Source: polynom.lisp.

Function: evaluate-force-boundary-test (mesh) ¶

Returns a function which checks if a cell is on a boundary classified with the key :evaluate-force-boundary.

Package: fl.flow-application.
Source: boundary-force.lisp.

Function: evaluate-shapes-at-points (shapes positions) ¶

Shapes is a sequence of shapes, positions is a vector of positions. The result is a vector of values.

Package: fl.discretization.
Source: fe.lisp.

Function: evp-cdr-test () ¶

Package: fl.application.
Source: evp-cdr.lisp.

Function: exact-1d-solution () ¶

The precise value for x=1/2 is easily seen to be 1/8. On the other hand it is equal to
1/pi^2 (4/pi)^d sum_{k odd} +/- 1/k^3

Package: fl.application.
Source: model-problem.lisp.

Function: exact-2d-solution () ¶

With the help of Fourier series we obtain the representation 1/pi^2 (4/pi)^d sum_{k_i odd} +/- 1/{k_1 k_2 (k_1^2+k_2^2)} for the value u(1/2,1/2).
+/- means sin(k_1*pi/2) * sin (k_2*pi/2)

Package: fl.application.
Source: model-problem.lisp.

Function: exact-3d-solution () ¶

With the help of Fourier series we obtain the representation 1/pi^2 (4/pi)^d sum_{k_i odd} +/- 1/{k_1 k_2 k_3 (k_1^2+k_2^2+k_3^2)} for the value u(1/2,1/2,1/2).
+/- means sin(k_1*pi/2) * sin (k_2*pi/2) * sin (k_3*pi/2)

Package: fl.application.
Source: model-problem.lisp.

Function: execute-in-parallel (work &key arguments distribute number-of-threads) ¶

Executes work in parallel distributed on @arg{number-of-threads} threads. The arguments for work are taken from the argument-lists in @arg{arguments}. Alternatively, @arg{distribute} may contain a function which generates the argument-lists by calling the function @function{work-on}.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: execute-in-pipeline (distribute &rest jobs) ¶

Every function in @arg{jobs} produces arguments for the next one with the function @function{call-next}. Every job is run in a separate thread.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: execute-thunk-with-pinned-objects (thunk pinned-objects) ¶

Package: fl.port.
Source: port.lisp.

Function: exponents->monomial-list (partition) ¶

Converts a monomial given by a list of powers of its components into our dense polynomial format.

Example: (exponents->monomial-list ’(1 2)) -> (() (0 0 1))

Package: fl.function.
Source: polynom.lisp.

Function: extend-horizontally (mat surface-mat) ¶

Adds one layer from surface-mat to mat.

Package: fl.geomg.
Source: geomg.lisp.

Function: extend-level-matrix (initial-mat surface-mat &key layers) ¶

Extends initial-mat by several layers from surface-mat.

Package: fl.geomg.
Source: geomg.lisp.

Function: extended-block (asa keys) ¶

Collect the next layer around keys in the matrix graph of asa.

Package: fl.geomg.
Source: vanka.lisp.

Function: extract-applicable-spec (arg-spec type) ¶

Handles the @arg{case}-construct and converts :element-type to @arg{type}.

Package: fl.lapack.
Source: lapack.lisp.

Function: extract-from-gradient (gradient from ncomps) ¶

Extract a numbers or subvectors from the gradient vector.

Package: fl.problem.
Source: pdef.lisp.

Function: extract-from-seq-in-order (seq order) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: extract-ip-data (cell qrule property-list) ¶

Converts all ansatz-space objects in the parameters list into local value arrays corresponding to the finite element.

Package: fl.discretization.
Source: sparseif.lisp.

Function: fast-ip-gradients (fe positions) ¶

Package: fl.discretization.
Source: fe.lisp.

Function: fd-laplace-matrix-triplets (dim n &optional sample) ¶

Short version of generating an arbitrary-dimensional FD discretization of the Laplace operator. n can be a number or a vector of dim numbers.

Package: fl.matlisp.
Source: compressed.lisp.

Function: fe-discretize-linear-problem (blackboard) ¶

Finite element discretization for a linear problem or the linearization of a nonlinear problem.

Package: fl.discretization.
Source: fedisc.lisp.

Function: fe-parameter-p (demand) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: fe-secondary-information (fe) ¶

Computes for a (vector) finite element the secondary information which is important when extracting data from ansatz-space vectors and matrices. For each dof in the fe, the access information to the global matrix in the form vblock/in-vblock-index and the access information to the local matrix in the form component-index/in-component-index is computed.

Package: fl.discretization.
Source: sparseif.lisp.

Function: femlisp-check-features () ¶

Package: fl.start.
Source: finalize.lisp.

Function: femlisp-multiprocessing-tests () ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: femlisp-restart () ¶

Should be called when restarting a saved Femlisp core.

Package: fl.start.
Source: finalize.lisp.

Function: femlisp-version () ¶

Package: fl.start.
Source: finalize.lisp.

Function: femlisp-workers () ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: find-cell-on-patch-with-midpoint (h-mesh patch midpoint level) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: find-compressed-offset (cm i j) ¶

This method may be inefficient with large bandwidths because it ignores the ordering of indices.

Package: fl.matlisp.
Source: compressed.lisp.

Function: find-first-path-geq (tree value) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: find-first-path-satisfying (tree condition &key direction) ¶

Finds the path to the DIRECTION-first node having an item satisfying CONDITION.
CONDITION should specify an semi-open interval wrt the trees order!

Package: net.scipolis.relations.
Source: relations.lisp.

Function: find-first-position>= (indices index) ¶

Finds the position for index, which is the first position which is >= index in the sorted list.

Package: fl.matlisp.
Source: sparse-tensor.lisp.

Function: find-key-in-tree (tree key-list) ¶

Find key-list in tree.

Package: fl.dictionary.
Source: dictionary.lisp.

Function: find-last-path-leq (tree value) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: find-local-index (cell local-vtx position-indices) ¶

Package: fl.plot.
Source: plot.lisp.

Function: (setf find-local-index) (cell local-vtx position-indices) ¶

Package: fl.plot.
Source: plot.lisp.

Function: find-segment-coordinates (polygon s) ¶

Package: fl.function.
Source: spline.lisp.

Function: find-vertex-centered-block (vertex-key asa) ¶

Collects a block of keys for cells containing the vertex. Handles identification and hanging nodes.

Package: fl.geomg.
Source: geoblock.lisp.

Function: five-point-stencil-matrix (nx ny &key orientation with-constraint-p) ¶

Generate a CM matrix for the five-point stencil on a grid with the given number of active grid points in each dimension.

If @arg{with-constraint-p} is true, a matrix corresponding to the five-point discretization of a Neumann problem with an average zero constraint is generated.

This routine is a specialized version of @function{fd-laplace-matrix}. It is several times faster, but can only handle the 2D stencil. However, it has also the possibility to add the constraint equation which was observed to be a problem for direct sparse solvers.

Package: fl.matlisp.
Source: compressed.lisp.

Function: fix-identification-for-positive-dimension (mesh dim) ¶

Copies domain identification to cells of dimension larger 0.

Package: fl.mesh.
Source: triangulate.lisp.

Function: fl-matlisp->matlisp (obj) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: flat-disk-domain (r1 r2 h &rest paras) ¶

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: flat-mesh-p (obj) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: float-accuracy (type) ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: float-quantity-observe (name id &optional float-format length) ¶

Observes the float quantity which can be found with @arg{id} on the blackboard under a name @arg{name} which should be a string.

Package: fl.iteration.
Source: iterate.lisp.

Function: float-type-union (type1 type2) ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: for-each-in-range (worker tree &key from to direction) ¶

Walks tree in the given range and calls worker on each datum.

Package: net.scipolis.relations.
Source: relations.lisp.

Function: for-each-index (func dims) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: for-each-offset-pair (func dims initial-off1 offsets1 initial-off2 offsets2) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: foreign-convert (x) ¶

Package: fl.port.
Source: port.lisp.

Function: freudenthal-refinement (n) ¶

Returns all sub-simplices resulting from regular refinement of an n-dimensional simplex by Freudenthal’s algorithm. The simplices are given by their corners in barycentric coordinates (multiplied by 2 to work with integer coordinates).
Example: (freudenthal-refinement 1) -> ((#(2 0) #(1 1)) (#(1 1) #(0 2)))

Package: fl.mesh.
Source: simplex.lisp.

Function: from-key (select-items) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: further-laplace-tests () ¶

This function provides further tests for Laplace problems, partially on non-structured meshes and/or on domains with curved boundary.

Package: fl.application.
Source: unstructured.lisp.

Function: fuzzy-match-strings (string1 string2) ¶

Match two strings allowing abbreviations of the form ‘h-2’ for ‘homogenization-2d’.

Package: fl.demo.
Source: demo.lisp.

Function: g-corner-matrix (cell) ¶

Returns a matrix whose columns are the vertex positions of the cell’s vertices.

Package: fl.mesh.
Source: cell.lisp.

Function: g-corners (cell) ¶

The g-corners are the vertex positions of the cell’s vertices.

Package: fl.mesh.
Source: cell.lisp.

Function: gauss-lobatto-family (s) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-lobatto-rule-on-unit-interval (s) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-points-for-weight (beta s &optional float-p accuracy) ¶

Calculates the coordinates for a Gauss-type quadrature rule on [-1,1] with respect to the weight @math{w(y)=(1+y)^beta}.

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-rule-for-simplex (n s) ¶

This function calculates a quadrature rule for an s^n-point method on the n-simplex following the procedure described in @cite{(Stroud 1971)}, page 29. The result is a list of interpolation points.

Package: fl.discretization.
Source: quadrature.lisp.

Function: gauss-rule-for-weight (n s) ¶

The result is an s-point quadrature rule on the interval [0,1] with respect to the weight function w(y)=(1-y)^n which is exact for polynomials of order 2s-1.

Package: fl.discretization.
Source: quadrature.lisp.

Function: generate-sparse-matrix-vector-gemm!-template (job) ¶

Generates the GEMM-XX! routine defined by JOB.

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: generate-standard-matrix-gemm!-template (job) ¶

Generates the GEMM-XX! routine defined by JOB.

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: generate-subcells-method (refcell) ¶

Defines a method for @arg{subcells}. This function should be called when the cell class is initialized.

Package: fl.mesh.
Source: cell.lisp.

Function: generate-subcells-method-source (refcell) ¶

Generates code for a @function{subcells} method for @arg{cell-class}.

Package: fl.mesh.
Source: cell.lisp.

Function: get-cachesize () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: get-cpuinfo () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: get-dependents (node graph) ¶

Get the dependents of @arg{node} in @arg{graph}.

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: get-index (r order) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: get-key-from-dic (dic) ¶

Returns a key from dic if nonempty.

Package: fl.dictionary.
Source: dictionary.lisp.

Function: get-matrix-blocks (smat row-keys col-keys) ¶

Package: fl.discretization.
Source: sparseif.lisp.

Function: get-patch-property (cell mesh property) ¶

Returns the value of the property.

Package: fl.mesh.
Source: mesh.lisp.

Function: (setf get-patch-property) (cell mesh property) ¶

Sets the value of the property.

Package: fl.mesh.
Source: mesh.lisp.

Function: get-path-create (simplex corners-of-sub-simplex path &optional create) ¶

Returns the path (see the description in the definition of <child-info>) to the sub-simplex given by its corners in barycentric coordinates. Additionally, if the sub-simplex cannot be found, it generates a new entry in the refine-info vector and fills the barycentric-corners field.

Package: fl.mesh.
Source: simplex.lisp.

Function: get-place-in-tensor (tensor write-p &rest search-indices) ¶

Returns a getter/setter pair for the specified location.

Package: fl.matlisp.
Source: sparse-tensor.lisp.

Function: get-processors () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: get-remaining-inds (rank cinds) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: get-subcell-children (cell skel) ¶

Returns a vector filled with all children of the subcells of @arg{cell}.

Package: fl.mesh.
Source: refine.lisp.

Function: get-workers () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: gnuplot-close () ¶

Package: fl.graphic.
Source: gnuplot.lisp.

Function: gnuplot-input-stream () ¶

Package: fl.graphic.
Source: gnuplot.lisp.

Function: gnuplot-output-stream () ¶

Package: fl.graphic.
Source: gnuplot.lisp.

Function: gnuplot-tics (filename) ¶

Package: fl.graphic.
Source: gnuplot.lisp.

Function: gram-matrix (vectors functionals pairing) ¶

Computes the Gram matrix of vectors and functionals wrt pairing.

Package: fl.discretization.
Source: fe.lisp.

Function: gram-schmidt (x b &key tolerance) ¶

Orthogonalizes the columns of X wrt to the bilinear form given by the symmetric matrix B.

Package: fl.iteration.
Source: evpsolve.lisp.

Function: gram-schmidt-new (x b) ¶

Unfortunately, this routine squares a bad condition number of X.

Package: fl.iteration.
Source: evpsolve.lisp.

Function: hand-over (&rest args) ¶

Hands over the arguments to the next worker job.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: handshake-with-dx () ¶

Package: fl.graphic.
Source: dx.lisp.

Function: hanging-nodes-constraints (ansatz-space &key level) ¶

These are inter-level constraints.

Package: fl.discretization.
Source: constraints.lisp.

Function: heat-equation-computation (domain order levels &key output plot steps) ¶

Performs the heat equation demo.

Package: fl.application.
Source: heat.lisp.

Function: heuveline-rannacher-computation (order levels &key output plot) ¶

Performs the Heuveline-Rannacher demo.

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: heuveline-rannacher-domain () ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: heuveline-rannacher-dual-problem () ¶

Only for testing purposes, otherwise such a problem is automatically generated inside the error estimator cycle.

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: heuveline-rannacher-dual-problem-fe-rhs () ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: heuveline-rannacher-dual-problem-rhs (&key cell fe &allow-other-keys) ¶

Distributional rhs for the dual problem of the article by Heuveline&Rannacher. We distribute it to several points to ensure that all surrounding cells contribute.

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: heuveline-rannacher-problem () ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: heuveline-rannacher-rhs (x) ¶

Smooth rhs for the problem -Delta u = rhs in the H-R article.

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: hierarchical-mesh-p (obj) ¶

Package: fl.mesh.
Source: mesh.lisp.

Function: hierarchical-search (h-mesh test &key level) ¶

Hierarchical search for a subtree of cells in @arg{h-mesh} satisfying @arg{test}. A leaf cell is returned, if successful, otherwise NIL.

Package: fl.mesh.
Source: mesh.lisp.

Function: high-precision-integration-points (qrule) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: high-precision-integration-weights (qrule) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: histogram (array) ¶

Calculates a Histogram of Mandelbrot iteration numbers.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: hom-cdr-tests () ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: hom-ns-tests () ¶

Package: fl.flow-application.
Source: hom-ns.lisp.

Function: identification-coefficient-p (coeff) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: identification-constraints (ansatz-space &key level ip-type) ¶

Returns inter-level constraints between level and level+1. ip-type=t sets the constraint matrix to identity for the level-unknowns.

Package: fl.discretization.
Source: constraints.lisp.

Function: identification-matrix (ansatz-space &key region level imat) ¶

Creates the interpolation matrix for identifying boundaries or other parts of the domain.

Package: fl.discretization.
Source: constraints.lisp.

Function: increase-priority (pq obj) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: induced-refinement-of-subcell-refcells (refcell rule subcell) ¶

A refinement rule on refcell induces a refinement of all its subparts.

Package: fl.mesh.
Source: refine.lisp.

Function: inflow-velocity (y &key h um) ¶

Parabolic inflow profile for y in [0,H] with maximum at 0.3

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: initialize-cell-class (refcell factors) ¶

Initializes the per-class information for the given reference cell.

Package: fl.mesh.
Source: cell.lisp.

Function: initialize-elahom-calculation (dim order &optional levels) ¶

Initializes all local finite element data and local interpolation matrices for dimension @arg{dim} and finite elements of order @arg{order} on cubic cells. This file should be loaded before starting elahom performance measurements.

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Function: inlay-block-decomposition (blockit asa) ¶

Block decomposition for obtaining a coarse-grid solver which is robust against the size of the coefficient jump.

Package: fl.application.
Source: elahom.lisp.

Function: inlay-cell-problem (dim eps) ¶

Generates the inlay cell problem. Parameters are the coefficient of the inlay and the component of the cell vector.

Package: fl.application.
Source: hom-cdr.lisp.

Function: insert-key-value-in-tree (tree key-list value) ¶

Package: fl.dictionary.
Source: dictionary.lisp.

Function: insert-lapack-template (name return-value argument-specifications) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: insert-simplex-in-table (node-ids table) ¶

Package: fl.mesh.
Source: tetgen.lisp.

Function: install-electromagnetic-potential-demo () ¶

Package: fl.application.
Source: sturm.lisp.

Function: integrate-monomial (mono dim) ¶

Result of integrating a monomial given by a list of exponents in @arg{mono} over the reference simplex of dimension @arg{dim} as int_S(n) x^alpha = (alpha1! alpha2! ...) / (n+alpha1+...)!

Package: fl.discretization.
Source: quadrature.lisp.

Function: integrate-monomial-over-simplex-product (mono dims) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: integrate-over-reference-product-cell (poly factor-dims) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: integrate-over-reference-simplex (poly n) ¶

Integrates a polynomial over the reference simplex by splitting them into monomials and integrating those.

Package: fl.discretization.
Source: quadrature.lisp.

Function: interface-table (cell-tree) ¶

The result is a table which maps each cell to a pair which consists of the minimum and the maximum index of an n-dimensional father.

Package: fl.mesh.
Source: rcb.lisp.

Function: intermediate-coordinates (func pos) ¶

Package: fl.function.
Source: function.lisp.

Function: interpolate (mappings) ¶

Interpolates a vector of functions f of length n+1 on the reference n-simplex. The functions are understood as providing functional values for the n+1 n-1-dimensional boundary simplices.

Package: fl.mesh.
Source: blending.lisp.

Function: interpolate-coefficient (ansatz-space coeff-symbol &optional solution constraints-p) ¶

Interpolates a coefficient function into a solution for @arg{ansatz-space}.

Package: fl.discretization.
Source: sparseas.lisp.

Function: interpolate-function (as func &optional solution constraints-p) ¶

Interpolates @arg{func} with the ansatz-space @arg{as}.

Package: fl.discretization.
Source: sparseas.lisp.

Function: inverse-direction (dir) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: ip (mappings s) ¶

mappings contains n+1 mappings from barycentric side coordinates of length n, s contains n+1 coordinates 0.0<s[i]<1.0

Package: fl.mesh.
Source: blending.lisp.

Function: ip-coords (structure) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: (setf ip-coords) (structure) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: ip-weight (structure) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: (setf ip-weight) (structure) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: isotropic-mesh-on-rectangle-domain (domain) ¶

Generates a rather isotropic mesh on a domain consisting of rectangular patches.

Package: fl.mesh.
Source: meshgen.lisp.

Function: iteration-test (linit &rest args &key maxsteps &allow-other-keys) ¶

Tests the linear iteration @var{linit} on a model problem specified via keyword parameters in @var{args}.

Package: fl.application.
Source: tools.lisp.

Function: jacobi-polynomial (alpha beta s) ¶

Construct a Jacobi polynomial of type (a,b) and degree s. Jacobi polynomials of type (a,b) are orthogonal polynomials with respect to the weight @math{(1-x)^a * (1-x)^b}. Note that this version of these polynomials is normalized in a non-standard way such that its leading coefficient is 1.

Package: fl.discretization.
Source: quadrature.lisp.

Function: k-variate-zero (k) ¶

A k-variate zero coefficient

Package: fl.function.
Source: polynom.lisp.

Function: key->index (mat keys type) ¶

Returns a hash-table mapping keys to CCS offsets.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: key-cells (key mesh) ¶

If cell is identified, its identification is the key.

Package: fl.discretization.
Source: sparseas.lisp.

Function: konwihr-demo (&optional parallel-p) ¶

Package: fl.konwihr.
Source: heisig-neuss-2017.lisp.

Function: l2g-evaluator (cell) ¶

Returns an evaluator for @arg{cell} which maps barycentric coordinates to g-coordinates.

Package: fl.mesh.
Source: cell.lisp.

Function: lagrange-basis (cell order type) ¶

Computes the Lagrange basis for a product-cell accelerated. The idea is to construct the shapes with their associated dof-coordinates as a product of lower-dimensional shapes and coordinates.

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-basis-boundary (cell order type) ¶

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-basis-inner (cell order type) ¶

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-basis-simplex (cell order type) ¶

Computes the Lagrange basis for a cell. Should be applied only for simplices, because for product-cells the basis can be computed as a tensor product which is faster.

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-boundary-dofs (cell order type) ¶

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-coords-1d (order type) ¶

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-dofs (cell order type) ¶

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-polynomial-vector (cell order type) ¶

Returns a vector of polynomials representing the isoparametric mapping.

Package: fl.discretization.
Source: lagrange.lisp.

Function: lagrange-reference-parameters (refcell order type) ¶

Computes an energy-minimizing extension to the interior for the boundary lagrangian.

Package: fl.discretization.
Source: lagrange.lisp.

Function: lapack-external-name (name type &optional underscore-p) ¶

@arg{name} is either a string denoting the LAPACK name without the number-type prefix, or a list of two strings denoting the names for the real and complex routines without the number-type prefix. This is useful when we have separate but similar routines for the real and complex case like, e.g., the LAPACK routines SPGV and HEGV.

Package: fl.lapack.
Source: lapack.lisp.

Function: lapack-lisp-name (name type) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: lapack-type-p (type) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: laplace-eigenvalue-computation (domain &key output plot dirichlet multiplicity shift time nr-levels base-level) ¶

Function performing the eigenvalue demo for the Laplace operator.

Package: fl.application.
Source: evp-cdr.lisp.

Function: laplace-model-problem-locally-refined (&key dim order at-boundary-p nr-of-local-refinements) ¶

Package: fl.application.
Source: locref.lisp.

Function: laplace-stencil (dim) ¶

Returns the @{2*dim+1}-point stencil for the Laplace matrix on a uniform mesh as an array of rank @arg{dim}.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: last-key (sorted-ht) ¶

Returns the last key in a sorted hash table.
This function should be in the interface of the sorted hash table.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: legendre-polynomial (n) ¶

Returns the Legendre polynomial or order @arg{n} normalized in such a way that its leading coefficient is 1.

Package: fl.discretization.
Source: quadrature.lisp.

Function: linear-interpolate (s x y) ¶

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: list->real-tensor (tree) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: load-blas-library () ¶

Package: fl.alien.
Source: alien.lisp.

Function: load-lapack-library () ¶

Package: fl.alien.
Source: alien.lisp.

Function: load-superlu-library () ¶

Loads foreign code for accessing SuperLU.

Package: fl.alien.
Source: alien.lisp.

Function: load-umfpack-library () ¶

Loads foreign code for accessing UMFPACK.

Package: fl.alien.
Source: alien.lisp.

Function: local-evaluation-matrix (fe depth &optional type) ¶

Returns a local evaluation matrix for the refcell-refinement-vertices of the given depth.

Package: fl.plot.
Source: feplot.lisp.

Function: local-interpolation-matrix (cell ansatz-space type) ¶

Returns a local interpolation matrix for interpolating the given @arg{fe-class} from @arg{cell} to its children in @arg{h-mesh}. If @arg{type} is :local, interpolation extends only to the interior children.

Package: fl.discretization.
Source: fetransfer.lisp.

Function: local-mg (&rest key-args) ¶

Constructor of a geometric multigrid iteration of correction scheme type.

Package: fl.geomg.
Source: geomg.lisp.

Function: local-projection-matrix (cell ansatz-space) ¶

Returns a local projection matrix for projecting the given @arg{fe-class} from the children of @arg{cell} in @arg{h-mesh} to @arg{cell}.

Package: fl.discretization.
Source: fetransfer.lisp.

Function: lock (mat rk) ¶

Package: fl.discretization.
Source: sparseif.lisp.

Function: lock-region (object keys) ¶

Should not be used externally. Use WITH-REGION instead.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: m+-nil-reducer (&rest args) ¶

Package: fl.application.
Source: app-utils.lisp.

Function: m-times (x) ¶

Package: fl.function.
Source: spline.lisp.

Function: make-<child-info> (&key reference-cell barycentric-corners boundary-paths transform-a transform-b) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: make-analog-with-multiplicity (x multiplicity) ¶

Package: fl.matlisp.
Source: sparse-vector.lisp.

Function: make-bpx-demo (problem problem-name order level) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: make-bratu-demo (dim) ¶

Package: fl.application.
Source: bratu.lisp.

Function: make-cdr-bl-demo (dim order levels) ¶

Package: fl.application.
Source: bl-cdr.lisp.

Function: make-cell-class-information (&key dimension reference-cell factor-simplices nr-of-sides nr-of-vertices nr-of-subcells boundary-indices-of-subcells refine-info refinement-rules) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: make-dll-item (&key object succ pred) ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: make-driven-cavity-demo (dim order reynolds) ¶

Package: fl.flow-application.
Source: driven-cavity.lisp.

Function: make-effective-diffusion-inlay-domain-demo (dim order levels) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: make-effective-diffusion-porous-domain-demo (dim order levels) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: make-effective-elasticity-inlay-domain-demo (dim order levels) ¶

Package: fl.application.
Source: elahom.lisp.

Function: make-effective-elasticity-porous-domain-demo (dim order levels) ¶

Package: fl.application.
Source: elahom.lisp.

Function: make-effective-permeability-demo (dim order levels) ¶

Package: fl.flow-application.
Source: hom-ns.lisp.

Function: make-elasticity-model-problem-demo (domain domain-name) ¶

Package: fl.application.
Source: model-problem.lisp.

Function: make-full-compressed-matrix (nrows ncols &optional orientation) ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: make-heat-equation-demo (domain domain-name) ¶

Package: fl.application.
Source: heat.lisp.

Function: make-heuveline-rannacher-demo (order levels) ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: make-index (order key) ¶

Creates a binary tree for indexing the relation in the appropriate order.

Package: net.scipolis.relations.
Source: relations.lisp.

Function: make-ip (&key weight coords) ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: make-key (cell local-vtx) ¶

Returns a suitable hash-table key for the vertex of cell.

Package: fl.plot.
Source: plot.lisp.

Function: make-lagrange-basis-demo (type) ¶

Package: fl.application.
Source: discretization-demos.lisp.

Function: make-laplace-eigenvalue-demo (domain domain-name) ¶

Package: fl.application.
Source: evp-cdr.lisp.

Function: make-model-problem-demo (domain domain-name) ¶

Package: fl.application.
Source: model-problem.lisp.

Function: make-parpool-entry (&key object refcount key) ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: make-plot-iteration-behavior-demo (dim order level iteration &key it-name) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: make-procinfo (&key cpu core socket node) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: make-reference-product-cell (factor-dims) ¶

Package: fl.mesh.
Source: product-cell.lisp.

Function: make-reference-simplex (dim) ¶

Constructs a reference simplex of the given dimension.

Package: fl.mesh.
Source: simplex.lisp.

Function: make-smoother-demo (smoother smoother-name) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: make-smoother-performance-graph-demo (smoother smoother-name) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: make-special-local-vec (as cell evaluate-force-boundary-p) ¶

Package: fl.flow-application.
Source: boundary-force.lisp.

Function: make-stationary-schaefer-turek-demo (dim levels) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: make-stiffness-matrix-demo (dim max-level order) ¶

Package: fl.application.
Source: discretization-demos.lisp.

Function: make-tensor-index (tensor) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: make-two-grid-behavior-demo (dim order level) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: mandelbrot-box (x1 x2 y1 y2 nx ny &optional result-p) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: mandelbrot-iteration (c) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: map-cell-vec (func &rest vecs) ¶

Package: fl.mesh.
Source: cell.lisp.

Function: map-key (r x) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: map-skeleton (func skel) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: match-input (input leaves) ¶

Package: fl.demo.
Source: demo.lisp.

Function: matlisp (name &rest args) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: matlisp->fl-matlisp (obj) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: matlisp-symbol (string) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: matrix-loop-expansion (bindings body) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: mconvert (mat) ¶

Package: fl.application.
Source: elahom.lisp.

Function: measure-time-repeated (fn &optional delta) ¶

Calls fn repeatedly until it takes more than *mflop-delta* seconds. Returns the time in seconds together with the repetition count.

Package: fl.utilities.
Source: mflop.lisp.

Function: memoization-table (size test) ¶

Package: fl.dictionary.
Source: dictionary.lisp.

Function: memory-usage () ¶

Returns an approximation to the memory used at this moment.

Package: fl.port.
Source: port.lisp.

Function: mesh-file (kind) ¶

Returns the pathname for the mesh component @arg{kind} which may be :poly, :edge, :node, :element and :face.

Package: fl.mesh.
Source: triangle.lisp.

Function: meshes-pathname () ¶

Returns the pathname of the directory for @femlisp{} meshes.

Package: fl.mesh.
Source: triangle.lisp.

Function: meshplot-position-array (vertex-indices transformation) ¶

Package: fl.plot.
Source: meshplot.lisp.

Function: message (string &rest args) ¶

Package: fl.start.
Source: finalize.lisp.

Function: mg-cdr-tests () ¶

Package: fl.application.
Source: mg-cdr.lisp.

Function: min-in-row (mat row &optional min) ¶

Package: fl.multigrid.
Source: stueben.lisp.

Function: model-problem-computation (domain &key output plot time) ¶

Performs the model problem demo.

Package: fl.application.
Source: model-problem.lisp.

Function: model-problem-discretization (&key dim size level order &allow-other-keys) ¶

Returns stiffness matrix and right-hand side for the discretization of the Laplace model problem on a cube of dimension @var{dim} using a mesh of meshwidth 1/@var{size} cells in each dimension with Lagrange finite elements of order @var{order}.

Package: fl.application.
Source: tools.lisp.

Function: model-problem-stiffness-matrix (dim level order) ¶

Returns the stiffness matrix for the @arg{dim}-dimensional model problem discretized on level @arg{level} with finite elements of order @arg{order}.

Package: fl.application.
Source: discretization-demos.lisp.

Function: modify-diagonal (d r omega) ¶

Implements the diagonal modification for ILU_mod.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: msym-ncols (matrix-symbol) ¶

Returns a symbol of the form <matrix-symbol>-NCOLS.

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: msym-nrows (matrix-symbol) ¶

Returns a symbol of the form <matrix-symbol>-NROWS.

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: msym-pos (matrix-symbol) ¶

Returns a symbol of the form <matrix-symbol>-POS.

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: msym-size (matrix-symbol) ¶

Returns a symbol of the form <matrix-symbol>-SIZE.

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: multi-worker (popper worker) ¶

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: multiple-barycentric-coordinates (cell local-positions) ¶

Returns a vector of weight-vectors for the reference cell @arg{refcell} at @arg{local-positions}.

Package: fl.mesh.
Source: cell.lisp.

Function: multiple-barycentric-gradients (cell local-positions) ¶

Returns a vector of weight-vectors for the reference cell @arg{refcell} at @arg{local-positions}.

Package: fl.mesh.
Source: cell.lisp.

Function: n-ball-dphi (x) ¶

Package: fl.mesh.
Source: domain.lisp.

Function: n-ball-phi (x) ¶

Package: fl.mesh.
Source: domain.lisp.

Function: navier-stokes-fe-tests () ¶

Package: fl.navier-stokes-fe.
Source: navier-stokes-fe.lisp.

Function: navier-stokes-streamline-diffusion-coefficient (dim) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: needed-order (select-items) ¶

Returns an order in which all fixed variables occur first, and also the number of fixed and variable positions.

Package: net.scipolis.relations.
Source: relations.lisp.

Function: nest (x n) ¶

Nest x into n levels of parentheses.

Package: fl.function.
Source: polynom.lisp.

Function: new-blas-method-code (name class-name template-args actual-args blas-macros body) ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: new-dispatcher-code (name template-args body) ¶

Generates a method which generates code for a type-specialized method.

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: new-gauss-rule-for-simplex (n s) ¶

This is an alternative to @function{gauss-rule-for-simplex} which is based on @function{cone-rule-for-simplex}.

Package: fl.discretization.
Source: quadrature.lisp.

Function: new-index (old-index new-order) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: new-vector-dof-from-dof (dof component subcell-offsets) ¶

Generates a vector-dof from a scalar dof.

Package: fl.discretization.
Source: fe.lisp.

Function: next (path &optional direction) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: nr-of-refinement-vertices (cell depth) ¶

Package: fl.plot.
Source: plot.lisp.

Function: ns-driven-cavity-demo (dim order levels &key delta base-level plot-mesh plot output reynolds smooth-p watch-points) ¶

Performs the driven cavity demo.

Package: fl.flow-application.
Source: driven-cavity.lisp.

Function: number-super-type (types) ¶

Returns the union of the number types in @arg{types}.

Package: fl.matlisp.
Source: store-vector.lisp.

Function: number-type (lapack-type) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: numbering (keys &optional count) ¶

Returns a hash-table mapping each element of @arg{keys} to an index.

Package: fl.matlisp.
Source: sparselu.lisp.

Function: optimal-thread-number () ¶

Old code. The optimal thread number depends on the kind of application and cannot really be determined in this simple way. Probably better is to use the introspection in @file{parallel.lisp}.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: oscillating-force (dim) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: p-div-coefficient (dim &optional eta) ¶

Pressure coefficient with derivative on test function

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: p-nomials-of-degree (simplex deg &optional type) ¶

Returns a list of monomials of degree = deg or <= deg for a simplex.

Package: fl.discretization.
Source: fe.lisp.

Function: parameter-name (para) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: parameter-order (para) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: parpool-entry-p (object) ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: patch-boundary-mesh (patch mesh) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: patch-mesh (patch refpatch-mesh) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: pi-core (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: (setf pi-core) (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: pi-cpu (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: (setf pi-cpu) (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: pi-node (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: (setf pi-node) (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: pi-socket (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: (setf pi-socket) (structure) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: plot-diffusion (problem &key refinements depth parametric) ¶

Plots the first component of the diffusion tensor.

Package: fl.application.
Source: app-utils.lisp.

Function: plot-dimension (dim) ¶

Package: fl.plot.
Source: meshplot.lisp.

Function: plot-iteration-behavior (dim order level iteration &key nr-steps) ¶

Plots the propagation of the error for some iteration. The iteration is applied to a finite element discretization with Lagrange finite elements of a given order of the Laplace model problem in dim space dimensions on a mesh with mesh-width 2^{-level}. This is done by plotting the approximation starting with an initial random guess and right-hand side 0.

Package: fl.application.
Source: multigrid-demos.lisp.

Function: plot-lagrange-basis (order type) ¶

Plots the 1D Lagrange basis of the given order and type.

Package: fl.application.
Source: discretization-demos.lisp.

Function: plot-transformation (dim) ¶

The default plot transformation is simply a projection on R^3.

Package: fl.plot.
Source: meshplot.lisp.

Function: polar->rect (r1 r2 phi1 phi2 &optional flipped-p delta) ¶

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: poly-eval (coeffs coords) ¶

Package: fl.function.
Source: polynom.lisp.

Function: pool-test () ¶

Package: fl.dictionary.
Source: pool.lisp.

Function: porous-cell-problem (dim &key radius a) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: position-array (cells position-indices depth &optional transformation) ¶

Collects all positions in the hash-table POSITION-INDICES into an array.

Package: fl.plot.
Source: plot.lisp.

Reader: ppe-key (instance) ¶

Writer: (setf ppe-key) (instance) ¶

Package: fl.dictionary.
Source: pool.lisp.
Target Slot: key.

Reader: ppe-object (instance) ¶

Writer: (setf ppe-object) (instance) ¶

Package: fl.dictionary.
Source: pool.lisp.
Target Slot: object.

Reader: ppe-refcount (instance) ¶

Writer: (setf ppe-refcount) (instance) ¶

Package: fl.dictionary.
Source: pool.lisp.
Target Slot: refcount.

Function: pq-get (pq obj) ¶

Lookup @arg{obj} from priority queue.

Package: fl.mesh.
Source: triangle.lisp.

Function: (setf pq-get) (pq obj) ¶

Set the value @arg{obj} from priority queue.

Package: fl.mesh.
Source: triangle.lisp.

Function: pq-insert (pq obj &optional value) ¶

Always insert at highest priority.

Package: fl.mesh.
Source: triangle.lisp.

Function: pq-pop (pq) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: pq-remove (pq obj) ¶

Remove @arg{obj} from priority queue.

Package: fl.mesh.
Source: triangle.lisp.

Function: pressure-boundary-conditions (dim value) ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: print-matrix (matrix stream) ¶

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: print-polynomial (poly &optional stream reversed) ¶

Package: fl.function.
Source: polynom.lisp.

Function: print-tensor (tensor stream) ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: problem-discretization (problem &key parametric level order &allow-other-keys) ¶

Returns stiffness matrix and rhs for a discretization of order @var{order} on a mesh with a mesh-size 2^@var{-level}.

Package: fl.application.
Source: tools.lisp.

Function: process-wait (process) ¶

Waits for @arg{process} to exit.

Package: fl.port.
Source: port.lisp.

Function: product-cell-class (factor-dims &optional mapped distorted) ¶

Package: fl.mesh.
Source: product-cell.lisp.

Function: product-table (skel1 skel2) ¶

Package: fl.mesh.
Source: product-cell.lisp.

Function: project (vector basis pairing) ¶

Projects vector on the subspace given by basis orthogonal to the scalar product in pairing.

Package: fl.discretization.
Source: fe.lisp.

Function: projection-coefficients (vector basis pairing) ¶

Returns the coefficients for a basis representation of a projection of vector on the subspace given by basis wrt the scalar product pairing.

Package: fl.discretization.
Source: fe.lisp.

Function: projection-matrix (flags) ¶

Package: fl.mesh.
Source: anisotropic.lisp.

Function: q-nomials-of-degree (cell deg &optional type) ¶

Builds the Qn = Pn-Pn-Pn ... on a product-cell.

Package: fl.discretization.
Source: fe.lisp.

Function: qlsolve (f df rhs x0) ¶

Solves a scalar quasilinear equation of the form f(x)*x=r with a Newton iteration.

Package: fl.iteration.
Source: nlsolve.lisp.

Function: quit () ¶

Quits Femlisp.

Package: fl.port.
Source: port.lisp.

Function: rcb-ordered-cells (skel) ¶

Package: fl.mesh.
Source: rcb.lisp.

Function: rcb-sort-items (items &key item->cell root-cells) ¶

Package: fl.mesh.
Source: rcb.lisp.

Function: read-next-numbers-line (stream) ¶

Reads the numbers from the next nonempty and uncommented line from @arg{stream}.

Package: fl.mesh.
Source: triangle.lisp.

Function: read-next-uncommented-line (stream) ¶

Reads the next nonempty line from @arg{stream} which does not begin with @code{#}. NIL indicates EOF.

Package: fl.mesh.
Source: triangle.lisp.

Function: read-nodes (stream nr-nodes &optional dim) ¶

Package: fl.mesh.
Source: tetgen.lisp.

Function: read-numbers-from-string (string) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: read-tetgen-mesh () ¶

Reads a mesh from Tetgen output.

Package: fl.mesh.
Source: tetgen.lisp.

Function: read-tetgen-mesh-for (interior-patch &optional mesh) ¶

Reads a mesh from Tetgen output.

Package: fl.mesh.
Source: tetgen.lisp.

Function: read-tetgen-simplices (stream vertices &optional n) ¶

Package: fl.mesh.
Source: tetgen.lisp.

Function: read-triangle-mesh-for (interior-patch &optional mesh) ¶

Builds or extends @arg{mesh} using the output from Triangle for meshing @arg{interior-patch}.

Package: fl.mesh.
Source: triangle.lisp.

Function: real-to-complex-vector (dvec) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: recursive-bisection (cells) ¶

Cells should be the ’substance’ cells, i.e. the highest dimensional cells of a mesh.

Package: fl.mesh.
Source: rcb.lisp.

Function: refcell-refinement-vertex-positions (cell level) ¶

Package: fl.plot.
Source: plot.lisp.

Function: refcell-refinement-vertices (cell level) ¶

Returns the vertices of the @arg{level}-refinement of the reference cell of @arg{cell} as a vector.

Package: fl.plot.
Source: plot.lisp.

Function: refine-cell-interior (refinfo cell subcell-refinements) ¶

Refines @arg{cell} by filling the first position of the vector @arg{subcell-refinements} with freshly generated children. The other positions should already be filled with the refinements of the cell’s boundary. Returns a vector of children.

Package: fl.mesh.
Source: refine.lisp.

Function: refine-info->refinement-rule (refcell refine-info) ¶

This generates a refinement-rule from the older refine-info data.

Package: fl.mesh.
Source: refine.lisp.

Function: refinement-rules (cell) ¶

Returns refinement information for the cell.

Package: fl.mesh.
Source: cell.lisp.

Function: refpatch-boundary-mesh (patch boundary-mesh) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: regression-test-femlisp (&key logfile passes) ¶

Package: fl.application.
Source: regression-tests.lisp.

Function: reload-foreign-code () ¶

Package: fl.alien.
Source: alien.lisp.

Function: remove-all-lapack-functions (name) ¶

Removes the CL bindings to the LAPACK functions categorized by @arg{name}.

Package: fl.lapack.
Source: lapack.lisp.

Function: remove-worker (group thread) ¶

Removes @arg{thread} from @arg{group}.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: rule-position (id cell) ¶

Package: fl.mesh.
Source: refine.lisp.

Function: safe-divide-by-zero (a b) ¶

Package: fl.iteration.
Source: solve.lisp.

Function: safer-find-cell-from-position (mesh global-pos &optional error-p) ¶

Package: fl.discretization.
Source: feeval.lisp.

Function: sample-domain () ¶

Generates a sample domain which is a modified unit-cube whose upper side bends upwards in the x_0-direction.

Package: fl.mesh.
Source: tetgen.lisp.

Function: sample-mesh (n &optional check-p) ¶

Package: fl.mesh.
Source: tetgen.lisp.

Function: schaefer-turek-observe (dim &optional drag-lift-p) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: send-task (group task) ¶

Send a task to the work-group.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: set-lagrange-ansatz-space-vector (asv func) ¶

Sets an ansatz-space-vector to interpolate a given function. This is still a suboptimal implementation for vector functions.

Package: fl.discretization.
Source: sparseif.lisp.

Function: shapes-and-dof-coords (factor-simplices order type) ¶

Computes simultaneously shapes and dof-coords for a simplex-product-cell as products of the simplex factor shapes and dofs.

Package: fl.discretization.
Source: lagrange.lisp.

Function: show-demo (demo) ¶

Shows the given demo.

Package: fl.demo.
Source: demo.lisp.

Function: sigma-p (coeff) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: simple-ball-inlay-cell-problem (dim eps) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: simple-consing (n) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: simple-newton (f x-start &key approximate-gradient error-p output) ¶

A simple Newton iteration for converting global to local coordinates.

Package: fl.mesh.
Source: cell.lisp.

Function: simple-pressure-boundary-conditions (dim dir value) ¶

This function is a preliminary version which works only for boundaries lying in a coordinate hyperplane.

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: simple-square-inlay-cell-problem (dim) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: simplex-corner (dim i) ¶

Creates the i-th corner of a simplex of dimension dim. The 0-th corner is the zero-vector. The others are equal to (unit-vector dim 1-i).

Package: fl.mesh.
Source: simplex.lisp.

Function: simplify (list) ¶

Package: fl.function.
Source: polynom.lisp.

Function: sinusoidal-boundary-layer-cell-problem (dim &rest key-args) ¶

Returns a boundary layer problem for a sinusoidally oscillating domain.

Package: fl.application.
Source: bl-cdr.lisp.

Function: skeleton->refinement-rule (names refcell skeleton) ¶

Setup the refinement rule from a refined skeleton.

Package: fl.mesh.
Source: refine.lisp.

Function: skeleton-substance (skel) ¶

The substance of a skeleton are those cells which are not boundary of a cell in @arg{skel}. This function returns those cells in the form of a hash-table.

Package: fl.mesh.
Source: skeleton.lisp.

Function: slow-ip-gradients (fe positions) ¶

Package: fl.discretization.
Source: fe.lisp.

Function: smooth-coefficient-cell-problem (dim) ¶

Package: fl.application.
Source: hom-cdr.lisp.

Function: smoother-demo-execute (smoother) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: smoother-graph-execute (smoother) ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: smoother-performance-test (&key dim order level smoother output simplex) ¶

Tests performance of smoother on a Laplace model problem. See make-smoother-demo for more information.

Package: fl.application.
Source: multigrid-demos.lisp.

Function: solution-dependent (coeffs) ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: solve-laplace (problem level order &key parametric solver) ¶

An old routine for solving the Laplace problem. You should use the interface provided by @code{solve} which provides automatic and more general solving together with a more flexible customization.

Package: fl.application.
Source: tools.lisp.

Function: solve-moment-system (b &optional n) ¶

Solves moment system by Jacobi iteration.

Package: fl.function.
Source: spline.lisp.

Function: solve-sturm-problem (nr-levels order) ¶

Package: fl.application.
Source: sturm.lisp.

Function: some-components (problem) ¶

Find a component list even in the case where there is a variable number of components across the domain.

Package: fl.problem.
Source: pde-problem.lisp.

Function: speedup-test (func) ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: spline-right-hand-side (x) ¶

Package: fl.function.
Source: spline.lisp.

Function: st-cylinder (&key dim radius offset &allow-other-keys) ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: st-cylinder-boundary-p (cell mesh) ¶

Predicate checking if cell is on the cylinder boundary of the correct dimension.

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: standard-classifier (domain) ¶

Package: fl.mesh.
Source: domain.lisp.

Function: standard-matrix-generator (type) ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: standard-matrix-indexing (i j nrows &optional ncols) ¶

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: stencil-matrix (stencil sizes) ¶

@arg{stencil} should be an array of rank dim, each dimension being 3, @arg{sizes} is either an integer or an integer vector of length dim. Each size denotes the number of interior mesh-points in the respective dimension.

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: store-vector-generator (type) ¶

Package: fl.matlisp.
Source: store-vector.lisp.

Function: sturm-domain () ¶

Package: fl.application.
Source: sturm.lisp.

Function: sturm-mesh (domain) ¶

Package: fl.application.
Source: sturm.lisp.

Function: sturm-problem (domain) ¶

Package: fl.application.
Source: sturm.lisp.

Function: sub-cells-of-child (child-corners) ¶

Package: fl.mesh.
Source: simplex.lisp.

Function: sub-cells-of-children (n) ¶

Package: fl.mesh.
Source: simplex.lisp.

Function: sub-side-mapping (k sk j dim) ¶

Returns the side mapping j for the intersection of the simplex with a level surface sk=const. @arg{dim} is the dimension of the original simplex.

Package: fl.mesh.
Source: blending.lisp.

Function: subcell-access-indices (cells) ¶

Constructs an ordering of all subcells of the list @arg{cells}. All cells in this list should have the same dimension.

Package: fl.mesh.
Source: cell.lisp.

Function: substance-boundary-cells (skel) ¶

Find boundary of the ’flesh’ and build up a table mapping those cells to the neighboring substance cells.

Package: fl.mesh.
Source: skeleton.lisp.

Function: superlu-solver () ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: swap-rows (j k mat-store m n) ¶

Swaps rows j and k in an m x n-matrix.

Package: fl.matlisp.
Source: standard-matrix-lr.lisp.

Function: symbol-store (symbol) ¶

Returns a symbol of the form <symbol>-STORE.

Package: fl.matlisp.
Source: store-vector.lisp.

Function: symmetric-packed-store (a &optional part) ¶

Package: fl.matlisp.
Source: hegv.lisp.

Function: synchronize-identification (new-skel skel table) ¶

Synchronizes identification information between @arg{new-skel} and @arg{skel}. @arg{table} is a hash-table mapping cells from new-skel to skel.

Package: fl.mesh.
Source: skeleton-build.lisp.

Function: terminate-workers () ¶

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: test-alienc () ¶

Package: fl.alienc.
Source: alienc.lisp.

Function: test-amg-cdr () ¶

Package: fl.application.
Source: amg-cdr.lisp.

Function: test-amop () ¶

Package: fl.amop.
Source: amop.lisp.

Function: test-arrays () ¶

Package: fl.matlisp.
Source: array-blas.lisp.

Function: test-assembly-heap () ¶

Package: fl.discretization.
Source: assembly-heap.lisp.

Function: test-bl-cdr () ¶

Package: fl.application.
Source: bl-cdr.lisp.

Function: test-bl-cell () ¶

Package: fl.domains.
Source: bl-cell.lisp.

Function: test-blas (fsym size &key generator flop-calculator nr-of-arguments) ¶

Test the performance of BLAS routines.

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: test-blas-basic () ¶

Package: fl.matlisp.
Source: blas-basic.lisp.

Function: test-call-matlisp () ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: test-cdr () ¶

Package: fl.cdr.
Source: cdr.lisp.

Function: test-circle-ring-domain () ¶

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: test-coeffplot () ¶

Package: fl.plot.
Source: coeffplot.lisp.

Function: test-compressed () ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: test-constraints () ¶

Package: fl.discretization.
Source: constraints.lisp.

Function: test-demo () ¶

Package: fl.demo.
Source: demo.lisp.

Function: test-dictionaries () ¶

Package: fl.dictionary.
Source: dictionary.lisp.

Function: test-driven-cavity () ¶

Package: fl.flow-application.
Source: driven-cavity.lisp.

Function: test-elasticity () ¶

Package: fl.elasticity.
Source: elasticity.lisp.

Function: test-elasticity-model-problem () ¶

Package: fl.application.
Source: model-problem.lisp.

Function: test-ellsys () ¶

Package: fl.ellsys.
Source: ellsys.lisp.

Function: test-error-estimator () ¶

Package: fl.strategy.
Source: error-estimator.lisp.

Function: test-error-indicator () ¶

Package: fl.strategy.
Source: error-indicator.lisp.

Function: test-evp () ¶

Package: fl.problem.
Source: evp.lisp.

Function: test-evpsolve () ¶

Package: fl.iteration.
Source: evpsolve.lisp.

Function: test-f (cell f) ¶

Returns a mapping for cell transformed with f

Package: fl.mesh.
Source: blending.lisp.

Function: test-fe () ¶

Package: fl.discretization.
Source: fe.lisp.

Function: test-fe-interpolation () ¶

Package: fl.strategy.
Source: fe-interpolation.lisp.

Function: test-fe-stationary () ¶

Package: fl.strategy.
Source: fe-stationary.lisp.

Function: test-fedisc () ¶

Package: fl.discretization.
Source: fedisc.lisp.

Function: test-femlisp-parallel () ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: test-fetransfer () ¶

Package: fl.discretization.
Source: fetransfer.lisp.

Function: test-function () ¶

Package: fl.function.
Source: function.lisp.

Function: test-function (func) ¶

Package: fl.tests.
Source: tests.lisp.

Function: test-function-plot () ¶

Package: fl.plot.
Source: function-plot.lisp.

Function: test-general () ¶

Package: fl.utilities.
Source: general.lisp.

Function: test-geomg () ¶

Package: fl.geomg.
Source: geomg.lisp.

Function: test-ggev () ¶

Package: fl.matlisp.
Source: ggev.lisp.

Function: test-gradient (func pos) ¶

Tests if numerical gradient and gradient agree.

Package: fl.function.
Source: function.lisp.

Function: test-heat-equation () ¶

Package: fl.application.
Source: heat.lisp.

Function: test-hegv () ¶

Package: fl.matlisp.
Source: hegv.lisp.

Function: test-heuveline-rannacher () ¶

Package: fl.application.
Source: heuveline-rannacher-2003.lisp.

Function: test-hole-domain () ¶

Package: fl.domains.
Source: hole-domain.lisp.

Function: test-homogenization-elasticity () ¶

Package: fl.application.
Source: elahom.lisp.

Function: test-inlay-domain () ¶

Package: fl.domains.
Source: inlay-domain.lisp.

Function: test-integration-rule (points weights &optional output) ¶

Tests the given rule against monomials of increasing degree. As a by-product this determines the order of the rule.

Package: fl.discretization.
Source: quadrature.lisp.

Function: test-iterate () ¶

Package: fl.iteration.
Source: iterate.lisp.

Function: test-krylow () ¶

Package: fl.iteration.
Source: krylow.lisp.

Function: test-lagrange () ¶

Package: fl.discretization.
Source: lagrange.lisp.

Function: test-lapack () ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: test-laplace-model-problem () ¶

Package: fl.application.
Source: model-problem.lisp.

Function: test-linit () ¶

Most tests can be found in linsolve.lisp.

Package: fl.iteration.
Source: linit.lisp.

Function: test-linsolve () ¶

Linear solving on different types of vector/matrix representations.

Package: fl.iteration.
Source: linsolve.lisp.

Function: test-macros () ¶

Package: fl.macros.
Source: macros.lisp.

Function: test-matlisp-vector-combination () ¶

Package: fl.matlisp.
Source: compat.lisp.

Function: test-meshplot () ¶

Package: fl.plot.
Source: meshplot.lisp.

Function: test-mflop () ¶

Package: fl.utilities.
Source: mflop.lisp.

Function: test-multigrid-demos () ¶

Package: fl.application.
Source: multigrid-demos.lisp.

Function: test-navier-stokes () ¶

Package: fl.navier-stokes.
Source: navier-stokes.lisp.

Function: test-nlsolve () ¶

Package: fl.iteration.
Source: nlsolve.lisp.

Function: test-number-blas () ¶

Package: fl.matlisp.
Source: number-blas.lisp.

Function: test-parallel-adaptions () ¶

Package: fl.parallel.
Source: parallel-adaptions.lisp.

Function: test-parallel-heap () ¶

Package: fl.dictionary.
Source: parallel-heap.lisp.

Function: test-pde-problem () ¶

Package: fl.problem.
Source: pde-problem.lisp.

Function: test-plot-dx () ¶

Package: fl.plot.
Source: plot-dx.lisp.

Function: test-plot-gnuplot () ¶

Package: fl.plot.
Source: plot-gnuplot.lisp.

Function: test-polynom () ¶

Package: fl.function.
Source: polynom.lisp.

Function: test-port () ¶

Package: fl.port.
Source: port.lisp.

Function: test-problem () ¶

Package: fl.problem.
Source: problem.lisp.

Function: test-quadrature () ¶

Package: fl.discretization.
Source: quadrature.lisp.

Function: test-refined-laplace-problem () ¶

Package: fl.application.
Source: locref.lisp.

Function: test-relations () ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: test-rothe () ¶

Package: fl.strategy.
Source: rothe.lisp.

Function: test-rothe-ellsys () ¶

Package: fl.strategy.
Source: rothe-ellsys.lisp.

Function: test-schaefer-turek () ¶

Package: fl.schaefer-turek.
Source: schaefer-turek-1996.lisp.

Function: test-solve () ¶

Package: fl.iteration.
Source: solve.lisp.

Function: test-sparse-matrix () ¶

Package: fl.matlisp.
Source: sparse-matrix.lisp.

Function: test-sparse-tensor () ¶

Package: fl.matlisp.
Source: sparse-tensor.lisp.

Function: test-sparse-vector () ¶

Package: fl.matlisp.
Source: sparse-vector.lisp.

Function: test-sparseas () ¶

Package: fl.discretization.
Source: sparseas.lisp.

Function: test-sparseif () ¶

Package: fl.discretization.
Source: sparseif.lisp.

Function: test-sparselu () ¶

Package: fl.matlisp.
Source: sparselu.lisp.

Function: test-spline () ¶

Package: fl.function.
Source: spline.lisp.

Function: test-standard-matrix () ¶

Package: fl.matlisp.
Source: standard-matrix.lisp.

Function: test-standard-matrix-blas () ¶

Package: fl.matlisp.
Source: standard-matrix-blas.lisp.

Function: test-standard-matrix-lr () ¶

Package: fl.matlisp.
Source: standard-matrix-lr.lisp.

Function: test-store-vector-blas () ¶

Package: fl.matlisp.
Source: store-vector.lisp.

Function: test-stueben () ¶

Package: fl.multigrid.
Source: stueben.lisp.

Function: test-sturm () ¶

Package: fl.application.
Source: sturm.lisp.

Function: test-superlu () ¶

Package: fl.alien.
Source: superlu.lisp.

Function: test-tensor () ¶

Package: fl.matlisp.
Source: tensor.lisp.

Function: test-time () ¶

Package: fl.problem.
Source: time.lisp.

Function: test-umfpack () ¶

Package: fl.alien.
Source: umfpack.lisp.

Function: test-utilities () ¶

Package: fl.utilities.
Source: utilities.lisp.

Function: test-v-cycle-convergence (dim order level &key smoother steps galerkin-p output cr-max base-level combination cg type coarse-grid-iteration smoothing-steps) ¶

Solves with a V-cycle and prints the average convergence rate. If cr-max is provided, it is checked if the convergence rate is smaller than this value.

Package: fl.application.
Source: mg-cdr.lisp.

Function: test-vector () ¶

Package: fl.matlisp.
Source: vector.lisp.

Function: test-vector-methods () ¶

Package: fl.matlisp.
Source: vector-methods.lisp.

Function: thread-local-memoization-pool (&key test) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: thread-local-memoize (pool func args) ¶

Package: fl.parallel.
Source: parallel.lisp.

Function: to-key (select-items) ¶

Package: net.scipolis.relations.
Source: relations.lisp.

Function: translate-list (translator list) ¶

Package: fl.matlisp.
Source: call-matlisp.lisp.

Function: translate-types (spec type) ¶

Package: fl.lapack.
Source: lapack.lisp.

Function: triangle-mapping (r phi1 phi2 &optional flipped-p) ¶

Maps the unit triangle to a circle segment. The triangle segment from (0,1) to (1,0) is mapped linearly to the arclength. The flipped-p parameter does a reflection across the y-axis.

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: triangulate-patch (patch boundary-mesh &key meshsize) ¶

Package: fl.mesh.
Source: triangle.lisp.

Function: trsm (lr-store b-store m n &key side unit-diagonal) ¶

Package: fl.matlisp.
Source: standard-matrix-lr.lisp.

Function: two-sorted-parts (n) ¶

Returns all partitions of {1,...,n} which consist of two sorted
parts. This is used in Freudenthal/Bey’s simplex refinement.
Example: (two-sorted-parts 2) -> ((() (1 2)) ((1) (2)) ((2) (1)) ((1 2) ()))

Package: fl.mesh.
Source: simplex.lisp.

Function: umfpack-solver () ¶

Package: fl.matlisp.
Source: compressed.lisp.

Function: undisplace-array (array) ¶

Return the fundamental array and the start and end positions into it of the displaced array. (Erik Naggum, c.l.l. 17.1.2004)

Package: fl.utilities.
Source: utilities.lisp.

Function: uniform-number-type (vec) ¶

Tries to find a uniform type for the numbers contained in @arg{vec}.

Package: fl.matlisp.
Source: store-vector.lisp.

Function: unlock (mat) ¶

Package: fl.discretization.
Source: sparseif.lisp.

Function: unlock-region (object keys) ¶

Should not be used externally. Use WITH-REGION instead.

Package: fl.parallel.
Source: multiprocessing.lisp.

Function: unmapped-cell-class (class) ¶

Returns the cell class without mapping mixin.

Package: fl.mesh.
Source: cell.lisp.

Function: update-cell-extreme-values (cell x min/max component) ¶

Computes the extreme values of @arg{x} on @arg{cell}. Note that the current implementation works correctly only for Lagrange finite elements, and even for those only approximate extrema are obtained.

Package: fl.discretization.
Source: feeval.lisp.

Function: update-demo-status (demo) ¶

Checks if all leaves have been visited. If yes, the demo is added to the visited demos.

Package: fl.demo.
Source: demo.lisp.

Function: update-i-p-sol (blackboard) ¶

For a given local refinement this updates interpolation and projection operators on the blackboard and interpolates the solution to the new surface. This is used in the strategy package.

Package: fl.strategy.
Source: strategy-utilities.lisp.

Function: vertex-index-table (skel) ¶

Returns a hash-table vertices->indices for refinement skeletons of reference cells. This is needed for plotting.

Package: fl.plot.
Source: plot.lisp.

Function: volume-of-cell (cell &optional s) ¶

Package: fl.discretization.
Source: fe.lisp.

Function: wait-for-dx () ¶

Package: fl.graphic.
Source: dx.lisp.

Function: wait-for-gnuplot () ¶

Does not work - somehow Gnuplot does not print anything to its output stream in contrast to DX.

Package: fl.graphic.
Source: gnuplot.lisp.

Function: watch-dc-center-velocity (dim) ¶

Returns a observe list for watching the velocity at the center of the driven cavity.

Package: fl.flow-application.
Source: driven-cavity.lisp.

Function: weight-lists (simplices local-pos) ¶

A list of weights for several simplices at once.

Package: fl.mesh.
Source: product-cell.lisp.

Function: weight-lists-grad-product-cell (cell local-pos) ¶

Package: fl.mesh.
Source: product-cell.lisp.

Function: weight-lists-grad-simplex (simplex) ¶

The result of this function are weight-lists with each weight-list corresponding to the weights for a partial derivative.

Package: fl.mesh.
Source: product-cell.lisp.

Function: without-component (s k) ¶

Package: fl.mesh.
Source: blending.lisp.

Function: work-done (cq) ¶

Package: fl.discretization.
Source: sparseif.lisp.

Function: write-1d-skeleton-to-poly-file (patch mesh vertices) ¶

Writes out the 1d-skeleton for @arg{mesh} to a @code{.poly}-file. Returns a hash-table mapping the cells mesh to ids, a vector mapping ids to vertices and a vector mapping ids to lines. @arg{vertices} is a list of vertices defining the correct ordering of vertices.

Package: fl.mesh.
Source: triangle.lisp.

Function: write-2d-skeleton-to-poly-file (patch mesh vertices) ¶

Writes out the 2d-skeleton for @arg{mesh} to a @code{.poly}-file. Returns a hash-table mapping the cells mesh to ids, a vector mapping ids to vertices and a vector mapping ids to lines. @arg{vertices} is a list of vertices defining the correct ordering of vertices.

Package: fl.mesh.
Source: tetgen.lisp.

Function: write-monomial (coeff&monomial stream) ¶

Package: fl.function.
Source: polynom.lisp.

Function: write-positions (stream position-array &optional header) ¶

Write a header and all positions to the stream.

Package: fl.plot.
Source: plot.lisp.

Function: write-vtk-positions (stream position-array) ¶

Package: fl.plot.
Source: plot-vtk.lisp.

Function: xsinx-bl-cell (dim &rest rest &key amplitude &allow-other-keys) ¶

Returns a boundary layer cell with a sinusoidally oscillating lower boundary.

Package: fl.domains.
Source: bl-cell.lisp.

Function: zap-to-unit-vectors (v) ¶

Package: fl.domains.
Source: circle-ring-domain.lisp.

Function: zero-k-jet (f k) ¶

Package: fl.function.
Source: function.lisp.

Function: zeros-of-separating-family (family n accuracy &optional float-p) ¶

This function works on the assumption that p_0=const and the zeros of p_n-1 together with the interval boundaries separate the zeros of p_n. Then an interval method is performed for each zero. Of course, accuracy problems may occur for the inexact arithmetic.

Package: fl.discretization.
Source: quadrature.lisp.

Next: Structures, Previous: Ordinary functions, Up: Internals [Contents][Index]

6.2.5 Generic functions

Generic Function: approximate (strategy blackboard) ¶

Compute a finite element approximation within the setting given on the blackboard.

Package

Source

fe-approximation.lisp.

Methods

Method: approximate :after ((fe-strategy <fe-evp-strategy>) blackboard) ¶

Ensures accuracy of the solution and the error estimate.

Source: fe-evp.lisp.

Method: approximate ((fe-strategy <stationary-fe-strategy>) blackboard) ¶

Ensures accuracy of the solution and the error estimate.

Source: fe-stationary.lisp.

Method: approximate ((fe-strategy <fe-interpolation>) blackboard) ¶

Interpolates a given function. Does only Lagrange interpolation at the moment.

Source: fe-interpolation.lisp.

Generic Function: automorphism-p (smat) ¶

Returns T, if domain and range are equal.

Package

Source

Methods

Method: automorphism-p ((mat <matrix>)) ¶: The default method checks only if the matrix is quadratic.

Method: automorphism-p ((a <block-definition-mixin>)) ¶

Generic Function: barycentric-coordinates (refcell local-pos) ¶

Computes barycentric coordinates for @arg{refcell} at @arg{local-pos}.

Package

Source

Methods

Method: barycentric-coordinates ((cell <product-cell>) local-pos) ¶

Source: product-cell.lisp.

Method: barycentric-coordinates ((refcell <simplex>) local-pos) ¶

Source: simplex.lisp.

Method: barycentric-coordinates ((vtx <vertex>) local-pos) ¶

Source: vertex.lisp.

Generic Function: barycentric-gradients (refcell local-pos) ¶

Computes the gradients of the barycentric coordinates for @arg{refcell} at @arg{local-pos}.

Package

Source

Methods

Method: barycentric-gradients ((cell <product-cell>) local-pos) ¶

Source: product-cell.lisp.

Method: barycentric-gradients ((cell <simplex>) local-pos) ¶

Source: simplex.lisp.

Method: barycentric-gradients ((vtx <vertex>) local-pos) ¶

Source: vertex.lisp.

Generic Function: blas-macro (object name) ¶

Interns a BLAS macro for instances of @arg{object} with name being the symbol @arg{name}.

Package

Source

blas-basic.lisp.

Methods

Method: blas-macro (object name) ¶: The default is no macro for this class.

Generic Reader: block-p (object) ¶

Package

Methods

Reader Method: block-p ((<refinement-indicator> <refinement-indicator>)) ¶

If block-p is T, all children of a parent cell are indicated for refinement together.

Source: error-indicator.lisp.
Target Slot: block-p.

Generic Reader: boundary-refinement-rules (object) ¶

Package

Methods

Reader Method: boundary-refinement-rules ((refinement-rule refinement-rule)) ¶

Refinement rules for the sides required by this rule.

Source: refine.lisp.
Target Slot: boundary-refinement-rules.

Generic Function: call-with-ivip (func problem rothe) ¶

Calls @arg{func} in an environment where problem is changed to a stationary interpolation problem.

Package

Source

rothe.lisp.

Methods

Method: call-with-ivip (func (problem <ellsys-problem>) rothe) ¶

Source: rothe-ellsys.lisp.

Generic Function: call-with-time-step-problem (func problem rothe) ¶

Calls @arg{func} in an environment where problem is changed to calculate the stationary time-step problem.

Package

Source

rothe.lisp.

Methods

Method: call-with-time-step-problem (func (problem <ellsys-problem>) rothe) ¶

Source: rothe-ellsys.lisp.

Generic Function: cell-class-information (object) ¶

Is implemented as an accessor for a per-class slot of the subclasses of class <cell>.

Package

Source

Methods

Reader Method: cell-class-information ((<vertex> <vertex>)) ¶

automatically generated reader method

Target Slot: cell-class-information.

Method: cell-class-information ((class standard-class)) ¶

Method: cell-class-information ((class-name symbol)) ¶

Generic Function: (setf cell-class-information) (object) ¶

Is implemented as an accessor for a per-class slot of the subclasses of class <cell>.

Package

Source

Methods

Writer Method: (setf cell-class-information) ((<vertex> <vertex>)) ¶

automatically generated writer method

Target Slot: cell-class-information.

Method: (setf cell-class-information) ((class standard-class)) ¶

Method: (setf cell-class-information) ((class-name symbol)) ¶

Generic Function: cell-rule (indicator cell) ¶

Determines the refinement rule of the cell.

Package

Source

Methods

Method: cell-rule ((indicator <largest-eta-indicator>) cell) ¶

Method: cell-rule ((indicator <isotropizing-indicator>) cell) ¶

Method: cell-rule ((indicator <cell-rule-indicator>) cell) ¶

Method: cell-rule ((indicator <uniform-refinement-indicator>) cell) ¶

Method: cell-rule (indicator cell) ¶: Default nothing is refined.

Generic Reader: cells (object) ¶

Package

Methods

Reader Method: cells ((identification identification)) ¶

A list of identified cells.

Source: identify.lisp.
Target Slot: cells.

Generic Function: check (obj &key &allow-other-keys) ¶

Checks the data structure of @arg{obj}.

Package

Source

general.lisp.

Method Combination

progn.

Options: :most-specific-first

Methods

Method: check progn ((h-mesh <hierarchical-mesh>) &key &allow-other-keys) ¶

Performs some additional checks for hierarchical meshes.

Source: mesh.lisp.

Method: check progn ((mesh <mesh>) &key &allow-other-keys) ¶

Performs some additional checks for mesh.

Source: mesh.lisp.

Method: check progn ((skel <skeleton>) &key &allow-other-keys) ¶

Checks the skeleton. An error is signaled if the skeleton looks bad.

Source: skeleton.lisp.

Method: check progn ((cell <standard-cell>) &key &allow-other-keys) ¶

Source: cell.lisp.

Method: check progn ((cell <cell-with-boundary>) &key &allow-other-keys) ¶

Source: cell.lisp.

Method: check progn (obj &key &allow-other-keys) ¶: Default method does nothing

Generic Function: choose-coarse-grid (amg blackboard) ¶

Pre-condition: an item :matrix has to be supplied on @arg{blackboard}. Post-condition: Items :matrix and :coarse-grid in the result. In the case of selection-amg this will be a set of selected indices of the fine-grid matrix graph. In the case of amg of aggregation type, this is a set of mutually disjoint sets of fine-grid indices.

Package

Source

Methods

Method: choose-coarse-grid ((amg <stueben>) blackboard) ¶

Ruge-Stueben coarse grid selection.

Source: stueben.lisp.

Generic Function: chunk-enqueue (cq chunk &optional finalizer) ¶

Package

Source

Methods

Method: chunk-enqueue ((cq chunk-queue) (chunk list) &optional finalizer) ¶

Generic Function: classify-problem (problem &rest keyword-args &key start-time end-time linear-p coercive &allow-other-keys) ¶

Classifies a problem (e.g. linear/nonlinear,
self-adjoint or not, time-dependent or not, and puts possible results in its property list, or even change the problem class to a more specialized problem.

Package

Source

Methods

Method: classify-problem :after ((problem <ellsys-problem>) &key start-time end-time &allow-other-keys) ¶

Source: ellsys.lisp.

Method: classify-problem ((problem <pde-problem>) &key linear-p coercive &allow-other-keys) ¶: Finds out nonlinearity of the problem by checking for nonlinear coefficients

Generic Reader: coeff-eval (object) ¶

Package

Methods

Reader Method: coeff-eval ((<coefficient> <coefficient>)) ¶

The evaluation funtion. It accepts a list of
keyword parameters which should correspond to the list in DEMANDS.

Source: pde-problem.lisp.
Target Slot: eval.

Generic Reader: combination-type (object) ¶

Package

Methods

Reader Method: combination-type ((<mg-iteration> <mg-iteration>)) ¶

Switch between additive and multiplicative
combination of corrections from different levels. The additive version should be used as a preconditioner.

Source: multigrid.lisp.
Target Slot: combination.

Generic Reader: compute (object) ¶

Package

Methods

Reader Method: compute ((computed-value-dictionary computed-value-dictionary)) ¶

A (usually memoized) function computing the values

Source: dictionary.lisp.
Target Slot: compute.

Generic Function: compute-error-approximant (errest blackboard) ¶

Calculates an approximation to the error.

Package

Source

Methods

Method: compute-error-approximant ((errest <setup-enriched-ansatz-space>) blackboard) ¶: Setup of interpolated solution, matrix, and rhs in the enriched ansatz space.

Method: compute-error-approximant ((errest <difference-with-projection>) blackboard) ¶: Computes solution-increment computed as difference solution on the finest mesh and a projection to the next-coarser level.

Method: compute-error-approximant ((errest <standard-error-estimator>) blackboard) ¶

Generic Function: compute-local-estimate (errest blackboard) ¶

Computes an estimate for the local contributions to the global error.

Package

Source

Methods

Method: compute-local-estimate ((errest <local-test-with-dual>) blackboard) ¶: Evaluates the duality error estimator given the dual solution and the approximate solution u. Works only for the :load-functional case at the moment, because the right-hand side is not assembled for the primal problem.

Method: compute-local-estimate ((errest <global-and-local-norm>) blackboard) ¶

Method: compute-local-estimate ((errest <standard-error-estimator>) blackboard) ¶

Generic Function: compute-local-imatrix (rule fe child-disc &key type shape-distortion &allow-other-keys) ¶

Returns a local interpolation matrix as a sparse matrix with standard-matrix entries.

Package

Source

fetransfer.lisp.

Methods

Method: compute-local-imatrix (rule (vecfe <vector-fe>) (child-disc <vector-fe-discretization>) &key type &allow-other-keys) ¶: Computes an interpolation matrix for the refinement rule @arg{rule} and the vector finite element @arg{vecfe}. The algorithm evaluates the nodal functionals of the children on the parent shape functions.

Method: compute-local-imatrix (rule (fe <scalar-fe>) (child-disc <scalar-fe-discretization>) &key shape-distortion type) ¶: This function computes a local interpolation matrix for the coarse finite element @arg{fe}, the refinement rule @arg{rule} and the discretization @arg{child-disc} of the children. For each refined interior degree of freedom, it evaluates the corresponding degree of freedom on the basis polynomials of the father cell which yields the entry in the local interpolation matrix. @arg{shape-distorion} allows to modify the shape which can be used for implementing problem-dependent finite elements.

Generic Function: compute-local-pmatrix (rule fe child-disc) ¶

Computes a local projection matrix as a sparse vector
with standard-matrix entries. Note that projection is not as canonic as interpolation. We implement here the injection of dof functionals, i.e. each degree of freedom is evaluated for the refined fe function.

Package

Source

fetransfer.lisp.

Methods

Method: compute-local-pmatrix (rule (vecfe <vector-fe>) child-disc) ¶: Computes a local projection matrix for vector finite elements.

Method: compute-local-pmatrix (rule (fe <scalar-fe>) child-disc) ¶: This function computes a local projection matrix for Lagrangian finite cells and maybe others. For each interior degree of freedom, it finds the child cell where the support of the node functional is contained and evaluates it on the basis polynomials of the child which yields the entry in the local projection matrix.

Generic Function: compute-weight-function (errest blackboard) ¶

Computes a weight function used for weighting the error according in a desired way.

Package

Source

Methods

Method: compute-weight-function ((errest <solve-dual-problem>) blackboard) ¶: Solves a dual problem in an ansatz-space of higher order. This error estimator is computationally more intensive than the original problem.

Method: compute-weight-function ((errest <standard-error-estimator>) blackboard) ¶

Generic Function: coordinates-inside? (cell local-pos) ¶

Checks if the given local coordinates are inside the reference cell.

Package

Source

Methods

Method: coordinates-inside? ((cell <product-cell>) local-pos) ¶

Source: product-cell.lisp.

Method: coordinates-inside? ((cell <simplex>) local-pos) ¶

Source: simplex.lisp.

Method: coordinates-inside? ((vtx <vertex>) local-pos) ¶

Source: vertex.lisp.

Generic Function: copy-cell (cell) ¶

Copy constructor for cells. It is guaranteed that the cell boundary is copied.

Package

Source

Methods

Method: copy-cell ((cell <boundary-cell>)) ¶

Source: triangulate.lisp.

Method: copy-cell ((vtx <vertex>)) ¶

Copy constructor for vertex. The vertex position is freshly allocated.

Source: vertex.lisp.

Method: copy-cell ((cell <mapped-cell>)) ¶

Method: copy-cell ((cell <standard-cell>)) ¶: Copy constructor for cells.

Generic Function: describe-all (object) ¶

Describe object and all sub-objects (e.g. a cell and all subcells).

Package

Source

Methods

Method: describe-all ((cell <cell>)) ¶

Generic Reader: discretization (object) ¶

Package

Methods

Reader Method: discretization ((<fe> <fe>)) ¶

automatically generated reader method

Source: fe.lisp.
Target Slot: discretization.

Generic Function: do-refinement! (skel refined-skel task &key refined-region) ¶

@arg{task} contains an association list of a cell/rule combination.
Note that the task is assumed to be consistent, which means that this function should usually not be called directly by the user. Its purpose is to allow for parallelization to kick in, which needs to ensure consistent refinement of interfaces.

Package

Source

Methods

Method: do-refinement! ((skel <skeleton>) (refined-skel <skeleton>) (task list) &key refined-region) ¶

Generic Reader: dof-subcell (object) ¶

Package

Methods

Reader Method: dof-subcell ((dof dof)) ¶

Reference subcell on which the dof is defined

Source: fe.lisp.
Target Slot: subcell.

Generic Reader: domain-a (object) ¶

Package

Methods

Reader Method: domain-a ((<linearly-transformed-function> <linearly-transformed-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: domain-a.

Generic Reader: domain-b (object) ¶

Package

Methods

Reader Method: domain-b ((<linearly-transformed-function> <linearly-transformed-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: domain-b.

Generic Function: drop-content (ldu pool) ¶

Package

Source

sparselu.lisp.

Methods

Method: drop-content ((ldu <ldu-sparse>) pool) ¶

Generic Function: ensure-contained (r &rest vecs) ¶

Ensure that the structure of the vector r is contained in the structure of all following vectors such that the entries of those vectors can be written to in parallel.

Since vectors are often generated as image or domain vectors of matrices ensuring the relevant entries, this function is not deeded very often.

Package

Source

Methods

Method: ensure-contained (r &rest vecs) ¶: For many types of vectors this operation does nothing.

Method: ensure-contained ((r <sparse-vector>) &rest vecs) ¶: It is necessary for extensible sparse vectors.

Generic Reader: ensure-mesh-quality-p (object) ¶

Package

Methods

Reader Method: ensure-mesh-quality-p ((<refinement-indicator> <refinement-indicator>)) ¶

If ensure-mesh-quality-p is T, the indicator ensures that the difference of mesh widths of neighboring cells does not become larger than a factor of 4.

Source: error-indicator.lisp.
Target Slot: ensure-mesh-quality-p.

Generic Function: ensure-mg-residual (mg-it mg-data) ¶

Ensure residual on current-level.

Package

Source

Methods

Method: ensure-mg-residual ((mg-it <mg-iteration>) mg-data) ¶

Generic Function: ensure-sol-rhs-res (mg-it mg-data level) ¶

Ensure allocation of sol/rhs/res on level.

Package

Source

Methods

Method: ensure-sol-rhs-res ((mg-it <mg-iteration>) mg-data level) ¶

Generic Function: evaluate-k-jet (f k x) ¶

Generic evaluation of k-jets of C^k-functions. A k-jet combines all derivatives from 0..k.

Package

Source

Methods

Method: evaluate-k-jet ((poly polynomial) (k integer) (x vector)) ¶

Source: polynom.lisp.

Method: evaluate-k-jet ((f <constant-function>) k x) ¶

Method: evaluate-k-jet ((f <special-function>) k x) ¶

Method: evaluate-k-jet (f k x) ¶: By default, the k-jet evaluation handles the cases K=0 and K=1 by calls to EVALUATE and EVALUATE-GRADIENT, respectively.

Generic Reader: evaluator (object) ¶

Package

Methods

Reader Method: evaluator ((<special-function> <special-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: evaluator.

Generic Reader: execute (object) ¶

Generic Writer: (setf execute) (object) ¶

Package

Methods

Reader Method: execute ((<demo> <demo>)) ¶

Writer Method: (setf execute) ((<demo> <demo>)) ¶

A function performing the demo.

Source: demo.lisp.
Target Slot: execute.

Generic Function: extend-triangulation (mesh dim embedded-dim program &key meshsize &allow-other-keys) ¶

Extend an existing triangulation on the @arg{dim}-1-skeleton to the @arg{dim}-skeleton using @arg{program}.

Package

Source

triangulate.lisp.

Methods

Method: extend-triangulation (mesh (dim (eql 3)) (embedded-dim (eql 3)) (program (eql :tetgen)) &key meshsize &allow-other-keys) ¶

Calls @program{tetgen} for each 3D patch of the domain. @arg{mesh} should already be generated for 0,1 and 2-dimensional patches.

Source: tetgen.lisp.

Method: extend-triangulation (mesh (dim (eql 2)) (embedded-dim (eql 3)) (program (eql :triangle)) &key meshsize &allow-other-keys) ¶

Triangle can only treat 2D domains, so we triangulate 2D reference patches in the 2D-embedded-in-3D case.

Source: triangle.lisp.

Method: extend-triangulation (mesh (dim (eql 2)) (embedded-dim (eql 2)) (program (eql :triangle)) &key meshsize &allow-other-keys) ¶

Calls @program{triangle} for each 2D patch of the domain. @arg{mesh} should already be generated for 0 and 1-dimensional patches.

Source: triangle.lisp.

Method: extend-triangulation :after (mesh dim embedded-dim program &key &allow-other-keys) ¶: Does the setup of isoparametric mapping of boundary cells.

Method: extend-triangulation (mesh (dim (eql 1)) embedded-dim (program (eql :internal)) &rest keys) ¶: Generates a mesh on the 1-skeleton for domain. Identification is taken care of.

Method: extend-triangulation (mesh (dim (eql 0)) embedded-dim (program (eql :internal)) &key &allow-other-keys) ¶

Method: extend-triangulation :before (mesh dim embedded-dim program &key &allow-other-keys) ¶: Checks that no higher-dimensional cells already exist. This might be too restrictive later on.

Generic Function: extended-mclear! (x x-row-off x-col-off x-row-end x-col-end) ¶

Clear the specified part of X.

Package

Source

Methods

Method: extended-mclear! ((x standard-matrix) x-row-off x-col-off x-row-end x-col-end) ¶

Source: standard-matrix-blas.lisp.

Generic Function: extended-minject! (x y y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Inject a part of the matrix X specified by the last four parameters in matrix Y at the position given by Y-ROW-OFFSET and Y-COL-OFFSET.

Package

Source

Methods

Method: extended-minject! ((x standard-matrix) (y standard-matrix) y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Source: standard-matrix-blas.lisp.

Generic Function: f-cycle (mg-it mg-data) ¶

Performs an F-cycle on current level.

Package

Source

Methods

Method: f-cycle ((mg-it <mg-iteration>) mg-data) ¶

Generic Reader: fallback (object) ¶

Package

Methods

Reader Method: fallback ((<safe-linear-solver> <safe-linear-solver>)) ¶

The fallback iteration.

Source: linsolve.lisp.
Target Slot: fallback.

Generic Reader: fallback-p (object) ¶

Package

Methods

Reader Method: fallback-p ((<safe-linear-solver> <safe-linear-solver>)) ¶

automatically generated reader method

Source: linsolve.lisp.
Target Slot: fallback-p.

Generic Writer: (setf fallback-p) (object) ¶

Package

Methods

Writer Method: (setf fallback-p) ((<safe-linear-solver> <safe-linear-solver>)) ¶

automatically generated writer method

Source: linsolve.lisp.
Target Slot: fallback-p.

Generic Reader: fe-factors (object) ¶

Package

Methods

Reader Method: fe-factors ((<fe> <fe>)) ¶

The factor FEs, if the FE is of product type, that is,
its basis and dofs are products of FE bases and dofs on the reference cells. Using such a factor representation can speed up several calculations considerably.

Source: fe.lisp.
Target Slot: fe-factors.

Generic Function: fill-local-from-global-mat (global-mat local-mat cell &optional domain-cell) ¶

Copies the region in global-mat determined by cell to local-mat.

Package

Source

Methods

Method: fill-local-from-global-mat ((smat <sparse-matrix>) local-mat (cell <cell>) &optional domain-cell) ¶

Generic Function: fill-local-from-global-vec (cell global-vec local-vec) ¶

Copies the region in global-vec determined by cell to local-vec.

Package

Source

Methods

Method: fill-local-from-global-vec ((cell <cell>) (svec <sparse-vector>) local-vec) ¶

Generic Function: filtered-matrix (amg blackboard) ¶

Precondition: items :matrix. Postcondition: :matrix and :filtered-matrix.

Package

Source

Methods

Method: filtered-matrix ((amg <stueben>) blackboard) ¶

Special filtering used by Ruge-Stueben.

Source: stueben.lisp.

Generic Function: find-ordering (mat keys) ¶

Package

Source

sparselu.lisp.

Methods

Method: find-ordering (mat keys) ¶: Default method: Finds a nested disection ordering of @arg{keys} with respect to the graph given by @arg{mat}.

Generic Function: finish (object) ¶

Package

Source

Methods

Method: finish ((pq parqueue)) ¶

Generic Reader: finished-p (object) ¶

Generic Writer: (setf finished-p) (object) ¶

Package

Methods

Reader Method: finished-p ((parqueue parqueue)) ¶

Writer Method: (setf finished-p) ((parqueue parqueue)) ¶

Indicator for no-more-input-allowed.

Source: multiprocessing.lisp.
Target Slot: finished-p.

Generic Function: force (obj) ¶

Force a delayed object.

Package

fl.macros.

Source

macros.lisp.

Methods

Method: force (obj) ¶: Default is identity.

Method: force ((obj function)) ¶: A simple lambda delay is forced using evaluation.

Generic Reader: forced-times (object) ¶

Package

Methods

Reader Method: forced-times ((<rothe> <rothe>)) ¶

automatically generated reader method

Source: rothe.lisp.
Target Slot: forced-times.

Generic Reader: fraction (object) ¶

Package

Methods

Reader Method: fraction ((<largest-eta-indicator> <largest-eta-indicator>)) ¶

automatically generated reader method

Source: error-indicator.lisp.
Target Slot: fraction.

Generic Reader: from-level (object) ¶

Package

Methods

Reader Method: from-level ((<refinement-indicator> <refinement-indicator>)) ¶

Below from-level, global refinement is used. If
from-level=NIL, regular global refinement is indicated, if no other indication is available.

Source: error-indicator.lisp.
Target Slot: from-level.

Generic Reader: functional (object) ¶

Package

Methods

Reader Method: functional ((<solve-dual-problem> <solve-dual-problem>)) ¶

automatically generated reader method

Source: error-estimator.lisp.
Target Slot: functional.

Generic Writer: (setf functional) (object) ¶

Package

Methods

Writer Method: (setf functional) ((<solve-dual-problem> <solve-dual-problem>)) ¶

automatically generated writer method

Source: error-estimator.lisp.
Target Slot: functional.

Generic Reader: galerkin-p (object) ¶

Package

Methods

Reader Method: galerkin-p ((<geometric-mg> <geometric-mg>)) ¶

automatically generated reader method

Source: geomg.lisp.
Target Slot: galerkin-p.

Generic Reader: gamma (object) ¶

Package

Methods

Reader Method: gamma ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: gamma.

Generic Function: generate-refine-info (refcell) ¶

Generates the refinement information for the reference cell.

Package

Source

Methods

Method: generate-refine-info ((refcell <product-cell>)) ¶

Allocates refine-info vector with barycentric-corners, then fills the boundary paths.

Source: product-cell.lisp.

Method: generate-refine-info ((refcell <simplex>)) ¶

Allocates an empty vector of children which is then filled calling GET-PATH-CREATE and CREATE-BOUNDARY-PATHS.

Source: simplex.lisp.

Method: generate-refine-info ((refcell <vertex>)) ¶

Construction of the refinement information which is to copy the vertex.

Source: vertex.lisp.

Method: generate-refine-info :after (refcell) ¶

Generates the transformation mappings.

Source: refine.lisp.

Method: generate-refine-info :before (refcell) ¶

Source: refine.lisp.

Generic Function: global-estimate (error-estimator blackboard) ¶

Puts an estimate for the total error on the blackboard. Will usually need the result of the local estimate.

Package

Source

Methods

Method: global-estimate ((errest <local-test-with-dual>) blackboard) ¶

Method: global-estimate ((errest <global-norm>) blackboard) ¶: Computes the global error from the local error contributions.

Generic Function: global-local-matrix-operation (global-mat local-mat image-cell domain-cell operation &key image-subcells domain-subcells delay-p) ¶

Performs some operation interfacing global to local values.

Package

Source

Methods

Method: global-local-matrix-operation ((smat <ansatz-space-automorphism>) local-mat (image-cell <cell>) (domain-cell <cell>) operation &key image-subcells domain-subcells delay-p) ¶

Generic Function: global-local-vector-operation (global-vec cell local-vec operation) ¶

Performs an operation interfacing global to local values.

Package

Source

Methods

Method: global-local-vector-operation ((svec <sparse-vector>) (cell <cell>) local-vec operation) ¶

Generic Function: graphic-input-stream (program) ¶

Return the input stream for the graphic program.

Package

Source

Methods

Method: graphic-input-stream ((program (eql :gnuplot))) ¶

Source: gnuplot.lisp.

Method: graphic-input-stream ((program (eql :dx))) ¶

Source: dx.lisp.

Generic Function: graphic-output-stream (program) ¶

Return the output stream for the graphic program.

Package: fl.graphic.
Source: graphics.lisp.

Generic Reader: head (object) ¶

Package

Methods

Reader Method: head ((queue queue)) ¶

automatically generated reader method

Source: utilities.lisp.
Target Slot: head.

Generic Writer: (setf head) (object) ¶

Package

Methods

Writer Method: (setf head) ((queue queue)) ¶

automatically generated writer method

Source: utilities.lisp.
Target Slot: head.

Generic Reader: high-precision-ips (object) ¶

Package

Methods

Reader Method: high-precision-ips ((integration-rule integration-rule)) ¶

A list of ips where an <ip> is a list (weight
coordinate-vector). Both weight and coordinates are in the high precision given by @var{*quadrature-rule-internal-precision*}.

Source: quadrature.lisp.
Target Slot: high-precision-ips.

Generic Reader: holes (object) ¶

Package

Methods

Reader Method: holes ((<boundary-cell> <boundary-cell>)) ¶

automatically generated reader method

Source: triangulate.lisp.
Target Slot: holes.

Generic Reader: image-a (object) ¶

Package

Methods

Reader Method: image-a ((<linearly-transformed-function> <linearly-transformed-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: image-a.

Generic Reader: image-b (object) ¶

Package

Methods

Reader Method: image-b ((<linearly-transformed-function> <linearly-transformed-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: image-b.

Generic Function: improved-prolongation (amg blackboard) ¶

Precondition: items :mat and :prol in the rest parameters. Postcondition: same.

Package

Source

Methods

Method: improved-prolongation ((amg <selection-amg>) blackboard) ¶

Define P_{FC} in a Stueben like manner. For the fine grid point i we have to solve for e_i in

$$ a_{ii} e_i = - sum_{j in N_i} a_{ij} e_j $$

with N_i being the neighborhood of $i$. Now $sum_{j in N_i} a_{ij} e_j$ is replaced by $alpha sum_{j in P_i} a_{ij} e_j$ where $alpha$ is chosen as

$$ alpha = frac{sum_{j in N_i} a_{ij}}}{sum_{j in P_i} a_{ij}} $$

to make the prolongation exact for constant functions.

Source: selection-amg.lisp.

Generic Function: index-key-function (r) ¶

Function for calculating the key of an entry

Package

Source

Methods

Method: index-key-function (r) ¶

Generic Reader: indices (object) ¶

Package

Methods

Reader Method: indices ((relation relation)) ¶

Association list order->index

Source: relations.lisp.
Target Slot: indices.

Generic Function: initial-value-interpolation-problem (rothe problem) ¶

Extract a stationary PDE problem for interpolating the initial values out of the given time-dependent PDE problem @arg{problem}.

Package: fl.strategy.
Source: rothe.lisp.

Generic Function: inner-iteration (iter) ¶

Often the iteration uses another iteration in its loop.
In this case, this routine returns this inner iteration. Usually, this will be another reader function for some slot.

Package

Source

Methods

Method: inner-iteration ((nlsolve <nonlinear-solver>)) ¶

Source: nlsolve.lisp.

Reader Method: inner-iteration ((<linear-solver> <linear-solver>)) ¶

The inner iteration.

Source: linsolve.lisp.
Target Slot: iteration.

Reader Method: inner-iteration ((<block-iteration> <block-iteration>)) ¶

Iteration which is used to solve for each block.

Source: blockit.lisp.
Target Slot: inner-iteration.

Method: inner-iteration (iter) ¶: Default method returns nil, i.e. there is no inner iteration.

Generic Function: interpolation-function (fe func &key dof &allow-other-keys) ¶

Assserts a correct form of @arg{func} for interpolation with the finite element @arg{fe}.

Package

Source

Methods

Method: interpolation-function ((fe <scalar-fe>) func &key &allow-other-keys) ¶: Asserts a scalar value of @arg{func}.

Method: interpolation-function ((fe <vector-fe>) func &key dof) ¶: Returns a function for the component of @arg{dof}.

Generic Function: ip-gradients-at-point (fe obj) ¶

Unmemoized ip-gradients for a single position.

Package

Source

Methods

Method: ip-gradients-at-point ((fe <scalar-fe>) pos) ¶

Method: ip-gradients-at-point ((fe <vector-fe>) pos) ¶

Generic Function: ip-values-at-point (fe obj) ¶

Slow and unmemoized ‘ip-values’ functionality for a single position.

Package

Source

Methods

Method: ip-values-at-point ((fe <scalar-fe>) pos) ¶

Method: ip-values-at-point ((fe <vector-fe>) pos) ¶

Generic Function: iteration (object) ¶

Package

Methods

Method: iteration ((solver <safe-linear-solver>)) ¶

Source: linsolve.lisp.

Reader Method: iteration ((<linear-solver> <linear-solver>)) ¶

The inner iteration.

Source: linsolve.lisp.
Target Slot: iteration.

Generic Reader: jet (object) ¶

Package

Methods

Reader Method: jet ((<special-function> <special-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: jet.

Generic Function: k-jet (function k dim) ¶

Calculates the k-jet of a function defined in R^dim.

Package

Source

Methods

Method: k-jet ((poly polynomial) (k integer) (dim integer)) ¶

Generic Function: lagrange-inner-coords (cell order type) ¶

Returns a list of Lagrange coordinates on the cell @arg{cell}
for Lagrange finite elements of order @arg{order} and type @arg{type}.

Package

Source

lagrange.lisp.

Methods

Method: lagrange-inner-coords ((vtx <vertex>) order type) ¶

Method: lagrange-inner-coords ((simplex <simplex>) order type) ¶

Method: lagrange-inner-coords ((cell <product-cell>) order type) ¶

Generic Function: lapack-convert (arg) ¶

Convert argument for use in a LAPACK routine.

Package

fl.lapack.

Source

lapack.lisp.

Methods

Method: lapack-convert ((mat standard-matrix)) ¶

Source: standard-matrix.lisp.

Method: lapack-convert (x) ¶

Method: lapack-convert ((x number)) ¶

Method: lapack-convert ((x vector)) ¶: Before calling the alien routine, vectors will probably be converted
to a pointer to their store. However, this is done in the foreign-call routine.

Generic Reader: ldu-diagonal (object) ¶

Package

Methods

Reader Method: ldu-diagonal ((<ldu-sparse> <ldu-sparse>)) ¶

automatically generated reader method

Source: sparselu.lisp.
Target Slot: diagonal.

Generic Reader: levels (object) ¶

Package

Methods

Reader Method: levels ((<hierarchical-mesh> <hierarchical-mesh>)) ¶

automatically generated reader method

Source: mesh.lisp.
Target Slot: levels.

Generic Writer: (setf levels) (object) ¶

Package

Methods

Writer Method: (setf levels) ((<hierarchical-mesh> <hierarchical-mesh>)) ¶

automatically generated writer method

Source: mesh.lisp.
Target Slot: levels.

Generic Reader: linear-solver (object) ¶

Package

Methods

Reader Method: linear-solver ((<nonlinear-solver> <nonlinear-solver>)) ¶

The linear solver for solving the linearization.

Source: nlsolve.lisp.
Target Slot: linear-solver.

Generic Function: lmgc (mg-it mg-data) ¶

Performs an lmgc cycle on current level.

Package

Source

Methods

Method: lmgc ((mg-it <mg-iteration>) mg-data) ¶

Generic Function: local-estimate (error-estimator blackboard) ¶

Puts a hash-table of local error contributions on the blackboard.

Package

Source

Methods

Method: local-estimate ((errest <standard-error-estimator>) blackboard) ¶

Generic Reader: locked-region (object) ¶

Package

Methods

Reader Method: locked-region ((locked-region-mixin locked-region-mixin)) ¶

automatically generated reader method

Source: multiprocessing.lisp.
Target Slot: locked-region.

Generic Reader: lower-left (object) ¶

Package

Methods

Reader Method: lower-left ((<ldu-sparse> <ldu-sparse>)) ¶

automatically generated reader method

Source: sparselu.lisp.
Target Slot: lower-left.

Generic Function: m*-nt-product-instance (x y) ¶

Allocates an instance for the product of X and Y^t.

Package

Source

Methods

Method: m*-nt-product-instance (x y) ¶

Generic Function: m.*! (x y) ¶

Y <- X .* Y

Package

Source

Methods

Method: m.*! ((x standard-matrix) (y standard-matrix)) ¶

Source: standard-matrix-blas.lisp.

Method: m.*! ((x static-store-vector) (y static-store-vector)) ¶

Source: store-vector.lisp.

Generic Function: make-product-cell (cell1 cell2 table) ¶

Generates the product-cell product of cell1 and cell2. The
boundary is taken from the list of lower-dimensional products supplied in table. The tensor product boundary is in the order de1 x e2, e1 x de2.

Package

Source

Methods

Method: make-product-cell ((cell1 <cell>) (cell2 <cell>) table) ¶

Method: make-product-cell ((cell <cell>) (vtx <vertex>) table) ¶

Method: make-product-cell ((vtx <vertex>) (cell <cell>) table) ¶

Method: make-product-cell ((vtx1 <vertex>) (vtx2 <vertex>) table) ¶

Method: make-product-cell :around ((cell1 <cell>) (cell2 <cell>) table) ¶

Generic Function: matop-x->y! (x y y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Package

Source

Methods

Method: matop-x->y! ((x standard-matrix) (y standard-matrix) y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Generic Function: matop-x<-y! (x y y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Package

Source

Methods

Method: matop-x<-y! ((x standard-matrix) (y standard-matrix) y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Generic Function: matop-y+=x! (x y y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Package

Source

Methods

Method: matop-y+=x! ((x standard-matrix) (y standard-matrix) y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Generic Function: matop-y-=x! (x y y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Package

Source

Methods

Method: matop-y-=x! ((x standard-matrix) (y standard-matrix) y-row-off y-col-off x-row-off x-col-off x-row-end x-col-end) ¶

Generic Reader: max-depth (object) ¶

Package

Methods

Reader Method: max-depth ((<algebraic-mg> <algebraic-mg>)) ¶

automatically generated reader method

Source: amg.lisp.
Target Slot: max-depth.

Generic Reader: maximal-time-step (object) ¶

Package

Methods

Reader Method: maximal-time-step ((<rothe> <rothe>)) ¶

automatically generated reader method

Source: rothe.lisp.
Target Slot: maximal-time-step.

Generic Reader: minimal-time-step (object) ¶

Package

Methods

Reader Method: minimal-time-step ((<rothe> <rothe>)) ¶

automatically generated reader method

Source: rothe.lisp.
Target Slot: minimal-time-step.

Generic Reader: model-time (object) ¶

Package

Methods

Reader Method: model-time ((<rothe> <rothe>)) ¶

Current time in the time-stepping scheme.

Source: rothe.lisp.
Target Slot: model-time.

Generic Function: multiple-l2dg (cell local-positions) ¶

Computes the gradients at the local positions for @arg{cell}.

Package

Source

Methods

Method: multiple-l2dg (cell local-positions) ¶: This default method uses a barycentric average of the vertex positions.

Generic Function: multiple-l2g (cell local-positions) ¶

Computes the associated global positions by interpolation from the vertices of @arg{cell}.

Package

Source

Methods

Method: multiple-l2g (cell local-positions) ¶: This default method uses a barycentric average of the vertex positions.

Generic Function: mutex (object) ¶

Package

Methods

Method: mutex (obj) ¶

Ordinary objects are not mutex-protected.

Source: multiprocessing.lisp.

Reader Method: mutex ((mutex-mixin mutex-mixin)) ¶

A mutex for excluding access of other threads.

Source: multiprocessing.lisp.
Target Slot: mutex.

Generic Reader: name (object) ¶

Generic Writer: (setf name) (object) ¶

Package

Methods

Reader Method: name ((<demo> <demo>)) ¶

Writer Method: (setf name) ((<demo> <demo>)) ¶

The name of the demo.

Source: demo.lisp.
Target Slot: name.

Generic Function: name (iter) ¶

Name of the iteration.

Package

Source

Methods

Method: name ((iter <iteration>)) ¶: The default name of an iteration is either its class name or the class name together with the name of the inner iteration.

Generic Reader: names (object) ¶

Package

Methods

Reader Method: names ((refinement-rule refinement-rule)) ¶

Names identifying the rule.

Source: refine.lisp.
Target Slot: names.

Generic Function: notify (waitqueue-object) ¶

Notifies @arg{waitqueue-object}.

Package

Source

Methods

Method: notify (obj) ¶

Method: notify ((wq waitqueue-mixin)) ¶

Generic Function: nr-segments (polygon) ¶

Package

Source

spline.lisp.

Methods

Method: nr-segments ((polygon <polygon>)) ¶

Method: nr-segments ((polygon <periodic-polygon>)) ¶

Generic Function: number-of-stored-entries (pattern) ¶

Number of stored entries of a sparse matrix pattern.

Package

Source

Methods

Method: number-of-stored-entries ((pattern compressed-pattern)) ¶

Generic Reader: offset0 (object) ¶

Package

Methods

Reader Method: offset0 ((full-tensor full-tensor)) ¶

An initial offset into the store-vector which defaults to 0.

Source: tensor.lisp.
Target Slot: offset0.

Generic Reader: offsets (object) ¶

Package

Methods

Reader Method: offsets ((compressed-pattern compressed-pattern)) ¶

Vector of offsets. This is only non-nil, if the pattern supports identification.

Source: compressed.lisp.
Target Slot: offsets.

Reader Method: offsets ((full-tensor full-tensor)) ¶

The offsets for the different dimensions. This
is internal information computed at tensor construction time.

Source: tensor.lisp.
Target Slot: offsets.

Generic Reader: old-time-step (object) ¶

Package

Methods

Reader Method: old-time-step ((<rothe> <rothe>)) ¶

For use in BDF formula

Source: rothe.lisp.
Target Slot: old-time-step.

Generic Reader: ordering (object) ¶

Package

Methods

Reader Method: ordering ((<block-iteration> <block-iteration>)) ¶

automatically generated reader method

Source: blockit.lisp.
Target Slot: ordering.

Generic Writer: (setf ordering) (object) ¶

Package

Methods

Writer Method: (setf ordering) ((<block-iteration> <block-iteration>)) ¶

automatically generated writer method

Source: blockit.lisp.
Target Slot: ordering.

Generic Reader: ordering (object) ¶

Package

Methods

Reader Method: ordering ((<ldu-sparse> <ldu-sparse>)) ¶

automatically generated reader method

Source: sparselu.lisp.
Target Slot: ordering.

Generic Reader: orientation (object) ¶

Package

Methods

Reader Method: orientation ((compressed-pattern compressed-pattern)) ¶

Denotes if rows or columns are compressed.

Source: compressed.lisp.
Target Slot: orientation.

Generic Reader: original (object) ¶

Package

Methods

Reader Method: original ((<linearly-transformed-function> <linearly-transformed-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: original.

Generic Reader: output (object) ¶

Package

Methods

Reader Method: output ((<solver> <solver>)) ¶

automatically generated reader method

Source: solve.lisp.
Target Slot: output.

Generic Function: output-p (iteration blackboard) ¶

Determines if status output is done.

Package

Source

Methods

Method: output-p ((iter <iteration>) blackboard) ¶: Checks if @var{*iteration-depth*} is smaller or equal @var{*output-depth*}.

Generic Reader: parametric (object) ¶

Package

Methods

Reader Method: parametric ((<mesh> <mesh>)) ¶

automatically generated reader method

Source: mesh.lisp.
Target Slot: parametric.

Generic Function: perform-with-locked-region (object keys perform) ¶

Perform @arg{perform} while @arg{keys} are locked in @arg{object}.

Package

Source

Methods

Method: perform-with-locked-region (object keys perform) ¶: No locking if @arg{object} is not a @class{locked-region-mixin}.

Method: perform-with-locked-region ((object locked-region-mixin) keys perform) ¶

Generic Reader: pivot-factor (object) ¶

Package

Methods

Reader Method: pivot-factor ((<largest-eta-indicator> <largest-eta-indicator>)) ¶

automatically generated reader method

Source: error-indicator.lisp.
Target Slot: pivot-factor.

Generic Function: plot-cells (skel &key part &allow-other-keys) ¶

Package

fl.plot.

Source

feplot.lisp.

Methods

Method: plot-cells ((skel <skeleton>) &key &allow-other-keys) ¶

Method: plot-cells ((h-mesh <hierarchical-mesh>) &key part &allow-other-keys) ¶

Generic Reader: points (object) ¶

Package

Methods

Reader Method: points ((<polygon> <polygon>)) ¶

A vector of points for the polygon.

Source: spline.lisp.
Target Slot: points.

Generic Function: poly+ (p1 p2) ¶

Add two polynomials P1 and P2.

Package

Source

Methods

Method: poly+ ((x number) (y number)) ¶

Method: poly+ ((x number) (y list)) ¶

Method: poly+ ((y list) (x number)) ¶

Method: poly+ ((x list) (y list)) ¶

Method: poly+ ((x polynomial) (y polynomial)) ¶

Generic Function: pool-size (pool) ¶

Calculates number of entries in pool.

Package

Source

Methods

Method: pool-size ((pool thread-safe-pool)) ¶

Method: pool-size (table) ¶

Method: pool-size ((pool pool)) ¶

Generic Function: popper (collection) ¶

Returns a function which accesses the given collection in parallel. Calling this function yields a new argument list together with a second value which is either NIL or a finalizer that should be called when working on that argument list is finished.

Package

Source

parallel-heap.lisp.

Methods

Method: popper ((heap parallel-heap)) ¶

Method: popper ((queue parqueue)) ¶

Generic Reader: post-smoother (object) ¶

Package

Methods

Reader Method: post-smoother ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: post-smoother.

Generic Reader: pre-smoother (object) ¶

Package

Methods

Reader Method: pre-smoother ((<mg-iteration> <mg-iteration>)) ¶

automatically generated reader method

Source: multigrid.lisp.
Target Slot: pre-smoother.

Generic Reader: precise-coord (object) ¶

Package

Methods

Reader Method: precise-coord ((dof dof)) ¶

Local coordinate of the dof in the reference subcell in high precision.

Source: fe.lisp.
Target Slot: precise-coord.

Generic Reader: precise-gcoord (object) ¶

Package

Methods

Reader Method: precise-gcoord ((dof dof)) ¶

Global coordinate of the dof on the reference cell in high precision.

Source: fe.lisp.
Target Slot: precise-gcoord.

Generic Function: print-element (matrix element stream) ¶

Prints the element @arg{element} of @arg{matrix} to the stream @arg{stream}.

Package

Source

Methods

Method: print-element ((matrix standard-matrix) element stream) ¶

Generic Function: print-matlab-format (mat) ¶

Print a matrix in Matlab/Octave format.

Package

Source

Methods

Method: print-matlab-format ((mat <sparse-matrix>)) ¶

Convert the Femlisp sparse matrix into a full matrix and print it in Matlab format.

Source: sparse-matrix.lisp.

Method: print-matlab-format ((mat standard-matrix)) ¶

Print Femlisp full matrices in Matlab/Octave format.

Source: standard-matrix.lisp.

Generic Function: prolongate (mg-it mg-data) ¶

Prolongation from current level. The current level is incremented after the operation.

Package

Source

Methods

Method: prolongate :after ((mg-it <mg-iteration>) mg-data) ¶

Method: prolongate ((mg-it <fas>) mg-data) ¶: This version of FAS prolongation uses the res_ field on the coarser level for computing the correction to be prolongated.

Method: prolongate ((mg-it <correction-scheme>) mg-data) ¶

Generic Function: pseudo-vertices (cell factor) ¶

Helper function for extracting all vertices of @arg{cell} in a reasonable order.

Package

Source

Methods

Method: pseudo-vertices ((cell <cell>) (factor <vertex>)) ¶

Method: pseudo-vertices ((cell <product-cell>) (factor <simplex>)) ¶

Generic Reader: pt-dictionary (object) ¶

Package

Methods

Reader Method: pt-dictionary ((priority-table priority-table)) ¶

automatically generated reader method

Source: stueben.lisp.
Target Slot: dictionary.

Generic Function: pt-in-table-p (pt obj) ¶

Checks if @arg{obj} is in the priority table @arg{pt}.

Package

Source

Methods

Method: pt-in-table-p ((pt priority-table) obj) ¶

Generic Function: pt-insert (table obj index) ¶

Insert @arg{obj} in a priority-table.

Package

Source

Methods

Method: pt-insert ((pt priority-table) obj index) ¶

Generic Function: pt-pop (pt) ¶

Gets the node with the highest priority from the priority table.

Package

Source

Methods

Method: pt-pop ((pt priority-table)) ¶

Generic Function: pt-remove (pt obj) ¶

Removes @arg{obj} from the priority table.

Package

Source

Methods

Method: pt-remove ((pt priority-table) obj) ¶

Generic Function: pt-shift-priority (pt obj shift) ¶

Changes the priority of @arg{obj}.

Package

Source

Methods

Method: pt-shift-priority ((pt priority-table) obj shift) ¶

Generic Reader: pt-table (object) ¶

Package

Methods

Reader Method: pt-table ((priority-table priority-table)) ¶

automatically generated reader method

Source: stueben.lisp.
Target Slot: table.

Generic Function: read-matrix (class entries &key nrows ncols &allow-other-keys) ¶

Generic interface for reading a sparse matrix.
@arg{class} is a symbol denoting the sparse matrix class with the sole purpose of allowing dispatch, @arg{entries} is a list of triplets of the form (row-index column-index element). Other key arguments can provide more specifications like the format.

Package

Source

Methods

Method: read-matrix ((class (eql fl.matlisp:compressed-matrix)) entries &rest keyword-args &key nrows ncols) ¶

Source: compressed.lisp.

Generic Function: refine-cell! (rule cell skel refined-skel refined-region) ¶

This local refinement function is used to assemble a
global refinement mapping which is represented by the skeleton ‘refinement’. It needs and ensures that the boundary of ‘cell’ is already refined. An existing refinement of ‘cell’ is simply kept.

Package

Source

Methods

Method: refine-cell! :after (rule (cell <cell>) (mesh <mesh>) (refined-mesh <mesh>) refined-region) ¶

This :AFTER-method for cell refinement copies the domain patch to the children. For meshes approximating smooth boundaries, the mappings from interior children are abandoned and finer parametric ones for the boundary neighbors are generated.

Source: mesh.lisp.

Method: refine-cell! :after (rule (cell <cell>) (skel <skeleton>) (refined-skel <skeleton>) refined-region) ¶: This after method ensures the refinement of identified cells and identifies the children.

Method: refine-cell! (rule (cell <cell>) (skel <skeleton>) (refined-skel <skeleton>) refined-region) ¶

Generic Reader: refinement-info (object) ¶

Package

Methods

Reader Method: refinement-info ((refinement-rule refinement-rule)) ¶

Vector of refinement information for the children.

Source: refine.lisp.
Target Slot: refinement-info.

Generic Function: remove-cells! (cell-container cells-to-remove) ¶

Remove @arg{cells} from a cell container like <skeleton>,
<mesh> or <hierarchical-mesh>.
N.B.: Due to our choice of data structure, this is not a local operation with cost O(n) (n=number of cells to be removed) but O(N) (N=total number of cells).

Package

Source

Methods

Method: remove-cells! (container (cells list)) ¶

Method: remove-cells! ((skel <skeleton>) (cells-to-remove hash-table)) ¶

Generic Reader: residual-norm (object) ¶

Package

Methods

Reader Method: residual-norm ((<discrete-iterative-solver> <discrete-iterative-solver>)) ¶

automatically generated reader method

Source: solve.lisp.
Target Slot: residual-norm.

Generic Reader: restart-cycle (object) ¶

Package

Methods

Reader Method: restart-cycle ((<preconditioned-krylow> <preconditioned-krylow>)) ¶

For many Krylow methods a restart is necessary after some steps.

Source: krylow.lisp.
Target Slot: restart-cycle.

Generic Function: restrict (mg-it mg-data) ¶

Restriction from current level. The current level is decremented after the operation.

Package

Source

Methods

Method: restrict :after ((mg-it <fas>) mg-data) ¶

Method: restrict :after ((mg-it <correction-scheme>) mg-data) ¶

Method: restrict :after ((mg-it <mg-iteration>) mg-data) ¶

Method: restrict ((mg-it <mg-iteration>) mg-data) ¶: The basic method for restriction restricts the residual, decrements the level and clears the residual-p flag.

Generic Reader: rule-factors (object) ¶

Package

Methods

Reader Method: rule-factors ((integration-rule integration-rule)) ¶

automatically generated reader method

Source: quadrature.lisp.
Target Slot: rule-factors.

Generic Function: select-estimator (problem blackboard) ¶

Select an error estimator.

Package

Source

gps.lisp.

Methods

Method: select-estimator (problem blackboard) ¶

Generic Function: select-indicator (problem blackboard) ¶

Select a refinement indicator.

Package

Source

gps.lisp.

Methods

Method: select-indicator ((problem <cdr-problem>) blackboard) ¶: For CDR problems, solving with local refinement works. If an error is estimated, we refine those cells within some factor of the maximum error.

Method: select-indicator (problem blackboard) ¶: For systems, there is still a problem with multigrid and local refinements. Therefore, we do not allow local refinement here.

Generic Function: select-linear-solver (matrix blackboard) ¶

Select a suitable solver depending on size of the matrix and the information on the blackoard.

Package

Source

Methods

Method: select-linear-solver :around ((asa <matrix>) blackboard) ¶

Generic Function: set-constraints (ansatz-space) ¶

Computes the constraint matrices for this ansatz-space.
Constraints arise partially because of the discretization, e.g. hanging nodes, and partially because of essential boundary conditions. Of course, these matrices change when mesh or discretization are adapted.

Package: fl.discretization.
Source: ansatz-space.lisp.

Generic Reader: size (object) ¶

Package

Methods

Reader Method: size ((cache-dictionary cache-dictionary)) ¶

automatically generated reader method

Source: dictionary.lisp.
Target Slot: size.

Reader Method: size ((small-cache-dictionary small-cache-dictionary)) ¶

automatically generated reader method

Source: dictionary.lisp.
Target Slot: size.

Generic Function: slice-copy (tensor index-settings) ¶

Extracts a slice of TENSOR

Package

Source

Methods

Method: slice-copy ((tensor full-tensor) index-settings) ¶

Generic Function: smooth (mg-it mg-data which) ¶

Smooth on current level. The argument which should be
one of the keywords :pre or :post and determines which smoothing is to be performed.

Package

Source

Methods

Method: smooth ((mg-it <mg-iteration>) mg-data which) ¶

Generic Function: smoothness (f) ¶

Returns smoothness of function. :INFINITY is returned for infinitely differentiable functions.

Package

Source

Methods

Method: smoothness ((f <linear-function>)) ¶

Method: smoothness ((f <constant-function>)) ¶

Generic Reader: solution (object) ¶

Package

Methods

Reader Method: solution ((<geometric-mg> <geometric-mg>)) ¶

automatically generated reader method

Source: geomg.lisp.
Target Slot: solution.

Generic Writer: (setf solution) (object) ¶

Package

Methods

Writer Method: (setf solution) ((<geometric-mg> <geometric-mg>)) ¶

automatically generated writer method

Source: geomg.lisp.
Target Slot: solution.

Generic Reader: solver-function (object) ¶

Package

Methods

Reader Method: solver-function ((<special-solver> <special-solver>)) ¶

automatically generated reader method

Source: linsolve.lisp.
Target Slot: solver-function.

Generic Reader: starts (object) ¶

Package

Methods

Reader Method: starts ((compressed-pattern compressed-pattern)) ¶

Vector with start indices of compressed columns/rows.

Source: compressed.lisp.
Target Slot: starts.

Generic Reader: step-control (object) ¶

Package

Methods

Reader Method: step-control ((<newton> <newton>)) ¶

NIL means that no step-control is done. If
step-control is a number, then it denotes the maximum number of halving steps which is tried before giving up.

Source: nlsolve.lisp.
Target Slot: step-control.

Generic Reader: store (object) ¶

Package

Methods

Reader Method: store ((small-cache-dictionary small-cache-dictionary)) ¶

automatically generated reader method

Source: dictionary.lisp.
Target Slot: store.

Generic Reader: store-p (object) ¶

Package

Methods

Reader Method: store-p ((<block-iteration> <block-iteration>)) ¶

T if diagonal can be stored.

Source: blockit.lisp.
Target Slot: store-p.

Generic Reader: tail (object) ¶

Package

Methods

Reader Method: tail ((queue queue)) ¶

automatically generated reader method

Source: utilities.lisp.
Target Slot: tail.

Generic Writer: (setf tail) (object) ¶

Package

Methods

Writer Method: (setf tail) ((queue queue)) ¶

automatically generated writer method

Source: utilities.lisp.
Target Slot: tail.

Generic Reader: tasks (object) ¶

Package

Methods

Reader Method: tasks ((work-group work-group)) ¶

automatically generated reader method

Source: multiprocessing.lisp.
Target Slot: tasks.

Generic Function: tentative-prolongation (amg blackboard) ¶

Precondition: the items :matrix and
:coarse-grid-nodes have to be supplied on the blackboard. Post-condition: Items :matrix and :tentative-prolongation on the blackboard. In the case of selection-amg this will usually be injection, in the case of aggregation-amg this will be the piecewise constant prolongation.

Package

Source

Methods

Method: tentative-prolongation ((amg <selection-amg>) blackboard) ¶

Simply injection, i.e. P_{CC}=Id_{CC}.

Source: selection-amg.lisp.

Generic Reader: theta (object) ¶

Package

Methods

Reader Method: theta ((<stueben> <stueben>)) ¶

automatically generated reader method

Source: stueben.lisp.
Target Slot: theta.

Generic Writer: (setf theta) (object) ¶

Package

Methods

Writer Method: (setf theta) ((<stueben> <stueben>)) ¶

automatically generated writer method

Source: stueben.lisp.
Target Slot: theta.

Generic Reader: threads (object) ¶

Package

Methods

Reader Method: threads ((work-group work-group)) ¶

automatically generated reader method

Source: multiprocessing.lisp.
Target Slot: threads.

Generic Writer: (setf threads) (object) ¶

Package

Methods

Writer Method: (setf threads) ((work-group work-group)) ¶

automatically generated writer method

Source: multiprocessing.lisp.
Target Slot: threads.

Generic Reader: time-step (object) ¶

Package

Methods

Reader Method: time-step ((<rothe> <rothe>)) ¶

automatically generated reader method

Source: rothe.lisp.
Target Slot: time-step.

Generic Function: time-step-problem (rothe problem) ¶

Extract a stationary PDE problem for performing one step of the given Rothe method out of the given time-dependent PDE problem @arg{problem}.

Package: fl.strategy.
Source: rothe.lisp.

Generic Reader: time-stepping-scheme (object) ¶

Package

Methods

Reader Method: time-stepping-scheme ((<rothe> <rothe>)) ¶

Time-stepping scheme, e.g. @code{:implicit-euler} or @code{:bdf2}.

Source: rothe.lisp.
Target Slot: scheme.

Generic Function: transform-cell! (cell transformation) ¶

Transforms the cell according to the transformation.
Note that this will not work, if unmapped cells are transformed nonlinearly.

Package

Source

skeleton-build.lisp.

Methods

Method: transform-cell! :after ((cell <boundary-cell>) transformation) ¶

Source: triangulate.lisp.

Method: transform-cell! :after ((cell <mapped-cell>) transformation) ¶

Method: transform-cell! :after ((cell <vertex>) transformation) ¶

Method: transform-cell! :before (cell transformation) ¶

Method: transform-cell! (cell transformation) ¶: Default method returns @arg{cell}.

Generic Function: unit (f) ¶

Generates a unit of the same kind as @arg{F}.

Package

Source

Methods

Method: unit ((f number)) ¶

Method: unit ((f list)) ¶

Method: unit ((f polynomial)) ¶

Generic Function: update-refinement! (skel refined-skel &key region indicator refined highest) ¶

Low-level interface to refinement. @arg{region} is
either NIL or a skeleton giving the region to be refined. @arg{indicator} is a function returning the refinement rule for each cell. In the skeleton @arg{refined} the actually refined cells can be collected, and @arg{highest} determines if the indicator gives refinement for every cell or only the highest-dimensional cells.

Package

Source

Methods

Method: update-refinement! ((skel <skeleton>) (refined-skel <skeleton>) &key region indicator refined highest) ¶

Generic Reader: upper-right (object) ¶

Package

Methods

Reader Method: upper-right ((<ldu-sparse> <ldu-sparse>)) ¶

automatically generated reader method

Source: sparselu.lisp.
Target Slot: upper-right.

Generic Reader: value (object) ¶

Package

Methods

Reader Method: value ((<constant-function> <constant-function>)) ¶

automatically generated reader method

Source: function.lisp.
Target Slot: value.

Generic Function: wait (waitqueue-object &key while until finish perform &allow-other-keys) ¶

Waits on @arg{waitqueue-object} while @arg{while} is
satisfied or until @arg{until} is satisfied. After a successful waiting, the function given in @arg{perform} is called.

Package

Source

Methods

Method: wait (obj &key &allow-other-keys) ¶: The default method for objects does not wait at all.

Method: wait ((wq waitqueue-mixin) &key while until perform finish) ¶

Generic Reader: waitqueue (object) ¶

Package

Methods

Reader Method: waitqueue ((waitqueue-mixin waitqueue-mixin)) ¶

automatically generated reader method

Source: multiprocessing.lisp.
Target Slot: waitqueue.

Generic Reader: work (object) ¶

Package

Methods

Reader Method: work ((work-group work-group)) ¶

automatically generated reader method

Source: multiprocessing.lisp.
Target Slot: work.

Generic Function: work-on-queue (work-queue) ¶

Package

Source

Methods

Method: work-on-queue ((cq chunk-queue)) ¶

Generic Function: x<-eye (x) ¶

Set x to the identity matrix.

Package

Source

Methods

Method: x<-eye (x) ¶

Generic Function: zero-constraints (problem) ¶

Returns a coefficient function which constrains all system components to zero.

Package

Source

Methods

Method: zero-constraints (problem) ¶

Next: Classes, Previous: Generic functions, Up: Internals [Contents][Index]

6.2.6 Structures

Structure: <child-info> ¶

This structure contains information about the children, their factor simplices, and how to find their boundary sides. The slots are:

class: the child’s cell-class

barycentric-corners:
A list of the child’s corners in barycentric coordinates

boundary-paths:
For each side of the child this list contains a path in the form (i_1, ..., i_l, j): here i_1, ..., i_l are positions in subsequent boundary lists starting from the boundary of the child’s parent, and j is the position in the refine-info vector of the boundary’s parent.

transform-A, transform-b: determine the transformation mapping for the child

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: reference-cell ¶

Type: fl.mesh:<cell>
Initform: (fl.utilities:required-argument)
Readers: child-reference-cell.
Writers: (setf child-reference-cell).

Slot: barycentric-corners ¶

Type: list
Readers: child-barycentric-corners.
Writers: (setf child-barycentric-corners).

Slot: boundary-paths ¶

Type: list
Readers: child-boundary-paths.
Writers: (setf child-boundary-paths).

Slot: transform-a ¶

Readers: child-transform-a.
Writers: (setf child-transform-a).

Slot: transform-b ¶

Readers: child-transform-b.
Writers: (setf child-transform-b).

Structure: cell-class-information ¶

Structure containing information necessary for cell handling.

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: dimension ¶

Type: fixnum
Initform: -1
Readers: ci-dimension.
Writers: (setf ci-dimension).

Slot: reference-cell ¶

Type: fl.mesh:<cell>
Initform: (error "reference cell has to be provided")
Readers: ci-reference-cell.
Writers: (setf ci-reference-cell).

Slot: factor-simplices ¶

Readers: ci-factor-simplices.
Writers: (setf ci-factor-simplices).

Slot: nr-of-sides ¶

Type: fixnum
Initform: -1
Readers: ci-nr-of-sides.
Writers: (setf ci-nr-of-sides).

Slot: nr-of-vertices ¶

Type: fixnum
Initform: -1
Readers: ci-nr-of-vertices.
Writers: (setf ci-nr-of-vertices).

Slot: nr-of-subcells ¶

Type: fixnum
Initform: -1
Readers: ci-nr-of-subcells.
Writers: (setf ci-nr-of-subcells).

Slot: boundary-indices-of-subcells ¶

Readers: ci-boundary-indices-of-subcells.
Writers: (setf ci-boundary-indices-of-subcells).

Slot: refine-info ¶

Readers: ci-refine-info.
Writers: (setf ci-refine-info).

Slot: refinement-rules ¶

Initform: #()
Readers: ci-refinement-rules.
Writers: (setf ci-refinement-rules).

Structure: parpool-entry ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: object ¶

Readers: ppe-object.
Writers: (setf ppe-object).

Slot: refcount ¶

Readers: ppe-refcount.
Writers: (setf ppe-refcount).

Slot: key ¶

Readers: ppe-key.
Writers: (setf ppe-key).

Next: Types, Previous: Structures, Up: Internals [Contents][Index]

6.2.7 Classes

Class: (<block-definition-mixin>⎵<ht-sparse-matrix>) ¶

Package

Direct superclasses

<block-definition-mixin>.
<ht-sparse-matrix>.

Class: (compressed-matrix⎵(store-vector⎵double-float⎵dynamic⎵nil)) ¶

Package

Direct superclasses

(store-vector⎵double-float⎵dynamic⎵nil).
compressed-matrix.

Class: (refinement-rule⎵<anisotropic-rule-mixin>) ¶

Package

Direct superclasses

<anisotropic-rule-mixin>.
refinement-rule.

Class: (store-vector⎵double-float⎵dynamic⎵nil) ¶

Package

Direct superclasses

static-store-vector.

Direct subclasses

(compressed-matrix⎵(store-vector⎵double-float⎵dynamic⎵nil)).
(standard-matrix⎵double-float).

Direct methods

element-type.
scalar-type.

Class: <aggregation-amg> ¶

This variant of algebraic multigrid coarsens in a
special way by collecting fine-grid nodes into aggregates. These are put into a set which is then used by the method build-ip to build the actual interpolation matrix.

Package: fl.multigrid.
Source: aggregation-amg.lisp.
Direct superclasses: <algebraic-mg>.

Class: <algebraic-mg> ¶

The algebraic multigrid iteration is a multigrid
iteration where the hierarchy of problems is derived from the fine-grid matrix. Usually, an algebraic multigrid will use the same iterator as its geometric counterpart.

Package

Source

Direct superclasses

<correction-scheme>.
<mg-iteration>.

Direct subclasses

<aggregation-amg>.
<selection-amg>.

Direct methods

cg-max-size.
coarse-grid-matrix.
coarsen.
max-depth.
multilevel-decomposition.
preprocess-matrix.
restriction.

Direct slots

Slot: max-depth ¶

Initform: most-positive-fixnum
Initargs: :max-depth
Readers: max-depth.
Writers: This slot is read-only.

Slot: cg-max-size ¶

Initform: fl.multigrid::*amg-cg-max-size*
Initargs: :cg-max-size
Readers: cg-max-size.
Writers: This slot is read-only.

Slot: output ¶

Initargs: :output

Class: <anisotropic-rule-mixin> ¶

Mixin for an anisotropic refrule. This type of rule includes copy and regular refinement as special cases.

Package

Source

(refinement-rule⎵<anisotropic-rule-mixin>).

Direct subclasses

Direct slots

Slot: types ¶

Initargs: :types

Class: <ansatz-space-object> ¶

Mixin for objects to which an ansatz-space is associated.

Package

Source

Direct superclasses

Direct subclasses

<ansatz-space-automorphism>.
<ansatz-space-vector>.

Direct methods

ansatz-space.
fe-class.
hierarchical-mesh.
make-analog.
mesh.
problem.

Direct slots

Slot: ansatz-space ¶

Type: fl.discretization:<ansatz-space>
Initargs: :ansatz-space
Readers: ansatz-space.
Writers: This slot is read-only.

Class: <block-definition-mixin> ¶

Package

Source

(<block-definition-mixin>⎵<ht-sparse-matrix>).

Direct subclasses

Direct methods

automorphism-p.
col-key->size.
keys->pattern.
make-analog.
row-key->size.

Direct slots

Slot: row-key->size ¶

Type: function
Initargs: :key->size, :row-key->size
Readers: row-key->size.
Writers: This slot is read-only.

Slot: col-key->size ¶

Type: function
Initargs: :key->size, :col-key->size
Readers: col-key->size.
Writers: This slot is read-only.

Slot: keys->pattern ¶

Function determining the pattern of a block.

Type: function
Initargs: :keys->pattern
Readers: keys->pattern.
Writers: This slot is read-only.

Class: <cell-with-boundary> ¶

This is an abstract class which is a base for standard-cell and boundary-cell.

Package

Source

Direct superclasses

<cell>.

Direct subclasses

<boundary-cell>.
<standard-cell>.

Direct methods

boundary.
check.

Direct slots

Slot: boundary ¶

A vector of boundary cells.

Type: fl.mesh::cell-vec
Initargs: :boundary
Readers: boundary.
Writers: This slot is read-only.

Class: <demo> ¶

Femlisp demo node.

Package

Source

demo.lisp.

Direct methods

(setf execute).
execute.
(setf leaves).
leaves.
(setf name).
name.

Direct slots

Slot: name ¶

The name of the demo.

Type: string
Initargs: :name
Readers: name.
Writers: (setf name).

Slot: short ¶

A short description.

Initargs: :short

Slot: long ¶

A long description.

Initargs: :long

Slot: leaves ¶

The child nodes of the demo.

Type: list
Readers: leaves.
Writers: (setf leaves).

Slot: execute ¶

A function performing the demo.

Initargs: :execute
Readers: execute.
Writers: (setf execute).

Slot: input ¶

Sample string of user input for testing.

Initargs: :test-input

Class: <difference-with-projection> ¶

This is a mixin to <standard-error-estimator> which
adapts project-solution to compute the difference between the solution and its projection to a coarser level in the quantity :solution-increment on the blackboard.

Package: fl.strategy.
Source: error-estimator.lisp.
Direct subclasses: <projection-error-estimator>.
Direct methods: compute-error-approximant.

Class: <discrete-iterative-solver> ¶

The base class of solvers for discrete linear and nonlinear problems.

Package

Source

Direct superclasses

Direct subclasses

<linear-solver>.
<nonlinear-solver>.

Direct methods

finally.
initially.
intermediate.
residual-norm.

Direct slots

Slot: residual-norm ¶

Initform: (function fl.matlisp:l2-norm)
Initargs: :residual-norm
Readers: residual-norm.
Writers: This slot is read-only.

Slot: observe ¶

Initform: fl.iteration:*discrete-iterative-solver-observe*

Class: <distorted-cell> ¶

A mixin which distinguishes if the cell mapping is a distortion of the multilinear mapping.

Package

Source

Direct methods

local->dglobal.
local->global.
multiple-local->dglobal.
multiple-local->global.

Class: <domain-image-mixin> ¶

Package

Source

Direct methods

domain-ansatz-space.
image-ansatz-space.

Direct slots

Slot: domain-ansatz-space ¶

Type: fl.discretization:<ansatz-space>
Initargs: :domain-ansatz-space
Readers: domain-ansatz-space.
Writers: This slot is read-only.

Slot: image-ansatz-space ¶

Type: fl.discretization:<ansatz-space>
Initargs: :image-ansatz-space
Readers: image-ansatz-space.
Writers: This slot is read-only.

Class: <error-estimator> ¶

An error estimator is used as first argument in the
generic functions local-estimate, global-estimate, and estimate which work on a blackboard.

Package: fl.strategy.
Source: error-estimator.lisp.
Direct subclasses: <standard-error-estimator>.
Direct methods: estimate.

Class: <evp-solver> ¶

General class for a solver of eigenvalue problems.

Package

Source

evpsolve.lisp.

Direct superclasses

<nonlinear-solver>.

Direct subclasses

<lobpcg>.
<wielandt-iteration>.

Class: <fe-evp-strategy> ¶

This class is a modification of
@class{<stationary-fe-strategy>} for solving PDE eigenvalue problems by a Wielandt iteration.

Package: fl.strategy.
Source: fe-evp.lisp.
Direct superclasses: <stationary-fe-strategy>.
Direct methods: approximate.

Class: <fe> ¶

Abstract base class for finite elements.

Package

Source

Direct superclasses

Direct subclasses

<scalar-fe>.
<vector-fe>.

Direct methods

discretization.
fe-factors.
interpolate-on-refcell.
quadrature-rule.
reference-cell.

Direct slots

Slot: refcell ¶

Type: fl.mesh:<cell>
Initargs: :cell
Readers: reference-cell.
Writers: This slot is read-only.

Slot: fe-factors ¶

Initargs: :fe-factors
Readers: fe-factors.
Writers: This slot is read-only.

Slot: discretization ¶

Initargs: :discretization
Readers: discretization.
Writers: This slot is read-only.

Class: <geometric-blocking-mixin> ¶

Determines if the block choice is centered on cells or
vertices. The latter choice can be shown to be robust in the order p for finite elements of Lagrange type [Pavarino 1994].

Package

Source

geoblock.lisp.

Direct subclasses

<geometric-psc>.
<geometric-ssc>.

Direct methods

setup-blocks.

Direct slots

Slot: type ¶

Package: common-lisp.
Initform: :vertex-centered
Initargs: :type

Class: <geometric-mg> ¶

The geometric multigrid iteration is a multigrid
iteration where the hierarchy of problems is obtained by discretizing on a sequence of refined meshes. It is an abstract class and should be merged with either <correction-scheme> or <fas>.

Package

Source

geomg.lisp.

Direct superclasses

<mg-iteration>.

Direct subclasses

<geometric-cs>.
<geometric-fas>.

Direct methods

galerkin-p.
multilevel-decomposition.
(setf solution).
solution.

Direct slots

Slot: solution ¶

Type: fl.discretization:<ansatz-space-vector>
Initargs: :solution
Readers: solution.
Writers: (setf solution).

Slot: galerkin-p ¶

Initargs: :galerkin-p
Readers: galerkin-p.
Writers: This slot is read-only.

Class: <global-and-local-norm> ¶

This is a mixin to <standard-error-estimator> which computes a local cell norm.

Package

Source

<projection-error-estimator>.

Direct superclasses

<global-norm>.

Direct subclasses

Direct methods

compute-local-estimate.

Direct slots

Slot: local-p ¶

Initform: 2
Initargs: :local-p

Class: <global-norm> ¶

This is a mixin to <standard-error-estimator> which
leads to computation of a p-norm of the local contributions. If global-p is :identity a simple summation is performed.

Package

Source

<global-and-local-norm>.

Direct subclasses

Direct methods

global-estimate.

Direct slots

Slot: global-p ¶

Initform: 2
Initargs: :global-p

Class: <gmres> ¶

Preconditioned GMRES iteration

Package: fl.iteration.
Source: krylow.lisp.
Direct superclasses: <preconditioned-krylow>.
Direct methods: make-iterator.

Class: <ht-sparse-matrix> ¶

The <ht-sparse-matrix> represents an unordered matrix graph indexed by general keys.

Package

Source

(<block-definition-mixin>⎵<ht-sparse-matrix>).

Direct superclasses

<sparse-dictionary-matrix>.
locked-region-mixin.

Direct subclasses

Direct methods

(setf column-table).
column-table.
initialize-instance.
(setf matrix-block).
(setf row-table).
row-table.

Direct slots

Slot: test ¶

Initform: (quote eql)
Initargs: :test

Slot: row-table ¶

Table of rows

Type: (or null hash-table)
Initargs: :row-table
Readers: row-table.
Writers: (setf row-table).

Slot: column-table ¶

Table of columns

Type: (or null hash-table)
Initargs: :column-table
Readers: column-table.
Writers: (setf column-table).

Class: <ht-sparse-vector> ¶

Sparse block vector class implemented using a hash-table.

Package

Source

Direct superclasses

<sparse-dictionary-vector>.
locked-region-mixin.

Direct subclasses

<ansatz-space-vector>.

Direct methods

blocks.
gesv!.
getrs!.
initialize-instance.
m*.

Direct slots

Slot: test ¶

Initform: (quote eql)
Initargs: :test

Slot: blocks ¶

Table of blocks.

Type: hash-table
Readers: blocks.
Writers: This slot is read-only.

Class: <isotropizing-indicator> ¶

Marks anisotropic product cells in such a way that they become isotropic.

Package: fl.strategy.
Source: error-indicator.lisp.
Direct superclasses: <refinement-indicator>.
Direct methods: cell-rule.

Class: <key->size-mixin> ¶

A mixin which is not used up to now, because the same functionality is provided using information from the ansatz-space.

Package

Source

Direct methods

key->size.
make-analog.

Direct slots

Slot: key->size ¶

Function determining the dimension of a block.

Type: function
Initargs: :key->size
Readers: key->size.
Writers: This slot is read-only.

Class: <ldu-sparse> ¶

Package

Source

sparselu.lisp.

Direct methods

drop-content.
getrs!.
ldu-diagonal.
lower-left.
m*.
ordering.
upper-right.

Direct slots

Slot: lower-left ¶

Initargs: :lower-left
Readers: lower-left.
Writers: This slot is read-only.

Slot: diagonal ¶

Initargs: :diagonal
Readers: ldu-diagonal.
Writers: This slot is read-only.

Slot: upper-right ¶

Initargs: :upper-right
Readers: upper-right.
Writers: This slot is read-only.

Slot: ordering ¶

Type: vector
Initargs: :ordering
Readers: ordering.
Writers: This slot is read-only.

Class: <linearly-transformed-function> ¶

<linearly-transformed-function> calls the original
function evaluation on linearly transformed coordinates and linearly transforms also the result.

Package

Source

Direct superclasses

Direct methods

differentiable-p.
domain-a.
domain-b.
evaluate.
evaluate-gradient.
image-a.
image-b.
original.

Direct slots

Slot: original ¶

Initargs: :original
Readers: original.
Writers: This slot is read-only.

Slot: domain-a ¶

Initargs: :domain-a
Readers: domain-a.
Writers: This slot is read-only.

Slot: domain-b ¶

Initargs: :domain-b
Readers: domain-b.
Writers: This slot is read-only.

Slot: image-a ¶

Initargs: :image-a
Readers: image-a.
Writers: This slot is read-only.

Slot: image-b ¶

Initargs: :image-b
Readers: image-b.
Writers: This slot is read-only.

Class: <lobpcg> ¶

Knyazev’s LOBPCG iteration.

Package: fl.iteration.
Source: evpsolve.lisp.
Direct superclasses: <evp-solver>.
Direct methods: next-step.

Class: <local-mg> ¶

Local geometric multigrid of correction scheme type.

Package: fl.geomg.
Source: geomg.lisp.
Direct superclasses: <geometric-cs>.

Class: <local-test-with-dual> ¶

A mixin testing the residual with an approximation of a
dual solution. To localize we subtract a local projection on lower order polynomials.

Package

Source

<duality-error-estimator>.

Direct subclasses

Direct methods

compute-local-estimate.
global-estimate.

Class: <mapped-vertex> ¶

At the moment, this class is not needed because vertices are not mapped.

Package

Source

vertex.lisp.

Direct superclasses

<mapped-cell>.
<vertex>.

Direct methods

global->local.
initialize-instance.

Class: <nonlinear-solver> ¶

Class for general nonlinear iterative solvers.

Package

<discrete-iterative-solver>.

Source

nlsolve.lisp.

Direct superclasses

Direct subclasses

<evp-solver>.
<newton>.

Direct methods

inner-iteration.
linear-solver.

Direct slots

Slot: linear-solver ¶

The linear solver for solving the linearization.

Initargs: :linear-solver
Readers: linear-solver.
Writers: This slot is read-only.

Class: <preconditioned-krylow> ¶

Package

Source

krylow.lisp.

Direct superclasses

Direct subclasses

<bi-cgstab>.
<cg>.
<gmres>.

Direct methods

print-object.
restart-cycle.

Direct slots

Slot: preconditioner ¶

A linear iteration used as a preconditioner

Initargs: :preconditioner

Slot: restart-cycle ¶

For many Krylow methods a restart is necessary after some steps.

Initargs: :restart-cycle
Readers: restart-cycle.
Writers: This slot is read-only.

Class: <richardson> ¶

Package: fl.iteration.
Source: linit.lisp.
Direct superclasses: <linear-iteration>.
Direct methods: make-iterator.

Class: <setup-blocks-mixin> ¶

Executes the given function for determining the block decomposition.

Package

Source

Direct subclasses

<custom-psc>.
<custom-ssc>.

Direct methods

setup-blocks.

Direct slots

Slot: block-setup ¶

Contains NIL or a function which is called for block setup.

Initargs: :block-setup

Class: <setup-enriched-ansatz-space> ¶

A mixin leading to the assembly of interpolated solution, matrix and rhs in an enriched ansatz space.

Package: fl.strategy.
Source: error-estimator.lisp.
Direct subclasses: <duality-error-estimator>.
Direct methods: compute-error-approximant.

Class: <solve-dual-problem> ¶

A mixin leading to the computation of the solution of
the dual problem for the given functional. The result is put in :error-weight-function.

Package

Source

<duality-error-estimator>.

Direct subclasses

Direct methods

compute-weight-function.
(setf functional).
functional.

Direct slots

Slot: functional ¶

Initargs: :functional
Readers: functional.
Writers: (setf functional).

Slot: solver ¶

Initargs: :solver

Class: <sparse-dictionary-matrix> ¶

Sparse matrices defined via dictionaries.

Package

Source

Direct superclasses

<sparse-matrix>.
pool-mixin.

Direct subclasses

<ht-sparse-matrix>.

Direct methods

Direct slots

Slot: row-table ¶

Table of row dictionaries.

Initargs: :row-table
Readers: row-table.
Writers: (setf row-table).

Slot: column-table ¶

Table of column dictionaries.

Initargs: :column-table
Readers: column-table.
Writers: (setf column-table).

Class: <sparse-dictionary-vector> ¶

Sparse block vector class indexed with general keys.

Package

Source

Direct superclasses

<sparse-vector>.

Direct subclasses

<ht-sparse-vector>.

Direct methods

for-each-entry.
for-each-entry-and-key.
for-each-key.
remove-key.
(setf vector-block).
vector-block.

Class: <standard-cell> ¶

The standard cell in Femlisp is defined via its boundary.

Package

Source

Direct superclasses

<cell-with-boundary>.

Direct subclasses

<1-1-1-1-product-cell>.
<1-1-1-product-cell>.
<1-1-product-cell>.
<1-2-product-cell>.
<1-simplex>.
<2-1-product-cell>.
<2-simplex>.
<3-simplex>.

Direct methods

boundary.
check.
copy-cell.

Direct slots

Slot: boundary ¶

A vector of boundary cells.

Type: fl.mesh::cell-vec
Initargs: :boundary
Readers: boundary.
Writers: This slot is read-only.

Class: <standard-error-estimator> ¶

For this form of error estimator the local estimate is
further decomposed in the steps project-solution, compute-weight-function, and compute-local-estimate, all of them acting on the blackboard.

Package

Source

Direct superclasses

<error-estimator>.

Direct subclasses

<duality-error-estimator>.
<projection-error-estimator>.

Direct methods

compute-error-approximant.
compute-local-estimate.
compute-weight-function.
local-estimate.

Class: <wielandt-iteration> ¶

Wielandt iteration.

Package: fl.iteration.
Source: evpsolve.lisp.
Direct superclasses: <evp-solver>.
Direct methods: next-step.

Class: chunk-queue ¶

Queue for chunk work. A chunk is a list of thunks, which can be enqueued only if the queue is empty.

Package

Source

Direct superclasses

parqueue.

Direct methods

chunk-enqueue.
dequeue.
work-on-queue.

Direct slots

Slot: in-work-count ¶

Initform: 0

Slot: finalizer ¶

Class: dictionary ¶

A superclass for user-defined dictionaries.

Package

Source

Direct subclasses

small-cache-dictionary.
sorted-dictionary.

Class: eql-relation ¶

Relation for objects.

Package

Source

Direct superclasses

relation.

Direct methods

r-insert.
r-select.

Direct slots

Slot: table ¶

Initform: (make-hash-table)

Slot: vector ¶

Package: common-lisp.
Initform: (make-array 0 :adjustable t :fill-pointer 0)

Class: identification ¶

This object describes a cluster of identified cells. At
the moment, it is used to describe identified boundaries and might be used later on for parallelization purposes. Those identifications are refered to in the properties of each cell.

Package

Source

identify.lisp.

Direct methods

cells.
print-object.
representative.

Direct slots

Slot: skeleton ¶

Initargs: :skeleton

Slot: cells ¶

A list of identified cells.

Initargs: :cells
Readers: cells.
Writers: This slot is read-only.

Class: parallel-heap ¶

This class implements a heap for traversing a set of objects in parallel in such a way that the operation does not conflict with other threads working on the same set. While the parallel operation works on some object, all dependents are blocked. Furthermore, after the operation on an object is finished its dependents are priorized for being operated on for optimizing cache use.

Package

Source

parallel-heap.lisp.

Direct superclasses

waitqueue-mixin.

Direct methods

popper.

Direct slots

Slot: available-objects ¶

Initform: (make-instance (quote fl.dictionary:sorted-hash-table) :insertion-order :heap)

Slot: blocked-objects ¶

Initform: (fl.patches:make-hash-table)

Slot: done-objects ¶

Slot: dependents ¶

A function returning all dependents of an object.

Initargs: :dependents

Class: pool-mixin ¶

Package

Source

<sparse-dictionary-matrix>.

Direct subclasses

Direct slots

Slot: pool ¶

A pool from which matrix-blocks may be obtained fast.

Package: fl.dictionary.
Initargs: :pool

Class: priority-queue ¶

tables is a dll of hash-tables, at the start is the
highest priority, at the end the lowest. objects is a hash-table from objects in the pq pointing to the dll-item where the object is.

Package

Source

triangle.lisp.

Direct methods

show.

Direct slots

Slot: tables ¶

Initform: (fl.utilities:make-dll)

Slot: objects ¶

Initform: (fl.patches:make-hash-table)

Class: priority-table ¶

Objects of this class are a dictionary for object/priority
pairs. It allows to pop objects of maximum or minimum priority. Objects can also be deleted.

Internally, table is an adjustable vector with fill-pointer being either 0 or larger than 0, if there is an entry in the doubly-linked list at the corresponding index.

Package

Source

Direct methods

pt-dictionary.
pt-in-table-p.
pt-insert.
pt-pop.
pt-remove.
pt-shift-priority.
pt-table.

Direct slots

Slot: table ¶

Initform: (make-array 32 :initial-element nil :adjustable t :fill-pointer 0)
Readers: pt-table.
Writers: This slot is read-only.

Slot: dictionary ¶

Initform: (make-hash-table)
Readers: pt-dictionary.
Writers: This slot is read-only.

Class: queue ¶

Queue class accessed with @function{enqueue} and @function{dequeue}.

Package

Source

Direct subclasses

parqueue.

Direct methods

dequeue.
dequeue-all.
emptyp.
enqueue.
(setf head).
head.
(setf tail).
tail.

Direct slots

Slot: head ¶

Readers: head.
Writers: (setf head).

Slot: tail ¶

Readers: tail.
Writers: (setf tail).

Class: sorted-dictionary ¶

A superclass for sorted dictionaries.

Package: fl.dictionary.
Source: dictionary.lisp.
Direct superclasses: dictionary.
Direct subclasses: sorted-hash-table.

Class: static-store-vector ¶

Subclass of @class{dynamic-store-vector} for which fast
BLAS operations are possible because the store is a simple and uniform array.

Package

(store-vector⎵double-float⎵dynamic⎵nil).

Source

store-vector.lisp.

Direct superclasses

store-vector.

Direct subclasses

Direct methods

axpy!.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
blas-macro.
copy!.
dot.
dot-abs.
fill!.
fill-random!.
m+!.
m.*!.
mequalp.
scal!.
shared-initialize.

Class: thread-cached-dictionary ¶

When calling dic-ref from inside a thread, first an
unlocked access to the thread-local dictionary is done, and only if this does not succed, the global dictionary is accessed with a lock.

Package

Source

Direct superclasses

mutex-mixin.

Direct methods

dic-for-each.
(setf dic-ref).
dic-ref.
initialize-instance.

Direct slots

Slot: generator ¶

Initargs: :generator

Slot: global-dic ¶

Slot: thread-local-dics ¶

Initform: (make-array 0 :adjustable t :initial-element nil)

Class: tree-dictionary ¶

For use in global memoization tables for short list keys.

Package

Source

Direct methods

(setf dic-ref).
dic-ref.

Direct slots

Slot: tree ¶

Class: vector-dof ¶

A dof of a vector finite element.

Package

Source

Direct superclasses

dof.

Direct methods

dof-component.

Direct slots

Slot: component ¶

The component in the solution vector to which this @class{dof} belongs.

Initargs: :component
Readers: dof-component.
Writers: This slot is read-only.

Class: work-group ¶

A class representing a group of threads working on a queue.

Package

Source