minieigen documentation¶

Overview¶

Todo

Something concise here.

Examples¶

Todo

Some examples of what can be done with minieigen.

Naming conventions¶

Classes are suffixed with number indicating size where it makes sense (it does not make sense for minieigen.Quaternion):
- minieigen.Vector3 is a 3-vector (column vector);
- minieigen.Matrix3 is a 3×3 matrix;
- minieigen.AlignedBox3 is aligned box in 3d;
- X indicates dynamic-sized types, such as minieigen.VectorX or minieigen.MatrixX.
Scalar (element) type is suffixed at the end:
- nothing is suffixed for floats (minieigen.Matrix3);
- i indicates integers (minieigen.Matrix3i);
- c indicates complex numbers (minieigen.Matrix3c).
Methods are named as follows:
- static methods are upper-case (as in c++), e.g. minieigen.Matrix3.Random;
  - nullary static methods are exposed as properties, if they return a constant (e.g. minieigen.Matrix3.Identity); if they don’t, they are exposed as methods (minieigen.Matrix3.Random); the idea is that the necessity to call the method (Matrix3.Random()) singifies that there is some computation going on, whereas constants behave like immutable singletons.
- non-static methods are lower-case (as in c++), e.g. minieigen.Matrix3.inverse.
Return types:
- methods modifying the instance in-place return None (e.g. minieigen.Vector3.normalize); some methods in c++ (e.g. Quaternion::setFromTwoVectors) both modify the instance and return the reference to it, which we don’t want to do in Python (minieigen.Quaternion.setFromTwoVectors);
- methods returning another object (e.g. minieigen.Vector3.normalized) do not modify the instance;
- methods returning (non-const) references return by value in python

Limitations¶

Type conversions (e.g. float to complex) are not supported.
Methods returning references in c++ return values in Python (so e.g. Matrix3().diagonal()[2]=0 would zero the last diagonal element in c++ but not in Python).
Many methods are not wrapped, though they are fairly easy to add.
Conversion from 1-column MatrixX to VectorX is not automatic in places where the algebra requires it.
Alignment of matrices is not supported (therefore Eigen cannot vectorize the code well); it might be a performance issue in some cases; c++ code interfacing with minieigen (in a way that c++ values can be set from Python) must compile with EIGEN_DONT_ALIGN, otherwise there might be crashes at runtime when vector instructions receive unaligned data. It seems that alignment is difficult to do with boost::python.
Proper automatic tests are missing.

Links¶

http://eigen.tuxfamily.org (Eigen itself)
http://www.launchpad.net/minieigen (upstream repository, bug reports, answers)
https://pypi.python.org/pypi/minieigen (Python package index page, used by easy_install)
packages:
- Debian
- Ubuntu: distribution, PPA

Documentation¶

miniEigen is wrapper for a small part of the Eigen library. Refer to its documentation for details. All classes in this module support pickling.

class minieigen.AlignedBox2¶

Axis-aligned box object in 2d, defined by its minimum and maximum corners

center((AlignedBox2)arg1) → Vector2[STATIC]¶

clamp((AlignedBox2)arg1, (AlignedBox2)arg2) → None[STATIC]¶

contains((AlignedBox2)arg1, (Vector2)arg2) → bool[STATIC]¶: contains( (AlignedBox2)arg1, (AlignedBox2)arg2) → bool

empty((AlignedBox2)arg1) → bool[STATIC]¶

extend((AlignedBox2)arg1, (Vector2)arg2) → None[STATIC]¶: extend( (AlignedBox2)arg1, (AlignedBox2)arg2) → None

intersection((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2[STATIC]¶

property max¶

merged((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2[STATIC]¶

property min¶

sizes((AlignedBox2)arg1) → Vector2[STATIC]¶

volume((AlignedBox2)arg1) → float[STATIC]¶

class minieigen.AlignedBox3¶

Axis-aligned box object, defined by its minimum and maximum corners

center((AlignedBox3)arg1) → Vector3[STATIC]¶

clamp((AlignedBox3)arg1, (AlignedBox3)arg2) → None[STATIC]¶

contains((AlignedBox3)arg1, (Vector3)arg2) → bool[STATIC]¶: contains( (AlignedBox3)arg1, (AlignedBox3)arg2) → bool

empty((AlignedBox3)arg1) → bool[STATIC]¶

extend((AlignedBox3)arg1, (Vector3)arg2) → None[STATIC]¶: extend( (AlignedBox3)arg1, (AlignedBox3)arg2) → None

intersection((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3[STATIC]¶

property max¶

merged((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3[STATIC]¶

property min¶

sizes((AlignedBox3)arg1) → Vector3[STATIC]¶

volume((AlignedBox3)arg1) → float[STATIC]¶

class minieigen.Matrix3¶

3x3 float matrix.

Supported operations (m is a Matrix3, f if a float/int, v is a Vector3): -m, m+m, m+=m, m-m, m-=m, m*f, f*m, m*=f, m/f, m/=f, m*m, m*=m, m*v, v*m, m==m, m!=m.

Static attributes: Zero, Ones, Identity.

Identity = Matrix3(1,0,0, 0,1,0, 0,0,1)¶

Ones = Matrix3(1,1,1, 1,1,1, 1,1,1)¶

static Random() → Matrix3[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

Zero = Matrix3(0,0,0, 0,0,0, 0,0,0)¶

col((Matrix3)arg1, (int)col) → Vector3[STATIC]¶: Return column as vector.

cols((Matrix3)arg1) → int[STATIC]¶: Number of columns.

computeUnitaryPositive((Matrix3)arg1) → tuple[STATIC]¶: Compute polar decomposition (unitary matrix U and positive semi-definite symmetric matrix P such that self=U*P).

determinant((Matrix3)arg1) → float[STATIC]¶: Return matrix determinant.

diagonal((Matrix3)arg1) → Vector3[STATIC]¶: Return diagonal as vector.

inverse((Matrix3)arg1) → Matrix3[STATIC]¶: Return inverted matrix.

isApprox((Matrix3)arg1, (Matrix3)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

jacobiSVD((Matrix3)arg1) → tuple[STATIC]¶: Compute SVD decomposition of square matrix, retuns (U,S,V) such that self=U*S*V.transpose()

maxAbsCoeff((Matrix3)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Matrix3)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((Matrix3)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((Matrix3)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((Matrix3)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Matrix3)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Matrix3)arg1) → Matrix3[STATIC]¶: Return normalized copy of this object

polarDecomposition((Matrix3)arg1) → tuple[STATIC]¶: Alias for computeUnitaryPositive.

prod((Matrix3)arg1) → float[STATIC]¶: Product of all elements.

pruned((Matrix3)arg1[, (float)absTol=1e-06]) → Matrix3[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix3)arg1, (int)row) → Vector3[STATIC]¶: Return row as vector.

rows((Matrix3)arg1) → int[STATIC]¶: Number of rows.

selfAdjointEigenDecomposition((Matrix3)arg1) → tuple[STATIC]¶: Compute eigen (spectral) decomposition of symmetric matrix, returns (eigVecs,eigVals). eigVecs is orthogonal Matrix3 with columns ar normalized eigenvectors, eigVals is Vector3 with corresponding eigenvalues. self=eigVecs*diag(eigVals)*eigVecs.transpose().

spectralDecomposition((Matrix3)arg1) → tuple[STATIC]¶: Alias for selfAdjointEigenDecomposition.

squaredNorm((Matrix3)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Matrix3)arg1) → float[STATIC]¶: Sum of all elements.

svd((Matrix3)arg1) → tuple[STATIC]¶: Alias for jacobiSVD.

trace((Matrix3)arg1) → float[STATIC]¶: Return sum of diagonal elements.

transpose((Matrix3)arg1) → Matrix3[STATIC]¶: Return transposed matrix.

class minieigen.Matrix3c¶

/TODO/

Identity = Matrix3c(1,0,0, 0,1,0, 0,0,1)¶

Ones = Matrix3c(1,1,1, 1,1,1, 1,1,1)¶

static Random() → Matrix3c[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

Zero = Matrix3c(0,0,0, 0,0,0, 0,0,0)¶

col((Matrix3c)arg1, (int)col) → Vector3c[STATIC]¶: Return column as vector.

cols((Matrix3c)arg1) → int[STATIC]¶: Number of columns.

determinant((Matrix3c)arg1) → complex[STATIC]¶: Return matrix determinant.

diagonal((Matrix3c)arg1) → Vector3c[STATIC]¶: Return diagonal as vector.

inverse((Matrix3c)arg1) → Matrix3c[STATIC]¶: Return inverted matrix.

isApprox((Matrix3c)arg1, (Matrix3c)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Matrix3c)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((Matrix3c)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((Matrix3c)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Matrix3c)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Matrix3c)arg1) → Matrix3c[STATIC]¶: Return normalized copy of this object

prod((Matrix3c)arg1) → complex[STATIC]¶: Product of all elements.

pruned((Matrix3c)arg1[, (float)absTol=1e-06]) → Matrix3c[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix3c)arg1, (int)row) → Vector3c[STATIC]¶: Return row as vector.

rows((Matrix3c)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Matrix3c)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Matrix3c)arg1) → complex[STATIC]¶: Sum of all elements.

trace((Matrix3c)arg1) → complex[STATIC]¶: Return sum of diagonal elements.

transpose((Matrix3c)arg1) → Matrix3c[STATIC]¶: Return transposed matrix.

class minieigen.Matrix6¶

6x6 float matrix. Constructed from 4 3x3 sub-matrices, from 6xVector6 (rows).

Supported operations (m is a Matrix6, f if a float/int, v is a Vector6): -m, m+m, m+=m, m-m, m-=m, m*f, f*m, m*=f, m/f, m/=f, m*m, m*=m, m*v, v*m, m==m, m!=m.

Static attributes: Zero, Ones, Identity.

Identity = Matrix6( ( 1, 0, 0, 0, 0, 0), ( 0, 1, 0, 0, 0, 0), ( 0, 0, 1, 0, 0, 0), ( 0, 0, 0, 1, 0, 0), ( 0, 0, 0, 0, 1, 0), ( 0, 0, 0, 0, 0, 1) )¶

Ones = Matrix6( ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1) )¶

static Random() → Matrix6[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

Zero = Matrix6( ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0) )¶

col((Matrix6)arg1, (int)col) → Vector6[STATIC]¶: Return column as vector.

cols((Matrix6)arg1) → int[STATIC]¶: Number of columns.

computeUnitaryPositive((Matrix6)arg1) → tuple[STATIC]¶: Compute polar decomposition (unitary matrix U and positive semi-definite symmetric matrix P such that self=U*P).

determinant((Matrix6)arg1) → float[STATIC]¶: Return matrix determinant.

diagonal((Matrix6)arg1) → Vector6[STATIC]¶: Return diagonal as vector.

inverse((Matrix6)arg1) → Matrix6[STATIC]¶: Return inverted matrix.

isApprox((Matrix6)arg1, (Matrix6)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

jacobiSVD((Matrix6)arg1) → tuple[STATIC]¶: Compute SVD decomposition of square matrix, retuns (U,S,V) such that self=U*S*V.transpose()

ll((Matrix6)arg1) → Matrix3[STATIC]¶: Return lower-left 3x3 block

lr((Matrix6)arg1) → Matrix3[STATIC]¶: Return lower-right 3x3 block

maxAbsCoeff((Matrix6)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Matrix6)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((Matrix6)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((Matrix6)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((Matrix6)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Matrix6)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Matrix6)arg1) → Matrix6[STATIC]¶: Return normalized copy of this object

polarDecomposition((Matrix6)arg1) → tuple[STATIC]¶: Alias for computeUnitaryPositive.

prod((Matrix6)arg1) → float[STATIC]¶: Product of all elements.

pruned((Matrix6)arg1[, (float)absTol=1e-06]) → Matrix6[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix6)arg1, (int)row) → Vector6[STATIC]¶: Return row as vector.

rows((Matrix6)arg1) → int[STATIC]¶: Number of rows.

selfAdjointEigenDecomposition((Matrix6)arg1) → tuple[STATIC]¶: Compute eigen (spectral) decomposition of symmetric matrix, returns (eigVecs,eigVals). eigVecs is orthogonal Matrix3 with columns ar normalized eigenvectors, eigVals is Vector3 with corresponding eigenvalues. self=eigVecs*diag(eigVals)*eigVecs.transpose().

spectralDecomposition((Matrix6)arg1) → tuple[STATIC]¶: Alias for selfAdjointEigenDecomposition.

squaredNorm((Matrix6)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Matrix6)arg1) → float[STATIC]¶: Sum of all elements.

svd((Matrix6)arg1) → tuple[STATIC]¶: Alias for jacobiSVD.

trace((Matrix6)arg1) → float[STATIC]¶: Return sum of diagonal elements.

transpose((Matrix6)arg1) → Matrix6[STATIC]¶: Return transposed matrix.

ul((Matrix6)arg1) → Matrix3[STATIC]¶: Return upper-left 3x3 block

ur((Matrix6)arg1) → Matrix3[STATIC]¶: Return upper-right 3x3 block

class minieigen.Matrix6c¶

/TODO/

Identity = Matrix6c( ( 1, 0, 0, 0, 0, 0), ( 0, 1, 0, 0, 0, 0), ( 0, 0, 1, 0, 0, 0), ( 0, 0, 0, 1, 0, 0), ( 0, 0, 0, 0, 1, 0), ( 0, 0, 0, 0, 0, 1) )¶

Ones = Matrix6c( ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1), ( 1, 1, 1, 1, 1, 1) )¶

static Random() → Matrix6c[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

Zero = Matrix6c( ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0), ( 0, 0, 0, 0, 0, 0) )¶

col((Matrix6c)arg1, (int)col) → Vector6c[STATIC]¶: Return column as vector.

cols((Matrix6c)arg1) → int[STATIC]¶: Number of columns.

determinant((Matrix6c)arg1) → complex[STATIC]¶: Return matrix determinant.

diagonal((Matrix6c)arg1) → Vector6c[STATIC]¶: Return diagonal as vector.

inverse((Matrix6c)arg1) → Matrix6c[STATIC]¶: Return inverted matrix.

isApprox((Matrix6c)arg1, (Matrix6c)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

ll((Matrix6c)arg1) → Matrix3c[STATIC]¶: Return lower-left 3x3 block

lr((Matrix6c)arg1) → Matrix3c[STATIC]¶: Return lower-right 3x3 block

maxAbsCoeff((Matrix6c)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((Matrix6c)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((Matrix6c)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Matrix6c)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Matrix6c)arg1) → Matrix6c[STATIC]¶: Return normalized copy of this object

prod((Matrix6c)arg1) → complex[STATIC]¶: Product of all elements.

pruned((Matrix6c)arg1[, (float)absTol=1e-06]) → Matrix6c[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix6c)arg1, (int)row) → Vector6c[STATIC]¶: Return row as vector.

rows((Matrix6c)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Matrix6c)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Matrix6c)arg1) → complex[STATIC]¶: Sum of all elements.

trace((Matrix6c)arg1) → complex[STATIC]¶: Return sum of diagonal elements.

transpose((Matrix6c)arg1) → Matrix6c[STATIC]¶: Return transposed matrix.

ul((Matrix6c)arg1) → Matrix3c[STATIC]¶: Return upper-left 3x3 block

ur((Matrix6c)arg1) → Matrix3c[STATIC]¶: Return upper-right 3x3 block

class minieigen.MatrixX¶

XxX (dynamic-sized) float matrix. Constructed from list of rows (as VectorX).

Supported operations (m is a MatrixX, f if a float/int, v is a VectorX): -m, m+m, m+=m, m-m, m-=m, m*f, f*m, m*=f, m/f, m/=f, m*m, m*=m, m*v, v*m, m==m, m!=m.

static Identity((int)arg1, (int)rank) → MatrixX[STATIC]¶: Create identity matrix with given rank (square).

static Ones((int)rows, (int)cols) → MatrixX[STATIC]¶: Create matrix of given dimensions where all elements are set to 1.

static Random((int)rows, (int)cols) → MatrixX[STATIC]¶: Create matrix with given dimensions where all elements are set to number between 0 and 1 (uniformly-distributed).

static Zero((int)rows, (int)cols) → MatrixX[STATIC]¶: Create zero matrix of given dimensions

col((MatrixX)arg1, (int)col) → VectorX[STATIC]¶: Return column as vector.

cols((MatrixX)arg1) → int[STATIC]¶: Number of columns.

computeUnitaryPositive((MatrixX)arg1) → tuple[STATIC]¶: Compute polar decomposition (unitary matrix U and positive semi-definite symmetric matrix P such that self=U*P).

determinant((MatrixX)arg1) → float[STATIC]¶: Return matrix determinant.

diagonal((MatrixX)arg1) → VectorX[STATIC]¶: Return diagonal as vector.

inverse((MatrixX)arg1) → MatrixX[STATIC]¶: Return inverted matrix.

isApprox((MatrixX)arg1, (MatrixX)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

jacobiSVD((MatrixX)arg1) → tuple[STATIC]¶: Compute SVD decomposition of square matrix, retuns (U,S,V) such that self=U*S*V.transpose()

maxAbsCoeff((MatrixX)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((MatrixX)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((MatrixX)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((MatrixX)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((MatrixX)arg1) → float[STATIC]¶: Euclidean norm.

normalize((MatrixX)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((MatrixX)arg1) → MatrixX[STATIC]¶: Return normalized copy of this object

polarDecomposition((MatrixX)arg1) → tuple[STATIC]¶: Alias for computeUnitaryPositive.

prod((MatrixX)arg1) → float[STATIC]¶: Product of all elements.

pruned((MatrixX)arg1[, (float)absTol=1e-06]) → MatrixX[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((MatrixX)arg1, (int)rows, (int)cols) → None[STATIC]¶: Change size of the matrix, keep values of elements which exist in the new matrix

row((MatrixX)arg1, (int)row) → VectorX[STATIC]¶: Return row as vector.

rows((MatrixX)arg1) → int[STATIC]¶: Number of rows.

selfAdjointEigenDecomposition((MatrixX)arg1) → tuple[STATIC]¶: Compute eigen (spectral) decomposition of symmetric matrix, returns (eigVecs,eigVals). eigVecs is orthogonal Matrix3 with columns ar normalized eigenvectors, eigVals is Vector3 with corresponding eigenvalues. self=eigVecs*diag(eigVals)*eigVecs.transpose().

spectralDecomposition((MatrixX)arg1) → tuple[STATIC]¶: Alias for selfAdjointEigenDecomposition.

squaredNorm((MatrixX)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((MatrixX)arg1) → float[STATIC]¶: Sum of all elements.

svd((MatrixX)arg1) → tuple[STATIC]¶: Alias for jacobiSVD.

trace((MatrixX)arg1) → float[STATIC]¶: Return sum of diagonal elements.

transpose((MatrixX)arg1) → MatrixX[STATIC]¶: Return transposed matrix.

class minieigen.MatrixXc¶

/TODO/

static Identity((int)arg1, (int)rank) → MatrixXc[STATIC]¶: Create identity matrix with given rank (square).

static Ones((int)rows, (int)cols) → MatrixXc[STATIC]¶: Create matrix of given dimensions where all elements are set to 1.

static Random((int)rows, (int)cols) → MatrixXc[STATIC]¶: Create matrix with given dimensions where all elements are set to number between 0 and 1 (uniformly-distributed).

static Zero((int)rows, (int)cols) → MatrixXc[STATIC]¶: Create zero matrix of given dimensions

col((MatrixXc)arg1, (int)col) → VectorXc[STATIC]¶: Return column as vector.

cols((MatrixXc)arg1) → int[STATIC]¶: Number of columns.

determinant((MatrixXc)arg1) → complex[STATIC]¶: Return matrix determinant.

diagonal((MatrixXc)arg1) → VectorXc[STATIC]¶: Return diagonal as vector.

inverse((MatrixXc)arg1) → MatrixXc[STATIC]¶: Return inverted matrix.

isApprox((MatrixXc)arg1, (MatrixXc)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((MatrixXc)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((MatrixXc)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((MatrixXc)arg1) → float[STATIC]¶: Euclidean norm.

normalize((MatrixXc)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((MatrixXc)arg1) → MatrixXc[STATIC]¶: Return normalized copy of this object

prod((MatrixXc)arg1) → complex[STATIC]¶: Product of all elements.

pruned((MatrixXc)arg1[, (float)absTol=1e-06]) → MatrixXc[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((MatrixXc)arg1, (int)rows, (int)cols) → None[STATIC]¶: Change size of the matrix, keep values of elements which exist in the new matrix

row((MatrixXc)arg1, (int)row) → VectorXc[STATIC]¶: Return row as vector.

rows((MatrixXc)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((MatrixXc)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((MatrixXc)arg1) → complex[STATIC]¶: Sum of all elements.

trace((MatrixXc)arg1) → complex[STATIC]¶: Return sum of diagonal elements.

transpose((MatrixXc)arg1) → MatrixXc[STATIC]¶: Return transposed matrix.

class minieigen.Quaternion¶

Quaternion representing rotation.

Supported operations (q is a Quaternion, v is a Vector3): q*q (rotation composition), q*=q, q*v (rotating v by q), q==q, q!=q.

Static attributes: Identity.

Identity = Quaternion((1,0,0),0)¶

Rotate((Quaternion)arg1, (Vector3)v) → Vector3[STATIC]¶

angularDistance((Quaternion)arg1, (Quaternion)arg2) → float[STATIC]¶

conjugate((Quaternion)arg1) → Quaternion[STATIC]¶

inverse((Quaternion)arg1) → Quaternion[STATIC]¶

norm((Quaternion)arg1) → float[STATIC]¶

normalize((Quaternion)arg1) → None[STATIC]¶

normalized((Quaternion)arg1) → Quaternion[STATIC]¶

setFromTwoVectors((Quaternion)arg1, (Vector3)u, (Vector3)v) → None[STATIC]¶

slerp((Quaternion)arg1, (float)t, (Quaternion)other) → Quaternion[STATIC]¶

toAngleAxis((Quaternion)arg1) → tuple[STATIC]¶

toAxisAngle((Quaternion)arg1) → tuple[STATIC]¶

toRotationMatrix((Quaternion)arg1) → Matrix3[STATIC]¶

toRotationVector((Quaternion)arg1) → Vector3[STATIC]¶

class minieigen.Vector2¶

3-dimensional float vector.

Supported operations (f if a float/int, v is a Vector3): -v, v+v, v+=v, v-v, v-=v, v*f, f*v, v*=f, v/f, v/=f, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of 2 floats.

Static attributes: Zero, Ones, UnitX, UnitY.

Identity = Vector2(1,0)¶

Ones = Vector2(1,1)¶

static Random() → Vector2[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector2[STATIC]¶

UnitX = Vector2(1,0)¶

UnitY = Vector2(0,1)¶

Zero = Vector2(0,0)¶

asDiagonal((Vector2)arg1) → object[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector2)arg1) → int[STATIC]¶: Number of columns.

dot((Vector2)arg1, (Vector2)other) → float[STATIC]¶: Dot product with other.

isApprox((Vector2)arg1, (Vector2)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector2)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector2)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((Vector2)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((Vector2)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((Vector2)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector2)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector2)arg1) → Vector2[STATIC]¶: Return normalized copy of this object

outer((Vector2)arg1, (Vector2)other) → object[STATIC]¶: Outer product with other.

prod((Vector2)arg1) → float[STATIC]¶: Product of all elements.

pruned((Vector2)arg1[, (float)absTol=1e-06]) → Vector2[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector2)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector2)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector2)arg1) → float[STATIC]¶: Sum of all elements.

class minieigen.Vector2c¶

/TODO/

Identity = Vector2c(1,0)¶

Ones = Vector2c(1,1)¶

static Random() → Vector2c[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector2c[STATIC]¶

UnitX = Vector2c(1,0)¶

UnitY = Vector2c(0,1)¶

Zero = Vector2c(0,0)¶

asDiagonal((Vector2c)arg1) → object[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector2c)arg1) → int[STATIC]¶: Number of columns.

dot((Vector2c)arg1, (Vector2c)other) → complex[STATIC]¶: Dot product with other.

isApprox((Vector2c)arg1, (Vector2c)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector2c)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((Vector2c)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((Vector2c)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector2c)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector2c)arg1) → Vector2c[STATIC]¶: Return normalized copy of this object

outer((Vector2c)arg1, (Vector2c)other) → object[STATIC]¶: Outer product with other.

prod((Vector2c)arg1) → complex[STATIC]¶: Product of all elements.

pruned((Vector2c)arg1[, (float)absTol=1e-06]) → Vector2c[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector2c)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector2c)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector2c)arg1) → complex[STATIC]¶: Sum of all elements.

class minieigen.Vector2i¶

2-dimensional integer vector.

Supported operations (i if an int, v is a Vector2i): -v, v+v, v+=v, v-v, v-=v, v*i, i*v, v*=i, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of 2 integers.

Static attributes: Zero, Ones, UnitX, UnitY.

Identity = Vector2i(1,0)¶

Ones = Vector2i(1,1)¶

static Random() → Vector2i[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector2i[STATIC]¶

UnitX = Vector2i(1,0)¶

UnitY = Vector2i(0,1)¶

Zero = Vector2i(0,0)¶

asDiagonal((Vector2i)arg1) → object[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector2i)arg1) → int[STATIC]¶: Number of columns.

dot((Vector2i)arg1, (Vector2i)other) → int[STATIC]¶: Dot product with other.

isApprox((Vector2i)arg1, (Vector2i)other[, (int)prec=0]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector2i)arg1) → int[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector2i)arg1) → int[STATIC]¶: Maximum value over all elements.

mean((Vector2i)arg1) → int[STATIC]¶: Mean value over all elements.

minCoeff((Vector2i)arg1) → int[STATIC]¶: Minimum value over all elements.

outer((Vector2i)arg1, (Vector2i)other) → object[STATIC]¶: Outer product with other.

prod((Vector2i)arg1) → int[STATIC]¶: Product of all elements.

rows((Vector2i)arg1) → int[STATIC]¶: Number of rows.

sum((Vector2i)arg1) → int[STATIC]¶: Sum of all elements.

class minieigen.Vector3¶

3-dimensional float vector.

Supported operations (f if a float/int, v is a Vector3): -v, v+v, v+=v, v-v, v-=v, v*f, f*v, v*=f, v/f, v/=f, v==v, v!=v, plus operations with Matrix3 and Quaternion.

Implicit conversion from sequence (list, tuple, …) of 3 floats.

Static attributes: Zero, Ones, UnitX, UnitY, UnitZ.

Identity = Vector3(1,0,0)¶

Ones = Vector3(1,1,1)¶

static Random() → Vector3[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector3[STATIC]¶

UnitX = Vector3(1,0,0)¶

UnitY = Vector3(0,1,0)¶

UnitZ = Vector3(0,0,1)¶

Zero = Vector3(0,0,0)¶

asDiagonal((Vector3)arg1) → Matrix3[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector3)arg1) → int[STATIC]¶: Number of columns.

cross((Vector3)arg1, (Vector3)arg2) → Vector3[STATIC]¶

dot((Vector3)arg1, (Vector3)other) → float[STATIC]¶: Dot product with other.

isApprox((Vector3)arg1, (Vector3)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector3)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector3)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((Vector3)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((Vector3)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((Vector3)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector3)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector3)arg1) → Vector3[STATIC]¶: Return normalized copy of this object

outer((Vector3)arg1, (Vector3)other) → Matrix3[STATIC]¶: Outer product with other.

prod((Vector3)arg1) → float[STATIC]¶: Product of all elements.

pruned((Vector3)arg1[, (float)absTol=1e-06]) → Vector3[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector3)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector3)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector3)arg1) → float[STATIC]¶: Sum of all elements.

xy((Vector3)arg1) → Vector2[STATIC]¶

xz((Vector3)arg1) → Vector2[STATIC]¶

yx((Vector3)arg1) → Vector2[STATIC]¶

yz((Vector3)arg1) → Vector2[STATIC]¶

zx((Vector3)arg1) → Vector2[STATIC]¶

zy((Vector3)arg1) → Vector2[STATIC]¶

class minieigen.Vector3c¶

/TODO/

Identity = Vector3c(1,0,0)¶

Ones = Vector3c(1,1,1)¶

static Random() → Vector3c[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector3c[STATIC]¶

UnitX = Vector3c(1,0,0)¶

UnitY = Vector3c(0,1,0)¶

UnitZ = Vector3c(0,0,1)¶

Zero = Vector3c(0,0,0)¶

asDiagonal((Vector3c)arg1) → Matrix3c[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector3c)arg1) → int[STATIC]¶: Number of columns.

cross((Vector3c)arg1, (Vector3c)arg2) → Vector3c[STATIC]¶

dot((Vector3c)arg1, (Vector3c)other) → complex[STATIC]¶: Dot product with other.

isApprox((Vector3c)arg1, (Vector3c)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector3c)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((Vector3c)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((Vector3c)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector3c)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector3c)arg1) → Vector3c[STATIC]¶: Return normalized copy of this object

outer((Vector3c)arg1, (Vector3c)other) → Matrix3c[STATIC]¶: Outer product with other.

prod((Vector3c)arg1) → complex[STATIC]¶: Product of all elements.

pruned((Vector3c)arg1[, (float)absTol=1e-06]) → Vector3c[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector3c)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector3c)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector3c)arg1) → complex[STATIC]¶: Sum of all elements.

xy((Vector3c)arg1) → Vector2c[STATIC]¶

xz((Vector3c)arg1) → Vector2c[STATIC]¶

yx((Vector3c)arg1) → Vector2c[STATIC]¶

yz((Vector3c)arg1) → Vector2c[STATIC]¶

zx((Vector3c)arg1) → Vector2c[STATIC]¶

zy((Vector3c)arg1) → Vector2c[STATIC]¶

class minieigen.Vector3i¶

3-dimensional integer vector.

Supported operations (i if an int, v is a Vector3i): -v, v+v, v+=v, v-v, v-=v, v*i, i*v, v*=i, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of 3 integers.

Static attributes: Zero, Ones, UnitX, UnitY, UnitZ.

Identity = Vector3i(1,0,0)¶

Ones = Vector3i(1,1,1)¶

static Random() → Vector3i[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector3i[STATIC]¶

UnitX = Vector3i(1,0,0)¶

UnitY = Vector3i(0,1,0)¶

UnitZ = Vector3i(0,0,1)¶

Zero = Vector3i(0,0,0)¶

asDiagonal((Vector3i)arg1) → object[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector3i)arg1) → int[STATIC]¶: Number of columns.

cross((Vector3i)arg1, (Vector3i)arg2) → Vector3i[STATIC]¶

dot((Vector3i)arg1, (Vector3i)other) → int[STATIC]¶: Dot product with other.

isApprox((Vector3i)arg1, (Vector3i)other[, (int)prec=0]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector3i)arg1) → int[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector3i)arg1) → int[STATIC]¶: Maximum value over all elements.

mean((Vector3i)arg1) → int[STATIC]¶: Mean value over all elements.

minCoeff((Vector3i)arg1) → int[STATIC]¶: Minimum value over all elements.

outer((Vector3i)arg1, (Vector3i)other) → object[STATIC]¶: Outer product with other.

prod((Vector3i)arg1) → int[STATIC]¶: Product of all elements.

rows((Vector3i)arg1) → int[STATIC]¶: Number of rows.

sum((Vector3i)arg1) → int[STATIC]¶: Sum of all elements.

xy((Vector3i)arg1) → Vector2i[STATIC]¶

xz((Vector3i)arg1) → Vector2i[STATIC]¶

yx((Vector3i)arg1) → Vector2i[STATIC]¶

yz((Vector3i)arg1) → Vector2i[STATIC]¶

zx((Vector3i)arg1) → Vector2i[STATIC]¶

zy((Vector3i)arg1) → Vector2i[STATIC]¶

class minieigen.Vector4¶

4-dimensional float vector.

Supported operations (f if a float/int, v is a Vector3): -v, v+v, v+=v, v-v, v-=v, v*f, f*v, v*=f, v/f, v/=f, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of 4 floats.

Static attributes: Zero, Ones.

Identity = Vector4(1,0,0, 0)¶

Ones = Vector4(1,1,1, 1)¶

static Random() → Vector4[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector4[STATIC]¶

Zero = Vector4(0,0,0, 0)¶

asDiagonal((Vector4)arg1) → object[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector4)arg1) → int[STATIC]¶: Number of columns.

dot((Vector4)arg1, (Vector4)other) → float[STATIC]¶: Dot product with other.

isApprox((Vector4)arg1, (Vector4)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector4)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector4)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((Vector4)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((Vector4)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((Vector4)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector4)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector4)arg1) → Vector4[STATIC]¶: Return normalized copy of this object

outer((Vector4)arg1, (Vector4)other) → object[STATIC]¶: Outer product with other.

prod((Vector4)arg1) → float[STATIC]¶: Product of all elements.

pruned((Vector4)arg1[, (float)absTol=1e-06]) → Vector4[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector4)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector4)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector4)arg1) → float[STATIC]¶: Sum of all elements.

class minieigen.Vector6¶

6-dimensional float vector.

Supported operations (f if a float/int, v is a Vector6): -v, v+v, v+=v, v-v, v-=v, v*f, f*v, v*=f, v/f, v/=f, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of 6 floats.

Static attributes: Zero, Ones.

Identity = Vector6(1,0,0, 0,0,0)¶

Ones = Vector6(1,1,1, 1,1,1)¶

static Random() → Vector6[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector6[STATIC]¶

Zero = Vector6(0,0,0, 0,0,0)¶

asDiagonal((Vector6)arg1) → Matrix6[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector6)arg1) → int[STATIC]¶: Number of columns.

dot((Vector6)arg1, (Vector6)other) → float[STATIC]¶: Dot product with other.

head((Vector6)arg1) → Vector3[STATIC]¶

isApprox((Vector6)arg1, (Vector6)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector6)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector6)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((Vector6)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((Vector6)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((Vector6)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector6)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector6)arg1) → Vector6[STATIC]¶: Return normalized copy of this object

outer((Vector6)arg1, (Vector6)other) → Matrix6[STATIC]¶: Outer product with other.

prod((Vector6)arg1) → float[STATIC]¶: Product of all elements.

pruned((Vector6)arg1[, (float)absTol=1e-06]) → Vector6[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector6)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector6)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector6)arg1) → float[STATIC]¶: Sum of all elements.

tail((Vector6)arg1) → Vector3[STATIC]¶

class minieigen.Vector6c¶

/TODO/

Identity = Vector6c(1,0,0, 0,0,0)¶

Ones = Vector6c(1,1,1, 1,1,1)¶

static Random() → Vector6c[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector6c[STATIC]¶

Zero = Vector6c(0,0,0, 0,0,0)¶

asDiagonal((Vector6c)arg1) → Matrix6c[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector6c)arg1) → int[STATIC]¶: Number of columns.

dot((Vector6c)arg1, (Vector6c)other) → complex[STATIC]¶: Dot product with other.

head((Vector6c)arg1) → Vector3c[STATIC]¶

isApprox((Vector6c)arg1, (Vector6c)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector6c)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((Vector6c)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((Vector6c)arg1) → float[STATIC]¶: Euclidean norm.

normalize((Vector6c)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((Vector6c)arg1) → Vector6c[STATIC]¶: Return normalized copy of this object

outer((Vector6c)arg1, (Vector6c)other) → Matrix6c[STATIC]¶: Outer product with other.

prod((Vector6c)arg1) → complex[STATIC]¶: Product of all elements.

pruned((Vector6c)arg1[, (float)absTol=1e-06]) → Vector6c[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector6c)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((Vector6c)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((Vector6c)arg1) → complex[STATIC]¶: Sum of all elements.

tail((Vector6c)arg1) → Vector3c[STATIC]¶

class minieigen.Vector6i¶

6-dimensional float vector.

Supported operations (f if a float/int, v is a Vector6): -v, v+v, v+=v, v-v, v-=v, v*f, f*v, v*=f, v/f, v/=f, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of 6 floats.

Static attributes: Zero, Ones.

Identity = Vector6i(1,0,0, 0,0,0)¶

Ones = Vector6i(1,1,1, 1,1,1)¶

static Random() → Vector6i[STATIC]¶: Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector6i[STATIC]¶

Zero = Vector6i(0,0,0, 0,0,0)¶

asDiagonal((Vector6i)arg1) → object[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((Vector6i)arg1) → int[STATIC]¶: Number of columns.

dot((Vector6i)arg1, (Vector6i)other) → int[STATIC]¶: Dot product with other.

head((Vector6i)arg1) → Vector3i[STATIC]¶

isApprox((Vector6i)arg1, (Vector6i)other[, (int)prec=0]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((Vector6i)arg1) → int[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((Vector6i)arg1) → int[STATIC]¶: Maximum value over all elements.

mean((Vector6i)arg1) → int[STATIC]¶: Mean value over all elements.

minCoeff((Vector6i)arg1) → int[STATIC]¶: Minimum value over all elements.

outer((Vector6i)arg1, (Vector6i)other) → object[STATIC]¶: Outer product with other.

prod((Vector6i)arg1) → int[STATIC]¶: Product of all elements.

rows((Vector6i)arg1) → int[STATIC]¶: Number of rows.

sum((Vector6i)arg1) → int[STATIC]¶: Sum of all elements.

tail((Vector6i)arg1) → Vector3i[STATIC]¶

class minieigen.VectorX¶

Dynamic-sized float vector.

Supported operations (f if a float/int, v is a VectorX): -v, v+v, v+=v, v-v, v-=v, v*f, f*v, v*=f, v/f, v/=f, v==v, v!=v.

Implicit conversion from sequence (list, tuple, …) of X floats.

static Ones((int)arg1) → VectorX[STATIC]¶

static Random((int)len) → VectorX[STATIC]¶: Return vector of given length with all elements set to values between 0 and 1 randomly.

static Unit((int)arg1, (int)arg2) → VectorX[STATIC]¶

static Zero((int)arg1) → VectorX[STATIC]¶

asDiagonal((VectorX)arg1) → MatrixX[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((VectorX)arg1) → int[STATIC]¶: Number of columns.

dot((VectorX)arg1, (VectorX)other) → float[STATIC]¶: Dot product with other.

isApprox((VectorX)arg1, (VectorX)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((VectorX)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

maxCoeff((VectorX)arg1) → float[STATIC]¶: Maximum value over all elements.

mean((VectorX)arg1) → float[STATIC]¶: Mean value over all elements.

minCoeff((VectorX)arg1) → float[STATIC]¶: Minimum value over all elements.

norm((VectorX)arg1) → float[STATIC]¶: Euclidean norm.

normalize((VectorX)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((VectorX)arg1) → VectorX[STATIC]¶: Return normalized copy of this object

outer((VectorX)arg1, (VectorX)other) → MatrixX[STATIC]¶: Outer product with other.

prod((VectorX)arg1) → float[STATIC]¶: Product of all elements.

pruned((VectorX)arg1[, (float)absTol=1e-06]) → VectorX[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((VectorX)arg1, (int)arg2) → None[STATIC]¶

rows((VectorX)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((VectorX)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((VectorX)arg1) → float[STATIC]¶: Sum of all elements.

class minieigen.VectorXc¶

/TODO/

static Ones((int)arg1) → VectorXc[STATIC]¶

static Random((int)len) → VectorXc[STATIC]¶: Return vector of given length with all elements set to values between 0 and 1 randomly.

static Unit((int)arg1, (int)arg2) → VectorXc[STATIC]¶

static Zero((int)arg1) → VectorXc[STATIC]¶

asDiagonal((VectorXc)arg1) → MatrixXc[STATIC]¶: Return diagonal matrix with this vector on the diagonal.

cols((VectorXc)arg1) → int[STATIC]¶: Number of columns.

dot((VectorXc)arg1, (VectorXc)other) → complex[STATIC]¶: Dot product with other.

isApprox((VectorXc)arg1, (VectorXc)other[, (float)prec=1e-12]) → bool[STATIC]¶: Approximate comparison with precision prec.

maxAbsCoeff((VectorXc)arg1) → float[STATIC]¶: Maximum absolute value over all elements.

mean((VectorXc)arg1) → complex[STATIC]¶: Mean value over all elements.

norm((VectorXc)arg1) → float[STATIC]¶: Euclidean norm.

normalize((VectorXc)arg1) → None[STATIC]¶: Normalize this object in-place.

normalized((VectorXc)arg1) → VectorXc[STATIC]¶: Return normalized copy of this object

outer((VectorXc)arg1, (VectorXc)other) → MatrixXc[STATIC]¶: Outer product with other.

prod((VectorXc)arg1) → complex[STATIC]¶: Product of all elements.

pruned((VectorXc)arg1[, (float)absTol=1e-06]) → VectorXc[STATIC]¶: Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((VectorXc)arg1, (int)arg2) → None[STATIC]¶

rows((VectorXc)arg1) → int[STATIC]¶: Number of rows.

squaredNorm((VectorXc)arg1) → float[STATIC]¶: Square of the Euclidean norm.

sum((VectorXc)arg1) → complex[STATIC]¶: Sum of all elements.

minieigen.float2str((float)f[, (int)pad=0]) → str¶: Return the shortest string representation of f which will is equal to f when converted back to float. This function is only useful in Python prior to 3.0; starting from that version, standard string conversion does just that.