SimpleMatrix.hpp#

Return to documentation for this file
#ifndef __SimpleMatrix__
#define __SimpleMatrix__

#include <iosfwd>
#include "SiconosSerialization.hpp"
#include "SiconosVisitor.hpp"
#include "SiconosAlgebraTypeDef.hpp"
#include "SiconosFwd.hpp"
#include "SiconosMatrix.hpp"
#include "SiconosVector.hpp"

class BlockVector;

class SimpleMatrix: public SiconosMatrix
{
protected:
  ACCEPT_SERIALIZATION(SimpleMatrix);

  MATRIX_UBLAS_TYPE mat;

private:

  SP::VInt _ipiv;

  bool _isPLUFactorized = false;

  bool _isPLUFactorizedInPlace = false;

  bool _isCholeskyFactorized = false;

  bool _isCholeskyFactorizedInPlace = false;

  bool _isQRFactorized = false;

  bool _isPLUInversed = false;

  SP::NumericsMatrix _numericsMatrix;

  void private_prod(unsigned int startRow, const SiconosVector& x, SiconosVector& y, bool init);

  void private_addprod(unsigned int startRow, unsigned int startCol, const SiconosVector& x, SiconosVector& res);

public:

  SimpleMatrix();

  SimpleMatrix(unsigned int row, unsigned int col, Siconos::UBLAS_TYPE typ = Siconos::DENSE, unsigned int upper = 1, unsigned int lower = 1);

  SimpleMatrix(unsigned int row, unsigned int col, double inputValue,
               Siconos::UBLAS_TYPE typ = Siconos::DENSE,
               unsigned int upper = 1, unsigned int lower = 1);

  SimpleMatrix(const SimpleMatrix& smat);

  SimpleMatrix(const SimpleMatrix& A , const Index& coord );

  SimpleMatrix(const SiconosMatrix& m);

  SimpleMatrix(const DenseMat& m);

  SimpleMatrix(const TriangMat& m);

  SimpleMatrix(const SymMat& m);

  SimpleMatrix(const BandedMat& m);

  SimpleMatrix(const SparseMat& m);

  SimpleMatrix(const SparseCoordinateMat& m);

  SimpleMatrix(const ZeroMat& m);

  SimpleMatrix(const IdentityMat& m);

  SimpleMatrix(const std::string& file, bool ascii = true);

  ~SimpleMatrix();

  void updateNumericsMatrix() override;

  NumericsMatrix * numericsMatrix() const override
  {
    return _numericsMatrix.get();
  };

  inline bool isPLUInversed() const override
  {
    return _isPLUInversed;
  }

  inline bool isPLUFactorized() const override
  {
    return _isPLUFactorized;
  }

  inline bool isPLUFactorizedInPlace() const override
  {
    return _isPLUFactorizedInPlace;
  }

  inline bool isCholeskyFactorized() const override
  {
    return _isCholeskyFactorized;
  }

  inline bool isCholeskyFactorizedInPlace() const
  {
    return _isCholeskyFactorizedInPlace;
  }

  inline bool isQRFactorized() const
  {
    return _isQRFactorized;
  }

  inline SP::VInt ipiv() const override
  {
    return _ipiv;
  }

  bool checkSymmetry(double tol) const override;

  const DenseMat getDense(unsigned int row = 0, unsigned int col = 0) const override;

  const TriangMat getTriang(unsigned int row = 0, unsigned int col = 0) const override;

  const SymMat getSym(unsigned int row = 0, unsigned int col = 0) const override;

  const BandedMat getBanded(unsigned int row = 0, unsigned int col = 0) const override;

  const SparseMat getSparse(unsigned int row = 0, unsigned int col = 0) const override;

  const SparseCoordinateMat getSparseCoordinate(unsigned int row = 0, unsigned int col = 0) const override;

  const ZeroMat getZero(unsigned int row = 0, unsigned int col = 0) const override;

  const IdentityMat getIdentity(unsigned int row = 0, unsigned int col = 0) const override;

  DenseMat* dense(unsigned int row = 0, unsigned int col = 0) const override;

  TriangMat* triang(unsigned int row = 0, unsigned int col = 0) const override;

  SymMat* sym(unsigned int row = 0, unsigned int col = 0) const override;

  BandedMat* banded(unsigned int row = 0, unsigned int col = 0) const override;

  SparseMat* sparse(unsigned int row = 0, unsigned int col = 0) const override;

  SparseCoordinateMat* sparseCoordinate(unsigned int row = 0, unsigned int col = 0) const override;

  ZeroMat* zero_mat(unsigned int row = 0, unsigned int col = 0) const override;

  IdentityMat* identity(unsigned int row = 0, unsigned int col = 0) const override;

  double* getArray(unsigned int row = 0, unsigned int col = 0) const override;

  void zero() override;

  void randomize() override;

  void randomize_sym() override;

  void eye() override;

  unsigned copyData(double* data) const;

  void assign(const SimpleMatrix &smat);

  unsigned int size(unsigned int index) const override;

  void resize(unsigned int row, unsigned int col, unsigned int lower = 0, unsigned int upper = 0, bool preserve = true) override;

  double normInf() const override;

  void normInfByColumn(SP::SiconosVector vIn) const;

  double det() const;

  void display() const override;

  void displayExpert(bool  brief = true) const override;

  std::string toString() const override;

  double& operator()(unsigned int i, unsigned int j) override;

  double operator()(unsigned int i, unsigned int j) const override;

  double getValue(unsigned int i, unsigned int j) const override;

  void setValue(unsigned int i, unsigned int j, double value) override;

  void setBlock(unsigned int posRow, unsigned int posCol, const SiconosMatrix& m);

  void getRow(unsigned int row, SiconosVector& vOut) const override;

  void getCol(unsigned int col, SiconosVector& vOut) const override;

  void setRow(unsigned int row , const SiconosVector& vIn) override;

  void setCol(unsigned int col, const SiconosVector& vIn) override;

  void getSubCol(unsigned int index, unsigned int pos, SP::SiconosVector vOut) const;

  void getSubRow(unsigned int index, unsigned int pos, SP::SiconosVector vOut) const;

  void setSubCol(unsigned int index, unsigned int pos, SP::SiconosVector vIn);

  void setSubRow(unsigned int index, unsigned int pos, SP::SiconosVector vIn);

  void addBlock(unsigned int i, unsigned int j, const SiconosMatrix& m);

  void subBlock(unsigned int i, unsigned int j, const SiconosMatrix& m);

  void trans() override;

  void trans(const SiconosMatrix& mat) override;

  SimpleMatrix& operator = (const SiconosMatrix& m) override;

  SimpleMatrix& operator = (const SimpleMatrix& m);

  SimpleMatrix& operator = (const DenseMat& m) override;

  SimpleMatrix& operator +=(const SiconosMatrix& m) override;

  SimpleMatrix& operator -=(const SiconosMatrix& m) override;

  void PLUFactorizationInPlace() override;

  void Factorize() override;

  void PLUInverseInPlace() override;

  void PLUForwardBackwardInPlace(SiconosMatrix& B) override;
  void Solve(SiconosMatrix& B) override;

  void PLUForwardBackwardInPlace(SiconosVector& B) override;
  void Solve(SiconosVector& B) override;

  void SolveByLeastSquares(SiconosMatrix& B);

  void SolveByLeastSquares(SiconosVector& B);

  void resetLU() override;

  void resetCholesky();

  void resetQR();

  void resetFactorizationFlags() override;

  ACCEPT_STD_VISITORS();

  friend std::ostream& operator<<(std::ostream& os, const SimpleMatrix& sm);

  friend const SimpleMatrix operator * (const SiconosMatrix&, double);

  friend  SP::SimpleMatrix operator * (const SP::SimpleMatrix, const SP::SimpleMatrix);

  friend  void operator +=(SP::SiconosMatrix, SP::SimpleMatrix);

  friend  SimpleMatrix operator * (double , const SiconosMatrix&);

  friend const SimpleMatrix operator /(const SiconosMatrix&, double);

  friend const SimpleMatrix operator +(const SiconosMatrix&, const SiconosMatrix&);

  friend SP::SimpleMatrix operator +(const SP::SimpleMatrix, const SP::SimpleMatrix);

  friend void add(const SiconosMatrix&, const SiconosMatrix&, SiconosMatrix&);

  friend const SimpleMatrix operator -(const SiconosMatrix&, const SiconosMatrix&);

  friend void sub(const SiconosMatrix&, const SiconosMatrix&, SiconosMatrix&);

  friend bool operator == (const SiconosMatrix&, const SiconosMatrix&);

  friend bool operator!= (const SiconosMatrix&, const SiconosMatrix&);

};

#endif