amino  1.0-beta2
Lightweight Robot Utility Library
Amino Lisp API

Table of Contents

Basic utilities for robotics.

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

MAKE-REAL-ARRAY

[function]

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

MATRIX

[standard class]

Descriptor for a matrix following LAPACK conventions.

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

AXIS-ANGLE

[standard class]

An orientation in axis-angle form

AXIS-ANGLE

[generic-function]

AXIS-ANGLE: (x) => result
Convert orientation X to axis-angle form.

AXIS-ANGLE

[method]

AXIS-ANGLE: ((x z-angle)) => result
Convert orientation X to axis-angle form.

AXIS-ANGLE

[method]

AXIS-ANGLE: ((x y-angle)) => result
Convert orientation X to axis-angle form.

AXIS-ANGLE

[method]

AXIS-ANGLE: ((x x-angle)) => result
Convert orientation X to axis-angle form.

AXIS-ANGLE

[method]

AXIS-ANGLE: ((x quaternion)) => result
Convert orientation X to axis-angle form.

AXIS-ANGLE*

[function]

AXIS-ANGLE*: (x y z theta) => result
Create an axis-angle orientation from components.

CROSS

[function]

CROSS: (a b &optional c) => result
Compute the cross product of vector-3 A and B.

DEGREES

[function]

DEGREES: (value) => result
Convert VALUE in degrees to radians.

DUAL-QUATERNION

[standard class]

DUAL-QUATERNION

[generic-function]

DUAL-QUATERNION: (x) => result
Convert transform X to dual quaternion form.

DUAL-QUATERNION

[method]

DUAL-QUATERNION: ((x array)) => result
Convert transform X to dual quaternion form.

DUAL-QUATERNION

[method]

DUAL-QUATERNION: ((x quaternion-translation)) => result
Convert transform X to dual quaternion form.

DUAL-QUATERNION

[method]

DUAL-QUATERNION: ((x quaternion)) => result
Convert transform X to dual quaternion form.

DUAL-QUATERNION

[method]

DUAL-QUATERNION: ((x (eql nil))) => result
Convert transform X to dual quaternion form.

DUAL-QUATERNION

[method]

DUAL-QUATERNION: ((x dual-quaternion)) => result
Convert transform X to dual quaternion form.

DUAL-QUATERNION-2

[generic-function]

DUAL-QUATERNION-2: (r x) => result
Convert rotation R and translation X to dual quaternion form.

DUAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r matrix) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.

DUAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r axis-angle) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.

DUAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r euler-angle) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.

DUAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r principal-angle) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.

DUAL-QUATERNION-2

[method]

DUAL-QUATERNION-2: ((r quaternion) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.

ENSURE-VEC

[function]

ENSURE-VEC: (thing) => result
Coerce THING to a vec.

EULER-RPY

[generic-function]

EULER-RPY: (x) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x z-angle)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x y-angle)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x x-angle)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x quaternion)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x (eql nil))) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x cons)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY

[method]

EULER-RPY: ((x array)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.

EULER-RPY*

[function]

EULER-RPY*: (r p y) => result
Alias for ZYX euler angles.

EULER-ZYX

[standard class]

EULER-ZYX

[generic-function]

EULER-ZYX: (x) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x z-angle)) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x y-angle)) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x x-angle)) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x cons)) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x array)) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x quaternion)) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX

[method]

EULER-ZYX: ((x (eql nil))) => result
Convert orientation X to Euler angle ZYX form.

EULER-ZYX*

[function]

EULER-ZYX*: (z y x) => result
Construct Euler angle from components.

FNVEC

[function]

FNVEC: (&rest args) => result
Create a fixnum vector

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

IDENTITY-QUATERNION

[function]

IDENTITY-QUATERNION: () => result
Return the identity quaternion.

IDENTITY-TF

[function]

IDENTITY-TF: () => result
Return the identity transform.

IDENTITY-VEC3

[function]

IDENTITY-VEC3: () => result
Return the "identity" 3-vector.

INVERSE

[generic-function]

INVERSE: (x) => result
Compute the inverse of X

INVERSE

[method]

INVERSE: ((x quaternion-translation)) => result
Compute the inverse of X

INVERSE

[method]

INVERSE: ((x principal-angle)) => result
Compute the inverse of X

INVERSE

[method]

INVERSE: ((x quaternion)) => result
Compute the inverse of X

INVERSE

[method]

INVERSE: ((x real)) => result
Compute the inverse of X

MAKE-CRS-MATRIX

[function]

MAKE-CRS-MATRIX: (row-count column-count element-count) => result
Create a sparse matrix in compressed row storage form

MAKE-FNVEC

[function]

MAKE-FNVEC: (n) => result
Make a floating point (double) vector.

MAKE-MATRIX

[function]

MAKE-MATRIX: (m n) => result
Make a new matrix with M rows and N cols.

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

MAKE-VEC

[function]

MAKE-VEC: (n &key initial-element) => result
Make a floating point (double) vector.

MATREF

[function]

MATREF: (matrix i j) => result
Return element at row i, col j.

MATRIX->LIST

[generic-function]

MATRIX->LIST: (matrix) => result
Convert a matrix type to a list.

MATRIX->LIST

[method]

MATRIX->LIST: ((matrix quaternion-translation)) => result
Convert a matrix type to a list.

MATRIX->LIST

[method]

MATRIX->LIST: ((matrix real-array)) => result
Convert a matrix type to a list.

MATRIX->LIST

[method]

MATRIX->LIST: ((matrix array)) => result
Convert a matrix type to a list.

NORMALIZE

[generic-function]

NORMALIZE: (x) => result
Compute the normalized form of X

NORMALIZE

[method]

NORMALIZE: ((x quaternion-translation)) => result
Make the rotation component a unit quaternion.
Translation is not altered.

NORMALIZE

[method]

NORMALIZE: ((x list)) => result
Compute the normalized form of X

NORMALIZE

[method]

NORMALIZE: ((x array)) => result
Compute the normalized form of X

NORMALIZE

[method]

NORMALIZE: ((x real)) => result
Compute the normalized form of X

PARSE-FLOAT

[function]

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

PI-RAD

[function]

PI-RAD: (value) => result
Return VALUE*pi

QUATERNION

[standard class]

QUATERNION

[generic-function]

QUATERNION: (x) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x z-angle)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x y-angle)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x x-angle)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x cons)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x array)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x euler-zyx)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x matrix)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x axis-angle)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x complex)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x real)) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x (eql nil))) => result
Convert orientation X to a quaternion.

QUATERNION

[method]

QUATERNION: ((x quaternion)) => result
Convert orientation X to a quaternion.

QUATERNION*

[function]

QUATERNION*: (x y z w) => result
Construct a quaternion from its elements.

QUATERNION-FROM-VECTORS

[function]

QUATERNION-FROM-VECTORS: (u v &optional q) => result
Find the unit quaternion representing the rotation from U to V.

QUATERNION-IDENTITY-P

[function]

QUATERNION-IDENTITY-P: (quaternion) => result
Test if it is the identify quaternion.

QUATERNION-TRANSLATION

[standard class]

QUATERNION-TRANSLATION

[generic-function]

QUATERNION-TRANSLATION: (x) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x euler-zyx)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x axis-angle)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x z-angle)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x y-angle)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x x-angle)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x quaternion)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x vec3)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x dual-quaternion)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x (eql nil))) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x cons)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x array)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x tf-readable)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION

[method]

QUATERNION-TRANSLATION: ((x quaternion-translation)) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION*

[function]

QUATERNION-TRANSLATION*: (r x) => result
Convert transform X to quaternion-translation form.

QUATERNION-TRANSLATION-2

[generic-function]

QUATERNION-TRANSLATION-2: (r x) => result
Convert rotation R and translation X to quaternion-translation form.

QUATERNION-TRANSLATION-2

[method]

QUATERNION-TRANSLATION-2: (r x) => result
Convert rotation R and translation X to quaternion-translation form.

QUATERNION-TRANSLATION-2

[method]

QUATERNION-TRANSLATION-2: ((r quaternion) (x vec3)) => result
Convert rotation R and translation X to quaternion-translation form.

QUATERNION-W

[function]

QUATERNION-W: (q) => result
Return the quaternion W element.

QUATERNION-X

[function]

QUATERNION-X: (q) => result
Return the quaternion X element.

QUATERNION-Y

[function]

QUATERNION-Y: (q) => result
Return the quaternion Y element.

QUATERNION-Z

[function]

QUATERNION-Z: (q) => result
Return the quaternion Z element.

ROTATION

[generic-function]

ROTATION: (x) => result
Extract the rotation part of X

ROTATION

[method]

ROTATION: ((x quaternion-translation)) => result
Return the rotation quaternion part.

ROTATION-MATRIX

[generic-function]

ROTATION-MATRIX: (x) => result
Convert orientation X to a rotation matrix.

ROTATION-MATRIX

[method]

ROTATION-MATRIX: ((x z-angle)) => result
Convert orientation X to a rotation matrix.

ROTATION-MATRIX

[method]

ROTATION-MATRIX: ((x y-angle)) => result
Convert orientation X to a rotation matrix.

ROTATION-MATRIX

[method]

ROTATION-MATRIX: ((x x-angle)) => result
Convert orientation X to a rotation matrix.

ROTATION-MATRIX

[method]

ROTATION-MATRIX: ((x axis-angle)) => result
Convert orientation X to a rotation matrix.

ROTATION-MATRIX

[method]

ROTATION-MATRIX: ((x quaternion)) => result
Convert orientation X to a rotation matrix.

TF

[function]

TF: (transform) => result
Convert TRANSFORM to TF type

TF*

[function]

TF*: (rotation translation) => result
Convert ROTATION and TRANSLATION to TF type

TF-ARRAY

[function]

TF-ARRAY: (tf &optional array) => result
Convert transform object to an array.

TF-COPY

[function]

TF-COPY: (transform &optional result) => result
Deeply copy TRANFORM into RESULT.

TF-INVERSE

[function]

TF-INVERSE: (transform &optional inverse) => result
Compute the inverse of the transform.

TF-MUL

[function]

TF-MUL: (tf-0 tf-1 &optional result) => result
Multiply TF-0 and TF-1, storing in RESULT.

TF-NORMALIZE

[function]

TF-NORMALIZE: (transform &optional result) => result
Normalize TRANSFORM, storing into RESULT.

TF-QUATERNION

[function]

TF-QUATERNION: (transform) => result
Return the rotation part as a quaternion

TF-READABLE

[standard class]

Human-readable transform

TF-READABLE

[function]

TF-READABLE: (tf) => result
Convert TF to human-readable form.

TF-READABLE*

[function]

TF-READABLE*: (rotation translation) => result
Create a human-readable transform.

TF-TAG

[standard class]

A transform tragged with parent and child frame labels.

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

TF-TREE-ABSOLUTE-TF

[function]

TF-TREE-ABSOLUTE-TF: (relative-tree frame) => result
Compute the absolute transform of FRAME.

TF-TREE-FIND

[function]

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

TF-TREE-INSERT

[function]

TF-TREE-INSERT: (tree tf-tag) => result
Add tagged TF to tree.

TF-TREE-REMOVE

[function]

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

TRANSFORM

[generic-function]

TRANSFORM: (tf point) => result
Transform a point.

TRANSFORM

[method]

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

TRANSFORM

[method]

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

TRANSFORM

[method]

TRANSFORM: ((tf matrix) (point vec3)) => result
Transform a point.

TRANSFORM

[method]

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

TRANSFORM

[method]

TRANSFORM: ((tf quaternion) (point vec3)) => result
Transform a point.

TRANSFORMATION-MATRIX

[generic-function]

TRANSFORMATION-MATRIX: (x) => result
Convert transform X to a trasnformation matrix form.

TRANSFORMATION-MATRIX-2

[generic-function]

TRANSFORMATION-MATRIX-2: (r x) => result
Convert rotation R and translation X to transformation matrix form.

TRANSLATION

[generic-function]

TRANSLATION: (x) => result
Extract the translation part of X

TRANSLATION

[method]

TRANSLATION: ((x quaternion-translation)) => result
Return the translation quaternion part.

VEC

[function]

VEC: (&rest args) => result
Create a floating-point vector

VEC-CAT

[function]

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

VEC-DIST

[function]

VEC-DIST: (a b) => result
Return the Euclidean distance between two vectors.

VEC-FLATTEN

[function]

VEC-FLATTEN: (sequence) => result
Flatten positionly-nested sequences into a single numeric vector.

VEC-LIST

[function]

VEC-LIST: (vec) => result
Convert VEC to a list.

VEC-NORM

[function]

VEC-NORM: (x) => result
Return the Euclidean normal of the vectors.

VEC-SEQUENCE

[function]

VEC-SEQUENCE: (vec) => result
Ensure that VEC is a sequence.

VEC-SSD

[function]

VEC-SSD: (a b) => result
Return the sum of squared differences between vectors A and B.

VEC-W

[function]

VEC-W: (vector) => result
Return the W element of the vector.

VEC-X

[function]

VEC-X: (vector) => result
Return the X element of the vector.

VEC-Y

[function]

VEC-Y: (vector) => result
Return the Y element of the vector.

VEC-Z

[function]

VEC-Z: (vector) => result
Return the Z element of the vector.

VEC3

[standard class]

VEC3

[generic-function]

VEC3: (x) => result
Convert X to a 3-element vector.

VEC3

[method]

VEC3: ((x cons)) => result
Convert X to a 3-element vector.

VEC3

[method]

VEC3: ((x array)) => result
Convert X to a 3-element vector.

VEC3

[method]

VEC3: ((x (eql nil))) => result
Convert X to a 3-element vector.

VEC3

[method]

VEC3: ((x vec3)) => result
Convert X to a 3-element vector.

VEC3*

[function]

VEC3*: (x y z) => result
Construct a vector-3 from components.

VEC3-IDENTITY-P

[function]

VEC3-IDENTITY-P: (vec3) => result
Check if vector-3 is 'identity', i.e., zero.

VEC3-NORMALIZE

[function]

VEC3-NORMALIZE: (v) => result
Normalize a vector-3 to norm of 1.

VECREF

[function]

VECREF: (vector i) => result
Return I'th element of column vector VECTOR

WITH-QUATERNION

[macro]

WITH-QUATERNION: ((x y z w) quaternion declaration* statement*) => result
Bind the components of QUATERNION.

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

Authors

  • Neil T. Dantam