![]() |
amino
1.0-beta2
Lightweight Robot Utility Library
|
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.
[function]
%MAKE-MATRIX: (&key (data data) (offset offset) (stride stride) (cols cols) (rows rows)) => result
[function]
%MATRIX-COLS: (instance) => result
[function]
%MATRIX-DATA: (instance) => result
[function]
%MATRIX-OFFSET: (instance) => result
[function]
%MATRIX-ROWS: (instance) => result
[function]
%MATRIX-STRIDE: (instance) => result
[function]
CHECK-MATRIX-BOUNDS: (data offset stride rows columns) => result
[function]
CHECK-MATRIX-DIMENSIONS: (&rest dimensions) => result
[function]
MAKE-CRS-MATRIX: (row-count column-count element-count) => result
Create a sparse matrix in compressed row storage form
M
[function]
MAKE-REAL-ARRAY: (&key (data data)) => result
[standard class]
Descriptor for a matrix following LAPACK conventions.
M
[function]
MATRIX-DIMENSION-ERROR: (format &rest args) => result
[function]
MATRIX-STORAGE-ERROR: (format &rest args) => result
[standard class]
[function]
REAL-ARRAY-DATA: (instance) => result
[function]
VEC: (&rest args) => result
Create a floating-point vector
(
[function]
(SETF %MATRIX-COLS): (value instance) => result
[function]
(SETF %MATRIX-DATA): (value instance) => result
[function]
(SETF %MATRIX-OFFSET): (value instance) => result
[function]
(SETF %MATRIX-ROWS): (value instance) => result
[function]
(SETF %MATRIX-STRIDE): (value instance) => result
[function]
(SETF REAL-ARRAY-DATA): (value instance) => result
[special-var]
An identity transformation.
A
[standard class]
An orientation in axis-angle form
A
[generic-function]
AXIS-ANGLE: (x) => result
Convert orientation X to axis-angle form.
A
[method]
AXIS-ANGLE: ((x z-angle)) => result
Convert orientation X to axis-angle form.
A
[method]
AXIS-ANGLE: ((x y-angle)) => result
Convert orientation X to axis-angle form.
A
[method]
AXIS-ANGLE: ((x x-angle)) => result
Convert orientation X to axis-angle form.
A
[method]
AXIS-ANGLE: ((x quaternion)) => result
Convert orientation X to axis-angle form.
A
[function]
AXIS-ANGLE*: (x y z theta) => result
Create an axis-angle orientation from components.
C
[function]
CROSS: (a b &optional c) => result
Compute the cross product of vector-3 A and B.
D
[function]
DEGREES: (value) => result
Convert VALUE in degrees to radians.
D
[standard class]
[generic-function]
DUAL-QUATERNION: (x) => result
Convert transform X to dual quaternion form.
D
[method]
DUAL-QUATERNION: ((x array)) => result
Convert transform X to dual quaternion form.
D
[method]
DUAL-QUATERNION: ((x quaternion-translation)) => result
Convert transform X to dual quaternion form.
D
[method]
DUAL-QUATERNION: ((x quaternion)) => result
Convert transform X to dual quaternion form.
D
[method]
DUAL-QUATERNION: ((x (eql nil))) => result
Convert transform X to dual quaternion form.
D
[method]
DUAL-QUATERNION: ((x dual-quaternion)) => result
Convert transform X to dual quaternion form.
D
[generic-function]
DUAL-QUATERNION-2: (r x) => result
Convert rotation R and translation X to dual quaternion form.
D
[method]
DUAL-QUATERNION-2: ((r matrix) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.
D
[method]
DUAL-QUATERNION-2: ((r axis-angle) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.
D
[method]
DUAL-QUATERNION-2: ((r euler-angle) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.
D
[method]
DUAL-QUATERNION-2: ((r principal-angle) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.
D
[method]
DUAL-QUATERNION-2: ((r quaternion) (x vec3)) => result
Convert rotation R and translation X to dual quaternion form.
E
[function]
ENSURE-VEC: (thing) => result
Coerce THING to a vec.
E
[generic-function]
EULER-RPY: (x) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x z-angle)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x y-angle)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x x-angle)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x quaternion)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x (eql nil))) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x cons)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[method]
EULER-RPY: ((x array)) => result
Convert orientation X to Euler angle roll-pitch-yaw form.
E
[function]
EULER-RPY*: (r p y) => result
Alias for ZYX euler angles.
E
[standard class]
[generic-function]
EULER-ZYX: (x) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x z-angle)) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x y-angle)) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x x-angle)) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x cons)) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x array)) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x quaternion)) => result
Convert orientation X to Euler angle ZYX form.
E
[method]
EULER-ZYX: ((x (eql nil))) => result
Convert orientation X to Euler angle ZYX form.
E
[function]
EULER-ZYX*: (z y x) => result
Construct Euler angle from components.
F
[function]
FNVEC: (&rest args) => result
Create a fixnum vector
F
[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
[function]
IDENTITY-QUATERNION: () => result
Return the identity quaternion.
I
[function]
IDENTITY-TF: () => result
Return the identity transform.
I
[function]
IDENTITY-VEC3: () => result
Return the "identity" 3-vector.
I
[generic-function]
INVERSE: (x) => result
Compute the inverse of X
I
[method]
INVERSE: ((x quaternion-translation)) => result
Compute the inverse of X
I
[method]
INVERSE: ((x principal-angle)) => result
Compute the inverse of X
I
[method]
INVERSE: ((x quaternion)) => result
Compute the inverse of X
I
[method]
INVERSE: ((x real)) => result
Compute the inverse of X
M
[function]
MAKE-CRS-MATRIX: (row-count column-count element-count) => result
Create a sparse matrix in compressed row storage form
M
[function]
MAKE-FNVEC: (n) => result
Make a floating point (double) vector.
M
[function]
MAKE-MATRIX: (m n) => result
Make a new matrix with M rows and N cols.
M
[function]
MAKE-TF-TREE: () => result
Create a new TF tree. The tree is a map from the frame name to its relative transform.
M
[function]
MAKE-VEC: (n &key initial-element) => result
Make a floating point (double) vector.
M
[function]
MATREF: (matrix i j) => result
Return element at row i, col j.
M
[generic-function]
MATRIX->LIST: (matrix) => result
Convert a matrix type to a list.
M
[method]
MATRIX->LIST: ((matrix quaternion-translation)) => result
Convert a matrix type to a list.
M
[method]
MATRIX->LIST: ((matrix real-array)) => result
Convert a matrix type to a list.
M
[method]
MATRIX->LIST: ((matrix array)) => result
Convert a matrix type to a list.
N
[generic-function]
NORMALIZE: (x) => result
Compute the normalized form of X
N
[method]
NORMALIZE: ((x quaternion-translation)) => result
Make the rotation component a unit quaternion. Translation is not altered.
N
[method]
NORMALIZE: ((x list)) => result
Compute the normalized form of X
N
[method]
NORMALIZE: ((x array)) => result
Compute the normalized form of X
N
[method]
NORMALIZE: ((x real)) => result
Compute the normalized form of X
P
[function]
PARSE-FLOAT: (string &optional invalid-error invalid-value) => result
[function]
PI-RAD: (value) => result
Return VALUE*pi
Q
[standard class]
[generic-function]
QUATERNION: (x) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x z-angle)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x y-angle)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x x-angle)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x cons)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x array)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x euler-zyx)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x matrix)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x axis-angle)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x complex)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x real)) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x (eql nil))) => result
Convert orientation X to a quaternion.
Q
[method]
QUATERNION: ((x quaternion)) => result
Convert orientation X to a quaternion.
Q
[function]
QUATERNION*: (x y z w) => result
Construct a quaternion from its elements.
Q
[function]
QUATERNION-FROM-VECTORS: (u v &optional q) => result
Find the unit quaternion representing the rotation from U to V.
Q
[function]
QUATERNION-IDENTITY-P: (quaternion) => result
Test if it is the identify quaternion.
Q
[standard class]
[generic-function]
QUATERNION-TRANSLATION: (x) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x euler-zyx)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x axis-angle)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x z-angle)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x y-angle)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x x-angle)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x quaternion)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x vec3)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x dual-quaternion)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x (eql nil))) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x cons)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x array)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x tf-readable)) => result
Convert transform X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION: ((x quaternion-translation)) => result
Convert transform X to quaternion-translation form.
Q
[function]
QUATERNION-TRANSLATION*: (r x) => result
Convert transform X to quaternion-translation form.
Q
[generic-function]
QUATERNION-TRANSLATION-2: (r x) => result
Convert rotation R and translation X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION-2: (r x) => result
Convert rotation R and translation X to quaternion-translation form.
Q
[method]
QUATERNION-TRANSLATION-2: ((r quaternion) (x vec3)) => result
Convert rotation R and translation X to quaternion-translation form.
Q
[function]
QUATERNION-W: (q) => result
Return the quaternion W element.
Q
[function]
QUATERNION-X: (q) => result
Return the quaternion X element.
Q
[function]
QUATERNION-Y: (q) => result
Return the quaternion Y element.
Q
[function]
QUATERNION-Z: (q) => result
Return the quaternion Z element.
R
[generic-function]
ROTATION: (x) => result
Extract the rotation part of X
R
[method]
ROTATION: ((x quaternion-translation)) => result
Return the rotation quaternion part.
R
[generic-function]
ROTATION-MATRIX: (x) => result
Convert orientation X to a rotation matrix.
R
[method]
ROTATION-MATRIX: ((x z-angle)) => result
Convert orientation X to a rotation matrix.
R
[method]
ROTATION-MATRIX: ((x y-angle)) => result
Convert orientation X to a rotation matrix.
R
[method]
ROTATION-MATRIX: ((x x-angle)) => result
Convert orientation X to a rotation matrix.
R
[method]
ROTATION-MATRIX: ((x axis-angle)) => result
Convert orientation X to a rotation matrix.
R
[method]
ROTATION-MATRIX: ((x quaternion)) => result
Convert orientation X to a rotation matrix.
T
[function]
TF: (transform) => result
Convert TRANSFORM to TF type
T
[function]
TF*: (rotation translation) => result
Convert ROTATION and TRANSLATION to TF type
T
[function]
TF-ARRAY: (tf &optional array) => result
Convert transform object to an array.
T
[function]
TF-COPY: (transform &optional result) => result
Deeply copy TRANFORM into RESULT.
T
[function]
TF-INVERSE: (transform &optional inverse) => result
Compute the inverse of the transform.
T
[function]
TF-MUL: (tf-0 tf-1 &optional result) => result
Multiply TF-0 and TF-1, storing in RESULT.
T
[function]
TF-NORMALIZE: (transform &optional result) => result
Normalize TRANSFORM, storing into RESULT.
T
[function]
TF-QUATERNION: (transform) => result
Return the rotation part as a quaternion
T
[standard class]
Human-readable transform
T
[function]
TF-READABLE: (tf) => result
Convert TF to human-readable form.
T
[function]
TF-READABLE*: (rotation translation) => result
Create a human-readable transform.
T
[standard class]
A transform tragged with parent and child frame labels.
T
[function]
TF-TAG: (parent tf child) => result
[function]
TF-TAG-CHILD: (instance) => result
[function]
TF-TAG-PARENT: (instance) => result
[function]
TF-TAG-TF: (instance) => result
[function]
TF-TRANSLATION: (transform) => result
Return the translation part.
T
[function]
TF-TREE-ABSOLUTE-TF: (relative-tree frame) => result
Compute the absolute transform of FRAME.
T
[function]
TF-TREE-FIND: (tree frame) => result
Find the TF in the tree
T
[function]
TF-TREE-INSERT: (tree tf-tag) => result
Add tagged TF to tree.
T
[function]
TF-TREE-REMOVE: (tree frame) => result
Remove FRAME from tree
T
[generic-function]
TRANSFORM: (tf point) => result
Transform a point.
T
[method]
TRANSFORM: ((tf euler-angle) (point vec3)) => result
Transform a point.
T
[method]
TRANSFORM: ((tf principal-angle) (point vec3)) => result
Transform a point.
T
[method]
TRANSFORM: ((tf matrix) (point vec3)) => result
Transform a point.
T
[method]
TRANSFORM: ((tf quaternion-translation) (point vec3)) => result
Transform a point.
T
[method]
TRANSFORM: ((tf quaternion) (point vec3)) => result
Transform a point.
T
[generic-function]
TRANSFORMATION-MATRIX: (x) => result
Convert transform X to a trasnformation matrix form.
T
[method]
TRANSFORMATION-MATRIX: ((x dual-quaternion)) => result
Convert transform X to a trasnformation matrix form.
T
[method]
TRANSFORMATION-MATRIX: ((x quaternion-translation)) => result
Convert transform X to a trasnformation matrix form.
T
[generic-function]
TRANSFORMATION-MATRIX-2: (r x) => result
Convert rotation R and translation X to transformation matrix form.
T
[generic-function]
TRANSLATION: (x) => result
Extract the translation part of X
T
[method]
TRANSLATION: ((x quaternion-translation)) => result
Return the translation quaternion part.
V
[function]
VEC: (&rest args) => result
Create a floating-point vector
V
[function]
VEC-CAT: (&rest args) => result
Concatenate vectors.
V
[function]
VEC-DIST: (a b) => result
Return the Euclidean distance between two vectors.
V
[function]
VEC-FLATTEN: (sequence) => result
Flatten positionly-nested sequences into a single numeric vector.
V
[function]
VEC-LIST: (vec) => result
Convert VEC to a list.
V
[function]
VEC-NORM: (x) => result
Return the Euclidean normal of the vectors.
V
[function]
VEC-SEQUENCE: (vec) => result
Ensure that VEC is a sequence.
V
[function]
VEC-SSD: (a b) => result
Return the sum of squared differences between vectors A and B.
V
[function]
VEC-W: (vector) => result
Return the W element of the vector.
V
[function]
VEC-X: (vector) => result
Return the X element of the vector.
V
[function]
VEC-Y: (vector) => result
Return the Y element of the vector.
V
[function]
VEC-Z: (vector) => result
Return the Z element of the vector.
V
[standard class]
[generic-function]
VEC3: (x) => result
Convert X to a 3-element vector.
V
[method]
VEC3: ((x cons)) => result
Convert X to a 3-element vector.
V
[method]
VEC3: ((x array)) => result
Convert X to a 3-element vector.
V
[method]
VEC3: ((x (eql nil))) => result
Convert X to a 3-element vector.
V
[method]
VEC3: ((x vec3)) => result
Convert X to a 3-element vector.
V
[function]
VEC3*: (x y z) => result
Construct a vector-3 from components.
V
[function]
VEC3-IDENTITY-P: (vec3) => result
Check if vector-3 is 'identity', i.e., zero.
V
[function]
VEC3-NORMALIZE: (v) => result
Normalize a vector-3 to norm of 1.
V
[function]
VECREF: (vector i) => result
Return I'th element of column vector VECTOR
W
[macro]
WITH-QUATERNION: ((x y z w) quaternion declaration* statement*) => result
Bind the components of QUATERNION.
W
[macro]
WITH-VEC3: ((x y z) vec3 declaration* statement*) => result
Bind the elements of a VEC3.
X
[standard class]
A rotation about the X axis
X
[function]
X-ANGLE: (value) => result
Construct a rotation about the X axis.
Y
[standard class]
A rotation about the Y axis
Y
[function]
Y-ANGLE: (value) => result
Construct a rotation about the Y axis.
Z
[standard class]
A rotation about the Z axis
Z
[function]
Z-ANGLE: (value) => result
Construct a rotation about the Z axis.
(
[function]
(SETF MATREF): (value matrix i j) => result
Set element at row i, col j.
(
[function]
(SETF TF-TAG-CHILD): (value instance) => result
[function]
(SETF TF-TAG-PARENT): (value instance) => result
[function]
(SETF TF-TAG-TF): (value instance) => result
[function]
(SETF VECREF): (value vec i) => result
Set the I'th value of VEC to VALUE.
A