home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / nihcl-3.0 / vector / FloatVec.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-16  |  9.7 KB  |  279 lines
  1. #ifndef    FLOATVEC_H
  2. #define    FLOATVEC_H
  3.  
  4. /* FloatVec.h -- Float Precision Vectors
  5.  
  6.     THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
  7.     "UNITED STATES GOVERNMENT WORK".  IT WAS WRITTEN AS A PART OF THE
  8.     AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE.  THIS MEANS IT
  9.     CANNOT BE COPYRIGHTED.  THIS SOFTWARE IS FREELY AVAILABLE TO THE
  10.     PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
  11.     RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.
  12.  
  13. Author:
  14.     K. E. Gorlen
  15.     Bg. 12A, Rm. 2033
  16.     Computer Systems Laboratory
  17.     Division of Computer Research and Technology
  18.     National Institutes of Health
  19.     Bethesda, Maryland 20892
  20.     Phone: (301) 496-1111
  21.     uucp: uunet!nih-csl!kgorlen
  22.     Internet:kgorlen@alw.nih.gov
  23.  
  24. Function:
  25.     
  26. Modification History:
  27.  
  28. $Log:    FloatVec.h,v $
  29.  * Revision 3.0  90/05/16  23:00:31  kgorlen
  30.  * Release for 1st edition.
  31.  * 
  32. */
  33. #include "Vector.h"
  34. #include "BitVec.h"
  35. #include "IntVec.h"
  36.  
  37. class FloatSlice;
  38. class FloatPick;
  39. class FloatSlct;
  40.  
  41. class FloatVec : public Vector {
  42.     DECLARE_MEMBERS(FloatVec);
  43.     float* v;    // pointer to data, NULL if empty vector
  44.     void indexRangeErr() const;
  45. protected:
  46.     virtual void storer(OIOofd&) const;
  47.     virtual void storer(OIOout&) const;
  48. public:
  49.     FloatVec(unsigned len =0);
  50.     FloatVec(unsigned len, float from, float by =1.0);
  51.     FloatVec(const float*, unsigned len);
  52.     FloatVec(const FloatVec&);
  53.     FloatVec(const FloatSlice&);
  54.     FloatVec(const DoubleVec&);
  55.     ~FloatVec()        { delete v; }
  56.     FloatSlice operator()(int pos, unsigned lgt, int stride =1);
  57.     const FloatSlice operator()(int pos, unsigned lgt, int stride =1) const;
  58.     float*    pt()            { return v; }
  59.     const float* pt() const    { return v; }
  60.     operator FloatSlice();
  61.     operator const FloatSlice() const;
  62. //    operator ComplexVec();
  63.     float&    operator[](int i) {        // vector element
  64.         if ((unsigned)i >= n) indexRangeErr();
  65.         return v[i];
  66.     }
  67.     const float& operator[](int i) const {    // vector element
  68.         if ((unsigned)i >= n) indexRangeErr();
  69.         return v[i];
  70.     }
  71.     float& operator()(int i)        { return v[i]; }
  72.     const float& operator()(int i) const    { return v[i]; }
  73.     FloatPick operator[](const IntVec&);
  74.     const FloatPick operator[](const IntVec&) const;
  75.     FloatSlct operator[](const BitVec&);
  76.     const FloatSlct operator[](const BitVec&) const;
  77.     void /*FloatVec::*/operator=(const FloatVec&);
  78.     void /*FloatVec::*/operator=(const FloatSlice&);
  79.     void /*FloatVec::*/operator=(const FloatSlct&);
  80.     void /*FloatVec::*/operator=(const FloatPick&);
  81.     void /*FloatVec::*/operator=(float);
  82.     void /*FloatVec::*/lengthErr(const FloatSlice&) const;
  83.     void selectErr(const BitVec&) const;
  84.     virtual void    deepenShallowCopy();
  85.     virtual unsigned hash() const;
  86.     virtual bool    isEqual(const Object&) const;
  87.     virtual void    printOn(ostream& strm =cout) const;
  88.     virtual void    scanFrom(istream& strm);
  89.     virtual void    sort();
  90.     virtual const Class* species() const;
  91. };
  92.  
  93. class TempFloatVec : public FloatVec {
  94.     friend FloatSlice;
  95.     friend FloatPick;
  96.     friend FloatSlct;
  97.     TempFloatVec(unsigned len =0) : FloatVec(len) {}
  98.     virtual void free();
  99. };
  100.  
  101. class FloatSlice : public NIHCL {
  102.     FloatVec* V;    // vector pointer
  103.     float* p;    // slice pointer
  104.     unsigned l;    // slice length
  105.     int k;        // slice stride
  106.     FloatSlice(const FloatVec& v, int pos, unsigned lgt, int stride =1);
  107.     FloatSlice(const FloatVec& v, unsigned lgt) {
  108.         V = &(FloatVec&)v;  p = ((FloatVec&)v).pt();  l = lgt;  k = 1;
  109.     }
  110.     FloatSlice(const FloatSlice&);
  111.     friend FloatVec;
  112. public:
  113.     FloatSlice(const FloatPick&);
  114.     FloatSlice(const FloatSlct&);
  115.     ~FloatSlice()        { V->free(); }
  116.     float*    pt()            { return p; }
  117.     const float* pt() const    { return p; }
  118.     unsigned length() const    { return l; }
  119.     int stride() const    { return k; }
  120.     void /*FloatSlice::*/operator=(const FloatVec&);
  121.     void /*FloatSlice::*/operator=(const FloatPick&);
  122.     void /*FloatSlice::*/operator=(const FloatSlct&);
  123.     void /*FloatSlice::*/operator=(const FloatSlice&);
  124.     void /*FloatSlice::*/operator=(float);
  125.     void /*FloatSlice::*/lengthErr(const FloatVec&) const;
  126.     void /*FloatSlice::*/lengthErr(const FloatSlice&) const;
  127.     void /*FloatSlice::*/lengthErr(const IntVec&) const;
  128.     void selectErr(const BitVec&) const;
  129. friend    FloatVec    operator-(const FloatSlice&);
  130. friend    FloatVec    operator++(FloatSlice&);
  131. friend    FloatVec    operator--(FloatSlice&);
  132. friend    FloatVec    operator*(const FloatSlice&,const FloatSlice&);
  133. friend    FloatVec    operator/(const FloatSlice&,const FloatSlice&);
  134. friend    FloatVec    operator+(const FloatSlice&,const FloatSlice&);
  135. friend    FloatVec    operator-(const FloatSlice&,const FloatSlice&);
  136. friend    FloatVec    operator*(const FloatSlice&,float);
  137. friend    FloatVec    operator*(float s,const FloatSlice& V)  { return V*s; }
  138. friend    FloatVec    operator/(const FloatSlice&,float);
  139. friend    FloatVec    operator/(float,const FloatSlice&);
  140. friend    FloatVec    operator+(const FloatSlice&,float);
  141. friend    FloatVec    operator+(float s,const FloatSlice& V)  { return V+s; }
  142. friend    FloatVec    operator-(const FloatSlice&,float);
  143. friend    FloatVec    operator-(float,const FloatSlice&);
  144. friend    BitVec        operator<(const FloatSlice&,const FloatSlice&);
  145. friend    BitVec        operator>(const FloatSlice& U,const FloatSlice& V)  { return V < U; }
  146. friend    BitVec        operator<=(const FloatSlice&,const FloatSlice&);
  147. friend    BitVec        operator>=(const FloatSlice& U,const FloatSlice& V)  { return V <= U; }
  148. friend    BitVec        operator==(const FloatSlice&,const FloatSlice&);
  149. friend    BitVec        operator!=(const FloatSlice&,const FloatSlice&);
  150. friend    BitVec        operator<(const FloatSlice&,float);
  151. friend    BitVec        operator<(float s,const FloatSlice& V)  { return V>s; }
  152. friend    BitVec        operator>(const FloatSlice&,float);
  153. friend    BitVec        operator>(float s,const FloatSlice& V)  { return V<s; }
  154. friend    BitVec        operator<=(const FloatSlice&,float);
  155. friend    BitVec        operator<=(float s,const FloatSlice& V)  { return V>=s; }
  156. friend    BitVec        operator>=(const FloatSlice&,float);
  157. friend    BitVec        operator>=(float s,const FloatSlice& V)  { return V<=s; }
  158. friend    BitVec        operator==(const FloatSlice&,float);
  159. friend    BitVec        operator==(float s,const FloatSlice& V)  { return V==s; }
  160. friend    BitVec        operator!=(const FloatSlice&,float);
  161. friend    BitVec        operator!=(float s,const FloatSlice& V)  { return V!=s; }
  162. friend    void        operator+=(FloatSlice&,const FloatSlice&);
  163. friend    void        operator+=(FloatSlice&,float);
  164. friend    void        operator-=(FloatSlice&,const FloatSlice&);
  165. friend    void        operator-=(FloatSlice&,float);
  166. friend    void        operator*=(FloatSlice&,const FloatSlice&);
  167. friend    void        operator*=(FloatSlice&,float);
  168. friend    void        operator/=(FloatSlice&,const FloatSlice&);
  169. friend    void        operator/=(FloatSlice&,float);
  170.     FloatVec    apply(mathFunTy) const;
  171. friend    FloatVec    abs(const FloatSlice& V);
  172. friend    FloatVec    acos(const FloatSlice& V)    { return V.apply(acos); }
  173. friend    FloatVec    asin(const FloatSlice& V)    { return V.apply(asin); }
  174. friend    FloatVec    atan(const FloatSlice& V)    { return V.apply(atan); }
  175. friend    FloatVec    atan2(const FloatSlice&,const FloatSlice&);
  176. friend    FloatVec    ceil(const FloatSlice& V)    { return V.apply(ceil); }
  177. friend    FloatVec    cos(const FloatSlice& V)    { return V.apply(cos); }
  178. friend    FloatVec    cosh(const FloatSlice& V)    { return V.apply(cosh); }
  179. friend    FloatVec    cumsum(const FloatSlice&);
  180. friend    FloatVec    delta(const FloatSlice&);
  181. friend    float        dot(const FloatSlice&,const FloatSlice&);
  182. friend    FloatVec    exp(const FloatSlice& V)    { return V.apply(exp); }
  183. friend    FloatVec    floor(const FloatSlice& V)    { return V.apply(floor); }
  184. friend    FloatVec    log(const FloatSlice& V)    { return V.apply(log); }
  185. friend    int        max(const FloatSlice&);
  186. friend    int        min(const FloatSlice&);
  187. friend    float        prod(const FloatSlice&);
  188. friend    FloatVec    pow(const FloatSlice&,const FloatSlice&);
  189. friend    FloatVec    reverse(const FloatSlice&);
  190. friend    FloatVec    sin(const FloatSlice& V)    { return V.apply(sin); }
  191. friend    FloatVec    sinh(const FloatSlice& V)    { return V.apply(sinh); }
  192. friend    FloatVec    sqrt(const FloatSlice& V)    { return V.apply(sqrt); }
  193. friend    float        sum(const FloatSlice&);
  194. friend    FloatVec    tan(const FloatSlice& V)    { return V.apply(tan); }
  195. friend    FloatVec    tanh(const FloatSlice& V)    { return V.apply(tanh); }
  196. };
  197.  
  198. class FloatPick : public NIHCL {
  199.     FloatVec* V;
  200.     const IntVec* X;
  201.     FloatPick(const FloatVec& v,const IntVec& x)    { V = &(FloatVec&)v;  X = &x; }
  202.     FloatPick(const FloatPick& s)            { V = s.V; X = s.X; }
  203.     friend FloatVec;
  204.     friend FloatSlice;
  205.     friend FloatSlct;
  206. public:
  207.     void /*FloatPick::*/operator=(const FloatVec&);
  208.     void /*FloatPick::*/operator=(const FloatPick&);
  209.     void /*FloatPick::*/operator=(const FloatSlct&);
  210.     void /*FloatPick::*/operator=(const FloatSlice&);
  211.     void /*FloatPick::*/operator=(float);
  212.     unsigned length() const    { return X->length(); }
  213. };
  214.  
  215. class FloatSlct: public NIHCL {
  216.     FloatVec* V;
  217.     const BitVec* B;
  218.     FloatSlct(const FloatVec& v, const BitVec& b)    { V = &(FloatVec&)v;  B = &b; }
  219.     FloatSlct(const FloatSlct& s)            { V = s.V; B = s.B; }
  220.     friend FloatVec;
  221.     friend FloatSlice;
  222.     friend FloatPick;
  223. public:
  224.     void /*FloatSlct::*/operator=(const FloatVec&);
  225.     void /*FloatSlct::*/operator=(const FloatPick&);
  226.     void /*FloatSlct::*/operator=(const FloatSlct&);
  227.     void /*FloatSlct::*/operator=(const FloatSlice&);
  228.     void /*FloatSlct::*/operator=(float);
  229.     unsigned length() const    { return B->length(); }
  230. };
  231.  
  232. inline FloatSlice FloatVec::operator()(int pos, unsigned lgt, int stride)
  233. {
  234.     FloatSlice s(*this,pos,lgt,stride);
  235.     return s;
  236. }
  237.  
  238. inline const FloatSlice FloatVec::operator()(int pos, unsigned lgt, int stride) const
  239. {
  240.     const FloatSlice s(*this,pos,lgt,stride);
  241.     return s;
  242. }
  243.  
  244. inline FloatVec::operator FloatSlice()
  245. {
  246.     FloatSlice s(*this,length());
  247.     return s;
  248. }
  249.  
  250. inline FloatVec::operator const FloatSlice() const
  251. {
  252.     const FloatSlice s(*this,length());
  253.     return s;
  254. }
  255.  
  256. inline FloatPick FloatVec::operator[](const IntVec& I)
  257. {
  258.     return FloatPick(*this,I);
  259. }
  260.  
  261. inline const FloatPick FloatVec::operator[](const IntVec& I) const
  262. {
  263.     const FloatPick t(*this,I);
  264.     return t;
  265. }
  266.  
  267. inline FloatSlct FloatVec::operator[](const BitVec& B)
  268. {
  269.     return FloatSlct(*this,B);
  270. }
  271.  
  272. inline const FloatSlct FloatVec::operator[](const BitVec& B) const
  273. {
  274.     const FloatSlct t(*this,B);
  275.     return t;
  276. }
  277.  
  278. #endif
  279.