home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / DRWIN101.ZIP / VECUTIL.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-02  |  7.3 KB  |  206 lines
  1. #include "vecutil.hpp"
  2.  
  3.  
  4. void vecerror(char* s) { cout <<"RUNTIME ERROR: "<<s<<'\n'; exit(1); }
  5.  
  6. static Vec _rtnVec(40);                //for calcs
  7.  
  8.  
  9. //---------------------------------------------------------------------------
  10. Vec::Vec()                             //constructor
  11. {
  12.   siz=0;                               //start with none
  13.   x=new double[DEF_SIZ];               //get memory for vector
  14.   loadcoord=0;                         //currently loading first coord
  15.   if (!x) return;                      //oops! no mem
  16.   siz=DEF_SIZ;                         //set size
  17.   Fill();                              //fill'er up wid nils
  18. }   //Vec::Vec(int)
  19.  
  20.  
  21. //---------------------------------------------------------------------------
  22. Vec::Vec(int n)                        //constructor
  23. {
  24.   if (n<=0) n=DEF_SIZ;                 //bad sizension, use 3
  25.   siz=0;                               //start with none
  26.   x=new double[n];                     //get memory for vector
  27.   loadcoord=0;                         //currently loading first coord
  28.   if (!x) return;                      //oops! no mem
  29.   siz=n;                               //set size
  30.   Fill();                              //fill'er up wid nils
  31. }   //Vec::Vec(int)
  32.  
  33.  
  34. //---------------------------------------------------------------------------
  35. Vec::~Vec()                            //destructor
  36. {
  37.   if (x) delete x;                     //kill the coords
  38. }   //Vec::~Vec(void)
  39.  
  40.  
  41. //---------------------------------------------------------------------------
  42. void Vec::Fill(double val) {           //fill with value
  43.   register int i;                      //index register
  44.   for (i=0;i<siz;i++) x[i]=val;        //store it
  45.   loadcoord=0;                         //currently loading first coord
  46. }   //Vec::Fill
  47.  
  48.  
  49. //---------------------------------------------------------------------------
  50. void Vec::Show(void)                   //display as text
  51. {
  52.   cout <<'('<<x[0];
  53.   for (int i=1;i<siz;i++) cout <<','<<x[i];
  54.   cout <<')';
  55. }   //Vec::Show(void)
  56.  
  57.  
  58. //---------------------------------------------------------------------------
  59. void Vec::operator =(Vec& v)           //assignment
  60. {
  61.   int m=MIN(siz,v.siz);                //check size
  62.   for (int i=0;i<m;i++) x[i]=v.x[i];   //copy each one that fits
  63.   for (;i<siz;i++) x[i]=0.0;           //fill the rest with zeros
  64.   loadcoord=0;                         //currently loading first coord
  65. }   //Vec::=(Vec&)
  66.  
  67.  
  68. //---------------------------------------------------------------------------
  69. void Vec::operator =(double a)         //assignment, fill with double
  70. {
  71.   Fill(a);                             //fill'er up
  72.   loadcoord=0;                         //currently loading first coord
  73. }   //Vec::=(double)
  74.  
  75.  
  76. //---------------------------------------------------------------------------
  77. Vec& Vec::operator +=(Vec& v)          //add to
  78. {
  79.   int m=MIN(siz,v.siz);                //find number to copy
  80.   for (int i=0;i<m;i++) x[i]+=v.x[i];  //add to
  81.   return *this;
  82. }   //Vec::+=(Vec&)
  83.  
  84.  
  85. //---------------------------------------------------------------------------
  86. Vec& Vec::operator -=(Vec& v)          //subtract from
  87. {
  88.   int m=MIN(siz,v.siz);                //find number to copy
  89.   for (int i=0;i<m;i++) x[i]-=v.x[i];  //subtract from
  90.   return *this;
  91. }   //Vec::+=(Vec&)
  92.  
  93.  
  94. //---------------------------------------------------------------------------
  95. Vec& Vec::operator *=(double a)        //scalar product
  96. {
  97.   for (int i=0;i<siz;i++) x[i]*=a;     //multiply through
  98.   loadcoord=0;                         //currently loading first coord
  99.   return *this;
  100. }   //Vec::*=(double a)
  101.  
  102.  
  103. //---------------------------------------------------------------------------
  104. Vec& Vec::operator /=(double a)        //scalar quotient
  105. {
  106.   loadcoord=0;                         //currently loading first coord
  107.   if (a==0.0) return *this;            //can't divide by 0
  108.   for (int i=0;i<siz;i++) x[i]/=a;     //multiply through
  109.   return *this;
  110. }   //Vec::/=(double a)
  111.  
  112.  
  113. //---------------------------------------------------------------------------
  114. double Vec::operator !(void)           //scalar length
  115. {
  116.   double dot=0.0;
  117.   for (int i=0;i<siz;i++) dot += x[i]*x[i];   //get dot product
  118.   return sqrt(dot);                    //return square root of dot product
  119. }   //!(Vec&)
  120.  
  121.  
  122. //---------------------------------------------------------------------------
  123. Vec& Vec::operator <<(double a)
  124. {
  125.   if (loadcoord>=siz) loadcoord=0;
  126.   x[loadcoord++]=a;
  127.   return *this;
  128. }   //Vec::<<(double)
  129.  
  130.  
  131. //---------------------------------------------------------------------------
  132. Vec operator +(Vec& u,Vec& v)          //vector addition
  133. {
  134.   int i;
  135.  
  136.   _rtnVec.siz=MAX(u.siz,v.siz);
  137.   if (u.siz<v.siz) {                            //if u is smaller..
  138.     for (i=0;i<u.siz;i++) _rtnVec.x[i]=u.x[i]+v.x[i]; //..copy up to u's coords
  139.     for (;i<_rtnVec.siz;i++) _rtnVec.x[i]=v.x[i];           //..finish with v's
  140.   }
  141.   else {                                        //otherwise v is smaller
  142.     for (i=0;i<v.siz;i++) _rtnVec.x[i]=u.x[i]+v.x[i]; //..copy up to v's coords
  143.     for (;i<_rtnVec.siz;i++) _rtnVec.x[i]=u.x[i];           //..finish with u's
  144.   }
  145.   return _rtnVec;
  146. }   //Vec +(Vec&,Vec&)
  147.  
  148.  
  149. //---------------------------------------------------------------------------
  150. Vec operator -(Vec& u,Vec& v)          //vector addition
  151. {
  152.   int i;
  153.  
  154.   _rtnVec.siz=MAX(u.siz,v.siz);
  155.   if (u.siz<v.siz) {                            //if u is smaller..
  156.     for (i=0;i<u.siz;i++) _rtnVec.x[i]=u.x[i]-v.x[i]; //..copy up to u's coords
  157.     for (;i<_rtnVec.siz;i++) _rtnVec.x[i]=-v.x[i];    //..finish with v's
  158.   }
  159.   else {                                        //otherwise v is smaller
  160.     for (i=0;i<v.siz;i++) _rtnVec.x[i]=u.x[i]-v.x[i]; //..copy up to v's coords
  161.     for (;i<_rtnVec.siz;i++) _rtnVec.x[i]=u.x[i];     //..finish with u's
  162.   }
  163.   return _rtnVec;
  164. }   //Vec -(Vec&,Vec&)
  165.  
  166.  
  167. //---------------------------------------------------------------------------
  168. double operator *(Vec& u,Vec& v)       //inner (dot) product
  169. {
  170.   double dot=0.0;                      //dot product
  171.   int m=MAX(u.siz,v.siz);              //get smallest sizension
  172.   for (int i=0;i<m;i++) dot += u.x[i]*v.x[i];  //calculate dot product
  173.   return dot;
  174. }   //double *(Vec&,Vec&)
  175.  
  176.  
  177. //---------------------------------------------------------------------------
  178. Vec operator *(Vec& v,double a)        //scalar product
  179. {
  180.   _rtnVec.siz=v.siz;
  181.   _rtnVec=v;                           //copy it
  182.   _rtnVec*=a;                          //scalar product
  183.   return _rtnVec;                      //give it to 'em
  184. }   //Vec *(Vec&,double)
  185.  
  186.  
  187. //---------------------------------------------------------------------------
  188. double operator >>(Vec& u,Vec& v)      //angle between vectors, radians
  189. {
  190.   double dot=u*v;                      //dot product of u,v
  191.   double times=!u*!v;                  //product of lengths
  192.   if (times==0.0) return M_PI_2;       //pi/2 if they're orthogonal
  193.   return acos(dot/times);              //give'm the number
  194. }   //double *(Vec&,Vec&)
  195.  
  196.  
  197. //---------------------------------------------------------------------------
  198. ostream& operator<<(ostream& out,Vec& v)  //for cout use
  199. {
  200.   out << '(' << v.x[0];
  201.   for (int i=1;i<v.siz;i++) out <<','<<v.x[i];
  202.   out << ')';
  203.   return out;
  204. }   //operator<<(ostream& out,Vec& v)
  205.  
  206.