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 4.0 beta 2 "William Riker" on Mon Aug 15 04:06:37 2022 GMT+0.

Table of Contents


1 Introduction

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)								
(make-vector2d-array dimensons &key adjustable fill-pointer)

(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

2 Systems

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


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

2.1 cl-tuples

Experimental Tuple Types Facade

Author

John Connors

License

MIT

Version

1.0

Dependencies
  • iterate (system).
  • alexandria (system).
Source

cl-tuples.asd.

Child Components

3 Files

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


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

3.1 Lisp


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

3.1.1 cl-tuples/cl-tuples.asd

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

ASDF Systems

cl-tuples.

Packages

cl-tuples-system.


3.1.2 cl-tuples/package.lisp

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Packages

cl-tuples.


3.1.3 cl-tuples/utils.lisp

Dependency

package.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.4 cl-tuples/symbols.lisp

Dependency

utils.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Packages

tuple-types.

Public Interface
Internals

3.1.5 cl-tuples/syntax.lisp

Dependency

symbols.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.6 cl-tuples/tuple-expander.lisp

Dependency

syntax.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Internals

3.1.8 cl-tuples/vector.lisp

Dependency

tuples.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.9 cl-tuples/matrix.lisp

Dependency

vector.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.10 cl-tuples/quaternion.lisp

Dependency

matrix.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.11 cl-tuples/colour.lisp

Dependency

quaternion.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.12 cl-tuples/triangle.lisp

Dependency

colour.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

3.1.13 cl-tuples/rect.lisp

Dependency

triangle.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

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

3.1.14 cl-tuples/aabb.lisp

Dependency

rect.lisp (file).

Source

cl-tuples.asd.

Parent Component

cl-tuples (system).

Public Interface
Internals

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.

Nickname

tuples

Use List
  • alexandria.
  • common-lisp.
  • iterate.
Public Interface
Internals

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

4.3 tuple-types

Source

symbols.lisp.


5 Definitions

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


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

5.1 Public Interface


5.1.1 Constants

Constant: fast-pi
Package

cl-tuples.

Source

utils.lisp.


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

5.1.2 Special variables

Special Variable: *float-print-format*
Package

cl-tuples.

Source

matrix.lisp.


5.1.3 Macros

Macro: aabb* (tuple-array-name)

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

Package

cl-tuples.

Source

aabb.lisp.

Setf expander for this macro

(setf aabb*).

Macro: aabb-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

aabb.lisp.

Setf expander for this macro

(setf aabb-aref*).

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

cl-tuples.

Source

aabb.lisp.

Setf expanders to this macro

(setf aabb-aref*).

Macro: aabb-key-values (&key initial-element minx maxx miny maxy minz maxz)
Package

cl-tuples.

Source

aabb.lisp.

Macro: aabb-map* (operator &rest args)
Package

cl-tuples.

Source

aabb.lisp.

Macro: aabb-reduce* (operator tuple)
Package

cl-tuples.

Source

aabb.lisp.

Macro: aabb-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

aabb.lisp.

Setf expanders to this macro

(setf aabb*).

Macro: aabb-values* (&rest elements)

Convert AABB forms to multiple values.

Package

cl-tuples.

Source

aabb.lisp.

Macro: aabb-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

aabb.lisp.

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

cl-tuples.

Source

aabb.lisp.

Macro: angle-axis* (tuple-array-name)

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

Package

cl-tuples.

Source

quaternion.lisp.

Setf expander for this macro

(setf angle-axis*).

Macro: angle-axis-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

quaternion.lisp.

Setf expander for this macro

(setf angle-axis-aref*).

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

cl-tuples.

Source

quaternion.lisp.

Setf expanders to this macro

(setf angle-axis-aref*).

Macro: angle-axis-key-values (&key initial-element x y z a)
Package

cl-tuples.

Source

quaternion.lisp.

Macro: angle-axis-map* (operator &rest args)
Package

cl-tuples.

Source

quaternion.lisp.

Macro: angle-axis-matrix33* (aa)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: angle-axis-quaternion* (aa)

Convert an angle-axis tuple to a quaternion tuple

Package

cl-tuples.

Source

quaternion.lisp.

Macro: angle-axis-reduce* (operator tuple)
Package

cl-tuples.

Source

quaternion.lisp.

Macro: angle-axis-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

quaternion.lisp.

Setf expanders to this macro

(setf angle-axis*).

Macro: angle-axis-values* (&rest elements)

Convert ANGLE-AXIS forms to multiple values.

Package

cl-tuples.

Source

quaternion.lisp.

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

cl-tuples.

Source

quaternion.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Macro: cofactor-matrix22* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: cofactor-matrix33* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: cofactor-matrix44* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: colour* (tuple-array-name)

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

Package

cl-tuples.

Source

colour.lisp.

Setf expander for this macro

(setf colour*).

Macro: colour-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

colour.lisp.

Setf expander for this macro

(setf colour-aref*).

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

cl-tuples.

Source

colour.lisp.

Setf expanders to this macro

(setf colour-aref*).

Macro: colour-key-values (&key initial-element r g b a)
Package

cl-tuples.

Source

colour.lisp.

Macro: colour-map* (operator &rest args)
Package

cl-tuples.

Source

colour.lisp.

Macro: colour-reduce* (operator tuple)
Package

cl-tuples.

Source

colour.lisp.

Macro: colour-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

colour.lisp.

Setf expanders to this macro

(setf colour*).

Macro: colour-values* (&rest elements)

Convert COLOUR forms to multiple values.

Package

cl-tuples.

Source

colour.lisp.

Macro: colour-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

colour.lisp.

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

cl-tuples.

Source

colour.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

Macro: delta-vector3d* (start end)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: disable-tuples-syntax ()
Package

cl-tuples.

Source

syntax.lisp.

Macro: enable-tuples-syntax ()
Package

cl-tuples.

Source

syntax.lisp.

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

cl-tuples.

Source

syntax.lisp.

Macro: identity-matrix44* ()

DEF-TUPLE-OP IDENTITY-MATRIX44* NIL

Package

cl-tuples.

Source

matrix.lisp.

Macro: inverted-matrix22* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: inverted-matrix33* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: inverted-matrix44* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

syntax.lisp.

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

cl-tuples.

Source

syntax.lisp.

Macro: make-aabb (&rest elements)

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

Package

cl-tuples.

Source

aabb.lisp.

Macro: make-aabb* (tuple-values)

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

Package

cl-tuples.

Source

aabb.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Macro: make-angle-axis* (tuple-values)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: make-colour (&rest elements)

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

Package

cl-tuples.

Source

colour.lisp.

Macro: make-colour* (tuple-values)

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

Package

cl-tuples.

Source

colour.lisp.

Macro: make-matrix22 (&rest elements)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-matrix22* (tuple-values)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-matrix33 (&rest elements)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-matrix33* (tuple-values)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-matrix44 (&rest elements)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-matrix44* (tuple-values)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-quaternion (&rest elements)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: make-quaternion* (tuple-values)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: make-rect (&rest elements)

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

Package

cl-tuples.

Source

rect.lisp.

Macro: make-rect* (tuple-values)

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

Package

cl-tuples.

Source

rect.lisp.

Macro: make-triangle (&rest elements)

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

Package

cl-tuples.

Source

triangle.lisp.

Macro: make-triangle* (tuple-values)

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

Package

cl-tuples.

Source

triangle.lisp.

Macro: make-vector2d (&rest elements)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: make-vector2d* (tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: make-vector3d (&rest elements)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: make-vector3d* (tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: make-vertex3d (&rest elements)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: make-vertex3d* (tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: matrix22* (tuple-array-name)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this macro

(setf matrix22*).

Macro: matrix22-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this macro

(setf matrix22-aref*).

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

cl-tuples.

Source

matrix.lisp.

Setf expanders to this macro

(setf matrix22-aref*).

Macro: matrix22-determinant* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix22-key-values (&key initial-element e00 e01 e10 e11)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix22-map* (operator &rest args)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix22-reduce* (operator tuple)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix22-scale* (x mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix22-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expanders to this macro

(setf matrix22*).

Macro: matrix22-values* (&rest elements)

Convert MATRIX22 forms to multiple values.

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix22-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: matrix33* (tuple-array-name)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this macro

(setf matrix33*).

Macro: matrix33-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this macro

(setf matrix33-aref*).

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

cl-tuples.

Source

matrix.lisp.

Setf expanders to this macro

(setf matrix33-aref*).

Macro: matrix33-determinant* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-key-values (&key initial-element e00 e01 e02 e10 e11 e12 e20 e21 e22)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-map* (operator &rest args)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-matrix44* (mat3)

Convert a 3x3 matrix to a 4x4 matrix

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-product* (m0 m1)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-reduce* (operator tuple)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-scale* (x mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expanders to this macro

(setf matrix33*).

Macro: matrix33-values* (&rest elements)

Convert MATRIX33 forms to multiple values.

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: matrix44* (tuple-array-name)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this macro

(setf matrix44*).

Macro: matrix44-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this macro

(setf matrix44-aref*).

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

cl-tuples.

Source

matrix.lisp.

Setf expanders to this macro

(setf matrix44-aref*).

Macro: matrix44-determinant* (mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-key-values (&key initial-element e00 e01 e02 e03 e10 e11 e12 e13 e20 e21 e22 e23 e30 e31 e32 e33)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-map* (operator &rest args)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-matrix33* (mat44)

Convert a 4x4 matrix to a 3x3 matrix

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-product* (m0 m1)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-reduce* (operator tuple)
Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-scale* (x mat)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

matrix.lisp.

Setf expanders to this macro

(setf matrix44*).

Macro: matrix44-values* (&rest elements)

Convert MATRIX44 forms to multiple values.

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix44-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: new-aabb ()

Create an array suitable for holding a single AABB

Package

cl-tuples.

Source

aabb.lisp.

Macro: new-angle-axis ()

Create an array suitable for holding a single ANGLE-AXIS

Package

cl-tuples.

Source

quaternion.lisp.

Macro: new-colour ()

Create an array suitable for holding a single COLOUR

Package

cl-tuples.

Source

colour.lisp.

Macro: new-matrix22 ()

Create an array suitable for holding a single MATRIX22

Package

cl-tuples.

Source

matrix.lisp.

Macro: new-matrix33 ()

Create an array suitable for holding a single MATRIX33

Package

cl-tuples.

Source

matrix.lisp.

Macro: new-matrix44 ()

Create an array suitable for holding a single MATRIX44

Package

cl-tuples.

Source

matrix.lisp.

Macro: new-quaternion ()

Create an array suitable for holding a single QUATERNION

Package

cl-tuples.

Source

quaternion.lisp.

Macro: new-rect ()

Create an array suitable for holding a single RECT

Package

cl-tuples.

Source

rect.lisp.

Macro: new-triangle ()

Create an array suitable for holding a single TRIANGLE

Package

cl-tuples.

Source

triangle.lisp.

Macro: new-vector2d ()

Create an array suitable for holding a single VECTOR2D

Package

cl-tuples.

Source

vector.lisp.

Macro: new-vector3d ()

Create an array suitable for holding a single VECTOR3D

Package

cl-tuples.

Source

vector.lisp.

Macro: new-vertex3d ()

Create an array suitable for holding a single VERTEX3D

Package

cl-tuples.

Source

vector.lisp.

Macro: print-matrix22* (stream mat)

Print a 2x2 matrix in a useful format.

Package

cl-tuples.

Source

matrix.lisp.

Macro: print-matrix33* (stream mat)

Print a 3x3 matrix in a useful format.

Package

cl-tuples.

Source

matrix.lisp.

Macro: print-matrix44* (stream mat)

Print a 4x4 matrix in a useful format.

Package

cl-tuples.

Source

matrix.lisp.

Macro: quaternion* (tuple-array-name)

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

Package

cl-tuples.

Source

quaternion.lisp.

Setf expander for this macro

(setf quaternion*).

Macro: quaternion-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

quaternion.lisp.

Setf expander for this macro

(setf quaternion-aref*).

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

cl-tuples.

Source

quaternion.lisp.

Setf expanders to this macro

(setf quaternion-aref*).

Macro: quaternion-conjugate* (q)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-dot* (q0 q1)

Dot product of two quaternions.

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-inverse* (q)

Inverse of quaternion

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-key-values (&key initial-element x y z w)
Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-mag* (q)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-mag-square* (q)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-map* (operator &rest args)
Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-matrix33* (q)

Convert a quaternion to a 3x3 rotation matrix.

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-normalize* (q)

Ensure a quaternion is a unit

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-product* (q-lhs q-rhs)

Multiple of two quaternions

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-reduce* (operator tuple)
Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-scale* (q s)

Multiply a quat by a scalar

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

quaternion.lisp.

Setf expanders to this macro

(setf quaternion*).

Macro: quaternion-sum* (q0 q1)

Sum the components of two quaternions

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-transform-vector3d* (vector quat)

Transform a 3d vector with a quaternion

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-values* (&rest elements)

Convert QUATERNION forms to multiple values.

Package

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

quaternion.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Macro: rect* (tuple-array-name)

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

Package

cl-tuples.

Source

rect.lisp.

Setf expander for this macro

(setf rect*).

Macro: rect-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

rect.lisp.

Setf expander for this macro

(setf rect-aref*).

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

cl-tuples.

Source

rect.lisp.

Setf expanders to this macro

(setf rect-aref*).

Macro: rect-key-values (&key initial-element left right top bottom)
Package

cl-tuples.

Source

rect.lisp.

Macro: rect-map* (operator &rest args)
Package

cl-tuples.

Source

rect.lisp.

Macro: rect-reduce* (operator tuple)
Package

cl-tuples.

Source

rect.lisp.

Macro: rect-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

rect.lisp.

Setf expanders to this macro

(setf rect*).

Macro: rect-values* (&rest elements)

Convert RECT forms to multiple values.

Package

cl-tuples.

Source

rect.lisp.

Macro: rect-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

rect.lisp.

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

cl-tuples.

Source

rect.lisp.

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

cl-tuples.

Source

syntax.lisp.

Macro: rotatex-matrix44* (rotation)

Return a matrix for rotating around the x axis.

Package

cl-tuples.

Source

matrix.lisp.

Macro: rotatey-matrix44* (rotation)

Return a matrix for rotating around the y axis.

Package

cl-tuples.

Source

matrix.lisp.

Macro: rotatez-matrix44* (rotation)

Return a matrix for rotating around the z axis.

Package

cl-tuples.

Source

matrix.lisp.

Macro: scaling-matrix44* (sx sy sz)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: transform-vector2d* (mat vec)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: transform-vector3d* (mat vect)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: transform-vertex2d* (mat vert)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: transform-vertex3d* (mat vert)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: translation-matrix44* (tx ty tz)

Return a matrix that represents a translation transformation

Package

cl-tuples.

Source

matrix.lisp.

Macro: transpose-matrix33* (mat33)

Return the transpose of the matrix

Package

cl-tuples.

Source

matrix.lisp.

Macro: transpose-matrix44* (mat44)

Return the transpose of the matrix

Package

cl-tuples.

Source

matrix.lisp.

Macro: triangle* (tuple-array-name)

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

Package

cl-tuples.

Source

triangle.lisp.

Setf expander for this macro

(setf triangle*).

Macro: triangle-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

triangle.lisp.

Setf expander for this macro

(setf triangle-aref*).

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

cl-tuples.

Source

triangle.lisp.

Setf expanders to this macro

(setf triangle-aref*).

Macro: triangle-key-values (&key initial-element a b c)
Package

cl-tuples.

Source

triangle.lisp.

Macro: triangle-map* (operator &rest args)
Package

cl-tuples.

Source

triangle.lisp.

Macro: triangle-reduce* (operator tuple)
Package

cl-tuples.

Source

triangle.lisp.

Macro: triangle-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

triangle.lisp.

Setf expanders to this macro

(setf triangle*).

Macro: triangle-values* (&rest elements)

Convert TRIANGLE forms to multiple values.

Package

cl-tuples.

Source

triangle.lisp.

Macro: triangle-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

triangle.lisp.

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

cl-tuples.

Source

triangle.lisp.

Macro: vector2d* (tuple-array-name)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vector2d*).

Macro: vector2d-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vector2d-aref*).

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

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vector2d-aref*).

Macro: vector2d-dot* (veca vecb)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-key-values (&key initial-element x y)
Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-length* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-map* (operator &rest args)
Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-normal* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-reduce* (operator tuple)
Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-scale* (vec s)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vector2d*).

Macro: vector2d-values* (&rest elements)

Convert VECTOR2D forms to multiple values.

Package

cl-tuples.

Source

vector.lisp.

Macro: vector2d-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.

Macro: vector2d-vertex2d* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d* (tuple-array-name)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vector3d*).

Macro: vector3d-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vector3d-aref*).

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

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vector3d-aref*).

Macro: vector3d-cross* (lhs rhs)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-difference* (veca vecb)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-dot* (veca vecb)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-key-values (&key initial-element x y z)
Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-length* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-map* (operator &rest args)
Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-normal* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-quaternion* (vector)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: vector3d-reduce* (operator tuple)
Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-scale* (vec s)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vector3d*).

Macro: vector3d-sum* (veca vecb)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-values* (&rest elements)

Convert VECTOR3D forms to multiple values.

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.

Macro: vector3d-vertex3d* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vertex2d-vector2d* (vert)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vertex3d* (tuple-array-name)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vertex3d*).

Macro: vertex3d-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vertex3d-aref*).

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

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vertex3d-aref*).

Macro: vertex3d-distance* (start end)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vertex3d-key-values (&key initial-element x y z w)
Package

cl-tuples.

Source

vector.lisp.

Macro: vertex3d-map* (operator &rest args)
Package

cl-tuples.

Source

vector.lisp.

Macro: vertex3d-reduce* (operator tuple)
Package

cl-tuples.

Source

vector.lisp.

Macro: vertex3d-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vertex3d*).

Macro: vertex3d-translation-matrix44* (vert)

Return a matrix that represents a translation transformation

Package

cl-tuples.

Source

matrix.lisp.

Macro: vertex3d-values* (&rest elements)

Convert VERTEX3D forms to multiple values.

Package

cl-tuples.

Source

vector.lisp.

Macro: vertex3d-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.

Macro: vertex3d-vector3d* (vert)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: with-aabb (tuple-place element-syms &body forms)

Bind elements of a AABB multiple value to symbols.

Package

cl-tuples.

Source

aabb.lisp.

Macro: with-aabb* (tuple element-syms &body forms)

Bind elements of a AABB vector to symbols.

Package

cl-tuples.

Source

aabb.lisp.

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

cl-tuples.

Source

aabb.lisp.

Macro: with-angle-axis (tuple-place element-syms &body forms)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: with-angle-axis* (tuple element-syms &body forms)

Bind elements of a ANGLE-AXIS vector to symbols.

Package

cl-tuples.

Source

quaternion.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Macro: with-colour (tuple-place element-syms &body forms)

Bind elements of a COLOUR multiple value to symbols.

Package

cl-tuples.

Source

colour.lisp.

Macro: with-colour* (tuple element-syms &body forms)

Bind elements of a COLOUR vector to symbols.

Package

cl-tuples.

Source

colour.lisp.

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

cl-tuples.

Source

colour.lisp.

Macro: with-matrix22 (tuple-place element-syms &body forms)

Bind elements of a MATRIX22 multiple value to symbols.

Package

cl-tuples.

Source

matrix.lisp.

Macro: with-matrix22* (tuple element-syms &body forms)

Bind elements of a MATRIX22 vector to symbols.

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: with-matrix33 (tuple-place element-syms &body forms)

Bind elements of a MATRIX33 multiple value to symbols.

Package

cl-tuples.

Source

matrix.lisp.

Macro: with-matrix33* (tuple element-syms &body forms)

Bind elements of a MATRIX33 vector to symbols.

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: with-matrix44 (tuple-place element-syms &body forms)

Bind elements of a MATRIX44 multiple value to symbols.

Package

cl-tuples.

Source

matrix.lisp.

Macro: with-matrix44* (tuple element-syms &body forms)

Bind elements of a MATRIX44 vector to symbols.

Package

cl-tuples.

Source

matrix.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: with-quaternion (tuple-place element-syms &body forms)

Bind elements of a QUATERNION multiple value to symbols.

Package

cl-tuples.

Source

quaternion.lisp.

Macro: with-quaternion* (tuple element-syms &body forms)

Bind elements of a QUATERNION vector to symbols.

Package

cl-tuples.

Source

quaternion.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Macro: with-rect (tuple-place element-syms &body forms)

Bind elements of a RECT multiple value to symbols.

Package

cl-tuples.

Source

rect.lisp.

Macro: with-rect* (tuple element-syms &body forms)

Bind elements of a RECT vector to symbols.

Package

cl-tuples.

Source

rect.lisp.

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

cl-tuples.

Source

rect.lisp.

Macro: with-triangle (tuple-place element-syms &body forms)

Bind elements of a TRIANGLE multiple value to symbols.

Package

cl-tuples.

Source

triangle.lisp.

Macro: with-triangle* (tuple element-syms &body forms)

Bind elements of a TRIANGLE vector to symbols.

Package

cl-tuples.

Source

triangle.lisp.

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

cl-tuples.

Source

triangle.lisp.

Macro: with-vector2d (tuple-place element-syms &body forms)

Bind elements of a VECTOR2D multiple value to symbols.

Package

cl-tuples.

Source

vector.lisp.

Macro: with-vector2d* (tuple element-syms &body forms)

Bind elements of a VECTOR2D vector to symbols.

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.

Macro: with-vector3d (tuple-place element-syms &body forms)

Bind elements of a VECTOR3D multiple value to symbols.

Package

cl-tuples.

Source

vector.lisp.

Macro: with-vector3d* (tuple element-syms &body forms)

Bind elements of a VECTOR3D vector to symbols.

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.

Macro: with-vertex3d (tuple-place element-syms &body forms)

Bind elements of a VERTEX3D multiple value to symbols.

Package

cl-tuples.

Source

vector.lisp.

Macro: with-vertex3d* (tuple element-syms &body forms)

Bind elements of a VERTEX3D vector to symbols.

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.


5.1.4 Setf expanders

Setf Expander: (setf aabb*) (&rest args)
Package

cl-tuples.

Source

aabb.lisp.

Reader

aabb* (macro).

Writer

aabb-setter* (macro).

Setf Expander: (setf aabb-aref) (array-name tuple-index)
Package

cl-tuples.

Source

aabb.lisp.

Reader

aabb-aref (function).

Writer

aabb-aref-setter (function).

Setf Expander: (setf aabb-aref*) (&rest args)
Package

cl-tuples.

Source

aabb.lisp.

Reader

aabb-aref* (macro).

Writer

aabb-aref-setter* (macro).

Setf Expander: (setf angle-axis*) (&rest args)
Package

cl-tuples.

Source

quaternion.lisp.

Reader

angle-axis* (macro).

Writer

angle-axis-setter* (macro).

Setf Expander: (setf angle-axis-aref) (array-name tuple-index)
Package

cl-tuples.

Source

quaternion.lisp.

Reader

angle-axis-aref (function).

Writer

angle-axis-aref-setter (function).

Setf Expander: (setf angle-axis-aref*) (&rest args)
Package

cl-tuples.

Source

quaternion.lisp.

Reader

angle-axis-aref* (macro).

Writer

angle-axis-aref-setter* (macro).

Setf Expander: (setf colour*) (&rest args)
Package

cl-tuples.

Source

colour.lisp.

Reader

colour* (macro).

Writer

colour-setter* (macro).

Setf Expander: (setf colour-aref) (array-name tuple-index)
Package

cl-tuples.

Source

colour.lisp.

Reader

colour-aref (function).

Writer

colour-aref-setter (function).

Setf Expander: (setf colour-aref*) (&rest args)
Package

cl-tuples.

Source

colour.lisp.

Reader

colour-aref* (macro).

Writer

colour-aref-setter* (macro).

Setf Expander: (setf matrix22*) (&rest args)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix22* (macro).

Writer

matrix22-setter* (macro).

Setf Expander: (setf matrix22-aref) (array-name tuple-index)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix22-aref (function).

Writer

matrix22-aref-setter (function).

Setf Expander: (setf matrix22-aref*) (&rest args)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix22-aref* (macro).

Writer

matrix22-aref-setter* (macro).

Setf Expander: (setf matrix33*) (&rest args)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix33* (macro).

Writer

matrix33-setter* (macro).

Setf Expander: (setf matrix33-aref) (array-name tuple-index)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix33-aref (function).

Writer

matrix33-aref-setter (function).

Setf Expander: (setf matrix33-aref*) (&rest args)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix33-aref* (macro).

Writer

matrix33-aref-setter* (macro).

Setf Expander: (setf matrix44*) (&rest args)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix44* (macro).

Writer

matrix44-setter* (macro).

Setf Expander: (setf matrix44-aref) (array-name tuple-index)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix44-aref (function).

Writer

matrix44-aref-setter (function).

Setf Expander: (setf matrix44-aref*) (&rest args)
Package

cl-tuples.

Source

matrix.lisp.

Reader

matrix44-aref* (macro).

Writer

matrix44-aref-setter* (macro).

Setf Expander: (setf quaternion*) (&rest args)
Package

cl-tuples.

Source

quaternion.lisp.

Reader

quaternion* (macro).

Writer

quaternion-setter* (macro).

Setf Expander: (setf quaternion-aref) (array-name tuple-index)
Package

cl-tuples.

Source

quaternion.lisp.

Reader

quaternion-aref (function).

Writer

quaternion-aref-setter (function).

Setf Expander: (setf quaternion-aref*) (&rest args)
Package

cl-tuples.

Source

quaternion.lisp.

Reader

quaternion-aref* (macro).

Writer

quaternion-aref-setter* (macro).

Setf Expander: (setf rect*) (&rest args)
Package

cl-tuples.

Source

rect.lisp.

Reader

rect* (macro).

Writer

rect-setter* (macro).

Setf Expander: (setf rect-aref) (array-name tuple-index)
Package

cl-tuples.

Source

rect.lisp.

Reader

rect-aref (function).

Writer

rect-aref-setter (function).

Setf Expander: (setf rect-aref*) (&rest args)
Package

cl-tuples.

Source

rect.lisp.

Reader

rect-aref* (macro).

Writer

rect-aref-setter* (macro).

Setf Expander: (setf triangle*) (&rest args)
Package

cl-tuples.

Source

triangle.lisp.

Reader

triangle* (macro).

Writer

triangle-setter* (macro).

Setf Expander: (setf triangle-aref) (array-name tuple-index)
Package

cl-tuples.

Source

triangle.lisp.

Reader

triangle-aref (function).

Writer

triangle-aref-setter (function).

Setf Expander: (setf triangle-aref*) (&rest args)
Package

cl-tuples.

Source

triangle.lisp.

Reader

triangle-aref* (macro).

Writer

triangle-aref-setter* (macro).

Setf Expander: (setf vector2d*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vector2d* (macro).

Writer

vector2d-setter* (macro).

Setf Expander: (setf vector2d-aref) (array-name tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Reader

vector2d-aref (function).

Writer

vector2d-aref-setter (function).

Setf Expander: (setf vector2d-aref*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vector2d-aref* (macro).

Writer

vector2d-aref-setter* (macro).

Setf Expander: (setf vector3d*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vector3d* (macro).

Writer

vector3d-setter* (macro).

Setf Expander: (setf vector3d-aref) (array-name tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Reader

vector3d-aref (function).

Writer

vector3d-aref-setter (function).

Setf Expander: (setf vector3d-aref*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vector3d-aref* (macro).

Writer

vector3d-aref-setter* (macro).

Setf Expander: (setf vertex3d*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vertex3d* (macro).

Writer

vertex3d-setter* (macro).

Setf Expander: (setf vertex3d-aref) (array-name tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Reader

vertex3d-aref (function).

Writer

vertex3d-aref-setter (function).

Setf Expander: (setf vertex3d-aref*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vertex3d-aref* (macro).

Writer

vertex3d-aref-setter* (macro).


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

5.1.5 Ordinary functions

Function: aabb-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

aabb.lisp.

Setf expander for this function

(setf aabb-aref).

Function: aabb-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

aabb.lisp.

Setf expanders to this function

(setf aabb-aref).

Function: aabb-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-fill-pointer (tuple-array)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-vector-push (tuple array-name)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

aabb.lisp.

Function: angle-axis-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

quaternion.lisp.

Setf expander for this function

(setf angle-axis-aref).

Function: angle-axis-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

quaternion.lisp.

Setf expanders to this function

(setf angle-axis-aref).

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

cl-tuples.

Source

quaternion.lisp.

Function: angle-axis-fill-pointer (tuple-array)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf angle-axis-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

quaternion.lisp.

Function: angle-axis-vector-push (tuple array-name)
Package

cl-tuples.

Source

quaternion.lisp.

Function: angle-axis-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

quaternion.lisp.

Function: colour-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

colour.lisp.

Setf expander for this function

(setf colour-aref).

Function: colour-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

colour.lisp.

Setf expanders to this function

(setf colour-aref).

Function: colour-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

colour.lisp.

Function: colour-fill-pointer (tuple-array)
Package

cl-tuples.

Source

colour.lisp.

Function: (setf colour-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

colour.lisp.

Function: colour-vector-push (tuple array-name)
Package

cl-tuples.

Source

colour.lisp.

Function: colour-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

colour.lisp.

Function: make-aabb-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

aabb.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Function: make-colour-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

colour.lisp.

Function: make-matrix22-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

matrix.lisp.

Function: make-matrix33-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

matrix.lisp.

Function: make-matrix44-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

matrix.lisp.

Function: make-quaternion-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

quaternion.lisp.

Function: make-rect-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

rect.lisp.

Function: make-triangle-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

triangle.lisp.

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

cl-tuples.

Source

symbols.lisp.

Function: make-vector2d-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

vector.lisp.

Function: make-vector3d-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

vector.lisp.

Function: make-vertex3d-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

vector.lisp.

Function: matrix22-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this function

(setf matrix22-aref).

Function: matrix22-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

matrix.lisp.

Setf expanders to this function

(setf matrix22-aref).

Function: matrix22-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

matrix.lisp.

Function: matrix22-fill-pointer (tuple-array)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix22-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix22-vector-push (tuple array-name)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix22-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this function

(setf matrix33-aref).

Function: matrix33-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

matrix.lisp.

Setf expanders to this function

(setf matrix33-aref).

Function: matrix33-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-fill-pointer (tuple-array)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-vector-push (tuple array-name)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

matrix.lisp.

Setf expander for this function

(setf matrix44-aref).

Function: matrix44-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

matrix.lisp.

Setf expanders to this function

(setf matrix44-aref).

Function: matrix44-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-fill-pointer (tuple-array)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-vector-push (tuple array-name)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

matrix.lisp.

Function: quaternion-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

quaternion.lisp.

Setf expander for this function

(setf quaternion-aref).

Function: quaternion-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

quaternion.lisp.

Setf expanders to this function

(setf quaternion-aref).

Function: quaternion-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

quaternion.lisp.

Function: quaternion-fill-pointer (tuple-array)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf quaternion-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

quaternion.lisp.

Function: quaternion-vector-push (tuple array-name)
Package

cl-tuples.

Source

quaternion.lisp.

Function: quaternion-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

quaternion.lisp.

Function: rect-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

rect.lisp.

Setf expander for this function

(setf rect-aref).

Function: rect-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

rect.lisp.

Setf expanders to this function

(setf rect-aref).

Function: rect-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

rect.lisp.

Function: rect-fill-pointer (tuple-array)
Package

cl-tuples.

Source

rect.lisp.

Function: (setf rect-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

rect.lisp.

Function: rect-vector-push (tuple array-name)
Package

cl-tuples.

Source

rect.lisp.

Function: rect-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

rect.lisp.

Function: triangle-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

triangle.lisp.

Setf expander for this function

(setf triangle-aref).

Function: triangle-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

triangle.lisp.

Setf expanders to this function

(setf triangle-aref).

Function: triangle-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

triangle.lisp.

Function: triangle-fill-pointer (tuple-array)
Package

cl-tuples.

Source

triangle.lisp.

Function: (setf triangle-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

triangle.lisp.

Function: triangle-vector-push (tuple array-name)
Package

cl-tuples.

Source

triangle.lisp.

Function: triangle-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

triangle.lisp.

Function: tuple-element-type (type-name)

Return the size of the type

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-gensyms (type-name)

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

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-size (type-name)

Return the size of the type

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-typep (type-name)

Test to see if this symbol represents a tuple type

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-typespec (type-name)

Return typespec of tuple as multiple value.

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-typespec* (type-name)

Return typespec of tuple as bounded array

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-typespec** (type-name)

Return typespec of tuple as unbounded array

Package

cl-tuples.

Source

symbols.lisp.

Function: vector2d-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Setf expander for this function

(setf vector2d-aref).

Function: vector2d-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this function

(setf vector2d-aref).

Function: vector2d-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

vector.lisp.

Function: vector2d-fill-pointer (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector2d-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: vector2d-vector-push (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vector2d-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Setf expander for this function

(setf vector3d-aref).

Function: vector3d-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this function

(setf vector3d-aref).

Function: vector3d-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-fill-pointer (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector3d-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-vector-push (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Setf expander for this function

(setf vertex3d-aref).

Function: vertex3d-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this function

(setf vertex3d-aref).

Function: vertex3d-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-fill-pointer (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex3d-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-vector-push (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.


5.1.6 Types

Type: fast-float ()
Package

cl-tuples.

Source

utils.lisp.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *original-readtable*
Package

cl-tuples.

Source

syntax.lisp.

Special Variable: *restore-reader-syntax*
Package

cl-tuples.

Source

syntax.lisp.

Special Variable: *tuple-expander-keywords*
Package

cl-tuples.

Source

tuple-expander.lisp.


5.2.2 Macros

Macro: check-rotation-matrix33* (m)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: check-rotation-matrix44* (m)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: def-new-tuple (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-array-dimensions (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-array-setf (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-array-setf* (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-array-typespec (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-documentation (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-fill-pointer (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-map (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-reduce (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-set (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-setf* (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-setf-fill-pointer (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-struct (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-typespec (type-name)

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

Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-vector-push (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-vector-push* (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-vector-push-extend (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: def-tuple-vector-push-extend* (type-name)
Package

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

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

cl-tuples.

Source

tuples.lisp.

Macro: export-tuple-operations (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: identity-matrix22* ()

DEF-TUPLE-OP IDENTITY-MATRIX22* NIL

Package

cl-tuples.

Source

matrix.lisp.

Macro: identity-matrix33* ()

DEF-TUPLE-OP IDENTITY-MATRIX33* NIL

Package

cl-tuples.

Source

matrix.lisp.

Macro: intersect-aabb* (aabb0 aabb1)

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

Package

cl-tuples.

Source

aabb.lisp.

Macro: make-test-matrix44* ()

Return a matrix for testing purposes

Package

cl-tuples.

Source

matrix.lisp.

Macro: make-tuple-operations (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Macro: make-vertex2d (&rest elements)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: make-vertex2d* (tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-angle-axis* (m)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: matrix33-equal* (k m)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: matrix33-quaternion* (m)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: matrix33-trace* (m)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: matrix44-equal* (k m)

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

Package

cl-tuples.

Source

matrix.lisp.

Macro: multiply-arguments (operator factor arguments)
Package

cl-tuples.

Source

utils.lisp.

Macro: new-vertex2d ()

Create an array suitable for holding a single VERTEX2D

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

quaternion.lisp.

Macro: quaternion-power* (q times)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: rect-height* (r)

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

Package

cl-tuples.

Source

rect.lisp.

Macro: rect-width* (r)

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

Package

cl-tuples.

Source

rect.lisp.

Macro: rotatex-matrix33* (rotation)

Return a matrix for rotating around the x axis.

Package

cl-tuples.

Source

matrix.lisp.

Macro: rotatey-matrix33* (rotation)

Return a matrix for rotating around the y axis.

Package

cl-tuples.

Source

matrix.lisp.

Macro: rotatez-matrix33* (rotation)

Return a matrix for rotating around the z axis.

Package

cl-tuples.

Source

matrix.lisp.

Macro: transform-aabb* (mat box)

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

Package

cl-tuples.

Source

aabb.lisp.

Macro: transpose-matrix22* (mat22)

Return the transpose of the matrix

Package

cl-tuples.

Source

matrix.lisp.

Macro: vector2d-length-square* (vec)

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

Package

cl-tuples.

Source

vector.lisp.

Macro: vector3d-angle-axis* (axis angle)

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

Package

cl-tuples.

Source

quaternion.lisp.

Macro: vector3d-matrix3d* (zvec yvec)

Construct a rotation matrix from 2 vectors

Package

cl-tuples.

Source

matrix.lisp.

Macro: vertex2d* (tuple-array-name)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vertex2d*).

Macro: vertex2d-aref* (tuple-array array-index)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expander for this macro

(setf vertex2d-aref*).

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

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vertex2d-aref*).

Macro: vertex2d-key-values (&key initial-element x y w)
Package

cl-tuples.

Source

vector.lisp.

Macro: vertex2d-map* (operator &rest args)
Package

cl-tuples.

Source

vector.lisp.

Macro: vertex2d-reduce* (operator tuple)
Package

cl-tuples.

Source

vector.lisp.

Macro: vertex2d-setter* (tuple-place tuple-values)

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

Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this macro

(setf vertex2d*).

Macro: vertex2d-values* (&rest elements)

Convert VERTEX2D forms to multiple values.

Package

cl-tuples.

Source

vector.lisp.

Macro: vertex2d-vector-push* (tuple-values array-name)

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

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.

Macro: with-vertex2d (tuple-place element-syms &body forms)

Bind elements of a VERTEX2D multiple value to symbols.

Package

cl-tuples.

Source

vector.lisp.

Macro: with-vertex2d* (tuple element-syms &body forms)

Bind elements of a VERTEX2D vector to symbols.

Package

cl-tuples.

Source

vector.lisp.

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

cl-tuples.

Source

vector.lisp.


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

5.2.3 Setf expanders

Setf Expander: (setf vertex2d*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vertex2d* (macro).

Writer

vertex2d-setter* (macro).

Setf Expander: (setf vertex2d-aref) (array-name tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Reader

vertex2d-aref (function).

Writer

vertex2d-aref-setter (function).

Setf Expander: (setf vertex2d-aref*) (&rest args)
Package

cl-tuples.

Source

vector.lisp.

Reader

vertex2d-aref* (macro).

Writer

vertex2d-aref-setter* (macro).


5.2.4 Ordinary functions

Function: #[-reader (stream char arg)
Package

cl-tuples.

Source

syntax.lisp.

Function: #{-reader (stream char arg)
Package

cl-tuples.

Source

syntax.lisp.

Function: %disable-tuples-syntax ()
Package

cl-tuples.

Source

syntax.lisp.

Function: %enable-tuples-syntax (&optional save-original-p)
Package

cl-tuples.

Source

syntax.lisp.

Function: aabb-maxx (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-maxx) (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-maxy (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-maxy) (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-maxz (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-maxz) (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-minx (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-minx) (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-miny (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-miny) (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: aabb-minz (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: (setf aabb-minz) (structure)
Package

cl-tuples.

Source

aabb.lisp.

Function: angle-axis-a (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf angle-axis-a) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: angle-axis-x (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf angle-axis-x) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: angle-axis-y (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf angle-axis-y) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: angle-axis-z (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf angle-axis-z) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

Function: body-expander-fn (names types elements gensyms body)

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

Package

cl-tuples.

Source

tuple-expander.lisp.

Function: colour-a (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: (setf colour-a) (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: colour-b (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: (setf colour-b) (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: colour-g (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: (setf colour-g) (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: colour-r (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: (setf colour-r) (structure)
Package

cl-tuples.

Source

colour.lisp.

Function: construct-tuple-array-maker (type-name)
Package

cl-tuples.

Source

tuple-expander.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

Function: construct-tuple-set-aref (type-name tuple-place index varlist)
Package

cl-tuples.

Source

tuple-expander.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

Function: copy-aabb (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-angle-axis (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-colour (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-matrix22 (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-matrix33 (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-matrix44 (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-quaternion (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-rect (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-triangle (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-vector2d (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-vector3d (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-vertex2d (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

Function: copy-vertex3d (sequence)

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

Package

cl-tuples.

Alias for

copy-seq.

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

cl-tuples.

Source

tuple-expander.lisp.

Function: document-tuple-type (type-name)
Package

cl-tuples.

Source

tuples.lisp.

Function: is-asterisk-symbol (s)
Package

cl-tuples.

Source

utils.lisp.

Function: last-char (str)
Package

cl-tuples.

Source

utils.lisp.

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

cl-tuples.

Source

utils.lisp.

Function: make-vertex2d-array (dimensions &key adjustable initial-element fill-pointer)

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

Package

cl-tuples.

Source

vector.lisp.

Function: matrix-cofactors (length)
Package

cl-tuples.

Source

utils.lisp.

Function: matrix-minor (x y length &optional prefix)
Package

cl-tuples.

Source

utils.lisp.

Function: matrix-symbol (i j &optional prefix)

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

Package

cl-tuples.

Source

utils.lisp.

Function: matrix22-e00 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix22-e00) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix22-e01 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix22-e01) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix22-e10 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix22-e10) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix22-e11 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix22-e11) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e00 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e00) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e01 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e01) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e02 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e02) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e10 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e10) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e11 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e11) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e12 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e12) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e20 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e20) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e21 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e21) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix33-e22 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix33-e22) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e00 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e00) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e01 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e01) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e02 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e02) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e03 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e03) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e10 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e10) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e11 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e11) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e12 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e12) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e13 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e13) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e20 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e20) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e21 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e21) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e22 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e22) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e23 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e23) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e30 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e30) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e31 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e31) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e32 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e32) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: matrix44-e33 (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: (setf matrix44-e33) (structure)
Package

cl-tuples.

Source

matrix.lisp.

Function: quaternion-w (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf quaternion-w) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: quaternion-x (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf quaternion-x) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: quaternion-y (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf quaternion-y) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: quaternion-z (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: (setf quaternion-z) (structure)
Package

cl-tuples.

Source

quaternion.lisp.

Function: rect-bottom (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: (setf rect-bottom) (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: rect-left (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: (setf rect-left) (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: rect-right (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: (setf rect-right) (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: rect-top (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: (setf rect-top) (structure)
Package

cl-tuples.

Source

rect.lisp.

Function: simple-tuple-typespec* (type-name)

Return typespec of tuple as bounded array

Package

cl-tuples.

Source

symbols.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

Function: symbol-to-string (sym)

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

Package

cl-tuples.

Source

utils.lisp.

Function: triangle-a (structure)
Package

cl-tuples.

Source

triangle.lisp.

Function: (setf triangle-a) (structure)
Package

cl-tuples.

Source

triangle.lisp.

Function: triangle-b (structure)
Package

cl-tuples.

Source

triangle.lisp.

Function: (setf triangle-b) (structure)
Package

cl-tuples.

Source

triangle.lisp.

Function: triangle-c (structure)
Package

cl-tuples.

Source

triangle.lisp.

Function: (setf triangle-c) (structure)
Package

cl-tuples.

Source

triangle.lisp.

Function: tuple-elements (type-name)

Return a list of element names

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-initial-element (type-name)

Return the inital element type of a tuple array

Package

cl-tuples.

Source

symbols.lisp.

Function: tuple-places (type-name array-name)

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

Package

cl-tuples.

Source

symbols.lisp.

Function: vector2d-x (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector2d-x) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vector2d-y (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector2d-y) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-x (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector3d-x) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-y (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector3d-y) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vector3d-z (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vector3d-z) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-aref (tuple-array tuple-index)
Package

cl-tuples.

Source

vector.lisp.

Setf expander for this function

(setf vertex2d-aref).

Function: vertex2d-aref-setter (array-name tuple-index tuple)
Package

cl-tuples.

Source

vector.lisp.

Setf expanders to this function

(setf vertex2d-aref).

Function: vertex2d-array-dimensions (tuple-array)

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

Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-fill-pointer (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex2d-fill-pointer) (tuple-array)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-vector-push (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-vector-push-extend (tuple array-name)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-w (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex2d-w) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-x (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex2d-x) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex2d-y (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex2d-y) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-w (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex3d-w) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-x (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex3d-x) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-y (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex3d-y) (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: vertex3d-z (structure)
Package

cl-tuples.

Source

vector.lisp.

Function: (setf vertex3d-z) (structure)
Package

cl-tuples.

Source

vector.lisp.


5.2.5 Generic functions

Generic Function: tuple-expansion-fn (type-name expansion)
Package

cl-tuples.

Source

tuple-expander.lisp.

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

cl-tuples.

Source

tuple-expander.lisp.

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

Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   #   %   (  
A   B   C   D   E   F   G   I   L   M   N   P   Q   R   S   T   V   W  
Index Entry  Section

#
#[-reader: Private ordinary functions
#{-reader: Private ordinary functions

%
%disable-tuples-syntax: Private ordinary functions
%enable-tuples-syntax: Private ordinary functions

(
(setf aabb*): Public setf expanders
(setf aabb-aref): Public setf expanders
(setf aabb-aref*): Public setf expanders
(setf aabb-fill-pointer): Public ordinary functions
(setf aabb-maxx): Private ordinary functions
(setf aabb-maxy): Private ordinary functions
(setf aabb-maxz): Private ordinary functions
(setf aabb-minx): Private ordinary functions
(setf aabb-miny): Private ordinary functions
(setf aabb-minz): Private ordinary functions
(setf angle-axis*): Public setf expanders
(setf angle-axis-a): Private ordinary functions
(setf angle-axis-aref): Public setf expanders
(setf angle-axis-aref*): Public setf expanders
(setf angle-axis-fill-pointer): Public ordinary functions
(setf angle-axis-x): Private ordinary functions
(setf angle-axis-y): Private ordinary functions
(setf angle-axis-z): Private ordinary functions
(setf colour*): Public setf expanders
(setf colour-a): Private ordinary functions
(setf colour-aref): Public setf expanders
(setf colour-aref*): Public setf expanders
(setf colour-b): Private ordinary functions
(setf colour-fill-pointer): Public ordinary functions
(setf colour-g): Private ordinary functions
(setf colour-r): Private ordinary functions
(setf matrix22*): Public setf expanders
(setf matrix22-aref): Public setf expanders
(setf matrix22-aref*): Public setf expanders
(setf matrix22-e00): Private ordinary functions
(setf matrix22-e01): Private ordinary functions
(setf matrix22-e10): Private ordinary functions
(setf matrix22-e11): Private ordinary functions
(setf matrix22-fill-pointer): Public ordinary functions
(setf matrix33*): Public setf expanders
(setf matrix33-aref): Public setf expanders
(setf matrix33-aref*): Public setf expanders
(setf matrix33-e00): Private ordinary functions
(setf matrix33-e01): Private ordinary functions
(setf matrix33-e02): Private ordinary functions
(setf matrix33-e10): Private ordinary functions
(setf matrix33-e11): Private ordinary functions
(setf matrix33-e12): Private ordinary functions
(setf matrix33-e20): Private ordinary functions
(setf matrix33-e21): Private ordinary functions
(setf matrix33-e22): Private ordinary functions
(setf matrix33-fill-pointer): Public ordinary functions
(setf matrix44*): Public setf expanders
(setf matrix44-aref): Public setf expanders
(setf matrix44-aref*): Public setf expanders
(setf matrix44-e00): Private ordinary functions
(setf matrix44-e01): Private ordinary functions
(setf matrix44-e02): Private ordinary functions
(setf matrix44-e03): Private ordinary functions
(setf matrix44-e10): Private ordinary functions
(setf matrix44-e11): Private ordinary functions
(setf matrix44-e12): Private ordinary functions
(setf matrix44-e13): Private ordinary functions
(setf matrix44-e20): Private ordinary functions
(setf matrix44-e21): Private ordinary functions
(setf matrix44-e22): Private ordinary functions
(setf matrix44-e23): Private ordinary functions
(setf matrix44-e30): Private ordinary functions
(setf matrix44-e31): Private ordinary functions
(setf matrix44-e32): Private ordinary functions
(setf matrix44-e33): Private ordinary functions
(setf matrix44-fill-pointer): Public ordinary functions
(setf quaternion*): Public setf expanders
(setf quaternion-aref): Public setf expanders
(setf quaternion-aref*): Public setf expanders
(setf quaternion-fill-pointer): Public ordinary functions
(setf quaternion-w): Private ordinary functions
(setf quaternion-x): Private ordinary functions
(setf quaternion-y): Private ordinary functions
(setf quaternion-z): Private ordinary functions
(setf rect*): Public setf expanders
(setf rect-aref): Public setf expanders
(setf rect-aref*): Public setf expanders
(setf rect-bottom): Private ordinary functions
(setf rect-fill-pointer): Public ordinary functions
(setf rect-left): Private ordinary functions
(setf rect-right): Private ordinary functions
(setf rect-top): Private ordinary functions
(setf triangle*): Public setf expanders
(setf triangle-a): Private ordinary functions
(setf triangle-aref): Public setf expanders
(setf triangle-aref*): Public setf expanders
(setf triangle-b): Private ordinary functions
(setf triangle-c): Private ordinary functions
(setf triangle-fill-pointer): Public ordinary functions
(setf vector2d*): Public setf expanders
(setf vector2d-aref): Public setf expanders
(setf vector2d-aref*): Public setf expanders
(setf vector2d-fill-pointer): Public ordinary functions
(setf vector2d-x): Private ordinary functions
(setf vector2d-y): Private ordinary functions
(setf vector3d*): Public setf expanders
(setf vector3d-aref): Public setf expanders
(setf vector3d-aref*): Public setf expanders
(setf vector3d-fill-pointer): Public ordinary functions
(setf vector3d-x): Private ordinary functions
(setf vector3d-y): Private ordinary functions
(setf vector3d-z): Private ordinary functions
(setf vertex2d*): Private setf expanders
(setf vertex2d-aref): Private setf expanders
(setf vertex2d-aref*): Private setf expanders
(setf vertex2d-fill-pointer): Private ordinary functions
(setf vertex2d-w): Private ordinary functions
(setf vertex2d-x): Private ordinary functions
(setf vertex2d-y): Private ordinary functions
(setf vertex3d*): Public setf expanders
(setf vertex3d-aref): Public setf expanders
(setf vertex3d-aref*): Public setf expanders
(setf vertex3d-fill-pointer): Public ordinary functions
(setf vertex3d-w): Private ordinary functions
(setf vertex3d-x): Private ordinary functions
(setf vertex3d-y): Private ordinary functions
(setf vertex3d-z): Private ordinary functions

A
aabb*: Public macros
aabb-aref: Public ordinary functions
aabb-aref*: Public macros
aabb-aref-setter: Public ordinary functions
aabb-aref-setter*: Public macros
aabb-array-dimensions: Public ordinary functions
aabb-fill-pointer: Public ordinary functions
aabb-key-values: Public macros
aabb-map*: Public macros
aabb-maxx: Private ordinary functions
aabb-maxy: Private ordinary functions
aabb-maxz: Private ordinary functions
aabb-minx: Private ordinary functions
aabb-miny: Private ordinary functions
aabb-minz: Private ordinary functions
aabb-reduce*: Public macros
aabb-setter*: Public macros
aabb-values*: Public macros
aabb-vector-push: Public ordinary functions
aabb-vector-push*: Public macros
aabb-vector-push-extend: Public ordinary functions
aabb-vector-push-extend*: Public macros
angle-axis*: Public macros
angle-axis-a: Private ordinary functions
angle-axis-aref: Public ordinary functions
angle-axis-aref*: Public macros
angle-axis-aref-setter: Public ordinary functions
angle-axis-aref-setter*: Public macros
angle-axis-array-dimensions: Public ordinary functions
angle-axis-fill-pointer: Public ordinary functions
angle-axis-key-values: Public macros
angle-axis-map*: Public macros
angle-axis-matrix33*: Public macros
angle-axis-quaternion*: Public macros
angle-axis-reduce*: Public macros
angle-axis-setter*: Public macros
angle-axis-values*: Public macros
angle-axis-vector-push: Public ordinary functions
angle-axis-vector-push*: Public macros
angle-axis-vector-push-extend: Public ordinary functions
angle-axis-vector-push-extend*: Public macros
angle-axis-x: Private ordinary functions
angle-axis-y: Private ordinary functions
angle-axis-z: Private ordinary functions
arg-expander-fn-aux: Private ordinary functions
arg-expander-fn-aux-with: Private ordinary functions

B
body-expander-fn: Private ordinary functions

C
check-rotation-matrix33*: Private macros
check-rotation-matrix44*: Private macros
cofactor-matrix22*: Public macros
cofactor-matrix33*: Public macros
cofactor-matrix44*: Public macros
colour*: Public macros
colour-a: Private ordinary functions
colour-aref: Public ordinary functions
colour-aref*: Public macros
colour-aref-setter: Public ordinary functions
colour-aref-setter*: Public macros
colour-array-dimensions: Public ordinary functions
colour-b: Private ordinary functions
colour-fill-pointer: Public ordinary functions
colour-g: Private ordinary functions
colour-key-values: Public macros
colour-map*: Public macros
colour-r: Private ordinary functions
colour-reduce*: Public macros
colour-setter*: Public macros
colour-values*: Public macros
colour-vector-push: Public ordinary functions
colour-vector-push*: Public macros
colour-vector-push-extend: Public ordinary functions
colour-vector-push-extend*: Public macros
construct-tuple-array-maker: Private ordinary functions
construct-tuple-array-reference: Private ordinary functions
construct-tuple-set-aref: Private ordinary functions
construct-tuple-slots: Private ordinary functions
construct-tuple-value-type: Private ordinary functions
copy-aabb: Private ordinary functions
copy-angle-axis: Private ordinary functions
copy-colour: Private ordinary functions
copy-matrix22: Private ordinary functions
copy-matrix33: Private ordinary functions
copy-matrix44: Private ordinary functions
copy-quaternion: Private ordinary functions
copy-rect: Private ordinary functions
copy-triangle: Private ordinary functions
copy-vector2d: Private ordinary functions
copy-vector3d: Private ordinary functions
copy-vertex2d: Private ordinary functions
copy-vertex3d: Private ordinary functions

D
def-new-tuple: Private macros
def-tuple: Private macros
def-tuple-aref: Private macros
def-tuple-aref*: Private macros
def-tuple-aref-setter: Private macros
def-tuple-aref-setter*: Private macros
def-tuple-array-dimensions: Private macros
def-tuple-array-maker: Private macros
def-tuple-array-setf: Private macros
def-tuple-array-setf*: Private macros
def-tuple-array-typespec: Private macros
def-tuple-documentation: Private macros
def-tuple-expander-fn: Private ordinary functions
def-tuple-fill-pointer: Private macros
def-tuple-getter: Private macros
def-tuple-key: Private macros
def-tuple-maker: Private macros
def-tuple-maker*: Private macros
def-tuple-map: Private macros
def-tuple-op: Public macros
def-tuple-reduce: Private macros
def-tuple-set: Private macros
def-tuple-setf*: Private macros
def-tuple-setf-fill-pointer: Private macros
def-tuple-setter: Private macros
def-tuple-struct: Private macros
def-tuple-type: Public macros
def-tuple-typespec: Private macros
def-tuple-vector-push: Private macros
def-tuple-vector-push*: Private macros
def-tuple-vector-push-extend: Private macros
def-tuple-vector-push-extend*: Private macros
def-with-tuple: Private macros
def-with-tuple*: Private macros
def-with-tuple-aref: Private macros
delta-vector3d*: Public macros
disable-tuples-syntax: Public macros
document-tuple-type: Private ordinary functions

E
enable-tuples-syntax: Public macros
export-tuple-operations: Private macros

F
file-enable-tuples-syntax: Public macros
Function, #[-reader: Private ordinary functions
Function, #{-reader: Private ordinary functions
Function, %disable-tuples-syntax: Private ordinary functions
Function, %enable-tuples-syntax: Private ordinary functions
Function, (setf aabb-fill-pointer): Public ordinary functions
Function, (setf aabb-maxx): Private ordinary functions
Function, (setf aabb-maxy): Private ordinary functions
Function, (setf aabb-maxz): Private ordinary functions
Function, (setf aabb-minx): Private ordinary functions
Function, (setf aabb-miny): Private ordinary functions
Function, (setf aabb-minz): Private ordinary functions
Function, (setf angle-axis-a): Private ordinary functions
Function, (setf angle-axis-fill-pointer): Public ordinary functions
Function, (setf angle-axis-x): Private ordinary functions
Function, (setf angle-axis-y): Private ordinary functions
Function, (setf angle-axis-z): Private ordinary functions
Function, (setf colour-a): Private ordinary functions
Function, (setf colour-b): Private ordinary functions
Function, (setf colour-fill-pointer): Public ordinary functions
Function, (setf colour-g): Private ordinary functions
Function, (setf colour-r): Private ordinary functions
Function, (setf matrix22-e00): Private ordinary functions
Function, (setf matrix22-e01): Private ordinary functions
Function, (setf matrix22-e10): Private ordinary functions
Function, (setf matrix22-e11): Private ordinary functions
Function, (setf matrix22-fill-pointer): Public ordinary functions
Function, (setf matrix33-e00): Private ordinary functions
Function, (setf matrix33-e01): Private ordinary functions
Function, (setf matrix33-e02): Private ordinary functions
Function, (setf matrix33-e10): Private ordinary functions
Function, (setf matrix33-e11): Private ordinary functions
Function, (setf matrix33-e12): Private ordinary functions
Function, (setf matrix33-e20): Private ordinary functions
Function, (setf matrix33-e21): Private ordinary functions
Function, (setf matrix33-e22): Private ordinary functions
Function, (setf matrix33-fill-pointer): Public ordinary functions
Function, (setf matrix44-e00): Private ordinary functions
Function, (setf matrix44-e01): Private ordinary functions
Function, (setf matrix44-e02): Private ordinary functions
Function, (setf matrix44-e03): Private ordinary functions
Function, (setf matrix44-e10): Private ordinary functions
Function, (setf matrix44-e11): Private ordinary functions
Function, (setf matrix44-e12): Private ordinary functions
Function, (setf matrix44-e13): Private ordinary functions
Function, (setf matrix44-e20): Private ordinary functions
Function, (setf matrix44-e21): Private ordinary functions
Function, (setf matrix44-e22): Private ordinary functions
Function, (setf matrix44-e23): Private ordinary functions
Function, (setf matrix44-e30): Private ordinary functions
Function, (setf matrix44-e31): Private ordinary functions
Function, (setf matrix44-e32): Private ordinary functions
Function, (setf matrix44-e33): Private ordinary functions
Function, (setf matrix44-fill-pointer): Public ordinary functions
Function, (setf quaternion-fill-pointer): Public ordinary functions
Function, (setf quaternion-w): Private ordinary functions
Function, (setf quaternion-x): Private ordinary functions
Function, (setf quaternion-y): Private ordinary functions
Function, (setf quaternion-z): Private ordinary functions
Function, (setf rect-bottom): Private ordinary functions
Function, (setf rect-fill-pointer): Public ordinary functions
Function, (setf rect-left): Private ordinary functions
Function, (setf rect-right): Private ordinary functions
Function, (setf rect-top): Private ordinary functions
Function, (setf triangle-a): Private ordinary functions
Function, (setf triangle-b): Private ordinary functions
Function, (setf triangle-c): Private ordinary functions
Function, (setf triangle-fill-pointer): Public ordinary functions
Function, (setf vector2d-fill-pointer): Public ordinary functions
Function, (setf vector2d-x): Private ordinary functions
Function, (setf vector2d-y): Private ordinary functions
Function, (setf vector3d-fill-pointer): Public ordinary functions
Function, (setf vector3d-x): Private ordinary functions
Function, (setf vector3d-y): Private ordinary functions
Function, (setf vector3d-z): Private ordinary functions
Function, (setf vertex2d-fill-pointer): Private ordinary functions
Function, (setf vertex2d-w): Private ordinary functions
Function, (setf vertex2d-x): Private ordinary functions
Function, (setf vertex2d-y): Private ordinary functions
Function, (setf vertex3d-fill-pointer): Public ordinary functions
Function, (setf vertex3d-w): Private ordinary functions
Function, (setf vertex3d-x): Private ordinary functions
Function, (setf vertex3d-y): Private ordinary functions
Function, (setf vertex3d-z): Private ordinary functions
Function, aabb-aref: Public ordinary functions
Function, aabb-aref-setter: Public ordinary functions
Function, aabb-array-dimensions: Public ordinary functions
Function, aabb-fill-pointer: Public ordinary functions
Function, aabb-maxx: Private ordinary functions
Function, aabb-maxy: Private ordinary functions
Function, aabb-maxz: Private ordinary functions
Function, aabb-minx: Private ordinary functions
Function, aabb-miny: Private ordinary functions
Function, aabb-minz: Private ordinary functions
Function, aabb-vector-push: Public ordinary functions
Function, aabb-vector-push-extend: Public ordinary functions
Function, angle-axis-a: Private ordinary functions
Function, angle-axis-aref: Public ordinary functions
Function, angle-axis-aref-setter: Public ordinary functions
Function, angle-axis-array-dimensions: Public ordinary functions
Function, angle-axis-fill-pointer: Public ordinary functions
Function, angle-axis-vector-push: Public ordinary functions
Function, angle-axis-vector-push-extend: Public ordinary functions
Function, angle-axis-x: Private ordinary functions
Function, angle-axis-y: Private ordinary functions
Function, angle-axis-z: Private ordinary functions
Function, arg-expander-fn-aux: Private ordinary functions
Function, arg-expander-fn-aux-with: Private ordinary functions
Function, body-expander-fn: Private ordinary functions
Function, colour-a: Private ordinary functions
Function, colour-aref: Public ordinary functions
Function, colour-aref-setter: Public ordinary functions
Function, colour-array-dimensions: Public ordinary functions
Function, colour-b: Private ordinary functions
Function, colour-fill-pointer: Public ordinary functions
Function, colour-g: Private ordinary functions
Function, colour-r: Private ordinary functions
Function, colour-vector-push: Public ordinary functions
Function, colour-vector-push-extend: Public ordinary functions
Function, construct-tuple-array-maker: Private ordinary functions
Function, construct-tuple-array-reference: Private ordinary functions
Function, construct-tuple-set-aref: Private ordinary functions
Function, construct-tuple-slots: Private ordinary functions
Function, construct-tuple-value-type: Private ordinary functions
Function, copy-aabb: Private ordinary functions
Function, copy-angle-axis: Private ordinary functions
Function, copy-colour: Private ordinary functions
Function, copy-matrix22: Private ordinary functions
Function, copy-matrix33: Private ordinary functions
Function, copy-matrix44: Private ordinary functions
Function, copy-quaternion: Private ordinary functions
Function, copy-rect: Private ordinary functions
Function, copy-triangle: Private ordinary functions
Function, copy-vector2d: Private ordinary functions
Function, copy-vector3d: Private ordinary functions
Function, copy-vertex2d: Private ordinary functions
Function, copy-vertex3d: Private ordinary functions
Function, def-tuple-expander-fn: Private ordinary functions
Function, document-tuple-type: Private ordinary functions
Function, is-asterisk-symbol: Private ordinary functions
Function, last-char: Private ordinary functions
Function, make-aabb-array: Public ordinary functions
Function, make-adorned-symbol: Private ordinary functions
Function, make-angle-axis-array: Public ordinary functions
Function, make-colour-array: Public ordinary functions
Function, make-matrix22-array: Public ordinary functions
Function, make-matrix33-array: Public ordinary functions
Function, make-matrix44-array: Public ordinary functions
Function, make-quaternion-array: Public ordinary functions
Function, make-rect-array: Public ordinary functions
Function, make-triangle-array: Public ordinary functions
Function, make-tuple-symbol: Public ordinary functions
Function, make-vector2d-array: Public ordinary functions
Function, make-vector3d-array: Public ordinary functions
Function, make-vertex2d-array: Private ordinary functions
Function, make-vertex3d-array: Public ordinary functions
Function, matrix-cofactors: Private ordinary functions
Function, matrix-minor: Private ordinary functions
Function, matrix-symbol: Private ordinary functions
Function, matrix22-aref: Public ordinary functions
Function, matrix22-aref-setter: Public ordinary functions
Function, matrix22-array-dimensions: Public ordinary functions
Function, matrix22-e00: Private ordinary functions
Function, matrix22-e01: Private ordinary functions
Function, matrix22-e10: Private ordinary functions
Function, matrix22-e11: Private ordinary functions
Function, matrix22-fill-pointer: Public ordinary functions
Function, matrix22-vector-push: Public ordinary functions
Function, matrix22-vector-push-extend: Public ordinary functions
Function, matrix33-aref: Public ordinary functions
Function, matrix33-aref-setter: Public ordinary functions
Function, matrix33-array-dimensions: Public ordinary functions
Function, matrix33-e00: Private ordinary functions
Function, matrix33-e01: Private ordinary functions
Function, matrix33-e02: Private ordinary functions
Function, matrix33-e10: Private ordinary functions
Function, matrix33-e11: Private ordinary functions
Function, matrix33-e12: Private ordinary functions
Function, matrix33-e20: Private ordinary functions
Function, matrix33-e21: Private ordinary functions
Function, matrix33-e22: Private ordinary functions
Function, matrix33-fill-pointer: Public ordinary functions
Function, matrix33-vector-push: Public ordinary functions
Function, matrix33-vector-push-extend: Public ordinary functions
Function, matrix44-aref: Public ordinary functions
Function, matrix44-aref-setter: Public ordinary functions
Function, matrix44-array-dimensions: Public ordinary functions
Function, matrix44-e00: Private ordinary functions
Function, matrix44-e01: Private ordinary functions
Function, matrix44-e02: Private ordinary functions
Function, matrix44-e03: Private ordinary functions
Function, matrix44-e10: Private ordinary functions
Function, matrix44-e11: Private ordinary functions
Function, matrix44-e12: Private ordinary functions
Function, matrix44-e13: Private ordinary functions
Function, matrix44-e20: Private ordinary functions
Function, matrix44-e21: Private ordinary functions
Function, matrix44-e22: Private ordinary functions
Function, matrix44-e23: Private ordinary functions
Function, matrix44-e30: Private ordinary functions
Function, matrix44-e31: Private ordinary functions
Function, matrix44-e32: Private ordinary functions
Function, matrix44-e33: Private ordinary functions
Function, matrix44-fill-pointer: Public ordinary functions
Function, matrix44-vector-push: Public ordinary functions
Function, matrix44-vector-push-extend: Public ordinary functions
Function, quaternion-aref: Public ordinary functions
Function, quaternion-aref-setter: Public ordinary functions
Function, quaternion-array-dimensions: Public ordinary functions
Function, quaternion-fill-pointer: Public ordinary functions
Function, quaternion-vector-push: Public ordinary functions
Function, quaternion-vector-push-extend: Public ordinary functions
Function, quaternion-w: Private ordinary functions
Function, quaternion-x: Private ordinary functions
Function, quaternion-y: Private ordinary functions
Function, quaternion-z: Private ordinary functions
Function, rect-aref: Public ordinary functions
Function, rect-aref-setter: Public ordinary functions
Function, rect-array-dimensions: Public ordinary functions
Function, rect-bottom: Private ordinary functions
Function, rect-fill-pointer: Public ordinary functions
Function, rect-left: Private ordinary functions
Function, rect-right: Private ordinary functions
Function, rect-top: Private ordinary functions
Function, rect-vector-push: Public ordinary functions
Function, rect-vector-push-extend: Public ordinary functions
Function, simple-tuple-typespec*: Private ordinary functions
Function, symbol-macro-expander-fn: Private ordinary functions
Function, symbol-to-string: Private ordinary functions
Function, triangle-a: Private ordinary functions
Function, triangle-aref: Public ordinary functions
Function, triangle-aref-setter: Public ordinary functions
Function, triangle-array-dimensions: Public ordinary functions
Function, triangle-b: Private ordinary functions
Function, triangle-c: Private ordinary functions
Function, triangle-fill-pointer: Public ordinary functions
Function, triangle-vector-push: Public ordinary functions
Function, triangle-vector-push-extend: Public ordinary functions
Function, tuple-element-type: Public ordinary functions
Function, tuple-elements: Private ordinary functions
Function, tuple-gensyms: Public ordinary functions
Function, tuple-initial-element: Private ordinary functions
Function, tuple-places: Private ordinary functions
Function, tuple-size: Public ordinary functions
Function, tuple-typep: Public ordinary functions
Function, tuple-typespec: Public ordinary functions
Function, tuple-typespec*: Public ordinary functions
Function, tuple-typespec**: Public ordinary functions
Function, vector2d-aref: Public ordinary functions
Function, vector2d-aref-setter: Public ordinary functions
Function, vector2d-array-dimensions: Public ordinary functions
Function, vector2d-fill-pointer: Public ordinary functions
Function, vector2d-vector-push: Public ordinary functions
Function, vector2d-vector-push-extend: Public ordinary functions
Function, vector2d-x: Private ordinary functions
Function, vector2d-y: Private ordinary functions
Function, vector3d-aref: Public ordinary functions
Function, vector3d-aref-setter: Public ordinary functions
Function, vector3d-array-dimensions: Public ordinary functions
Function, vector3d-fill-pointer: Public ordinary functions
Function, vector3d-vector-push: Public ordinary functions
Function, vector3d-vector-push-extend: Public ordinary functions
Function, vector3d-x: Private ordinary functions
Function, vector3d-y: Private ordinary functions
Function, vector3d-z: Private ordinary functions
Function, vertex2d-aref: Private ordinary functions
Function, vertex2d-aref-setter: Private ordinary functions
Function, vertex2d-array-dimensions: Private ordinary functions
Function, vertex2d-fill-pointer: Private ordinary functions
Function, vertex2d-vector-push: Private ordinary functions
Function, vertex2d-vector-push-extend: Private ordinary functions
Function, vertex2d-w: Private ordinary functions
Function, vertex2d-x: Private ordinary functions
Function, vertex2d-y: Private ordinary functions
Function, vertex3d-aref: Public ordinary functions
Function, vertex3d-aref-setter: Public ordinary functions
Function, vertex3d-array-dimensions: Public ordinary functions
Function, vertex3d-fill-pointer: Public ordinary functions
Function, vertex3d-vector-push: Public ordinary functions
Function, vertex3d-vector-push-extend: Public ordinary functions
Function, vertex3d-w: Private ordinary functions
Function, vertex3d-x: Private ordinary functions
Function, vertex3d-y: Private ordinary functions
Function, vertex3d-z: Private ordinary functions

G
Generic Function, tuple-expansion-fn: Private generic functions
Generic Function, tuple-symbol: Private generic functions

I
identity-matrix22*: Private macros
identity-matrix33*: Private macros
identity-matrix44*: Public macros
intersect-aabb*: Private macros
inverted-matrix22*: Public macros
inverted-matrix33*: Public macros
inverted-matrix44*: Public macros
is-asterisk-symbol: Private ordinary functions

L
last-char: Private ordinary functions
locally-disable-tuples-syntax: Public macros
locally-enable-tuples-syntax: Public macros

M
Macro, aabb*: Public macros
Macro, aabb-aref*: Public macros
Macro, aabb-aref-setter*: Public macros
Macro, aabb-key-values: Public macros
Macro, aabb-map*: Public macros
Macro, aabb-reduce*: Public macros
Macro, aabb-setter*: Public macros
Macro, aabb-values*: Public macros
Macro, aabb-vector-push*: Public macros
Macro, aabb-vector-push-extend*: Public macros
Macro, angle-axis*: Public macros
Macro, angle-axis-aref*: Public macros
Macro, angle-axis-aref-setter*: Public macros
Macro, angle-axis-key-values: Public macros
Macro, angle-axis-map*: Public macros
Macro, angle-axis-matrix33*: Public macros
Macro, angle-axis-quaternion*: Public macros
Macro, angle-axis-reduce*: Public macros
Macro, angle-axis-setter*: Public macros
Macro, angle-axis-values*: Public macros
Macro, angle-axis-vector-push*: Public macros
Macro, angle-axis-vector-push-extend*: Public macros
Macro, check-rotation-matrix33*: Private macros
Macro, check-rotation-matrix44*: Private macros
Macro, cofactor-matrix22*: Public macros
Macro, cofactor-matrix33*: Public macros
Macro, cofactor-matrix44*: Public macros
Macro, colour*: Public macros
Macro, colour-aref*: Public macros
Macro, colour-aref-setter*: Public macros
Macro, colour-key-values: Public macros
Macro, colour-map*: Public macros
Macro, colour-reduce*: Public macros
Macro, colour-setter*: Public macros
Macro, colour-values*: Public macros
Macro, colour-vector-push*: Public macros
Macro, colour-vector-push-extend*: Public macros
Macro, def-new-tuple: Private macros
Macro, def-tuple: Private macros
Macro, def-tuple-aref: Private macros
Macro, def-tuple-aref*: Private macros
Macro, def-tuple-aref-setter: Private macros
Macro, def-tuple-aref-setter*: Private macros
Macro, def-tuple-array-dimensions: Private macros
Macro, def-tuple-array-maker: Private macros
Macro, def-tuple-array-setf: Private macros
Macro, def-tuple-array-setf*: Private macros
Macro, def-tuple-array-typespec: Private macros
Macro, def-tuple-documentation: Private macros
Macro, def-tuple-fill-pointer: Private macros
Macro, def-tuple-getter: Private macros
Macro, def-tuple-key: Private macros
Macro, def-tuple-maker: Private macros
Macro, def-tuple-maker*: Private macros
Macro, def-tuple-map: Private macros
Macro, def-tuple-op: Public macros
Macro, def-tuple-reduce: Private macros
Macro, def-tuple-set: Private macros
Macro, def-tuple-setf*: Private macros
Macro, def-tuple-setf-fill-pointer: Private macros
Macro, def-tuple-setter: Private macros
Macro, def-tuple-struct: Private macros
Macro, def-tuple-type: Public macros
Macro, def-tuple-typespec: Private macros
Macro, def-tuple-vector-push: Private macros
Macro, def-tuple-vector-push*: Private macros
Macro, def-tuple-vector-push-extend: Private macros
Macro, def-tuple-vector-push-extend*: Private macros
Macro, def-with-tuple: Private macros
Macro, def-with-tuple*: Private macros
Macro, def-with-tuple-aref: Private macros
Macro, delta-vector3d*: Public macros
Macro, disable-tuples-syntax: Public macros
Macro, enable-tuples-syntax: Public macros
Macro, export-tuple-operations: Private macros
Macro, file-enable-tuples-syntax: Public macros
Macro, identity-matrix22*: Private macros
Macro, identity-matrix33*: Private macros
Macro, identity-matrix44*: Public macros
Macro, intersect-aabb*: Private macros
Macro, inverted-matrix22*: Public macros
Macro, inverted-matrix33*: Public macros
Macro, inverted-matrix44*: Public macros
Macro, locally-disable-tuples-syntax: Public macros
Macro, locally-enable-tuples-syntax: Public macros
Macro, make-aabb: Public macros
Macro, make-aabb*: Public macros
Macro, make-angle-axis: Public macros
Macro, make-angle-axis*: Public macros
Macro, make-colour: Public macros
Macro, make-colour*: Public macros
Macro, make-matrix22: Public macros
Macro, make-matrix22*: Public macros
Macro, make-matrix33: Public macros
Macro, make-matrix33*: Public macros
Macro, make-matrix44: Public macros
Macro, make-matrix44*: Public macros
Macro, make-quaternion: Public macros
Macro, make-quaternion*: Public macros
Macro, make-rect: Public macros
Macro, make-rect*: Public macros
Macro, make-test-matrix44*: Private macros
Macro, make-triangle: Public macros
Macro, make-triangle*: Public macros
Macro, make-tuple-operations: Private macros
Macro, make-vector2d: Public macros
Macro, make-vector2d*: Public macros
Macro, make-vector3d: Public macros
Macro, make-vector3d*: Public macros
Macro, make-vertex2d: Private macros
Macro, make-vertex2d*: Private macros
Macro, make-vertex3d: Public macros
Macro, make-vertex3d*: Public macros
Macro, matrix-dot: Private macros
Macro, matrix22*: Public macros
Macro, matrix22-aref*: Public macros
Macro, matrix22-aref-setter*: Public macros
Macro, matrix22-determinant*: Public macros
Macro, matrix22-key-values: Public macros
Macro, matrix22-map*: Public macros
Macro, matrix22-reduce*: Public macros
Macro, matrix22-scale*: Public macros
Macro, matrix22-setter*: Public macros
Macro, matrix22-values*: Public macros
Macro, matrix22-vector-push*: Public macros
Macro, matrix22-vector-push-extend*: Public macros
Macro, matrix33*: Public macros
Macro, matrix33-angle-axis*: Private macros
Macro, matrix33-aref*: Public macros
Macro, matrix33-aref-setter*: Public macros
Macro, matrix33-determinant*: Public macros
Macro, matrix33-equal*: Private macros
Macro, matrix33-key-values: Public macros
Macro, matrix33-map*: Public macros
Macro, matrix33-matrix44*: Public macros
Macro, matrix33-product*: Public macros
Macro, matrix33-quaternion*: Private macros
Macro, matrix33-reduce*: Public macros
Macro, matrix33-scale*: Public macros
Macro, matrix33-setter*: Public macros
Macro, matrix33-trace*: Private macros
Macro, matrix33-values*: Public macros
Macro, matrix33-vector-push*: Public macros
Macro, matrix33-vector-push-extend*: Public macros
Macro, matrix44*: Public macros
Macro, matrix44-aref*: Public macros
Macro, matrix44-aref-setter*: Public macros
Macro, matrix44-determinant*: Public macros
Macro, matrix44-equal*: Private macros
Macro, matrix44-key-values: Public macros
Macro, matrix44-map*: Public macros
Macro, matrix44-matrix33*: Public macros
Macro, matrix44-product*: Public macros
Macro, matrix44-reduce*: Public macros
Macro, matrix44-scale*: Public macros
Macro, matrix44-setter*: Public macros
Macro, matrix44-values*: Public macros
Macro, matrix44-vector-push*: Public macros
Macro, matrix44-vector-push-extend*: Public macros
Macro, multiply-arguments: Private macros
Macro, new-aabb: Public macros
Macro, new-angle-axis: Public macros
Macro, new-colour: Public macros
Macro, new-matrix22: Public macros
Macro, new-matrix33: Public macros
Macro, new-matrix44: Public macros
Macro, new-quaternion: Public macros
Macro, new-rect: Public macros
Macro, new-triangle: Public macros
Macro, new-vector2d: Public macros
Macro, new-vector3d: Public macros
Macro, new-vertex2d: Private macros
Macro, new-vertex3d: Public macros
Macro, print-matrix22*: Public macros
Macro, print-matrix33*: Public macros
Macro, print-matrix44*: Public macros
Macro, quaternion*: Public macros
Macro, quaternion-angle-axis*: Private macros
Macro, quaternion-aref*: Public macros
Macro, quaternion-aref-setter*: Public macros
Macro, quaternion-conjugate*: Public macros
Macro, quaternion-dot*: Public macros
Macro, quaternion-inverse*: Public macros
Macro, quaternion-key-values: Public macros
Macro, quaternion-mag*: Public macros
Macro, quaternion-mag-square*: Public macros
Macro, quaternion-map*: Public macros
Macro, quaternion-matrix33*: Public macros
Macro, quaternion-normalize*: Public macros
Macro, quaternion-power*: Private macros
Macro, quaternion-product*: Public macros
Macro, quaternion-reduce*: Public macros
Macro, quaternion-scale*: Public macros
Macro, quaternion-setter*: Public macros
Macro, quaternion-sum*: Public macros
Macro, quaternion-transform-vector3d*: Public macros
Macro, quaternion-values*: Public macros
Macro, quaternion-vector-push*: Public macros
Macro, quaternion-vector-push-extend*: Public macros
Macro, rect*: Public macros
Macro, rect-aref*: Public macros
Macro, rect-aref-setter*: Public macros
Macro, rect-height*: Private macros
Macro, rect-key-values: Public macros
Macro, rect-map*: Public macros
Macro, rect-reduce*: Public macros
Macro, rect-setter*: Public macros
Macro, rect-values*: Public macros
Macro, rect-vector-push*: Public macros
Macro, rect-vector-push-extend*: Public macros
Macro, rect-width*: Private macros
Macro, restore-tuples-syntax-state: Public macros
Macro, rotatex-matrix33*: Private macros
Macro, rotatex-matrix44*: Public macros
Macro, rotatey-matrix33*: Private macros
Macro, rotatey-matrix44*: Public macros
Macro, rotatez-matrix33*: Private macros
Macro, rotatez-matrix44*: Public macros
Macro, scaling-matrix44*: Public macros
Macro, transform-aabb*: Private macros
Macro, transform-vector2d*: Public macros
Macro, transform-vector3d*: Public macros
Macro, transform-vertex2d*: Public macros
Macro, transform-vertex3d*: Public macros
Macro, translation-matrix44*: Public macros
Macro, transpose-matrix22*: Private macros
Macro, transpose-matrix33*: Public macros
Macro, transpose-matrix44*: Public macros
Macro, triangle*: Public macros
Macro, triangle-aref*: Public macros
Macro, triangle-aref-setter*: Public macros
Macro, triangle-key-values: Public macros
Macro, triangle-map*: Public macros
Macro, triangle-reduce*: Public macros
Macro, triangle-setter*: Public macros
Macro, triangle-values*: Public macros
Macro, triangle-vector-push*: Public macros
Macro, triangle-vector-push-extend*: Public macros
Macro, vector2d*: Public macros
Macro, vector2d-aref*: Public macros
Macro, vector2d-aref-setter*: Public macros
Macro, vector2d-dot*: Public macros
Macro, vector2d-key-values: Public macros
Macro, vector2d-length*: Public macros
Macro, vector2d-length-square*: Private macros
Macro, vector2d-map*: Public macros
Macro, vector2d-normal*: Public macros
Macro, vector2d-reduce*: Public macros
Macro, vector2d-scale*: Public macros
Macro, vector2d-setter*: Public macros
Macro, vector2d-values*: Public macros
Macro, vector2d-vector-push*: Public macros
Macro, vector2d-vector-push-extend*: Public macros
Macro, vector2d-vertex2d*: Public macros
Macro, vector3d*: Public macros
Macro, vector3d-angle-axis*: Private macros
Macro, vector3d-aref*: Public macros
Macro, vector3d-aref-setter*: Public macros
Macro, vector3d-cross*: Public macros
Macro, vector3d-difference*: Public macros
Macro, vector3d-dot*: Public macros
Macro, vector3d-key-values: Public macros
Macro, vector3d-length*: Public macros
Macro, vector3d-map*: Public macros
Macro, vector3d-matrix3d*: Private macros
Macro, vector3d-normal*: Public macros
Macro, vector3d-quaternion*: Public macros
Macro, vector3d-reduce*: Public macros
Macro, vector3d-scale*: Public macros
Macro, vector3d-setter*: Public macros
Macro, vector3d-sum*: Public macros
Macro, vector3d-values*: Public macros
Macro, vector3d-vector-push*: Public macros
Macro, vector3d-vector-push-extend*: Public macros
Macro, vector3d-vertex3d*: Public macros
Macro, vertex2d*: Private macros
Macro, vertex2d-aref*: Private macros
Macro, vertex2d-aref-setter*: Private macros
Macro, vertex2d-key-values: Private macros
Macro, vertex2d-map*: Private macros
Macro, vertex2d-reduce*: Private macros
Macro, vertex2d-setter*: Private macros
Macro, vertex2d-values*: Private macros
Macro, vertex2d-vector-push*: Private macros
Macro, vertex2d-vector-push-extend*: Private macros
Macro, vertex2d-vector2d*: Public macros
Macro, vertex3d*: Public macros
Macro, vertex3d-aref*: Public macros
Macro, vertex3d-aref-setter*: Public macros
Macro, vertex3d-distance*: Public macros
Macro, vertex3d-key-values: Public macros
Macro, vertex3d-map*: Public macros
Macro, vertex3d-reduce*: Public macros
Macro, vertex3d-setter*: Public macros
Macro, vertex3d-translation-matrix44*: Public macros
Macro, vertex3d-values*: Public macros
Macro, vertex3d-vector-push*: Public macros
Macro, vertex3d-vector-push-extend*: Public macros
Macro, vertex3d-vector3d*: Public macros
Macro, with-aabb: Public macros
Macro, with-aabb*: Public macros
Macro, with-aabb-aref: Public macros
Macro, with-angle-axis: Public macros
Macro, with-angle-axis*: Public macros
Macro, with-angle-axis-aref: Public macros
Macro, with-colour: Public macros
Macro, with-colour*: Public macros
Macro, with-colour-aref: Public macros
Macro, with-matrix22: Public macros
Macro, with-matrix22*: Public macros
Macro, with-matrix22-aref: Public macros
Macro, with-matrix33: Public macros
Macro, with-matrix33*: Public macros
Macro, with-matrix33-aref: Public macros
Macro, with-matrix44: Public macros
Macro, with-matrix44*: Public macros
Macro, with-matrix44-aref: Public macros
Macro, with-quaternion: Public macros
Macro, with-quaternion*: Public macros
Macro, with-quaternion-aref: Public macros
Macro, with-rect: Public macros
Macro, with-rect*: Public macros
Macro, with-rect-aref: Public macros
Macro, with-triangle: Public macros
Macro, with-triangle*: Public macros
Macro, with-triangle-aref: Public macros
Macro, with-vector2d: Public macros
Macro, with-vector2d*: Public macros
Macro, with-vector2d-aref: Public macros
Macro, with-vector3d: Public macros
Macro, with-vector3d*: Public macros
Macro, with-vector3d-aref: Public macros
Macro, with-vertex2d: Private macros
Macro, with-vertex2d*: Private macros
Macro, with-vertex2d-aref: Private macros
Macro, with-vertex3d: Public macros
Macro, with-vertex3d*: Public macros
Macro, with-vertex3d-aref: Public macros
make-aabb: Public macros
make-aabb*: Public macros
make-aabb-array: Public ordinary functions
make-adorned-symbol: Private ordinary functions
make-angle-axis: Public macros
make-angle-axis*: Public macros
make-angle-axis-array: Public ordinary functions
make-colour: Public macros
make-colour*: Public macros
make-colour-array: Public ordinary functions
make-matrix22: Public macros
make-matrix22*: Public macros
make-matrix22-array: Public ordinary functions
make-matrix33: Public macros
make-matrix33*: Public macros
make-matrix33-array: Public ordinary functions
make-matrix44: Public macros
make-matrix44*: Public macros
make-matrix44-array: Public ordinary functions
make-quaternion: Public macros
make-quaternion*: Public macros
make-quaternion-array: Public ordinary functions
make-rect: Public macros
make-rect*: Public macros
make-rect-array: Public ordinary functions
make-test-matrix44*: Private macros
make-triangle: Public macros
make-triangle*: Public macros
make-triangle-array: Public ordinary functions
make-tuple-operations: Private macros
make-tuple-symbol: Public ordinary functions
make-vector2d: Public macros
make-vector2d*: Public macros
make-vector2d-array: Public ordinary functions
make-vector3d: Public macros
make-vector3d*: Public macros
make-vector3d-array: Public ordinary functions
make-vertex2d: Private macros
make-vertex2d*: Private macros
make-vertex2d-array: Private ordinary functions
make-vertex3d: Public macros
make-vertex3d*: Public macros
make-vertex3d-array: Public ordinary functions
matrix-cofactors: Private ordinary functions
matrix-dot: Private macros
matrix-minor: Private ordinary functions
matrix-symbol: Private ordinary functions
matrix22*: Public macros
matrix22-aref: Public ordinary functions
matrix22-aref*: Public macros
matrix22-aref-setter: Public ordinary functions
matrix22-aref-setter*: Public macros
matrix22-array-dimensions: Public ordinary functions
matrix22-determinant*: Public macros
matrix22-e00: Private ordinary functions
matrix22-e01: Private ordinary functions
matrix22-e10: Private ordinary functions
matrix22-e11: Private ordinary functions
matrix22-fill-pointer: Public ordinary functions
matrix22-key-values: Public macros
matrix22-map*: Public macros
matrix22-reduce*: Public macros
matrix22-scale*: Public macros
matrix22-setter*: Public macros
matrix22-values*: Public macros
matrix22-vector-push: Public ordinary functions
matrix22-vector-push*: Public macros
matrix22-vector-push-extend: Public ordinary functions
matrix22-vector-push-extend*: Public macros
matrix33*: Public macros
matrix33-angle-axis*: Private macros
matrix33-aref: Public ordinary functions
matrix33-aref*: Public macros
matrix33-aref-setter: Public ordinary functions
matrix33-aref-setter*: Public macros
matrix33-array-dimensions: Public ordinary functions
matrix33-determinant*: Public macros
matrix33-e00: Private ordinary functions
matrix33-e01: Private ordinary functions
matrix33-e02: Private ordinary functions
matrix33-e10: Private ordinary functions
matrix33-e11: Private ordinary functions
matrix33-e12: Private ordinary functions
matrix33-e20: Private ordinary functions
matrix33-e21: Private ordinary functions
matrix33-e22: Private ordinary functions
matrix33-equal*: Private macros
matrix33-fill-pointer: Public ordinary functions
matrix33-key-values: Public macros
matrix33-map*: Public macros
matrix33-matrix44*: Public macros
matrix33-product*: Public macros
matrix33-quaternion*: Private macros
matrix33-reduce*: Public macros
matrix33-scale*: Public macros
matrix33-setter*: Public macros
matrix33-trace*: Private macros
matrix33-values*: Public macros
matrix33-vector-push: Public ordinary functions
matrix33-vector-push*: Public macros
matrix33-vector-push-extend: Public ordinary functions
matrix33-vector-push-extend*: Public macros
matrix44*: Public macros
matrix44-aref: Public ordinary functions
matrix44-aref*: Public macros
matrix44-aref-setter: Public ordinary functions
matrix44-aref-setter*: Public macros
matrix44-array-dimensions: Public ordinary functions
matrix44-determinant*: Public macros
matrix44-e00: Private ordinary functions
matrix44-e01: Private ordinary functions
matrix44-e02: Private ordinary functions
matrix44-e03: Private ordinary functions
matrix44-e10: Private ordinary functions
matrix44-e11: Private ordinary functions
matrix44-e12: Private ordinary functions
matrix44-e13: Private ordinary functions
matrix44-e20: Private ordinary functions
matrix44-e21: Private ordinary functions
matrix44-e22: Private ordinary functions
matrix44-e23: Private ordinary functions
matrix44-e30: Private ordinary functions
matrix44-e31: Private ordinary functions
matrix44-e32: Private ordinary functions
matrix44-e33: Private ordinary functions
matrix44-equal*: Private macros
matrix44-fill-pointer: Public ordinary functions
matrix44-key-values: Public macros
matrix44-map*: Public macros
matrix44-matrix33*: Public macros
matrix44-product*: Public macros
matrix44-reduce*: Public macros
matrix44-scale*: Public macros
matrix44-setter*: Public macros
matrix44-values*: Public macros
matrix44-vector-push: Public ordinary functions
matrix44-vector-push*: Public macros
matrix44-vector-push-extend: Public ordinary functions
matrix44-vector-push-extend*: Public macros
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-expansion-fn: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
Method, tuple-symbol: Private generic functions
multiply-arguments: Private macros

N
new-aabb: Public macros
new-angle-axis: Public macros
new-colour: Public macros
new-matrix22: Public macros
new-matrix33: Public macros
new-matrix44: Public macros
new-quaternion: Public macros
new-rect: Public macros
new-triangle: Public macros
new-vector2d: Public macros
new-vector3d: Public macros
new-vertex2d: Private macros
new-vertex3d: Public macros

P
print-matrix22*: Public macros
print-matrix33*: Public macros
print-matrix44*: Public macros

Q
quaternion*: Public macros
quaternion-angle-axis*: Private macros
quaternion-aref: Public ordinary functions
quaternion-aref*: Public macros
quaternion-aref-setter: Public ordinary functions
quaternion-aref-setter*: Public macros
quaternion-array-dimensions: Public ordinary functions
quaternion-conjugate*: Public macros
quaternion-dot*: Public macros
quaternion-fill-pointer: Public ordinary functions
quaternion-inverse*: Public macros
quaternion-key-values: Public macros
quaternion-mag*: Public macros
quaternion-mag-square*: Public macros
quaternion-map*: Public macros
quaternion-matrix33*: Public macros
quaternion-normalize*: Public macros
quaternion-power*: Private macros
quaternion-product*: Public macros
quaternion-reduce*: Public macros
quaternion-scale*: Public macros
quaternion-setter*: Public macros
quaternion-sum*: Public macros
quaternion-transform-vector3d*: Public macros
quaternion-values*: Public macros
quaternion-vector-push: Public ordinary functions
quaternion-vector-push*: Public macros
quaternion-vector-push-extend: Public ordinary functions
quaternion-vector-push-extend*: Public macros
quaternion-w: Private ordinary functions
quaternion-x: Private ordinary functions
quaternion-y: Private ordinary functions
quaternion-z: Private ordinary functions

R
rect*: Public macros
rect-aref: Public ordinary functions
rect-aref*: Public macros
rect-aref-setter: Public ordinary functions
rect-aref-setter*: Public macros
rect-array-dimensions: Public ordinary functions
rect-bottom: Private ordinary functions
rect-fill-pointer: Public ordinary functions
rect-height*: Private macros
rect-key-values: Public macros
rect-left: Private ordinary functions
rect-map*: Public macros
rect-reduce*: Public macros
rect-right: Private ordinary functions
rect-setter*: Public macros
rect-top: Private ordinary functions
rect-values*: Public macros
rect-vector-push: Public ordinary functions
rect-vector-push*: Public macros
rect-vector-push-extend: Public ordinary functions
rect-vector-push-extend*: Public macros
rect-width*: Private macros
restore-tuples-syntax-state: Public macros
rotatex-matrix33*: Private macros
rotatex-matrix44*: Public macros
rotatey-matrix33*: Private macros
rotatey-matrix44*: Public macros
rotatez-matrix33*: Private macros
rotatez-matrix44*: Public macros

S
scaling-matrix44*: Public macros
Setf Expander, (setf aabb*): Public setf expanders
Setf Expander, (setf aabb-aref): Public setf expanders
Setf Expander, (setf aabb-aref*): Public setf expanders
Setf Expander, (setf angle-axis*): Public setf expanders
Setf Expander, (setf angle-axis-aref): Public setf expanders
Setf Expander, (setf angle-axis-aref*): Public setf expanders
Setf Expander, (setf colour*): Public setf expanders
Setf Expander, (setf colour-aref): Public setf expanders
Setf Expander, (setf colour-aref*): Public setf expanders
Setf Expander, (setf matrix22*): Public setf expanders
Setf Expander, (setf matrix22-aref): Public setf expanders
Setf Expander, (setf matrix22-aref*): Public setf expanders
Setf Expander, (setf matrix33*): Public setf expanders
Setf Expander, (setf matrix33-aref): Public setf expanders
Setf Expander, (setf matrix33-aref*): Public setf expanders
Setf Expander, (setf matrix44*): Public setf expanders
Setf Expander, (setf matrix44-aref): Public setf expanders
Setf Expander, (setf matrix44-aref*): Public setf expanders
Setf Expander, (setf quaternion*): Public setf expanders
Setf Expander, (setf quaternion-aref): Public setf expanders
Setf Expander, (setf quaternion-aref*): Public setf expanders
Setf Expander, (setf rect*): Public setf expanders
Setf Expander, (setf rect-aref): Public setf expanders
Setf Expander, (setf rect-aref*): Public setf expanders
Setf Expander, (setf triangle*): Public setf expanders
Setf Expander, (setf triangle-aref): Public setf expanders
Setf Expander, (setf triangle-aref*): Public setf expanders
Setf Expander, (setf vector2d*): Public setf expanders
Setf Expander, (setf vector2d-aref): Public setf expanders
Setf Expander, (setf vector2d-aref*): Public setf expanders
Setf Expander, (setf vector3d*): Public setf expanders
Setf Expander, (setf vector3d-aref): Public setf expanders
Setf Expander, (setf vector3d-aref*): Public setf expanders
Setf Expander, (setf vertex2d*): Private setf expanders
Setf Expander, (setf vertex2d-aref): Private setf expanders
Setf Expander, (setf vertex2d-aref*): Private setf expanders
Setf Expander, (setf vertex3d*): Public setf expanders
Setf Expander, (setf vertex3d-aref): Public setf expanders
Setf Expander, (setf vertex3d-aref*): Public setf expanders
simple-tuple-typespec*: Private ordinary functions
symbol-macro-expander-fn: Private ordinary functions
symbol-to-string: Private ordinary functions

T
transform-aabb*: Private macros
transform-vector2d*: Public macros
transform-vector3d*: Public macros
transform-vertex2d*: Public macros
transform-vertex3d*: Public macros
translation-matrix44*: Public macros
transpose-matrix22*: Private macros
transpose-matrix33*: Public macros
transpose-matrix44*: Public macros
triangle*: Public macros
triangle-a: Private ordinary functions
triangle-aref: Public ordinary functions
triangle-aref*: Public macros
triangle-aref-setter: Public ordinary functions
triangle-aref-setter*: Public macros
triangle-array-dimensions: Public ordinary functions
triangle-b: Private ordinary functions
triangle-c: Private ordinary functions
triangle-fill-pointer: Public ordinary functions
triangle-key-values: Public macros
triangle-map*: Public macros
triangle-reduce*: Public macros
triangle-setter*: Public macros
triangle-values*: Public macros
triangle-vector-push: Public ordinary functions
triangle-vector-push*: Public macros
triangle-vector-push-extend: Public ordinary functions
triangle-vector-push-extend*: Public macros
tuple-element-type: Public ordinary functions
tuple-elements: Private ordinary functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-expansion-fn: Private generic functions
tuple-gensyms: Public ordinary functions
tuple-initial-element: Private ordinary functions
tuple-places: Private ordinary functions
tuple-size: Public ordinary functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-symbol: Private generic functions
tuple-typep: Public ordinary functions
tuple-typespec: Public ordinary functions
tuple-typespec*: Public ordinary functions
tuple-typespec**: Public ordinary functions

V
vector2d*: Public macros
vector2d-aref: Public ordinary functions
vector2d-aref*: Public macros
vector2d-aref-setter: Public ordinary functions
vector2d-aref-setter*: Public macros
vector2d-array-dimensions: Public ordinary functions
vector2d-dot*: Public macros
vector2d-fill-pointer: Public ordinary functions
vector2d-key-values: Public macros
vector2d-length*: Public macros
vector2d-length-square*: Private macros
vector2d-map*: Public macros
vector2d-normal*: Public macros
vector2d-reduce*: Public macros
vector2d-scale*: Public macros
vector2d-setter*: Public macros
vector2d-values*: Public macros
vector2d-vector-push: Public ordinary functions
vector2d-vector-push*: Public macros
vector2d-vector-push-extend: Public ordinary functions
vector2d-vector-push-extend*: Public macros
vector2d-vertex2d*: Public macros
vector2d-x: Private ordinary functions
vector2d-y: Private ordinary functions
vector3d*: Public macros
vector3d-angle-axis*: Private macros
vector3d-aref: Public ordinary functions
vector3d-aref*: Public macros
vector3d-aref-setter: Public ordinary functions
vector3d-aref-setter*: Public macros
vector3d-array-dimensions: Public ordinary functions
vector3d-cross*: Public macros
vector3d-difference*: Public macros
vector3d-dot*: Public macros
vector3d-fill-pointer: Public ordinary functions
vector3d-key-values: Public macros
vector3d-length*: Public macros
vector3d-map*: Public macros
vector3d-matrix3d*: Private macros
vector3d-normal*: Public macros
vector3d-quaternion*: Public macros
vector3d-reduce*: Public macros
vector3d-scale*: Public macros
vector3d-setter*: Public macros
vector3d-sum*: Public macros
vector3d-values*: Public macros
vector3d-vector-push: Public ordinary functions
vector3d-vector-push*: Public macros
vector3d-vector-push-extend: Public ordinary functions
vector3d-vector-push-extend*: Public macros
vector3d-vertex3d*: Public macros
vector3d-x: Private ordinary functions
vector3d-y: Private ordinary functions
vector3d-z: Private ordinary functions
vertex2d*: Private macros
vertex2d-aref: Private ordinary functions
vertex2d-aref*: Private macros
vertex2d-aref-setter: Private ordinary functions
vertex2d-aref-setter*: Private macros
vertex2d-array-dimensions: Private ordinary functions
vertex2d-fill-pointer: Private ordinary functions
vertex2d-key-values: Private macros
vertex2d-map*: Private macros
vertex2d-reduce*: Private macros
vertex2d-setter*: Private macros
vertex2d-values*: Private macros
vertex2d-vector-push: Private ordinary functions
vertex2d-vector-push*: Private macros
vertex2d-vector-push-extend: Private ordinary functions
vertex2d-vector-push-extend*: Private macros
vertex2d-vector2d*: Public macros
vertex2d-w: Private ordinary functions
vertex2d-x: Private ordinary functions
vertex2d-y: Private ordinary functions
vertex3d*: Public macros
vertex3d-aref: Public ordinary functions
vertex3d-aref*: Public macros
vertex3d-aref-setter: Public ordinary functions
vertex3d-aref-setter*: Public macros
vertex3d-array-dimensions: Public ordinary functions
vertex3d-distance*: Public macros
vertex3d-fill-pointer: Public ordinary functions
vertex3d-key-values: Public macros
vertex3d-map*: Public macros
vertex3d-reduce*: Public macros
vertex3d-setter*: Public macros
vertex3d-translation-matrix44*: Public macros
vertex3d-values*: Public macros
vertex3d-vector-push: Public ordinary functions
vertex3d-vector-push*: Public macros
vertex3d-vector-push-extend: Public ordinary functions
vertex3d-vector-push-extend*: Public macros
vertex3d-vector3d*: Public macros
vertex3d-w: Private ordinary functions
vertex3d-x: Private ordinary functions
vertex3d-y: Private ordinary functions
vertex3d-z: Private ordinary functions

W
with-aabb: Public macros
with-aabb*: Public macros
with-aabb-aref: Public macros
with-angle-axis: Public macros
with-angle-axis*: Public macros
with-angle-axis-aref: Public macros
with-colour: Public macros
with-colour*: Public macros
with-colour-aref: Public macros
with-matrix22: Public macros
with-matrix22*: Public macros
with-matrix22-aref: Public macros
with-matrix33: Public macros
with-matrix33*: Public macros
with-matrix33-aref: Public macros
with-matrix44: Public macros
with-matrix44*: Public macros
with-matrix44-aref: Public macros
with-quaternion: Public macros
with-quaternion*: Public macros
with-quaternion-aref: Public macros
with-rect: Public macros
with-rect*: Public macros
with-rect-aref: Public macros
with-triangle: Public macros
with-triangle*: Public macros
with-triangle-aref: Public macros
with-vector2d: Public macros
with-vector2d*: Public macros
with-vector2d-aref: Public macros
with-vector3d: Public macros
with-vector3d*: Public macros
with-vector3d-aref: Public macros
with-vertex2d: Private macros
with-vertex2d*: Private macros
with-vertex2d-aref: Private macros
with-vertex3d: Public macros
with-vertex3d*: Public macros
with-vertex3d-aref: Public macros

Jump to:   #   %   (  
A   B   C   D   E   F   G   I   L   M   N   P   Q   R   S   T   V   W  

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

A.4 Data types

Jump to:   A   C   F   M   P   Q   R   S   T   U   V  
Index Entry  Section

A
aabb.lisp: The cl-tuples/aabb․lisp file

C
cl-tuples: The cl-tuples system
cl-tuples: The cl-tuples package
cl-tuples-system: The cl-tuples-system package
cl-tuples.asd: The cl-tuples/cl-tuples․asd file
colour.lisp: The cl-tuples/colour․lisp file

F
fast-float: Public types
File, aabb.lisp: The cl-tuples/aabb․lisp file
File, cl-tuples.asd: The cl-tuples/cl-tuples․asd file
File, colour.lisp: The cl-tuples/colour․lisp file
File, matrix.lisp: The cl-tuples/matrix․lisp file
File, package.lisp: The cl-tuples/package․lisp file
File, quaternion.lisp: The cl-tuples/quaternion․lisp file
File, rect.lisp: The cl-tuples/rect․lisp file
File, symbols.lisp: The cl-tuples/symbols․lisp file
File, syntax.lisp: The cl-tuples/syntax․lisp file
File, triangle.lisp: The cl-tuples/triangle․lisp file
File, tuple-expander.lisp: The cl-tuples/tuple-expander․lisp file
File, tuples.lisp: The cl-tuples/tuples․lisp file
File, utils.lisp: The cl-tuples/utils․lisp file
File, vector.lisp: The cl-tuples/vector․lisp file

M
matrix.lisp: The cl-tuples/matrix․lisp file

P
Package, cl-tuples: The cl-tuples package
Package, cl-tuples-system: The cl-tuples-system package
Package, tuple-types: The tuple-types package
package.lisp: The cl-tuples/package․lisp file

Q
quaternion.lisp: The cl-tuples/quaternion․lisp file

R
rect.lisp: The cl-tuples/rect․lisp file

S
symbols.lisp: The cl-tuples/symbols․lisp file
syntax.lisp: The cl-tuples/syntax․lisp file
System, cl-tuples: The cl-tuples system

T
triangle.lisp: The cl-tuples/triangle․lisp file
tuple-expander.lisp: The cl-tuples/tuple-expander․lisp file
tuple-types: The tuple-types package
tuples.lisp: The cl-tuples/tuples․lisp file
Type, fast-float: Public types

U
utils.lisp: The cl-tuples/utils․lisp file

V
vector.lisp: The cl-tuples/vector․lisp file

Jump to:   A   C   F   M   P   Q   R   S   T   U   V