Functions - Alphabetical List

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A

AbelPoissonKernel the Abel Poisson kernel
abs (S2FunHarmonic) absolute value of a function Syntax sF = abs(sF) sF = abs(sF, 'bandwidth', bandwidth)
abs (S2FunTri) ABS Absolute value. ABS(X) is the absolute value of the elements of X. When X is complex, ABS(X) is the complex modulus (magnitude) of the elements of X.
abs (vector3d) length of vector
accumarray (vector3d) accumarray for vector3d
acos (S2FunHarmonic) cost of a function Syntax sF = acos(sF) sF = acos(sF, 'bandwidth', bandwidth)
add (crystalSymmetry) add additional symmetry operations to a crystal symmetry
adjustFigurePosition (mtexFigure) determine optimal size
affinetrans (EBSD) perform an affine transformation on spatial ebsd data
alignment (symmetry) return alignment of the reference frame as string, e.g. x||a, y||b*
allPairs all pairs of elements of x and y modulo permutation
allTriple all triple of elements of x and y modulo permutation
angle (S2AxisFieldTri) Syntax sVF = angle(sVF,sVF2) sVF = angle(sVF,v)
angle (S2VectorFieldTri) Syntax sVF = angle(sVF,sVF2) sVF = angle(sVF,v)
angle (fibre) angle fibre to orientation or fibre to fibre
angle (orientation) calculates rotational angle between orientations
angle (quaternion) calcualtes the rotational angle between rotations q1 and q2
angle (vector3d) angle between two vectors
angle_outer (quaternion) calcualtes the rotational angle between all rotations q1 and q2
angle_outer (vector3d) angle between two vectors Input v1, v2 - @vector3d
angularVelocityVector (velocityGradientTensor) angular velocity vector omega
annotate annotate to a existing figure
antiSym (tensor) the antisymmetric part A = 0.5(T - T.') of a tensor
apply_recursivly apply cmd recursively to all file in a directory
approximation (S2AxisFieldHarmonic) Syntax sAF = S2AxisField.quadrature(v, value) sAF = S2AxisField.quadrature(v, value, 'bandwidth', bw)
approximation (S2FunHarmonic) computes a least square problem to get an approximation Syntax sF = S2FunHarmonic.approximation(S2Grid, f) sF = S2FunHarmonic.approximation(S2Grid, f, 'bandwidth', bandwidth, 'tol', TOL, 'maxit', MAXIT, 'weights', W)
approximation (S2VectorFieldHarmonic) Syntax sVF = S2VectorField.quadrature(v, value) sVF = S2VectorField.quadrature(v, value, 'bandwidth', bw)
ar2rgb compute rgb values from angle and radius
area (grain2d) calculates the area of a list of grains
argin_check check ar to be of class classes
arrow3d (vector3d) plot three dimensional arrows
aspectRatio (grain2d) aspectratio = length / width
assert_grid check for valid grid parameters
assertExt assertExt is a function. assertExt(fname, extList)
axesDual (crystalSymmetry) return dual coordinate axes
axis (orientation) rotational axis of an misorientation or two orientations
axis (quaternion) rotational axis of the quaternion
axis2quat rotational axis, roational angle to Quaternion
axis2quat_outer rotational axis, roational angle to Quaternion
axisAngleColorKey
axisAnglePlot create a 3d Euler angle plot
axisAngleSections defines an axis angle section
axisRatios (strainTensor) logarithmic axis ratios of the finite strain ellipsoid
axisRatios (velocityGradientTensor) logarithmic axis ratios of the finite strain ellipsoid
axisSector (orientationRegion) computes the sector of rotational axes for orientations within region

B

bandwidth (ODF) bandwidth of the ODF
basicHKL (crystalSymmetry) plot symmetry
BCV (orientation) biased cross validation
bingham_test (orientation) bingham test for spherical/prolat/oblat case
BinghamComponent (BinghamComponent) BinghamComponent is a class. component = BinghamComponent(kappa, A)
BinghamODF defines a Bingham distributed ODF
BinghamS2 (BinghamS2) Input Z - smoothing parameters; Z(1)>=Z(2)>=Z(3), Z(3)<0 Z(1)=Z(2) rotationally symmetric unimodal distribution Z(1)<<Z(2) partial girdle distribution
binghamS2_demo BinghamS2: spherical Bingham distribution function
binsearch binaer search for zero in a motonously increasing function
birefringence (refractiveIndexTensor) birefringence from refractive index tensor
black2whiteColorMap Linear white to black gray-scale color map
blue2redColorMap creates a colormap, ranging from dark blue via white to dark red.
boundary (sphericalRegion) compute boundary points
boundarySize (grain2d) number of boundary segment
bucketSearch n-d search of the closest vertex out of a set of vertices V
bumpKernel the bump kernel Detailed explanation goes here
BungeColorKey assigns rgb values to orientations according the the Euler angles
BungePlot create a 3d Euler angle plot
byAxisAngle (orientation) define orientations by rotational axis and rotational angle
byAxisAngle (rotation) define rotations by rotational axis and rotational angle
byEuler (orientation) define orientations by Euler angles
byEuler (rotation) define rotentations by Euler angles
byMatrix (orientation) define orientations by a matrix
byMatrix (rotation) define rotations by matrices
byMiller (orientation) define orientations by Miller Bravais indeces
byVertices (sphericalRegion) define a spherical region by its vertices

C

c_hat return the second moments for bingham test
calc_background background of spectra
calc_flags check for optional flag
calcAngleDistribution (ODF) compute the angle distribution of an ODF or an MDF
calcAngleDistribution (orientation) calculate angle distribution
calcAngleDistribution (orientationRegion) compute the angle distribution of a uniform ODF for a crystal symmetry
calcAngleDistribution (symmetry) compute the angle distribution of a uniform ODF for a crystal symmetry
calcAxisDistribution (ODF) compute the axis distribution of an ODF or MDF
calcAxisDistribution (orientationRegion) compute the axis distribution of an uniform ODF or MDF
calcAxisDistribution (symmetry) compute the axis distribution of an uniform ODF or MDF
calcAxisVolume (ODF) amount of orientations with a specific misorientation axis
calcBario (DelaunaySO3) compute bariocentric coordinates for an orientation
calcBario (S2Triangulation) S2Triangulation/calcBario is a function. [bario, tId] = calcBario(sT, v, tId)
calcBinghamODF (orientation) calculate ODF from individuel orientations via kernel density estimation
calcCluster (orientation) sort orientations into clusters
calcComponents (ODF) heuristic to find modal orientations
calcDelaunay (vector3d) compute the Delaynay triangulation for a spherical grid
calcDensity (Miller) calculate a density function out of (weighted) crystal directions
calcDensity (vector3d) calculate a density function out of (weighted) unit vectors
calcError (ODF) calculate approximation error between two ODFs
calcError (PoleFigure) RP and mean square error
calcErrorPF (PoleFigure) error polefigure between meassured and recalculated pole figures
calcFEMODF (PoleFigure) PDF to ODF inversion
calcFourier (BinghamComponent) called by ODF/calcFourier
calcFourier (FourierComponent) called by ODF/calcFourier
calcFourier (ODF) compute Fourier coefficients of odf
calcFourier (femComponent) called by ODF/calcFourier
calcFourier (fibreComponent) called by ODF/calcFourier
calcFourier (uniformComponent) called by ODF/calcFourier
calcFourier (unimodalComponent) called by ODF/calcFourier
calcFourierODF (orientation) calculate ODF from individuel orientations via kernel density estimation
calcGND (EBSDhex) compute the geometrically necessary dislocation
calcGND (EBSDsquare) compute the geometrically necessary dislocation
calcGrains (EBSD) grains reconstruction from 2d EBSD data
calcInvTaylor (orientation) Taylor factor from orientation gradient
calcKearnsFactor Syntax
calcKernel (orientation) compute an optimal kernel function for ODF estimation
calcKernelODF (orientation) calculate ODF from individuel orientations via kernel density estimation
calcMDF (FourierComponent) calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF
calcMDF (ODF) calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF
calcMDF (unimodalComponent) calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF
calcMDF (orientation) computes an MDF from individuel orientations or misorientations
calcMeanDirection (grainBoundary) compute a smoothed direction that ignores staircasing
calcMIndex (ODF) M-index of Skemer et al.(2005) based on the difference between uncorrelated and uniform misorientation angle distributions
calcMIndex (orientation) TODO!!!
calcMisorientation (EBSD) calculate uncorrelated misorientations between two ebsd phases
calcModes (BinghamComponent) return the modes of the component
calcModes (ODF) heuristic to find modal orientations
calcModes (ODFComponent) return the modes of the component
calcModes (fibreComponent) return the modes of the component
calcModes (unimodalComponent) return the modes of the component
calcNormalization (PoleFigure) normalization of a meassured pole figure with respect to a second pole figure
calcODF (MLSSolver) apply zero range method
calcODF (PoleFigure) PDF to ODF inversion
calcODF (orientation) computes an ODF from individuel orientations
calcOrientations (ODF) draw random orientations from ODF
calcPDF (BinghamComponent) called by pdf
calcPDF (FourierComponent) calculate pole figure from Fourier coefficients
calcPDF (ODF) calcPDF computed the PDF corresponding to an ODF
calcPDF (femComponent) called by pdf
calcPDF (fibreComponent) calculate pdf for fibre component
calcPDF (uniformComponent) calculate pdf
calcPDF (unimodalComponent) compute the pole density function for a given unimodal component
calcpdf_special3 (ODF) compute the pdf for h = (theta,rhoh), r = (theta,rhor)
calcPoleFigure (ODF) simulate pole figures from an ODF
calcPoleFigure (PoleFigure) simulate pole figure
calcQuadratureWeights (vector3d) compute the area of the Voronoi decomposition
calcQuat (symmetry) calculate quaternions for Laue groups
calcShearStress (stressTensor) shear stress
calcTaylor (strainTensor) compute Taylor factor and strain dependent orientation gradient
calcTaylor (velocityGradientTensor) compute Taylor factor and strain dependent orientation gradient
calcTensor (EBSD) compute the average tensor for an EBSD data set
calcTensor (FourierComponent) compute the average tensor for an ODF
calcTensor (ODF) compute the average tensor for an ODF
calcTensor (ODFComponent) compute the average tensor for an ODF
calcTensor (orientation) compute the average tensor for a vector of orientations
calcTriplePoints (grainBoundary) compute triple points
calcUnitCell compute the unit cell for an EBSD data set
calcVoronoi (quaternion) compute the the Voronoi decomposition for unit quaternions
calcVoronoi (vector3d) compute the area of the Voronoi decomposition
calcVoronoiArea (vector3d) compute the spherical area of the Voronoi decomposition
calcZeroRange (zeroRangeMethod) calculate zero range
calliper (grain2d) Calliper (Feret diameter) of a grain in measurement units, the projection length normal to it and its direction/trend.
cat (S2FunHarmonic) overloads cat
cat (EBSD) overloads [ebsd1,ebsd2,ebsd3..]
cat (grain2d) implements [grain1, grain2]
cat (PoleFigure) implement cat for PoleFigure
cat (Miller) concatenate lists of Miller indices to one list
cat (S2Grid) implements cat for S2Grid
cat (dislocationSystem) implement cat for dislocationSystem
cat (fibre) implement cat for fibre
cat (quaternion) implement cat for quaternion
cat (rotation) implement cat for rotation
cat (slipSystem) implement cat for slipSystem
cat (vector3d) implement cat for vector3d
CauchyStrain (deformationGradientTensor) Cauchy strain or small strain
cell2file write cellstring to file
centerSpecimen (ODF) rotatates an odf with specimen symmetry into its symmetry axes
centroid (grain2d) calculates the barycenters of the grain boundary
centroid (vector3d) compute the centroid of a 2d polygon in 3d
char (EBSD) ebsd -> char
char (ODF) odf -> char
char (uniformComponent) standard output
char (unimodalComponent) called by standard output
char (PoleFigure) standard output
char (tensor) tensor to char
char (Miller) Miller indece to string
char (SO3Grid) convert to char
char (crystalSymmetry) object -> string
char (quaternion) quaternion to char
char (rotation) quaternion to char
char (specimenSymmetry) object -> string
char (sphericalRegion) convert spherical region to char
char (vector3d) convert to char
ChebCoeff (FourierComponent) return Chebyshev coefficient of odf
check (DelaunaySO3) ignore this
check (symmetry) check symmetry
check_installation check whether all binaries are working properly
check_interfaces determine interface from file
check_option check for option in option list
checkEulerAngleConvention checkEulerAngleConvention is a function. r = checkEulerAngleConvention(conv1, conv2)
checkInside (grain2d) check for points or grains to be inside a big grain
checkInside (S2Triangulation) S2Triangulation/checkInside is a function. [isInside, tId, bario] = checkInside(sT, v, tId)
checkInside (orientationRegion) check for points to be inside the orientation region
checkInside (sphericalRegion) check for points to be inside the spherical region
checkOption check for option in option list
checkSymmetry (tensor) tensor/checkSymmetry is a function. out = checkSymmetry(T)
checkZeroRange (zeroRangeMethod) check for zero regions in experiementl pole figures
ChristoffelTensor (ChristoffelTensor) ChristoffelTensor is a class. sT = ChristoffelTensor(varargin)
ChristoffelTensor (complianceTensor) Christoffel tensor of an elasticity tensor for a given direction
ChristoffelTensor (stiffnessTensor) Christoffel tensor of an elasticity tensor for a given direction
circle (vector3d) annotated a circle
cleanUp (orientationRegion) testing: cs = crystalSymmetry('222'); oR = cs.fundamentalRegion;
cleanUp (sphericalRegion) sphericalRegion/cleanUp is a function. sR = cleanUp(sR)
ClebschGordan ClebschGordan.m by David Terr, Raytheon, 6-17-04 Modified on 11-9-04
ClebschGordanTensor A = [[1 1 -1];[1 1 1];[-1 1 1]];
CLim (mtexFigure) set color range for figures
closeAllButCurrentFiles close all open files exept for the current one
clusterBreaker Recursively assigns points based on neighboring assignments If flag == 0, the point is fresh, 1, the point is set >1, the point belongs to a cluster that may have run into the recusion limit
cmeans m - fuzzifier
coarser (S1Grid) makes S1Grid more coarse
colon (tensor) double dot A:B between two tensors
colorbar (mtexFigure) COLORBAR Display color bar (color scale) COLORBAR appends a colorbar to the current axes in the default (right) location
complianceTensor (complianceTensor) complianceTensor is a class. sT = complianceTensor(varargin)
compressionDirection (velocityGradientTensor) compression direction
concentration (ODF) not yet implemeted
conformalPlot create a 3d Euler angle plot
conj (S2FunHarmonic) conjugate S2FunHarmonic
conj (tensor) conjugate of a tensor
connectedComponents label connected componentes in an graph (adjacency matrix)
contour (S2Fun) spherical contour plot
contour (vector3d) spherical contour plot
contour3s contour-slices
contourf (S2Fun) spherical filled contour plot
contourf (vector3d) spherical filled contour plot
conv (S2FunHarmonic) spherical convolution of sF with a radial function psi
conv (FourierComponent) convolute ODF with kernel psi
conv (ODF) convolute ODF with kernel psi
convertFigureRGB2ind default resolution
coolColorMap COOL Shades of cyan and magenta color map COOL(M) returns an M-by-3 matrix containing a "cool" colormap. COOL, by itself, is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
copy (S2Grid) copy certain condition from grid
copy (SO3Grid) copy nodes by indece
correct (PoleFigure) corrects polfigures for background and defocussing
cos (S2FunHarmonic) cost of a function Syntax sF = cos(sF) sF = cos(sF, 'bandwidth', bandwidth)
cprintf CPRINTF convert an array of any data type to a 2D character array
cprproject_read cprproject_read is a function. phases = cprproject_read(fname)
cross (S2AxisFieldHarmonic) syntax f = cross(sAF,v) f = cross(sAF1,sAF2) f = cross(sAF,sVF)
cross (S2AxisFieldTri) Syntax sVF = cross(sVF1,sVF2) sVF = cross(sVF1,v)
cross (S2VectorFieldHarmonic) pointwise cross product
cross (S2VectorFieldTri) Syntax sVF = cross(sVF1,sVF2) sVF = cross(sVF1,v)
cross (quaternion) pointwise cross product of three quaternions
cross (vector3d) pointwise cross product of two vector3d
cross_outer (vector3d) pointwise cross product of two vector3d
crossCorrelation (orientation) computes the cross correlation for the kernel density estimator
crystalShape (crystalShape) a class representing crystal shapes.
crystalSymmetry (crystalSymmetry) constructor
CSL coincidence site lattice misorientations for cubic symmetry
ctranspose (S2FunHarmonic) ctransposes S2FunHarmonic
ctranspose (tensor) conjugate of a tensor
ctranspose (orientation) inverse orientation
ctranspose (quaternion) transpose quaternion
ctranspose (vector3d) transpose vector
cubochoricGrid (cubochoricGrid) Syntax S3G = cubochoricGrid(ori,alphabeta,gamma)
cunion disjoint union
curvature (EBSDhex) computes the incomplete curvature tensor
curvature (EBSDsquare) computes the incomplete curvature tensor
curvature (dislocationDensityTensor) compute curvature tensor from a (complete) dislocation density tensor
curvatureTensor (curvatureTensor) curvatureTensor is a class. kappa = curvatureTensor(varargin)
customKernel defines a kernel function as a function of the rotational angle
cut2unitI cut2unitI is a function. x = cut2unitI(x)

D

deformationGradientTensor (deformationGradientTensor) deformationGradientTensor is a class. F = deformationGradientTensor(varargin)
deformationTensor (slipSystem) deformation tensor
deg2dim dimension of the harmonic space up to order l
degree x * degree = x in standard arc measure
DelaunaySO3 (DelaunaySO3) Syntax
deLaValeePoussinKernel DELAVALEEPOUSSINKERNEL Summary of this class goes here Detailed explanation goes here
delete (S1Grid) delte points from S1Grid
delete (S2Grid) elilinates points from grid
delete (SO3Grid) clear nodes by indece Input SOG - @SO3Grid indece - int32
delete_option clear options in option list
det (tensor) compute the determinants of rank 2 tensors
det (vector3d) pointwise determinant or triple product of three vector3d
det3 determinant of a list of 3x3 matrices
deviatoricStrain (strainTensor) deviatoric strain tensor
deviatoricStress (stressTensor) deviatoric stress
diag (tensor) convert rank 1 or rank 0 tensor into diagonal rank 2 tensor
diameter (grain2d) diameter of a grain in measurement units longest distance between any two vertices of the grain boundary
dim2deg dimension to harmonic degree of Wiegner D functions
directionalMagnitude (tensor) magnitude of a tensor in direction v
directionColorKey converts directions to rgb values
DirichletKernel the Dirichlet kernel in the orientation space
discreteSample (S2Fun) takes a random sample of n directions from S2Fun
discreteSample (ODF) draw a random sample
discreteSample (ODFComponent) draw a random sample
discreteSample (femComponent) draw a random sample
discreteSample (fibreComponent) evaluate an odf at orientation g
discreteSample (uniformComponent) draw a random sample
discreteSample (unimodalComponent) draw a random sample
discreteSample take a diskrete sample from a list of vectors, orientations, grains, EBSD
disjoint (symmetry) returns the disjoint of two symmetry groups
dislocationDensity (curvatureTensor) compute the dislocationDensity tensor from a curvature tensor
dislocationDensityTensor (dislocationDensityTensor) dislocation density or Nye tensor
dislocationSystem (dislocationSystem) class representing dislocation systems
display (S2AxisFieldHarmonic) standard output
display (S2FunHarmonic) standard output
display (S2FunHarmonicSym) standard output
display (S2FunTri) standard output
display (S2VectorFieldHarmonic) standard output
display (S2VectorFieldTri) standard output
display (EBSD) standard output
display (grain2d) standard output
display (grainBoundary) standard output
display (triplePointList) standard output
display (BinghamComponent) standard output
display (FourierComponent) called by standard output
display (ODF) standard output
display (femComponent) called by standard output
display (fibreComponent) called by standard output
display (uniformComponent) standard output
display (unimodalComponent) called by standard output
display (PoleFigure) standard output
display (tensor) standard output
display (DelaunaySO3) standard output
display (Miller) standard output
display (S1Grid) standart output
display (S2Grid) standard output
display (SO3Grid) standard output
display (crystalShape) standard output
display (crystalSymmetry) standard output
display (fibre) standard output
display (orientation) standart output
display (orientationRegion) standard output
display (quaternion) standart output
display (rotation) standart output
display (sphericalRegion) standard output
display (vector3d) standard output
displayClass displayClass is a function. displayClass(obj, input)
dispLine (crystalSymmetry) display symmetry as a one-liner
dispLine (specimenSymmetry) display symmetry as a one-liner
dist (S1Grid) distance to all points of S1Grid
dist_outer (S1Grid) distance to all points of S1Grid
doclink doclink is a function. linkText = doclink(fname, lname)
docmethods display all methods for a certain class
docopt DOCOPT Web browser for UNIX platforms. DOCOPT is an M-file that you or your system manager can edit to specify the Web browser to use with MATLAB. It is used for the WEB function with the -BROWSER option. It is also used for links to external Web sites from the the Help browser and from Web menu items. DOCOPT applies only to non-Macintosh UNIX platforms.
doHClustering (orientation) sort orientations into clusters
doIter (MLSSolver) perform one iteration step of the modified least squares algorithm
dot (S2AxisFieldHarmonic) syntax f = dot(sAF,v) f = dot(sAF1,sAF2) f = dot(sAF,sVF)
dot (S2AxisFieldTri) Syntax sVF = dot(sVF,sVF2) sVF = dot(sVF,v)
dot (S2FunHarmonic) inner product
dot (S2VectorFieldHarmonic) pointwise inner product
dot (S2VectorFieldTri) Syntax sVF = dot(sVF,sVF2) sVF = dot(sVF,v)
dot (Miller) inner product between two Miller indece
dot (orientation) compute minimum dot(o1,o2) modulo symmetry
dot (quaternion) inner product of quaternions g1 and g2
dot (rotation) compute rot1 . rot2
dot (vector3d) pointwise inner product
dot_angle (quaternion) compute minimum q1 . q2 modulo rotation about zaxis and angle omega
dot_outer (Miller) inner product between two Miller indece
dot_outer (SO3Grid) return outer inner product of all nodes within a eps neighborhood
dot_outer (orientation) dot_outer
dot_outer (quaternion) outer inner product between two quaternions
dot_outer (rotation) dot_outer
dot_outer (vector3d) outer dot product
double (tensor) convert tensor values to matrix
double (S1Grid) convert to double
double (quaternion) quaternion to double
double (vector3d) converts vector3d to double Input v - @vector3d Output x, y, z - double
doZeroRange (MLSSolver) MLSSolver/doZeroRange is a function. doZeroRange(solver, varargin)
drawNow (mtexFigure) mtexFigure/drawNow is a function. drawNow(mtexFig, varargin)
dspacing (Miller) space between crystal planes
DubnaGrid construct specimen grid of the Dubna goniometer
DubnaPoleFigure construct pole figure using Dubna struct file
dyad dyadic tensor product
dyad (vector3d) dyadic tensor product
dynOption class to add dynamic options to a static class Detailed explanation goes here
dynProp class to add dynamic properties to a static class Detailed explanation goes here

E

eangleProjection stereographic, conformal or equal angle projection
eareaProjection equal area projection
EBSD (EBSD) constructor
EBSDhex (EBSDhex) EBSD data on a hexagonal grid. In contrast to arbitrary EBSD data the values are stored in a matrix.
EBSDsquare (EBSDsquare) EBSD data on a rectangular grid. In contrast to arbitrary EBSD data the values are stored in a matrix.
edistProjection equal distant projection
efopen file open with error message
eig (S2FunHarmonic) eigen value of a spherical function
eig (tensor) compute the eigenvalues and eigenvectors of a tensor
eig2 eigenvalue and vectors of a symmetric 2x2 matrix
eig3 eigenvalue and vectors of a symmetric 3x3 matrix
EinsteinSum tensor multiplication according to Einstein summation convention
EinsteinSum (quaternion) tensor multiplication according to Einstein summation
elements (symmetry) extract symmetry elements by multiplicity
ellipse annotate an ellipse in a spherical plot
ellipsoid (strainTensor) Length (1+e) and direction of principal axes of strain ellipsoid from finite, lagrangian/eulerian strain tensor E with eigenvalues lambda with (1+e) = sqrt(1+2*lambda) for a Lagranage strain tensor (default) (1+e) = sqrt(1-2*lambda) for a Euler strain tensor Syntax [fe,qe] = ellipsoid(E)
end (S2FunHarmonic) overloaded end function
end (tensor) overloaded end function
end (dislocationSystem) overloaded end function
end (fibre) overloaded end function
end (quaternion) overloads end function
end (slipSystem) overloaded end function
end (vector3d) overloaded end function
energyVector (stiffnessTensor) Calculates Energy velocity vector (km/s)
ensurecell ensures that v is a cell with size s
ensureCS (symmetry) ensures that an obj has the right crystal symmetry
ensureNonNeg remove small negative values
entropy (S2FunHarmonic) entropy of a function
entropy (ODF) caclulate entropy of ODF
eq (grain2d) == Equal. A == B does element by element comparisons between A and B and returns an array with elements set to logical 1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
eq (tensor) checks whether two tensors are equal
eq (S1Grid) implements G1 == G2
eq (crystalSymmetry) check S1 == S2
eq (dislocationSystem) ? sS1 == sS2
eq (fibre) ? sS1 == sS2
eq (orientationRegion) == Equal. A == B does element by element comparisons between A and B and returns an array with elements set to logical 1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
eq (quaternion) ? q1 == q2
eq (slipSystem) ? sS1 == sS2
eq (sphericalRegion) == Equal. A == B does element by element comparisons between A and B and returns an array with elements set to logical 1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
eq (symmetry) check S1 == S2
eq (vector3d) ? v1 == v2
equal check all elements of A to be equal
equispacedS2Grid defines an equispaced spherical grid
equispacedSO3Grid defines a equispaced grid in the orientation space
equivalentPerimeter (grain2d) returns the equivalent perimeter of grain-polygon
equivalentRadius (grain2d) returns the equivalent radius of grain-polygon
equivalentStrain (strainTensor) von Mises equivalent strain
equivalentStrain (velocityGradientTensor) equivalent strain of a strain tensor
equivalentStress (stressTensor) von Mises equivalent stress
Euler (quaternion) quaternion to euler angle
euler2quat converts euler angle to quaternion
EulerAngleConvention EulerAngleConvention is a function. [convention, labels] = EulerAngleConvention(varargin)
EulerCycles retrieve Euler cycles from an not oriented edge list
EulerTours find Euler tours in an adjacency matrix
eval (S2AxisFieldHarmonic) syntax f = eval(sF,v)
eval (S2AxisFieldTri) Syntax v = eval(sFV,nodes)
eval (S2FunHarmonic) evaluates the spherical harmonic on a given set of points Syntax f = eval(sF,v)
eval (S2FunTri) syntax f = eval(sF,v)
eval (S2VectorFieldHarmonic) syntax f = eval(sVF,v)
eval (S2VectorFieldTri) Syntax v = eval(sFV,nodes)
eval (BinghamComponent) evaluate an odf at orientation g
eval (FourierComponent) evaluate odf using NSOFT
eval (ODF) evaluate an odf at orientation g
eval (femComponent) evaluate an odf at orientation ori
eval (fibreComponent) evaluate an odf at orientation g
eval (uniformComponent) evaluate an odf at orientation g
eval (unimodalComponent) evaluate sum of unimodal components at orientation g
evalkappa eigenvalues of orientation tensor to bingham distribution parameters
even (S2FunHarmonic) even or antipodal part of a spherical function
exp (Miller) misorientation vector to misorientation
exp (orientation) exponential function
exp (vector3d) rotation vector to rotation
expm (tensor) matrix exponential of a tensor
expm (velocityGradientTensor) deformation gradient tensor from velocity gradient tensor
export (EBSD) export EBSD data to a ascii file
export (ODF) export an ODF to an ASCII file
export (PoleFigure) export pole figure in an ASCII file
export (quaternion) export quaternions to a ascii file
export (vector3d) export quaternions to a ascii file
export_generic (ODF) export an ODF to an ASCII file
export_h5 (EBSD) export EBSD data to a ascii file
export_mtex (ODF) export an ODF into the MTEX format
export_VPSC (ODF) export an ODF to the VPSC format
export_VPSC (orientation) export individual orientations to the VPSC format
expquat matrix exponential to convert skew symmetric matrices into quaternions
extend (EBSD) returns the boundings of spatial EBSD data
extensionDirection (velocityGradientTensor) extension direction
extract_argoption extract options from option list
extract_data extract data
extract_option extract options from option list
extract_SO3grid extract_SO3grid is a function. [S3G, options] = extract_SO3grid(obj, varargin)
extractSphericalRegion TODO: maybe consider option 'antipodal'

F

factor (symmetry) factorizes s1 and s2 into l, d, r such that s1 = l * d and s2 = d * r
FCE (velocityGradientTensor) finite strain ellipsoid
fclencurt Fast Clenshaw Curtis Quadrature
fdct fdct is a function. C = fdct(x)
femComponent (femComponent) defines an ODF by finite elements
femODF defines an ODF by finite elements
fibre (fibre) fibre is a class representing a fibre in orientation space. Examples are alpha, beta or gamma fibres. In general a fibre is defined by a crystal direction h of type <Miller_index.html Miller> and a specimen direction of type <vector3d_index.html vector3d>.
fibre2quat arbitrary quaternion q with q * h = r
fibreComponent (fibreComponent) defines an fibre symmetric component
fibreODF defines an fibre symmetric ODF
fibreVolume (ODF) ratio of orientations with a certain orientation
fibreVolume (orientation) ratio of orientations close to a certain fibre
fibreVonMisesFisherKernel extract parameter and halfwidth
file2cell reads a file rowise into a cellstr
fill (EBSD) extrapolate spatial EBSD data by nearest neighbour for tetragonal lattice
fill (EBSDhex) fill spatial EBSD data
fill (EBSDsquare) fill spatial EBSD data
fillByGrainId (EBSD) extrapolate spatial EBSD data by nearest neighbour for tetragonal lattice
find (S1Grid) find close points
find (S2Grid) return index of all points in a epsilon neighborhood of a vector
find (SO3Grid) return indece and distance of all nodes within a eps neighborhood
find (quaternion) return indece and distance of all nodes within a eps neighborhood
find (vector3d) return index of all points in a epsilon neighborhood of a vector
find_option find postions of the options in option_list
find_type parse arguments list for a specific type an returns the first occurance
findByLocation (EBSD) select EBSD data by spatial coordinates
findByLocation (grain2d) select a grain by spatial coordinates
findByOrientation (EBSD) select ebsd data by orientation
findByOrientation (grain2d) select grains by orientation
findOutlier (PoleFigure) find outliers in pole figures
findTetra (DelaunaySO3) find tetrahegon
finiteStrain (velocityGradientTensor) derive finte strain axes and magnitudes from deformation tensor after n-steps (in strain rate units of L) using the solution of Provost et al.2014 doi:10.1029/2001JB001734
fitArea (crystalShape) change habitus of crystal shape to fit given faceAreas
fitDislocationSystems (curvatureTensor) fit dislocation systems to a curvature tensor
fitEllipse (grain2d) fit ellipses to grains using the method described in Mulchrone& Choudhury,2004 (https://doi.org/10.1016/S0191-8141(03)00093-2)
flip (grainBoundary) flip a boundary from phase1/phase2 to phase2/phase1
fliplr (EBSD) flip spatial ebsd-data from left to right
flipud (EBSD) flip spatial ebsd-data from upside down
FMC_Coarsen Performs one coarsening step.
FMC_interpret Interpretation of FMC data and grain assignment
FMC_MTEX setup Wnext
Fourier (FourierComponent) get Fourier coefficients of and ODF
Fourier (tensor) compute the Fourier coefficients of the tensor
FourierComponent (FourierComponent) defines an ODF component by its Fourier coefficients
FourierODF (ODF) compute FourierODF from another ODF
FourierODF defines an ODF by its Fourier coefficients
free_nfft (MLSSolver) MLSSolver/free_nfft is a function. free_nfft(solver)
fundamentalRegion (symmetry) fundamental region in orientation space for a (pair) of symmetries
fundamentalRegion get the fundamental zone in orientation space for a symmetry
fundamentalRegionEuler (symmetry) get the fundamental region in Euler angles
fundamentalSector (symmetry) get the fundamental sector for a symmetry in the inverse pole figure

G

gammaSections gamma sections for ODF and orientation plotting
GaussWeierstrassKernel extract parameter and halfwidth
gcm gcm is a function. mfig = mtexFig
generic_wizard generic_wizard is a function. values = generic_wizard(varargin)
geodesic (quaternion) Calculats the rotation, which is described by the geodesic gamma(t)_{rot1,rot2} from rot1 to rot2 at the location t, for vectors of n rotations.
get_flag extract flag from option list
get_obj_fields get_obj_fields is a function. varargout = get_obj_fields(obj, varargin)
get_option extract option from option list
getCamera get xAxis and zAxis position from axis
getClass getClass is a function. out = getClass(list, className, default)
getColormaps getColormaps is a function. [cm, cmd] = getColormaps
getdata (S2Grid) return index of all points in a epsilon neighborhood of a vector
getDataCursorPos (mtexFigure) get the position and value of the data cursor
getFundamentalRegion (orientation) projects orientations to a fundamental region
getHoldState getHoldState is a function. ishold = getHoldState(varargin)
getmem return total system memory in kb
getMinAxes (rotation) rotation/getMinAxes is a function. [axes, angle] = getMinAxes(rot)
getMTEXpref getMTEXpref is a function. value = getMTEXpref(pref, default)
getSubDirs getSubDirs - gets recursively all subdirectories of a given directory.
getUnitScale Syntax factor = getUnitScale(unit)
gnonomicProjection gnonomic projection
grad (S2FunHarmonic) calculates the gradiet of a spherical harmonic
grad (S2FunTri) S2FunTri/grad is a function. g = grad(sF, v)
grad (FourierComponent) gradient at orientation g
grad (ODF) gradient of odf at orientation ori
grad (ODFComponent) gradient at orientation g
grad (fibreComponent) evaluate an odf at orientation g
grad (uniformComponent) gradient of the ODF at orientation g
grad (unimodalComponent) gradient at orientation g
grain2d (grain2d) two dimensional grains
grainBoundary (grainBoundary) grainBoundary list of grain boundaries in 2-D
GreenStrain (deformationGradientTensor) Syntax E = GreenStrain(F)
gridify (EBSD) extend EBSD data to an grid
GridLength (S1Grid) return number of points

H

h5group2struct read h5 group to struct
halfQuadraticFilter haldQuadraticFilter uses the techniques elaborated half-quadratic minmization on manifolds to smooth EBSD data. Properties: alpha: regularisation parameter in [x,y] direction weight: function handle specified by the regularising function \varphi, @(t,eps), where eps is its parameter eps: Parameter for the weight tol: Tolerance for the gradient descent threshold: threshold for subgrain boundaries Methods: smooth: Applies the HQ minimization on the quaternions of the given orientations
hasHole (grain2d) test if a grain has a hole or not
hist (grain2d) plot a grain size histogram
hist (ODF) calcualtes a histogram of ODF
HKLDirectionKey HKLDirectionKey is a class. dM = HKLDirectionKey(varargin)
homochoricPlot create a 3d Euler angle plot
horzcat (S2FunHarmonic) overloads horzcat
horzcat (tensor) overloads [T1,T2,T3..]
horzcat (dislocationSystem) overloads [v1,v2,v3..]
horzcat (fibre) overloads [v1,v2,v3..]
horzcat (orientationRegion) HORZCAT Horizontal concatenation. [A B] is the horizontal concatenation of matrices A and B. A and B must have the same number of rows. [A,B] is the same thing. Any number of matrices can be concatenated within one pair of brackets. Horizontal and vertical concatenation can be combined together as in [1 2;3 4].
horzcat (quaternion) implements [q1,q2,q3..]
horzcat (slipSystem) overloads [v1,v2,v3..]
horzcat (sphericalRegion) HORZCAT Horizontal concatenation. [A B] is the horizontal concatenation of matrices A and B. A and B must have the same number of rows. [A,B] is the same thing. Any number of matrices can be concatenated within one pair of brackets. Horizontal and vertical concatenation can be combined together as in [1 2;3 4].
horzcat (vector3d) overloads [v1,v2,v3..]
hotColorMap HOT Black-red-yellow-white color map HOT(M) returns an M-by-3 matrix containing a "hot" colormap. HOT, by itself, is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
hr2quat arbitrary quaternion q with q * h = r
hsl2hsv hsl2hsv is a function. [h, s, v] = hsl2hsv(hh, ss, ll)
hsvColorMap HSV Hue-saturation-value color map HSV(M) returns an M-by-3 matrix containing an HSV colormap. HSV, by itself, is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
HSVDirectionKey converts crystal or specimen directions to rgb values
hull (grain2d) replace grains by its convex hull

I

id2ind (EBSD) find ind such that ebsd.id(ind) == id
import_wizard import_wizard is a function. import_wizard(varargin)
ind2char calculates coordinate from one index i - index s - size of matrix
infernoColorMap infernoColorMap is a function. varargout = infernoColorMap(varargin)
infimalConvolutionFilter matrix-valued image with the TV-norm. \argmin_u{\|u-u_0\|_2^2 + \lambda \|\nabla u\|_{2,1} + \mu \|H u\|_{2,1}}, \lambda,\mu > 0 Written by Johannes Persch, Ronny Bergmann, 09.06.2015 function ma_val_im_reg_2nd_ord minimzes the second order model of a OUTPUT: u_hat: computed minimizer diff: differences of u and v between two successive iterations
init (MLSSolver) extract pole figures
init (zeroRangeMethod) zeroRangeMethod/init is a function. init(zrm, varargin)
initIter (MLSSolver) maybe no starting vector of coefficients has been specified
inpolygon (EBSD) checks which ebsd data are within given polygon
inpolygon (grain2d) checks which grains are within given polygon
inpolygon (grainBoundary) checks which gb data are within given polygon
interp (vector3d) spherical interpolation - including some smoothing
intersect (grainBoundary) length of a boundary segment
inv (complianceTensor) compliance to stiffness tensor
inv (stiffnessTensor) stiffness to compliance tensor
inv (tensor) inverse of a tensor
inv (quaternion) quaternion of the inverse roation
ipfColorKey defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here
ipfHKLKey defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here
ipfHSVKey defines an orientation mapping based on a certain inverse pole figure
ipfSections ipfSections is a class. oS = ipfSections(CS1, CS2, varargin)
ipfSpotKey Maps an individual color to each given crystal directions being parallel to a specimen direction (fibre) Properties: center - list of crystal directions @Miller color - n-by-3 list representing RGB values, one for each center psi - @kernel providing the width and brightness for colored fibre inversePoleFigureDirection - specimen direction @vector3d
ipfTSLKey orientation mapping as it is used by TSL and HKL software
isappr check double == double
isempty (S2FunHarmonic) overloads isempty
isempty (PoleFigure) overloads length
isempty (dislocationSystem) overloads isempty
isempty (fibre) overloads isempty
isempty (quaternion) overloads isempty
isempty (slipSystem) overloads isempty
isempty (vector3d) overloads isempty
isempty_cell isempty for cells
iseven check double mod 2 == 0
isFourier (ODF) check whether odf is given by Fourier coefficients
isImproper (rotation) rotation/isImproper is a function. out = isImproper(r)
isLower (sphericalRegion) sphericalRegion/isLower is a function. out = isLower(sR)
isMisorientation (orientation) check whether o is a misorientation
isnan (quaternion) check for nan values
isnull ckeck double == 0
isOctave isOctave is a function. result = isOctave
isOutlier (PoleFigure) find outliers in pole figures
isPerp (vector3d) check whether v1 and v2 are orthogonal
ispos check double > 0
isRGB isRGB is a function. out = isRGB(fig)
isTwinning (grainBoundary) Syntax
isUpper (sphericalRegion) sphericalRegion/isUpper is a function. out = isUpper(sR)

K

K_symmetrised (kernel) evaluate kernel modulo symmetries
KAM (EBSD) intragranular average misorientation angle per orientation
kde Reliable and extremely fast kernel density estimator for one-dimensional data; Gaussian kernel is assumed and the bandwidth is chosen automatically; Unlike many other implementations, this one is immune to problems caused by multimodal densities with widely separated modes (see example). The estimation does not deteriorate for multimodal densities, because we never assume a parametric model for the data. INPUTS: data - a vector of data from which the density estimate is constructed; n - the number of mesh points used in the uniform discretization of the interval [MIN, MAX]; n has to be a power of two; if n is not a power of two, then n is rounded up to the next power of two, i.e., n is set to n=2^ceil(log2(n)); the default value of n is n=2^12; MIN, MAX - defines the interval [MIN,MAX] on which the density estimate is constructed; the default values of MIN and MAX are: MIN=min(data)-Range/10 and MAX=max(data)+Range/10, where Range=max(data)-min(data); OUTPUTS: bandwidth - the optimal bandwidth (Gaussian kernel assumed); density - column vector of length 'n' with the values of the density estimate at the grid points; xmesh - the grid over which the density estimate is computed; - If no output is requested, then the code automatically plots a graph of the density estimate. cdf - column vector of length 'n' with the values of the cdf Reference: Kernel density estimation via diffusion Z. I. Botev, J. F. Grotowski, and D. P. Kroese (2010) Annals of Statistics, Volume 38, Number 5, pages 2916-2957.
kernel (kernel) kernel is a class. psi = kernel(A)
KLCV (orientation) Kullback Leibler cross validation for optimal kernel estimation
kmeans k-means++: The Advantages of Careful Seeding", by David Arthur and Sergei Vassilvitskii, SODA 2007.
KuwaharaFilter KuwaharaFilter is a class. F = KuwaharaFilter(varargin)

L

l1TVFilter (l1TVFilter) smoothes quaternions by projecting them into tangential space and performing there smoothing spline approximation
LaboTeXColorMap return LaboTeX colormap
LaplaceKernel extract bandwidth
Laue (symmetry) return the corresponding Laue group
LaueName (symmetry) get Laue name
ldivide (orientation) o .\ v
le (S2FunHarmonic) overloads sF1 <= sF2
le (S2FunTri) overloads sF1 <= sF2
legendre0 Legendrepolynome bis zur Odnung N und gibt sie als Matrix zur�ck erste Dimension -> Ordnung zweite Dimension -> x
length (S2FunHarmonic) overloads length
length (tensor) returns the number of tensors
length (crystalShape) overloads length
length (dislocationSystem) overloads length
length (fibre) overloads length
length (quaternion) overloads length
length (slipSystem) overloads length
length (symmetry) number of symmetry elements
length (vector3d) overloads length
line (rotation) draw rotations connected by lines
line (vector3d) Syntax
linearCompressibility (complianceTensor) computes the linear compressibility of an elasticity tensor
linearCompressibility (stiffnessTensor) computes the linear compressibility of an elasticity tensor
load_generic load file using import data and txt2mat
loadallspectra load all spectra files of a Dubna meassurement cycle
loadCIF import crystal symmetry from cif file
loadData import PoleFigure, EBSD, and ODF data
loadEBSD import ebsd data
loadEBSD_ACOM read ACOM files (converted from *.res ASTAR)
loadEBSD_ang read TSL *.ang file
loadEBSD_brukertxt read Bruker *.txt file
loadEBSD_crc interface for Oxford Chanel 5 crc and cpr EBSD data files
loadEBSD_csv loadEBSD_csv is a function. ebsd = loadEBSD_csv(fname, varargin)
loadEBSD_ctf read HKL *.ctf file
loadEBSD_dream3d loadEBSD_dream3d is a function. ebsd = loadEBSD_dream3d(fname, varargin)
loadEBSD_ebsdimage Check extension
loadEBSD_generic load ebsd data from generic text files
loadEBSD_h5 loadEBSD_h5 is a function. [ebsd, header] = loadEBSD_h5(fname, varargin)
loadEBSD_hdf5 Read rotations
loadEBSD_osc loadEBSD_osc is a function. ebsd = loadEBSD_osc(fname, varargin)
loadEBSD_Oxfordcsv loadEBSD_Oxfordcsv is a function. ebsd = loadEBSD_Oxfordcsv(fname, varargin)
loadEBSD_sor load LaboTex *.sor file
loadGrainSet_hdf5 Read EBSD
loadHelper helps to load data-matrix with ColumnNames restricts also data according to conventions (e.g. >4pi)
loadODF import ebsd data
loadODF_generic load pole figure data from (alpha,beta,gamma) files
loadODF_VPSC loadODF_VPSC is a function. [odf, options] = loadODF_VPSC(fname, varargin)
loadOrientation import orientation data from data files
loadOrientation_DRex loadOrientation_DRex is a function. ori = loadOrientation_DRex(fname, varargin)
loadOrientation_generic load Orientation data from generic text files
loadOrientation_generic2 load Orientation data from generic text files
loadPHL loadPHL is a function. cs = loadPHL(fname)
loadPoleFigure import pole figure data
loadPoleFigure_aachen import data fom aachen ptx file
loadPoleFigure_aachen_exp import data fom aachen_exp file
loadPoleFigure_ana import data fom ana file
loadPoleFigure_beartex import data fom BeaTex file
loadPoleFigure_dubna load dubna cnv file
loadPoleFigure_geesthacht load ptx file
loadPoleFigure_generic load pole figure data from (theta,rho,intensity) files
loadPoleFigure_gpol loadPoleFigure_gpol is a function. pf = loadPoleFigure_gpol(fname, varargin)
loadPoleFigure_ibm import data fom ibm file
loadPoleFigure_juelich load juelich data format
loadPoleFigure_labotex load labotex pole figure data
loadPoleFigure_nja loadPoleFigure_nja is a function. pf = loadPoleFigure_nja(fname, varargin)
loadPoleFigure_out1 import polfigure-data form Graz
loadPoleFigure_philips load philips *.txt file
loadPoleFigure_plf load plf file
loadPoleFigure_popla import data fom Popla file
loadPoleFigure_pwd load D5000 powder data file
loadPoleFigure_rigaku import data fom Rigaku SamrtLab txt file
loadPoleFigure_rigaku_dat load *.dat files of rigaku devices
loadPoleFigure_rigaku_txt import data fom ana file
loadPoleFigure_rigaku_txt2 import data fom ana file
loadPoleFigure_rw1 import data from Philip's Xpert binary file format rw1
loadPoleFigure_scintag import data fom scintag ascii file
loadPoleFigure_siemens load D5000 data file
loadPoleFigure_slc load *.txt file with regular grid
loadPoleFigure_uxd import data fom ana file
loadPoleFigure_xrd import data fom aachen xrd file
loadPoleFigure_xrdml load xrdMeasurement (xrdml) file
loadspectra load a single spectrum o a Dubna meassurement
loadTensor import Tensor data
loadTensor_generic load a Tensor from a file
loadTensor_mpod import Tensor data
loadTensor_P load a Tensor from a file
loadVector3d import ebsd data
loadVector3d_generic load pole figure data from (alpha,beta,gamma) files
localOrientationGrid define a equispaced grid localized to a center orientation
log (S2FunHarmonic) log of a function
log (orientation) the misorientation vector between two orientations
log (quaternion) the logarithmic map that translates a rotation into a rotation vector
logm (tensor) matrix logarithm of a tensor
logm (orientation) the logarithmic map that translates a rotation into a spin tensor
logm (quaternion) the logarithmic map that translates a rotation into a spin tensor
LSCV (orientation) least squares cross valiadation

M

magmaColorMap magmaColorMap is a function. varargout = magmaColorMap(varargin)
makeS2FunDoc makeS2FunDoc is a function.
map (orientation) define orientations by pairs of vectors
map (rotation) define rotations by pairs of vectors
mapPlot class to handle spatial plots of EBSD data and grains
mat2quat converts direction cosine matrix to quaternion
matrix (tensor) return tensor as a matrix
matrix (quaternion) quaternion to direction cosine matrix conversion converts direction cosine matrix to quaternion
matrix (rotation) quaternion to direction cosine matrix conversion converts direction cosine matrix to quaternion
max (S2Fun) global, local and pointwise maxima of spherical functions
max (S2FunTri) MAX Maximum elements of an array. M = MAX(X) is the largest element in the vector X. If X is a matrix, M is a row vector containing the maximum element from each column. For N-D arrays, MAX(X) operates along the first non-singleton dimension.
max (ODF) heuristic to find local modal orientations
max (PoleFigure) maximum of two pole figures or the maximum of a single polefigure
max (tensor) MAX Maximum elements of an array. M = MAX(X) is the largest element in the vector X. If X is a matrix, M is a row vector containing the maximum element from each column. For N-D arrays, MAX(X) operates along the first non-singleton dimension.
max (S1Grid) return maximum value
maxAngle (orientationRegion) get the maximum angle of the fundamental region
maxAngle (symmetry) get the maximum angle of the fundamental region
mean (S2Fun) calculates the mean value for an univariate S2Fun or calculates the mean along a specified dimension fo a multimodal S2Fun
mean (S2FunHarmonic) calculates the mean value for an univariate S2Fun or calculates the mean along a specified dimension fo a multimodal S2Fun
mean (S2FunTri) mean value of a spherical function
mean (S2VectorFieldHarmonic) syntax f = mean(sVF)
mean (ODF) expected value of an ODF
mean (PoleFigure) mean of pole figure intensities
mean (tensor) mean of a list of tensors
mean (orientation) mean of a list of orientations, principle axes and moments of inertia
mean (quaternion) mean of a list of quaternions, principle axes and moments of inertia
mean (vector3d) computes the mean vector
mean_CS (quaternion) fast mean of
meanFilter implements a convolution filter for quaternion
meanStress (stressTensor) mean stress
medianFilter medianFilter is a class. F = medianFilter(varargin)
merge (grain2d) merge grains along special grain boundaries
mhyper multivariat hypergeometric function 1F1(1/2,p/2, kappa)
Miller (Miller) define a crystal direction by Miller indice
min (S2FunHarmonic) global, local and pointwise minima of spherical functions
min (S2FunTri) MIN Minimum elements of an array. M = MIN(X) is the smallest element in the vector X. If X is a matrix, M is a row vector containing the minimum element from each column. For N-D arrays, MIN(X) operates along the first non-singleton dimension.
min (PoleFigure) minimum of two pole figures or the minimum of a single polefigure
min (tensor) MIN Minimum elements of an array. M = MIN(X) is the smallest element in the vector X. If X is a matrix, M is a row vector containing the minimum element from each column. For N-D arrays, MIN(X) operates along the first non-singleton dimension.
min (S1Grid) return maximum value
minAngle (orientationRegion) get the minimum angle of the boundary of the fundamental region
minus (S2Fun) overload minus
minus (S2VectorFieldHarmonic) Syntax sVF = sVF1-sVF2 sVF = a-sVF1 sVF = sVF1-a
minus (S2VectorFieldTri) Syntax sVF = sVF1 - sVF2 sVF = sVF - v
minus (ODF) superposeing two ODFs
minus (PoleFigure) implements pf1 - pf2
minus (tensor) T1 - T2;
minus (S1Grid) - Minus. X - Y subtracts matrix Y from X. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
minus (quaternion) overloads minus
minus (vector3d) overload minus
mix2 mix2 sample ODF
mldivide (orientation) o \ v
mldivide (quaternion) \ Backslash or left matrix divide. A\B is the matrix division of A into B, which is roughly the same as INV(A)*B , except it is computed in a different way. If A is an N-by-N matrix and B is a column vector with N components, or a matrix with several such columns, then X = A\B is the solution to the equation A*X = B. A warning message is printed if A is badly scaled or nearly singular. A\EYE(SIZE(A)) produces the inverse of A.
mldivide (rotation) o \ v
MLSSolver (MLSSolver) modified least squares solver
mpower (quaternion) q^n
mpower (vector3d) n-th dyadic product
mPrime (slipSystem) m' parameter from Luster and Morris in 1995
mrdivide (ODF) scaling of the ODF
mrdivide (PoleFigure) implements pf1 ./ b and a ./ pf2
mrdivide (tensor) implements T / S
mrdivide (quaternion) scalar division
mtex_assert mtex_assert is a function. mtex_assert(cond, varargin)
mtex_path return install dir of mtex
mtexCifPath returns the default path to crystallographic information files (CIF)
mtexColorbar overide buildin Matlab colorbar function
mtexColorMap define an MTEX colormap
mtexdata load of data provided with mtex and often used in documentation
mtexDataPath returns the default path to mtex sample data
mtexdegchar returns the degree character
mtexEBSDPath returns the default path to EBSD data files
mtexFigure (mtexFigure) class to handles figures with equaly sized axes
MTEXmenu show up MTEX menu
mtexODFPath returns the default path to ODF-files
mtexPoleFigurePath returns the default path to PoleFigure data files
mtexTensorPath returns the default path to tensor-files
mtimes (S2FunHarmonic) Syntax sF = sF1 * sF2 sF = a * sF1 sF = sF1 * a
mtimes (S2FunTri) * Matrix multiply. X*Y is the matrix product of X and Y. Any scalar (a 1-by-1 matrix) may multiply anything. Otherwise, the number of columns of X must equal the number of rows of Y.
mtimes (S2VectorFieldHarmonic) Syntax sF = sF1*sF2 sF = a*sF1 sF = sF1*a
mtimes (EBSD) rotating the ebsd data by a certain rotation
mtimes (ODF) scaling of the ODF
mtimes (PoleFigure) scaling of PoleFigures, implements pf1 * b and a * pf2
mtimes (complianceTensor) tensor product S * sigma
mtimes (stiffnessTensor) tensor product C * eps
mtimes (tensor) implements T1 * T2
mtimes (SO3Grid) outer quaternion multiplication
mtimes (crystalShape) * Matrix multiply. X*Y is the matrix product of X and Y. Any scalar (a 1-by-1 matrix) may multiply anything. Otherwise, the number of columns of X must equal the number of rows of Y.
mtimes (orientation) orientation times Miller and orientation times orientation
mtimes (quaternion) quaternionen multiplication q1 * q2
mtimes (rotation) r = a * b
mtimes (vector3d) scalar multiplication
Mtv (MLSSolver) forward operator
multiplicityPerpZ (symmetry) maximum angle rho
multiplicityZ (symmetry) maximum angle rho
Mv (MLSSolver) forward operator

N

n (S2VectorField) Gives the normal vector of the tangential plane in v
n2str num2str with exact zero
nadjacent Returns the adjacency matrix of the n-neighbours.
nanmax FORMAT: [Y,IDX] = NANMAX(A,DIM,[B])
nanmean FORMAT: Y = NANMEAN(X,DIM)
nanmedian FORMAT: Y = NANMEDIAN(X,DIM)
nanmin FORMAT: [Y,IDX] = NANMIN(A,DIM,[B])
nanplus nanplus is a function. [a, count] = nanplus(a, b, count, alpha)
nansum FORMAT: Y = NANSUM(X,DIM)
ndims (tensor) overloads size
ndims (quaternion) overloads ndims
ne (grain2d) ~= Not equal. A ~= B does element by element comparisons between A and B and returns an array with elements set to logical 1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
ne (tensor) checks whether two tensors are not equal
ne (dislocationSystem) ? sS1 ~= sS2
ne (fibre) ? sS1 ~= sS2
ne (orientationRegion) ~= Not equal. A ~= B does element by element comparisons between A and B and returns an array with elements set to logical 1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
ne (quaternion) q1 ~= q2 ?
ne (slipSystem) ? sS1 ~= sS2
ne (sphericalRegion) ~= Not equal. A ~= B does element by element comparisons between A and B and returns an array with elements set to logical 1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
ne (vector3d) ? v1 == v2
neighbors (grain2d) returns the number of neighboring grains
neuralgas (ODF) attempt to distribute measure-sites equally according to invers polefigure density (experimental)
newer_version check matlab version
newMapPlot newMapPlot is a function. [mP, isNew] = newMapPlot(varargin)
newMtexFigure set uo a new plotting figure
newODFSectionPlot generate a new ODF section plot
newOrientationPlot prepare a 3d orientation plot
newSphericalPlot split plot in upper and lower hemisphere
nextAxis (mtexFigure) go to next plot
nextAxis nextAxis is a function. ax = nextAxis(varargin)
nextstyle NEXTSTYLE Get next plot linespec [L,C,M] = NEXTSTYLE(AX) gets the next line style, color and marker for plotting from the ColorOrder and LineStyleOrder of axes AX.
nfold (symmetry) maximal n-fold of symmetry axes
niceEuler (orientation) orientation to euler angle
noisepf (PoleFigure) simulate diffraction counts
norm (S2FunHarmonic) the L2 norm of a spherical function
norm (S2VectorFieldHarmonic) pointwise norm of the vectorfield
norm (S2VectorFieldTri) pointwise norm of the vectorfield
norm (FourierComponent) caclulate texture index of ODF
norm (ODF) caclulate texture index of ODF
norm (tensor) tensor frobenius norm
norm (quaternion) quaternion norm sqrt(a^2+b^2+c^2+c^2)
norm (vector3d) vector norm
normalDirection (velocityGradientTensor) normal direction
normalize (S2VectorField) Gives the normal vector of the tangential plane in v
normalize (PoleFigure) normalization of a meassured pole figure with respect to an ODF
normalize (quaternion) normalize quaternion
normalize (vector3d) normalize a vector
numel (tensor) returns the number of tensors
NWSE NWSE is a function. out = NWSE(in)

O

octahedralStrain (strainTensor) the octahedral strains
ODF (ODF) ODF is a class. odf = ODF(components, weights)
ODFSections (ODFSections) ODFSECTIONS Summary of this class goes here Detailed explanation goes here
omegaSections omegaSections is a class. oS = omegaSections(CS1, CS2, h1, h2, r_ref, varargin)
opticalAxis (refractiveIndexTensor) optical axis or axes for a refractive index tensor
option2str transforms option list to comma separated list
optiondraw apply options to handle
optionplot plot y against x using the options in varargin
orientation (fibre) generate a list of orientation out of a fibre
orientation (orientation) orientation - class representing orientations
orientationColorKey abstract class for defining (mis)orientation color keys
orientationPlot ODFSECTIONS
orientationRegion (orientationRegion) sphericalRegion implements a region in orientation space The region is bounded by planes normal to quaternions N i.e., all quaternions q inside a region satisfy the condition dot(q, N) <= 0 or dot(-q, N) <= 0 for all N
orth (vector3d) an arbitrary orthogonal vector
orthographicProjection orthographic projection
orthProj (vector3d) vector3d/orthProj is a function. v = orthProj(v, N)

P

parents (orientation) variants of an orientation relationship
paris (grain2d) Percentile Average Relative Indented Surface
parseXML PARSEXML Convert XML file to a MATLAB structure.
parulaColorMap PARULA Blue-green-orange-yellow color map PARULA(M) returns an M-by-3 matrix containing a colormap. The colors begin with dark purplish-blue and blue, range through green and orange, and end with bright yellow. PARULA is named after a bird, the tropical parula, which has these colors.
PatalaColorKey (PatalaColorKey) converts misorientations to rgb values as described in
pauseline pauseline is a function.
pcolor (S2Fun) spherical contour plot
pcolor (vector3d) spherical contour plot
pdfMatrix (femComponent) called by pdf
pdfMatrix (DelaunaySO3) called by pdf
perimeter (grain2d) calculates the perimeter of a grain without or without inclusions
perimeter (grainBoundary) boundary length per grain including holes
permute (quaternion) overloads permute
permute (rotation) overloads permute
perp (vector3d) conmpute an vector best orthogonal to a list of directions
perturbe (quaternion) pertube data randomly by epsilon
pf2odfSolver pf2odfSolver is a class. obj = pf2odfSolver(varargin)
pfSections pfSections is a class. oS = pfSections(CS1, CS2, varargin)
phaseList handles a list of phases
phi1Sections phi1 sections for ODF and orientation plotting
phi2Sections phi2 sections for ODF and orientation plotting
PhiSections PhiSections is a class. oS = PhiSections(varargin)
plainProjection sphericalProjection
planeIntersect (vector3d) pointwise determinant or triple product of three vector3d
plasmaColorMap plasmaColorMap is a function. varargout = plasmaColorMap(varargin)
plot (S2AxisField) plot spherical axis field
plot (S2Fun) plot spherical Function
plot (S2FunHarmonicSym) Syntax
plot (S2FunTri) PLOT Linear plot. PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix, then the vector is plotted versus the rows or columns of the matrix, whichever line up. If X is a scalar and Y is a vector, disconnected line objects are created and plotted as discrete points vertically at X.
plot (S2VectorField) plot spherical vector field
plot (EBSD) spatial EBSD plot
plot (grain2d) colorize grains
plot (grainBoundary) plot grain boundaries
plot (triplePointList) plot grain boundaries
plot (ODF) plots odf or append to a previous plot using 'add2all'
plot (PoleFigure) plot pole figure
plot (zeroRangeMethod) plot zero regions in pole figures
plot (tensor) plot a tensor T
plot (ODFSections) plot data into ODF sections
plot (S1Grid) plot grid
plot (S2Triangulation) find all edges given by vertex i and vertex j
plot (crystalShape) colorize grains
plot (fibre) plot a fibre
plot (orientation) annotate a orientation to an existing plot
plot (orientationRegion) plots a spherical region
plot (quaternion) PLOT Linear plot. PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix, then the vector is plotted versus the rows or columns of the matrix, whichever line up. If X is a scalar and Y is a vector, disconnected line objects are created and plotted as discrete points vertically at X.
plot (sphericalRegion) plots a spherical region
plot (symmetry) visualize symmetry elements according to international table
plot (vector3d) plot vectors as two dimensional projections on the sphere
plot (kernel) plot the kernel function
plot3d (S2Fun) plot spherical Function
plot3d (ODF) plots odf
plot3d (vector3d) plot spherical data
plot_spectra plot spectra of the Dubna goniometer
plota2east set the default plot direction of the x-axis
plota2north set the default plot direction of the x-axis
plota2south set the default plot direction of the x-axis
plota2west set the default plot direction of the x-axis
plotAngleDistribution plot axis distribution
plotAxisDistribution plot axis distribution
plotb2east set the default plot direction of the x-axis
plotb2north set the default plot direction of the x-axis
plotb2south set the default plot direction of the x-axis
plotb2west set the default plot direction of the x-axis
plotCustom (vector3d) Syntax plotcustom(v,@(x,y) drawCommand(x,y)) %
plotDiff (ODF) difference plot between two odfs or an odf and a pole figure
plotDiff (PoleFigure) difference plot between two pole figures or an odf and a pole figure
plotEllipse plot multiple ellipses
plotEmptySphere plots white sphere
plotFibre (ODF) plot odf along a fibre
plotFourier (ODF) plots Fourier coefficients of the odf
plotFourier (kernel) plot the Chybeyshev coefficients of the kernel function
plotHKL (crystalSymmetry) plot symmetry
plotIPDF (ODF) plot inverse pole figures
plotIPDF (fibre) plot orientations into inverse pole figures
plotIPDF (orientation) plot orientations into inverse pole figures
plotPDF (ODF) plot pole figures
plotPDF (fibre) plot a fibre into pole figures
plotPDF (orientation) plot orientations into pole figures
plotPDF (kernel) plot Radon transformed kernel
plotS2Grid create a regular S2Grid for plotting
plotSection (S2Fun) Syntax plotSection(sF,vector3d.Z) plotSection(sF,vector3d.Z,pi/3)
plotSection (S2VectorField) Syntax plotSection(sVF,vector3d.Z) plotSection(sVF,vector3d.Z,pi/3)
plotSection (ODF) plot ODF sections
plotSection (orientation) plot orientations to ODF sections
plotSO3Grid give a regular grid in orientation space
plotSpektra (S2FunHarmonic) plots Fourier coefficients of a spherical function
plotUnitCells (EBSD) EBSD/plotUnitCells is a function. h = plotUnitCells(ebsd, d, varargin)
plotUnitCells (EBSDsquare) EBSDsquare/plotUnitCells is a function. h = plotUnitCells(ebsd, d, varargin)
plotUVW (crystalSymmetry) plot symmetry
plotx2east set the default plot direction of the x-axis
plotx2north set the default plot direction of the x-axis
plotx2south set the default plot direction of the x-axis
plotx2west set the default plot direction of the x-axis
plotzIntoPlane set the default plot direction of the z-axis
plotzOutOfPlane set the default plot direction of the z-axis
plus (S2FunHarmonic) impements sF1 + sF2
plus (S2FunHarmonicSym) Syntax sF = sF1.^a
plus (S2FunTri) + Plus. X + Y adds matrices X and Y. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
plus (S2VectorFieldHarmonic) Syntax sVF = sVF1+sVF2 sVF = a+sVF1 sVF = sVF1+a
plus (S2VectorFieldTri) Syntax sVF = sVF1 + sVF2 sVF = sVF + v
plus (ODF) superposeing two ODFs
plus (PoleFigure) implements pf1 + pf2
plus (tensor) add two tensors
plus (S1Grid) + Plus. X + Y adds matrices X and Y. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
plus (crystalShape) crystal shape should be first argument
plus (quaternion) pointwise addition
plus (vector3d) poitwise addition
PoissonRatio (complianceTensor) computes the Poisson ratio of an elasticity tensor
PoissonRatio (stiffnessTensor) computes the Poisson ratio of an elasticity tensor
polar (tensor) compute the polar decomposition of rank 2 tensors
polar (velocityGradientTensor) polar decomposition of velocity gradient tensor
polar (S2Grid) polar coordinates of S2Grid
polar (vector3d) cartesian to spherical coordinates Input v - @vector3d Output theta - polar angle rho - azimuthal angle r - radius
polarCoordinates (sphericalRegion) compute polar coordinates of with respect to a spherical region
PoleFigure (PoleFigure) constructor
polyArea (vector3d) area of a flat polygon given by vertices v1, v2, ..., v_n
power (S2FunHarmonic) Syntax sF = sF1.^a
power (S2FunHarmonicSym) Syntax sF = sF1.^a
power (S2FunTri) .^ Array power. Z = X.^Y denotes element-by-element powers. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
power (orientation) ori.^n
power (quaternion) q.^n
power (rotation) r.^n
principalComponents (grain2d) returns the principalcomponents of grain polygon, without Holes
proceed_spectra procede Dubna spectra
prod (quaternion) overloads q1 * q2 * q3
progress display progress
project (ODFSections) project orientation to ODF sections used by plotSection
project2EulerFR (orientation) projects orientation to a fundamental region
project2EulerFR (quaternion) projects quaternions to a fundamental region
project2FundamentalRegion (Miller) projects vectors to the fundamental sector of the inverse pole figure
project2FundamentalRegion (orientation) projects orientation to a fundamental region
project2FundamentalRegion (quaternion) projects quaternions to a fundamental region
project2FundamentalRegion (rotation) projects rotation to a fundamental region
project2FundamentalRegion (vector3d) projects vectors to the fundamental sector of the inverse pole figure
properGroup (symmetry) return the corresponding Laue group
properSubGroup (symmetry) return the corresponding Laue group

Q

qmatrix (quaternion) returns the quaternion multiplication matrix
qq (quaternion) returns w * q' * q
qqplot (orientation) quantile-quantile of misorientation angle against random angular misorientation
quadrature (S2AxisFieldHarmonic) Syntax sF = S2AxisField.quadrature(v, value) sF = S2AxisField.quadrature(f) sF = S2AxisField.quadrature(f, 'bandwidth', M)
quadrature (S2FunHarmonic) Syntax sF = S2FunHarmonic.quadrature(nodes,values,'weights',w) sF = S2FunHarmonic.quadrature(f) sF = S2FunHarmonic.quadrature(f, 'bandwidth', bandwidth)
quadrature (S2FunHarmonicSym) Syntax sF = S2FunHarmonicSym.quadrature(nodes,values,'weights',w,CS) sF = S2FunHarmonicSym.quadrature(f,CS) sF = S2FunHarmonicSym.quadrature(f, 'bandwidth', bandwidth,CS)
quadrature (S2VectorFieldHarmonic) Syntax sVF = S2VectorField.quadrature(v, value) sVF = S2VectorField.quadrature(f) sVF = S2VectorField.quadrature(f, 'bandwidth', bw)
quadratureS2Grid Syntax [S2G, W, M2] = quadratureS2Grid(M) quadrature grid of type chebyshev [S2G, W, M2] = quadratureS2Grid(M, 'gauss') quadrature grid of type gauss
quadric (tensor) quadric
quantile (ODF) quantile orientations of an ODF
quantile n percent quantile of x
quaternion (quaternion) quaternion is a class. q = quaternion(varargin)
quaternionPlot create a 3d Euler angle plot
quiver (S2AxisField) quiver spherical axis field
quiver (S2VectorField) quiver spherical vector field
quiver (EBSD) plot directions at ebsd centers
quiver (grain2d) plot directions at grain centers
quiver (grainBoundary) plot directions at grain boundaries
quiver (vector3d) Syntax quiver(v,d)
quiver3 (S2AxisField) 3-dimensional quiver spherical axis field
quiver3 (S2Fun) a quiver plot on top of a surface plot
quiver3 (S2VectorField) 3-dimensional quiver spherical vector field
quiver3 (vector3d) Syntax quiver(v,d)
quiverSection (S2Fun) Syntax quiverSection(sF,v,vector3d.Z) quiverSection(sF,sVF,vector3d.Z) quiverSection(sF,v,vector3d.Z,pi/3)
quiverSection (S2VectorField) plot a vector field along another vectorfield
qwarning warning with option to stop

R

radon (S2FunHarmonic) Radon transform of a spherical function
randp randp(lambda) returns Poisson distributed Vector with mean lambda
range RANGE Sample range. Y = RANGE(X) returns the range of the values in X. For a vector input, Y is the difference between the maximum and minimum values. For a matrix input, Y is a vector containing the range for each column. For N-D arrays, RANGE operates along the first non-singleton dimension.
rank (vector3d) rank = 1
rdivide (S2FunHarmonic) Syntax sF = sF1/sF2 sF = sF1/a sF = a/sF1
rdivide (S2FunHarmonicSym) Syntax sF = sF1/sF2 sF = sF1/a sF = a/sF1
rdivide (S2FunTri) ./ Right array divide. A./B denotes element-by-element division. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
rdivide (S2VectorFieldHarmonic) Syntax
rdivide (S2VectorFieldTri) Syntax sVF = sVF ./ sF sVF = sVF ./ a
rdivide (ODF) scaling of the ODF
rdivide (PoleFigure) implements pf1 ./ b and a ./ pf2
rdivide (tensor) ./ Right array divide. A./B denotes element-by-element division. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
rdivide (quaternion) scalar division
rdivide (vector3d) scalar division v ./ s
real (tensor) REAL Complex real part. REAL(X) is the real part of X. See I or J to enter complex numbers.
real (quaternion) real-part of of quaternion
red2blueColorMap creates a colormap, ranging from dark blue via white to dark red.
reduce (EBSD) reduce ebsd data by a factor
reduce (EBSDhex) reduce ebsd data by taking only second pixel
refine (DelaunaySO3) step 1: compute center of any two orientation connected by an edge
refine (S1Grid) refine S1Grid
refine (S2Grid) refine S2Grid
refine (vector3d) refine vectors
reflection defines a reflection at plane with normal n
refractiveIndex (refractiveIndexTensor) refractive index with respect to a propagation direction
refractiveIndexTensor (refractiveIndexTensor) refractiveIndexTensor is a class. rI = refractiveIndexTensor(varargin)
region (Miller) return spherical region associated to a set of crystal directions
region (vector3d) vector3d/region is a function. sR = region(v, varargin)
regularisation (S2FunHarmonic) computes a regularisation Syntax sF = S2FunHarmonic.regularisation(S2Grid,f,lambda) sF = S2FunHarmonic.regularisation(S2Grid,f,lambda,'bandwidth', bandwidth,'node_weights',W,'fourier_weights',What)
regularS2Grid Syntax regularS2Grid('points',[72 19]) regularS2Grid('resolution',[5*degree 2.5*degree]) regularS2Grid('theta',theta,'rho',rho)
regularSO3Grid regular grid in Euler orientation space
reorder (grainBoundary) nicely reorder grain boundaries
repcell equivalent to repmat for cells
repmat (crystalShape) implements repmat for crystalShape
repmat (quaternion) overloads repmat
repmat (rotation) overloads repmat
repmat (vector3d) overloads repmat
reshape (S2FunHarmonic) overloads reshape
reshape (tensor) reshape for tensors
reshape (crystalShape) RESHAPE Reshape array. RESHAPE(X,M,N) or RESHAPE(X,[M,N]) returns the M-by-N matrix whose elements are taken columnwise from X. An error results if X does not have M*N elements.
reshape (quaternion) overloads reshape
reshape (rotation) overloads reshape
reshape (vector3d) overloads reshape
residualBurgersVector (slipSystem) compute the Schmid factor
restrict2Lower (sphericalRegion) sphericalRegion/restrict2Lower is a function. sR = restrict2Lower(sR)
restrict2Upper (sphericalRegion) sphericalRegion/restrict2Upper is a function. sR = restrict2Upper(sR)
restrictEBSD_ang read file header
rho (S2VectorField) Gives the vector in the tangential plane in v in the direction rho
rhoInside rhoInside is a function. ind = rhoInside(rho, minRho, maxRho)
rhoRange (sphericalRegion) compute range of the polar angle of a spherical region
RK_symmetrised (kernel) sum Radon trasformed kernel
rmallappdata removes all figure appdata
Rodrigues (quaternion) quaternion to rodrigues representation
rodrigues2quat rodrigues2quat is a function. q = rodrigues2quat(R, varargin)
RodriguesPlot create a 3d Euler angle plot
rotate (BinghamS2) rotate a BinghamS2 function
rotate (S2FunHarmonic) rotate a function by a rotation
rotate (S2FunTri) ROTATE Rotate objects about specified origin and direction. ROTATE(H,[THETA PHI],ALPHA) rotates the objects with handles H through angle ALPHA about an axis described by the 2-element direction vector [THETA PHI] (spherical coordinates). All the angles are in degrees. The handles in H must be children of the same axes.
rotate (S2VectorFieldHarmonic) rotate a function by a rotation
rotate (EBSD) rotate EBSD orientations or spatial data around point of origin
rotate (BinghamComponent) rotate component
rotate (FourierComponent) called by ODF/rotate
rotate (ODF) rotate ODF
rotate (femComponent) called by ODF/rotate
rotate (fibreComponent) called by ODF/rotate
rotate (uniformComponent) called by ODF/rotate
rotate (unimodalComponent) called by ODF/rotate
rotate (PoleFigure) rotates pole figures by a certain rotation
rotate (tensor) rotate a tensor by a list of rotations
rotate (Miller) rotate crystal directions
rotate (S2Triangulation) ROTATE Rotate objects about specified origin and direction. ROTATE(H,[THETA PHI],ALPHA) rotates the objects with handles H through angle ALPHA about an axis described by the 2-element direction vector [THETA PHI] (spherical coordinates). All the angles are in degrees. The handles in H must be children of the same axes.
rotate (crystalShape) rotate a crystal shape by an rotation or orientation
rotate (dislocationSystem) rotate dislocation systems system
rotate (orientationRegion) rotate of a orientation region
rotate (slipSystem) rotate slip system
rotate (sphericalRegion) rotate of a spherical region
rotate (vector3d) rotate vector3d by rotation or orientation
rotate_outer (S2FunHandle) rotate a function by a rotation
rotate_outer (S2FunHarmonic) rotate a function by a rotation
rotate_outer (ODF) rotate ODF
rotate_outer (PoleFigure) is called by rot * pf
rotate_outer (tensor) rotate a tensor by a list of rotations
rotate_outer (Miller) rotate crystal directions
rotate_outer (crystalShape) rotate a crystal shape by an rotation or orientation
rotate_outer (dislocationSystem) rotate dislocation systems
rotate_outer (slipSystem) rotate slip system
rotate_outer (vector3d) rotate vector3d by quaternion
rotation (tensor) convertes orthogonal rank 2 tensors into rotations
rotation (fibre) generate a list of orientation out of a fibre
rotation (rotation) defines an rotation
rotation_special (symmetry) returns symmetry elements different from rotation about c-axis
rotationRate (velocityGradientTensor) rotation rate
round (Miller) tries to round miller indizes to greatest common divisor
round2Miller (orientation) find lattice alignements for arbitrary orientations and misorientations

S

S1Grid (S1Grid) Constructor
S2AxisField (S2AxisField) a class represeneting a axis field on the sphere
S2AxisFieldHarmonic (S2AxisFieldHarmonic) a class represeneting a axis field on the sphere
S2AxisFieldTri (S2AxisFieldTri) a class represeneting a function on the sphere
S2DeLaValleePoussin extract parameter and halfwidth
S2Fun (S2Fun) a class represeneting a function on the sphere
S2Fun_index *|S2Fun|*
S2FunHandle (S2FunHandle) a class represeneting a function on the sphere
S2FunHarmonic (S2FunHarmonic) a class representing a function on the sphere
S2FunHarmonicSym (S2FunHarmonicSym) a class represeneting a symmetrised function on the sphere
S2FunTri (S2FunTri) a class represeneting a function on the sphere
S2Grid (S2Grid) Syntax S2Grid(theta,rho) % fills a Sphere with N--nodes regularS2Grid('resolution',5*degree) % construct regular polar and azimuthal spacing equispacedS2Grid('resolution',5*degree) % construct equispaced nodes
S2Kernel (S2Kernel) S2Kernel is a class. S2K = S2Kernel(A)
S2Triangulation (S2Triangulation) a class represeneting a triangulation on the sphere
S2VectorFieldHarmonic (S2VectorFieldHarmonic) a class represeneting a function on the sphere
S2VectorFieldTri (S2VectorFieldTri) a class represeneting a function on the sphere
SantaFe the SantaFe-sample ODF
save_sparse convert sparse matrix to jc, ir, pr
saveFigure save figure as graphics file
saveGrainSet_hdf5 Save GrainSet object to HDF5 format
scale (PoleFigure) scale polefigure by a factor
scaleBar Inserts a scale bar on the current ebsd or grain map.
scatter (Miller) plot Miller indece
scatter (orientation) plots orientations in 3d
scatter (quaternion) plot function
scatter (vector3d) Syntax scatter(v) % plot the directions v scatter(v,data) % colorize directions according to data scatter(v,'label',text) % plot text below markers scatter(v,'label',text,'textaboveMarker') % plot text above markers
scatter3d (vector3d) plot spherical data
SchmidFactor (slipSystem) compute the Schmid factor
SchmidTensor computes the Schmidt tensor
sectionLabels sectionLabels is a function. [symbol, labelx, labely] = sectionLabels(type)
segLength (grainBoundary) length of a boundary segment
select (PoleFigure) select PoleFigures
selectInteractive (EBSD) select interactively a rectangular region of an EBSD data set
selectInteractive (grain2d) select interactively a rectangular region of an EBSD data set
selectMaxbyColumn find maximum in each row
selectMaxbyRow find maximum in each column
selectMinbyColumn find minimum in each column
selectMinbyRow find minimum in each row
selector_old (grain2d) Grain Selector
selectPolygon select a polygon by mouse
set_default_option set option in option list if not yet present
set_option set option in option list
setappdata make setappdata work with multiple handles
setCamera set Camera according to xAxis and zAxis position
setColorRange set color range for figures
setdiff (vector3d) remove vectors v2 from a set of vectors v1
setFont FontName = "Consolas"; FontName = "Nimbus Mono PS";
setMTEXpref setMTEXpref is a function. setMTEXpref(pref, value)
setNull set approx zero to exact zero
setOption set option in option list
setSubSet (quaternion) indexing of quaternions
shapeFactor (grain2d) calculates the shapefactor of the grain-polygon, without Holes
shearDirection (velocityGradientTensor) shear direction
shearModulus (complianceTensor) shear modulus for an compliance tensor
shearModulus (stiffnessTensor) shear modulus for an elasticity tensor
shift (EBSD) shift spatial ebsd-data about (x,y)
shift (S1Grid) shifts S1Grid by delta
sigmaSections sigmaSections is a class. oS = sigmaSections(varargin)
simultaniousCG (S2FunHarmonic) calculates the minimum of a spherical harminc Syntax [v,pos] = simultaniousCG(sF) % the position where the minimum is atained
size (tensor) overloads size
size (crystalShape) overloads size
size (dislocationSystem) overloads size
size (fibre) overloads size
size (quaternion) overloads size
size (slipSystem) overloads size
size (vector3d) overloads size
size2str convert size to string
slipSystem (slipSystem) class representing slip systems
slope (ODF) | grad(r) |
smiley (S2Fun) S2Fun.smiley is a function. f = smiley(v, varargin)
smooth (EBSD) smooth spatial EBSD
smooth (EBSDhex) smooth spatial EBSD data
smooth (EBSDsquare) smooth spatial EBSD data
smooth (grain2d) constraint laplacian smoothing of grain boundaries and inner boundaries.
smooth (BinghamComponent) smooth ODF component
smooth (FourierComponent) smooth ODF component
smooth (ODF) smooth ODF
smooth (femComponent) smooth ODF component
smooth (fibreComponent) smooth ODF component
smooth (uniformComponent) smooth ODF component
smooth (unimodalComponent) smooth ODF component
smooth (Miller) plot Miller indece
smooth (vector3d) low level function for plotting functions on the sphere
smoothn SMOOTHN Robust spline smoothing for 1-D to N-D data. SMOOTHN provides a fast, automatized and robust discretized spline smoothing for data of arbitrary dimension.
SO3Grid (SO3Grid) represent orientations in a gridded structure to allow quick access
SobolevKernel SobolevKernel is a class. psi = SobolevKernel(s, varargin)
sparse (vector3d) SPARSE Create sparse matrix. S = SPARSE(X) converts a sparse or full matrix to sparse form by squeezing out any zero elements.
sparseConcat sparseConcat is a function. newSparse = sparseConcat(oldSparse, newRows, newCols, newVals, newSize)
spatialProfile (EBSD) select EBSD data along line segments
specimenSymmetry (specimenSymmetry) defines a specimen symmetry
spectralTransmission (refractiveIndexTensor) Syntax rgb = spectralTransmission(rI,vprop,p,thickness)
spectralTransmissionColorKey spectralTransmissionColorKey is a class. oM = spectralTransmissionColorKey(rI, thickness, varargin)
sphereVolume (orientation) ratio of orientations with a certain orientation
sphericalClebschGordan use global wigner3j
sphericalPlot sphericalPlot is responsible for visualizing spherical data
sphericalProjection sphericalProjection
sphericalRegion (sphericalRegion) sphericalRegion implements a region on the sphere The region is bounded by small circles given by there normal vectors and the maximum inner product, i.e., all points v inside a region satisfy the conditions dot(v, N) <= alpha
sphericalY spherical harmonics of degree l
spinTensor (spinTensor) Syntax
splineFilter smoothes quaternions by projecting them into tangential space and performing there smoothing spline approximation
splitdata make n - partitions of a list, returns its indices
spotColorKey Detailed explanation goes here
spy (SO3Grid) spy distance matrix
sqrt (S2FunHarmonic) square root of a function Syntax sF = sqrt(sF) sF = sqrt(sF, 'bandwidth', bandwidth)
sqrtm (tensor) matrix exponential of a tensor
squareProjection equal area projection
SquareSingularityKernel extract parameter and halfwidth
steepestDescent (S2FunHarmonic) calculates the minimum of a spherical harminc Syntax [v,pos] = steepestDescent(sF) % the position where the minimum is atained
steepestDescent (S2FunHarmonicSym) calculates the minimum of a spherical harminc Syntax [f,pos] = steepestDescent(sF) % the position where the minimum is atained
steepestDescent (ODF) find maximum with steepest descent
steepestDescentX (ODF) find maximum with steepest descent
stiffnessTensor (stiffnessTensor) stiffnessTensor is a class. sT = stiffnessTensor(varargin)
strainRate (velocityGradientTensor) strain rate
strainRateTensor (strainRateTensor) strainRateTensor is the symmetric part of a velocity gradient tensor
strainTensor (strainTensor) strainTensor is a class. sT = strainTensor(varargin)
stressTensor (stressTensor) stressTensor is a class. sT = stressTensor(varargin)
string2Miller converts string to Miller indece
subGrid (S1Grid) epsilon - neighborhood of a point in the grid
subGrid (S2Grid) subgrid
subGrid (SO3Grid) sub-SO3Grid as epsilon neigborhood of a node
submatrix B = A(ind) with size as A if possible
subsasgn (S2FunHarmonic) overloads subsasgn
subsasgn (EBSD) overloads subsasgn
subsasgn (grain2d) overloads subsasgn
subsasgn (grainBoundary) overloads subsasgn
subsasgn (triplePointList) overloads subsasgn
subsasgn (PoleFigure) overloads subsasgn
subsasgn (tensor) overloads subsasgn
subsasgn (S2Grid) overloads subsasgn
subsasgn (SO3Grid) overloads subsasgn
subsasgn (dislocationSystem) overloads subsasgn
subsasgn (quaternion) overloads subsasgn
subsasgn (rotation) overloads subsasgn
subsasgn (slipSystem) overloads subsasgn
subsasgn (vector3d) overloads subsasgn
subSet (EBSD) indexing of EBSD data
subSet (grain2d)
subSet (grainBoundary) restrict boundary
subSet (triplePointList) restrict boundary
subSet (crystalShape) crystalShape/subSet is a function. cS = subSet(cS, NSelect)
subSet (dislocationSystem) subindex vector3d
subSet (fibre) subindex vector3d
subSet (quaternion) indexing of quaternions
subSet (rotation) indexing of rotation
subSet (slipSystem) subindex vector3d
subSet (vector3d) subindex vector3d
subsind (EBSD) subindexing of EBSD data
subsind (EBSDhex) subindexing of EBSD data
subsind (EBSDsquare) subindexing of EBSD data
subsref (S2FunHarmonic) overloads subsref
subsref (EBSD) indexing of EBSD data
subsref (grain2d) implements grains(1:3)
subsref (grainBoundary) implements gB(1:10)
subsref (triplePointList) implements tP(1:10)
subsref (PoleFigure) overide polefigure() and polefigure{}
subsref (tensor) overloads subsref
subsref (S2Grid) overloads subsref
subsref (SO3Grid) overloads subsref
subsref (crystalShape) overloads subsref
subsref (crystalSymmetry) overloads subsref
subsref (dislocationSystem) overloads subsref
subsref (fibre) overloads subsref
subsref (quaternion) overloads subsref
subsref (rotation) overloads subsref
subsref (slipSystem) overloads subsref
subsref (symmetry) overloads subsref
subsref (vector3d) overloads subsref
sum (S2Fun) calculates the mean value for an univariate S2Fun or calculates the mean along a specified dimension fo a multimodal S2Fun
sum (S2FunHarmonic) calculates the integral for an univariate S2Fun or sums up along a specified dimension fo a multimodal S2Fun
sum (tensor) sum of a list of tensors
sum (quaternion) overloads sum
sum (vector3d) sum of vectors
surf (S2Fun) SURF 3-D colored surface. SURF(X,Y,Z,C) plots the colored parametric surface defined by four matrix arguments. The view point is specified by VIEW. The axis labels are determined by the range of X, Y and Z, or by the current setting of AXIS. The color scaling is determined by the range of C, or by the current setting of CAXIS. The scaled color values are used as indices into the current COLORMAP. The shading model is set by SHADING.
surf (Miller) Syntax
surf (vector3d) Syntax
switchUnit returns the closest length to a known unit. For example, 10e3m will give 10km.
sym (tensor) the symmetric part S = 0.5(T + T.') of a tensor
symmetrise (S2FunHarmonic) symmetrises a function with respect to a symmetry or a direction
symmetrise (tensor) symmetrise a tensor according to its crystal symmetry
symmetrise (Miller) directions symmetrically equivalent to m
symmetrise (dislocationSystem) find all symmetrically equivalent slips systems
symmetrise (fibre) all crystallographically equivalent fibres
symmetrise (orientation) all crystallographically equivalent orientations
symmetrise (quaternion) symmetrcially equivalent orientations
symmetrise (slipSystem) find all symmetrically equivalent slips systems
symmetrise (vector3d) symmetrcially equivalent directions and its multiple
symmetry (symmetry) Supported Symmetries

T

tensor (tensor) constructor
tensor (dislocationSystem) tensor representation of a dislocation system
tensorSize (tensor) overloads size
text (grain2d) plot directions at grain centers
text (Miller) plot Miller indece
text (vector3d) display a text in a spherical plot
text3 (vector3d) plot three dimensional arrows
textureindex (ODF) caclulate texture index of ODF
theta (S2VectorField) Gives the vector in the tangential plane in v in the direction theta
times (S2FunHarmonic) overloads sF1 .* sF2
times (S2FunHarmonicSym) overloads sF1 .* sF2
times (S2FunTri) .* Array multiply. X.*Y denotes element-by-element multiplication. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
times (S2VectorFieldHarmonic) Syntax sVF = sVF1.*sVF2 sVF = a.*sVF1 sVF = sVF1.*a
times (S2VectorFieldTri) Syntax sVF = sVF .* sF sVF = sVF .* a
times (ODF) scaling of the ODF
times (PoleFigure) implements pf1 .* b and a .* pf2
times (tensor) multiply a tensor by a scalar
times (crystalShape) .* Array multiply. X.*Y denotes element-by-element multiplication. X and Y must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1.
times (orientation) vec = ori .* Miller
times (quaternion) quaternion .* quaternion and quaternion .* vector3d
times (rotation) r = a .* b
times (vector3d) .* - componenwtise multiplication
times_outer times_outer is a function. x = times_outer(a, b)
trace (tensor) compute the traces of a rank 2 tensor
trace (slipSystem) trace of the slip plane in the surface normal to n
transformationMatrix (crystalSymmetry) compute the transformation matrix from cs1 to cs2
transformReferenceFrame (tensor) set properties of a tensor variable
transformReferenceFrame (Miller) change reference frame while keeping hkl or uvw
transformReferenceFrame (orientation) change reference frame of an orientation
transpose (S2FunHarmonic) overloads transpose
transpose (tensor) transpose a list of a tensors
transpose (dislocationSystem) transpose list of slipSystem
transpose (fibre) transpose list of slipSystem
transpose (quaternion) transpose array of quaternions
transpose (rotation) transpose array of rotations
transpose (slipSystem) transpose list of slipSystem
transpose (vector3d) transpose vector
triangle (sphericalRegion) define a spherical triangle by its vertices
triplePointList (triplePointList) grainBoundary list of grain boundaries in 2-D
truncate (S2FunHarmonic) truncate neglectable coefficients this includes a bit of regularisation
TSLDirectionKey converts directions to rgb values

U

uiimport overload standard MATLAB uiimport
uminus (S2FunHarmonic) Syntax sF = -sF
uminus (S2FunTri) - Unary minus. -A negates the elements of A.
uminus (S2VectorFieldHarmonic) Syntax sVF = -sVF
uminus (S2VectorFieldTri) - Unary minus. -A negates the elements of A.
uminus (ODF) superposeing two ODFs
uminus (PoleFigure) implements -pf
uminus (tensor) unary minus
uminus (dislocationSystem) overloads unitary minus
uminus (quaternion) overload unitary minus
uminus (rotation) implements -rotation
uminus (slipSystem) overloads unitary minus
uminus (vector3d) overloads unitary minus
uniformComponent (uniformComponent) uniformComponent is a class. odf = uniformComponent(cs, ss, varargin)
uniformODF get crystal and specimen symmetry
unimodalComponent (unimodalComponent) unimodalComponent is a class. component = unimodalComponent(center, psi, weights)
unimodalODF define a unimodal ODF
union (PoleFigure) crytsallographic direction to one
union (symmetry) returns the union of two symmetry groups
unique (PoleFigure) remove dublicated points in a polefigure
unique (Miller) disjoint list of Miller indices
unique (orientation) disjoint list of quaternions
unique (quaternion) disjoint list of quaternions
unique (rotation) disjoint list of rotations
unique (vector3d) disjoint list of vectors
updateUnitCell (EBSD) this function should be called after the spatial coordinates of an EBSD data set have been modified
UpDown UpDown is a function. out = UpDown(in)

V

variants (orientation) variants of an orientation relationship
varlink link to a variable
vdisp vdisp is a function. vdisp(s, varargin)
vec2cell vec2cell is a function. c = vec2cell(v)
vec42quat returns a quaternion q with q u_1 = v1 and q u2 = v2
vector3d (tensor) convert rank one tensors to vector3d
vector3d (vector3d) Constructor
velocity (complianceTensor) computes the elastic wave velocity(km/s) from the elastic stiffness Cijkl tensor and density (g/cm3)
velocity (stiffnessTensor) computes the elastic wave velocity(km/s) from the elastic stiffness Cijkl tensor and density (g/cm3)
velocityGradientTensor (velocityGradientTensor) velocityGradientTensor is a class. L = velocityGradientTensor(varargin)
vertcat (S2FunHarmonic) overloads vertcat
vertcat (tensor) overloads [T1,T2,T3..]
vertcat (dislocationSystem) overloads [v1,v2,v3..]
vertcat (fibre) overloads [v1,v2,v3..]
vertcat (quaternion) implements [q1;q2;q3..]
vertcat (slipSystem) overloads [v1,v2,v3..]
vertcat (vector3d) overloads [v1,v2,v3..]
viridisColorMap viridisColorMap is a function. varargout = viridisColorMap(varargin)
Voigt (tensor) tensor/Voigt is a function. V = Voigt(T)
volume (S2FunHarmonic) S2FunHarmonic/volume is a function. sF = volume(sF1, center, radius)
volume (S2FunTri) S2FunTri/volume is a function. sF = volume(sF1, center, radius)
volume (ODF) ratio of orientations with a certain orientation
volume (ODFComponent) get resolution
volume (uniformComponent) for large angles or specimen symmetry take the quadrature based algorithm
volume (unimodalComponent) for large angles or specimen symmetry take the quadrature based algorithm
volume (orientation) ratio of orientations with a certain orientation
volume (orientationRegion) volume of an orientation region
volume (sphericalRegion) volume of a spherical region
volume (kernel) kernel/volume is a function. [vol, dist] = volume(psi, radius, dist)
volumeCompressibility (complianceTensor) computes the volume compressibility of an elasticity tensor
volumeCompressibility (stiffnessTensor) volume compressibility of an elasticity stiffness tensor
vonMisesFisherKernel extract parameter and halfwidth
vorticity (velocityGradientTensor) vorticity Gamma

W

white2blackColorMap gray Linear gray-scale color map
WhiteJetColorMap WhiteJetColorMap is a function. map = WhiteJetColorMap(n)
Wigner3j Compute the Wigner 3j symbol using the Racah formula.
Wigner3j_new %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Wigner3jPrecomputed Wigner3jPrecomputed is a function. wigner = Wigner3jPrecomputed(l, L, m1, m2)
WignerD Wigner-D function
wignerD2 spherical harmonics of degree l
write_cell write cell string to text file
writedouble write to file

X

xnum2str convert number to string
xvector vector (1,0,0)

Y

YoungsModulus (complianceTensor) Young's modulus for an elasticity tensor
YoungsModulus (stiffnessTensor) Young's modulus for an elasticity tensor
yvector vector (0,1,0)

Z

zeroRangeMethod (zeroRangeMethod) calculate zero range
zUpDown zUpDown is a function. v = zUpDown
zvector vector (0,0,1)