field.h Source File

00001 //****************************************************
00002 //  April, 1993, University of Illinois
00003 // Copyright (C) 1993, 1994 Tianlin Wang
00004 /* Copyright (C) 1994-2003 Matvec Development Team. 
00005 
00006   This program is free software; you can redistribute it and/or
00007   modify it under the terms of the GNU Library General Public
00008   License as published by the Free Software Foundation; either
00009   version 2 of the License, or (at your option) any later version.
00010   
00011   This program is distributed in the hope that it will be useful,
00012   but WITHOUT ANY WARRANTY; without even the implied warranty of
00013   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014   Library General Public License for more details.
00015     
00016   You should have received a copy of the GNU Library General Public
00017   License along with this library; if not, write to the Free
00018   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00019   MA 02111-1307, USA 
00020 */
00021 
00022 #ifndef MATVEC_FIELD_H
00023 #define MATVEC_FIELD_H
00024 
00025 #include <string>
00026 #include "util.h"
00027 #include "vector.h"
00028 #include "datanode.h"
00029 #include "fieldstruct.h"
00030 #include "hashtable.h"
00031 
00032 namespace matvec {
00033 /*!
00034    \class Field Field.h
00035    \brief a column for a data set
00036 
00037    \sa Data DataNode
00038 */
00039 
00040 class Field {
00041    friend class Data;
00042    protected:
00043       unsigned     ne;
00044       DataNode     mean_value;
00045       DataNode*    dat_vec;
00046       HashTable*   hashtable;
00047 
00048       void copyfrom(const Field& a);
00049 
00050    public:
00051       FieldStruct  col_struct;
00052 
00053       Field(void);                                    // Constructor 1
00054       Field(const unsigned n);                        // Constructor 2
00055       Field(const Field& a);                          // Constructor 3
00056       Field(const unsigned n,DataNode *a,FieldStruct st,
00057              HashTable* ht = 0);
00058       ~Field(void) {release();}                               // Destructor
00059 
00060       Field&          resize(const unsigned n);
00061       Field&          resize(const unsigned n, DataNode *a);  //dat_vec=0
00062 
00063       const Field&    operator=(const Field& a);
00064 
00065       Field&           operator+=(const Field& a);
00066       Field&           operator-=(const Field& a);
00067       Field&           operator*=(const Field& a);
00068       Field&           operator/=(const Field& a);
00069 
00070       Field&           operator+=(const double s);
00071       Field&           operator-=(const double s);
00072       Field&           operator*=(const double s);
00073       Field&           operator/=(const double s);
00074 
00075       DataNode&        operator()(const unsigned i);
00076       DataNode&        operator[](const unsigned i) {return dat_vec[i];}
00077 
00078       Field            operator!(void) const;
00079       Field            operator-(void) const;               //unary minus
00080       Field&           operator+(void) {return *this;};     //unary plus
00081 
00082       Vector<bool>           operator==(const Field &a) const;
00083       Vector<bool>           operator==(const double x) const;
00084       Vector<bool>           operator<(const Field &a) const;
00085       Vector<bool>           operator>(const Field &a) const;
00086       Vector<bool>           operator!=(const Field &a) const;
00087       Vector<bool>           operator<=(const Field &a) const;
00088       Vector<bool>           operator>=(const Field &a) const;
00089 
00090       friend Vector<bool>    operator==(const double a, const Field &b);
00091       friend Vector<bool>    operator<(const Field &a,const double b);
00092       friend Vector<bool>    operator<(const double a,const Field &b);
00093       friend Vector<bool>    operator!=(const Field &a,const double b);
00094       friend Vector<bool>    operator!=(const double a,const Field &b);
00095       friend Vector<bool>    operator>(const Field & a,const double b);
00096       friend Vector<bool>    operator>(const double a,const Field & b);
00097       friend Vector<bool>    operator<=(const Field &a,const double b);
00098       friend Vector<bool>    operator<=(const double a,const Field b);
00099       friend Vector<bool>    operator>=(const Field &a,const double b);
00100       friend Vector<bool>    operator>=(const double a,const Field &b);
00101 
00102       friend Field     operator+(const Field& a, const Field& b);
00103       friend Field     operator+(const Field& a, const double b);
00104       friend Field     operator+(const double b, const Field& a);
00105 
00106       friend Field     operator-(const Field& a, const Field& b);
00107       friend Field     operator-(const Field& a, const double b);
00108       friend Field     operator-(const double b, const Field& a);
00109 
00110       friend Field     operator / (const Field& a, const Field& b);
00111       friend Field     operator / (const Field& a, const double s);
00112       friend Field     operator / (const double s, const Field& b);
00113 
00114       friend Field     operator * (const Field& a, const Field& b);
00115       friend Field     operator * (const Field& a, const double b);
00116       friend Field     operator * (const double a, const Field& b);
00117 
00118       friend std::ostream&  operator<<(std::ostream& stream, const Field& a);
00119 
00120       friend Field     sin(Field& a);
00121       friend Field     asin(Field& a);
00122       friend Field     cos(Field& a);
00123       friend Field     acos(Field& a);
00124       friend Field     tan(Field& a);
00125       friend Field     atan(Field& a);
00126       friend Field     ceil(Field& a);
00127       friend Field     floor(Field& a);
00128       friend Field     log(Field& a);
00129       friend Field     log10(Field& a);
00130       friend Field     exp(Field& a);
00131       friend Field     sqrt(Field& a);
00132       friend Field     abs(Field& a);
00133       friend Field     erf(Field& a);
00134       friend Field     erfc(Field& a);
00135 
00136       void             value_for_missing(const double vm);
00137       void             out_to_stream(std::ostream& stream, const int ic) const;
00138       void             save(const std::string &ffname,
00139                             const int io_mode = std::ios::out) const;//SDK | ios::noreplace) const;
00140       void             display(const std::string &meg = "", const int ic=0) const;
00141       void             set_missing(const unsigned k);
00142       void             pretend_missing(const unsigned k);
00143       void             recover_missing(const unsigned k);
00144       Field            map(double (*f)(double)) const;
00145       Field            sub(const int i1,const int i2) const;
00146       Field&           zeros(void);
00147       Field&           ones(void);
00148       Field&           sort(void);
00149       DataNode         max(void) const;
00150       DataNode         min(void) const;
00151       DataNode         sum(void) const;
00152       DataNode         sumsq(void) const;
00153       DataNode         product(void) const;
00154       DataNode         mean(const int flag=1);
00155       DataNode         covariance(const Field *B=0) const;
00156       DataNode         elem(const unsigned i) const;
00157 
00158       unsigned         len(void) const {return ne;}
00159       unsigned         size(void) const {return ne;}
00160       void             release(void);
00161 
00162       void             index(const unsigned k)   {col_struct.index(k);}
00163       void             nlevel(const unsigned k)  {col_struct.nlevel(k);}
00164       void             nmiss(const unsigned k)   {col_struct.nmiss(k);}
00165       void             count_miss(const int k)   {col_struct.count_miss(k);}
00166       void             classi(const char c)      {col_struct.classi(c);}
00167       void             type(const char c)        {col_struct.type(c);}
00168       void             name(const std::string &n)      {col_struct.name(n);}
00169       unsigned         index(void)  const        {return col_struct.index();}
00170       unsigned         nlevel(void) const        {return col_struct.nlevel();}
00171       unsigned         nmiss(void)  const        {return col_struct.nmiss();}
00172       char             classi(void) const        {return col_struct.classi();}
00173       char             type(void)   const        {return col_struct.type();}
00174       const std::string      name(void)   const  {return col_struct.name();}
00175 
00176 };
00177 
00178 //public:
00179 
00180 inline Field::Field(void)                            //Constructor 1
00181 { ne = 0; dat_vec = 0; hashtable = 0; }
00182 
00183 inline Field::Field(const unsigned n)                //Constructor 2
00184 { 
00185   ne = n;  
00186   if(n>0){
00187     dat_vec = new DataNode [n]; 
00188   }
00189   else {
00190     dat_vec = 0;
00191   }
00192   hashtable = 0; 
00193 }
00194 
00195 inline DataNode& Field::operator()(const unsigned i)
00196 {
00197    if (i - 1 >= ne ) throw exception("Field(): subscript out of range");
00198    return dat_vec[i - 1];
00199 }
00200 
00201 inline DataNode Field::elem(const unsigned i) const
00202 {
00203    if (i - 1 >= ne) throw exception("Field.elem(): subscript out of range");
00204    return dat_vec[i - 1];
00205 }
00206 
00207 inline Field& Field::zeros(void)
00208 {
00209    for (unsigned i=0; i<ne; i++) dat_vec[i].double_val(0.0);
00210    return *this;
00211 }
00212 
00213 inline Field& Field::ones(void)
00214 {
00215    for (unsigned i=0; i<ne; i++) dat_vec[i].double_val(1.0);
00216    return *this;
00217 }
00218 
00219 } //////// end of namespace matvec
00220 
00221 #endif