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

---

VirtualMatrix.h

Go to the documentation of this file.

#ifndef Impala_Core_Matrix_VirtualMatrix_h
#define Impala_Core_Matrix_VirtualMatrix_h

#include "Core/Array/Arrays.h"
#include "Core/Vector/VectorTem.h"
#include "Core/Matrix/Mat.h"

namespace Impala
{
namespace Core
{
namespace Matrix
{


class VirtualMatrix
{
public:

    typedef Vector::VectorTem<Real64> Vector64;

    VirtualMatrix()
    {
    }

    virtual
    ~VirtualMatrix()
    {
    }

    virtual int
    NrRow() = 0;

    virtual int
    NrCol() = 0;

    Vector64
    GetRow(int rowNr)
    {
        Vector64 res(NrCol());
        GetRow(rowNr, res.GetData(), res.Size());
        return res;
    }

    int
    GetRow(int rowNr, Real64* buffer, int bufferSize)
    {
        if (bufferSize < NrCol())
        {
            ILOG_ERROR("[GetRow] Buffer too small");
            return 0;
        }
        if (HasGetRowImplReal64())
            return GetRowImpl(rowNr, buffer, bufferSize);
        if (!HasGetRowImplReal32())
        {
            ILOG_ERROR("GetRow not implemented");
            return 0;
        }
        Real32* tmpBuf = new Real32[bufferSize];
        int nr = GetRowImpl(rowNr, tmpBuf, bufferSize);
        for (int i=0 ; i<nr ; i++)
            buffer[i] = tmpBuf[i];
        delete tmpBuf;
        return nr;
    }

    int
    GetRow(int rowNr, Real32* buffer, int bufferSize)
    {
        if (bufferSize < NrCol())
        {
            ILOG_ERROR("[GetRow] Buffer too small");
            return 0;
        }
        if (HasGetRowImplReal32())
            return GetRowImpl(rowNr, buffer, bufferSize);
        if (!HasGetRowImplReal64())
        {
            ILOG_ERROR("GetRow not implemented");
            return 0;
        }
        Real64* tmpBuf = new Real64[bufferSize];
        int nr = GetRowImpl(rowNr, tmpBuf, bufferSize);
        for (int i=0 ; i<nr ; i++)
            buffer[i] = tmpBuf[i];
        delete tmpBuf;
        return nr;
    }

    // Assumes that buffer contains at least NrCol() items
    int
    AddRow(int rowNr, Real64* buffer)
    {
        if (HasAddRowImplReal64())
            return AddRowImpl(rowNr, buffer);
        if (!HasAddRowImplReal32())
        {
            ILOG_ERROR("AddRow not implemented");
            return 0;
        }
        int nr = NrCol();
        Real32* tmpBuf = new Real32[nr];
        for (int i=0 ; i<nr ; i++)
            tmpBuf[i] = buffer[i];
        int res = AddRowImpl(rowNr, tmpBuf);
        delete tmpBuf;
        return res;
    }

    // Assumes that buffer contains at least NrCol() items
    int
    AddRow(int rowNr, Real32* buffer)
    {
        if (HasAddRowImplReal32())
            return AddRowImpl(rowNr, buffer);
        if (!HasAddRowImplReal64())
        {
            ILOG_ERROR("AddRow not implemented");
            return 0;
        }
        int nr = NrCol();
        Real64* tmpBuf = new Real64[nr];
        for (int i=0 ; i<nr ; i++)
            tmpBuf[i] = buffer[i];
        int res = AddRowImpl(rowNr, tmpBuf);
        delete tmpBuf;
        return res;
    }

    int
    AddRowPart(int rowNr, int colNr, Real64* buffer, int bufSize)
    {
        if (HasAddRowImplReal64())
            return AddRowPartImpl(rowNr, colNr, buffer, bufSize);
        if (!HasAddRowImplReal32())
        {
            ILOG_ERROR("AddRowPart not implemented");
            return 0;
        }
        Real32* tmpBuf = new Real32[bufSize];
        for (int i=0 ; i<bufSize ; i++)
            tmpBuf[i] = buffer[i];
        int res = AddRowPartImpl(rowNr, colNr, tmpBuf, bufSize);
        delete tmpBuf;
        return res;
    }

    int
    AddRowPart(int rowNr, int colNr, Real32* buffer, int bufSize)
    {
        if (HasAddRowImplReal32())
            return AddRowPartImpl(rowNr, colNr, buffer, bufSize);
        if (!HasAddRowImplReal64())
        {
            ILOG_ERROR("AddRowPart not implemented");
            return 0;
        }
        Real64* tmpBuf = new Real64[bufSize];
        for (int i=0 ; i<bufSize ; i++)
            tmpBuf[i] = buffer[i];
        int res = AddRowPartImpl(rowNr, colNr, tmpBuf, bufSize);
        delete tmpBuf;
        return res;
    }

    Vector64
    GetDiagonal()
    {
        Vector64 res(NrCol());
        GetDiagonal(res.GetData(), res.Size());
        return res;
    }

    int
    GetDiagonal(Real64* buffer, int bufferSize)
    {
        if (NrRow() != NrCol())
        {
            ILOG_ERROR("[GetDiagonal] Only works for square matrices!");
            return 0;
        }
        if (bufferSize < NrCol())
        {
            ILOG_ERROR("[GetDiagonal] Buffer too small");
            return 0;
        }
        return GetDiagonalImpl(buffer, bufferSize);
    }

    int
    Diff(VirtualMatrix* arg)
    {
        if (NrRow() != arg->NrRow())
        {
            ILOG_ERROR("[Diff] NrRow differs: " << NrRow() << " vs " <<
                       arg->NrRow());
            return 1;
        }
        if (NrCol() != arg->NrCol())
        {
            ILOG_ERROR("[Diff] NrCol differs: " << NrCol() << " vs " <<
                       arg->NrCol());
            return 1;
        }
        int nDiff = 0;
        Real64* row = new Real64[NrCol()];
        Real64* rowArg = new Real64[NrCol()];
        for (int i=0 ; i<NrRow() ; i++)
        {
            GetRow(i, row, NrCol());
            arg->GetRow(i, rowArg, NrCol());
            for (int j=0 ; j<NrCol() ; j++)
            {
                if (fabs(row[j] - rowArg[j]) > 0.00001)
                {
                    ILOG_DEBUG("elem " << i << "," << j << " differs: "
                               << row[j] << " vs " << rowArg[j]);
                    nDiff++;
                }
            }
        }
        delete row;
        delete rowArg;
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

    void
    CopyFrom(VirtualMatrix* arg)
    {
        if (arg->HasGetRowImplReal64())
            return CopyFromImpl<Real64>(arg);
        if (arg->HasGetRowImplReal32())
            return CopyFromImpl<Real32>(arg);
        ILOG_ERROR("[CopyFrom] arg has no GetRow implementation");
    }

    // Get access to internal storage.
    // Typically only works for Real64 memory based specializations.
    // No warranty, use with care!
    virtual Mat*
    GetStorage()
    {
        return 0;
    }

private:

    virtual bool
    HasGetRowImplReal64()
    {
        return false;
    }

    virtual int
    GetRowImpl(int rowNr, Real64* buffer, int bufferSize)
    {
        ILOG_ERROR("[GetRowImpl] 64bit version should not be called");
        return 0;
    }

    virtual bool
    HasGetRowImplReal32()
    {
        return false;
    }

    virtual int
    GetRowImpl(int rowNr, Real32* buffer, int bufferSize)
    {
        ILOG_ERROR("[GetRowImpl] 32bit version should not be called");
        return 0;
    }

    virtual bool
    HasAddRowImplReal64()
    {
        return false;
    }

    virtual int
    AddRowImpl(int rowNr, Real64* buffer)
    {
        ILOG_ERROR("[AddRowImpl] 64bit version should not be called");
        return 0;
    }

    virtual int
    AddRowPartImpl(int rowNr, int colNr, Real64* buffer, int bufSize)
    {
        ILOG_ERROR("[AddRowPartImpl] 64bit version should not be called");
        return 0;
    }

    virtual bool
    HasAddRowImplReal32()
    {
        return false;
    }

    virtual int
    AddRowImpl(int rowNr, Real32* buffer)
    {
        ILOG_ERROR("[AddRowImpl] 32bit version should not be called");
        return 0;
    }

    virtual int
    AddRowPartImpl(int rowNr, int colNr, Real32* buffer, int bufSize)
    {
        ILOG_ERROR("[AddRowPartImpl] 32bit version should not be called");
        return 0;
    }

    virtual int
    GetDiagonalImpl(Real64* buffer, int bufferSize) = 0;

    template <class BufT>
    void
    CopyFromImpl(VirtualMatrix* arg)
    {
        BufT* buf = new BufT[NrCol()];
        for (int i=0 ; i<NrRow() ; i++)
        {
            int nr = arg->GetRow(i, buf, NrCol());
            if (nr != NrCol())
                break;
            nr = AddRow(i, buf);
            if (nr != NrCol())
                break;
        }
        delete buf;
    }

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VirtualMatrix, Impala.Core.Matrix);

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

#endif

---