BungeOfKocks
- Bunge angles from Kocks angles.

bunge = BungeOfKocks(kocks, units)

BungeOfKocks - Bunge angles from Kocks angles. USAGE: bunge = BungeOfKocks(kocks, units) INPUT: kocks is 3 x n, the Kocks angles for the same orientations units is a string, either 'degrees' or 'radians' OUTPUT: bunge is 3 x n, the Bunge angles for n orientations NOTES: * The angle units apply to both input and output.

BungeOfRMat
- Bunge angles from rotation matrices.

bunge = BungeOfRMat(rmat, units)

BungeOfRMat - Bunge angles from rotation matrices. USAGE: bunge = BungeOfRMat(rmat, units) INPUT: rmat is 3 x 3 x n, an array of rotation matrices units is a string, either 'degrees' or 'radians' specifying the output angle units OUTPUT: bunge is 3 x n, the array of Euler angles using Bunge convention

CubBaseMesh
- Return base mesh for cubic symmetries

m = CubBaseMesh()

CubBaseMesh - Return base mesh for cubic symmetries USAGE: m = CubBaseMesh INPUT: no inputs OUTPUT: m is a MeshStructure, on the cubic fundamental region

CubPolytope
- Polytope for cubic fundamental region.

cubp = CubPolytope()

CubPolytope - Polytope for cubic fundamental region. USAGE: cubp = CubPolytope INPUT: none OUTPUT: cubp is a PolytopeStructure: it gives the polytope for the cubic fundamental region including the vertex list and the faces component (for plotting)

CubSymmetries
- Return quaternions for cubic symmetry group.

csym = CubSymmetries()

CubSymmetries - Return quaternions for cubic symmetry group. USAGE: csym = CubSymmetries INPUT: none OUTPUT: csym is 4 x 24, quaternions for the cubic symmetry group

HexBaseMesh
- Return base mesh for hexagonal symmetries

m = HexBaseMesh()

HexBaseMesh - Return base mesh for hexagonal symmetries USAGE: m = HexBaseMesh INPUT: none OUTPUT: m is a MeshStructure, on the hexagonal fundamental region

HexPolytope
- Polytope for hexagonal fundamental region.

hexp = HexPolytope()

HexPolytope - Polytope for hexagonal fundamental region. USAGE: hexp = HexPolytope INPUT: none OUTPUT: hexp is a PolytopeStructure: the polytope of the hexgonal fundamental region; it includes the vertex list and the list of polygonal faces

HexSymmetries
- Quaternions for hexagonal symmetry group.

hsym = HexSymmetries()

HexSymmetries - Quaternions for hexagonal symmetry group. USAGE: hsym = HexSymmetries INPUT: none OUTPUT: hsym is 4 x 12, it is the hexagonal symmetry group represented as quaternions

KocksOfBunge
- Kocks angles from Bunge angles.

kocks = KocksOfBunge(bunge, units)

KocksOfBunge - Kocks angles from Bunge angles. USAGE: kocks = KocksOfBunge(bunge, units) INPUT: bunge is 3 x n, the Bunge angles for n orientations units is a string, either 'degrees' or 'radians' OUTPUT: kocks is 3 x n, the Kocks angles for the same orientations NOTES: * The angle units apply to both input and output.

QuatOfAngleAxis
- Quaternion of angle/axis pair.

quat = QuatOfAngleAxis(angle, raxis)

QuatOfAngleAxis - Quaternion of angle/axis pair. USAGE: quat = QuatOfAngleAxis(angle, rotaxis) INPUT: angle is an n-vector, the list of rotation angles raxis is 3 x n, the list of rotation axes, which need not be normalized (e.g. [1 1 1]'), but must be nonzero OUTPUT: quat is 4 x n, the quaternion representations of the given rotations. The first component of quat is nonnegative.

QuatOfRod
- Quaternion from Rodrigues vectors.

quat = QuatOfRod(rod)

QuatOfRod - Quaternion from Rodrigues vectors. USAGE: quat = QuatOfRod(rod) INPUT: rod is 3 x n, an array whose columns are Rodrigues parameters OUTPUT: quat is 4 x n, an array whose columns are the corresponding unit quaternion parameters; the first component of `quat' is nonnegative

QuatProd
- Product of two unit quaternions.

qp = QuatProd(q2, q1)

QuatProd - Product of two unit quaternions. USAGE: qp = QuatProd(q2, q1) INPUT: q2, q1 are 4 x n, arrays whose columns are quaternion parameters OUTPUT: qp is 4 x n, the array whose columns are the quaternion parameters of the product; the first component of qp is nonnegative NOTES: * If R(q) is the rotation corresponding to the quaternion parameters q, then R(qp) = R(q2) R(q1)

RMatOfBunge
- Rotation matrix from Bunge angles.

rmat = RMatOfBunge(bunge, units)

RMatOfBunge - Rotation matrix from Bunge angles. USAGE: rmat = RMatOfBunge(bunge, units) INPUT: bunge is 3 x n, the array of Bunge parameters units is a string, either 'degrees' or 'radians' OUTPUT: rmat is 3 x 3 x n, the corresponding rotation matrices

RMatOfQuat
- Convert quaternions to rotation matrices.

rmat = RMatOfQuat(quat)

RMatOfQuat - Convert quaternions to rotation matrices. USAGE: rmat = RMatOfQuat(quat) INPUT: quat is 4 x n, an array of quaternion parameters OUTPUT: rmat is 3 x 3 x n, the corresponding array of rotation matrices NOTES: * This is not optimized, but still does okay (about 6,700/sec on intel-linux ~2GHz)

RodDifferential
- Differential map for Rodrigues

diff = RodDifferential(rmesh, refpts)

RodDifferential - Differential map for Rodrigues USAGE: diff = RodDifferential(rmesh, refpts) INPUT: mesh is a mesh, on a Rodrigues mesh refpts is 4 x n, a list of points in the reference element, usually the quadrature points, given in barycentric coordinates OUTPUT: diff is 4 x 3 x nq, a list of tangent vectors at each reference point for each element; nq is the number of global quadrature points, that is n x ne, where ne is the number of elements

RodDistance
- Find angular distance between rotations.

dist = RodDistance(pt, ptlist, sym)

RodDistance - Find angular distance between rotations. USAGE: dist = RodDistance(pt, ptlist, sym) INPUT: pt is 3 x 1, a point given in Rodrigues parameters ptlist is 3 x n, a list of points, also Rodrigues sym is 4 x m, the symmetry group in quaternions OUTPUT: dist is 1 x n, the distance between `pt' and each point in `ptlist'

RODGAUSSIAN
- Gaussian distribution on angular distance.

gauss = RodGaussian(cen, pts, stdev, sym)

RODGAUSSIAN - Gaussian distribution on angular distance. USAGE: gauss = RodGaussian(cen, pts, stdev, sym) INPUT: cen is 3 x 1, the center of the distribution (in Rodrigues parameters) pts is 3 x n, a list of points (Rodrigues parameters) stdev is 1 x 1, the standard deviation of the distribution sym is 4 x k, the symmetry group (quaternions) OUTPUT: gauss is 1 x n, the list of values at each input point NOTES: * This returns the values of a (not normalized) 1D Gaussian applied to angular distance from the center point * The result is not normalized to have unit integral.

RodMetric
- find volume integration factor due to metric

metric = RodMetric(rod)

RodMetric - find volume integration factor due to metric USAGE: metric = RodMetric(rod) INPUT: rod is 3 x n, an array of 3-vectors (Rodrigues parameters) OUTPUT: metric is 1 x n, the metric at each point of `rod'

RodOfQuat
- Rodrigues parameterization from quaternion.

rod = RodOfQuat(quat)

RodOfQuat - Rodrigues parameterization from quaternion. USAGE: rod = RodOfQuat(quat) INPUT: quat is 4 x n, an array whose columns are quaternion paramters; it is assumed that there are no binary rotations (through 180 degrees) represented in the input list OUTPUT: rod is 3 x n, an array whose columns form the Rodrigues parameterization of the same rotations as quat

ToFundamentalRegion
- Put rotation in fundamental region.

rod = ToFundamentalRegion(quat, qsym)

ToFundamentalRegion - Put rotation in fundamental region. USAGE: rod = ToFundamentalRegion(quat, qsym) INPUT: quat is 4 x n, an array of n quaternions qsym is 4 x m, an array of m quaternions representing the symmetry group OUTPUT: rod is 3 x n, the array of Rodrigues vectors lying in the fundamental region for the symmetry group in question NOTES: * This routine is very memory intensive since it applies all symmetries to each input quaternion.

ToFundamentalRegionQ
- To quaternion fundamental region.

q = ToFundamentalRegionQ(quat, qsym)

ToFundamentalRegionQ - To quaternion fundamental region. USAGE: q = ToFundamentalRegionQ(quat, qsym) INPUT: quat is 4 x n, an array of n quaternions qsym is 4 x m, an array of m quaternions representing the symmetry group OUTPUT: q is 4 x n, the array of quaternions lying in the fundamental region for the symmetry group in question NOTES: * This routine is very memory intensive since it applies all symmetries to each input quaternion.