gmMatrixUtils.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_MATRIX_UTILS_H_
#define _GEMA_MATRIX_UTILS_H_
 
#ifndef GM_MATRIX_DEFINED
// Copy of the definition in gmMatrix.h to break a dependency cycle since gmMatrix.h must also 
// include gmMatrixUtils.h
#define GM_MATRIX_DEFINED
#include <armadillo>
typedef arma::mat GmMatrix;  
#endif
 
#include <math.h>
#include "gmLog.h"
#include <assert.h>
 
#if ARMA_VERSION_MAJOR != 14 || ARMA_VERSION_MINOR != 0
#error Unexpected Armadillo version.  Please check that our internal fiddling done  below is still valid
#endif
 
namespace GmMatrixUtils
{
 
  inline void fill(GmMatrix& m, const double* data, int nlin, int ncol)
  {
    m.set_size(nlin, ncol);
    memcpy(m.memptr(), data, nlin * ncol * sizeof(double));
  }
 
  inline void fillLine(GmMatrix& m, const double* data, int lin)
  {
    switch (m.n_cols)
    {
      // Optimize common case of small matrices
      case 8: m(lin, 7) = data[7]; [[fallthrough]];
      case 7: m(lin, 6) = data[6]; [[fallthrough]];
      case 6: m(lin, 5) = data[5]; [[fallthrough]];
      case 5: m(lin, 4) = data[4]; [[fallthrough]];
      case 4: m(lin, 3) = data[3]; [[fallthrough]];
      case 3: m(lin, 2) = data[2]; [[fallthrough]];
      case 2: m(lin, 1) = data[1]; [[fallthrough]];
      case 1: m(lin, 0) = data[0]; 
        break;
      default:
        for (unsigned int i = 0; i < m.n_cols; i++)
          m(lin, i) = data[i];
    }
  }
 
  inline void fillColumn(GmMatrix& m, const double* data, int col)
  {
    switch (m.n_rows)
    {
      // Optimize common case of small matrices
      case 8: m(7, col) = data[7]; [[fallthrough]];
      case 7: m(6, col) = data[6]; [[fallthrough]];
      case 6: m(5, col) = data[5]; [[fallthrough]];
      case 5: m(4, col) = data[4]; [[fallthrough]];
      case 4: m(3, col) = data[3]; [[fallthrough]];
      case 3: m(2, col) = data[2]; [[fallthrough]];
      case 2: m(1, col) = data[1]; [[fallthrough]];
      case 1: m(0, col) = data[0]; 
        break;
      default:
        for (unsigned int i = 0; i < m.n_rows; i++)
          m(i, col) = data[i];
    }
  }
 
  inline void setMatrixMemory(GmMatrix& m, double* data, int nlin, int ncol)
  {
    // Ugly hack ahead.  Please close your eyes.  This is dependent on the Armadillo
    // implementation and is done only because there is really no other way (short of
    // changing the library itself).
    assert(m.vec_state == 0);
    assert(m.mem_state == 2 || (m.mem_state == 0 && m.n_elem == 0 && m.mem == NULL));
    assert(m.n_alloc == 0);
    arma::access::rw(m.mem) = data;
    arma::access::rw(m.mem_state) = 2;
    arma::access::rw(m.n_rows) = nlin;
    arma::access::rw(m.n_cols) = ncol;
    arma::access::rw(m.n_elem) = nlin * ncol;
  }
 
  inline void resetMatrixMemory(GmMatrix& m)
  {
    // Ugly hack ahead.  Please close your eyes.  This is dependent on the Armadillo
    // implementation and is done only because there is really no other way (short of
    // changing the library itself).
    assert(m.vec_state == 0);
    if(m.mem_state == 2)
    {
      arma::access::rw(m.mem) = NULL;
      arma::access::rw(m.mem_state) = 0;
      arma::access::rw(m.n_rows) = 0;
      arma::access::rw(m.n_cols) = 0;
      arma::access::rw(m.n_elem) = 0;
    }
    else if(m.mem_state == 0)
    {
      m.reset();
      arma::access::rw(m.mem) = NULL;
    }
    else
      assert(0);
    assert(m.n_alloc == 0);
  }
 
  inline bool hasSharedMemory(GmMatrix& m) { return m.mem_state == 2; }
 
  inline void setMatrixSize(GmMatrix& m, int nlin, int ncol)
  {
    // Ugly hack ahead.  Please close your eyes.  This is dependent on the Armadillo
    // implementation and is done only because there is really no other way (short of
    // changing the library itself).
    assert(m.vec_state == 0);
    assert(m.mem_state == 2);
    assert(m.n_alloc == 0);
    assert(m.mem);
    arma::access::rw(m.n_rows) = nlin;
    arma::access::rw(m.n_cols) = ncol;
    arma::access::rw(m.n_elem) = nlin * ncol;
  }
 
  GMC_API_EXPORT void print(const GmMatrix& m, const GmLogCategory& logger, GmLogLevel level, int fieldWidth = 0,
                            char format = 'g', int precision = -1);
 
  GMC_API_EXPORT QString toString        (const GmMatrix& m, int fieldWidth = 0, char format = 'g', int precision = -1);
  GMC_API_EXPORT QString toColMajorString(const GmMatrix& m, int fieldWidth = 0, char format = 'g', int precision = -1);
 
  GMC_API_EXPORT void fillFromLuaTable  (GmMatrix& m, LuaTable& t);
  GMC_API_EXPORT bool fillFromLuaTable  (GmMatrix& m, LuaTable& t, int nlin, int ncol);
  GMC_API_EXPORT bool updateFromLuaTable(GmMatrix& m, LuaTable& t);
}
 
#endif