yade.minieigenHP module

When yade uses high-precision number as Real type the usual (old):

from minieigen import *

has to be replaced with:

from yade.minieigenHP import *

This command ensures backward compatibility between both. It is then guaranteed that python uses the same number of decimal places as yade is using everywhere else.

Please note that used precision can be very arbitrary, because cpp_bin_float or mpfr take it as a compile-time argument. Hence such yade.minieigenHP cannot be separately precompiled as a package. Though it could be precompiled for some special types such as boost::multiprecision::float128.

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 yade._minieigenHP.AlignedBox2

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

__init__((object)arg1) → None

__init__( (object)arg1, (AlignedBox2)other) -> None

__init__( (object)arg1, (Vector2)min, (Vector2)max) -> None

center((AlignedBox2)arg1) → Vector2
clamp((AlignedBox2)arg1, (AlignedBox2)arg2) → None
contains((AlignedBox2)arg1, (Vector2)arg2) → bool

contains( (AlignedBox2)arg1, (AlignedBox2)arg2) -> bool

empty((AlignedBox2)arg1) → bool
extend((AlignedBox2)arg1, (Vector2)arg2) → None

extend( (AlignedBox2)arg1, (AlignedBox2)arg2) -> None

intersection((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2
max
merged((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2
min
sizes((AlignedBox2)arg1) → Vector2
volume((AlignedBox2)arg1) → float
class yade._minieigenHP.AlignedBox3

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

__init__((object)arg1) → None

__init__( (object)arg1, (AlignedBox3)other) -> None

__init__( (object)arg1, (Vector3)min, (Vector3)max) -> None

center((AlignedBox3)arg1) → Vector3
clamp((AlignedBox3)arg1, (AlignedBox3)arg2) → None
contains((AlignedBox3)arg1, (Vector3)arg2) → bool

contains( (AlignedBox3)arg1, (AlignedBox3)arg2) -> bool

empty((AlignedBox3)arg1) → bool
extend((AlignedBox3)arg1, (Vector3)arg2) → None

extend( (AlignedBox3)arg1, (AlignedBox3)arg2) -> None

intersection((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3
max
merged((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3
min
sizes((AlignedBox3)arg1) → Vector3
volume((AlignedBox3)arg1) → float
class yade._minieigenHP.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 :

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)
__init__((object)arg1) → None

__init__( (object)arg1, (Quaternion)q) -> None

__init__( (object)arg1, (Matrix3)other) -> None

__init__( (object)arg1, (Vector3)diag) -> object

__init__( (object)arg1, (float)m00, (float)m01, (float)m02, (float)m10, (float)m11, (float)m12, (float)m20, (float)m21, (float)m22) -> object

__init__( (object)arg1, (Vector3)r0, (Vector3)r1, (Vector3)r2 [, (bool)cols=False]) -> object

col((Matrix3)arg1, (int)col) → Vector3 :

Return column as vector.

cols((Matrix3)arg1) → int :

Number of columns.

computeUnitaryPositive((Matrix3)arg1) → tuple :

Compute polar decomposition (unitary matrix U and positive semi-definite symmetric matrix P such that self=U*P).

determinant((Matrix3)arg1) → float :

Return matrix determinant.

diagonal((Matrix3)arg1) → Vector3 :

Return diagonal as vector.

inverse((Matrix3)arg1) → Matrix3 :

Return inverted matrix.

isApprox((Matrix3)arg1, (Matrix3)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

jacobiSVD((Matrix3)arg1) → tuple :

Compute SVD decomposition of square matrix, retuns (U,S,V) such that self=U*S*V.transpose()

maxAbsCoeff((Matrix3)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((Matrix3)arg1) → float :

Maximum value over all elements.

mean((Matrix3)arg1) → float :

Mean value over all elements.

minCoeff((Matrix3)arg1) → float :

Minimum value over all elements.

norm((Matrix3)arg1) → float :

Euclidean norm.

normalize((Matrix3)arg1) → None :

Normalize this object in-place.

normalized((Matrix3)arg1) → Matrix3 :

Return normalized copy of this object

polarDecomposition((Matrix3)arg1) → tuple :

Alias for computeUnitaryPositive.

prod((Matrix3)arg1) → float :

Product of all elements.

pruned((Matrix3)arg1[, (float)absTol=1e-06]) → Matrix3 :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix3)arg1, (int)row) → Vector3 :

Return row as vector.

rows((Matrix3)arg1) → int :

Number of rows.

selfAdjointEigenDecomposition((Matrix3)arg1) → tuple :

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 :

Alias for selfAdjointEigenDecomposition.

squaredNorm((Matrix3)arg1) → float :

Square of the Euclidean norm.

sum((Matrix3)arg1) → float :

Sum of all elements.

svd((Matrix3)arg1) → tuple :

Alias for jacobiSVD.

trace((Matrix3)arg1) → float :

Return sum of diagonal elements.

transpose((Matrix3)arg1) → Matrix3 :

Return transposed matrix.

class yade._minieigenHP.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 :

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)
__init__((object)arg1) → None

__init__( (object)arg1, (Matrix3c)other) -> None

__init__( (object)arg1, (Vector3c)diag) -> object

__init__( (object)arg1, (complex)m00, (complex)m01, (complex)m02, (complex)m10, (complex)m11, (complex)m12, (complex)m20, (complex)m21, (complex)m22) -> object

__init__( (object)arg1, (Vector3c)r0, (Vector3c)r1, (Vector3c)r2 [, (bool)cols=False]) -> object

col((Matrix3c)arg1, (int)col) → Vector3c :

Return column as vector.

cols((Matrix3c)arg1) → int :

Number of columns.

determinant((Matrix3c)arg1) → complex :

Return matrix determinant.

diagonal((Matrix3c)arg1) → Vector3c :

Return diagonal as vector.

inverse((Matrix3c)arg1) → Matrix3c :

Return inverted matrix.

isApprox((Matrix3c)arg1, (Matrix3c)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Matrix3c)arg1) → float :

Maximum absolute value over all elements.

mean((Matrix3c)arg1) → complex :

Mean value over all elements.

norm((Matrix3c)arg1) → float :

Euclidean norm.

normalize((Matrix3c)arg1) → None :

Normalize this object in-place.

normalized((Matrix3c)arg1) → Matrix3c :

Return normalized copy of this object

prod((Matrix3c)arg1) → complex :

Product of all elements.

pruned((Matrix3c)arg1[, (float)absTol=1e-06]) → Matrix3c :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix3c)arg1, (int)row) → Vector3c :

Return row as vector.

rows((Matrix3c)arg1) → int :

Number of rows.

squaredNorm((Matrix3c)arg1) → float :

Square of the Euclidean norm.

sum((Matrix3c)arg1) → complex :

Sum of all elements.

trace((Matrix3c)arg1) → complex :

Return sum of diagonal elements.

transpose((Matrix3c)arg1) → Matrix3c :

Return transposed matrix.

class yade._minieigenHP.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 :

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) )
__init__((object)arg1) → None

__init__( (object)arg1, (Matrix6)other) -> None

__init__( (object)arg1, (Vector6)diag) -> object

__init__( (object)arg1, (Matrix3)ul, (Matrix3)ur, (Matrix3)ll, (Matrix3)lr) -> object

__init__( (object)arg1, (Vector6)l0, (Vector6)l1, (Vector6)l2, (Vector6)l3, (Vector6)l4, (Vector6)l5 [, (bool)cols=False]) -> object

col((Matrix6)arg1, (int)col) → Vector6 :

Return column as vector.

cols((Matrix6)arg1) → int :

Number of columns.

computeUnitaryPositive((Matrix6)arg1) → tuple :

Compute polar decomposition (unitary matrix U and positive semi-definite symmetric matrix P such that self=U*P).

determinant((Matrix6)arg1) → float :

Return matrix determinant.

diagonal((Matrix6)arg1) → Vector6 :

Return diagonal as vector.

inverse((Matrix6)arg1) → Matrix6 :

Return inverted matrix.

isApprox((Matrix6)arg1, (Matrix6)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

jacobiSVD((Matrix6)arg1) → tuple :

Compute SVD decomposition of square matrix, retuns (U,S,V) such that self=U*S*V.transpose()

ll((Matrix6)arg1) → Matrix3 :

Return lower-left 3x3 block

lr((Matrix6)arg1) → Matrix3 :

Return lower-right 3x3 block

maxAbsCoeff((Matrix6)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((Matrix6)arg1) → float :

Maximum value over all elements.

mean((Matrix6)arg1) → float :

Mean value over all elements.

minCoeff((Matrix6)arg1) → float :

Minimum value over all elements.

norm((Matrix6)arg1) → float :

Euclidean norm.

normalize((Matrix6)arg1) → None :

Normalize this object in-place.

normalized((Matrix6)arg1) → Matrix6 :

Return normalized copy of this object

polarDecomposition((Matrix6)arg1) → tuple :

Alias for computeUnitaryPositive.

prod((Matrix6)arg1) → float :

Product of all elements.

pruned((Matrix6)arg1[, (float)absTol=1e-06]) → Matrix6 :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix6)arg1, (int)row) → Vector6 :

Return row as vector.

rows((Matrix6)arg1) → int :

Number of rows.

selfAdjointEigenDecomposition((Matrix6)arg1) → tuple :

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 :

Alias for selfAdjointEigenDecomposition.

squaredNorm((Matrix6)arg1) → float :

Square of the Euclidean norm.

sum((Matrix6)arg1) → float :

Sum of all elements.

svd((Matrix6)arg1) → tuple :

Alias for jacobiSVD.

trace((Matrix6)arg1) → float :

Return sum of diagonal elements.

transpose((Matrix6)arg1) → Matrix6 :

Return transposed matrix.

ul((Matrix6)arg1) → Matrix3 :

Return upper-left 3x3 block

ur((Matrix6)arg1) → Matrix3 :

Return upper-right 3x3 block

class yade._minieigenHP.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 :

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) )
__init__((object)arg1) → None

__init__( (object)arg1, (Matrix6c)other) -> None

__init__( (object)arg1, (Vector6c)diag) -> object

__init__( (object)arg1, (Matrix3c)ul, (Matrix3c)ur, (Matrix3c)ll, (Matrix3c)lr) -> object

__init__( (object)arg1, (Vector6c)l0, (Vector6c)l1, (Vector6c)l2, (Vector6c)l3, (Vector6c)l4, (Vector6c)l5 [, (bool)cols=False]) -> object

col((Matrix6c)arg1, (int)col) → Vector6c :

Return column as vector.

cols((Matrix6c)arg1) → int :

Number of columns.

determinant((Matrix6c)arg1) → complex :

Return matrix determinant.

diagonal((Matrix6c)arg1) → Vector6c :

Return diagonal as vector.

inverse((Matrix6c)arg1) → Matrix6c :

Return inverted matrix.

isApprox((Matrix6c)arg1, (Matrix6c)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

ll((Matrix6c)arg1) → Matrix3c :

Return lower-left 3x3 block

lr((Matrix6c)arg1) → Matrix3c :

Return lower-right 3x3 block

maxAbsCoeff((Matrix6c)arg1) → float :

Maximum absolute value over all elements.

mean((Matrix6c)arg1) → complex :

Mean value over all elements.

norm((Matrix6c)arg1) → float :

Euclidean norm.

normalize((Matrix6c)arg1) → None :

Normalize this object in-place.

normalized((Matrix6c)arg1) → Matrix6c :

Return normalized copy of this object

prod((Matrix6c)arg1) → complex :

Product of all elements.

pruned((Matrix6c)arg1[, (float)absTol=1e-06]) → Matrix6c :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

row((Matrix6c)arg1, (int)row) → Vector6c :

Return row as vector.

rows((Matrix6c)arg1) → int :

Number of rows.

squaredNorm((Matrix6c)arg1) → float :

Square of the Euclidean norm.

sum((Matrix6c)arg1) → complex :

Sum of all elements.

trace((Matrix6c)arg1) → complex :

Return sum of diagonal elements.

transpose((Matrix6c)arg1) → Matrix6c :

Return transposed matrix.

ul((Matrix6c)arg1) → Matrix3c :

Return upper-left 3x3 block

ur((Matrix6c)arg1) → Matrix3c :

Return upper-right 3x3 block

class yade._minieigenHP.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 :

Create identity matrix with given rank (square).

static Ones((int)rows, (int)cols) → MatrixX :

Create matrix of given dimensions where all elements are set to 1.

static Random((int)rows, (int)cols) → MatrixX :

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 :

Create zero matrix of given dimensions

__init__((object)arg1) → None

__init__( (object)arg1, (MatrixX)other) -> None

__init__( (object)arg1, (VectorX)diag) -> object

__init__( (object)arg1 [, (VectorX)r0=VectorX() [, (VectorX)r1=VectorX() [, (VectorX)r2=VectorX() [, (VectorX)r3=VectorX() [, (VectorX)r4=VectorX() [, (VectorX)r5=VectorX() [, (VectorX)r6=VectorX() [, (VectorX)r7=VectorX() [, (VectorX)r8=VectorX() [, (VectorX)r9=VectorX() [, (bool)cols=False]]]]]]]]]]]) -> object

__init__( (object)arg1, (object)rows [, (bool)cols=False]) -> object

col((MatrixX)arg1, (int)col) → VectorX :

Return column as vector.

cols((MatrixX)arg1) → int :

Number of columns.

computeUnitaryPositive((MatrixX)arg1) → tuple :

Compute polar decomposition (unitary matrix U and positive semi-definite symmetric matrix P such that self=U*P).

determinant((MatrixX)arg1) → float :

Return matrix determinant.

diagonal((MatrixX)arg1) → VectorX :

Return diagonal as vector.

inverse((MatrixX)arg1) → MatrixX :

Return inverted matrix.

isApprox((MatrixX)arg1, (MatrixX)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

jacobiSVD((MatrixX)arg1) → tuple :

Compute SVD decomposition of square matrix, retuns (U,S,V) such that self=U*S*V.transpose()

maxAbsCoeff((MatrixX)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((MatrixX)arg1) → float :

Maximum value over all elements.

mean((MatrixX)arg1) → float :

Mean value over all elements.

minCoeff((MatrixX)arg1) → float :

Minimum value over all elements.

norm((MatrixX)arg1) → float :

Euclidean norm.

normalize((MatrixX)arg1) → None :

Normalize this object in-place.

normalized((MatrixX)arg1) → MatrixX :

Return normalized copy of this object

polarDecomposition((MatrixX)arg1) → tuple :

Alias for computeUnitaryPositive.

prod((MatrixX)arg1) → float :

Product of all elements.

pruned((MatrixX)arg1[, (float)absTol=1e-06]) → MatrixX :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((MatrixX)arg1, (int)rows, (int)cols) → None :

Change size of the matrix, keep values of elements which exist in the new matrix

row((MatrixX)arg1, (int)row) → VectorX :

Return row as vector.

rows((MatrixX)arg1) → int :

Number of rows.

selfAdjointEigenDecomposition((MatrixX)arg1) → tuple :

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 :

Alias for selfAdjointEigenDecomposition.

squaredNorm((MatrixX)arg1) → float :

Square of the Euclidean norm.

sum((MatrixX)arg1) → float :

Sum of all elements.

svd((MatrixX)arg1) → tuple :

Alias for jacobiSVD.

trace((MatrixX)arg1) → float :

Return sum of diagonal elements.

transpose((MatrixX)arg1) → MatrixX :

Return transposed matrix.

class yade._minieigenHP.MatrixXc

/TODO/

static Identity((int)arg1, (int)rank) → MatrixXc :

Create identity matrix with given rank (square).

static Ones((int)rows, (int)cols) → MatrixXc :

Create matrix of given dimensions where all elements are set to 1.

static Random((int)rows, (int)cols) → MatrixXc :

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 :

Create zero matrix of given dimensions

__init__((object)arg1) → None

__init__( (object)arg1, (MatrixXc)other) -> None

__init__( (object)arg1, (VectorXc)diag) -> object

__init__( (object)arg1 [, (VectorXc)r0=VectorXc() [, (VectorXc)r1=VectorXc() [, (VectorXc)r2=VectorXc() [, (VectorXc)r3=VectorXc() [, (VectorXc)r4=VectorXc() [, (VectorXc)r5=VectorXc() [, (VectorXc)r6=VectorXc() [, (VectorXc)r7=VectorXc() [, (VectorXc)r8=VectorXc() [, (VectorXc)r9=VectorXc() [, (bool)cols=False]]]]]]]]]]]) -> object

__init__( (object)arg1, (object)rows [, (bool)cols=False]) -> object

col((MatrixXc)arg1, (int)col) → VectorXc :

Return column as vector.

cols((MatrixXc)arg1) → int :

Number of columns.

determinant((MatrixXc)arg1) → complex :

Return matrix determinant.

diagonal((MatrixXc)arg1) → VectorXc :

Return diagonal as vector.

inverse((MatrixXc)arg1) → MatrixXc :

Return inverted matrix.

isApprox((MatrixXc)arg1, (MatrixXc)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((MatrixXc)arg1) → float :

Maximum absolute value over all elements.

mean((MatrixXc)arg1) → complex :

Mean value over all elements.

norm((MatrixXc)arg1) → float :

Euclidean norm.

normalize((MatrixXc)arg1) → None :

Normalize this object in-place.

normalized((MatrixXc)arg1) → MatrixXc :

Return normalized copy of this object

prod((MatrixXc)arg1) → complex :

Product of all elements.

pruned((MatrixXc)arg1[, (float)absTol=1e-06]) → MatrixXc :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((MatrixXc)arg1, (int)rows, (int)cols) → None :

Change size of the matrix, keep values of elements which exist in the new matrix

row((MatrixXc)arg1, (int)row) → VectorXc :

Return row as vector.

rows((MatrixXc)arg1) → int :

Number of rows.

squaredNorm((MatrixXc)arg1) → float :

Square of the Euclidean norm.

sum((MatrixXc)arg1) → complex :

Sum of all elements.

trace((MatrixXc)arg1) → complex :

Return sum of diagonal elements.

transpose((MatrixXc)arg1) → MatrixXc :

Return transposed matrix.

class yade._minieigenHP.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.

Note

Quaternion is represented as axis-angle when printed (e.g. Identity is Quaternion((1,0,0),0), and can also be constructed from the axis-angle representation. This is however different from the data stored inside, which can be accessed by indices [0] (\(x\)), [1] (\(y\)), [2] (\(z\)), [3] (\(w\)). To obtain axis-angle programatically, use Quaternion.toAxisAngle which returns the tuple.

Identity = Quaternion((1,0,0),0)
Rotate((Quaternion)arg1, (Vector3)v) → Vector3
__init__((object)arg1) → None

__init__( (object)arg1, (Vector3)axis, (float)angle) -> object

__init__( (object)arg1, (float)angle, (Vector3)axis) -> object

__init__( (object)arg1, (Vector3)u, (Vector3)v) -> object

__init__( (object)arg1, (float)w, (float)x, (float)y, (float)z) -> None :

Initialize from coefficients.

Note

The order of coefficients is w, x, y, z. The [] operator numbers them differently, 0…4 for x y z w!

__init__( (object)arg1, (Matrix3)rotMatrix) -> None

__init__( (object)arg1, (Quaternion)other) -> None

angularDistance((Quaternion)arg1, (Quaternion)arg2) → float
conjugate((Quaternion)arg1) → Quaternion
inverse((Quaternion)arg1) → Quaternion
norm((Quaternion)arg1) → float
normalize((Quaternion)arg1) → None
normalized((Quaternion)arg1) → Quaternion
setFromTwoVectors((Quaternion)arg1, (Vector3)u, (Vector3)v) → None
slerp((Quaternion)arg1, (float)t, (Quaternion)other) → Quaternion
toAngleAxis((Quaternion)arg1) → tuple
toAxisAngle((Quaternion)arg1) → tuple
toRotationMatrix((Quaternion)arg1) → Matrix3
toRotationVector((Quaternion)arg1) → Vector3
class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector2
UnitX = Vector2(1,0)
UnitY = Vector2(0,1)
Zero = Vector2(0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector2)other) -> None

__init__( (object)arg1, (float)x, (float)y) -> None

asDiagonal((Vector2)arg1) → object :

Return diagonal matrix with this vector on the diagonal.

cols((Vector2)arg1) → int :

Number of columns.

dot((Vector2)arg1, (Vector2)other) → float :

Dot product with other.

isApprox((Vector2)arg1, (Vector2)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector2)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((Vector2)arg1) → float :

Maximum value over all elements.

mean((Vector2)arg1) → float :

Mean value over all elements.

minCoeff((Vector2)arg1) → float :

Minimum value over all elements.

norm((Vector2)arg1) → float :

Euclidean norm.

normalize((Vector2)arg1) → None :

Normalize this object in-place.

normalized((Vector2)arg1) → Vector2 :

Return normalized copy of this object

outer((Vector2)arg1, (Vector2)other) → object :

Outer product with other.

prod((Vector2)arg1) → float :

Product of all elements.

pruned((Vector2)arg1[, (float)absTol=1e-06]) → Vector2 :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector2)arg1) → int :

Number of rows.

squaredNorm((Vector2)arg1) → float :

Square of the Euclidean norm.

sum((Vector2)arg1) → float :

Sum of all elements.

class yade._minieigenHP.Vector2c

/TODO/

Identity = Vector2c(1,0)
Ones = Vector2c(1,1)
static Random() → Vector2c :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector2c
UnitX = Vector2c(1,0)
UnitY = Vector2c(0,1)
Zero = Vector2c(0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector2c)other) -> None

__init__( (object)arg1, (complex)x, (complex)y) -> None

asDiagonal((Vector2c)arg1) → object :

Return diagonal matrix with this vector on the diagonal.

cols((Vector2c)arg1) → int :

Number of columns.

dot((Vector2c)arg1, (Vector2c)other) → complex :

Dot product with other.

isApprox((Vector2c)arg1, (Vector2c)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector2c)arg1) → float :

Maximum absolute value over all elements.

mean((Vector2c)arg1) → complex :

Mean value over all elements.

norm((Vector2c)arg1) → float :

Euclidean norm.

normalize((Vector2c)arg1) → None :

Normalize this object in-place.

normalized((Vector2c)arg1) → Vector2c :

Return normalized copy of this object

outer((Vector2c)arg1, (Vector2c)other) → object :

Outer product with other.

prod((Vector2c)arg1) → complex :

Product of all elements.

pruned((Vector2c)arg1[, (float)absTol=1e-06]) → Vector2c :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector2c)arg1) → int :

Number of rows.

squaredNorm((Vector2c)arg1) → float :

Square of the Euclidean norm.

sum((Vector2c)arg1) → complex :

Sum of all elements.

class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector2i
UnitX = Vector2i(1,0)
UnitY = Vector2i(0,1)
Zero = Vector2i(0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector2i)other) -> None

__init__( (object)arg1, (int)x, (int)y) -> None

asDiagonal((Vector2i)arg1) → object :

Return diagonal matrix with this vector on the diagonal.

cols((Vector2i)arg1) → int :

Number of columns.

dot((Vector2i)arg1, (Vector2i)other) → int :

Dot product with other.

isApprox((Vector2i)arg1, (Vector2i)other[, (int)prec=0]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector2i)arg1) → int :

Maximum absolute value over all elements.

maxCoeff((Vector2i)arg1) → int :

Maximum value over all elements.

mean((Vector2i)arg1) → int :

Mean value over all elements.

minCoeff((Vector2i)arg1) → int :

Minimum value over all elements.

outer((Vector2i)arg1, (Vector2i)other) → object :

Outer product with other.

prod((Vector2i)arg1) → int :

Product of all elements.

rows((Vector2i)arg1) → int :

Number of rows.

sum((Vector2i)arg1) → int :

Sum of all elements.

class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector3
UnitX = Vector3(1,0,0)
UnitY = Vector3(0,1,0)
UnitZ = Vector3(0,0,1)
Zero = Vector3(0,0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector3)other) -> None

__init__( (object)arg1 [, (float)x=0.0 [, (float)y=0.0 [, (float)z=0.0]]]) -> None

asDiagonal((Vector3)arg1) → Matrix3 :

Return diagonal matrix with this vector on the diagonal.

cols((Vector3)arg1) → int :

Number of columns.

cross((Vector3)arg1, (Vector3)arg2) → Vector3
dot((Vector3)arg1, (Vector3)other) → float :

Dot product with other.

isApprox((Vector3)arg1, (Vector3)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector3)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((Vector3)arg1) → float :

Maximum value over all elements.

mean((Vector3)arg1) → float :

Mean value over all elements.

minCoeff((Vector3)arg1) → float :

Minimum value over all elements.

norm((Vector3)arg1) → float :

Euclidean norm.

normalize((Vector3)arg1) → None :

Normalize this object in-place.

normalized((Vector3)arg1) → Vector3 :

Return normalized copy of this object

outer((Vector3)arg1, (Vector3)other) → Matrix3 :

Outer product with other.

prod((Vector3)arg1) → float :

Product of all elements.

pruned((Vector3)arg1[, (float)absTol=1e-06]) → Vector3 :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector3)arg1) → int :

Number of rows.

squaredNorm((Vector3)arg1) → float :

Square of the Euclidean norm.

sum((Vector3)arg1) → float :

Sum of all elements.

xy((Vector3)arg1) → Vector2
xz((Vector3)arg1) → Vector2
yx((Vector3)arg1) → Vector2
yz((Vector3)arg1) → Vector2
zx((Vector3)arg1) → Vector2
zy((Vector3)arg1) → Vector2
class yade._minieigenHP.Vector3c

/TODO/

Identity = Vector3c(1,0,0)
Ones = Vector3c(1,1,1)
static Random() → Vector3c :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector3c
UnitX = Vector3c(1,0,0)
UnitY = Vector3c(0,1,0)
UnitZ = Vector3c(0,0,1)
Zero = Vector3c(0,0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector3c)other) -> None

__init__( (object)arg1 [, (complex)x=0j [, (complex)y=0j [, (complex)z=0j]]]) -> None

asDiagonal((Vector3c)arg1) → Matrix3c :

Return diagonal matrix with this vector on the diagonal.

cols((Vector3c)arg1) → int :

Number of columns.

cross((Vector3c)arg1, (Vector3c)arg2) → Vector3c
dot((Vector3c)arg1, (Vector3c)other) → complex :

Dot product with other.

isApprox((Vector3c)arg1, (Vector3c)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector3c)arg1) → float :

Maximum absolute value over all elements.

mean((Vector3c)arg1) → complex :

Mean value over all elements.

norm((Vector3c)arg1) → float :

Euclidean norm.

normalize((Vector3c)arg1) → None :

Normalize this object in-place.

normalized((Vector3c)arg1) → Vector3c :

Return normalized copy of this object

outer((Vector3c)arg1, (Vector3c)other) → Matrix3c :

Outer product with other.

prod((Vector3c)arg1) → complex :

Product of all elements.

pruned((Vector3c)arg1[, (float)absTol=1e-06]) → Vector3c :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector3c)arg1) → int :

Number of rows.

squaredNorm((Vector3c)arg1) → float :

Square of the Euclidean norm.

sum((Vector3c)arg1) → complex :

Sum of all elements.

xy((Vector3c)arg1) → Vector2c
xz((Vector3c)arg1) → Vector2c
yx((Vector3c)arg1) → Vector2c
yz((Vector3c)arg1) → Vector2c
zx((Vector3c)arg1) → Vector2c
zy((Vector3c)arg1) → Vector2c
class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector3i
UnitX = Vector3i(1,0,0)
UnitY = Vector3i(0,1,0)
UnitZ = Vector3i(0,0,1)
Zero = Vector3i(0,0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector3i)other) -> None

__init__( (object)arg1 [, (int)x=0 [, (int)y=0 [, (int)z=0]]]) -> None

asDiagonal((Vector3i)arg1) → object :

Return diagonal matrix with this vector on the diagonal.

cols((Vector3i)arg1) → int :

Number of columns.

cross((Vector3i)arg1, (Vector3i)arg2) → Vector3i
dot((Vector3i)arg1, (Vector3i)other) → int :

Dot product with other.

isApprox((Vector3i)arg1, (Vector3i)other[, (int)prec=0]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector3i)arg1) → int :

Maximum absolute value over all elements.

maxCoeff((Vector3i)arg1) → int :

Maximum value over all elements.

mean((Vector3i)arg1) → int :

Mean value over all elements.

minCoeff((Vector3i)arg1) → int :

Minimum value over all elements.

outer((Vector3i)arg1, (Vector3i)other) → object :

Outer product with other.

prod((Vector3i)arg1) → int :

Product of all elements.

rows((Vector3i)arg1) → int :

Number of rows.

sum((Vector3i)arg1) → int :

Sum of all elements.

xy((Vector3i)arg1) → Vector2i
xz((Vector3i)arg1) → Vector2i
yx((Vector3i)arg1) → Vector2i
yz((Vector3i)arg1) → Vector2i
zx((Vector3i)arg1) → Vector2i
zy((Vector3i)arg1) → Vector2i
class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector4
Zero = Vector4(0,0,0, 0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector4)other) -> None

__init__( (object)arg1, (float)v0, (float)v1, (float)v2, (float)v3) -> None

asDiagonal((Vector4)arg1) → object :

Return diagonal matrix with this vector on the diagonal.

cols((Vector4)arg1) → int :

Number of columns.

dot((Vector4)arg1, (Vector4)other) → float :

Dot product with other.

isApprox((Vector4)arg1, (Vector4)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector4)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((Vector4)arg1) → float :

Maximum value over all elements.

mean((Vector4)arg1) → float :

Mean value over all elements.

minCoeff((Vector4)arg1) → float :

Minimum value over all elements.

norm((Vector4)arg1) → float :

Euclidean norm.

normalize((Vector4)arg1) → None :

Normalize this object in-place.

normalized((Vector4)arg1) → Vector4 :

Return normalized copy of this object

outer((Vector4)arg1, (Vector4)other) → object :

Outer product with other.

prod((Vector4)arg1) → float :

Product of all elements.

pruned((Vector4)arg1[, (float)absTol=1e-06]) → Vector4 :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector4)arg1) → int :

Number of rows.

squaredNorm((Vector4)arg1) → float :

Square of the Euclidean norm.

sum((Vector4)arg1) → float :

Sum of all elements.

class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector6
Zero = Vector6(0,0,0, 0,0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector6)other) -> None

__init__( (object)arg1, (float)v0, (float)v1, (float)v2, (float)v3, (float)v4, (float)v5) -> object

__init__( (object)arg1, (Vector3)head, (Vector3)tail) -> object

asDiagonal((Vector6)arg1) → Matrix6 :

Return diagonal matrix with this vector on the diagonal.

cols((Vector6)arg1) → int :

Number of columns.

dot((Vector6)arg1, (Vector6)other) → float :

Dot product with other.

head((Vector6)arg1) → Vector3
isApprox((Vector6)arg1, (Vector6)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector6)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((Vector6)arg1) → float :

Maximum value over all elements.

mean((Vector6)arg1) → float :

Mean value over all elements.

minCoeff((Vector6)arg1) → float :

Minimum value over all elements.

norm((Vector6)arg1) → float :

Euclidean norm.

normalize((Vector6)arg1) → None :

Normalize this object in-place.

normalized((Vector6)arg1) → Vector6 :

Return normalized copy of this object

outer((Vector6)arg1, (Vector6)other) → Matrix6 :

Outer product with other.

prod((Vector6)arg1) → float :

Product of all elements.

pruned((Vector6)arg1[, (float)absTol=1e-06]) → Vector6 :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector6)arg1) → int :

Number of rows.

squaredNorm((Vector6)arg1) → float :

Square of the Euclidean norm.

sum((Vector6)arg1) → float :

Sum of all elements.

tail((Vector6)arg1) → Vector3
class yade._minieigenHP.Vector6c

/TODO/

Identity = Vector6c(1,0,0, 0,0,0)
Ones = Vector6c(1,1,1, 1,1,1)
static Random() → Vector6c :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector6c
Zero = Vector6c(0,0,0, 0,0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector6c)other) -> None

__init__( (object)arg1, (complex)v0, (complex)v1, (complex)v2, (complex)v3, (complex)v4, (complex)v5) -> object

__init__( (object)arg1, (Vector3c)head, (Vector3c)tail) -> object

asDiagonal((Vector6c)arg1) → Matrix6c :

Return diagonal matrix with this vector on the diagonal.

cols((Vector6c)arg1) → int :

Number of columns.

dot((Vector6c)arg1, (Vector6c)other) → complex :

Dot product with other.

head((Vector6c)arg1) → Vector3c
isApprox((Vector6c)arg1, (Vector6c)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector6c)arg1) → float :

Maximum absolute value over all elements.

mean((Vector6c)arg1) → complex :

Mean value over all elements.

norm((Vector6c)arg1) → float :

Euclidean norm.

normalize((Vector6c)arg1) → None :

Normalize this object in-place.

normalized((Vector6c)arg1) → Vector6c :

Return normalized copy of this object

outer((Vector6c)arg1, (Vector6c)other) → Matrix6c :

Outer product with other.

prod((Vector6c)arg1) → complex :

Product of all elements.

pruned((Vector6c)arg1[, (float)absTol=1e-06]) → Vector6c :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

rows((Vector6c)arg1) → int :

Number of rows.

squaredNorm((Vector6c)arg1) → float :

Square of the Euclidean norm.

sum((Vector6c)arg1) → complex :

Sum of all elements.

tail((Vector6c)arg1) → Vector3c
class yade._minieigenHP.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 :

Return an object where all elements are randomly set to values between 0 and 1.

static Unit((int)arg1) → Vector6i
Zero = Vector6i(0,0,0, 0,0,0)
__init__((object)arg1) → None

__init__( (object)arg1, (Vector6i)other) -> None

__init__( (object)arg1, (int)v0, (int)v1, (int)v2, (int)v3, (int)v4, (int)v5) -> object

__init__( (object)arg1, (Vector3i)head, (Vector3i)tail) -> object

asDiagonal((Vector6i)arg1) → object :

Return diagonal matrix with this vector on the diagonal.

cols((Vector6i)arg1) → int :

Number of columns.

dot((Vector6i)arg1, (Vector6i)other) → int :

Dot product with other.

head((Vector6i)arg1) → Vector3i
isApprox((Vector6i)arg1, (Vector6i)other[, (int)prec=0]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((Vector6i)arg1) → int :

Maximum absolute value over all elements.

maxCoeff((Vector6i)arg1) → int :

Maximum value over all elements.

mean((Vector6i)arg1) → int :

Mean value over all elements.

minCoeff((Vector6i)arg1) → int :

Minimum value over all elements.

outer((Vector6i)arg1, (Vector6i)other) → object :

Outer product with other.

prod((Vector6i)arg1) → int :

Product of all elements.

rows((Vector6i)arg1) → int :

Number of rows.

sum((Vector6i)arg1) → int :

Sum of all elements.

tail((Vector6i)arg1) → Vector3i
class yade._minieigenHP.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 Random((int)len) → VectorX :

Return vector of given length with all elements set to values between 0 and 1 randomly.

static Unit((int)arg1, (int)arg2) → VectorX
static Zero((int)arg1) → VectorX
__init__((object)arg1) → None

__init__( (object)arg1, (VectorX)other) -> None

__init__( (object)arg1, (object)vv) -> object

asDiagonal((VectorX)arg1) → MatrixX :

Return diagonal matrix with this vector on the diagonal.

cols((VectorX)arg1) → int :

Number of columns.

dot((VectorX)arg1, (VectorX)other) → float :

Dot product with other.

isApprox((VectorX)arg1, (VectorX)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((VectorX)arg1) → float :

Maximum absolute value over all elements.

maxCoeff((VectorX)arg1) → float :

Maximum value over all elements.

mean((VectorX)arg1) → float :

Mean value over all elements.

minCoeff((VectorX)arg1) → float :

Minimum value over all elements.

norm((VectorX)arg1) → float :

Euclidean norm.

normalize((VectorX)arg1) → None :

Normalize this object in-place.

normalized((VectorX)arg1) → VectorX :

Return normalized copy of this object

outer((VectorX)arg1, (VectorX)other) → MatrixX :

Outer product with other.

prod((VectorX)arg1) → float :

Product of all elements.

pruned((VectorX)arg1[, (float)absTol=1e-06]) → VectorX :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((VectorX)arg1, (int)arg2) → None
rows((VectorX)arg1) → int :

Number of rows.

squaredNorm((VectorX)arg1) → float :

Square of the Euclidean norm.

sum((VectorX)arg1) → float :

Sum of all elements.

class yade._minieigenHP.VectorXc

/TODO/

static Ones((int)arg1) → VectorXc
static Random((int)len) → VectorXc :

Return vector of given length with all elements set to values between 0 and 1 randomly.

static Unit((int)arg1, (int)arg2) → VectorXc
static Zero((int)arg1) → VectorXc
__init__((object)arg1) → None

__init__( (object)arg1, (VectorXc)other) -> None

__init__( (object)arg1, (object)vv) -> object

asDiagonal((VectorXc)arg1) → MatrixXc :

Return diagonal matrix with this vector on the diagonal.

cols((VectorXc)arg1) → int :

Number of columns.

dot((VectorXc)arg1, (VectorXc)other) → complex :

Dot product with other.

isApprox((VectorXc)arg1, (VectorXc)other[, (float)prec=1e-12]) → bool :

Approximate comparison with precision prec.

maxAbsCoeff((VectorXc)arg1) → float :

Maximum absolute value over all elements.

mean((VectorXc)arg1) → complex :

Mean value over all elements.

norm((VectorXc)arg1) → float :

Euclidean norm.

normalize((VectorXc)arg1) → None :

Normalize this object in-place.

normalized((VectorXc)arg1) → VectorXc :

Return normalized copy of this object

outer((VectorXc)arg1, (VectorXc)other) → MatrixXc :

Outer product with other.

prod((VectorXc)arg1) → complex :

Product of all elements.

pruned((VectorXc)arg1[, (float)absTol=1e-06]) → VectorXc :

Zero all elements which are greater than absTol. Negative zeros are not pruned.

resize((VectorXc)arg1, (int)arg2) → None
rows((VectorXc)arg1) → int :

Number of rows.

squaredNorm((VectorXc)arg1) → float :

Square of the Euclidean norm.

sum((VectorXc)arg1) → complex :

Sum of all elements.

yade._minieigenHP.getEigenFlags() → dict
Returns:A python dictionary listing flags for all types, see: https://eigen.tuxfamily.org/dox/group__flags.html
yade._minieigenHP.getEigenStorageOrders() → dict
Returns:A python dictionary listing options for all types, see: https://eigen.tuxfamily.org/dox/group__TopicStorageOrders.html