|| || || || || ||

---

VirtualMatrixMemory.h

Go to the documentation of this file.

#ifndef Impala_Core_Matrix_VirtualMatrixMemory_h
#define Impala_Core_Matrix_VirtualMatrixMemory_h

#include "Core/Matrix/VirtualMatrix.h"
#include "Core/Matrix/MatFunc.h"
#include "Util/IOBuffer.h"
#include "Core/Array/ReadRaw.h"

namespace Impala
{
namespace Core
{
namespace Matrix
{


template<class ArrayT>
class VirtualMatrixMemory : public VirtualMatrix
{
public:

    typedef typename ArrayT::StorType StorT;

    VirtualMatrixMemory(ArrayT* mat)
    {
        mMat = mat;
    }

    virtual
    ~VirtualMatrixMemory()
    {
        delete mMat;
        mMat = 0;
    }

    virtual int
    NrRow()
    {
        return MatNrRow(mMat);
    }

    virtual int
    NrCol()
    {
        return MatNrCol(mMat);
    }

    virtual Mat*
    GetStorage()
    {
        return dynamic_cast<Mat*>(mMat);
    }

private:

    virtual bool
    HasGetRowImplReal64()
    {
        // Actually, we can do both but we have a preference
        return (sizeof(StorT) == 8);
    }

    virtual int
    GetRowImpl(int rowNr, Real64* buffer, int bufferSize)
    {
        return ReadRow(rowNr, buffer, bufferSize);
    }

    virtual bool
    HasGetRowImplReal32()
    {
        // Actually, we can do both but we have a preference
        return (sizeof(StorT) == 4);
    }

    virtual int
    GetRowImpl(int rowNr, Real32* buffer, int bufferSize)
    {
        return ReadRow(rowNr, buffer, bufferSize);
    }

    template<class OutputT>
    int
    ReadRow(int rowNr, OutputT* buffer, int bufferSize)
    {
        if (MatNrCol(mMat) > bufferSize)
        {
            ILOG_ERROR("[ReadRow] Buffer too small");
            return 0;
        }
        StorT* row = MatE(mMat, rowNr, 0);
        for (int i=0 ; i<MatNrCol(mMat) ; i++)
        {
            buffer[i] = static_cast<OutputT>(row[i]);
        }
        return MatNrCol(mMat);
    }

    virtual int
    GetDiagonalImpl(Real64* buffer, int bufferSize)
    {
        if (MatNrCol(mMat) > bufferSize)
        {
            ILOG_ERROR("[GetDiagonalImpl] Buffer too small");
            return 0;
        }
        for (int i=0 ; i<MatNrRow(mMat) ; i++)
            buffer[i] = static_cast<Real64>(*MatE(mMat, i, i));
        return MatNrCol(mMat);
    }

    ArrayT* mMat;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT_TEMPL_1(VirtualMatrixMemory, ArrayT, Impala.Core.Matrix);

} // namespace Matrix
} // namespace Core
} // namespace Impala

#endif

---