amino  1.0-beta2
Lightweight Robot Utility Library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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 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