\( \usepackage{euler} % must be loaded before fontspec for the whole doc (below); this must be kept for pngmath, however \usepackage{hyperref} \usepackage{amsmath} \usepackage{amsbsy} %\usepackage{mathabx} \usepackage{underscore} \usepackage[all]{xy} % Metadata of the pdf output \hypersetup{pdftitle={Yade Documentation}} \hypersetup{pdfauthor={Smilauer, V., et al.}} \hypersetup{pdfkeywords={Discrete element method, granular materials, contact law, hydromechanical coupling}} % symbols \renewcommand{\mat}{\boldsymbol} \renewcommand{\vec}{\boldsymbol} \renewcommand{\tens}{\boldsymbol} %normalized and locfram here \def\normalized#1{\widehat{#1}} \def\locframe#1{\widetilde{#1}} % timestep \def\Dt{\Delta t} \def\Dtcr{\Dt_{\rm cr}} % algorithm complexity \def\bigO#1{{\mathcal{O}(#1)}} % variants for greek symbols \let\epsilon\varepsilon \let\theta\vartheta \let\phi\varphi % shorthands \let\sig\sigma \let\eps\epsilon % variables at different points of time \def\prev#1{#1^-} \def\pprev#1{#1^\ominus} \def\curr#1{#1^{\circ}} \def\nnext#1{#1^\oplus} \def\next#1{#1^+} % shorthands for geometry \def\currn{\curr{\vec{n}}} \def\currC{\curr{\vec{C}}} \def\uT{\vec{u}_T} \def\curruT{\curr{\vec{u}}_T} \def\prevuT{\prev{\vec{u}}_T} \def\currn{\curr{\vec{n}}} \def\prevn{\prev{\vec{n}}} % motion \def\pprevvel{\pprev{\dot{\vec{u}}}} \def\nnextvel{\nnext{\dot{\vec{u}}}} \def\curraccel{\curr{\ddot{\vec{u}}}} \def\prevpos{\prev{\vec{u}}} \def\currpos{\curr{\vec{u}}} \def\nextpos{\next{\vec{u}}} \def\curraaccel{\curr{\dot{\vec{\omega}}}} \def\pprevangvel{\pprev{\vec{\omega}}} \def\nnextangvel{\nnext{\vec{\omega}}} \def\loccurr#1{\curr{\locframe{#1}}} \def\numCPU{n_{\rm cpu}} \DeclareMathOperator{\Align}{Align} \DeclareMathOperator{\sign}{sgn} % sorting algorithms \def\isleq#1{\currelem{#1}\ar@/^/[ll]^{\leq}} \def\isnleq#1{\currelem{#1}\ar@/^/[ll]^{\not\leq}} \def\currelem#1{\fbox{$#1$}} \def\sortSep{||} \def\sortInv{\hbox{\phantom{||}}} \def\sortlines#1{\xymatrix@=3pt{#1}} \def\crossBound{||\mkern-18mu<} \)

# 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`.

The `RealHP<n>` higher precision vectors and matrices can be accessed in python by using the `.HPn` module scope. For example:

    import yade.minieigenHP as mne
    mne.HP2.Vector3(1,2,3) # produces Vector3 using RealHP<2> precision
    mne.Vector3(1,2,3)     # without using HPn module scope it defaults to RealHP<1>

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
  property max

    None( (yade._minieigenHP.AlignedBox2)arg1) -> yade._minieigenHP.Vector2

  merged((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2
  property min

    None( (yade._minieigenHP.AlignedBox2)arg1) -> yade._minieigenHP.Vector2

  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
  property max

    None( (yade._minieigenHP.AlignedBox3)arg1) -> yade._minieigenHP.Vector3

  merged((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3
  property min

    None( (yade._minieigenHP.AlignedBox3)arg1) -> yade._minieigenHP.Vector3

  sizes((AlignedBox3)arg1) → Vector3
  volume((AlignedBox3)arg1) → float

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

      None( (yade._minieigenHP.AlignedBox2)arg1) -> yade._minieigenHP.Vector2

    merged((AlignedBox2)arg1, (AlignedBox2)arg2) → AlignedBox2
    property min

      None( (yade._minieigenHP.AlignedBox2)arg1) -> yade._minieigenHP.Vector2

    sizes((AlignedBox2)arg1) → Vector2
    volume((AlignedBox2)arg1) → float
  class 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
    property max

      None( (yade._minieigenHP.AlignedBox3)arg1) -> yade._minieigenHP.Vector3

    merged((AlignedBox3)arg1, (AlignedBox3)arg2) → AlignedBox3
    property min

      None( (yade._minieigenHP.AlignedBox3)arg1) -> yade._minieigenHP.Vector3

    sizes((AlignedBox3)arg1) → Vector3
    volume((AlignedBox3)arg1) → float
  Complex

    alias of `complex`

  class 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, (str)m00, (str)m01, (str)m02, (str)m10, (str)m11, (str)m12, (str)m20, (str)m21, (str)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 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, (str)m00, (str)m01, (str)m02, (str)m10, (str)m11, (str)m12, (str)m20, (str)m21, (str)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 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 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 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 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 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, (object)angle) -> object

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

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

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

      __init__( (object)arg1, (tuple)axis, (str)angle) -> object

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

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

      __init__( (object)arg1, (str)str1, (str)str2, (str)str3, (str)str4) -> 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
  Real

    alias of `float`

  class 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, (str)str1, (str)str2) -> object

      __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 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, (str)str1, (str)str2) -> object

      __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 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, (str)str1, (str)str2) -> object

      __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 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, (str)str1, (str)str2, (str)str3) -> object

      __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 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, (str)str1, (str)str2, (str)str3) -> object

      __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 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, (str)str1, (str)str2, (str)str3) -> object

      __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 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, (str)str1, (str)str2, (str)str3, (str)str4) -> object

      __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 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 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 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 ints.

    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 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 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.

  vectorize = False

class yade._minieigenHP.HP2
  class AlignedBox2

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

    __init__((object)arg1) → None

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

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

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

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

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

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

    intersection((HP2.AlignedBox2)arg1, (HP2.AlignedBox2)arg2) → HP2.AlignedBox2
    property max

      None( (yade._minieigenHP.HP2.AlignedBox2)arg1) -> yade._minieigenHP.HP2.Vector2

    merged((HP2.AlignedBox2)arg1, (HP2.AlignedBox2)arg2) → HP2.AlignedBox2
    property min

      None( (yade._minieigenHP.HP2.AlignedBox2)arg1) -> yade._minieigenHP.HP2.Vector2

    sizes((HP2.AlignedBox2)arg1) → HP2.Vector2
    volume((HP2.AlignedBox2)arg1) → HP2.Real
  class AlignedBox3

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

    __init__((object)arg1) → None

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

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

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

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

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

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

    intersection((HP2.AlignedBox3)arg1, (HP2.AlignedBox3)arg2) → HP2.AlignedBox3
    property max

      None( (yade._minieigenHP.HP2.AlignedBox3)arg1) -> yade._minieigenHP.HP2.Vector3

    merged((HP2.AlignedBox3)arg1, (HP2.AlignedBox3)arg2) → HP2.AlignedBox3
    property min

      None( (yade._minieigenHP.HP2.AlignedBox3)arg1) -> yade._minieigenHP.HP2.Vector3

    sizes((HP2.AlignedBox3)arg1) → HP2.Vector3
    volume((HP2.AlignedBox3)arg1) → HP2.Real
  class Complex

    The Complex type.

    __init__((object)arg1) → None

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

      __init__( (object)arg1, (complex)z) -> object

      __init__( (object)arg1, (float)d) -> object

      __init__( (object)arg1, (int)i) -> object

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

      __init__( (object)arg1, (object)re, (object)im) -> object

      __init__( (object)arg1, (float)a, (float)b) -> object

      __init__( (object)arg1, (int)i, (int)j) -> object

      __init__( (object)arg1, (str)str1, (str)str2) -> object

    property imag

      None( (yade._minieigenHP.HP2.Complex)arg1) -> object

    levelComplexHPMethod((HP2.Complex)arg1) → int
    property levelHP

      None( (yade._minieigenHP.HP2.Complex)arg1) -> int

    property real

      None( (yade._minieigenHP.HP2.Complex)arg1) -> object

  class 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() → HP2.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, (HP2.Quaternion)q) -> None

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

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

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

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

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

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

      Return column as vector.

    cols((HP2.Matrix3)arg1) → int :

      Number of columns.

    computeUnitaryPositive((HP2.Matrix3)arg1) → tuple :

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

    determinant((HP2.Matrix3)arg1) → HP2.Real :

      Return matrix determinant.

    diagonal((HP2.Matrix3)arg1) → HP2.Vector3 :

      Return diagonal as vector.

    inverse((HP2.Matrix3)arg1) → HP2.Matrix3 :

      Return inverted matrix.

    isApprox((HP2.Matrix3)arg1, (HP2.Matrix3)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    jacobiSVD((HP2.Matrix3)arg1) → tuple :

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

    maxAbsCoeff((HP2.Matrix3)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.Matrix3)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.Matrix3)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.Matrix3)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.Matrix3)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Matrix3)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Matrix3)arg1) → HP2.Matrix3 :

      Return normalized copy of this object

    polarDecomposition((HP2.Matrix3)arg1) → tuple :

      Alias for `computeUnitaryPositive`.

    prod((HP2.Matrix3)arg1) → HP2.Real :

      Product of all elements.

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

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

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

      Return row as vector.

    rows((HP2.Matrix3)arg1) → int :

      Number of rows.

    selfAdjointEigenDecomposition((HP2.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((HP2.Matrix3)arg1) → tuple :

      Alias for `selfAdjointEigenDecomposition`.

    squaredNorm((HP2.Matrix3)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Matrix3)arg1) → HP2.Real :

      Sum of all elements.

    svd((HP2.Matrix3)arg1) → tuple :

      Alias for `jacobiSVD`.

    trace((HP2.Matrix3)arg1) → HP2.Real :

      Return sum of diagonal elements.

    transpose((HP2.Matrix3)arg1) → HP2.Matrix3 :

      Return transposed matrix.

  class Matrix3c

    /TODO/

    Identity = Matrix3c(Complex("1","0"),Complex("0","0"),Complex("0","0"), Complex("0","0"),Complex("1","0"),Complex("0","0"), Complex("0","0"),Complex("0","0"),Complex("1","0"))
    Ones = Matrix3c(Complex("1","0"),Complex("1","0"),Complex("1","0"), Complex("1","0"),Complex("1","0"),Complex("1","0"), Complex("1","0"),Complex("1","0"),Complex("1","0"))
    static Random() → HP2.Matrix3c :

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

    Zero = Matrix3c(Complex("0","0"),Complex("0","0"),Complex("0","0"), Complex("0","0"),Complex("0","0"),Complex("0","0"), Complex("0","0"),Complex("0","0"),Complex("0","0"))
    __init__((object)arg1) → None

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

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

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

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

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

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

      Return column as vector.

    cols((HP2.Matrix3c)arg1) → int :

      Number of columns.

    determinant((HP2.Matrix3c)arg1) → HP2.Complex :

      Return matrix determinant.

    diagonal((HP2.Matrix3c)arg1) → HP2.Vector3c :

      Return diagonal as vector.

    inverse((HP2.Matrix3c)arg1) → HP2.Matrix3c :

      Return inverted matrix.

    isApprox((HP2.Matrix3c)arg1, (HP2.Matrix3c)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Matrix3c)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.Matrix3c)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.Matrix3c)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Matrix3c)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Matrix3c)arg1) → HP2.Matrix3c :

      Return normalized copy of this object

    prod((HP2.Matrix3c)arg1) → HP2.Complex :

      Product of all elements.

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

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

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

      Return row as vector.

    rows((HP2.Matrix3c)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Matrix3c)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Matrix3c)arg1) → HP2.Complex :

      Sum of all elements.

    trace((HP2.Matrix3c)arg1) → HP2.Complex :

      Return sum of diagonal elements.

    transpose((HP2.Matrix3c)arg1) → HP2.Matrix3c :

      Return transposed matrix.

  class 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() → HP2.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, (HP2.Matrix6)other) -> None

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

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

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

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

      Return column as vector.

    cols((HP2.Matrix6)arg1) → int :

      Number of columns.

    computeUnitaryPositive((HP2.Matrix6)arg1) → tuple :

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

    determinant((HP2.Matrix6)arg1) → HP2.Real :

      Return matrix determinant.

    diagonal((HP2.Matrix6)arg1) → HP2.Vector6 :

      Return diagonal as vector.

    inverse((HP2.Matrix6)arg1) → HP2.Matrix6 :

      Return inverted matrix.

    isApprox((HP2.Matrix6)arg1, (HP2.Matrix6)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    jacobiSVD((HP2.Matrix6)arg1) → tuple :

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

    ll((HP2.Matrix6)arg1) → HP2.Matrix3 :

      Return lower-left 3x3 block

    lr((HP2.Matrix6)arg1) → HP2.Matrix3 :

      Return lower-right 3x3 block

    maxAbsCoeff((HP2.Matrix6)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.Matrix6)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.Matrix6)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.Matrix6)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.Matrix6)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Matrix6)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Matrix6)arg1) → HP2.Matrix6 :

      Return normalized copy of this object

    polarDecomposition((HP2.Matrix6)arg1) → tuple :

      Alias for `computeUnitaryPositive`.

    prod((HP2.Matrix6)arg1) → HP2.Real :

      Product of all elements.

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

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

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

      Return row as vector.

    rows((HP2.Matrix6)arg1) → int :

      Number of rows.

    selfAdjointEigenDecomposition((HP2.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((HP2.Matrix6)arg1) → tuple :

      Alias for `selfAdjointEigenDecomposition`.

    squaredNorm((HP2.Matrix6)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Matrix6)arg1) → HP2.Real :

      Sum of all elements.

    svd((HP2.Matrix6)arg1) → tuple :

      Alias for `jacobiSVD`.

    trace((HP2.Matrix6)arg1) → HP2.Real :

      Return sum of diagonal elements.

    transpose((HP2.Matrix6)arg1) → HP2.Matrix6 :

      Return transposed matrix.

    ul((HP2.Matrix6)arg1) → HP2.Matrix3 :

      Return upper-left 3x3 block

    ur((HP2.Matrix6)arg1) → HP2.Matrix3 :

      Return upper-right 3x3 block

  class Matrix6c

    /TODO/

    Identity = Matrix6c( (Complex("1","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("1","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("1","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("1","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("1","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("1","0")) )
    Ones = Matrix6c( (Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0")), (Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0")), (Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0")), (Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0")), (Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0")), (Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0"),Complex("1","0")) )
    static Random() → HP2.Matrix6c :

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

    Zero = Matrix6c( (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")), (Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0"),Complex("0","0")) )
    __init__((object)arg1) → None

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

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

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

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

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

      Return column as vector.

    cols((HP2.Matrix6c)arg1) → int :

      Number of columns.

    determinant((HP2.Matrix6c)arg1) → HP2.Complex :

      Return matrix determinant.

    diagonal((HP2.Matrix6c)arg1) → HP2.Vector6c :

      Return diagonal as vector.

    inverse((HP2.Matrix6c)arg1) → HP2.Matrix6c :

      Return inverted matrix.

    isApprox((HP2.Matrix6c)arg1, (HP2.Matrix6c)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    ll((HP2.Matrix6c)arg1) → HP2.Matrix3c :

      Return lower-left 3x3 block

    lr((HP2.Matrix6c)arg1) → HP2.Matrix3c :

      Return lower-right 3x3 block

    maxAbsCoeff((HP2.Matrix6c)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.Matrix6c)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.Matrix6c)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Matrix6c)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Matrix6c)arg1) → HP2.Matrix6c :

      Return normalized copy of this object

    prod((HP2.Matrix6c)arg1) → HP2.Complex :

      Product of all elements.

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

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

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

      Return row as vector.

    rows((HP2.Matrix6c)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Matrix6c)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Matrix6c)arg1) → HP2.Complex :

      Sum of all elements.

    trace((HP2.Matrix6c)arg1) → HP2.Complex :

      Return sum of diagonal elements.

    transpose((HP2.Matrix6c)arg1) → HP2.Matrix6c :

      Return transposed matrix.

    ul((HP2.Matrix6c)arg1) → HP2.Matrix3c :

      Return upper-left 3x3 block

    ur((HP2.Matrix6c)arg1) → HP2.Matrix3c :

      Return upper-right 3x3 block

  class 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) → HP2.MatrixX :

      Create identity matrix with given rank (square).

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

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

    static Random((int)rows, (int)cols) → HP2.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) → HP2.MatrixX :

      Create zero matrix of given dimensions

    __init__((object)arg1) → None

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

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

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

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

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

      Return column as vector.

    cols((HP2.MatrixX)arg1) → int :

      Number of columns.

    computeUnitaryPositive((HP2.MatrixX)arg1) → tuple :

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

    determinant((HP2.MatrixX)arg1) → HP2.Real :

      Return matrix determinant.

    diagonal((HP2.MatrixX)arg1) → HP2.VectorX :

      Return diagonal as vector.

    inverse((HP2.MatrixX)arg1) → HP2.MatrixX :

      Return inverted matrix.

    isApprox((HP2.MatrixX)arg1, (HP2.MatrixX)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    jacobiSVD((HP2.MatrixX)arg1) → tuple :

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

    maxAbsCoeff((HP2.MatrixX)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.MatrixX)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.MatrixX)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.MatrixX)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.MatrixX)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.MatrixX)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.MatrixX)arg1) → HP2.MatrixX :

      Return normalized copy of this object

    polarDecomposition((HP2.MatrixX)arg1) → tuple :

      Alias for `computeUnitaryPositive`.

    prod((HP2.MatrixX)arg1) → HP2.Real :

      Product of all elements.

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

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

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

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

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

      Return row as vector.

    rows((HP2.MatrixX)arg1) → int :

      Number of rows.

    selfAdjointEigenDecomposition((HP2.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((HP2.MatrixX)arg1) → tuple :

      Alias for `selfAdjointEigenDecomposition`.

    squaredNorm((HP2.MatrixX)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.MatrixX)arg1) → HP2.Real :

      Sum of all elements.

    svd((HP2.MatrixX)arg1) → tuple :

      Alias for `jacobiSVD`.

    trace((HP2.MatrixX)arg1) → HP2.Real :

      Return sum of diagonal elements.

    transpose((HP2.MatrixX)arg1) → HP2.MatrixX :

      Return transposed matrix.

  class MatrixXc

    /TODO/

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

      Create identity matrix with given rank (square).

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

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

    static Random((int)rows, (int)cols) → HP2.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) → HP2.MatrixXc :

      Create zero matrix of given dimensions

    __init__((object)arg1) → None

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

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

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

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

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

      Return column as vector.

    cols((HP2.MatrixXc)arg1) → int :

      Number of columns.

    determinant((HP2.MatrixXc)arg1) → HP2.Complex :

      Return matrix determinant.

    diagonal((HP2.MatrixXc)arg1) → HP2.VectorXc :

      Return diagonal as vector.

    inverse((HP2.MatrixXc)arg1) → HP2.MatrixXc :

      Return inverted matrix.

    isApprox((HP2.MatrixXc)arg1, (HP2.MatrixXc)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.MatrixXc)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.MatrixXc)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.MatrixXc)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.MatrixXc)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.MatrixXc)arg1) → HP2.MatrixXc :

      Return normalized copy of this object

    prod((HP2.MatrixXc)arg1) → HP2.Complex :

      Product of all elements.

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

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

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

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

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

      Return row as vector.

    rows((HP2.MatrixXc)arg1) → int :

      Number of rows.

    squaredNorm((HP2.MatrixXc)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.MatrixXc)arg1) → HP2.Complex :

      Sum of all elements.

    trace((HP2.MatrixXc)arg1) → HP2.Complex :

      Return sum of diagonal elements.

    transpose((HP2.MatrixXc)arg1) → HP2.MatrixXc :

      Return transposed matrix.

  class 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((HP2.Quaternion)arg1, (HP2.Vector3)v) → HP2.Vector3
    __init__((object)arg1) → None

      __init__( (object)arg1, (HP2.Vector3)axis, (object)angle) -> object

      __init__( (object)arg1, (HP2.Vector3)axis, (HP2.Real)angle) -> object

      __init__( (object)arg1, (object)angle, (HP2.Vector3)axis) -> object

      __init__( (object)arg1, (HP2.Real)angle, (HP2.Vector3)axis) -> object

      __init__( (object)arg1, (tuple)axis, (str)angle) -> object

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

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

      __init__( (object)arg1, (str)str1, (str)str2, (str)str3, (str)str4) -> object

      __init__( (object)arg1, (HP2.Real)w, (HP2.Real)x, (HP2.Real)y, (HP2.Real)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, (HP2.Matrix3)rotMatrix) -> None

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

      __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!

    angularDistance((HP2.Quaternion)arg1, (HP2.Quaternion)arg2) → HP2.Real
    conjugate((HP2.Quaternion)arg1) → HP2.Quaternion
    inverse((HP2.Quaternion)arg1) → HP2.Quaternion
    norm((HP2.Quaternion)arg1) → HP2.Real
    normalize((HP2.Quaternion)arg1) → None
    normalized((HP2.Quaternion)arg1) → HP2.Quaternion
    setFromTwoVectors((HP2.Quaternion)arg1, (HP2.Vector3)u, (HP2.Vector3)v) → None
    slerp((HP2.Quaternion)arg1, (HP2.Real)t, (HP2.Quaternion)other) → HP2.Quaternion
    toAngleAxis((HP2.Quaternion)arg1) → tuple
    toAxisAngle((HP2.Quaternion)arg1) → tuple
    toRotationMatrix((HP2.Quaternion)arg1) → HP2.Matrix3
    toRotationVector((HP2.Quaternion)arg1) → HP2.Vector3
  class Real

    The Real type.

    __init__((object)arg1) → None

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

      __init__( (object)arg1, (float)d) -> object

      __init__( (object)arg1, (int)i) -> object

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

    property imag

      None( (yade._minieigenHP.HP2.Real)arg1) -> yade._minieigenHP.HP2.Real

    property levelHP

      None( (yade._minieigenHP.HP2.Real)arg1) -> int

    levelRealHPMethod((HP2.Real)arg1) → int
    property real

      None( (yade._minieigenHP.HP2.Real)arg1) -> yade._minieigenHP.HP2.Real

    sqrt((HP2.Real)arg1) → HP2.Real
  class 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() → HP2.Vector2 :

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

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

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

      __init__( (object)arg1, (str)str1, (str)str2) -> object

      __init__( (object)arg1, (HP2.Real)x, (HP2.Real)y) -> None

    asDiagonal((HP2.Vector2)arg1) → object :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector2)arg1) → int :

      Number of columns.

    dot((HP2.Vector2)arg1, (HP2.Vector2)other) → HP2.Real :

      Dot product with other.

    isApprox((HP2.Vector2)arg1, (HP2.Vector2)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector2)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.Vector2)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.Vector2)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.Vector2)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.Vector2)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector2)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector2)arg1) → HP2.Vector2 :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector2)arg1) → HP2.Real :

      Product of all elements.

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

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

    rows((HP2.Vector2)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector2)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector2)arg1) → HP2.Real :

      Sum of all elements.

  class Vector2c

    /TODO/

    Identity = Vector2c(Complex("1","0"),Complex("0","0"))
    Ones = Vector2c(Complex("1","0"),Complex("1","0"))
    static Random() → HP2.Vector2c :

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

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

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

      __init__( (object)arg1, (str)str1, (str)str2) -> object

      __init__( (object)arg1, (HP2.Complex)x, (HP2.Complex)y) -> None

    asDiagonal((HP2.Vector2c)arg1) → object :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector2c)arg1) → int :

      Number of columns.

    dot((HP2.Vector2c)arg1, (HP2.Vector2c)other) → HP2.Complex :

      Dot product with other.

    isApprox((HP2.Vector2c)arg1, (HP2.Vector2c)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector2c)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.Vector2c)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.Vector2c)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector2c)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector2c)arg1) → HP2.Vector2c :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector2c)arg1) → HP2.Complex :

      Product of all elements.

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

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

    rows((HP2.Vector2c)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector2c)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector2c)arg1) → HP2.Complex :

      Sum of all elements.

  class 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, (str)str1, (str)str2) -> object

      __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 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() → HP2.Vector3 :

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

    static Unit((int)arg1) → HP2.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, (HP2.Vector3)other) -> None

      __init__( (object)arg1, (str)str1, (str)str2, (str)str3) -> object

      __init__( (object)arg1 [, (HP2.Real)x=Real(“0”) [, (HP2.Real)y=Real(“0”) [, (HP2.Real)z=Real(“0”)]]]) -> None

    asDiagonal((HP2.Vector3)arg1) → HP2.Matrix3 :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector3)arg1) → int :

      Number of columns.

    cross((HP2.Vector3)arg1, (HP2.Vector3)arg2) → HP2.Vector3
    dot((HP2.Vector3)arg1, (HP2.Vector3)other) → HP2.Real :

      Dot product with other.

    isApprox((HP2.Vector3)arg1, (HP2.Vector3)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector3)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.Vector3)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.Vector3)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.Vector3)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.Vector3)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector3)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector3)arg1) → HP2.Vector3 :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector3)arg1) → HP2.Real :

      Product of all elements.

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

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

    rows((HP2.Vector3)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector3)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector3)arg1) → HP2.Real :

      Sum of all elements.

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

    /TODO/

    Identity = Vector3c(Complex("1","0"),Complex("0","0"),Complex("0","0"))
    Ones = Vector3c(Complex("1","0"),Complex("1","0"),Complex("1","0"))
    static Random() → HP2.Vector3c :

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

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

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

      __init__( (object)arg1, (str)str1, (str)str2, (str)str3) -> object

      __init__( (object)arg1 [, (HP2.Complex)x=Complex(“0”,”0”) [, (HP2.Complex)y=Complex(“0”,”0”) [, (HP2.Complex)z=Complex(“0”,”0”)]]]) -> None

    asDiagonal((HP2.Vector3c)arg1) → HP2.Matrix3c :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector3c)arg1) → int :

      Number of columns.

    cross((HP2.Vector3c)arg1, (HP2.Vector3c)arg2) → HP2.Vector3c
    dot((HP2.Vector3c)arg1, (HP2.Vector3c)other) → HP2.Complex :

      Dot product with other.

    isApprox((HP2.Vector3c)arg1, (HP2.Vector3c)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector3c)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.Vector3c)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.Vector3c)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector3c)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector3c)arg1) → HP2.Vector3c :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector3c)arg1) → HP2.Complex :

      Product of all elements.

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

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

    rows((HP2.Vector3c)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector3c)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector3c)arg1) → HP2.Complex :

      Sum of all elements.

    xy((HP2.Vector3c)arg1) → HP2.Vector2c
    xz((HP2.Vector3c)arg1) → HP2.Vector2c
    yx((HP2.Vector3c)arg1) → HP2.Vector2c
    yz((HP2.Vector3c)arg1) → HP2.Vector2c
    zx((HP2.Vector3c)arg1) → HP2.Vector2c
    zy((HP2.Vector3c)arg1) → HP2.Vector2c
  class 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, (str)str1, (str)str2, (str)str3) -> object

      __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 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() → HP2.Vector4 :

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

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

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

      __init__( (object)arg1, (str)str1, (str)str2, (str)str3, (str)str4) -> object

      __init__( (object)arg1, (HP2.Real)v0, (HP2.Real)v1, (HP2.Real)v2, (HP2.Real)v3) -> None

    asDiagonal((HP2.Vector4)arg1) → object :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector4)arg1) → int :

      Number of columns.

    dot((HP2.Vector4)arg1, (HP2.Vector4)other) → HP2.Real :

      Dot product with other.

    isApprox((HP2.Vector4)arg1, (HP2.Vector4)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector4)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.Vector4)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.Vector4)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.Vector4)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.Vector4)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector4)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector4)arg1) → HP2.Vector4 :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector4)arg1) → HP2.Real :

      Product of all elements.

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

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

    rows((HP2.Vector4)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector4)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector4)arg1) → HP2.Real :

      Sum of all elements.

  class 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() → HP2.Vector6 :

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

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

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

      __init__( (object)arg1, (HP2.Real)v0, (HP2.Real)v1, (HP2.Real)v2, (HP2.Real)v3, (HP2.Real)v4, (HP2.Real)v5) -> object

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

    asDiagonal((HP2.Vector6)arg1) → HP2.Matrix6 :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector6)arg1) → int :

      Number of columns.

    dot((HP2.Vector6)arg1, (HP2.Vector6)other) → HP2.Real :

      Dot product with other.

    head((HP2.Vector6)arg1) → HP2.Vector3
    isApprox((HP2.Vector6)arg1, (HP2.Vector6)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector6)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.Vector6)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.Vector6)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.Vector6)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.Vector6)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector6)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector6)arg1) → HP2.Vector6 :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector6)arg1) → HP2.Real :

      Product of all elements.

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

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

    rows((HP2.Vector6)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector6)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector6)arg1) → HP2.Real :

      Sum of all elements.

    tail((HP2.Vector6)arg1) → HP2.Vector3
  class Vector6c

    /TODO/

    Identity = Vector6c(Complex("1","0"),Complex("0","0"),Complex("0","0"), Complex("0","0"),Complex("0","0"),Complex("0","0"))
    Ones = Vector6c(Complex("1","0"),Complex("1","0"),Complex("1","0"), Complex("1","0"),Complex("1","0"),Complex("1","0"))
    static Random() → HP2.Vector6c :

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

    static Unit((int)arg1) → HP2.Vector6c
    Zero = Vector6c(Complex("0","0"),Complex("0","0"),Complex("0","0"), Complex("0","0"),Complex("0","0"),Complex("0","0"))
    __init__((object)arg1) → None

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

      __init__( (object)arg1, (HP2.Complex)v0, (HP2.Complex)v1, (HP2.Complex)v2, (HP2.Complex)v3, (HP2.Complex)v4, (HP2.Complex)v5) -> object

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

    asDiagonal((HP2.Vector6c)arg1) → HP2.Matrix6c :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.Vector6c)arg1) → int :

      Number of columns.

    dot((HP2.Vector6c)arg1, (HP2.Vector6c)other) → HP2.Complex :

      Dot product with other.

    head((HP2.Vector6c)arg1) → HP2.Vector3c
    isApprox((HP2.Vector6c)arg1, (HP2.Vector6c)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.Vector6c)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.Vector6c)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.Vector6c)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.Vector6c)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.Vector6c)arg1) → HP2.Vector6c :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.Vector6c)arg1) → HP2.Complex :

      Product of all elements.

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

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

    rows((HP2.Vector6c)arg1) → int :

      Number of rows.

    squaredNorm((HP2.Vector6c)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.Vector6c)arg1) → HP2.Complex :

      Sum of all elements.

    tail((HP2.Vector6c)arg1) → HP2.Vector3c
  class 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 ints.

    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 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) → HP2.VectorX
    static Random((int)len) → HP2.VectorX :

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

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

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

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

    asDiagonal((HP2.VectorX)arg1) → HP2.MatrixX :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.VectorX)arg1) → int :

      Number of columns.

    dot((HP2.VectorX)arg1, (HP2.VectorX)other) → HP2.Real :

      Dot product with other.

    isApprox((HP2.VectorX)arg1, (HP2.VectorX)other[, (HP2.Real)prec=Real("3.842735439305961756982896186698285364e-31")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.VectorX)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    maxCoeff((HP2.VectorX)arg1) → HP2.Real :

      Maximum value over all elements.

    mean((HP2.VectorX)arg1) → HP2.Real :

      Mean value over all elements.

    minCoeff((HP2.VectorX)arg1) → HP2.Real :

      Minimum value over all elements.

    norm((HP2.VectorX)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.VectorX)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.VectorX)arg1) → HP2.VectorX :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.VectorX)arg1) → HP2.Real :

      Product of all elements.

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

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

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

      Number of rows.

    squaredNorm((HP2.VectorX)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.VectorX)arg1) → HP2.Real :

      Sum of all elements.

  class VectorXc

    /TODO/

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

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

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

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

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

    asDiagonal((HP2.VectorXc)arg1) → HP2.MatrixXc :

      Return diagonal matrix with this vector on the diagonal.

    cols((HP2.VectorXc)arg1) → int :

      Number of columns.

    dot((HP2.VectorXc)arg1, (HP2.VectorXc)other) → HP2.Complex :

      Dot product with other.

    isApprox((HP2.VectorXc)arg1, (HP2.VectorXc)other[, (HP2.Real)prec=Complex("3.842735439305961756982896186698285364e-31", "0")]) → bool :

      Approximate comparison with precision prec.

    maxAbsCoeff((HP2.VectorXc)arg1) → HP2.Real :

      Maximum absolute value over all elements.

    mean((HP2.VectorXc)arg1) → HP2.Complex :

      Mean value over all elements.

    norm((HP2.VectorXc)arg1) → HP2.Real :

      Euclidean norm.

    normalize((HP2.VectorXc)arg1) → None :

      Normalize this object in-place.

    normalized((HP2.VectorXc)arg1) → HP2.VectorXc :

      Return normalized copy of this object

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

      Outer product with other.

    prod((HP2.VectorXc)arg1) → HP2.Complex :

      Product of all elements.

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

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

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

      Number of rows.

    squaredNorm((HP2.VectorXc)arg1) → HP2.Real :

      Square of the Euclidean norm.

    sum((HP2.VectorXc)arg1) → HP2.Complex :

      Sum of all elements.

  vectorize = False

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, (str)m00, (str)m01, (str)m02, (str)m10, (str)m11, (str)m12, (str)m20, (str)m21, (str)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, (str)m00, (str)m01, (str)m02, (str)m10, (str)m11, (str)m12, (str)m20, (str)m21, (str)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, (object)angle) -> object

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

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

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

    __init__( (object)arg1, (tuple)axis, (str)angle) -> object

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

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

    __init__( (object)arg1, (str)str1, (str)str2, (str)str3, (str)str4) -> 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, (str)str1, (str)str2) -> object

    __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, (str)str1, (str)str2) -> object

    __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, (str)str1, (str)str2) -> object

    __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, (str)str1, (str)str2, (str)str3) -> object

    __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, (str)str1, (str)str2, (str)str3) -> object

    __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, (str)str1, (str)str2, (str)str3) -> object

    __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, (str)str1, (str)str2, (str)str3, (str)str4) -> object

    __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 ints.

  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.