OpenPaperOpt/Array2D.h

Go to the documentation of this file.

/*******************************************************************************
 * Array2D.h - A simple 2D array class
 ********************************************************************************/
        
#ifndef _ARRAY2D_H_
#define _ARRAY2D_H_
#include "V3.h"

template<class T> class Array2D {
 public:
         // Constructor
        

         Array2D(){}
         Array2D(int _rows, int _columns):
         rows(_rows), columns(_columns) {p = new T[rows*columns];};
        Array2D(const Array2D <T> & m):p(NULL){*this = m;}

         
         // Destructor
         ~Array2D() {
                 delete p; 
         }

         // Operators
         int rows;
         int columns;
         T* operator[](int i) { return (p + columns*i); }
         const T* operator[](int i) const { return (p + columns*i); }
         T& operator()(int i, int j) { return (*(p + columns*i + j)); }
         const T& operator()(int i, int j) const { return (*(p + columns*i + j)); }

         //add the function from original Matrix class
         Array2D <T> &operator=(const Array2D <T>& m){
                 //Adjust the dimension
                 rows =m.rows;
                 columns = m.columns;
                 //Delete previous data
                //if (p) delete [] p;
                //Check the new dimension
                if (rows > 0 && columns > 0)
                        //Allocate memory
                        p = new T[rows * columns];
                else
                        p = NULL;
                //and copy the data
                for (int i = 0; i < rows; i++)
                        for (int j = 0; j < columns; j++)
                                (*this)(i, j) = m(i, j);
                return *this;}
        const V3<T> row(int i) const{return V3<T>((*this)(i, 0), (*this)(i, 1), (*this)(i, 2));}

        void SetRow(int i, const V3<T>& v){(*this)(i, 0) = v.X();(*this)(i, 1) = v.Y();(*this)(i, 2) = v.Z();}

        const Array2D <T> operator*(const Array2D <T>& m) const{
                //Size the resulting matrix
                Array2D <T> res( rows,m.columns);
                //Check that the dimensions agree
                if (this->rows!=m.rows) throw (" dimensions do not agree");
                //Do the matrix multiplication
                for(int i = 0; i < rows; i++)
                        for(int j = 0; j < m.columns; j++)
                        {
                                res(i, j) = 0;
                                for(int t = 0; t < columns; t++)
                                        res(i, j) += (*this)(i, t) * m(t, j);
                        }
                return res;
        }
        const V3<T> operator*(const V3<T>& v) const{
                
                V3<T> res(0, 0, 0);
                //Check the dimensions
                if (this->columns != 3 || this->rows != 3) throw ("Matrix must have dimension 3x3 for V3<T> multiplication");
                //We just do the multiplication manually here
                res.X(v.X() * (*this)(0, 0) + v.Y() * (*this)(0, 1) + v.Z() * (*this)(0, 2));
                res.Y(v.X() * (*this)(1, 0) + v.Y() * (*this)(1, 1) + v.Z() * (*this)(1, 2));
                res.Z(v.X() * (*this)(2, 0) + v.Y() * (*this)(2, 1) + v.Z() * (*this)(2, 2));
                return res;
        }
         const Array2D <T> transpose() const{
                 Array2D <T> res(this->columns, this->rows);
                for(int i = 0; i < rows; i++)
                        for(int j = 0; j < columns; j++)
                                res(j, i) = (*this)(i, j);
                return res;
         }

        void identity(void){
                for(int i=0; i<rows; i++)
                        for(int j=0; j<columns; j++)
                        {
                                if(i==j)
                                        (*this)(i, j)=1;
                                else
                                        (*this)(i, j)=0;
                        }
        }
         
        
         // disable the built-in assignment operator.
         //double operator=(int index); 
  
         const int GetColumns() const { return columns; }
         const int GetRows() const { return rows; }

private:
        
        

        T *p;
        
         
};

#endif