Matrix.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * Copyright (C) 2006-2010 RobotCub Consortium
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_SIG_MATRIX_H
#define YARP_SIG_MATRIX_H
 
#include <cstdlib> //defines size_t
#include <cstring> //memset
#include <yarp/os/Portable.h>
#include <yarp/sig/Vector.h>
#include <yarp/os/ManagedBytes.h>
 
namespace yarp {
    namespace sig {
        class Matrix;
    }
}
 
namespace yarp {
    namespace sig {
        YARP_sig_API bool submatrix(const Matrix &in, Matrix &out, size_t r1, size_t r2, size_t c1, size_t c2);
        YARP_sig_API bool removeCols(const Matrix &in, Matrix &out, size_t first_col, size_t how_many);
        YARP_sig_API bool removeRows(const Matrix &in, Matrix &out, size_t first_row, size_t how_many);
    }
}
 
class YARP_sig_API yarp::sig::Matrix: public yarp::os::Portable
{
private:
    double *storage;
    double **matrix; //double pointer access to elements
 
    size_t nrows;
    size_t ncols;
 
    void updatePointers();
 
public:
    Matrix():
      storage(0),
          matrix(0),
          nrows(0),
          ncols(0)
      {}
 
      Matrix(size_t r, size_t c);
 
      Matrix(const Matrix &m);
 
      ~Matrix();
 
      const Matrix &operator=(const Matrix &r);
 
      const Matrix &operator=(double v);
 
      size_t rows() const
      { return nrows; }
 
      size_t cols() const
      { return ncols; }
 
      void resize(size_t r, size_t c);
 
      inline double *operator[](size_t r)
      { return matrix[r]; }
 
      inline const double *operator[](size_t r) const
      { return matrix[r]; }
 
      inline const double &operator()(size_t r, size_t c) const
      { return matrix[r][c]; }
 
      inline double &operator()(size_t r, size_t c)
      { return matrix[r][c]; }
 
      void zero();
 
      bool setRow(size_t row, const Vector &r);
 
      bool setCol(size_t col, const Vector &c);
 
      Matrix transposed() const;
 
      const Matrix &eye();
 
      const Matrix &diagonal(const Vector &d);
 
      Matrix submatrix(size_t r1, size_t r2, size_t c1, size_t c2) const
      {
          Matrix ret;
          ret.resize(r2-r1+1, c2-c1+1);
 
          yarp::sig::submatrix((*this), ret, r1, r2, c1, c2);
          return ret;
      }
 
      bool setSubmatrix(const Matrix &m, size_t r, size_t c);
 
      bool setSubrow(const Vector &v, size_t r, size_t c);
 
      bool setSubcol(const Vector &v, size_t r, size_t c);
 
      Vector getRow(size_t r) const;
 
      Vector getCol(size_t c) const;
 
      Matrix removeCols(size_t first_col, size_t how_many);
 
      Matrix removeRows(size_t first_row, size_t how_many);
 
      Vector subrow(size_t r, size_t c, size_t size) const;
 
      Vector subcol(size_t r, size_t c, size_t size) const;
 
      std::string toString(int precision=-1, int width=-1, const char* endRowStr="\n") const;
 
      inline double *data()
      {return (nrows>0&&ncols>0)?storage:0/*NULL*/;}
 
      inline const double *data() const
      {return (nrows>0&&ncols>0)?storage:0/*NULL*/;}
 
      bool operator==(const yarp::sig::Matrix &r) const;
 
      /*
      * Read vector from a connection.
      * return true iff a vector was read correctly
      */
      bool read(yarp::os::ConnectionReader& connection) override;
 
      bool write(yarp::os::ConnectionWriter& connection) const override;
 
};
 
#endif // YARP_SIG_MATRIX_H