vetVector.h

#ifndef __VETLIB_VETVECTOR_H__
 #define __VETLIB_VETVECTOR_H__

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


template<class T>
class vetVector
 {

        protected:

                unsigned int items;

                T* data;
                T* dataSum;


        public:

                vetVector()
                 {
                        items = 0;
                        data = NULL;
                        dataSum = NULL;
                 }

                vetVector(unsigned int itemCount)
                 {
                        data = NULL;
                        dataSum = NULL;
                        setDim(itemCount);
                 }

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

                vetVector(itemCount, T* data_ptr)
                 {
                        items = itemCount;

                        data = data_ptr;

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

                 }

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

                        if ( dataSum != NULL )
                                delete dataSum;
                 }

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

                        if ( dataSum != NULL )
                                delete dataSum;

                        items = itemCount;

                        data = new T [items];
                        dataSum = new T;
                 }

                unsigned int getItemsCount() { return items; };
                T getItemsSum() { return *dataSum; };

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

                VETRESULT setValue(unsigned int itemIndex, T& value)
                 {
                        if ( itemIndex < 0 || itemIndex >= items )
                                return VETRET_PARAM_ERR;

                        if ( data == NULL )
                                return VETRET_ILLEGAL_USE;

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

                        return VETRET_OK;
                 }

                T& getValue(unsigned int itemIndex)
                 {
                        if ( itemIndex < 0 || itemIndex >= items )
                                throw "Out of bounds.";

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

                        return data[ itemIndex ];
                 }

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

                        T curMax = data[0];

                        for (int i=0; i < items; 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 < items; 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 < items; i++)
                                data[i] = value;

                        dataSum = items * 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\n", items) == EOF )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        for (int i=0; i < items; 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",&items) == EOF )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        if ( items < 1 )
                         {
                                fclose(fp);
                                return VETRET_INTERNAL_ERR;
                         }

                        setDim(items);

                        float tmpValue;

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

                        for (int is=0; is < items; is++)
                                dataSum += data[is];

                        return ret;
                 }


};

#endif //__VETLIB_VETVECTOR_H__

---