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 != 5 || ARMA_VERSION_MINOR != 200
#error Unexpected Armadillo version.  Please check that our internal fiddling done bellow 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];
                case 7: m(lin, 6) = data[6];
                case 6: m(lin, 5) = data[5];
                case 5: m(lin, 4) = data[4];
                case 4: m(lin, 3) = data[3];
                case 3: m(lin, 2) = data[2];
                case 2: m(lin, 1) = data[1];
                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];
                case 7: m(6, col) = data[6];
                case 6: m(5, col) = data[5];
                case 5: m(4, col) = data[4];
                case 4: m(3, col) = data[3];
                case 3: m(2, col) = data[2];
                case 2: m(1, col) = data[1];
                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));
                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);
  }

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