The cl-tuples Reference Manual

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

The cl-tuples Reference Manual

This is the cl-tuples Reference Manual, version 1.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Dec 02 09:51:55 2019 GMT+0.

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

cl-tuples - A set of macros for auto-generating optimised vector math routines

A tuple type declaration auto-generates a number of useful functions, macros, and types.

It is best to give an example.

``````(def-tuple-type vector2d
:tuple-element-type short-float
:initial-element 0.0f0
:elements (x y))
``````

Will declare a tuple of short-floats, arrays of which are initialised with the element 0.0f0 and which has two elements, named x and y.

There will be a struct to represent this type, declared as follows:

``````(defstruct vector2d
:type vector
:constructor nil
(x 0.0f0 :type short-float)
(y 0.0f0 :type short-float))
``````

i.e. a struct, stored as a vector with elements representing the elements of the tuple, initialised to the initial-element value of the tuple.

Literals can be written via the modified read syntax

``````	#[ vector2d 0.2 1.2 ] => #( 0.2 1.2 )
#[ vector2d* 0.2 1.2 ] => (values 0.2 1.2)
``````

It is reccomended literals are written with the above syntax as their expansion will also incorportate type definitions that will be compatible with the following routines that will be generated to be able to manipulate them.

``````(vector2d-values* x y) => (values x y)          ;; convert from args to values
(vector2d* v) => (values (aref v 0) (aref v 1)) ;; covert from array to values
(new-vector2d)                                  ;; returns an empty tuple vector- i.e. #( 0 0 )
(make-vector2d x y)                             ;; returns a vector (struct) as #( x y )
(make-vector2d* (values x y))                   ;; same as the above only with multiple value arguments
(setf (vector2d* v) (values x y) )              ;; generalised set that takes multiple values
(with-vector2d v (i j) ...)                     ;; binds x and y of tuple vector v to i and j in the body
(with-vector2d* (values x y) (i j) ..)          ;; same as the above, only it expects a values form

;; arrays -- this can create an array  of n vector2ds (eg 4 vector2ds == 8 element array)

(vector2d-aref v  n)  						    ;; treats v as an array of n vector2d's and
;; returns the nth vector2d as a vector (ie
;; struct)
(vector2d-aref* v n)							;; treats v as an array of n vector2d's and returns the
;; nth vector2 as multiple values

(setf (vector2d-aref v n) #( x y ))             ;; sets the n'tn vector2d in the array v

(setf (vector2d-aref v n) (values x y ))       	;; sets the n'tn vector2d in the array v, expects multiple
;; value argument

(vector2d-push #( x y ) v)                     ;; push an vector2d into an array of vector2d
(vector2d-push*  (values x y) v)               ;; same as above but with multiple values
(vector2d-push-extend #( x y ) v)              ;; as vector2d-push but admits the possiblity of extension
(vector2d-push-extend* (values x y) v)         ;; same as above but takes multiple value arguments

(vector2d-fill-pointer v)                       ;; returns fill pointer
(setf (vector2d-fill-pointer v) x)              ;; sets fill pointer
(vector2d-array-dimensions v)                   ;; returns number of vector2d's array can hold
``````

In addition a small convienince reader syntax is implemented - #{ x y z } is equivalent to (values x y z) as client code of this library is likely to manipulate many multiple values.

Note that the code cl-tuples generates is implementation agnostic: it is heavily predicated on the assumption that your implementation does a good job of optimising multiple value calls. If this is not the case, then the convienence of the array - related functions are probably the only good reason to use this library.

HOWTO

A two-dimensional vector value is created by `MAKE-VECTOR2D`:

``````> (make-vector2d 1f0 1f0)
#(1.0 1.0)
``````

The type `FAST-FLOAT`, which is used for all float values, is actually a subtype of `SINGLE-FLOAT`, so make sure to only use values that fit into that type.

To calculate the length of this vector `VECTOR2D-LENGTH*` can now be used like this:

``````> (let ((v (make-vector2d 1f0 1f0)))
(vector2d-length* (vector2d* v)))
1.4142135
``````

By converting the object into a bunch of variables, the macro pipeline keeps transient objects and function calls away. The above form thus expands to something like the following (type declarations and some other code omitted for clarity):

``````(LET ((V (MAKE-VECTOR2D 1.0 1.0)))
(MULTIPLE-VALUE-BIND (#:G1764 #:G1765)
(VALUES (AREF V 0) (AREF V 1))
(SYMBOL-MACROLET ((X #:G1764) (Y #:G1765))
(SQRT (+ (* X X) (* Y Y))))))
``````

The coordinates of the vector are bound and made available to the length calculation code. If we skip the object creation and go straight the `VALUES` route, the following is approximately the same as above, without ever creating a vector object.

``````> (vector2d-length* (vector2d-values 1.0 1.0))
1.4142135
``````

The reader syntax may be used to the same effect:

``````> (enable-tuples-syntax)
> #{1.0 1.0}
1.0
1.0
> (vector2d-length* #{1.0 1.0})
1.4142135
``````

(Since the reader syntax and `VECTOR2D-VALUES` expand directly into a `VALUES` call, nothing prevents you from using that as well.)

Based on this design more operations are implemented. See the API and the tests for details on vectors, vertexes, matrixes and quaternions.

Defining new operators is done via `DEF-TUPLE-OP`, e.g.:

``````(def-tuple-op scaling-matrix44*
((sx fast-float)
(sy fast-float)
(sz fast-float))
(:return matrix44
(matrix44-values*
sx    0.0f0 0.0f0 0.0f0
0.0f0 sy    0.0f0 0.0f0
0.0f0 0.0f0 sz    0.0f0
0.0f0 0.0f0 0.0f0 1.0f0)))
``````

This operator accepts three arguments and creates the obvious matrix from them. So lets say, a function has as a conventional argument a vector of three elements. Binding each element to a name and applying the above operator to them gives us the following:

``````> (let ((v (make-vector3d* #{1f0 1f0 1f0))))
(with-vector3d v (sx sy sz)
(make-matrix44* (scaling-matrix44* sx sy sz)))
#(1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0)
``````

The calculated matrix is converted to an actual object to be returned.

ASSORTED EXAMPLES

``````> (let ((v (make-vector2d 1f0 1f0))
(s 2f0))
(vector2d-length* (vector2d-scale* (vector2d* v) s)))
2.828427
``````

QUATERNIONS

(Adapted from the documentation of cl-quaternion to this API.)

Creating a quaternion from real and imaginary components. The first argument is the real part, and the rest are the imaginary components.

``````> (make-quaternion* (quaternion-values* 10f0 3f0 0f0 0f0))
#(10.0 3.0 0.0 0.0)
``````

Quaternions can be normalized and magnitudes may be computed.

``````> (make-quaternion* (quaternion-normalize* (quaternion* *)))
#(0.9578263 0.28734788 0.0 0.0)
> (quaternion-mag* (quaternion* *))
1.0
``````

Quaternion addition and multiplication are supported.

``````> (make-quaternion*
(quaternion-sum* (quaternion-values* 3f0 0f0 0f0 0f0)
(quaternion-values* 1f0 1f0 0f0 1f0)))
#(4.0 1.0 0.0 1.0)
> (make-quaternion*
(quaternion-product* (quaternion-values* 3f0 0f0 0f0 0f0)
(quaternion-values* 1f0 1f0 0f0 1f0)))
#(3.0 0.0 3.0 -3.0)
``````

Unit quaternions may be used to represent rotations. Functions are provided for working with quaternions for this purpose.

``````> (values fast-pi (type-of fast-pi))
3.1415927
SINGLE-FLOAT
> (make-quaternion*
(angle-axis-quaternion*
(angle-axis-values* 0f0 0f0 1f0 (/ single-pi 2f0))))
#(0.0 0.0 0.70710677 0.70710677)
``````

Vectors can then be transformed using these quaternions.

``````> (quaternion-transform-vector3d*
(vector3d-values* 0.0 1.0 0.0)
(angle-axis-quaternion*
(angle-axis-values* 0.0 0.0 1.0 (/ fast-pi 2))))
-0.99999994
0.0
0.0
``````

At the moment you have still to convert an angle-axis representation to either a matrix or a quaternion by yourself to rotate a vector by it.

``````> (quaternion-transform-vector3d*
(vector3d-values* 0.0 1.0 0.0)
(angle-axis-quaternion*
(angle-axis-values* 0.0 0.0 1.0 fast-pi)))
8.742278e-8
-1.0
0.0
> (transform-vector3d*
(angle-axis-matrix33*
(angle-axis-values* 0.0 0.0 1.0 fast-pi))
(vector3d-values* 0.0 1.0 0.0))
8.742278e-8
-1.0
0.0
``````

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

2 Systems

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

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

2.1 cl-tuples

Author

John Connors

MIT

Description

Version

1.0

Dependencies
• iterate
• alexandria
Source

cl-tuples.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 cl-tuples.asd

Location

cl-tuples.asd

Systems

cl-tuples (system)

Packages

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

3.1.2 cl-tuples/package.lisp

Parent

cl-tuples (system)

Location

package.lisp

Packages

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

3.1.3 cl-tuples/utils.lisp

Dependency

package.lisp (file)

Parent

cl-tuples (system)

Location

utils.lisp

Exported Definitions
Internal Definitions

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

3.1.4 cl-tuples/symbols.lisp

Dependency

utils.lisp (file)

Parent

cl-tuples (system)

Location

symbols.lisp

Packages
Exported Definitions
Internal Definitions

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

3.1.5 cl-tuples/syntax.lisp

Dependency

symbols.lisp (file)

Parent

cl-tuples (system)

Location

syntax.lisp

Exported Definitions
Internal Definitions

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

3.1.6 cl-tuples/tuple-expander.lisp

Dependency

syntax.lisp (file)

Parent

cl-tuples (system)

Location

tuple-expander.lisp

Internal Definitions

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

3.1.7 cl-tuples/tuples.lisp

Dependency

tuple-expander.lisp (file)

Parent

cl-tuples (system)

Location

tuples.lisp

Exported Definitions
Internal Definitions

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

3.1.8 cl-tuples/vector.lisp

Dependency

tuples.lisp (file)

Parent

cl-tuples (system)

Location

vector.lisp

Exported Definitions
Internal Definitions

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

3.1.9 cl-tuples/matrix.lisp

Dependency

vector.lisp (file)

Parent

cl-tuples (system)

Location

matrix.lisp

Exported Definitions
Internal Definitions

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

3.1.10 cl-tuples/quaternion.lisp

Dependency

matrix.lisp (file)

Parent

cl-tuples (system)

Location

quaternion.lisp

Exported Definitions
Internal Definitions

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

3.1.11 cl-tuples/colour.lisp

Dependency

quaternion.lisp (file)

Parent

cl-tuples (system)

Location

colour.lisp

Exported Definitions
Internal Definitions

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

3.1.12 cl-tuples/triangle.lisp

Dependency

colour.lisp (file)

Parent

cl-tuples (system)

Location

triangle.lisp

Exported Definitions
Internal Definitions

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

3.1.13 cl-tuples/rect.lisp

Dependency

triangle.lisp (file)

Parent

cl-tuples (system)

Location

rect.lisp

Exported Definitions
Internal Definitions

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

3.1.14 cl-tuples/aabb.lisp

Dependency

rect.lisp (file)

Parent

cl-tuples (system)

Location

aabb.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.

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

4.1 cl-tuples-system

Source

cl-tuples.asd

Use List
• asdf/interface
• common-lisp

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

4.2 cl-tuples

Source

package.lisp (file)

Nickname

tuples

Use List
• iterate
• alexandria.1.0.0
• common-lisp
Exported Definitions
Internal Definitions

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

4.3 tuple-types

Source

symbols.lisp (file)

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

5 Definitions

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

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

5.1 Exported definitions

Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Constants

Constant: fast-pi
Package
Source

utils.lisp (file)

Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Special variables

Special Variable: *float-print-format*
Package
Source

matrix.lisp (file)

Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Macros

Macro: aabb* TUPLE-ARRAY-NAME

Unpack array representation of an AABB and convert to multiple values.

Package
Source

aabb.lisp (file)

Setf Expander

(setf aabb*) (setf expander)

Setf Expander: (setf aabb*) TUPLE-PLACE TUPLE-VALUES
Package
Source

aabb.lisp (file)

aabb* (macro)

Writer

aabb-setter* (macro)

Macro: aabb-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual AABB to multiple values from an array of AABBs.

Package
Source

aabb.lisp (file)

Setf Expander

(setf aabb-aref*) (setf expander)

Setf Expander: (setf aabb-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

aabb.lisp (file)

aabb-aref* (macro)

Writer

aabb-aref-setter* (macro)

Macro: aabb-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an AABB vector in a vector of AABBs from a multiple values AABB

Package
Source

aabb.lisp (file)

Setf Expander

(setf aabb-aref*) (setf expander)

Macro: aabb-key-values &key INITIAL-ELEMENT (MINX MINX) (MAXX MAXX) (MINY MINY) (MAXY MAXY) (MINZ MINZ) (MAXZ MAXZ)
Package
Source

aabb.lisp (file)

Macro: aabb-map* OPERATOR &rest ARGS
Package
Source

aabb.lisp (file)

Macro: aabb-reduce* OPERATOR TUPLE
Package
Source

aabb.lisp (file)

Macro: aabb-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an AABB vector from a multiple values AABB

Package
Source

aabb.lisp (file)

Setf Expander

(setf aabb*) (setf expander)

Macro: aabb-values* &rest ELEMENTS

Convert AABB forms to multiple values.

Package
Source

aabb.lisp (file)

Macro: aabb-vector-push* TUPLE-VALUES ARRAY-NAME

Push a AABB multiple value onto the end of a vector of AABB’s

Package
Source

aabb.lisp (file)

Macro: aabb-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a AABB multiple value onto the end of a vector of AABB’s with the possibility of extension

Package
Source

aabb.lisp (file)

Macro: angle-axis* TUPLE-ARRAY-NAME

Unpack array representation of an ANGLE-AXIS and convert to multiple values.

Package
Source

quaternion.lisp (file)

Setf Expander

(setf angle-axis*) (setf expander)

Setf Expander: (setf angle-axis*) TUPLE-PLACE TUPLE-VALUES
Package
Source

quaternion.lisp (file)

angle-axis* (macro)

Writer

angle-axis-setter* (macro)

Macro: angle-axis-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual ANGLE-AXIS to multiple values from an array of ANGLE-AXISs.

Package
Source

quaternion.lisp (file)

Setf Expander

(setf angle-axis-aref*) (setf expander)

Setf Expander: (setf angle-axis-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

quaternion.lisp (file)

angle-axis-aref* (macro)

Writer

angle-axis-aref-setter* (macro)

Macro: angle-axis-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an ANGLE-AXIS vector in a vector of ANGLE-AXISs from a multiple values ANGLE-AXIS

Package
Source

quaternion.lisp (file)

Setf Expander

(setf angle-axis-aref*) (setf expander)

Macro: angle-axis-key-values &key INITIAL-ELEMENT (X X) (Y Y) (Z Z) (A A)
Package
Source

quaternion.lisp (file)

Macro: angle-axis-map* OPERATOR &rest ARGS
Package
Source

quaternion.lisp (file)

Macro: angle-axis-matrix33* AA

DEF-TUPLE-OP ANGLE-AXIS-MATRIX33* (ANGLE-AXIS)

Package
Source

quaternion.lisp (file)

Macro: angle-axis-quaternion* AA

Convert an angle-axis tuple to a quaternion tuple

Package
Source

quaternion.lisp (file)

Macro: angle-axis-reduce* OPERATOR TUPLE
Package
Source

quaternion.lisp (file)

Macro: angle-axis-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an ANGLE-AXIS vector from a multiple values ANGLE-AXIS

Package
Source

quaternion.lisp (file)

Setf Expander

(setf angle-axis*) (setf expander)

Macro: angle-axis-values* &rest ELEMENTS

Convert ANGLE-AXIS forms to multiple values.

Package
Source

quaternion.lisp (file)

Macro: angle-axis-vector-push* TUPLE-VALUES ARRAY-NAME

Push a ANGLE-AXIS multiple value onto the end of a vector of ANGLE-AXIS’s

Package
Source

quaternion.lisp (file)

Macro: angle-axis-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a ANGLE-AXIS multiple value onto the end of a vector of ANGLE-AXIS’s with the possibility of extension

Package
Source

quaternion.lisp (file)

Macro: cofactor-matrix22* MAT

DEF-TUPLE-OP COFACTOR-MATRIX22* (MATRIX22)

Package
Source

matrix.lisp (file)

Macro: cofactor-matrix33* MAT

DEF-TUPLE-OP COFACTOR-MATRIX33* (MATRIX33)

Package
Source

matrix.lisp (file)

Macro: cofactor-matrix44* MAT

DEF-TUPLE-OP COFACTOR-MATRIX44* (MATRIX44)

Package
Source

matrix.lisp (file)

Macro: colour* TUPLE-ARRAY-NAME

Unpack array representation of an COLOUR and convert to multiple values.

Package
Source

colour.lisp (file)

Setf Expander

(setf colour*) (setf expander)

Setf Expander: (setf colour*) TUPLE-PLACE TUPLE-VALUES
Package
Source

colour.lisp (file)

colour* (macro)

Writer

colour-setter* (macro)

Macro: colour-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual COLOUR to multiple values from an array of COLOURs.

Package
Source

colour.lisp (file)

Setf Expander

(setf colour-aref*) (setf expander)

Setf Expander: (setf colour-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

colour.lisp (file)

colour-aref* (macro)

Writer

colour-aref-setter* (macro)

Macro: colour-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an COLOUR vector in a vector of COLOURs from a multiple values COLOUR

Package
Source

colour.lisp (file)

Setf Expander

(setf colour-aref*) (setf expander)

Macro: colour-key-values &key INITIAL-ELEMENT (R R) (G G) (B B) (A A)
Package
Source

colour.lisp (file)

Macro: colour-map* OPERATOR &rest ARGS
Package
Source

colour.lisp (file)

Macro: colour-reduce* OPERATOR TUPLE
Package
Source

colour.lisp (file)

Macro: colour-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an COLOUR vector from a multiple values COLOUR

Package
Source

colour.lisp (file)

Setf Expander

(setf colour*) (setf expander)

Macro: colour-values* &rest ELEMENTS

Convert COLOUR forms to multiple values.

Package
Source

colour.lisp (file)

Macro: colour-vector-push* TUPLE-VALUES ARRAY-NAME

Push a COLOUR multiple value onto the end of a vector of COLOUR’s

Package
Source

colour.lisp (file)

Macro: colour-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a COLOUR multiple value onto the end of a vector of COLOUR’s with the possibility of extension

Package
Source

colour.lisp (file)

Macro: def-tuple-op NAME PARAM-LIST &body FORMS

Macro to define a tuple operator. The name of the operator is name. The operator arguments are determined by args, which is a list of the form ((argument-name argument-type (elements) ..)). Within the forms the tuple value form is bound to the argument-name and the tuple elements are bound to the symbols in the element list

Package
Source

tuples.lisp (file)

Macro: def-tuple-type TUPLE-TYPE-NAME &key TUPLE-ELEMENT-TYPE INITIAL-ELEMENT ELEMENTS

Create a tuple type. To be used from the top level.
For example (def-tuple-type vector3d single-float (x y z)) will create several macros and functions.
Firstly, the accessor functions (vector3d array) (vector3d-aref array index).
Secondly, the context macros (with-vector3d tuple (element-symbols) forms..) and (with-vector3d-array tuple (element-symbols) index forms..), Thirdly the constructors (new-vector3d) and (make-vector3d tuple), (make-vector3d-array dimensions &key adjustable fill-pointer),
Forthly generalised access as in (setf (vector3d array) tuple) and (setf (vector3d-aref array) index tuple),

Package
Source

tuples.lisp (file)

Macro: delta-vector3d* START END

DEF-TUPLE-OP DELTA-VECTOR3D* (VERTEX3D VERTEX3D)

Package
Source

vector.lisp (file)

Macro: disable-tuples-syntax ()
Package
Source

syntax.lisp (file)

Macro: enable-tuples-syntax ()
Package
Source

syntax.lisp (file)

Macro: file-enable-tuples-syntax ()
Package
Source

syntax.lisp (file)

Macro: identity-matrix44* ()

DEF-TUPLE-OP IDENTITY-MATRIX44* NIL

Package
Source

matrix.lisp (file)

Macro: inverted-matrix22* MAT

DEF-TUPLE-OP INVERTED-MATRIX22* (MATRIX22)

Package
Source

matrix.lisp (file)

Macro: inverted-matrix33* MAT

DEF-TUPLE-OP INVERTED-MATRIX33* (MATRIX33)

Package
Source

matrix.lisp (file)

Macro: inverted-matrix44* MAT

DEF-TUPLE-OP INVERTED-MATRIX44* (MATRIX44)

Package
Source

matrix.lisp (file)

Macro: locally-disable-tuples-syntax ()
Package
Source

syntax.lisp (file)

Macro: locally-enable-tuples-syntax ()
Package
Source

syntax.lisp (file)

Macro: make-aabb &rest ELEMENTS

Create an array sutable for holding a single AABB and initialize it from a multiple-values form

Package
Source

aabb.lisp (file)

Macro: make-aabb* TUPLE-VALUES

Create an array sutable for holding a single AABB and initialize it from a form

Package
Source

aabb.lisp (file)

Macro: make-angle-axis &rest ELEMENTS

Create an array sutable for holding a single ANGLE-AXIS and initialize it from a multiple-values form

Package
Source

quaternion.lisp (file)

Macro: make-angle-axis* TUPLE-VALUES

Create an array sutable for holding a single ANGLE-AXIS and initialize it from a form

Package
Source

quaternion.lisp (file)

Macro: make-colour &rest ELEMENTS

Create an array sutable for holding a single COLOUR and initialize it from a multiple-values form

Package
Source

colour.lisp (file)

Macro: make-colour* TUPLE-VALUES

Create an array sutable for holding a single COLOUR and initialize it from a form

Package
Source

colour.lisp (file)

Macro: make-matrix22 &rest ELEMENTS

Create an array sutable for holding a single MATRIX22 and initialize it from a multiple-values form

Package
Source

matrix.lisp (file)

Macro: make-matrix22* TUPLE-VALUES

Create an array sutable for holding a single MATRIX22 and initialize it from a form

Package
Source

matrix.lisp (file)

Macro: make-matrix33 &rest ELEMENTS

Create an array sutable for holding a single MATRIX33 and initialize it from a multiple-values form

Package
Source

matrix.lisp (file)

Macro: make-matrix33* TUPLE-VALUES

Create an array sutable for holding a single MATRIX33 and initialize it from a form

Package
Source

matrix.lisp (file)

Macro: make-matrix44 &rest ELEMENTS

Create an array sutable for holding a single MATRIX44 and initialize it from a multiple-values form

Package
Source

matrix.lisp (file)

Macro: make-matrix44* TUPLE-VALUES

Create an array sutable for holding a single MATRIX44 and initialize it from a form

Package
Source

matrix.lisp (file)

Macro: make-quaternion &rest ELEMENTS

Create an array sutable for holding a single QUATERNION and initialize it from a multiple-values form

Package
Source

quaternion.lisp (file)

Macro: make-quaternion* TUPLE-VALUES

Create an array sutable for holding a single QUATERNION and initialize it from a form

Package
Source

quaternion.lisp (file)

Macro: make-rect &rest ELEMENTS

Create an array sutable for holding a single RECT and initialize it from a multiple-values form

Package
Source

rect.lisp (file)

Macro: make-rect* TUPLE-VALUES

Create an array sutable for holding a single RECT and initialize it from a form

Package
Source

rect.lisp (file)

Macro: make-triangle &rest ELEMENTS

Create an array sutable for holding a single TRIANGLE and initialize it from a multiple-values form

Package
Source

triangle.lisp (file)

Macro: make-triangle* TUPLE-VALUES

Create an array sutable for holding a single TRIANGLE and initialize it from a form

Package
Source

triangle.lisp (file)

Macro: make-vector2d &rest ELEMENTS

Create an array sutable for holding a single VECTOR2D and initialize it from a multiple-values form

Package
Source

vector.lisp (file)

Macro: make-vector2d* TUPLE-VALUES

Create an array sutable for holding a single VECTOR2D and initialize it from a form

Package
Source

vector.lisp (file)

Macro: make-vector3d &rest ELEMENTS

Create an array sutable for holding a single VECTOR3D and initialize it from a multiple-values form

Package
Source

vector.lisp (file)

Macro: make-vector3d* TUPLE-VALUES

Create an array sutable for holding a single VECTOR3D and initialize it from a form

Package
Source

vector.lisp (file)

Macro: make-vertex3d &rest ELEMENTS

Create an array sutable for holding a single VERTEX3D and initialize it from a multiple-values form

Package
Source

vector.lisp (file)

Macro: make-vertex3d* TUPLE-VALUES

Create an array sutable for holding a single VERTEX3D and initialize it from a form

Package
Source

vector.lisp (file)

Macro: matrix22* TUPLE-ARRAY-NAME

Unpack array representation of an MATRIX22 and convert to multiple values.

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix22*) (setf expander)

Setf Expander: (setf matrix22*) TUPLE-PLACE TUPLE-VALUES
Package
Source

matrix.lisp (file)

matrix22* (macro)

Writer

matrix22-setter* (macro)

Macro: matrix22-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual MATRIX22 to multiple values from an array of MATRIX22s.

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix22-aref*) (setf expander)

Setf Expander: (setf matrix22-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

matrix.lisp (file)

matrix22-aref* (macro)

Writer

matrix22-aref-setter* (macro)

Macro: matrix22-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an MATRIX22 vector in a vector of MATRIX22s from a multiple values MATRIX22

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix22-aref*) (setf expander)

Macro: matrix22-determinant* MAT

DEF-TUPLE-OP MATRIX22-DETERMINANT* (MATRIX22)

Package
Source

matrix.lisp (file)

Macro: matrix22-key-values &key INITIAL-ELEMENT (E00 E00) (E01 E01) (E10 E10) (E11 E11)
Package
Source

matrix.lisp (file)

Macro: matrix22-map* OPERATOR &rest ARGS
Package
Source

matrix.lisp (file)

Macro: matrix22-reduce* OPERATOR TUPLE
Package
Source

matrix.lisp (file)

Macro: matrix22-scale* X MAT

DEF-TUPLE-OP MATRIX22-SCALE* (FAST-FLOAT MATRIX22)

Package
Source

matrix.lisp (file)

Macro: matrix22-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an MATRIX22 vector from a multiple values MATRIX22

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix22*) (setf expander)

Macro: matrix22-values* &rest ELEMENTS

Convert MATRIX22 forms to multiple values.

Package
Source

matrix.lisp (file)

Macro: matrix22-vector-push* TUPLE-VALUES ARRAY-NAME

Push a MATRIX22 multiple value onto the end of a vector of MATRIX22’s

Package
Source

matrix.lisp (file)

Macro: matrix22-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a MATRIX22 multiple value onto the end of a vector of MATRIX22’s with the possibility of extension

Package
Source

matrix.lisp (file)

Macro: matrix33* TUPLE-ARRAY-NAME

Unpack array representation of an MATRIX33 and convert to multiple values.

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix33*) (setf expander)

Setf Expander: (setf matrix33*) TUPLE-PLACE TUPLE-VALUES
Package
Source

matrix.lisp (file)

matrix33* (macro)

Writer

matrix33-setter* (macro)

Macro: matrix33-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual MATRIX33 to multiple values from an array of MATRIX33s.

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix33-aref*) (setf expander)

Setf Expander: (setf matrix33-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

matrix.lisp (file)

matrix33-aref* (macro)

Writer

matrix33-aref-setter* (macro)

Macro: matrix33-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an MATRIX33 vector in a vector of MATRIX33s from a multiple values MATRIX33

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix33-aref*) (setf expander)

Macro: matrix33-determinant* MAT

DEF-TUPLE-OP MATRIX33-DETERMINANT* (MATRIX33)

Package
Source

matrix.lisp (file)

Macro: matrix33-key-values &key INITIAL-ELEMENT (E00 E00) (E01 E01) (E02 E02) (E10 E10) (E11 E11) (E12 E12) (E20 E20) (E21 E21) (E22 E22)
Package
Source

matrix.lisp (file)

Macro: matrix33-map* OPERATOR &rest ARGS
Package
Source

matrix.lisp (file)

Macro: matrix33-matrix44* MAT3

Convert a 3x3 matrix to a 4x4 matrix

Package
Source

matrix.lisp (file)

Macro: matrix33-product* M0 M1

DEF-TUPLE-OP MATRIX33-PRODUCT* (MATRIX33 MATRIX33)

Package
Source

matrix.lisp (file)

Macro: matrix33-reduce* OPERATOR TUPLE
Package
Source

matrix.lisp (file)

Macro: matrix33-scale* X MAT

DEF-TUPLE-OP MATRIX33-SCALE* (FAST-FLOAT MATRIX33)

Package
Source

matrix.lisp (file)

Macro: matrix33-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an MATRIX33 vector from a multiple values MATRIX33

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix33*) (setf expander)

Macro: matrix33-values* &rest ELEMENTS

Convert MATRIX33 forms to multiple values.

Package
Source

matrix.lisp (file)

Macro: matrix33-vector-push* TUPLE-VALUES ARRAY-NAME

Push a MATRIX33 multiple value onto the end of a vector of MATRIX33’s

Package
Source

matrix.lisp (file)

Macro: matrix33-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a MATRIX33 multiple value onto the end of a vector of MATRIX33’s with the possibility of extension

Package
Source

matrix.lisp (file)

Macro: matrix44* TUPLE-ARRAY-NAME

Unpack array representation of an MATRIX44 and convert to multiple values.

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix44*) (setf expander)

Setf Expander: (setf matrix44*) TUPLE-PLACE TUPLE-VALUES
Package
Source

matrix.lisp (file)

matrix44* (macro)

Writer

matrix44-setter* (macro)

Macro: matrix44-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual MATRIX44 to multiple values from an array of MATRIX44s.

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix44-aref*) (setf expander)

Setf Expander: (setf matrix44-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

matrix.lisp (file)

matrix44-aref* (macro)

Writer

matrix44-aref-setter* (macro)

Macro: matrix44-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an MATRIX44 vector in a vector of MATRIX44s from a multiple values MATRIX44

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix44-aref*) (setf expander)

Macro: matrix44-determinant* MAT

DEF-TUPLE-OP MATRIX44-DETERMINANT* (MATRIX44)

Package
Source

matrix.lisp (file)

Macro: matrix44-key-values &key INITIAL-ELEMENT (E00 E00) (E01 E01) (E02 E02) (E03 E03) (E10 E10) (E11 E11) (E12 E12) (E13 E13) (E20 E20) (E21 E21) (E22 E22) (E23 E23) (E30 E30) (E31 E31) (E32 E32) (E33 E33)
Package
Source

matrix.lisp (file)

Macro: matrix44-map* OPERATOR &rest ARGS
Package
Source

matrix.lisp (file)

Macro: matrix44-matrix33* MAT44

Convert a 4x4 matrix to a 3x3 matrix

Package
Source

matrix.lisp (file)

Macro: matrix44-product* M0 M1

DEF-TUPLE-OP MATRIX44-PRODUCT* (MATRIX44 MATRIX44)

Package
Source

matrix.lisp (file)

Macro: matrix44-reduce* OPERATOR TUPLE
Package
Source

matrix.lisp (file)

Macro: matrix44-scale* X MAT

DEF-TUPLE-OP MATRIX44-SCALE* (FAST-FLOAT MATRIX44)

Package
Source

matrix.lisp (file)

Macro: matrix44-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an MATRIX44 vector from a multiple values MATRIX44

Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix44*) (setf expander)

Macro: matrix44-values* &rest ELEMENTS

Convert MATRIX44 forms to multiple values.

Package
Source

matrix.lisp (file)

Macro: matrix44-vector-push* TUPLE-VALUES ARRAY-NAME

Push a MATRIX44 multiple value onto the end of a vector of MATRIX44’s

Package
Source

matrix.lisp (file)

Macro: matrix44-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a MATRIX44 multiple value onto the end of a vector of MATRIX44’s with the possibility of extension

Package
Source

matrix.lisp (file)

Macro: new-aabb ()

Create an array suitable for holding a single AABB

Package
Source

aabb.lisp (file)

Macro: new-angle-axis ()

Create an array suitable for holding a single ANGLE-AXIS

Package
Source

quaternion.lisp (file)

Macro: new-colour ()

Create an array suitable for holding a single COLOUR

Package
Source

colour.lisp (file)

Macro: new-matrix22 ()

Create an array suitable for holding a single MATRIX22

Package
Source

matrix.lisp (file)

Macro: new-matrix33 ()

Create an array suitable for holding a single MATRIX33

Package
Source

matrix.lisp (file)

Macro: new-matrix44 ()

Create an array suitable for holding a single MATRIX44

Package
Source

matrix.lisp (file)

Macro: new-quaternion ()

Create an array suitable for holding a single QUATERNION

Package
Source

quaternion.lisp (file)

Macro: new-rect ()

Create an array suitable for holding a single RECT

Package
Source

rect.lisp (file)

Macro: new-triangle ()

Create an array suitable for holding a single TRIANGLE

Package
Source

triangle.lisp (file)

Macro: new-vector2d ()

Create an array suitable for holding a single VECTOR2D

Package
Source

vector.lisp (file)

Macro: new-vector3d ()

Create an array suitable for holding a single VECTOR3D

Package
Source

vector.lisp (file)

Macro: new-vertex3d ()

Create an array suitable for holding a single VERTEX3D

Package
Source

vector.lisp (file)

Macro: print-matrix22* STREAM MAT

Print a 2x2 matrix in a useful format.

Package
Source

matrix.lisp (file)

Macro: print-matrix33* STREAM MAT

Print a 3x3 matrix in a useful format.

Package
Source

matrix.lisp (file)

Macro: print-matrix44* STREAM MAT

Print a 4x4 matrix in a useful format.

Package
Source

matrix.lisp (file)

Macro: quaternion* TUPLE-ARRAY-NAME

Unpack array representation of an QUATERNION and convert to multiple values.

Package
Source

quaternion.lisp (file)

Setf Expander

(setf quaternion*) (setf expander)

Setf Expander: (setf quaternion*) TUPLE-PLACE TUPLE-VALUES
Package
Source

quaternion.lisp (file)

quaternion* (macro)

Writer

quaternion-setter* (macro)

Macro: quaternion-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual QUATERNION to multiple values from an array of QUATERNIONs.

Package
Source

quaternion.lisp (file)

Setf Expander

(setf quaternion-aref*) (setf expander)

Setf Expander: (setf quaternion-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

quaternion.lisp (file)

quaternion-aref* (macro)

Writer

quaternion-aref-setter* (macro)

Macro: quaternion-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an QUATERNION vector in a vector of QUATERNIONs from a multiple values QUATERNION

Package
Source

quaternion.lisp (file)

Setf Expander

(setf quaternion-aref*) (setf expander)

Macro: quaternion-conjugate* Q

DEF-TUPLE-OP QUATERNION-CONJUGATE* (QUATERNION)

Package
Source

quaternion.lisp (file)

Macro: quaternion-dot* Q0 Q1

Dot product of two quaternions.

Package
Source

quaternion.lisp (file)

Macro: quaternion-inverse* Q

Inverse of quaternion

Package
Source

quaternion.lisp (file)

Macro: quaternion-key-values &key INITIAL-ELEMENT (X X) (Y Y) (Z Z) (W W)
Package
Source

quaternion.lisp (file)

Macro: quaternion-mag* Q

DEF-TUPLE-OP QUATERNION-MAG* (QUATERNION)

Package
Source

quaternion.lisp (file)

Macro: quaternion-mag-square* Q

DEF-TUPLE-OP QUATERNION-MAG-SQUARE* (QUATERNION)

Package
Source

quaternion.lisp (file)

Macro: quaternion-map* OPERATOR &rest ARGS
Package
Source

quaternion.lisp (file)

Macro: quaternion-matrix33* Q

Convert a quaternion to a 3x3 rotation matrix.

Package
Source

quaternion.lisp (file)

Macro: quaternion-normalize* Q

Ensure a quaternion is a unit

Package
Source

quaternion.lisp (file)

Macro: quaternion-product* Q-LHS Q-RHS

Multiple of two quaternions

Package
Source

quaternion.lisp (file)

Macro: quaternion-reduce* OPERATOR TUPLE
Package
Source

quaternion.lisp (file)

Macro: quaternion-scale* Q S

Multiply a quat by a scalar

Package
Source

quaternion.lisp (file)

Macro: quaternion-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an QUATERNION vector from a multiple values QUATERNION

Package
Source

quaternion.lisp (file)

Setf Expander

(setf quaternion*) (setf expander)

Macro: quaternion-sum* Q0 Q1

Sum the components of two quaternions

Package
Source

quaternion.lisp (file)

Macro: quaternion-transform-vector3d* VECTOR QUAT

Transform a 3d vector with a quaternion

Package
Source

quaternion.lisp (file)

Macro: quaternion-values* &rest ELEMENTS

Convert QUATERNION forms to multiple values.

Package
Source

quaternion.lisp (file)

Macro: quaternion-vector-push* TUPLE-VALUES ARRAY-NAME

Push a QUATERNION multiple value onto the end of a vector of QUATERNION’s

Package
Source

quaternion.lisp (file)

Macro: quaternion-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a QUATERNION multiple value onto the end of a vector of QUATERNION’s with the possibility of extension

Package
Source

quaternion.lisp (file)

Macro: rect* TUPLE-ARRAY-NAME

Unpack array representation of an RECT and convert to multiple values.

Package
Source

rect.lisp (file)

Setf Expander

(setf rect*) (setf expander)

Setf Expander: (setf rect*) TUPLE-PLACE TUPLE-VALUES
Package
Source

rect.lisp (file)

rect* (macro)

Writer

rect-setter* (macro)

Macro: rect-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual RECT to multiple values from an array of RECTs.

Package
Source

rect.lisp (file)

Setf Expander

(setf rect-aref*) (setf expander)

Setf Expander: (setf rect-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

rect.lisp (file)

rect-aref* (macro)

Writer

rect-aref-setter* (macro)

Macro: rect-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an RECT vector in a vector of RECTs from a multiple values RECT

Package
Source

rect.lisp (file)

Setf Expander

(setf rect-aref*) (setf expander)

Macro: rect-key-values &key INITIAL-ELEMENT (LEFT LEFT) (RIGHT RIGHT) (TOP TOP) (BOTTOM BOTTOM)
Package
Source

rect.lisp (file)

Macro: rect-map* OPERATOR &rest ARGS
Package
Source

rect.lisp (file)

Macro: rect-reduce* OPERATOR TUPLE
Package
Source

rect.lisp (file)

Macro: rect-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an RECT vector from a multiple values RECT

Package
Source

rect.lisp (file)

Setf Expander

(setf rect*) (setf expander)

Macro: rect-values* &rest ELEMENTS

Convert RECT forms to multiple values.

Package
Source

rect.lisp (file)

Macro: rect-vector-push* TUPLE-VALUES ARRAY-NAME

Push a RECT multiple value onto the end of a vector of RECT’s

Package
Source

rect.lisp (file)

Macro: rect-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a RECT multiple value onto the end of a vector of RECT’s with the possibility of extension

Package
Source

rect.lisp (file)

Macro: restore-tuples-syntax-state ()
Package
Source

syntax.lisp (file)

Macro: rotatex-matrix44* ROTATION

Return a matrix for rotating around the x axis.

Package
Source

matrix.lisp (file)

Macro: rotatey-matrix44* ROTATION

Return a matrix for rotating around the y axis.

Package
Source

matrix.lisp (file)

Macro: rotatez-matrix44* ROTATION

Return a matrix for rotating around the z axis.

Package
Source

matrix.lisp (file)

Macro: scaling-matrix44* SX SY SZ

DEF-TUPLE-OP SCALING-MATRIX44* (FAST-FLOAT FAST-FLOAT FAST-FLOAT)

Package
Source

matrix.lisp (file)

Macro: transform-vector2d* MAT VEC

DEF-TUPLE-OP TRANSFORM-VECTOR2D* (MATRIX33 VECTOR2D)

Package
Source

matrix.lisp (file)

Macro: transform-vector3d* MAT VECT

DEF-TUPLE-OP TRANSFORM-VECTOR3D* (MATRIX33 VECTOR3D)

Package
Source

matrix.lisp (file)

Macro: transform-vertex2d* MAT VERT

DEF-TUPLE-OP TRANSFORM-VERTEX2D* (MATRIX33 VECTOR2D)

Package
Source

matrix.lisp (file)

Macro: transform-vertex3d* MAT VERT

DEF-TUPLE-OP TRANSFORM-VERTEX3D* (MATRIX44 VERTEX3D)

Package
Source

matrix.lisp (file)

Macro: translation-matrix44* TX TY TZ

Return a matrix that represents a translation transformation

Package
Source

matrix.lisp (file)

Macro: transpose-matrix33* MAT33

Return the transpose of the matrix

Package
Source

matrix.lisp (file)

Macro: transpose-matrix44* MAT44

Return the transpose of the matrix

Package
Source

matrix.lisp (file)

Macro: triangle* TUPLE-ARRAY-NAME

Unpack array representation of an TRIANGLE and convert to multiple values.

Package
Source

triangle.lisp (file)

Setf Expander

(setf triangle*) (setf expander)

Setf Expander: (setf triangle*) TUPLE-PLACE TUPLE-VALUES
Package
Source

triangle.lisp (file)

triangle* (macro)

Writer

triangle-setter* (macro)

Macro: triangle-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual TRIANGLE to multiple values from an array of TRIANGLEs.

Package
Source

triangle.lisp (file)

Setf Expander

(setf triangle-aref*) (setf expander)

Setf Expander: (setf triangle-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

triangle.lisp (file)

triangle-aref* (macro)

Writer

triangle-aref-setter* (macro)

Macro: triangle-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an TRIANGLE vector in a vector of TRIANGLEs from a multiple values TRIANGLE

Package
Source

triangle.lisp (file)

Setf Expander

(setf triangle-aref*) (setf expander)

Macro: triangle-key-values &key INITIAL-ELEMENT (A A) (B B) (C C)
Package
Source

triangle.lisp (file)

Macro: triangle-map* OPERATOR &rest ARGS
Package
Source

triangle.lisp (file)

Macro: triangle-reduce* OPERATOR TUPLE
Package
Source

triangle.lisp (file)

Macro: triangle-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an TRIANGLE vector from a multiple values TRIANGLE

Package
Source

triangle.lisp (file)

Setf Expander

(setf triangle*) (setf expander)

Macro: triangle-values* &rest ELEMENTS

Convert TRIANGLE forms to multiple values.

Package
Source

triangle.lisp (file)

Macro: triangle-vector-push* TUPLE-VALUES ARRAY-NAME

Push a TRIANGLE multiple value onto the end of a vector of TRIANGLE’s

Package
Source

triangle.lisp (file)

Macro: triangle-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a TRIANGLE multiple value onto the end of a vector of TRIANGLE’s with the possibility of extension

Package
Source

triangle.lisp (file)

Macro: vector2d* TUPLE-ARRAY-NAME

Unpack array representation of an VECTOR2D and convert to multiple values.

Package
Source

vector.lisp (file)

Setf Expander

(setf vector2d*) (setf expander)

Setf Expander: (setf vector2d*) TUPLE-PLACE TUPLE-VALUES
Package
Source

vector.lisp (file)

vector2d* (macro)

Writer

vector2d-setter* (macro)

Macro: vector2d-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual VECTOR2D to multiple values from an array of VECTOR2Ds.

Package
Source

vector.lisp (file)

Setf Expander

(setf vector2d-aref*) (setf expander)

Setf Expander: (setf vector2d-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

vector.lisp (file)

vector2d-aref* (macro)

Writer

vector2d-aref-setter* (macro)

Macro: vector2d-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an VECTOR2D vector in a vector of VECTOR2Ds from a multiple values VECTOR2D

Package
Source

vector.lisp (file)

Setf Expander

(setf vector2d-aref*) (setf expander)

Macro: vector2d-dot* VECA VECB

DEF-TUPLE-OP VECTOR2D-DOT* (VECTOR2D VECTOR2D)

Package
Source

vector.lisp (file)

Macro: vector2d-key-values &key INITIAL-ELEMENT (X X) (Y Y)
Package
Source

vector.lisp (file)

Macro: vector2d-length* VEC

DEF-TUPLE-OP VECTOR2D-LENGTH* (VECTOR2D)

Package
Source

vector.lisp (file)

Macro: vector2d-map* OPERATOR &rest ARGS
Package
Source

vector.lisp (file)

Macro: vector2d-normal* VEC

DEF-TUPLE-OP VECTOR2D-NORMAL* (VECTOR2D)

Package
Source

vector.lisp (file)

Macro: vector2d-reduce* OPERATOR TUPLE
Package
Source

vector.lisp (file)

Macro: vector2d-scale* VEC S

DEF-TUPLE-OP VECTOR2D-SCALE* (VECTOR2D FAST-FLOAT)

Package
Source

vector.lisp (file)

Macro: vector2d-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an VECTOR2D vector from a multiple values VECTOR2D

Package
Source

vector.lisp (file)

Setf Expander

(setf vector2d*) (setf expander)

Macro: vector2d-values* &rest ELEMENTS

Convert VECTOR2D forms to multiple values.

Package
Source

vector.lisp (file)

Macro: vector2d-vector-push* TUPLE-VALUES ARRAY-NAME

Push a VECTOR2D multiple value onto the end of a vector of VECTOR2D’s

Package
Source

vector.lisp (file)

Macro: vector2d-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a VECTOR2D multiple value onto the end of a vector of VECTOR2D’s with the possibility of extension

Package
Source

vector.lisp (file)

Macro: vector2d-vertex2d* VEC

DEF-TUPLE-OP VECTOR2D-VERTEX2D* (VECTOR2D)

Package
Source

vector.lisp (file)

Macro: vector3d* TUPLE-ARRAY-NAME

Unpack array representation of an VECTOR3D and convert to multiple values.

Package
Source

vector.lisp (file)

Setf Expander

(setf vector3d*) (setf expander)

Setf Expander: (setf vector3d*) TUPLE-PLACE TUPLE-VALUES
Package
Source

vector.lisp (file)

vector3d* (macro)

Writer

vector3d-setter* (macro)

Macro: vector3d-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual VECTOR3D to multiple values from an array of VECTOR3Ds.

Package
Source

vector.lisp (file)

Setf Expander

(setf vector3d-aref*) (setf expander)

Setf Expander: (setf vector3d-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

vector.lisp (file)

vector3d-aref* (macro)

Writer

vector3d-aref-setter* (macro)

Macro: vector3d-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an VECTOR3D vector in a vector of VECTOR3Ds from a multiple values VECTOR3D

Package
Source

vector.lisp (file)

Setf Expander

(setf vector3d-aref*) (setf expander)

Macro: vector3d-cross* LHS RHS

DEF-TUPLE-OP VECTOR3D-CROSS* (VECTOR3D VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vector3d-difference* VECA VECB

DEF-TUPLE-OP VECTOR3D-DIFFERENCE* (VECTOR3D VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vector3d-dot* VECA VECB

DEF-TUPLE-OP VECTOR3D-DOT* (VECTOR3D VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vector3d-key-values &key INITIAL-ELEMENT (X X) (Y Y) (Z Z)
Package
Source

vector.lisp (file)

Macro: vector3d-length* VEC

DEF-TUPLE-OP VECTOR3D-LENGTH* (VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vector3d-map* OPERATOR &rest ARGS
Package
Source

vector.lisp (file)

Macro: vector3d-normal* VEC

DEF-TUPLE-OP VECTOR3D-NORMAL* (VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vector3d-quaternion* VECTOR

Convert a 3d vector into q auqt for angular velocity purposes

Package
Source

quaternion.lisp (file)

Macro: vector3d-reduce* OPERATOR TUPLE
Package
Source

vector.lisp (file)

Macro: vector3d-scale* VEC S

DEF-TUPLE-OP VECTOR3D-SCALE* (VECTOR3D FAST-FLOAT)

Package
Source

vector.lisp (file)

Macro: vector3d-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an VECTOR3D vector from a multiple values VECTOR3D

Package
Source

vector.lisp (file)

Setf Expander

(setf vector3d*) (setf expander)

Macro: vector3d-sum* VECA VECB

DEF-TUPLE-OP VECTOR3D-SUM* (VECTOR3D VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vector3d-values* &rest ELEMENTS

Convert VECTOR3D forms to multiple values.

Package
Source

vector.lisp (file)

Macro: vector3d-vector-push* TUPLE-VALUES ARRAY-NAME

Push a VECTOR3D multiple value onto the end of a vector of VECTOR3D’s

Package
Source

vector.lisp (file)

Macro: vector3d-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a VECTOR3D multiple value onto the end of a vector of VECTOR3D’s with the possibility of extension

Package
Source

vector.lisp (file)

Macro: vector3d-vertex3d* VEC

DEF-TUPLE-OP VECTOR3D-VERTEX3D* (VECTOR3D)

Package
Source

vector.lisp (file)

Macro: vertex2d-vector2d* VERT

DEF-TUPLE-OP VERTEX2D-VECTOR2D* (VERTEX2D)

Package
Source

vector.lisp (file)

Macro: vertex3d* TUPLE-ARRAY-NAME

Unpack array representation of an VERTEX3D and convert to multiple values.

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex3d*) (setf expander)

Setf Expander: (setf vertex3d*) TUPLE-PLACE TUPLE-VALUES
Package
Source

vector.lisp (file)

vertex3d* (macro)

Writer

vertex3d-setter* (macro)

Macro: vertex3d-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual VERTEX3D to multiple values from an array of VERTEX3Ds.

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex3d-aref*) (setf expander)

Setf Expander: (setf vertex3d-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

vector.lisp (file)

vertex3d-aref* (macro)

Writer

vertex3d-aref-setter* (macro)

Macro: vertex3d-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an VERTEX3D vector in a vector of VERTEX3Ds from a multiple values VERTEX3D

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex3d-aref*) (setf expander)

Macro: vertex3d-distance* START END

DEF-TUPLE-OP VERTEX3D-DISTANCE* (VERTEX3D VERTEX3D)

Package
Source

vector.lisp (file)

Macro: vertex3d-key-values &key INITIAL-ELEMENT (X X) (Y Y) (Z Z) (W W)
Package
Source

vector.lisp (file)

Macro: vertex3d-map* OPERATOR &rest ARGS
Package
Source

vector.lisp (file)

Macro: vertex3d-reduce* OPERATOR TUPLE
Package
Source

vector.lisp (file)

Macro: vertex3d-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an VERTEX3D vector from a multiple values VERTEX3D

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex3d*) (setf expander)

Macro: vertex3d-translation-matrix44* VERT

Return a matrix that represents a translation transformation

Package
Source

matrix.lisp (file)

Macro: vertex3d-values* &rest ELEMENTS

Convert VERTEX3D forms to multiple values.

Package
Source

vector.lisp (file)

Macro: vertex3d-vector-push* TUPLE-VALUES ARRAY-NAME

Push a VERTEX3D multiple value onto the end of a vector of VERTEX3D’s

Package
Source

vector.lisp (file)

Macro: vertex3d-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a VERTEX3D multiple value onto the end of a vector of VERTEX3D’s with the possibility of extension

Package
Source

vector.lisp (file)

Macro: vertex3d-vector3d* VERT

DEF-TUPLE-OP VERTEX3D-VECTOR3D* (VERTEX3D)

Package
Source

vector.lisp (file)

Macro: with-aabb TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a AABB multiple value to symbols.

Package
Source

aabb.lisp (file)

Macro: with-aabb* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a AABB vector to symbols.

Package
Source

aabb.lisp (file)

Macro: with-aabb-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a AABB from vector of AABB’s to symbols

Package
Source

aabb.lisp (file)

Macro: with-angle-axis TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a ANGLE-AXIS multiple value to symbols.

Package
Source

quaternion.lisp (file)

Macro: with-angle-axis* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a ANGLE-AXIS vector to symbols.

Package
Source

quaternion.lisp (file)

Macro: with-angle-axis-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a ANGLE-AXIS from vector of ANGLE-AXIS’s to symbols

Package
Source

quaternion.lisp (file)

Macro: with-colour TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a COLOUR multiple value to symbols.

Package
Source

colour.lisp (file)

Macro: with-colour* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a COLOUR vector to symbols.

Package
Source

colour.lisp (file)

Macro: with-colour-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a COLOUR from vector of COLOUR’s to symbols

Package
Source

colour.lisp (file)

Macro: with-matrix22 TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a MATRIX22 multiple value to symbols.

Package
Source

matrix.lisp (file)

Macro: with-matrix22* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a MATRIX22 vector to symbols.

Package
Source

matrix.lisp (file)

Macro: with-matrix22-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a MATRIX22 from vector of MATRIX22’s to symbols

Package
Source

matrix.lisp (file)

Macro: with-matrix33 TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a MATRIX33 multiple value to symbols.

Package
Source

matrix.lisp (file)

Macro: with-matrix33* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a MATRIX33 vector to symbols.

Package
Source

matrix.lisp (file)

Macro: with-matrix33-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a MATRIX33 from vector of MATRIX33’s to symbols

Package
Source

matrix.lisp (file)

Macro: with-matrix44 TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a MATRIX44 multiple value to symbols.

Package
Source

matrix.lisp (file)

Macro: with-matrix44* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a MATRIX44 vector to symbols.

Package
Source

matrix.lisp (file)

Macro: with-matrix44-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a MATRIX44 from vector of MATRIX44’s to symbols

Package
Source

matrix.lisp (file)

Macro: with-quaternion TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a QUATERNION multiple value to symbols.

Package
Source

quaternion.lisp (file)

Macro: with-quaternion* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a QUATERNION vector to symbols.

Package
Source

quaternion.lisp (file)

Macro: with-quaternion-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a QUATERNION from vector of QUATERNION’s to symbols

Package
Source

quaternion.lisp (file)

Macro: with-rect TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a RECT multiple value to symbols.

Package
Source

rect.lisp (file)

Macro: with-rect* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a RECT vector to symbols.

Package
Source

rect.lisp (file)

Macro: with-rect-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a RECT from vector of RECT’s to symbols

Package
Source

rect.lisp (file)

Macro: with-triangle TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a TRIANGLE multiple value to symbols.

Package
Source

triangle.lisp (file)

Macro: with-triangle* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a TRIANGLE vector to symbols.

Package
Source

triangle.lisp (file)

Macro: with-triangle-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a TRIANGLE from vector of TRIANGLE’s to symbols

Package
Source

triangle.lisp (file)

Macro: with-vector2d TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a VECTOR2D multiple value to symbols.

Package
Source

vector.lisp (file)

Macro: with-vector2d* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a VECTOR2D vector to symbols.

Package
Source

vector.lisp (file)

Macro: with-vector2d-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a VECTOR2D from vector of VECTOR2D’s to symbols

Package
Source

vector.lisp (file)

Macro: with-vector3d TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a VECTOR3D multiple value to symbols.

Package
Source

vector.lisp (file)

Macro: with-vector3d* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a VECTOR3D vector to symbols.

Package
Source

vector.lisp (file)

Macro: with-vector3d-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a VECTOR3D from vector of VECTOR3D’s to symbols

Package
Source

vector.lisp (file)

Macro: with-vertex3d TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a VERTEX3D multiple value to symbols.

Package
Source

vector.lisp (file)

Macro: with-vertex3d* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a VERTEX3D vector to symbols.

Package
Source

vector.lisp (file)

Macro: with-vertex3d-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a VERTEX3D from vector of VERTEX3D’s to symbols

Package
Source

vector.lisp (file)

Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Functions

Function: aabb-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

aabb.lisp (file)

Setf Expander

(setf aabb-aref) (setf expander)

Setf Expander: (setf aabb-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

aabb.lisp (file)

aabb-aref (function)

Writer

aabb-aref-setter (function)

Function: aabb-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

aabb.lisp (file)

Setf Expander

(setf aabb-aref) (setf expander)

Function: aabb-array-dimensions TUPLE-ARRAY

Return the size of a vector of AABB’s (ie how many AABB’s it contains)

Package
Source

aabb.lisp (file)

Function: aabb-fill-pointer TUPLE-ARRAY
Function: (setf aabb-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

aabb.lisp (file)

Function: aabb-vector-push TUPLE ARRAY-NAME
Package
Source

aabb.lisp (file)

Function: aabb-vector-push-extend TUPLE ARRAY-NAME
Package
Source

aabb.lisp (file)

Function: angle-axis-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

quaternion.lisp (file)

Setf Expander

(setf angle-axis-aref) (setf expander)

Setf Expander: (setf angle-axis-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

quaternion.lisp (file)

angle-axis-aref (function)

Writer

angle-axis-aref-setter (function)

Function: angle-axis-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

quaternion.lisp (file)

Setf Expander

(setf angle-axis-aref) (setf expander)

Function: angle-axis-array-dimensions TUPLE-ARRAY

Return the size of a vector of ANGLE-AXIS’s (ie how many ANGLE-AXIS’s it contains)

Package
Source

quaternion.lisp (file)

Function: angle-axis-fill-pointer TUPLE-ARRAY
Function: (setf angle-axis-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

quaternion.lisp (file)

Function: angle-axis-vector-push TUPLE ARRAY-NAME
Package
Source

quaternion.lisp (file)

Function: angle-axis-vector-push-extend TUPLE ARRAY-NAME
Package
Source

quaternion.lisp (file)

Function: colour-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

colour.lisp (file)

Setf Expander

(setf colour-aref) (setf expander)

Setf Expander: (setf colour-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

colour.lisp (file)

colour-aref (function)

Writer

colour-aref-setter (function)

Function: colour-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

colour.lisp (file)

Setf Expander

(setf colour-aref) (setf expander)

Function: colour-array-dimensions TUPLE-ARRAY

Return the size of a vector of COLOUR’s (ie how many COLOUR’s it contains)

Package
Source

colour.lisp (file)

Function: colour-fill-pointer TUPLE-ARRAY
Function: (setf colour-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

colour.lisp (file)

Function: colour-vector-push TUPLE ARRAY-NAME
Package
Source

colour.lisp (file)

Function: colour-vector-push-extend TUPLE ARRAY-NAME
Package
Source

colour.lisp (file)

Function: make-aabb-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of AABB’s

Package
Source

aabb.lisp (file)

Function: make-angle-axis-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of ANGLE-AXIS’s

Package
Source

quaternion.lisp (file)

Function: make-colour-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of COLOUR’s

Package
Source

colour.lisp (file)

Function: make-matrix22-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of MATRIX22’s

Package
Source

matrix.lisp (file)

Function: make-matrix33-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of MATRIX33’s

Package
Source

matrix.lisp (file)

Function: make-matrix44-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of MATRIX44’s

Package
Source

matrix.lisp (file)

Function: make-quaternion-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of QUATERNION’s

Package
Source

quaternion.lisp (file)

Function: make-rect-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of RECT’s

Package
Source

rect.lisp (file)

Function: make-triangle-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of TRIANGLE’s

Package
Source

triangle.lisp (file)

Function: make-tuple-symbol TYPE-NAME TUPLE-ELEMENT-TYPE TUPLE-INITIAL-ELEMENT ELEMENTS

Makes a symbol used to identify a tuple type and interns it in the package used for holding metadata about the tuple types. Information about the tuple type is stored in the property list of the symbol.

Package
Source

symbols.lisp (file)

Function: make-vector2d-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of VECTOR2D’s

Package
Source

vector.lisp (file)

Function: make-vector3d-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of VECTOR3D’s

Package
Source

vector.lisp (file)

Function: make-vertex3d-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of VERTEX3D’s

Package
Source

vector.lisp (file)

Function: matrix22-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix22-aref) (setf expander)

Setf Expander: (setf matrix22-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

matrix.lisp (file)

matrix22-aref (function)

Writer

matrix22-aref-setter (function)

Function: matrix22-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix22-aref) (setf expander)

Function: matrix22-array-dimensions TUPLE-ARRAY

Return the size of a vector of MATRIX22’s (ie how many MATRIX22’s it contains)

Package
Source

matrix.lisp (file)

Function: matrix22-fill-pointer TUPLE-ARRAY
Function: (setf matrix22-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

matrix.lisp (file)

Function: matrix22-vector-push TUPLE ARRAY-NAME
Package
Source

matrix.lisp (file)

Function: matrix22-vector-push-extend TUPLE ARRAY-NAME
Package
Source

matrix.lisp (file)

Function: matrix33-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix33-aref) (setf expander)

Setf Expander: (setf matrix33-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

matrix.lisp (file)

matrix33-aref (function)

Writer

matrix33-aref-setter (function)

Function: matrix33-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix33-aref) (setf expander)

Function: matrix33-array-dimensions TUPLE-ARRAY

Return the size of a vector of MATRIX33’s (ie how many MATRIX33’s it contains)

Package
Source

matrix.lisp (file)

Function: matrix33-fill-pointer TUPLE-ARRAY
Function: (setf matrix33-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

matrix.lisp (file)

Function: matrix33-vector-push TUPLE ARRAY-NAME
Package
Source

matrix.lisp (file)

Function: matrix33-vector-push-extend TUPLE ARRAY-NAME
Package
Source

matrix.lisp (file)

Function: matrix44-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix44-aref) (setf expander)

Setf Expander: (setf matrix44-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

matrix.lisp (file)

matrix44-aref (function)

Writer

matrix44-aref-setter (function)

Function: matrix44-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

matrix.lisp (file)

Setf Expander

(setf matrix44-aref) (setf expander)

Function: matrix44-array-dimensions TUPLE-ARRAY

Return the size of a vector of MATRIX44’s (ie how many MATRIX44’s it contains)

Package
Source

matrix.lisp (file)

Function: matrix44-fill-pointer TUPLE-ARRAY
Function: (setf matrix44-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

matrix.lisp (file)

Function: matrix44-vector-push TUPLE ARRAY-NAME
Package
Source

matrix.lisp (file)

Function: matrix44-vector-push-extend TUPLE ARRAY-NAME
Package
Source

matrix.lisp (file)

Function: quaternion-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

quaternion.lisp (file)

Setf Expander

(setf quaternion-aref) (setf expander)

Setf Expander: (setf quaternion-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

quaternion.lisp (file)

quaternion-aref (function)

Writer

quaternion-aref-setter (function)

Function: quaternion-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

quaternion.lisp (file)

Setf Expander

(setf quaternion-aref) (setf expander)

Function: quaternion-array-dimensions TUPLE-ARRAY

Return the size of a vector of QUATERNION’s (ie how many QUATERNION’s it contains)

Package
Source

quaternion.lisp (file)

Function: quaternion-fill-pointer TUPLE-ARRAY
Function: (setf quaternion-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

quaternion.lisp (file)

Function: quaternion-vector-push TUPLE ARRAY-NAME
Package
Source

quaternion.lisp (file)

Function: quaternion-vector-push-extend TUPLE ARRAY-NAME
Package
Source

quaternion.lisp (file)

Function: rect-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

rect.lisp (file)

Setf Expander

(setf rect-aref) (setf expander)

Setf Expander: (setf rect-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

rect.lisp (file)

rect-aref (function)

Writer

rect-aref-setter (function)

Function: rect-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

rect.lisp (file)

Setf Expander

(setf rect-aref) (setf expander)

Function: rect-array-dimensions TUPLE-ARRAY

Return the size of a vector of RECT’s (ie how many RECT’s it contains)

Package
Source

rect.lisp (file)

Function: rect-fill-pointer TUPLE-ARRAY
Function: (setf rect-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

rect.lisp (file)

Function: rect-vector-push TUPLE ARRAY-NAME
Package
Source

rect.lisp (file)

Function: rect-vector-push-extend TUPLE ARRAY-NAME
Package
Source

rect.lisp (file)

Function: triangle-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

triangle.lisp (file)

Setf Expander

(setf triangle-aref) (setf expander)

Setf Expander: (setf triangle-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

triangle.lisp (file)

triangle-aref (function)

Writer

triangle-aref-setter (function)

Function: triangle-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

triangle.lisp (file)

Setf Expander

(setf triangle-aref) (setf expander)

Function: triangle-array-dimensions TUPLE-ARRAY

Return the size of a vector of TRIANGLE’s (ie how many TRIANGLE’s it contains)

Package
Source

triangle.lisp (file)

Function: triangle-fill-pointer TUPLE-ARRAY
Function: (setf triangle-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

triangle.lisp (file)

Function: triangle-vector-push TUPLE ARRAY-NAME
Package
Source

triangle.lisp (file)

Function: triangle-vector-push-extend TUPLE ARRAY-NAME
Package
Source

triangle.lisp (file)

Function: tuple-element-type TYPE-NAME

Return the size of the type

Package
Source

symbols.lisp (file)

Function: tuple-gensyms TYPE-NAME

Return a list of gensyms, one for each element of the tuple

Package
Source

symbols.lisp (file)

Function: tuple-size TYPE-NAME

Return the size of the type

Package
Source

symbols.lisp (file)

Function: tuple-typep TYPE-NAME

Test to see if this symbol represents a tuple type

Package
Source

symbols.lisp (file)

Function: tuple-typespec TYPE-NAME

Return typespec of tuple as multiple value.

Package
Source

symbols.lisp (file)

Function: tuple-typespec* TYPE-NAME

Return typespec of tuple as bounded array

Package
Source

symbols.lisp (file)

Function: tuple-typespec** TYPE-NAME

Return typespec of tuple as unbounded array

Package
Source

symbols.lisp (file)

Function: vector2d-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

vector.lisp (file)

Setf Expander

(setf vector2d-aref) (setf expander)

Setf Expander: (setf vector2d-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

vector2d-aref (function)

Writer

vector2d-aref-setter (function)

Function: vector2d-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

Setf Expander

(setf vector2d-aref) (setf expander)

Function: vector2d-array-dimensions TUPLE-ARRAY

Return the size of a vector of VECTOR2D’s (ie how many VECTOR2D’s it contains)

Package
Source

vector.lisp (file)

Function: vector2d-fill-pointer TUPLE-ARRAY
Function: (setf vector2d-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

vector.lisp (file)

Function: vector2d-vector-push TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vector2d-vector-push-extend TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vector3d-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

vector.lisp (file)

Setf Expander

(setf vector3d-aref) (setf expander)

Setf Expander: (setf vector3d-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

vector3d-aref (function)

Writer

vector3d-aref-setter (function)

Function: vector3d-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

Setf Expander

(setf vector3d-aref) (setf expander)

Function: vector3d-array-dimensions TUPLE-ARRAY

Return the size of a vector of VECTOR3D’s (ie how many VECTOR3D’s it contains)

Package
Source

vector.lisp (file)

Function: vector3d-fill-pointer TUPLE-ARRAY
Function: (setf vector3d-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

vector.lisp (file)

Function: vector3d-vector-push TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vector3d-vector-push-extend TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vertex3d-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

vector.lisp (file)

Setf Expander

(setf vertex3d-aref) (setf expander)

Setf Expander: (setf vertex3d-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

vertex3d-aref (function)

Writer

vertex3d-aref-setter (function)

Function: vertex3d-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

Setf Expander

(setf vertex3d-aref) (setf expander)

Function: vertex3d-array-dimensions TUPLE-ARRAY

Return the size of a vector of VERTEX3D’s (ie how many VERTEX3D’s it contains)

Package
Source

vector.lisp (file)

Function: vertex3d-fill-pointer TUPLE-ARRAY
Function: (setf vertex3d-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

vector.lisp (file)

Function: vertex3d-vector-push TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vertex3d-vector-push-extend TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Types

Type: fast-float ()
Package
Source

utils.lisp (file)

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

5.2 Internal definitions

Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Package
Source

syntax.lisp (file)

Package
Source

syntax.lisp (file)

Special Variable: *tuple-expander-keywords*
Package
Source

tuple-expander.lisp (file)

Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: check-rotation-matrix33* M

DEF-TUPLE-OP CHECK-ROTATION-MATRIX33* (MATRIX33)

Package
Source

matrix.lisp (file)

Macro: check-rotation-matrix44* M

DEF-TUPLE-OP CHECK-ROTATION-MATRIX44* (MATRIX44)

Package
Source

matrix.lisp (file)

Macro: def-new-tuple TYPE-NAME

Create a function to create a place suitable for holding an individual tuple. eg (new-vector3d)

Package
Source

tuples.lisp (file)

Macro: def-tuple TYPE-NAME

Create an alias for values for this tuple.eg (vector3d-values* 1.0 0.0 0.0) => #{ 1.0 0.0 0.0 }

Package
Source

tuples.lisp (file)

Macro: def-tuple-aref TYPE-NAME

Create a tuple aref macro for unpacking individual tuple from an array of tuples. eg (vector3d-aref up 5) => #(0.0 1.0 0.0)

Package
Source

tuples.lisp (file)

Macro: def-tuple-aref* TYPE-NAME

Create a tuple aref macro for unpacking individual tuple from an array of tuples. eg (vector3d-aref up 5) => (values 0.0 1.0 0.0)

Package
Source

tuples.lisp (file)

Macro: def-tuple-aref-setter TYPE-NAME

Create an aref-setter macro for setting an element in an array of tuples from a multiple-value tuple. eg (vector3d-aref-setter up 2 #( 0.0 1.0 0.0 ))

Package
Source

tuples.lisp (file)

Macro: def-tuple-aref-setter* TYPE-NAME

Create an aref-setter macro for setting an element in an array of tuples from a multiple-value tuple. eg (vector3d-aref-setter up 2 #{ 0.0 1.0 0.0 })

Package
Source

tuples.lisp (file)

Macro: def-tuple-array-dimensions TYPE-NAME

Create a function that will return the number of tuples in the array of tuple places.

Package
Source

tuples.lisp (file)

Macro: def-tuple-array-maker TYPE-NAME

Create a function to create an array suitable for holding an number of individual tuples. ie an array of tuple places. eg (make-vector3d-array 5 :adjustable t)

Package
Source

tuples.lisp (file)

Macro: def-tuple-array-setf TYPE-NAME

Create generalised variable macros for an array of tuples of type-name with the given elements.

Package
Source

tuples.lisp (file)

Macro: def-tuple-array-setf* TYPE-NAME

Create generalised variable macros for an array of tuples of type-name with the given elements.

Package
Source

tuples.lisp (file)

Macro: def-tuple-array-typespec TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-documentation TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-fill-pointer TYPE-NAME

Create a function that will return a vector fill pointer in terms of tuple size

Package
Source

tuples.lisp (file)

Macro: def-tuple-getter TYPE-NAME

Create an access macro such as (vector3d vec) that takes a tuple place and unpacks it to tuples (aka multiple values)

Package
Source

tuples.lisp (file)

Macro: def-tuple-key TYPE-NAME

Create an alias for values for this tuple.eg (vector3d-key-values z 1.0 x 2.0) => #{ 2.0 0.0 1.0 }

Package
Source

tuples.lisp (file)

Macro: def-tuple-maker TYPE-NAME

Create a function to create an place suitable for holding an individual tuple, and initialise elements from multiple-value tuple. eg (make-vector3d (values 1.0 2.0 2.0 ))

Package
Source

tuples.lisp (file)

Macro: def-tuple-maker* TYPE-NAME

Create a function to create an place suitable for holding an individual tuple, and initialise elements from array tuple. eg (make-vector3d* #( 1.0 2.0 2.0 ))

Package
Source

tuples.lisp (file)

Macro: def-tuple-map TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-reduce TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-set TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-setf* TYPE-NAME

Create generalised variable macros for tuple of type-name with the given elements.

Package
Source

tuples.lisp (file)

Macro: def-tuple-setf-fill-pointer TYPE-NAME

Create a function that will adjust a vector fill pointer in terms of tuple size

Package
Source

tuples.lisp (file)

Macro: def-tuple-setter TYPE-NAME

Creates a tuple-setter for setting a tuple place from a mutiple-value tuple. eg (vector3d-setter up #{ 0.0 1.0 0.0 })

Package
Source

tuples.lisp (file)

Macro: def-tuple-struct TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-typespec TYPE-NAME

Create an alias typespec eg. (deftype vector3d* () ‘(values ’single-float ’single-float ’single-float))

Package
Source

tuples.lisp (file)

Macro: def-tuple-vector-push TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-vector-push* TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-vector-push-extend TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-tuple-vector-push-extend* TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: def-with-tuple TYPE-NAME

Create a macro that can be used to bind members of a value tuple to symbols to symbols e-g (with-vector thing-vec (x y z w) &body forms)

Package
Source

tuples.lisp (file)

Macro: def-with-tuple* TYPE-NAME

Create a macro that can be used to bind members of the tuples place to symbols to symbols e-g (with-vector* thing-vec #(x y z w) &body forms)

Package
Source

tuples.lisp (file)

Macro: def-with-tuple-aref TYPE-NAME

Create a macro that can be used to bind elements of an array of tuples to symbols e-g (with-vector3d-aref (thing-vec 5 (x y z w)) (+ x y z w))

Package
Source

tuples.lisp (file)

Macro: export-tuple-operations TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: identity-matrix22* ()

DEF-TUPLE-OP IDENTITY-MATRIX22* NIL

Package
Source

matrix.lisp (file)

Macro: identity-matrix33* ()

DEF-TUPLE-OP IDENTITY-MATRIX33* NIL

Package
Source

matrix.lisp (file)

Macro: intersect-aabb* AABB0 AABB1

DEF-TUPLE-OP INTERSECT-AABB* (AABB AABB)

Package
Source

aabb.lisp (file)

Macro: make-test-matrix44* ()

Return a matrix for testing purposes

Package
Source

matrix.lisp (file)

Macro: make-tuple-operations TYPE-NAME
Package
Source

tuples.lisp (file)

Macro: make-vertex2d &rest ELEMENTS

Create an array sutable for holding a single VERTEX2D and initialize it from a multiple-values form

Package
Source

vector.lisp (file)

Macro: make-vertex2d* TUPLE-VALUES

Create an array sutable for holding a single VERTEX2D and initialize it from a form

Package
Source

vector.lisp (file)

Macro: matrix-dot DIMENSION ROW COL

Generate the symbols required for a dot product between the row and column of a matrix, assuming accessor symbol is e<row><col>

Package
Source

matrix.lisp (file)

Macro: matrix33-angle-axis* M

DEF-TUPLE-OP MATRIX33-ANGLE-AXIS* (MATRIX33)

Package
Source

quaternion.lisp (file)

Macro: matrix33-equal* K M

DEF-TUPLE-OP MATRIX33-EQUAL* (MATRIX33 MATRIX33)

Package
Source

matrix.lisp (file)

Macro: matrix33-quaternion* M

DEF-TUPLE-OP MATRIX33-QUATERNION* (MATRIX33)

Package
Source

quaternion.lisp (file)

Macro: matrix33-trace* M

DEF-TUPLE-OP MATRIX33-TRACE* (MATRIX33)

Package
Source

quaternion.lisp (file)

Macro: matrix44-equal* K M

DEF-TUPLE-OP MATRIX44-EQUAL* (MATRIX44 MATRIX44)

Package
Source

matrix.lisp (file)

Macro: multiply-arguments OPERATOR FACTOR ARGUMENTS
Package
Source

utils.lisp (file)

Macro: new-vertex2d ()

Create an array suitable for holding a single VERTEX2D

Package
Source

vector.lisp (file)

Macro: quaternion-angle-axis* Q

Convert an quaternion tuple to an angle-axis tuple. If the angle is zero, the axis isn’t defined, so the unit x vector is returned instead.

Package
Source

quaternion.lisp (file)

Macro: quaternion-power* Q TIMES

DEF-TUPLE-OP QUATERNION-POWER* (QUATERNION FAST-FLOAT)

Package
Source

quaternion.lisp (file)

Macro: rect-height* R

DEF-TUPLE-OP RECT-HEIGHT* (RECT)

Package
Source

rect.lisp (file)

Macro: rect-width* R

DEF-TUPLE-OP RECT-WIDTH* (RECT)

Package
Source

rect.lisp (file)

Macro: rotatex-matrix33* ROTATION

Return a matrix for rotating around the x axis.

Package
Source

matrix.lisp (file)

Macro: rotatey-matrix33* ROTATION

Return a matrix for rotating around the y axis.

Package
Source

matrix.lisp (file)

Macro: rotatez-matrix33* ROTATION

Return a matrix for rotating around the z axis.

Package
Source

matrix.lisp (file)

Macro: transform-aabb* MAT BOX

DEF-TUPLE-OP TRANSFORM-AABB* (MATRIX44 AABB)

Package
Source

aabb.lisp (file)

Macro: transpose-matrix22* MAT22

Return the transpose of the matrix

Package
Source

matrix.lisp (file)

Macro: vector2d-length-square* VEC

DEF-TUPLE-OP VECTOR2D-LENGTH-SQUARE* (VECTOR2D)

Package
Source

vector.lisp (file)

Macro: vector3d-angle-axis* AXIS ANGLE

DEF-TUPLE-OP VECTOR3D-ANGLE-AXIS* (VECTOR3D FAST-FLOAT)

Package
Source

quaternion.lisp (file)

Macro: vector3d-matrix3d* ZVEC YVEC

Construct a rotation matrix from 2 vectors

Package
Source

matrix.lisp (file)

Macro: vertex2d* TUPLE-ARRAY-NAME

Unpack array representation of an VERTEX2D and convert to multiple values.

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex2d*) (setf expander)

Setf Expander: (setf vertex2d*) TUPLE-PLACE TUPLE-VALUES
Package
Source

vector.lisp (file)

vertex2d* (macro)

Writer

vertex2d-setter* (macro)

Macro: vertex2d-aref* TUPLE-ARRAY ARRAY-INDEX

Unpack individual VERTEX2D to multiple values from an array of VERTEX2Ds.

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex2d-aref*) (setf expander)

Setf Expander: (setf vertex2d-aref*) ARRAY-NAME ARRAY-INDEX TUPLE-VALUES
Package
Source

vector.lisp (file)

vertex2d-aref* (macro)

Writer

vertex2d-aref-setter* (macro)

Macro: vertex2d-aref-setter* ARRAY-NAME ARRAY-INDEX TUPLE-VALUES

Creates a macro for setting an VERTEX2D vector in a vector of VERTEX2Ds from a multiple values VERTEX2D

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex2d-aref*) (setf expander)

Macro: vertex2d-key-values &key INITIAL-ELEMENT (X X) (Y Y) (W W)
Package
Source

vector.lisp (file)

Macro: vertex2d-map* OPERATOR &rest ARGS
Package
Source

vector.lisp (file)

Macro: vertex2d-reduce* OPERATOR TUPLE
Package
Source

vector.lisp (file)

Macro: vertex2d-setter* TUPLE-PLACE TUPLE-VALUES

Creates a macro for setting an VERTEX2D vector from a multiple values VERTEX2D

Package
Source

vector.lisp (file)

Setf Expander

(setf vertex2d*) (setf expander)

Macro: vertex2d-values* &rest ELEMENTS

Convert VERTEX2D forms to multiple values.

Package
Source

vector.lisp (file)

Macro: vertex2d-vector-push* TUPLE-VALUES ARRAY-NAME

Push a VERTEX2D multiple value onto the end of a vector of VERTEX2D’s

Package
Source

vector.lisp (file)

Macro: vertex2d-vector-push-extend* TUPLE-VALUES ARRAY-NAME

Push a VERTEX2D multiple value onto the end of a vector of VERTEX2D’s with the possibility of extension

Package
Source

vector.lisp (file)

Macro: with-vertex2d TUPLE-PLACE ELEMENT-SYMS &body FORMS

Bind elements of a VERTEX2D multiple value to symbols.

Package
Source

vector.lisp (file)

Macro: with-vertex2d* TUPLE ELEMENT-SYMS &body FORMS

Bind elements of a VERTEX2D vector to symbols.

Package
Source

vector.lisp (file)

Macro: with-vertex2d-aref (ARRAY-NAME INDEX ELEMENT-SYMS) &body FORMS

Bind the elements of a VERTEX2D from vector of VERTEX2D’s to symbols

Package
Source

vector.lisp (file)

Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Package
Source

syntax.lisp (file)

Package
Source

syntax.lisp (file)

Function: %disable-tuples-syntax ()
Package
Source

syntax.lisp (file)

Function: %enable-tuples-syntax &optional SAVE-ORIGINAL-P
Package
Source

syntax.lisp (file)

Function: aabb-maxx STRUCTURE
Function: (setf aabb-maxx) VALUE STRUCTURE
Package
Source

aabb.lisp (file)

Function: aabb-maxy STRUCTURE
Function: (setf aabb-maxy) VALUE STRUCTURE
Package
Source

aabb.lisp (file)

Function: aabb-maxz STRUCTURE
Function: (setf aabb-maxz) VALUE STRUCTURE
Package
Source

aabb.lisp (file)

Function: aabb-minx STRUCTURE
Function: (setf aabb-minx) VALUE STRUCTURE
Package
Source

aabb.lisp (file)

Function: aabb-miny STRUCTURE
Function: (setf aabb-miny) VALUE STRUCTURE
Package
Source

aabb.lisp (file)

Function: aabb-minz STRUCTURE
Function: (setf aabb-minz) VALUE STRUCTURE
Package
Source

aabb.lisp (file)

Function: angle-axis-a STRUCTURE
Function: (setf angle-axis-a) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: angle-axis-x STRUCTURE
Function: (setf angle-axis-x) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: angle-axis-y STRUCTURE
Function: (setf angle-axis-y) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: angle-axis-z STRUCTURE
Function: (setf angle-axis-z) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: arg-expander-fn-aux N NAMES TYPES ELEMENTS GENSYMS BODY

Handle the expansion of the n-th parameter in a def-tuple-op call list. Names are the

Package
Source

tuple-expander.lisp (file)

Function: arg-expander-fn-aux-with N NAMES TYPES ELEMENTS GENSYMS BODY

Handle the tuple type case, expanding into -WITH macros. The rest is handled by ARG-EXPANDER-FN-AUX in a separate step.

Package
Source

tuple-expander.lisp (file)

Function: body-expander-fn NAMES TYPES ELEMENTS GENSYMS BODY

Expand the declarations and return type wrapper round a def-tuple-op. form

Package
Source

tuple-expander.lisp (file)

Function: colour-a STRUCTURE
Function: (setf colour-a) VALUE STRUCTURE
Package
Source

colour.lisp (file)

Function: colour-b STRUCTURE
Function: (setf colour-b) VALUE STRUCTURE
Package
Source

colour.lisp (file)

Function: colour-g STRUCTURE
Function: (setf colour-g) VALUE STRUCTURE
Package
Source

colour.lisp (file)

Function: colour-r STRUCTURE
Function: (setf colour-r) VALUE STRUCTURE
Package
Source

colour.lisp (file)

Function: construct-tuple-array-maker TYPE-NAME
Package
Source

tuple-expander.lisp (file)

Function: construct-tuple-array-reference TYPE-NAME TUPLE-ARRAY-NAME INDEX

Given a tuple type and an array index, return a form for returnign the array index

Package
Source

tuple-expander.lisp (file)

Function: construct-tuple-set-aref TYPE-NAME TUPLE-PLACE INDEX VARLIST
Package
Source

tuple-expander.lisp (file)

Function: construct-tuple-slots TYPE-NAME

Given a tuple type return a list of slots sutable for the body of a defstruct body eg: ((A 0.0f0 :TYPE SINGLE-FLOAT) (B 0.0f0 :TYPE SINGLE-FLOAT))

Package
Source

tuple-expander.lisp (file)

Function: construct-tuple-value-type TYPE-NAME

Given a tuple name construct the for of a value typespec for it eg (values single-float single-float)

Package
Source

tuple-expander.lisp (file)

Function: copy-aabb SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-angle-axis SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-colour SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-matrix22 SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-matrix33 SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-matrix44 SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-quaternion SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-rect SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-triangle SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-vector2d SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-vector3d SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-vertex2d SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: copy-vertex3d SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package
Source

Function: def-tuple-expander-fn PARAMS TYPES ELEMENTS FORMS

Helper function for def-tuple-op. Expands the arguments into a series of WITH-* forms so that symbols are bound to tuple elements in the body of the operator.

Package
Source

tuple-expander.lisp (file)

Function: document-tuple-type TYPE-NAME
Package
Source

tuples.lisp (file)

Function: is-asterisk-symbol S
Package
Source

utils.lisp (file)

Function: last-char STR
Package
Source

utils.lisp (file)

Function: make-adorned-symbol NAME &key PREFIX SUFFIX ASTERISK PACKAGE

Construct symbol for use as a function name, prefixed or suffixed with some string, and optionally an added asterisk

Package
Source

utils.lisp (file)

Function: make-vertex2d-array DIMENSIONS &key ADJUSTABLE INITIAL-ELEMENT FILL-POINTER

Create an array suitable for holding a number of VERTEX2D’s

Package
Source

vector.lisp (file)

Function: matrix-cofactors LENGTH
Package
Source

utils.lisp (file)

Function: matrix-minor X Y LENGTH &optional PREFIX
Package
Source

utils.lisp (file)

Function: matrix-symbol I J &optional PREFIX

Construct a symbol that will represent an elemnet of a matrix.

Package
Source

utils.lisp (file)

Function: matrix22-e00 STRUCTURE
Function: (setf matrix22-e00) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix22-e01 STRUCTURE
Function: (setf matrix22-e01) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix22-e10 STRUCTURE
Function: (setf matrix22-e10) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix22-e11 STRUCTURE
Function: (setf matrix22-e11) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e00 STRUCTURE
Function: (setf matrix33-e00) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e01 STRUCTURE
Function: (setf matrix33-e01) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e02 STRUCTURE
Function: (setf matrix33-e02) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e10 STRUCTURE
Function: (setf matrix33-e10) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e11 STRUCTURE
Function: (setf matrix33-e11) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e12 STRUCTURE
Function: (setf matrix33-e12) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e20 STRUCTURE
Function: (setf matrix33-e20) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e21 STRUCTURE
Function: (setf matrix33-e21) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix33-e22 STRUCTURE
Function: (setf matrix33-e22) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e00 STRUCTURE
Function: (setf matrix44-e00) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e01 STRUCTURE
Function: (setf matrix44-e01) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e02 STRUCTURE
Function: (setf matrix44-e02) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e03 STRUCTURE
Function: (setf matrix44-e03) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e10 STRUCTURE
Function: (setf matrix44-e10) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e11 STRUCTURE
Function: (setf matrix44-e11) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e12 STRUCTURE
Function: (setf matrix44-e12) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e13 STRUCTURE
Function: (setf matrix44-e13) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e20 STRUCTURE
Function: (setf matrix44-e20) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e21 STRUCTURE
Function: (setf matrix44-e21) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e22 STRUCTURE
Function: (setf matrix44-e22) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e23 STRUCTURE
Function: (setf matrix44-e23) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e30 STRUCTURE
Function: (setf matrix44-e30) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e31 STRUCTURE
Function: (setf matrix44-e31) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e32 STRUCTURE
Function: (setf matrix44-e32) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: matrix44-e33 STRUCTURE
Function: (setf matrix44-e33) VALUE STRUCTURE
Package
Source

matrix.lisp (file)

Function: quaternion-w STRUCTURE
Function: (setf quaternion-w) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: quaternion-x STRUCTURE
Function: (setf quaternion-x) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: quaternion-y STRUCTURE
Function: (setf quaternion-y) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: quaternion-z STRUCTURE
Function: (setf quaternion-z) VALUE STRUCTURE
Package
Source

quaternion.lisp (file)

Function: rect-bottom STRUCTURE
Function: (setf rect-bottom) VALUE STRUCTURE
Package
Source

rect.lisp (file)

Function: rect-left STRUCTURE
Function: (setf rect-left) VALUE STRUCTURE
Package
Source

rect.lisp (file)

Function: rect-right STRUCTURE
Function: (setf rect-right) VALUE STRUCTURE
Package
Source

rect.lisp (file)

Function: rect-top STRUCTURE
Function: (setf rect-top) VALUE STRUCTURE
Package
Source

rect.lisp (file)

Function: simple-tuple-typespec* TYPE-NAME

Return typespec of tuple as bounded array

Package
Source

symbols.lisp (file)

Function: symbol-macro-expander-fn N NAMES TYPES ELEMENTS GENSYMS BODY

Wrap the body of def tuple op in symbol macros mapped to gensyms to prevent name capture.

Package
Source

tuple-expander.lisp (file)

Function: symbol-to-string SYM

If the argument is a symbol or string, return it as a string.

Package
Source

utils.lisp (file)

Function: triangle-a STRUCTURE
Function: (setf triangle-a) VALUE STRUCTURE
Package
Source

triangle.lisp (file)

Function: triangle-b STRUCTURE
Function: (setf triangle-b) VALUE STRUCTURE
Package
Source

triangle.lisp (file)

Function: triangle-c STRUCTURE
Function: (setf triangle-c) VALUE STRUCTURE
Package
Source

triangle.lisp (file)

Function: tuple-elements TYPE-NAME

Return a list of element names

Package
Source

symbols.lisp (file)

Function: tuple-initial-element TYPE-NAME

Return the inital element type of a tuple array

Package
Source

symbols.lisp (file)

Function: tuple-places TYPE-NAME ARRAY-NAME

Return a list of (aref *) forms to turn at tuple represeted and array into individual places.

Package
Source

symbols.lisp (file)

Function: vector2d-x STRUCTURE
Function: (setf vector2d-x) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vector2d-y STRUCTURE
Function: (setf vector2d-y) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vector3d-x STRUCTURE
Function: (setf vector3d-x) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vector3d-y STRUCTURE
Function: (setf vector3d-y) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vector3d-z STRUCTURE
Function: (setf vector3d-z) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex2d-aref TUPLE-ARRAY TUPLE-INDEX
Package
Source

vector.lisp (file)

Setf Expander

(setf vertex2d-aref) (setf expander)

Setf Expander: (setf vertex2d-aref) ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

vertex2d-aref (function)

Writer

vertex2d-aref-setter (function)

Function: vertex2d-aref-setter ARRAY-NAME TUPLE-INDEX TUPLE
Package
Source

vector.lisp (file)

Setf Expander

(setf vertex2d-aref) (setf expander)

Function: vertex2d-array-dimensions TUPLE-ARRAY

Return the size of a vector of VERTEX2D’s (ie how many VERTEX2D’s it contains)

Package
Source

vector.lisp (file)

Function: vertex2d-fill-pointer TUPLE-ARRAY
Function: (setf vertex2d-fill-pointer) VALUE TUPLE-ARRAY
Package
Source

vector.lisp (file)

Function: vertex2d-vector-push TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vertex2d-vector-push-extend TUPLE ARRAY-NAME
Package
Source

vector.lisp (file)

Function: vertex2d-w STRUCTURE
Function: (setf vertex2d-w) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex2d-x STRUCTURE
Function: (setf vertex2d-x) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex2d-y STRUCTURE
Function: (setf vertex2d-y) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex3d-w STRUCTURE
Function: (setf vertex3d-w) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex3d-x STRUCTURE
Function: (setf vertex3d-x) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex3d-y STRUCTURE
Function: (setf vertex3d-y) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Function: vertex3d-z STRUCTURE
Function: (setf vertex3d-z) VALUE STRUCTURE
Package
Source

vector.lisp (file)

Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: tuple-expansion-fn TYPE-NAME EXPANSION
Package
Source

tuple-expander.lisp (file)

Methods
Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-reduce))
Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-map))
Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-maker*))

Create a macro that creates new tuple place, form and initialize it with values

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-maker))

Create a macro that creates new tuple place and initialize it from a list of elements

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-new-tuple))

Create a macro that creates a new tuple.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-with-tuple-aref))

Create a wrapper macro that will bind an indexed tuple form in an array to symbols turing evaluation of the body.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-with-tuple*))

Create a wrapper that will bind a tuple value form to symbols during evaluation of the body.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-with-tuple))

Create a wrapper that will bind a tuple place to symbols during evaluation of the body.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push-extend*))

Create a macro that will push a tuple value form into an array of existing tuple places, extending if adjustable.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push*))

Create a macro that will push a tuple value form into an array of existing tuple places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push-extend))

Create a macro that will push a tuple value form into an array of existing tuple places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push))

Create a macro that will push a tuple value form into an array of existing tuple places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-setf-fill-pointer))

Create macro that returns the number of tuples in an array of tuple places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-fill-pointer))

Create macro that returns the number of tuples in an array of tuple places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-dimensions))

Create macro that returns the number of tuples in an array of tuple places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-setf*))

Expand form that creates generalized reference to tuple-arrays

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-setf))

Expand form that creates generalized reference to tuple-arrays

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref-setter*))

Create a macro that will set an indexed array of tuple places to the values of a tuple value form

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref-setter))

Create a macro that will set an indexed array of tuple places to the values of a tuple struct form

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-nth-tuple))
Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref*))

Create a macro that will index an array that is considered to be an array of tuples and extract an individual tuple as a value form

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref))

Create a macro that will set an indexed array of tuple places to the values of a tuple struct form

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-maker))

Create macro that creates a array of tuple array places.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-setf*))

Expand form that creates generalized reference to a tuple place

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-set))
Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-setter))

Create a macro that will set an tuple place form to the values of a tuple value form

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-getter))

Create a macro that will return the contents of a place representing our tuple as a value form

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-struct))

Defines a structure that will hold the tuple based on a vector.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-type))

Expand the deftype form for an array of tuples

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-type))

Expand the tuple multiple value deftype form.

Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-key-values))
Method: tuple-expansion-fn (TYPE-NAME symbol) (EXPANSION (eql def-tuple-values))

Expand to a macro that will create a values form representing our tuple type.

Generic Function: tuple-symbol TYPE-NAME EXPANSION
Package
Source

tuple-expander.lisp (file)

Methods
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-reduce))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-map))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-maker*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-maker))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-new-tuple))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-with-tuple-aref))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-with-tuple*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-with-tuple))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push-extend*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push-extend))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-vector-push))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-setf-fill-pointer))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-fill-pointer))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-dimensions))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-setf*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-setf))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref-setter*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref-setter))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-nth-tuple))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-aref))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-maker))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-setf*))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-set))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-setter))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-getter))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-struct))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-array-type))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-type))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-key-values))
Method: tuple-symbol (TYPE-NAME symbol) (EXPANSION (eql def-tuple-values))

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

Appendix A Indexes

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