The l-math Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The l-math Reference Manual

This is the l-math Reference Manual, version 0.4.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:57:01 2022 GMT+0.

Table of Contents


1 Introduction

L-MATH

This library is no longer maintained.

L-MATH is a library for performing simple linear algebra. Vector and matrix classes are available, as are simple linear interpolation functions, spline-based interpolations (Catmull-Rom and B-Spline methods), and various operations related to creating rotation matrices.

L-MATH also contains various spline implementations, including those implemented using matrices:

There are also general splines that are calculated using recurrence formulae (which is generally a more stable approach than using matrices), such as:

In addition, L-MATH contains various functions for creating random data, including:

Vector

Vectors can be constructed using the VECTOR and TO-VECTOR functions. VECTOR accepts a list of elements, like so:

(lm:vector 1 2 3) => #<L-MATH:VECTOR 1.000 2.000 3.000 >

The VECTOR's dimension is defined by the number of elements in the VECTOR function's lambda list.

(lm:dimension (lm:vector 1 2 3 4)) => 4

TO-VECTOR is intended to transform other types into the VECTOR type. At the moment it supports transforming lists and, trivially, other vector objects:

(lm:to-vector (list 1 2 3)) => #<L-MATH:VECTOR 1.000 2.000 3.000 >

Importantly, TO-VECTOR allows the vector's length to be modified:

(lm:to-vector (list 1 2 3) :dimension 2) => #<L-MATH:VECTOR 1.000 2.000 >
(lm:to-vector (lm:vector 1 2) :dimension 3) => #<L-MATH:VECTOR 1.000 2.000 0.000 >

Vectors can typically be represented as lists. For instance:

(lm:dot-product (lm:vector 1 0 1) (list 0 1 0)) => 0

Various operations (listed below) are available for VECTOR objects. Many of these functions will also accept lists as VECTOR representations.

(lm:dimension VECTOR)

Returns the VECTOR's dimension.

(lm:length VECTOR)

Synonym for DIMENSION.

(lm:norm VECTOR)

Returns the VECTOR's length.

(lm:vector= LHS RHS)

Returns T iff the two vectors are equal. Internally, the VECTOR class stores the data as an array of double-floats. Because of rounding errors it is not advisable to compare floating point values exactly. VECTOR= uses the special variable equivalence-tolerance to define the tolerance within which two vectors are considered equal. equivalence-tolerance defaults to 0.0001, which should be reasonable for most applications. For example:

(lm:vector= (lm:vector 1 2 3) (lm:vector 1 2 3.1)) => NIL
(lm:vector= (lm:vector 1 2 3) (lm:vector 1 2 3.00001)) => T
(lm:elt VECTOR index)

Returns the element at the given index. This is also a SETFable place. VECTORs are zero based.

(lm:x VECTOR) (lm:y VECTOR) (lm:z VECTOR) (lm:w VECTOR)

Returns the elements at indices 0, 1, 2 and 3 respectively. These are all SETFable places.

(lm:dot-product VECTOR)

Returns the VECTOR's dot product.

(lm:cross-product LHS RHS)

Calculates the cross product between two 3-vectors.

(lm:angle-between FROM-VECTOR TO-VECTOR)

Returns the angle, in radians, needed to align the FROM-VECTOR with the TO-VECTOR. The angle is signed, and is a left-handed rotation. Example:

(lm:to-degrees (lm:angle-between (lm:vector 1 0) (lm:vector 0 1))) => 90.0d0
(lm:to-degrees (lm:angle-between (lm:vector 1 0) (lm:vector 0 -1))) => -90.0d0
(lm:euclidean-distance LHS RHS)

Calculates the Euclidean distance between two vectors or two numbers.

Matrix

Matrices can be constructed using (lm:MAKE-MATRIX row col &key initial-elements)

(lm:make-matrix 2 3 :initial-elements '(1 0 0
		    		        0 1 0))
=>					
#<L-MATH:MATRIX 2 x 3
1.000 0.000 0.000 
0.000 1.000 0.000 >

If :initial-elements isn't specified, the matrix elements are initialised to zero.

(lm:matrix= LHS RHS)

Ensures that two matrices are numerically equivalent. All the real-valued components must be within equivalence-tolerance of each other.

(lm:matrix-rows MATRIX) (lm:matrix-cols MATRIX)

Returns the number of rows and columns in the matrix.

(lm:matrix-elt MATRIX row col)

Returns the element at the given row and column. MATRIX objects are zero based. This is a SETFable place.

(lm:make-identity SIZE)

Returns a SIZE×SIZE identity matrix.

(lm:roll-matrix SIZE ANGLE)

Returns SIZE×SIZE matrix which will rotate a post multiplied vector around the z-axis. It is a left-handed rotation. The ANGLE is given in radians. SIZE should be either 3 or 4.

(lm:yaw-matrix SIZE ANGLE)

Returns SIZE×SIZE matrix which will rotate a post multiplied vector around the y-axis. It is a left-handed rotation. The ANGLE is given in radians. SIZE should be either 3 or 4.

(lm:pitch-matrix SIZE ANGLE)

Returns SIZE×SIZE matrix which will rotate a post multiplied vector around the x-axis. It is a left-handed rotation. The ANGLE is given in radians. SIZE should be either 3 or 4.

(lm:set-rotation-naming-convention CONVENTION)

Rebinds YAW-MATRIX, PITCH-MATRIX, and ROLL-MATRIX to rotate around different axes. The available conventions are provided in lm:*rotation-naming-conventions*

(lm:create-rotation-matrix VIEW RIGHT UP &optional (SIZE 3))

Creates a rotation matrix from three vectors. VIEW is the direction that the resulting vector should be pointing along, UP is the direction upwards. RIGHT is the vector orthogonal to this. Will return a left-handed rotation matrix. SIZE is the size of the matrix, and should be either 3 or 4.

(lm:create-rotation-from-view VIEW WORLD-UP &optional (SIZE (length SIZE)))

Given a direction to look in (VIEW), and the direction that is 'upwards' in a given coordinate system, this function creates a rotation matrix to translate into that coordinate system. This rotation is left-handed. SIZE should be either 3 or 4.

(lm:create-rotation-from-view-to-view FROM-VIEW TO-VIEW WORLD-UP)

Creates a rotation matrix that will rotate the vector FROM-VIEW on to the vector TO-VIEW, using WORLD-UP as the coordinate system's 'upward' direction. This is a left-handed rotation. Example:

(let ((rotation (lm:create-rotation-from-view-to-view (lm:vector 1 0 0) 
						      (lm:vector 0 1 0) 
						      (lm:vector 0 0 1))))
	   (lm:* rotation (lm:vector 1 0 0)))
=> #<L-MATH:VECTOR 0.000 1.000 0.000 >

Interpolation

(lm:linear-interpolation START END T-VAL)

Given two vectors (START and END), and a real valued parameter (T-VAL), this returns a vector between START and END. When T-VAL is zero, this returns START. When T-VAL is 1, this returns END. Values between 0 and 1 return vectors between START and END; values below zero return vectors "before" START; values above 1 return vectors "after" END. The value 0.5 returns the vector exactly between START and END. Example:

(lm:linear-interpolation (lm:vector -1 0) (lm:vector 1 0) 0.5)
=> #<L-MATH:VECTOR 0.000 0.000 >
(lm:linear-interpolation (lm:vector 0 0 0) (lm:vector 10 10 10) 2)
=> #<L-MATH:VECTOR 20.000 20.000 20.000 >

This method also accepts arbitrary numbers, and will interpolate between them:

(lm:linear-interpolation 0 100 0.5) => 50.0
(lm:between START END)

Returns the vector exactly between the VECTORs START and END.

General Operations

(lm:equivalent LHS RHS)

Returns t iff the two objects are numerically equivalent. Numbers are tested using =. Real-valued objects (REAL types, VECTORs and MATRIXs) are compared to each other using a tolerance equivalence-tolerance. VECTORs and MATRIX objects are compared using VECTOR= and MATRIX=.

(lm:copy OBJECT)

Returns a copy of the given VECTOR, MATRIX or list.

(lm:negate OBJECT) (lm:negate! OBJECT)

Returns the arithmetic inverse of the given object. NEGATE! does so destructively. Example:

(lm:negate (list 1 -2 3)) => (-1 2 -3)
(lm:to-radians ANGLE) (lm:to-degrees ANGLE)

Converts from radians to degrees, and vice versa.

(lm:test-dimensions LHS RHS)

Ensures that the two items have the same dimensions. The items may be lists, vectors or matrices in most sensible combinations. This function is useful when implementing your own operations between vectors and matrices to ensure that their dimensions agree. If they do not, a DIMENSION-ERROR condition is signalled.

Arithmetic operations

All the general arithmetic operations are defined:

* (lm:+ LHS RHS)
* (lm:- LHS RHS)
* (lm:- OBJECT)
* (lm:* LHS RHS)
* (lm:/ LHS RHS)

Conditions

L-MATH-ERROR: A general condition from which all error conditions for the package inherit.

DIMENSION-ERROR: This is signalled when an operation is requested on objects whose dimensions are inappropriate.

ZERO-NORM-ERROR: This is signalled on operations which do not make sense for vectors with zero norm.

OPERATION-NOT-SUPPORTED: This is signalled when an arithmetic operation is requested on two objects for which the operation is not supported. This should usually not occur, and probably should be considered a bug if it does.

General Comments

Both VECTOR and MATRIX classes have load forms (MAKE-LOAD-FORM). Internally, the data is stored as arrays of DOUBLE-FLOAT values.

For those operations which deal with rotations, note that rotation matrices should be post-multiplied by the vectors. The coordinate system is left-handed, as are the rotations.

Supported Compilers

L-MATH is known to work on SBCL 1.0.29 and 1.0.55. While it should work on other compilers, this so far has not been tested. Please feel free to send in reports of which compilers you've successfully run this with, or to file bug reports where L-MATH is having problems.

Getting and Installing

L-MATH is available from its [home page][2] at Common Lisp.net, or from its github repository. L-MATH can be installed using ASDF-INSTALL and QUICKLISP:

(require 'asdf-install)
(asdf-install:install 'l-math)

(quicklisp:quickload 'l-math)

Reporting Bugs

Bugs can be reported to https://github.com/TheRiver/L-MATH.

License

See the file LICENSE for the licensing details. In brief, L-MATH is licensed under the GPL, with additional permissions giving link exceptions (aka the Classpath exception). Importantly for a Common Lisp library, this exception allows you to use this GPLed library in your application regardless of the licenses of the compiler and the other libraries you are using (as long, of course, as you satisfy those licenses).

Note that this does not remove the obligation that the rest of the GPL places on you, such as supplying the source code of this library.

[2]: http://www.common-lisp.net/projects/l-math/ "Common Lisp


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 l-math

A simple math library focused on linear algebra.

Author

Rudolph Neeser <rudy.neeser@gmail.com>

License

GPLv3 with Classpath Exception

Version

0.4.0

Source

l-math.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 l-math/l-math.asd

Source

l-math.asd.

Parent Component

l-math (system).

ASDF Systems

l-math.

Packages

l-math-asdf.


3.1.2 l-math/package.lisp

Source

l-math.asd.

Parent Component

l-math (system).

Packages

l-math.


3.1.3 l-math/conditions.lisp

Dependency

package.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

3.1.4 l-math/generics.lisp

Dependency

conditions.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

initialise-data (generic function).


3.1.5 l-math/vector.lisp

Dependency

generics.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

initialise-data (method).


3.1.6 l-math/matrix.lisp

Dependency

vector.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

initialise-data (method).


3.1.7 l-math/tests.lisp

Dependency

matrix.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

test-dimensions (generic function).

Internals

3.1.8 l-math/vector-operations.lisp

Dependency

tests.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

3.1.9 l-math/operations.lisp

Dependency

vector-operations.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
  • * (function).
  • + (function).
  • - (function).
  • / (function).
  • c* (generic function).
  • c+ (generic function).
  • c- (generic function).
  • c/ (generic function).
Internals

3.1.10 l-math/rotations.lisp

Dependency

operations.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

fill-row (macro).


3.1.11 l-math/scale.lisp

Dependency

rotations.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

3.1.12 l-math/translation.lisp

Dependency

scale.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

create-translation-matrix (function).


3.1.13 l-math/utility.lisp

Dependency

translation.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

3.1.14 l-math/interpolate.lisp

Dependency

utility.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

private-bilinear-interpolation (function).


3.1.15 l-math/random.lisp

Dependency

interpolate.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

3.1.16 l-math/basis.lisp

Dependency

random.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

3.1.17 l-math/spline.lisp

Dependency

basis.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface
Internals

3.1.18 l-math/spline-interpolation.lisp

Dependency

spline.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

spline-interpolation (generic function).


3.1.19 l-math/transform.lisp

Dependency

spline-interpolation.lisp (file).

Source

l-math.asd.

Parent Component

l-math (system).

Public Interface

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 l-math-asdf

Source

l-math.asd.

Use List
  • asdf/interface.
  • common-lisp.

Previous: , Up: Packages   [Contents][Index]

4.2 l-math

Source

package.lisp.

Nickname

lm

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


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

5.1.1 Special variables

Special Variable: *equivalence-tolerance*

When objects are closer than this distance, they are considered equivalent.

Package

l-math.

Source

generics.lisp.

Special Variable: *rotation-naming-conventions*

Defines the various mappings possible between ROLL-MATRIX, PITCH-MATRIX, YAW-MATRIX, and the different axes.

Package

l-math.

Source

rotations.lisp.


5.1.2 Macros

Macro: do-each-matrix-element ((symbol matrix &optional row-index-symbol col-index-symbol) &body body)

Iterates over each of the matrix elements, row by row.

Package

l-math.

Source

matrix.lisp.

Macro: do-each-matrix-element-2 ((lhs-symbol rhs-symbol lhs-matrix rhs-matrix &key transpose-rhs) &body body)
Package

l-math.

Source

matrix.lisp.

Macro: do-each-vector-element ((element vector &key index-symbol) &body body)

Iterates over elements in a vector.

Package

l-math.

Source

vector.lisp.


5.1.3 Setf expanders

Setf Expander: (setf elt) (vector index)
Package

l-math.

Source

vector.lisp.

Reader

elt (generic function).

Setf Expander: (setf matrix-elt) (matrix row col)
Package

l-math.

Source

matrix.lisp.

Reader

matrix-elt (generic function).

Setf Expander: (setf spline-geometry) (spline)
Package

l-math.

Source

spline.lisp.

Reader

spline-geometry (generic function).

Writer

set-spline-geometry (generic function).


5.1.4 Ordinary functions

Function: * (&rest items)
Package

l-math.

Source

operations.lisp.

Function: + (&rest items)
Package

l-math.

Source

operations.lisp.

Function: - (&rest items)
Package

l-math.

Source

operations.lisp.

Function: / (&rest items)
Package

l-math.

Source

operations.lisp.

Function: b-spline-basis (knot-data degree family parameter &key offset fast-spline-index)

Ask for the value of a given basis function. This is based on
Farin’s ’Curves and Surfaces for Computer Aided Geometric Design. DEGREE is the degree of the curve.

This has some pre-calculated basis functions for uniform knot
secquences. You can access these by specifying an index using
FAST-SPLINE-INDEX. This is an integer between 0 and DEGREE, and
specifies which of the basis functions should be called.

Package

l-math.

Source

basis.lisp.

Function: binomial-coefficient (n i)

Calculates the binomial coefficients. n and i must be non-negative.

Package

l-math.

Source

utility.lisp.

Function: create-bernstein-polynomial (n i)

Returns a bernstein polynomial for n and i. This returned function takes one parameter.

Package

l-math.

Source

utility.lisp.

Function: create-rotation-from-view (view world-up &optional size)

Given a direction to look in (VIEW), and the direction that is ’upwards’ in a given coordinate system, this function creates a rotation matrix to translate into that coordinate system. This matrix should be post multiplied by any vectors. The matrix is defined using a left-handed coordinate system.

Package

l-math.

Source

rotations.lisp.

Function: create-rotation-from-view-to-view (from-view to-view world-up)

Creates a rotation matrix that will rotate the vector FROM-VIEW on to the vector TO-VIEW, using WORLD-UP as the coordinate system’s ’upward’ direction. This matrix should be post-multiplied by any vectors.

Package

l-math.

Source

rotations.lisp.

Function: create-rotation-matrix (view right up &optional size)

Creates a rotation matrix from three vectors. VIEW is the direction that the object should be pointing along, UP is the direction upwards. RIGHT is the vector orthogonal to this.

Package

l-math.

Source

rotations.lisp.

Function: create-scale-matrix (scale-list &key homogenous)

Given a list of scales, one for each dimension, this returns a matrix that will scale any post multiplied vectors by the appropriate amount in each dimension.

Package

l-math.

Source

scale.lisp.

Function: create-translation-matrix (translations)

Given a list of translation, this returns a (1+ (length translations)) × (1+ (length translations)) matrix that will translate any post multiplied vector by the given amount in each dimension. This is a matrix that operates in homogenous coordinates.

Package

l-math.

Source

translation.lisp.

Function: create-uniform-scale-matrix (dimension scale &key homogenous)

Creates a matrix that will scale all elements uniformly. Post multiply this matrix by the vectors.

Package

l-math.

Source

scale.lisp.

Function: draw-noise3-output (width height file-path &optional plane-width)

Outputs perlin noise in the PPM format. WIDTH and HEIGHT are the resolution of the image. FILE-PATH defines where the image should be saved, and PLANE-WIDTH defines the width of the plane on which the noise is added. The wider this width, the smaller the noise detail.

Package

l-math.

Source

random.lisp.

Function: evaluate-bernstein-polynomial (n i t-val)

Evaluates the bernstein polygnomial for n and i at t-val. If this polynomial will be used multiple times, it might be more efficient to create it using CREATE-BERNSTEIN-POLYNOMIAL.

Package

l-math.

Source

utility.lisp.

Function: factorial (n)

Calculates the factorial of the integer, n. The factorial is the product of the sequence of integers 1, 2, 3, ..., n. n must not be a negative number. The factorial of n = 0 is defined to be 1.

Package

l-math.

Source

utility.lisp.

Function: initialize-noise3 (&key lookup-size)

Initialises the perlin noise function, NOISE3. This will be called automatically by NOISE3 if it has not already been done so. You usually will not have to call this function. If you wish to change the random data which NOISE3 uses to calculate the perlin noise, then call this function. LOOKUP-SIZE determines the amount of data stored to calculate the perlin noise. You will probably not have to change this from the default value.

Package

l-math.

Source

random.lisp.

Function: make-diagonal (diagonal)

Creates a (length diagonal) × (length diagonal) matrix zero everywhere except along the diagonal.

Package

l-math.

Source

matrix.lisp.

Function: make-identity (size)

Creates an size x size identity matrix.

Package

l-math.

Source

matrix.lisp.

Function: make-knots (knots &key multiplicity add-phantoms)

Creates a knot sequence. Notice that this will add some phantom knots to the beginning and end of the sequence, unless ADD-PHANTOMS is false. If MULTIPLICITY, a list of multiplicity values, is not given, each knot is assumed to be a simple (non-repeated) knot.

Package

l-math.

Source

basis.lisp.

Function: make-matrix (rows cols &key initial-elements)

Creates a matrix of the given dimensions.

Package

l-math.

Source

matrix.lisp.

Function: make-random-vector (dimension &key noise)

Creates a VECTOR of the given dimension filled with random values obtained by calling NOISE once for each element in the VECTOR. By default, this uses normally distributed random numbers with a mean of 0 and standard deviation of 1.

Package

l-math.

Source

random.lisp.

Function: make-vector (dim &key initial-elements)

Create a vector of the given dimensions.

Package

l-math.

Source

vector.lisp.

Function: noise3 (point)

Calculates Perlin noise. As input, it takes a 3-vector. It returns a random value between -1 and 1.

Package

l-math.

Source

random.lisp.

Function: normal (&key mean sd min max state)

Returns a normally distributed random variable with the given mean and standard-deviation. If min or max is given, the random number is no smaller than min and no larger than max.

Package

l-math.

Source

random.lisp.

Function: pitch-by (vector angle)

Returns the given vector after it has undergone a pitch by the given angle, specified in radians. This is a left-handed rotation.

Package

l-math.

Source

rotations.lisp.

Function: pitch-matrix (size angle)

A synonym for ROTATION-X, although this can be changed using lm:SET-ROTATION-NAMING-CONVENTION.

Package

l-math.

Source

rotations.lisp.

Function: roll-by (vector angle)

Returns the given vector after it has undergone a roll by the given angle, specified in radians. This is a left-handed rotation.

Package

l-math.

Source

rotations.lisp.

Function: roll-matrix (size angle)

A synonym for ROTATION-Z, although this can be changed using lm:SET-ROTATION-NAMING-CONVENTION.

Package

l-math.

Source

rotations.lisp.

Function: rotation-x (size angle)

Creates a matrix that rotates around the x-axis by the given angle, given in radians. This is a left-handed rotation.

Package

l-math.

Source

rotations.lisp.

Function: rotation-y (size angle)

Creates a matrix that rotates around the y-axis by the given angle, given in radians. This is a left-handed rotation

Package

l-math.

Source

rotations.lisp.

Function: rotation-z (size angle)

Creates a matrix that rotates around the z-axis by the given angle, in radians. This is a left-handed rotation.

Package

l-math.

Source

rotations.lisp.

Function: set-rotation-naming-convention (convention)

Changes the mappings between ROLL-MATRIX, PITCH-MATRIX and YAW-MATRIX and the axes. See lm:*rotation-naming-conventions* to see what conventions are possible.

Package

l-math.

Source

rotations.lisp.

Function: summation-transformer (additive-term &rest other-terms)

Returns a function that will add the additive-term, and all the other-terms, to its argument. It is useful for translating objects, since that is merely an addition of a vector term.

Package

l-math.

Source

transform.lisp.

Function: to-degrees (radians)
Package

l-math.

Source

rotations.lisp.

Function: to-radians (degrees)
Package

l-math.

Source

rotations.lisp.

Function: uniform (&key min max state)

Returns a random number uniformly distributed between
minimum (inclusive) and maximum (exclusive). Like CL:RANDOM, the type of the returned value depends on the type of min and max.

Package

l-math.

Source

random.lisp.

Function: vector (&rest elements)

Create a vector.

Package

l-math.

Source

vector.lisp.

Function: yaw-by (vector angle)

Returns the given vector after it has undergone a yaw by the given angle, specified in radians. This is a left-handed rotation.

Package

l-math.

Source

rotations.lisp.

Function: yaw-matrix (size angle)

A synonym for ROTATION-Y, although this can be changed using lm:SET-ROTATION-NAMING-CONVENTION.

Package

l-math.

Source

rotations.lisp.


5.1.5 Generic functions

Generic Function: all-knots (knots)

Given a knots data structure, this will return a list of all knots, including multiplicities.

Package

l-math.

Source

basis.lisp.

Methods
Method: all-knots ((spline b-spline))

Returns a list of all the knots (repeated if necessary for multiplicity) of the b-spline

Source

spline.lisp.

Method: all-knots ((knots-data b-spline-knots))
Generic Function: angle-between (from to)

Returns the angle between two vectors. The angle is
in radians, and is signed. The angle represents the the angle needed to transform the FROM vector to the TO vector.

Package

l-math.

Source

vector-operations.lisp.

Methods
Method: angle-between ((from vector) (to vector))
Generic Reader: b-spline-degree (object)
Generic Writer: (setf b-spline-degree) (object)
Package

l-math.

Methods
Reader Method: b-spline-degree ((b-spline b-spline))
Writer Method: (setf b-spline-degree) ((b-spline b-spline))

The degree of the b-spline. This defaults to cubic.

Source

spline.lisp.

Target Slot

degree.

Generic Reader: b-spline-knots (object)
Generic Writer: (setf b-spline-knots) (object)
Package

l-math.

Methods
Reader Method: b-spline-knots ((b-spline b-spline))
Writer Method: (setf b-spline-knots) ((b-spline b-spline))

A structure detailing the spline’s knots.

Source

spline.lisp.

Target Slot

knots.

Generic Reader: b-spline-points (object)
Generic Writer: (setf b-spline-points) (object)
Package

l-math.

Methods
Reader Method: b-spline-points ((b-spline b-spline))
Writer Method: (setf b-spline-points) ((b-spline b-spline))

A list of points used defining the b-spline polygon.

Source

spline.lisp.

Target Slot

points.

Generic Reader: basis-matrix (object)
Generic Writer: (setf basis-matrix) (object)
Package

l-math.

Methods
Reader Method: basis-matrix ((matrix-spline matrix-spline))
Writer Method: (setf basis-matrix) ((matrix-spline matrix-spline))

Defines the behaviour of the
spline. For possible bases to use, see MAKE-HERMITE-BASIS-MATRIX, MAKE-BEZIER-BASIS-MATRIX, and MAKE-UNIFORM-NONRATIONAL-BSPLINE-BASIS-MATRIX

Source

spline.lisp.

Target Slot

basis-matrix.

Generic Function: between (start end)

Calculates the vector half way between two other
vectors. This is equivalent to (LINEAR-INTERPOLATION START END 0.5).

Package

l-math.

Source

interpolate.lisp.

Methods
Method: between (start end)
Generic Function: bilinear-interpolation (top-left bottom-left top-right bottom-right parameter)

Performs bilinear interpolation: first this
performs linear interpolation between the TOP-LEFT and BOTTOM-LEFT, as well as TOP-RIGHT and BOTTOM-RIGHT, using the y coordinate of the parameter. It then performs linear interpolation between these obtained values using the parameter’s x coordinate. The four position vectors can be of any dimension, but must all be of the same dimension. The paramater must be a 2-vector. Parameter
(0, 0) maps to the upper left corner, and (1, 1) maps to the lower right corner.

Package

l-math.

Source

interpolate.lisp.

Methods
Method: bilinear-interpolation ((top-left vector) (bottom-left vector) (top-right vector) (bottom-right vector) parameter)
Method: bilinear-interpolation ((top-left number) (bottom-left number) (top-right number) (bottom-right number) parameter)
Generic Function: c* (lhs rhs)

multiplies two objects together.

Package

l-math.

Source

operations.lisp.

Methods
Method: c* ((lhs matrix) (rhs matrix))
Method: c* ((lhs vector) (rhs matrix))
Method: c* ((lhs matrix) (rhs vector))
Method: c* ((lhs list) rhs)

Converts lists to vectors when performing mixed type operations.

Method: c* (lhs (rhs list))

Converts lists to vectors when performing mixed type operations.

Method: c* ((lhs list) (rhs list))
Method: c* ((lhs vector) (rhs vector))
Method: c* (lhs rhs)
Method: c* ((lhs number) (rhs number))
Method: c* ((lhs number) (rhs vector))
Method: c* ((lhs number) (rhs list))
Method: c* ((lhs vector) (rhs number))
Method: c* ((lhs list) (rhs number))
Method: c* ((lhs number) (rhs matrix))
Method: c* ((lhs matrix) (rhs number))
Generic Function: c+ (lhs rhs)

Adds two objects together.

Package

l-math.

Source

operations.lisp.

Methods
Method: c+ ((lhs list) rhs)

Converts lists to vectors when performing mixed type operations.

Method: c+ (lhs (rhs list))

Converts lists to vectors when performing mixed type operations.

Method: c+ ((lhs list) (rhs list))
Method: c+ ((lhs vector) (rhs vector))
Method: c+ (lhs rhs)
Method: c+ ((lhs number) (rhs number))
Method: c+ ((lhs number) (rhs vector))
Method: c+ ((lhs vector) (rhs number))
Method: c+ ((lhs number) (rhs list))
Method: c+ ((lhs list) (rhs number))
Method: c+ ((lhs number) (rhs matrix))
Method: c+ ((lhs matrix) (rhs number))
Generic Function: c- (lhs rhs)

Subtracts objects.

Package

l-math.

Source

operations.lisp.

Methods
Method: c- ((lhs list) rhs)

Converts lists to vectors when performing mixed type operations.

Method: c- (lhs (rhs list))

Converts lists to vectors when performing mixed type operations.

Method: c- ((lhs list) (rhs list))
Method: c- ((lhs vector) (rhs vector))
Method: c- (lhs rhs)
Method: c- ((lhs number) (rhs number))
Method: c- ((lhs number) (rhs vector))
Method: c- ((lhs vector) (rhs number))
Method: c- ((lhs number) (rhs list))
Method: c- ((lhs list) (rhs number))
Method: c- ((lhs number) (rhs matrix))
Method: c- ((lhs matrix) (rhs number))
Generic Function: c/ (lhs rhs)

Divides two objects.

Package

l-math.

Source

operations.lisp.

Methods
Method: c/ ((lhs list) rhs)

Converts lists to vectors when performing mixed type operations.

Method: c/ (lhs (rhs list))

Converts lists to vectors when performing mixed type operations.

Method: c/ ((lhs list) (rhs list))
Method: c/ ((lhs vector) (rhs vector))
Method: c/ (lhs rhs)
Method: c/ ((lhs number) (rhs number))
Method: c/ ((lhs number) (rhs vector))
Method: c/ ((lhs number) (rhs list))
Method: c/ ((lhs vector) (rhs number))
Method: c/ ((lhs list) (rhs number))
Method: c/ ((lhs number) (rhs matrix))
Method: c/ ((lhs matrix) (rhs number))
Generic Function: centre-of-mass (vector &rest vectors)

Calculates the centre point of a series of objects.

Package

l-math.

Source

vector-operations.lisp.

Methods
Method: centre-of-mass ((vector vector) &rest vectors)
Method: centre-of-mass ((number number) &rest numbers)

Calculates the average of a list of numbers.

Generic Function: coefficient-matrix (curve)

Returns a list of coefficient matrices for the
polynomials that control the curve along each segment. The first column of each matrix contains the coefficients for the polynomial calculating the x coefficients (row 1 is the cubic coefficient, row 2 the quadratic coefficient, row 3 the linear coefficient, and row 4 the constant). Column 2 does the same for the y polynomial coefficients, and column 3 for the z coefficients.

Package

l-math.

Source

spline.lisp.

Methods
Method: coefficient-matrix ((spline matrix-spline))
Generic Function: copy (item)

Returns a copy of the given item.

Package

l-math.

Source

generics.lisp.

Methods
Method: copy ((matrix matrix))
Source

matrix.lisp.

Method: copy ((vector vector))

Returns a copy of a VECTOR, just as COPY-VECTOR does.

Source

vector.lisp.

Method: copy ((item list))

Returns a copy of a list.

Generic Function: copy-vector (vector)

Returns a copy of the original vector

Package

l-math.

Source

vector.lisp.

Methods
Method: copy-vector ((vector vector))
Generic Function: cross-product (lhs rhs)

Calculates the cross product between 3-vectors

Package

l-math.

Source

vector-operations.lisp.

Methods
Method: cross-product ((lhs vector) (rhs vector))
Generic Function: dimension (object)

Returns the dimensions of a given object.

Package

l-math.

Source

generics.lisp.

Methods
Method: dimension ((matrix matrix))

Returns a list giving the number of rows and columns in the matrix.

Source

matrix.lisp.

Method: dimension ((vector list))

Returns the dimension of a vector represented as a list.

Source

vector.lisp.

Method: dimension ((vector vector))

Returns the dimension of a vector.

Source

vector.lisp.

Generic Function: domain-knots (spline)

Returns a list of the domain knots of the
spline (the knots over which the spline is defined). These are repeated for multiplicities.

Package

l-math.

Source

spline.lisp.

Methods
Method: domain-knots ((spline b-spline))
Generic Function: dot-product (lhs rhs)

Calculates the dot product between two vectors.

Package

l-math.

Source

vector-operations.lisp.

Methods
Method: dot-product ((lhs vector) (rhs vector))
Method: dot-product ((lhs list) (rhs vector))
Method: dot-product ((lhs vector) (rhs list))
Method: dot-product ((lhs list) (rhs list))
Generic Function: elt (vector index)

Returns the element of a VECTOR at the given index.

Package

l-math.

Source

vector.lisp.

Setf expander for this generic function

(setf elt).

Methods
Method: elt ((vector vector) (index integer))
Method: elt ((vector list) (index integer))
Generic Function: equivalent (lhs rhs)

Returns t iff the two objects are numerically the same. Real valued objects are always compared using *equivalence-tolerance*.

Package

l-math.

Source

generics.lisp.

Methods
Method: equivalent ((lhs matrix) (rhs matrix))

Synonym for MATRIX=

Source

matrix.lisp.

Method: equivalent ((lhs vector) (rhs list))
Source

vector.lisp.

Method: equivalent ((lhs list) (rhs vector))

Compares a list and a vector for equivalence.

Source

vector.lisp.

Method: equivalent ((lhs list) (rhs list))

Returns t iff the two lists are of the same length with equivalent elements.

Source

vector.lisp.

Method: equivalent ((lhs vector) (rhs vector))

Synonym for VECTOR=.

Source

vector.lisp.

Method: equivalent (lhs rhs)

A default implementation that ensures that unrelated objects are not considered equivalent.

Method: equivalent ((lhs number) (rhs number))

Returns t iff two numbers are equivalent (using =).

Method: equivalent ((lhs real) (rhs real))

Two real values are compared for equivalence to a pre-defined tolerance.

Generic Function: euclidean-distance (lhs rhs)

Calculates the Euclidean distance between two objects.

Package

l-math.

Source

vector-operations.lisp.

Methods
Method: euclidean-distance ((lhs number) (rhs number))

Calculates the Euclidean distance between two numbers.

Method: euclidean-distance ((lhs list) (rhs list))

Calculates the Euclidean distance between two vectors, represented as lists.

Method: euclidean-distance ((lhs vector) (rhs vector))

Calculates the Euclidean distance between two vectors.

Generic Function: evaluate (spline parameter)

Evaluate the given spline at the given parameter value. Returns a point on that spline.

Package

l-math.

Source

spline.lisp.

Methods
Method: evaluate ((spline b-spline) (parameter number))
Method: evaluate ((spline bezier-curve) (t-val real))

Evaluates the given bezier curve at the given parameter value.

Method: evaluate ((spline matrix-spline) (parameter real))

Evaluates the given spline at the parameter.

Generic Reader: knots (object)
Package

l-math.

Methods
Reader Method: knots ((b-spline-knots b-spline-knots))

An ascending collection of knots, stored with repetition.

Source

basis.lisp.

Target Slot

knots.

Generic Function: (setf knots) (object)
Package

l-math.

Methods
Writer Method: (setf knots) :after ((knot-data b-spline-knots))
Source

basis.lisp.

Target Slot

knots.

Method: (setf knots) ((b-spline-knots b-spline-knots))

An ascending collection of knots, stored with repetition.

Source

basis.lisp.

Generic Function: length (vector)

An alias for DIMENSION

Package

l-math.

Source

vector.lisp.

Methods
Method: length ((array simple-array))
Method: length (vector)
Generic Function: linear-interpolation (start end t-val)

Interpolates between two points, using the
parametric line equation. START and END are the two endpoints of a line. While T-VAL takes values between 0 and 1, inclusive, the returned points will lie between these two points. No matter the value of T-VAL, the returned point will always be on the line, but will be outside of the [start, end] line segment if T-VAL is not on the domain [0, 1]

Package

l-math.

Source

interpolate.lisp.

Methods
Method: linear-interpolation (start end (t-val real))
Method: linear-interpolation ((start number) (end number) (t-val real))
Generic Function: matrix-cols (matrix)

Returns the number of columns in a matrix.

Package

l-math.

Source

matrix.lisp.

Methods
Method: matrix-cols ((matrix matrix))
Generic Function: matrix-elt (matrix row col)

Return the matrix componenent at the given row and column

Package

l-math.

Source

matrix.lisp.

Setf expander for this generic function

(setf matrix-elt).

Methods
Method: matrix-elt ((matrix matrix) (row integer) (col integer))
Generic Function: matrix-rows (matrix)

Return the number of rows in a matrix.

Package

l-math.

Source

matrix.lisp.

Methods
Method: matrix-rows ((matrix matrix))
Generic Function: matrix= (lhs rhs)

Returns t iff the two matrices are equal. Effected by *equivalence-tolerance*.

Package

l-math.

Source

matrix.lisp.

Methods
Method: matrix= ((lhs matrix) (rhs matrix))
Generic Function: maximum-parameter (spline)

Returns the maximum value that the spline parameter may take.

Package

l-math.

Source

spline.lisp.

Methods
Method: maximum-parameter ((spline b-spline))
Method: maximum-parameter ((spline bezier-curve))
Method: maximum-parameter ((spline matrix-spline))
Generic Function: minimum-parameter (spline)

Returns the minimum value that the spline parameter may take.

Package

l-math.

Source

spline.lisp.

Methods
Method: minimum-parameter ((spline b-spline))
Method: minimum-parameter ((spline bezier-curve))
Method: minimum-parameter ((spline matrix-spline))
Generic Reader: multiplicity (object)
Package

l-math.

Methods
Reader Method: multiplicity ((b-spline-knots b-spline-knots))

The multiplicity of the above knots.

Source

basis.lisp.

Target Slot

multiplicity.

Generic Function: (setf multiplicity) (object)
Package

l-math.

Methods
Writer Method: (setf multiplicity) :after ((knot-data b-spline-knots))
Source

basis.lisp.

Target Slot

multiplicity.

Method: (setf multiplicity) ((b-spline-knots b-spline-knots))

The multiplicity of the above knots.

Source

basis.lisp.

Generic Function: negate (item)

Returns an item with all of its elements negated. This is non-destructive.

Package

l-math.

Source

generics.lisp.

Methods
Method: negate ((matrix matrix))

Returns the additive inverse of a matrix.

Source

matrix.lisp.

Method: negate ((vector list))

Non-destructively returns the additive inverse of the list, as if it were a vector.

Source

vector.lisp.

Method: negate ((vector vector))

Non-destructively returns the additive inverse of a vector.

Source

vector.lisp.

Method: negate ((item number))

Returns the additive inverse of all basic Common Lisp numbers. This is just a shortcut for using the cl:- function.

Generic Function: negate! (item)

Returns the additive inverse of an item, much like NEGATE, only this version is destructive.

Package

l-math.

Source

generics.lisp.

Methods
Method: negate! ((matrix matrix))

Sets the matrix to its additive inverse and returns it.

Source

matrix.lisp.

Method: negate! ((vector list))

Destructively returns the additive inverse of the given list.

Source

vector.lisp.

Method: negate! ((vector vector))

Destructively returns the additive inverse of a vector.

Source

vector.lisp.

Generic Function: norm (vector)

The distance of the vector from zero.

Package

l-math.

Source

vector.lisp.

Methods
Method: norm ((vector vector))
Method: norm ((vector list))
Generic Function: normalise (vector)

Returns a normalised version of the vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: normalise ((vector vector))
Method: normalise ((vector list))

Returns the normalised version of a vector represented as a list.

Generic Function: normalise! (vector)

Destructively normalises the vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: normalise! ((vector vector))
Method: normalise! ((vector list))

Destructively updates the vector, represented as a list, into its normalised version.

Generic Function: set-spline-geometry (spline geometry)

Set the control geometry (end points, tangents, etc.) of the given spline.

Package

l-math.

Source

spline.lisp.

Setf expanders to this generic function

(setf spline-geometry).

Methods
Method: set-spline-geometry ((spline b-spline) (geometry list))

A list of points defining the spline’s b-spline polygon.

Method: set-spline-geometry ((spline bezier-curve) (geometry list))

A list of points defining the bézier curve’s geometry. For a curve of degree n, there should be n+1 points.

Method: set-spline-geometry ((spline three-shared-spline) (list list))

A list of points making up the spline geometry, in order of occurance.

Method: set-spline-geometry ((spline last-shared-spline) (list list))

Sets the control geometry of the hermite curve and bézier
curves.

For hermite curves, this list should contain at least 4
elements, and should be laid out in the following manner, where Pn represents the nth point, and a(Pn) represents the tangent leading away from that point, and b(Pn) represents the tangent leading towards that point.

P1 a(P1) b(P2) P2 a(P2) b(P3) P3 a(P3) ... b(Pn-1) Pn-1 a(Pn-1) b(Pn) Pn

For bézier curves, this should be a sequence of control points:

P1 P2 P3 P4 P5 ... Pn

Both the points and the tangents should be 3-vectors.

Generic Function: spline-geometry (spline)

Returns the geometry of the associated
spline. These are the end points, tangents, and so on, of the various splines.

Package

l-math.

Source

spline.lisp.

Setf expander for this generic function

(setf spline-geometry).

Methods
Method: spline-geometry ((spline b-spline))
Method: spline-geometry ((spline bezier-curve))
Method: spline-geometry ((spline three-shared-spline))

Returns the list of geometry making up the spline.

Method: spline-geometry ((spline last-shared-spline))

Returns a list of the geometry that made up the spline.

Generic Function: spline-interpolation (points &key degree parametrisation close)

Returns a b-spline that interpolates the given
points. This is based on the discussion in sections 9.1 and 7.8 of Farin’s Curves and Surfaces for Computer Aided Geometric Design. PARAMETRISATION should be one of :uniform, :centripetal, or :chord-length. If CLOSE is true, then this will produce a closed b-spline.

Package

l-math.

Source

spline-interpolation.lisp.

Methods
Method: spline-interpolation ((points list) &key degree parametrisation close)
Generic Function: test-dimensions (lhs rhs &key transpose-rhs both &allow-other-keys)

Throws an error if the two objects do not agree in
dimensions. If the second object is a matrix, it is possible to transpose the dimensions that are tested using the :transpose-rhs argument.

Package

l-math.

Source

tests.lisp.

Methods
Method: test-dimensions ((lhs matrix) (rhs matrix) &key transpose-rhs both)
Method: test-dimensions ((lhs list) (rhs matrix) &key)
Method: test-dimensions ((lhs matrix) (rhs list) &key)
Method: test-dimensions ((lhs vector) (rhs matrix) &key)
Method: test-dimensions ((lhs matrix) (rhs vector) &key)
Method: test-dimensions ((vector list) (dimension number) &key)

Ensure that the given vector has the specified dimension.

Method: test-dimensions ((lhs list) (rhs list) &key)
Method: test-dimensions ((vector vector) (dimension number) &key)

Ensure that the given vector has the specified dimension.

Method: test-dimensions ((lhs vector) (rhs vector) &key)
Generic Function: to-homogenous (item)

Takes an item and lifts it into homogenous space by adding one dimension on to it.

Package

l-math.

Source

generics.lisp.

Methods
Method: to-homogenous ((item vector))

Adds the element 1 to the end of the list.

Source

vector.lisp.

Method: to-homogenous ((item list))

Adds the element 1 to the end of the list.

Source

vector.lisp.

Generic Function: to-list (item)

Returns a representation of the given object as a list.

Package

l-math.

Source

generics.lisp.

Methods
Method: to-list ((vector vector))

Transforms a vector object into a list.

Source

vector.lisp.

Method: to-list ((item list))

The list representation of a list is just the list itself.

Generic Function: to-vector (item &key dimension)

Returns a new vector object based created from the
function’s arguments. If dimension is supplied, it should be a positive integer defining the dimension of the returned vector. If the specified dimension is shorter than the given item, extra elements are truncated. If it is longer, the new vector will be padded with zero elements.

Package

l-math.

Source

vector.lisp.

Methods
Method: to-vector ((item list) &key dimension)

Converts a list to a vector.

Method: to-vector ((item vector) &key dimension)

Returns a copy of the given vector.

Generic Function: transform (transformer object)

Applies the transformer to the object, and returns the appropriate result of the transformation.

Package

l-math.

Source

transform.lisp.

Methods
Method: transform (transformer (spline b-spline))

Transforms a spline. The TRANSFORMER should accept a point, and will be called once for each control point of the spline. The new spline will share the B-SPLINE-KNOTS of the old spline object.

Method: transform ((function function) (vector vector))

Applies a function to a vector and returns the result.

Method: transform (transformer (list list))

Applies the transformer to all objects in a list, returning the list of results, much like MAPCAR.

Generic Function: transpose (matrix)

Returns the non-destructive transpose of a matrix

Package

l-math.

Source

matrix.lisp.

Methods
Method: transpose ((matrix matrix))
Generic Function: vector= (lhs rhs)

Returns t iff the two vectors are equal. Effected by *equivalence-tolerance*.

Package

l-math.

Source

vector.lisp.

Methods
Method: vector= ((lhs list) (rhs list))
Method: vector= ((lhs vector) (rhs vector))
Generic Function: w (vector)

Returns the w component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: w ((vector vector))
Generic Function: (setf w) (vector)

Sets the w component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: (setf w) ((vector vector))
Generic Function: x (vector)

Returns the x component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: x ((vector vector))
Method: x ((vector list))

Allows a list to be treated accessed in a limited way as a vector.

Generic Function: (setf x) (vector)

Sets the x component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: (setf x) ((vector vector))
Method: (setf x) ((vector list))
Generic Function: y (vector)

Returns the y component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: y ((vector vector))
Method: y ((vector list))

Allows a list to be accessed, in a limited way, as a vector.

Generic Function: (setf y) (vector)

Sets the y component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: (setf y) ((vector vector))
Method: (setf y) ((vector list))
Generic Function: z (vector)

Returns the z component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: z ((vector vector))
Method: z ((vector list))

Allows a list to be accessed, in a limited way, as a vector.

Generic Function: (setf z) (vector)

Sets the z component from an appropriately sized vector.

Package

l-math.

Source

vector.lisp.

Methods
Method: (setf z) ((vector vector))
Method: (setf z) ((vector list))
Generic Function: zerop (item)

Returns T iff the given item is zero, to the tolerance used by EQUIVALENT

Package

l-math.

Source

generics.lisp.

Methods
Method: zerop ((matrix matrix))

Returns T iff all components in the matrix is EQUIVALENT to zero.

Source

matrix.lisp.

Method: zerop ((vector list))

Returns T if all components of the vector are zero.

Source

vector.lisp.

Method: zerop ((vector vector))

Returns T if all components of the vector are zero.

Source

vector.lisp.

Method: zerop ((number number))

5.1.6 Standalone methods

Method: initialize-instance :after ((spline bezier-curve) &key degree)
Source

spline.lisp.

Method: initialize-instance :after ((vector vector) &key size)
Source

vector.lisp.

Method: initialize-instance :after ((spline b-spline) &key uniform chord-length centripetal)

UNIFORM: if true, will automatically create a set of uniform knots, based on the b-spline’s degree and number of points in the b-spline polygon.

Source

spline.lisp.

Method: initialize-instance :after ((knot-data b-spline-knots) &key)
Source

basis.lisp.

Method: initialize-instance :after ((matrix matrix) &key size)
Source

matrix.lisp.

Method: make-load-form ((vector vector) &optional environment)
Source

vector.lisp.

Method: make-load-form ((matrix matrix) &optional environment)
Source

matrix.lisp.

Method: print-object ((vector vector) stream)
Source

vector.lisp.

Method: print-object ((spline b-spline) stream)
Source

spline.lisp.

Method: print-object ((knots b-spline-knots) stream)
Source

basis.lisp.

Method: print-object ((matrix matrix) stream)
Source

matrix.lisp.


5.1.7 Conditions

Condition: dimension-error
Package

l-math.

Source

conditions.lisp.

Direct superclasses

l-math-error.

Direct subclasses

required-dimension-error.

Direct methods
Direct slots
Slot: dim1
Initform

(quote nil)

Initargs

:dim1

Readers

dimension-error-dim1.

Writers

This slot is read-only.

Slot: dim2
Initform

(quote nil)

Initargs

:dim2

Readers

dimension-error-dim2.

Writers

This slot is read-only.

Condition: l-math-error
Package

l-math.

Source

conditions.lisp.

Direct superclasses

error.

Direct subclasses
Direct methods
Direct slots
Slot: format-control
Initform

(quote "a general mathematical error has occured.")

Initargs

:format-control

Readers

l-math-error-format-control.

Writers

This slot is read-only.

Slot: format-arguments
Initform

(quote nil)

Initargs

:format-arguments

Readers

l-math-error-format-arguments.

Writers

This slot is read-only.


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

5.1.8 Classes

Class: b-spline

A non-uniform b-spline implementation. It has much
code to speed up the uniform quadratic and cubic cases, however. But
it supports arbitrary degree non-uniform b-splines in an arbtirary n-dimensional space.

There are a number of options when constructing a b-spline. The
simplest is when constructing a uniform b-spline, like so:

(make-instance ’lm:b-spline :degree 3 :points *list-of-points* :uniform t)

A non-uniform parameterisation that attempts to equalise the
distance travelled over parameter sections is chord length parameterisation: (make-instance ’lm:b-spline :degree 3 :points *list-of-points* :chord-length t)

Another non-uniform parameterisation (the prefered parametrisation)
is centripetal parametrisation, which preserves ratios of square
roots of distances between points of the control geometry:
(make-instance ’lm:b-spline :degree 3 :points *list-of-points* :centripetal t)

Knots may be specified with the :knots argument, and should be
constructed using lm:MAKE-KNOTS.

Package

l-math.

Source

spline.lisp.

Direct superclasses

spline.

Direct methods
Direct slots
Slot: points

A list of points used defining the b-spline polygon.

Type

list

Initargs

:points

Readers

b-spline-points.

Writers

(setf b-spline-points).

Slot: knots

A structure detailing the spline’s knots.

Type

(or null l-math:b-spline-knots)

Initargs

:knots

Readers

b-spline-knots.

Writers

(setf b-spline-knots).

Slot: degree

The degree of the b-spline. This defaults to cubic.

Type

integer

Initform

3

Initargs

:degree

Readers

b-spline-degree.

Writers

(setf b-spline-degree).

Class: b-spline-knots

Some docs. You will likely find it more convenient
to construct instance of this class using MAKE-KNOTS. Notice that B-SPLINE-BASIS requires a phantom knot on either end of the knot sequence. MAKE-KNOTS will automatically add those knots for you.

Package

l-math.

Source

basis.lisp.

Direct methods
Direct slots
Slot: knots

An ascending collection of knots, stored with repetition.

Type

(or null (simple-array double-float))

Initargs

:knots

Readers

knots.

Writers

(setf knots).

Slot: multiplicity

The multiplicity of the above knots.

Type

(or null (simple-array fixnum))

Initargs

:multiplicity

Readers

multiplicity.

Writers

(setf multiplicity).

Slot: knot-count

The number of knots, taking in to account multiplicity.

Type

fixnum

Initform

0

Readers

knot-count.

Writers

This slot is read-only.

Slot: no-multiplicity

Indicates whether there is a multiplicity or not in the knots.

Readers

no-multiplicity-p.

Writers

This slot is read-only.

Slot: uniform

A boolean indicating whether this is a uniform sequence of knots or not.

Readers

uniform-p.

Writers

This slot is read-only.

Class: bezier-curve

A general bezier curve class, which can be of any
degree (unlike CUBIC-BEZIER-CURVE, which is always cubic). Note that this is a single curve, and not a piecewise spline. If you want a piecewise generalisation of this, use the B-SPLINE class.

Package

l-math.

Source

spline.lisp.

Direct superclasses

spline.

Direct methods
Direct slots
Slot: degree

The degree of the curve. The default is to be cubic.

Type

integer

Readers

bezier-curve-degree.

Writers

(setf bezier-curve-degree).

Slot: bernstein-polynomials

A cached list of berstein-polynomials, used in the calculation of the curve.

Type

list

Readers

bernstein-polynomials.

Writers

This slot is read-only.

Slot: spline-geometry

A list of points defining the
curve. For a cubic curve, that is 4 points. For a curve of degree n, there will be n+1 points.

Initargs

:spline-geometry

Class: catmull-rom-spline

The interpolating catmull-rom spline in 3-space. This spline passes through all of its control points. It is also called the Overhauser spine.

Package

l-math.

Source

spline.lisp.

Direct superclasses

three-shared-spline.

Direct Default Initargs
InitargValue
:basis-matrix(make-catmull-rom-basis-matrix)
Class: cubic-bezier-curve

Represents a cubic bézier curve in 3-space.

Package

l-math.

Source

spline.lisp.

Direct superclasses

last-shared-spline.

Direct Default Initargs
InitargValue
:basis-matrix(make-bezier-basis-matrix)
Class: hermite-curve

Represents a hermite curve in 3-space.

Package

l-math.

Source

spline.lisp.

Direct superclasses

last-shared-spline.

Direct Default Initargs
InitargValue
:basis-matrix(make-hermite-basis-matrix)
Class: matrix

A mathematical matrix class.

Package

l-math.

Source

matrix.lisp.

Direct methods
Direct slots
Slot: data

A 2D array holding the matrix data.

Type

(array double-float)

Initargs

:data

Class: spline

A base class for all spline and parametric curve implementations.

Package

l-math.

Source

spline.lisp.

Direct subclasses
Class: unrbs-spline

A uniform, non-rational b-spline in 3-space.

Package

l-math.

Source

spline.lisp.

Direct superclasses

three-shared-spline.

Direct Default Initargs
InitargValue
:basis-matrix(make-uniform-nonrational-bspline-basis-matrix)
Class: vector

A mathematical vector class.

Package

l-math.

Source

vector.lisp.

Direct methods
Direct slots
Slot: data

An array holding the vector’s data

Type

(array double-float)

Initargs

:data


5.2 Internals


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

5.2.1 Special variables

Special Variable: *perlin-gradients*

Stores the wavelet coefficients / gradients.

Package

l-math.

Source

random.lisp.

Special Variable: *perlin-permutations*

A list of random permutations.

Package

l-math.

Source

random.lisp.


5.2.2 Macros

Macro: create-list-operation-method (name function)

Generates a method, such as c+, which operates on common lisp lists, treating them as if they were vectors.

Package

l-math.

Source

operations.lisp.

Macro: create-vector-operation-method (name function)

Expands into code that can be used to fill out one a method for one of the generic methods defined below, such as c+

Package

l-math.

Source

operations.lisp.

Macro: etest-dimensions (lhs rhs)
Package

l-math.

Source

tests.lisp.

Macro: etest-needed-vector-dimension (vector dimension)
Package

l-math.

Source

tests.lisp.

Macro: fill-row (matrix item-name row-num)

A macro useful for filling matrices in functions such as CREATE-ROTATION-MATRIX.

Package

l-math.

Source

rotations.lisp.


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

5.2.3 Ordinary functions

Function: centripetal-parameterisation (all-points degree)

Produces a non-parameteric parameterisation for b-splines, where the ratio of parameters is equivalent to the square root of the ratio of the distances between the corresponding control points.

Package

l-math.

Source

basis.lisp.

Function: chord-length-parameterisation (all-points degree)

Produces a non-parameteric parameterisation for b-splines, where the ratio of parameters is equivalent to the ratio of the distances between the corresponding control points.

Package

l-math.

Source

basis.lisp.

Function: find-starting-knot-index (knot-data degree parameter)

Given knot data, the degree of a spline, and a parameter, this locates the first index of the knots which will be used to define the point on the given spline. Returns first the b-spline-basis family to be used, and then the offset index of the knot.

Package

l-math.

Source

basis.lisp.

Function: make-bezier-basis-matrix ()

Returns the 4×4 Bézier basis matrix.

Package

l-math.

Source

basis.lisp.

Function: make-catmull-rom-basis-matrix ()

Returns the 4×4 matrix for catmull-rom interpolating splines.

Package

l-math.

Source

basis.lisp.

Function: make-hermite-basis-matrix ()

Returns the 4×4 hermite basis matrix.

Package

l-math.

Source

basis.lisp.

Function: make-random-matrix (rows cols &key noise)

Creates a MATRIX of the ROWS × COLS dimension filled with random values obtained by calling NOISE once for each element in the MATRIX. By default, this uses normally distributed random numbers with a mean of 0 and standard deviation of 1.

Package

l-math.

Source

random.lisp.

Function: make-uniform-nonrational-bspline-basis-matrix ()

Returns a 4×4 matrix for the uniform, nonrational b-splines.

Package

l-math.

Source

basis.lisp.

Function: number-needed-knots (num-points degree)

Given the number of points making up a spline, and the degree of the spline, this will tell us the number of required knots.

Package

l-math.

Source

basis.lisp.

Function: private-bilinear-interpolation (top-left bottom-left top-right bottom-right parameter)
Package

l-math.

Source

interpolate.lisp.

Function: ratio-parameterisation (all-points degree function)

This can be used to determine a knot sequence based on some ’distance’ between the given points. The distance is measured using FUNCTION, which should be a binary function returning a real. If this function is the euclidean distance metric, then this will produce chord-length parametrisation.

Package

l-math.

Source

basis.lisp.


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

5.2.4 Generic functions

Generic Reader: bernstein-polynomials (object)
Package

l-math.

Methods
Reader Method: bernstein-polynomials ((bezier-curve bezier-curve))

A cached list of berstein-polynomials, used in the calculation of the curve.

Source

spline.lisp.

Target Slot

bernstein-polynomials.

Generic Reader: bezier-curve-degree (object)
Package

l-math.

Methods
Reader Method: bezier-curve-degree ((bezier-curve bezier-curve))

The degree of the curve. The default is to be cubic.

Source

spline.lisp.

Target Slot

degree.

Generic Function: (setf bezier-curve-degree) (object)
Package

l-math.

Methods
Writer Method: (setf bezier-curve-degree) :after ((spline bezier-curve))
Source

spline.lisp.

Target Slot

degree.

Method: (setf bezier-curve-degree) ((bezier-curve bezier-curve))

The degree of the curve. The default is to be cubic.

Source

spline.lisp.

Generic Function: calculate-knot-count (knot-data)

Returns the number of knots in the data, taking in to account multiplicity. Sets KNOT-COUNT accordingly.

Package

l-math.

Source

basis.lisp.

Methods
Method: calculate-knot-count ((knot-data b-spline-knots))
Generic Function: calculate-uniformity (knot-data)

Calculates whether the knot-data is uniform or not. Sets UNIFORM-P accordingly.

Package

l-math.

Source

basis.lisp.

Methods
Method: calculate-uniformity ((knot-data b-spline-knots))
Generic Reader: dimension-error-dim1 (condition)
Package

l-math.

Methods
Reader Method: dimension-error-dim1 ((condition required-dimension-error))
Source

conditions.lisp.

Target Slot

dim1.

Reader Method: dimension-error-dim1 ((condition dimension-error))
Source

conditions.lisp.

Target Slot

dim1.

Generic Reader: dimension-error-dim2 (condition)
Package

l-math.

Methods
Reader Method: dimension-error-dim2 ((condition required-dimension-error))
Source

conditions.lisp.

Target Slot

dim2.

Reader Method: dimension-error-dim2 ((condition dimension-error))
Source

conditions.lisp.

Target Slot

dim2.

Generic Function: get-ith-knot (knot-data i &optional offset)

Returns the ith knot, taking in to account
multiplicity. OFFSET should be positive number that array indices are offset by.

Package

l-math.

Source

basis.lisp.

Methods
Method: get-ith-knot ((spline b-spline) (i integer) &optional offset)
Source

spline.lisp.

Method: get-ith-knot ((knot-data b-spline-knots) (i integer) &optional offset)
Generic Function: high-parameter (knot-data degree)

Given a knot sequence and the degree of the spline,
this returns the highest possible parameter value the spline will aceept.

Package

l-math.

Source

basis.lisp.

Methods
Method: high-parameter ((knots b-spline-knots) (degree integer))
Generic Function: initialise-data (item size)

Initialises the DATA slot to the given size. Returns the vector object.

Package

l-math.

Source

generics.lisp.

Methods
Method: initialise-data ((matrix matrix) (size-list list))
Source

matrix.lisp.

Method: initialise-data ((vector vector) (size integer))
Source

vector.lisp.

Generic Reader: knot-count (object)
Package

l-math.

Methods
Reader Method: knot-count ((b-spline-knots b-spline-knots))

The number of knots, taking in to account multiplicity.

Source

basis.lisp.

Target Slot

knot-count.

Generic Reader: l-math-error-format-arguments (condition)
Package

l-math.

Methods
Reader Method: l-math-error-format-arguments ((condition l-math-error))
Source

conditions.lisp.

Target Slot

format-arguments.

Generic Reader: l-math-error-format-control (condition)
Package

l-math.

Methods
Reader Method: l-math-error-format-control ((condition l-math-error))
Source

conditions.lisp.

Target Slot

format-control.

Generic Function: low-parameter (knot-data degree)

Given a knot sequence and the degree of the spline,
this returns the lowest possible parameter value the spline will accept.

Package

l-math.

Source

basis.lisp.

Methods
Method: low-parameter ((knots b-spline-knots) (degree integer))
Generic Reader: no-multiplicity-p (object)
Package

l-math.

Methods
Reader Method: no-multiplicity-p ((b-spline-knots b-spline-knots))

Indicates whether there is a multiplicity or not in the knots.

Source

basis.lisp.

Target Slot

no-multiplicity.

Generic Reader: operation-not-suported-operation-name (condition)
Package

l-math.

Methods
Reader Method: operation-not-suported-operation-name ((condition operation-not-supported))
Source

conditions.lisp.

Target Slot

operation-name.

Generic Reader: operation-not-supported-extra-information (condition)
Package

l-math.

Methods
Reader Method: operation-not-supported-extra-information ((condition operation-not-supported))
Source

conditions.lisp.

Target Slot

extra-information.

Generic Function: test-nonzero (vector &optional threshold)

Throws a ZERO-LENGTH-ERROR if the given vector has a length close to zero.

Package

l-math.

Source

tests.lisp.

Methods
Method: test-nonzero (vector &optional threshold)
Generic Reader: uniform-p (object)
Package

l-math.

Methods
Reader Method: uniform-p ((b-spline-knots b-spline-knots))

A boolean indicating whether this is a uniform sequence of knots or not.

Source

basis.lisp.

Target Slot

uniform.


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

5.2.5 Conditions

Condition: operation-not-supported
Package

l-math.

Source

conditions.lisp.

Direct superclasses

l-math-error.

Direct methods
Direct slots
Slot: operation-name
Initform

(quote "<generic operation>")

Initargs

:operation-name

Readers

operation-not-suported-operation-name.

Writers

This slot is read-only.

Slot: extra-information
Initform

(quote nil)

Initargs

:extra-information

Readers

operation-not-supported-extra-information.

Writers

This slot is read-only.

Condition: required-dimension-error
Package

l-math.

Source

conditions.lisp.

Direct superclasses

dimension-error.

Direct methods
Direct slots
Slot: dim1
Initform

(quote nil)

Initargs

:dim1

Readers

dimension-error-dim1.

Writers

This slot is read-only.

Slot: dim2
Initform

(quote nil)

Initargs

:dim2

Readers

dimension-error-dim2.

Writers

This slot is read-only.

Condition: spline-geometry-error
Package

l-math.

Source

conditions.lisp.

Direct superclasses

l-math-error.

Direct slots
Slot: format-control
Initform

(quote "the geometry data for the spline is malformed.")

Initargs

:format-control

Condition: zero-norm-error
Package

l-math.

Source

conditions.lisp.

Direct superclasses

l-math-error.

Direct slots
Slot: format-control
Initform

(quote "the given vector is of zero length.")

Initargs

:format-control


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

5.2.6 Classes

Class: last-shared-spline

This class is for those curves / splines who set up
their geometry matrices by repeating the last element in a set of four, such as the hermite and bézier curves.

Package

l-math.

Source

spline.lisp.

Direct superclasses

matrix-spline.

Direct subclasses
Direct methods
Class: matrix-spline

Used to represent splines that are defined by basis matrices.

Package

l-math.

Source

spline.lisp.

Direct superclasses

spline.

Direct subclasses
Direct methods
Direct slots
Slot: basis-matrix

Defines the behaviour of the
spline. For possible bases to use, see MAKE-HERMITE-BASIS-MATRIX, MAKE-BEZIER-BASIS-MATRIX, and MAKE-UNIFORM-NONRATIONAL-BSPLINE-BASIS-MATRIX

Initargs

:basis-matrix

Readers

basis-matrix.

Writers

(setf basis-matrix).

Slot: geometry

An array storing the various geometry matrices that make up the spline.

Type

(or null simple-array)

Class: three-shared-spline

Represents those splines for which the last three
geometry points are always shared with a new point to construct the spline. These are splines such as the b-splines and catmull-rom splines.

Package

l-math.

Source

spline.lisp.

Direct superclasses

matrix-spline.

Direct subclasses
Direct methods

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (   *   +   -   /  
A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W   X   Y   Z  
Index Entry  Section

(
(setf b-spline-degree): Public generic functions
(setf b-spline-degree): Public generic functions
(setf b-spline-knots): Public generic functions
(setf b-spline-knots): Public generic functions
(setf b-spline-points): Public generic functions
(setf b-spline-points): Public generic functions
(setf basis-matrix): Public generic functions
(setf basis-matrix): Public generic functions
(setf bezier-curve-degree): Private generic functions
(setf bezier-curve-degree): Private generic functions
(setf bezier-curve-degree): Private generic functions
(setf elt): Public setf expanders
(setf knots): Public generic functions
(setf knots): Public generic functions
(setf knots): Public generic functions
(setf matrix-elt): Public setf expanders
(setf multiplicity): Public generic functions
(setf multiplicity): Public generic functions
(setf multiplicity): Public generic functions
(setf spline-geometry): Public setf expanders
(setf w): Public generic functions
(setf w): Public generic functions
(setf x): Public generic functions
(setf x): Public generic functions
(setf x): Public generic functions
(setf y): Public generic functions
(setf y): Public generic functions
(setf y): Public generic functions
(setf z): Public generic functions
(setf z): Public generic functions
(setf z): Public generic functions

*
*: Public ordinary functions

+
+: Public ordinary functions

-
-: Public ordinary functions

/
/: Public ordinary functions

A
all-knots: Public generic functions
all-knots: Public generic functions
all-knots: Public generic functions
angle-between: Public generic functions
angle-between: Public generic functions

B
b-spline-basis: Public ordinary functions
b-spline-degree: Public generic functions
b-spline-degree: Public generic functions
b-spline-knots: Public generic functions
b-spline-knots: Public generic functions
b-spline-points: Public generic functions
b-spline-points: Public generic functions
basis-matrix: Public generic functions
basis-matrix: Public generic functions
bernstein-polynomials: Private generic functions
bernstein-polynomials: Private generic functions
between: Public generic functions
between: Public generic functions
bezier-curve-degree: Private generic functions
bezier-curve-degree: Private generic functions
bilinear-interpolation: Public generic functions
bilinear-interpolation: Public generic functions
bilinear-interpolation: Public generic functions
binomial-coefficient: Public ordinary functions

C
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c*: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c+: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c-: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
c/: Public generic functions
calculate-knot-count: Private generic functions
calculate-knot-count: Private generic functions
calculate-uniformity: Private generic functions
calculate-uniformity: Private generic functions
centre-of-mass: Public generic functions
centre-of-mass: Public generic functions
centre-of-mass: Public generic functions
centripetal-parameterisation: Private ordinary functions
chord-length-parameterisation: Private ordinary functions
coefficient-matrix: Public generic functions
coefficient-matrix: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy-vector: Public generic functions
copy-vector: Public generic functions
create-bernstein-polynomial: Public ordinary functions
create-list-operation-method: Private macros
create-rotation-from-view: Public ordinary functions
create-rotation-from-view-to-view: Public ordinary functions
create-rotation-matrix: Public ordinary functions
create-scale-matrix: Public ordinary functions
create-translation-matrix: Public ordinary functions
create-uniform-scale-matrix: Public ordinary functions
create-vector-operation-method: Private macros
cross-product: Public generic functions
cross-product: Public generic functions

D
dimension: Public generic functions
dimension: Public generic functions
dimension: Public generic functions
dimension: Public generic functions
dimension-error-dim1: Private generic functions
dimension-error-dim1: Private generic functions
dimension-error-dim1: Private generic functions
dimension-error-dim2: Private generic functions
dimension-error-dim2: Private generic functions
dimension-error-dim2: Private generic functions
do-each-matrix-element: Public macros
do-each-matrix-element-2: Public macros
do-each-vector-element: Public macros
domain-knots: Public generic functions
domain-knots: Public generic functions
dot-product: Public generic functions
dot-product: Public generic functions
dot-product: Public generic functions
dot-product: Public generic functions
dot-product: Public generic functions
draw-noise3-output: Public ordinary functions

E
elt: Public generic functions
elt: Public generic functions
elt: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
equivalent: Public generic functions
etest-dimensions: Private macros
etest-needed-vector-dimension: Private macros
euclidean-distance: Public generic functions
euclidean-distance: Public generic functions
euclidean-distance: Public generic functions
euclidean-distance: Public generic functions
evaluate: Public generic functions
evaluate: Public generic functions
evaluate: Public generic functions
evaluate: Public generic functions
evaluate-bernstein-polynomial: Public ordinary functions

F
factorial: Public ordinary functions
fill-row: Private macros
find-starting-knot-index: Private ordinary functions
Function, *: Public ordinary functions
Function, +: Public ordinary functions
Function, -: Public ordinary functions
Function, /: Public ordinary functions
Function, b-spline-basis: Public ordinary functions
Function, binomial-coefficient: Public ordinary functions
Function, centripetal-parameterisation: Private ordinary functions
Function, chord-length-parameterisation: Private ordinary functions
Function, create-bernstein-polynomial: Public ordinary functions
Function, create-rotation-from-view: Public ordinary functions
Function, create-rotation-from-view-to-view: Public ordinary functions
Function, create-rotation-matrix: Public ordinary functions
Function, create-scale-matrix: Public ordinary functions
Function, create-translation-matrix: Public ordinary functions
Function, create-uniform-scale-matrix: Public ordinary functions
Function, draw-noise3-output: Public ordinary functions
Function, evaluate-bernstein-polynomial: Public ordinary functions
Function, factorial: Public ordinary functions
Function, find-starting-knot-index: Private ordinary functions
Function, initialize-noise3: Public ordinary functions
Function, make-bezier-basis-matrix: Private ordinary functions
Function, make-catmull-rom-basis-matrix: Private ordinary functions
Function, make-diagonal: Public ordinary functions
Function, make-hermite-basis-matrix: Private ordinary functions
Function, make-identity: Public ordinary functions
Function, make-knots: Public ordinary functions
Function, make-matrix: Public ordinary functions
Function, make-random-matrix: Private ordinary functions
Function, make-random-vector: Public ordinary functions
Function, make-uniform-nonrational-bspline-basis-matrix: Private ordinary functions
Function, make-vector: Public ordinary functions
Function, noise3: Public ordinary functions
Function, normal: Public ordinary functions
Function, number-needed-knots: Private ordinary functions
Function, pitch-by: Public ordinary functions
Function, pitch-matrix: Public ordinary functions
Function, private-bilinear-interpolation: Private ordinary functions
Function, ratio-parameterisation: Private ordinary functions
Function, roll-by: Public ordinary functions
Function, roll-matrix: Public ordinary functions
Function, rotation-x: Public ordinary functions
Function, rotation-y: Public ordinary functions
Function, rotation-z: Public ordinary functions
Function, set-rotation-naming-convention: Public ordinary functions
Function, summation-transformer: Public ordinary functions
Function, to-degrees: Public ordinary functions
Function, to-radians: Public ordinary functions
Function, uniform: Public ordinary functions
Function, vector: Public ordinary functions
Function, yaw-by: Public ordinary functions
Function, yaw-matrix: Public ordinary functions

G
Generic Function, (setf b-spline-degree): Public generic functions
Generic Function, (setf b-spline-knots): Public generic functions
Generic Function, (setf b-spline-points): Public generic functions
Generic Function, (setf basis-matrix): Public generic functions
Generic Function, (setf bezier-curve-degree): Private generic functions
Generic Function, (setf knots): Public generic functions
Generic Function, (setf multiplicity): Public generic functions
Generic Function, (setf w): Public generic functions
Generic Function, (setf x): Public generic functions
Generic Function, (setf y): Public generic functions
Generic Function, (setf z): Public generic functions
Generic Function, all-knots: Public generic functions
Generic Function, angle-between: Public generic functions
Generic Function, b-spline-degree: Public generic functions
Generic Function, b-spline-knots: Public generic functions
Generic Function, b-spline-points: Public generic functions
Generic Function, basis-matrix: Public generic functions
Generic Function, bernstein-polynomials: Private generic functions
Generic Function, between: Public generic functions
Generic Function, bezier-curve-degree: Private generic functions
Generic Function, bilinear-interpolation: Public generic functions
Generic Function, c*: Public generic functions
Generic Function, c+: Public generic functions
Generic Function, c-: Public generic functions
Generic Function, c/: Public generic functions
Generic Function, calculate-knot-count: Private generic functions
Generic Function, calculate-uniformity: Private generic functions
Generic Function, centre-of-mass: Public generic functions
Generic Function, coefficient-matrix: Public generic functions
Generic Function, copy: Public generic functions
Generic Function, copy-vector: Public generic functions
Generic Function, cross-product: Public generic functions
Generic Function, dimension: Public generic functions
Generic Function, dimension-error-dim1: Private generic functions
Generic Function, dimension-error-dim2: Private generic functions
Generic Function, domain-knots: Public generic functions
Generic Function, dot-product: Public generic functions
Generic Function, elt: Public generic functions
Generic Function, equivalent: Public generic functions
Generic Function, euclidean-distance: Public generic functions
Generic Function, evaluate: Public generic functions
Generic Function, get-ith-knot: Private generic functions
Generic Function, high-parameter: Private generic functions
Generic Function, initialise-data: Private generic functions
Generic Function, knot-count: Private generic functions
Generic Function, knots: Public generic functions
Generic Function, l-math-error-format-arguments: Private generic functions
Generic Function, l-math-error-format-control: Private generic functions
Generic Function, length: Public generic functions
Generic Function, linear-interpolation: Public generic functions
Generic Function, low-parameter: Private generic functions
Generic Function, matrix-cols: Public generic functions
Generic Function, matrix-elt: Public generic functions
Generic Function, matrix-rows: Public generic functions
Generic Function, matrix=: Public generic functions
Generic Function, maximum-parameter: Public generic functions
Generic Function, minimum-parameter: Public generic functions
Generic Function, multiplicity: Public generic functions
Generic Function, negate: Public generic functions
Generic Function, negate!: Public generic functions
Generic Function, no-multiplicity-p: Private generic functions
Generic Function, norm: Public generic functions
Generic Function, normalise: Public generic functions
Generic Function, normalise!: Public generic functions
Generic Function, operation-not-suported-operation-name: Private generic functions
Generic Function, operation-not-supported-extra-information: Private generic functions
Generic Function, set-spline-geometry: Public generic functions
Generic Function, spline-geometry: Public generic functions
Generic Function, spline-interpolation: Public generic functions
Generic Function, test-dimensions: Public generic functions
Generic Function, test-nonzero: Private generic functions
Generic Function, to-homogenous: Public generic functions
Generic Function, to-list: Public generic functions
Generic Function, to-vector: Public generic functions
Generic Function, transform: Public generic functions
Generic Function, transpose: Public generic functions
Generic Function, uniform-p: Private generic functions
Generic Function, vector=: Public generic functions
Generic Function, w: Public generic functions
Generic Function, x: Public generic functions
Generic Function, y: Public generic functions
Generic Function, z: Public generic functions
Generic Function, zerop: Public generic functions
get-ith-knot: Private generic functions
get-ith-knot: Private generic functions
get-ith-knot: Private generic functions

H
high-parameter: Private generic functions
high-parameter: Private generic functions

I
initialise-data: Private generic functions
initialise-data: Private generic functions
initialise-data: Private generic functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-noise3: Public ordinary functions

K
knot-count: Private generic functions
knot-count: Private generic functions
knots: Public generic functions
knots: Public generic functions

L
l-math-error-format-arguments: Private generic functions
l-math-error-format-arguments: Private generic functions
l-math-error-format-control: Private generic functions
l-math-error-format-control: Private generic functions
length: Public generic functions
length: Public generic functions
length: Public generic functions
linear-interpolation: Public generic functions
linear-interpolation: Public generic functions
linear-interpolation: Public generic functions
low-parameter: Private generic functions
low-parameter: Private generic functions

M
Macro, create-list-operation-method: Private macros
Macro, create-vector-operation-method: Private macros
Macro, do-each-matrix-element: Public macros
Macro, do-each-matrix-element-2: Public macros
Macro, do-each-vector-element: Public macros
Macro, etest-dimensions: Private macros
Macro, etest-needed-vector-dimension: Private macros
Macro, fill-row: Private macros
make-bezier-basis-matrix: Private ordinary functions
make-catmull-rom-basis-matrix: Private ordinary functions
make-diagonal: Public ordinary functions
make-hermite-basis-matrix: Private ordinary functions
make-identity: Public ordinary functions
make-knots: Public ordinary functions
make-load-form: Public standalone methods
make-load-form: Public standalone methods
make-matrix: Public ordinary functions
make-random-matrix: Private ordinary functions
make-random-vector: Public ordinary functions
make-uniform-nonrational-bspline-basis-matrix: Private ordinary functions
make-vector: Public ordinary functions
matrix-cols: Public generic functions
matrix-cols: Public generic functions
matrix-elt: Public generic functions
matrix-elt: Public generic functions
matrix-rows: Public generic functions
matrix-rows: Public generic functions
matrix=: Public generic functions
matrix=: Public generic functions
maximum-parameter: Public generic functions
maximum-parameter: Public generic functions
maximum-parameter: Public generic functions
maximum-parameter: Public generic functions
Method, (setf b-spline-degree): Public generic functions
Method, (setf b-spline-knots): Public generic functions
Method, (setf b-spline-points): Public generic functions
Method, (setf basis-matrix): Public generic functions
Method, (setf bezier-curve-degree): Private generic functions
Method, (setf bezier-curve-degree): Private generic functions
Method, (setf knots): Public generic functions
Method, (setf knots): Public generic functions
Method, (setf multiplicity): Public generic functions
Method, (setf multiplicity): Public generic functions
Method, (setf w): Public generic functions
Method, (setf x): Public generic functions
Method, (setf x): Public generic functions
Method, (setf y): Public generic functions
Method, (setf y): Public generic functions
Method, (setf z): Public generic functions
Method, (setf z): Public generic functions
Method, all-knots: Public generic functions
Method, all-knots: Public generic functions
Method, angle-between: Public generic functions
Method, b-spline-degree: Public generic functions
Method, b-spline-knots: Public generic functions
Method, b-spline-points: Public generic functions
Method, basis-matrix: Public generic functions
Method, bernstein-polynomials: Private generic functions
Method, between: Public generic functions
Method, bezier-curve-degree: Private generic functions
Method, bilinear-interpolation: Public generic functions
Method, bilinear-interpolation: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c*: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c+: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c-: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, c/: Public generic functions
Method, calculate-knot-count: Private generic functions
Method, calculate-uniformity: Private generic functions
Method, centre-of-mass: Public generic functions
Method, centre-of-mass: Public generic functions
Method, coefficient-matrix: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, copy-vector: Public generic functions
Method, cross-product: Public generic functions
Method, dimension: Public generic functions
Method, dimension: Public generic functions
Method, dimension: Public generic functions
Method, dimension-error-dim1: Private generic functions
Method, dimension-error-dim1: Private generic functions
Method, dimension-error-dim2: Private generic functions
Method, dimension-error-dim2: Private generic functions
Method, domain-knots: Public generic functions
Method, dot-product: Public generic functions
Method, dot-product: Public generic functions
Method, dot-product: Public generic functions
Method, dot-product: Public generic functions
Method, elt: Public generic functions
Method, elt: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, equivalent: Public generic functions
Method, euclidean-distance: Public generic functions
Method, euclidean-distance: Public generic functions
Method, euclidean-distance: Public generic functions
Method, evaluate: Public generic functions
Method, evaluate: Public generic functions
Method, evaluate: Public generic functions
Method, get-ith-knot: Private generic functions
Method, get-ith-knot: Private generic functions
Method, high-parameter: Private generic functions
Method, initialise-data: Private generic functions
Method, initialise-data: Private generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, knot-count: Private generic functions
Method, knots: Public generic functions
Method, l-math-error-format-arguments: Private generic functions
Method, l-math-error-format-control: Private generic functions
Method, length: Public generic functions
Method, length: Public generic functions
Method, linear-interpolation: Public generic functions
Method, linear-interpolation: Public generic functions
Method, low-parameter: Private generic functions
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, matrix-cols: Public generic functions
Method, matrix-elt: Public generic functions
Method, matrix-rows: Public generic functions
Method, matrix=: Public generic functions
Method, maximum-parameter: Public generic functions
Method, maximum-parameter: Public generic functions
Method, maximum-parameter: Public generic functions
Method, minimum-parameter: Public generic functions
Method, minimum-parameter: Public generic functions
Method, minimum-parameter: Public generic functions
Method, multiplicity: Public generic functions
Method, negate: Public generic functions
Method, negate: Public generic functions
Method, negate: Public generic functions
Method, negate: Public generic functions
Method, negate!: Public generic functions
Method, negate!: Public generic functions
Method, negate!: Public generic functions
Method, no-multiplicity-p: Private generic functions
Method, norm: Public generic functions
Method, norm: Public generic functions
Method, normalise: Public generic functions
Method, normalise: Public generic functions
Method, normalise!: Public generic functions
Method, normalise!: Public generic functions
Method, operation-not-suported-operation-name: Private generic functions
Method, operation-not-supported-extra-information: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, set-spline-geometry: Public generic functions
Method, set-spline-geometry: Public generic functions
Method, set-spline-geometry: Public generic functions
Method, set-spline-geometry: Public generic functions
Method, spline-geometry: Public generic functions
Method, spline-geometry: Public generic functions
Method, spline-geometry: Public generic functions
Method, spline-geometry: Public generic functions
Method, spline-interpolation: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-dimensions: Public generic functions
Method, test-nonzero: Private generic functions
Method, to-homogenous: Public generic functions
Method, to-homogenous: Public generic functions
Method, to-list: Public generic functions
Method, to-list: Public generic functions
Method, to-vector: Public generic functions
Method, to-vector: Public generic functions
Method, transform: Public generic functions
Method, transform: Public generic functions
Method, transform: Public generic functions
Method, transpose: Public generic functions
Method, uniform-p: Private generic functions
Method, vector=: Public generic functions
Method, vector=: Public generic functions
Method, w: Public generic functions
Method, x: Public generic functions
Method, x: Public generic functions
Method, y: Public generic functions
Method, y: Public generic functions
Method, z: Public generic functions
Method, z: Public generic functions
Method, zerop: Public generic functions
Method, zerop: Public generic functions
Method, zerop: Public generic functions
Method, zerop: Public generic functions
minimum-parameter: Public generic functions
minimum-parameter: Public generic functions
minimum-parameter: Public generic functions
minimum-parameter: Public generic functions
multiplicity: Public generic functions
multiplicity: Public generic functions

N
negate: Public generic functions
negate: Public generic functions
negate: Public generic functions
negate: Public generic functions
negate: Public generic functions
negate!: Public generic functions
negate!: Public generic functions
negate!: Public generic functions
negate!: Public generic functions
no-multiplicity-p: Private generic functions
no-multiplicity-p: Private generic functions
noise3: Public ordinary functions
norm: Public generic functions
norm: Public generic functions
norm: Public generic functions
normal: Public ordinary functions
normalise: Public generic functions
normalise: Public generic functions
normalise: Public generic functions
normalise!: Public generic functions
normalise!: Public generic functions
normalise!: Public generic functions
number-needed-knots: Private ordinary functions

O
operation-not-suported-operation-name: Private generic functions
operation-not-suported-operation-name: Private generic functions
operation-not-supported-extra-information: Private generic functions
operation-not-supported-extra-information: Private generic functions

P
pitch-by: Public ordinary functions
pitch-matrix: Public ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
private-bilinear-interpolation: Private ordinary functions

R
ratio-parameterisation: Private ordinary functions
roll-by: Public ordinary functions
roll-matrix: Public ordinary functions
rotation-x: Public ordinary functions
rotation-y: Public ordinary functions
rotation-z: Public ordinary functions

S
set-rotation-naming-convention: Public ordinary functions
set-spline-geometry: Public generic functions
set-spline-geometry: Public generic functions
set-spline-geometry: Public generic functions
set-spline-geometry: Public generic functions
set-spline-geometry: Public generic functions
Setf Expander, (setf elt): Public setf expanders
Setf Expander, (setf matrix-elt): Public setf expanders
Setf Expander, (setf spline-geometry): Public setf expanders
spline-geometry: Public generic functions
spline-geometry: Public generic functions
spline-geometry: Public generic functions
spline-geometry: Public generic functions
spline-geometry: Public generic functions
spline-interpolation: Public generic functions
spline-interpolation: Public generic functions
summation-transformer: Public ordinary functions

T
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-dimensions: Public generic functions
test-nonzero: Private generic functions
test-nonzero: Private generic functions
to-degrees: Public ordinary functions
to-homogenous: Public generic functions
to-homogenous: Public generic functions
to-homogenous: Public generic functions
to-list: Public generic functions
to-list: Public generic functions
to-list: Public generic functions
to-radians: Public ordinary functions
to-vector: Public generic functions
to-vector: Public generic functions
to-vector: Public generic functions
transform: Public generic functions
transform: Public generic functions
transform: Public generic functions
transform: Public generic functions
transpose: Public generic functions
transpose: Public generic functions

U
uniform: Public ordinary functions
uniform-p: Private generic functions
uniform-p: Private generic functions

V
vector: Public ordinary functions
vector=: Public generic functions
vector=: Public generic functions
vector=: Public generic functions

W
w: Public generic functions
w: Public generic functions

X
x: Public generic functions
x: Public generic functions
x: Public generic functions

Y
y: Public generic functions
y: Public generic functions
y: Public generic functions
yaw-by: Public ordinary functions
yaw-matrix: Public ordinary functions

Z
z: Public generic functions
z: Public generic functions
z: Public generic functions
zerop: Public generic functions
zerop: Public generic functions
zerop: Public generic functions
zerop: Public generic functions
zerop: Public generic functions

Jump to:   (   *   +   -   /  
A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W   X   Y   Z  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
B   D   E   F   G   K   M   N   O   P   S   U  
Index Entry  Section

*
*equivalence-tolerance*: Public special variables
*perlin-gradients*: Private special variables
*perlin-permutations*: Private special variables
*rotation-naming-conventions*: Public special variables

B
basis-matrix: Private classes
bernstein-polynomials: Public classes

D
data: Public classes
data: Public classes
degree: Public classes
degree: Public classes
dim1: Public conditions
dim1: Private conditions
dim2: Public conditions
dim2: Private conditions

E
extra-information: Private conditions

F
format-arguments: Public conditions
format-control: Public conditions
format-control: Private conditions
format-control: Private conditions

G
geometry: Private classes

K
knot-count: Public classes
knots: Public classes
knots: Public classes

M
multiplicity: Public classes

N
no-multiplicity: Public classes

O
operation-name: Private conditions

P
points: Public classes

S
Slot, basis-matrix: Private classes
Slot, bernstein-polynomials: Public classes
Slot, data: Public classes
Slot, data: Public classes
Slot, degree: Public classes
Slot, degree: Public classes
Slot, dim1: Public conditions
Slot, dim1: Private conditions
Slot, dim2: Public conditions
Slot, dim2: Private conditions
Slot, extra-information: Private conditions
Slot, format-arguments: Public conditions
Slot, format-control: Public conditions
Slot, format-control: Private conditions
Slot, format-control: Private conditions
Slot, geometry: Private classes
Slot, knot-count: Public classes
Slot, knots: Public classes
Slot, knots: Public classes
Slot, multiplicity: Public classes
Slot, no-multiplicity: Public classes
Slot, operation-name: Private conditions
Slot, points: Public classes
Slot, spline-geometry: Public classes
Slot, uniform: Public classes
Special Variable, *equivalence-tolerance*: Public special variables
Special Variable, *perlin-gradients*: Private special variables
Special Variable, *perlin-permutations*: Private special variables
Special Variable, *rotation-naming-conventions*: Public special variables
spline-geometry: Public classes

U
uniform: Public classes

Jump to:   *  
B   D   E   F   G   K   M   N   O   P   S   U  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   D   F   G   H   I   L   M   O   P   R   S   T   U   V   Z  
Index Entry  Section

B
b-spline: Public classes
b-spline-knots: Public classes
basis.lisp: The l-math/basis․lisp file
bezier-curve: Public classes

C
catmull-rom-spline: Public classes
Class, b-spline: Public classes
Class, b-spline-knots: Public classes
Class, bezier-curve: Public classes
Class, catmull-rom-spline: Public classes
Class, cubic-bezier-curve: Public classes
Class, hermite-curve: Public classes
Class, last-shared-spline: Private classes
Class, matrix: Public classes
Class, matrix-spline: Private classes
Class, spline: Public classes
Class, three-shared-spline: Private classes
Class, unrbs-spline: Public classes
Class, vector: Public classes
Condition, dimension-error: Public conditions
Condition, l-math-error: Public conditions
Condition, operation-not-supported: Private conditions
Condition, required-dimension-error: Private conditions
Condition, spline-geometry-error: Private conditions
Condition, zero-norm-error: Private conditions
conditions.lisp: The l-math/conditions․lisp file
cubic-bezier-curve: Public classes

D
dimension-error: Public conditions

F
File, basis.lisp: The l-math/basis․lisp file
File, conditions.lisp: The l-math/conditions․lisp file
File, generics.lisp: The l-math/generics․lisp file
File, interpolate.lisp: The l-math/interpolate․lisp file
File, l-math.asd: The l-math/l-math․asd file
File, matrix.lisp: The l-math/matrix․lisp file
File, operations.lisp: The l-math/operations․lisp file
File, package.lisp: The l-math/package․lisp file
File, random.lisp: The l-math/random․lisp file
File, rotations.lisp: The l-math/rotations․lisp file
File, scale.lisp: The l-math/scale․lisp file
File, spline-interpolation.lisp: The l-math/spline-interpolation․lisp file
File, spline.lisp: The l-math/spline․lisp file
File, tests.lisp: The l-math/tests․lisp file
File, transform.lisp: The l-math/transform․lisp file
File, translation.lisp: The l-math/translation․lisp file
File, utility.lisp: The l-math/utility․lisp file
File, vector-operations.lisp: The l-math/vector-operations․lisp file
File, vector.lisp: The l-math/vector․lisp file

G
generics.lisp: The l-math/generics․lisp file

H
hermite-curve: Public classes

I
interpolate.lisp: The l-math/interpolate․lisp file

L
l-math: The l-math system
l-math: The l-math package
l-math-asdf: The l-math-asdf package
l-math-error: Public conditions
l-math.asd: The l-math/l-math․asd file
last-shared-spline: Private classes

M
matrix: Public classes
matrix-spline: Private classes
matrix.lisp: The l-math/matrix․lisp file

O
operation-not-supported: Private conditions
operations.lisp: The l-math/operations․lisp file

P
Package, l-math: The l-math package
Package, l-math-asdf: The l-math-asdf package
package.lisp: The l-math/package․lisp file

R
random.lisp: The l-math/random․lisp file
required-dimension-error: Private conditions
rotations.lisp: The l-math/rotations․lisp file

S
scale.lisp: The l-math/scale․lisp file
spline: Public classes
spline-geometry-error: Private conditions
spline-interpolation.lisp: The l-math/spline-interpolation․lisp file
spline.lisp: The l-math/spline․lisp file
System, l-math: The l-math system

T
tests.lisp: The l-math/tests․lisp file
three-shared-spline: Private classes
transform.lisp: The l-math/transform․lisp file
translation.lisp: The l-math/translation․lisp file

U
unrbs-spline: Public classes
utility.lisp: The l-math/utility․lisp file

V
vector: Public classes
vector-operations.lisp: The l-math/vector-operations․lisp file
vector.lisp: The l-math/vector․lisp file

Z
zero-norm-error: Private conditions

Jump to:   B   C   D   F   G   H   I   L   M   O   P   R   S   T   U   V   Z