vetMatrix.h

#ifndef __VETLIB_VETMATRIX_H__
 #define __VETLIB_VETMATRIX_H__

 #include "../vetDefs.h"
 #include <stdio.h>
 #include <fstream>


template<class T>
class vetMatrix
 {

        protected:

                unsigned int rows;
                unsigned int columns;

                T* data;
                T* dataSum;


        public:

                vetMatrix()
                 {
                        rows = 0;
                        columns = 0;
                        data = NULL;
                        dataSum = NULL;
                 }

                vetMatrix(unsigned int colCount, unsigned int rowCount)
                 {
                        data = NULL;
                        dataSum = NULL;
                        setDim(colCount, rowCount);
                 }

                vetMatrix(const char* filename)
                 {
                        data = NULL;
                        dataSum = NULL;
                        loadFromFile(filename);
                 }

                vetMatrix(unsigned int colCount, unsigned int rowCount, T* data_ptr)
                 {
                        rows = rowCount;
                        columns = colCount;

                        data = data_ptr;

                        dataSum = new T;;
                        for (int is=0; is < columns * rows; is++)
                                dataSum += data[is];

                 }

                ~vetMatrix()
                 {
                        if ( data != NULL )
                                delete [] data;

                        if ( dataSum != NULL )
                                delete dataSum;
                 }

                void setDim(unsigned int colCount, unsigned int rowCount)
                 {
                        if ( data != NULL )
                                delete [] data;

                        if ( dataSum != NULL )
                                delete dataSum;

                        rows = rowCount;
                        columns = colCount;

                        data = new T [rows*columns];
                        dataSum = new T;
                 }

                unsigned int getRowsCount() { return rows; };
                unsigned int getColumnsCount() { return columns; };
                unsigned int getItemsCount() { return columns*rows; };
                T getItemsSum() { return *dataSum; };

                T* dump_data() { return data; };
                T* dump_dataSum() { return dataSum; };

                VETRESULT setValue(unsigned int x, unsigned int y, T& value)
                 {
                        if ( x < 0 || y < 0 || x >= columns || y >= rows )
                                return VETRET_PARAM_ERR;

                        if ( data == NULL )
                                return VETRET_ILLEGAL_USE;

                        dataSum -= data[ y * rows + x ];
                        data[ y * rows + x ] = value;
                        dataSum += value;

                        return VETRET_OK;
                 }

                T& getValue(unsigned int x, unsigned int y)
                 {
                        if ( x < 0 || y < 0 || x >= columns || y >= rows )
                                throw "Out of bounds.";

                        if ( data == NULL )
                                throw "Empty table.";

                        return data[ y * rows + x ];
                 }

                T& getValueMax()
                 {
                        if ( data == NULL )
                                throw "Empty table.";

                        T curMax = data[0];

                        for (int i=0; i < columns * rows; i++)
                                if ( data[i] > curMax )
                                        curMax = data[i];

                        return curMax;
                 }

                T& getValueMin()
                 {
                        if ( data == NULL )
                                throw "Empty table.";

                        T curMin = data[0];

                        for (int i=0; i < columns * rows; i++)
                                if ( data[i] < curMax )
                                        curMax = data[i];

                        return curMax;
                 }

                void clearWith(T& value)
                 {
                        if ( data == NULL )
                                throw "Empty table.";

                        for (int i=0; i < columns * rows; i++)
                                data[i] = value;

                        dataSum = columns * rows * value;

                 }


//              T& operator() (unsigned int i, unsigned int j);




                VETRESULT saveToFile(const char* filename)
                 {
                        FILE *fp;
                        int ret = VETRET_OK;

                        if ( data == NULL )
                                return VETRET_ILLEGAL_USE;

                        if ( (fp = fopen(filename, "w")) == NULL )
                                return VETRET_PARAM_ERR;


                        if( fprintf(fp, "%d %d\n", rows, columns) == EOF )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        for (int i=0; i < columns * rows; i++)
                                if ( fprintf(fp, "%f ", (float)data[i]) == EOF)
                                        ret = VETRET_INTERNAL_ERR;

                        if ( fprintf(fp, "\n") == EOF )
                                ret = VETRET_INTERNAL_ERR;

                        fclose(fp);
                        return ret ;
                 }



                VETRESULT loadFromFile(const char* filename)
                 {
                        FILE *fp;
                        int ret = VETRET_OK;

                        if ( (fp=fopen(filename,"r")) == NULL )
                                return VETRET_PARAM_ERR;

                        unsigned int newRows = 0;
                        unsigned int newCols = 0;

                        if ( fscanf(fp,"%u",&newRows) == EOF )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        if ( fscanf(fp,"%u",&newCols) == EOF )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        if ( newRows < 0 || newCols < 0 )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        setDim(newRows, newCols);



                        float tmpValue;

                        for (int i=0; i < newRows * newCols; i++)
                                if( fscanf(fp, "%f", &tmpValue) == EOF )
                                        ret = VETRET_INTERNAL_ERR;
                                else
                                        data[i] = (T)tmpValue;

                        for (int is=0; is < columns * rows; is++)
                                dataSum += data[is];

                        return ret;
                 }


};

#endif //__VETLIB_VETMATRIX_H__

---