Amino Lisp API

Basic utilities for robotics.

• Homepage: http://amino.golems.org
• Source Repository: https://github.com/golems/amino
• License: 3-Clause BSD

Amino provides numerics, geometry, and memory-management for robotics and real-time applications. This lisp system interfaces with a foreign (C) library.

The AMINO-TYPE dictionary

%MAKE-MATRIX

[function]

%MAKE-MATRIX: (&key (data data) (offset offset) (stride stride) (cols cols) (rows rows)) => result

%MATRIX-COLS

[function]

%MATRIX-COLS: (instance) => result

%MATRIX-DATA

[function]

%MATRIX-DATA: (instance) => result

%MATRIX-OFFSET

[function]

%MATRIX-OFFSET: (instance) => result

%MATRIX-ROWS

[function]

%MATRIX-ROWS: (instance) => result

%MATRIX-STRIDE

[function]

%MATRIX-STRIDE: (instance) => result

CHECK-MATRIX-BOUNDS

[function]

CHECK-MATRIX-BOUNDS: (data offset stride rows columns) => result

CHECK-MATRIX-DIMENSIONS

[function]

CHECK-MATRIX-DIMENSIONS: (&rest dimensions) => result

MAKE-CRS-MATRIX

[function]

MAKE-CRS-MATRIX: (row-count column-count element-count) => result

Create a sparse matrix in compressed row storage form

M

AKE-REAL-ARRAY

[function]

MAKE-REAL-ARRAY: (&key (data data)) => result

MATRIX

[standard class]

Descriptor for a matrix following LAPACK conventions.

M

ATRIX-DIMENSION-ERROR

[function]

MATRIX-DIMENSION-ERROR: (format &rest args) => result

MATRIX-STORAGE-ERROR

[function]

MATRIX-STORAGE-ERROR: (format &rest args) => result

REAL-ARRAY

[standard class]

REAL-ARRAY-DATA

[function]

REAL-ARRAY-DATA: (instance) => result

VEC

[function]

VEC: (&rest args) => result

Create a floating-point vector

(

SETF %MATRIX-COLS)

[function]

(SETF %MATRIX-COLS): (value instance) => result

(SETF %MATRIX-DATA)

[function]

(SETF %MATRIX-DATA): (value instance) => result

(SETF %MATRIX-OFFSET)

[function]

(SETF %MATRIX-OFFSET): (value instance) => result

(SETF %MATRIX-ROWS)

[function]

(SETF %MATRIX-ROWS): (value instance) => result

(SETF %MATRIX-STRIDE)

[function]

(SETF %MATRIX-STRIDE): (value instance) => result

(SETF REAL-ARRAY-DATA)

[function]

(SETF REAL-ARRAY-DATA): (value instance) => result

The AMINO dictionary

+TF-IDENT+

[special-var]

An identity transformation.

A

XIS-ANGLE

[standard class]

An orientation in axis-angle form

A

XIS-ANGLE

[generic-function]

AXIS-ANGLE: (x) => result

Convert orientation X to axis-angle form.

A

XIS-ANGLE

[method]

AXIS-ANGLE: ((x z-angle)) => result

Convert orientation X to axis-angle form.

A

XIS-ANGLE

[method]

AXIS-ANGLE: ((x y-angle)) => result

Convert orientation X to axis-angle form.

A

XIS-ANGLE

[method]

AXIS-ANGLE: ((x x-angle)) => result

Convert orientation X to axis-angle form.

A

XIS-ANGLE

[method]

AXIS-ANGLE: ((x quaternion)) => result

Convert orientation X to axis-angle form.

A

XIS-ANGLE*

[function]

AXIS-ANGLE*: (x y z theta) => result

Create an axis-angle orientation from components.

C

ROSS

[function]

CROSS: (a b &optional c) => result

Compute the cross product of vector-3 A and B.

D

EGREES

[function]

DEGREES: (value) => result

Convert VALUE in degrees to radians.

D

UAL-QUATERNION

[standard class]

DUAL-QUATERNION

[generic-function]

DUAL-QUATERNION: (x) => result

Convert transform X to dual quaternion form.

D

UAL-QUATERNION

[method]

DUAL-QUATERNION: ((x array)) => result

Convert transform X to dual quaternion form.

D

UAL-QUATERNION

[method]

DUAL-QUATERNION: ((x quaternion-translation)) => result

Convert transform X to dual quaternion form.

D

UAL-QUATERNION

[method]

DUAL-QUATERNION: ((x quaternion)) => result

Convert transform X to dual quaternion form.

D

UAL-QUATERNION

[method]

DUAL-QUATERNION: ((x (eql nil))) => result

Convert transform X to dual quaternion form.

D

UAL-QUATERNION

[method]

DUAL-QUATERNION: ((x dual-quaternion)) => result

Convert transform X to dual quaternion form.

D

UAL-QUATERNION-2

[generic-function]

DUAL-QUATERNION-2: (r x) => result

Convert rotation R and translation X to dual quaternion form.

D

UAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r matrix) (x vec3)) => result

Convert rotation R and translation X to dual quaternion form.

D

UAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r axis-angle) (x vec3)) => result

Convert rotation R and translation X to dual quaternion form.

D

UAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r euler-angle) (x vec3)) => result

Convert rotation R and translation X to dual quaternion form.

D

UAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r principal-angle) (x vec3)) => result

Convert rotation R and translation X to dual quaternion form.

D

UAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r quaternion) (x vec3)) => result

Convert rotation R and translation X to dual quaternion form.

E

NSURE-VEC

[function]

ENSURE-VEC: (thing) => result

Coerce THING to a vec.

E

ULER-RPY

[generic-function]

EULER-RPY: (x) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x z-angle)) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x y-angle)) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x x-angle)) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x quaternion)) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x (eql nil))) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x cons)) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY

[method]

EULER-RPY: ((x array)) => result

Convert orientation X to Euler angle roll-pitch-yaw form.

E

ULER-RPY*

[function]

EULER-RPY*: (r p y) => result

Alias for ZYX euler angles.

E

ULER-ZYX

[standard class]

EULER-ZYX

[generic-function]

EULER-ZYX: (x) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x z-angle)) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x y-angle)) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x x-angle)) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x cons)) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x array)) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x quaternion)) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX

[method]

EULER-ZYX: ((x (eql nil))) => result

Convert orientation X to Euler angle ZYX form.

E

ULER-ZYX*

[function]

EULER-ZYX*: (z y x) => result

Construct Euler angle from components.

F

NVEC

[function]

FNVEC: (&rest args) => result

Create a fixnum vector

F

NVEC-FLATTEN

[function]

FNVEC-FLATTEN: (sequence) => result

Flatten positionly-nested sequences into a single numeric vector.

G

*

[function]

G*: (first &rest rest) => result

Generic * operation

G

+

[function]

G+: (first &rest rest) => result

Generic + operation

G

-

[function]

G-: (first &rest rest) => result

Generic - operation

G

/

[function]

G/: (first &rest rest) => result

Generic / operation

I

DENTITY-QUATERNION

[function]

IDENTITY-QUATERNION: () => result

Return the identity quaternion.

I

DENTITY-TF

[function]

IDENTITY-TF: () => result

Return the identity transform.

I

DENTITY-VEC3

[function]

IDENTITY-VEC3: () => result

Return the "identity" 3-vector.

I

NVERSE

[generic-function]

INVERSE: (x) => result

Compute the inverse of X

I

NVERSE

[method]

INVERSE: ((x quaternion-translation)) => result

Compute the inverse of X

I

NVERSE

[method]

INVERSE: ((x principal-angle)) => result

Compute the inverse of X

I

NVERSE

[method]

INVERSE: ((x quaternion)) => result

Compute the inverse of X

I

NVERSE

[method]

INVERSE: ((x real)) => result

Compute the inverse of X

M

AKE-CRS-MATRIX

[function]

MAKE-CRS-MATRIX: (row-count column-count element-count) => result

Create a sparse matrix in compressed row storage form

M

AKE-FNVEC

[function]

MAKE-FNVEC: (n) => result

Make a floating point (double) vector.

M

AKE-MATRIX

[function]

MAKE-MATRIX: (m n) => result

Make a new matrix with M rows and N cols.

M

AKE-TF-TREE

[function]

MAKE-TF-TREE: () => result

Create a new TF tree.
The tree is a map from the frame name to its relative transform.

M

AKE-VEC

[function]

MAKE-VEC: (n &key initial-element) => result

Make a floating point (double) vector.

M

ATREF

[function]

MATREF: (matrix i j) => result

Return element at row i, col j.

M

ATRIX->LIST

[generic-function]

MATRIX->LIST: (matrix) => result

Convert a matrix type to a list.

M

ATRIX->LIST

[method]

MATRIX->LIST: ((matrix quaternion-translation)) => result

Convert a matrix type to a list.

M

ATRIX->LIST

[method]

MATRIX->LIST: ((matrix real-array)) => result

Convert a matrix type to a list.

M

ATRIX->LIST

[method]

MATRIX->LIST: ((matrix array)) => result

Convert a matrix type to a list.

N

ORMALIZE

[generic-function]

NORMALIZE: (x) => result

Compute the normalized form of X

N

ORMALIZE

[method]

NORMALIZE: ((x quaternion-translation)) => result

Make the rotation component a unit quaternion.

Translation is not altered.

N

ORMALIZE

[method]

NORMALIZE: ((x list)) => result

Compute the normalized form of X

N

ORMALIZE

[method]

NORMALIZE: ((x array)) => result

Compute the normalized form of X

N

ORMALIZE

[method]

NORMALIZE: ((x real)) => result

Compute the normalized form of X

P

ARSE-FLOAT

[function]

PARSE-FLOAT: (string &optional invalid-error invalid-value) => result

PI-RAD

[function]

PI-RAD: (value) => result

Return VALUE*pi

Q

UATERNION

[standard class]

QUATERNION

[generic-function]

QUATERNION: (x) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x z-angle)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x y-angle)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x x-angle)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x cons)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x array)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x euler-zyx)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x matrix)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x axis-angle)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x complex)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x real)) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x (eql nil))) => result

Convert orientation X to a quaternion.

Q

UATERNION

[method]

QUATERNION: ((x quaternion)) => result

Convert orientation X to a quaternion.

Q

UATERNION*

[function]

QUATERNION*: (x y z w) => result

Construct a quaternion from its elements.

Q

UATERNION-FROM-VECTORS

[function]

QUATERNION-FROM-VECTORS: (u v &optional q) => result

Find the unit quaternion representing the rotation from U to V.

Q

UATERNION-IDENTITY-P

[function]

QUATERNION-IDENTITY-P: (quaternion) => result

Test if it is the identify quaternion.

Q

UATERNION-TRANSLATION

[standard class]

QUATERNION-TRANSLATION

[generic-function]

QUATERNION-TRANSLATION: (x) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x euler-zyx)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x axis-angle)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x z-angle)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x y-angle)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x x-angle)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x quaternion)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x vec3)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x dual-quaternion)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x (eql nil))) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x cons)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x array)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x tf-readable)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x quaternion-translation)) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION*

[function]

QUATERNION-TRANSLATION*: (r x) => result

Convert transform X to quaternion-translation form.

Q

UATERNION-TRANSLATION-2

[generic-function]

QUATERNION-TRANSLATION-2: (r x) => result

Convert rotation R and translation X to quaternion-translation form.

Q

UATERNION-TRANSLATION-2

[method]

QUATERNION-TRANSLATION-2: (r x) => result

Convert rotation R and translation X to quaternion-translation form.

Q

UATERNION-TRANSLATION-2

[method]

QUATERNION-TRANSLATION-2: ((r quaternion) (x vec3)) => result

Convert rotation R and translation X to quaternion-translation form.

Q

UATERNION-W

[function]

QUATERNION-W: (q) => result

Return the quaternion W element.

Q

UATERNION-X

[function]

QUATERNION-X: (q) => result

Return the quaternion X element.

Q

UATERNION-Y

[function]

QUATERNION-Y: (q) => result

Return the quaternion Y element.

Q

UATERNION-Z

[function]

QUATERNION-Z: (q) => result

Return the quaternion Z element.

R

OTATION

[generic-function]

ROTATION: (x) => result

Extract the rotation part of X

R

OTATION

[method]

ROTATION: ((x quaternion-translation)) => result

Return the rotation quaternion part.

R

OTATION-MATRIX

[generic-function]

ROTATION-MATRIX: (x) => result

Convert orientation X to a rotation matrix.

R

OTATION-MATRIX

[method]

ROTATION-MATRIX: ((x z-angle)) => result

Convert orientation X to a rotation matrix.

R

OTATION-MATRIX

[method]

ROTATION-MATRIX: ((x y-angle)) => result

Convert orientation X to a rotation matrix.

R

OTATION-MATRIX

[method]

ROTATION-MATRIX: ((x x-angle)) => result

Convert orientation X to a rotation matrix.

R

OTATION-MATRIX

[method]

ROTATION-MATRIX: ((x axis-angle)) => result

Convert orientation X to a rotation matrix.

R

OTATION-MATRIX

[method]

ROTATION-MATRIX: ((x quaternion)) => result

Convert orientation X to a rotation matrix.

T

F

[function]

TF: (transform) => result

Convert TRANSFORM to TF type

T

F*

[function]

TF*: (rotation translation) => result

Convert ROTATION and TRANSLATION to TF type

T

F-ARRAY

[function]

TF-ARRAY: (tf &optional array) => result

Convert transform object to an array.

T

F-COPY

[function]

TF-COPY: (transform &optional result) => result

Deeply copy TRANFORM into RESULT.

T

F-INVERSE

[function]

TF-INVERSE: (transform &optional inverse) => result

Compute the inverse of the transform.

T

F-MUL

[function]

TF-MUL: (tf-0 tf-1 &optional result) => result

Multiply TF-0 and TF-1, storing in RESULT.

T

F-NORMALIZE

[function]

TF-NORMALIZE: (transform &optional result) => result

Normalize TRANSFORM, storing into RESULT.

T

F-QUATERNION

[function]

TF-QUATERNION: (transform) => result

Return the rotation part as a quaternion

T

F-READABLE

[standard class]

Human-readable transform

T

F-READABLE

[function]

TF-READABLE: (tf) => result

Convert TF to human-readable form.

T

F-READABLE*

[function]

TF-READABLE*: (rotation translation) => result

Create a human-readable transform.

T

F-TAG

[standard class]

A transform tragged with parent and child frame labels.

T

F-TAG

[function]

TF-TAG: (parent tf child) => result

TF-TAG-CHILD

[function]

TF-TAG-CHILD: (instance) => result

TF-TAG-PARENT

[function]

TF-TAG-PARENT: (instance) => result

TF-TAG-TF

[function]

TF-TAG-TF: (instance) => result

TF-TRANSLATION

[function]

TF-TRANSLATION: (transform) => result

Return the translation part.

T

F-TREE-ABSOLUTE-TF

[function]

TF-TREE-ABSOLUTE-TF: (relative-tree frame) => result

Compute the absolute transform of FRAME.

T

F-TREE-FIND

[function]

TF-TREE-FIND: (tree frame) => result

Find the TF in the tree

T

F-TREE-INSERT

[function]

TF-TREE-INSERT: (tree tf-tag) => result

Add tagged TF to tree.

T

F-TREE-REMOVE

[function]

TF-TREE-REMOVE: (tree frame) => result

Remove FRAME from tree

T

RANSFORM

[generic-function]

TRANSFORM: (tf point) => result

Transform a point.

T

RANSFORM

[method]

TRANSFORM: ((tf euler-angle) (point vec3)) => result

Transform a point.

T

RANSFORM

[method]

TRANSFORM: ((tf principal-angle) (point vec3)) => result

Transform a point.

T

RANSFORM

[method]

TRANSFORM: ((tf matrix) (point vec3)) => result

Transform a point.

T

RANSFORM

[method]

TRANSFORM: ((tf quaternion-translation) (point vec3)) => result

Transform a point.

T

RANSFORM

[method]

TRANSFORM: ((tf quaternion) (point vec3)) => result

Transform a point.

T

RANSFORMATION-MATRIX

[generic-function]

TRANSFORMATION-MATRIX: (x) => result

Convert transform X to a trasnformation matrix form.

T

RANSFORMATION-MATRIX

[method]

TRANSFORMATION-MATRIX: ((x dual-quaternion)) => result

Convert transform X to a trasnformation matrix form.

T

RANSFORMATION-MATRIX

[method]

TRANSFORMATION-MATRIX: ((x quaternion-translation)) => result

Convert transform X to a trasnformation matrix form.

T

RANSFORMATION-MATRIX-2

[generic-function]

TRANSFORMATION-MATRIX-2: (r x) => result

Convert rotation R and translation X to transformation matrix form.

T

RANSLATION

[generic-function]

TRANSLATION: (x) => result

Extract the translation part of X

T

RANSLATION

[method]

TRANSLATION: ((x quaternion-translation)) => result

Return the translation quaternion part.

V

EC

[function]

VEC: (&rest args) => result

Create a floating-point vector

V

EC-CAT

[function]

VEC-CAT: (&rest args) => result

Concatenate vectors.

V

EC-DIST

[function]

VEC-DIST: (a b) => result

Return the Euclidean distance between two vectors.

V

EC-FLATTEN

[function]

VEC-FLATTEN: (sequence) => result

Flatten positionly-nested sequences into a single numeric vector.

V

EC-LIST

[function]

VEC-LIST: (vec) => result

Convert VEC to a list.

V

EC-NORM

[function]

VEC-NORM: (x) => result

Return the Euclidean normal of the vectors.

V

EC-SEQUENCE

[function]

VEC-SEQUENCE: (vec) => result

Ensure that VEC is a sequence.

V

EC-SSD

[function]

VEC-SSD: (a b) => result

Return the sum of squared differences between vectors A and B.

V

EC-W

[function]

VEC-W: (vector) => result

Return the W element of the vector.

V

EC-X

[function]

VEC-X: (vector) => result

Return the X element of the vector.

V

EC-Y

[function]

VEC-Y: (vector) => result

Return the Y element of the vector.

V

EC-Z

[function]

VEC-Z: (vector) => result

Return the Z element of the vector.

V

EC3

[standard class]

VEC3

[generic-function]

VEC3: (x) => result

Convert X to a 3-element vector.

V

EC3

[method]

VEC3: ((x cons)) => result

Convert X to a 3-element vector.

V

EC3

[method]

VEC3: ((x array)) => result

Convert X to a 3-element vector.

V

EC3

[method]

VEC3: ((x (eql nil))) => result

Convert X to a 3-element vector.

V

EC3

[method]

VEC3: ((x vec3)) => result

Convert X to a 3-element vector.

V

EC3*

[function]

VEC3*: (x y z) => result

Construct a vector-3 from components.

V

EC3-IDENTITY-P

[function]

VEC3-IDENTITY-P: (vec3) => result

Check if vector-3 is 'identity', i.e., zero.

V

EC3-NORMALIZE

[function]

VEC3-NORMALIZE: (v) => result

Normalize a vector-3 to norm of 1.

V

ECREF

[function]

VECREF: (vector i) => result

Return I'th element of column vector VECTOR

W

ITH-QUATERNION

[macro]

WITH-QUATERNION: ((x y z w) quaternion declaration* statement*) => result

Bind the components of QUATERNION.

W

ITH-VEC3

[macro]

WITH-VEC3: ((x y z) vec3 declaration* statement*) => result

Bind the elements of a VEC3.

X

-ANGLE

[standard class]

A rotation about the X axis

X

-ANGLE

[function]

X-ANGLE: (value) => result

Construct a rotation about the X axis.

Y

-ANGLE

[standard class]

A rotation about the Y axis

Y

-ANGLE

[function]

Y-ANGLE: (value) => result

Construct a rotation about the Y axis.

Z

-ANGLE

[standard class]

A rotation about the Z axis

Z

-ANGLE

[function]

Z-ANGLE: (value) => result

Construct a rotation about the Z axis.

(

SETF MATREF)

[function]

(SETF MATREF): (value matrix i j) => result

Set element at row i, col j.

(

SETF TF-TAG-CHILD)

[function]

(SETF TF-TAG-CHILD): (value instance) => result

(SETF TF-TAG-PARENT)

[function]

(SETF TF-TAG-PARENT): (value instance) => result

(SETF TF-TAG-TF)

[function]

(SETF TF-TAG-TF): (value instance) => result

(SETF VECREF)

[function]

(SETF VECREF): (value vec i) => result

Set the I'th value of VEC to VALUE.

A

uthors

• Neil T. Dantam