Shark Machine Learning Library

• About Shark
• Sourceforge
  • Project Summary
  • Downloads
  • Subversion Repository
• Getting Started
• Tutorials
• FAQ
• Main Modules
  • ReClaM
  • EALib
  • MOO-EALib
  • Fuzzy
• Tools
  • Mixture
  • Array
  • Rng
  • LinAlg
  • FileUtil

ArrayTable.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================


#ifndef __ARRAY_TABLE_H
#define __ARRAY_TABLE_H

#include "Array/Array.h"

//===========================================================================
template<class T>

class ArrayTable
{

public:

//===========================================================================
    Array<T> A;

//===========================================================================
    Array<T*> P1;

//===========================================================================
    Array<T**> P2;


//===========================================================================
    void resize(unsigned d0, unsigned d1, unsigned d2, int dummy = 0)
    {
        unsigned i, j;
        A.resize(d0, d1, d2, false);
        P1.resize(d0, d1, false);
        P2.resize(d0, false);
        for (i = 0;i < d0;i++) {
            for (j = 0;j < d1;j++)  P1(i, j) = &A(i, j, 0);
            P2(i) = &P1(i, 0);
        }
    }

//===========================================================================
    void resize(unsigned d0, unsigned d1, int dummy = 0)
    {
        unsigned i;
        A.resize(d0, d1, false);
        P1.resize(d0, false);
        P2.resize(0, false);
        for (i = 0;i < d0;i++) P1(i) = &A(i, 0);
    }

//===========================================================================
    void resize(unsigned d0, int dummy = 0)
    {
        A.resize(d0, false);
        P1.resize(0, false);
        P2.resize(0, false);
    }


//===========================================================================
    operator T*()
    {
        return A.elemvec();
    }


//===========================================================================
    operator T**()
    {
        return P1.elemvec();
    }


//===========================================================================
    operator T***()
    {
        return P2.elemvec();
    }


//===========================================================================
    T& operator()(unsigned i)
    {
        return A(i);
    }


//===========================================================================
    T& operator()(unsigned i,unsigned j)
    {
        return P1(i)[j];
    }


//===========================================================================
    T& operator()(unsigned i,unsigned j, unsigned k)
    {
        return P2(i)[j][k];
    }


//===========================================================================
    ArrayTable<T>& operator =(const ArrayTable<T>& a)
    {
        if (a.A.ndim() == 3) resize(a.A.dim(0), a.A.dim(1), a.A.dim(2), false);
        else {
            if (a.A.ndim() == 2) resize(a.A.dim(0), a.A.dim(1), false);
            else if (a.A.ndim() == 1) resize(a.A.dim(0), false);
        }
        A = a.A;
        return *this;
    }

//===========================================================================
    ArrayTable<T>& operator =(const T& d)
    {
        for (unsigned i = 0;i < A.nelem();i++) A.elem(i) = d;
        return *this;
    }



//===========================================================================
    ArrayTable()
{ }

//===========================================================================
    ArrayTable(unsigned i)
    {
        resize(i);
    }


//===========================================================================
    ArrayTable(unsigned i, unsigned j)
    {
        resize(i, j);
    }


//===========================================================================
    ArrayTable(unsigned i, unsigned j, unsigned k)
    {
        resize(i, j, k);
    }

//===========================================================================
    ArrayTable(const ArrayTable<T>& a)
    {
        operator = (a);
    }


};


#endif // __ARRAY_TABLE_H