# 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

- Index

- Search Page

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

    None( (minieigen.AlignedBox2)arg1) -> minieigen.Vector2

  merged((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2[STATIC]
  property min

    None( (minieigen.AlignedBox2)arg1) -> minieigen.Vector2

  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

    None( (minieigen.AlignedBox3)arg1) -> minieigen.Vector3

  merged((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3[STATIC]
  property min

    None( (minieigen.AlignedBox3)arg1) -> minieigen.Vector3

  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.