home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / rwvector.lha / RWVector2.1 / src / xvecop.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-18  |  6.6 KB  |  320 lines
  1. /*
  2.  *    Definitions for various arithmetic operations
  3.  *
  4.  *    Copyright (C) 1988, 1989.
  5.  *
  6.  *    Dr. Thomas Keffer
  7.  *    Rogue Wave Associates
  8.  *    P.O. Box 85341
  9.  *    Seattle WA 98145-1341
  10.  *
  11.  *    Permission to use, copy, modify, and distribute this
  12.  *    software and its documentation for any purpose and
  13.  *    without fee is hereby granted, provided that the
  14.  *    above copyright notice appear in all copies and that
  15.  *    both that copyright notice and this permission notice
  16.  *    appear in supporting documentation.
  17.  *    
  18.  *    This software is provided "as is" without any
  19.  *    expressed or implied warranty.
  20.  *
  21.  *
  22.  *    @(#)xvecop.cc    2.1    8/18/89
  23.  */
  24.  
  25. #define NO_VECTOR_MATHFUN
  26. #include "rw/<T>Vec.h"
  27. #define TYPE <T>_TYPE
  28. #include "vecdefs.h"
  29.  
  30. // Unary minus on a <T>Vec
  31. <T>Vec
  32. operator-(const <T>Vec& s)
  33. {
  34.   register i = s.length();
  35.   <T>Vec temp(i);
  36.   register <T>* sp = s.data();
  37.   register <T>* dp = temp.data();
  38.   register j = s.stride();
  39.   while (i--) { *dp++ = -(*sp);  sp += j; }
  40.   return temp;
  41. }
  42.  
  43. #if HAS_INCRDECR
  44. // Unary increment on a <T>Vec
  45. <T>Vec&
  46. <T>Vec::operator++()
  47. {
  48.   register i = length();
  49.   register <T>* sp = data();
  50.   register j = stride();
  51.   while (i--) { ++(*sp); sp += j; }
  52.   return *this;
  53. }
  54.  
  55. // Unary decrement on a <T>Vec
  56. <T>Vec&
  57. <T>Vec::operator--()
  58. {
  59.   register i = length();
  60.   register <T>* sp = data();
  61.   register j = stride();
  62.   while (i--) { --(*sp); sp += j; }
  63.   return *this;
  64. }
  65.  
  66. #endif
  67.  
  68. // Binary multiply element-by-element
  69. <T>Vec
  70. operator*(const <T>Vec& u, const <T>Vec& v)
  71. {
  72.   register i = v.length();
  73.   u.lengthCheck(i);
  74.   <T>Vec temp(i);
  75.   register <T>* up = u.data();
  76.   register <T>* vp = v.data();
  77.   register <T>* dp = temp.data();
  78.   register uj = u.stride();
  79.   register vj = v.stride();
  80.   while (i--) { *dp++ = *up * *vp;  up += uj; vp += vj; }
  81.   return temp;
  82. }
  83.  
  84. #if HAS_DIVIDE
  85. // Binary divide element-by-element
  86. <T>Vec
  87. operator/(const <T>Vec& u, const <T>Vec& v)
  88. {
  89.   register i = v.length();
  90.   u.lengthCheck(i);
  91.   <T>Vec temp(i);
  92.   register <T>* up = u.data();
  93.   register <T>* vp = v.data();
  94.   register <T>* dp = temp.data();
  95.   register uj = u.stride();
  96.   register vj = v.stride();
  97.   while (i--) { *dp++ = *up / *vp;  up += uj; vp += vj; }
  98.   return temp;
  99. }
  100. #endif
  101.  
  102. // Binary add element-by-element
  103. <T>Vec
  104. operator+(const <T>Vec& u, const <T>Vec& v)
  105. {
  106.   register i = v.length();
  107.   u.lengthCheck(i);
  108.   <T>Vec temp(i);
  109.   register <T>* up = u.data();
  110.   register <T>* vp = v.data();
  111.   register <T>* dp = temp.data();
  112.   register uj = u.stride();
  113.   register vj = v.stride();
  114.   while (i--) { *dp++ = *up + *vp;  up += uj; vp += vj; }
  115.   return temp;
  116. }
  117.  
  118. // Binary subtract element-by-element
  119. <T>Vec
  120. operator-(const <T>Vec& u, const <T>Vec& v)
  121. {
  122.   register i = v.length();
  123.   u.lengthCheck(i);
  124.   <T>Vec temp(i);
  125.   register <T>* up = u.data();
  126.   register <T>* vp = v.data();
  127.   register <T>* dp = temp.data();
  128.   register uj = u.stride();
  129.   register vj = v.stride();
  130.   while (i--) { *dp++ = *up - *vp;  up += uj; vp += vj; }
  131.   return temp;
  132. }
  133.  
  134. // Multiply by a scalar
  135. <T>Vec
  136. operator*(const <T>Vec& s, <T> scalar)
  137. {
  138.   register i = s.length();
  139.   <T>Vec temp(i);
  140.   register <T>* sp = s.data();
  141.   register <T>* dp = temp.data();
  142.   register j = s.stride();
  143.   REGISTER <T> c = scalar;
  144.   while (i--) { *dp++ = *sp * c; sp += j; }
  145.   return temp;
  146. }
  147.  
  148. #if HAS_DIVIDE
  149. // Divide by a scalar
  150. <T>Vec
  151. operator/(const <T>Vec& s, <T> scalar)
  152. {
  153.   register i = s.length();
  154.   <T>Vec temp(i);
  155.   register <T>* sp = s.data();
  156.   register <T>* dp = temp.data();
  157.   register j = s.stride();
  158.   REGISTER <T> c = scalar;
  159.   while (i--) { *dp++ = *sp / c; sp += j; }
  160.   return temp;
  161. }
  162.  
  163. // Divide into a scalar
  164. <T>Vec
  165. operator/(<T> scalar, const <T>Vec& s)
  166. {
  167.   register i = s.length();
  168.   <T>Vec temp(i);
  169.   register <T>* sp = s.data();
  170.   register <T>* dp = temp.data();
  171.   register j = s.stride();
  172.   REGISTER <T> c = scalar;
  173.   while (i--) { *dp++ = c / *sp; sp += j; }
  174.   return temp;
  175. }
  176. #endif
  177.  
  178. // Add a scalar
  179. <T>Vec
  180. operator+(const <T>Vec& s, <T> scalar)
  181. {
  182.   register i = s.length();
  183.   <T>Vec temp(i);
  184.   register <T>* sp = s.data();
  185.   register <T>* dp = temp.data();
  186.   register j = s.stride();
  187.   REGISTER <T> c = scalar;
  188.   while (i--) { *dp++ = *sp + c; sp += j; }
  189.   return temp;
  190. }
  191.  
  192. // Subtract a scalar
  193. <T>Vec
  194. operator-(const <T>Vec& s, <T> scalar)
  195. {
  196.   register i = s.length();
  197.   <T>Vec temp(i);
  198.   register <T>* sp = s.data();
  199.   register <T>* dp = temp.data();
  200.   register j = s.stride();
  201.   REGISTER <T> c = scalar;
  202.   while (i--) { *dp++ = *sp - c; sp += j; }
  203.   return temp;
  204. }
  205.  
  206. // Subtract from a scalar
  207. <T>Vec
  208. operator-(<T> scalar, const <T>Vec& s)
  209. {
  210.   register i = s.length();
  211.   <T>Vec temp(i);
  212.   register <T>* sp = s.data();
  213.   register <T>* dp = temp.data();
  214.   register j = s.stride();
  215.   REGISTER <T> c = scalar;
  216.   while (i--) { *dp++ = c - *sp; sp += j; }
  217.   return temp;
  218. }
  219.  
  220. /******** Arithmetic assignment operators **********/
  221.  
  222. <T>Vec&
  223. <T>Vec::operator+=(const <T>Vec& u)
  224. {
  225.   register i = u.length();
  226.   lengthCheck(i);
  227.   register <T>* up = u.data();
  228.   register <T>* tp = data();
  229.   register uj = u.stride();
  230.   register tj = stride();
  231.   while (i--) { *tp += *up;  up += uj; tp += tj; }
  232.   return *this;
  233. }
  234.  
  235. <T>Vec&
  236. <T>Vec::operator+=(<T> scalar)
  237. {
  238.   register i = length();
  239.   register <T>* tp = data();
  240.   register tj = stride();
  241.   REGISTER <T> c = scalar;
  242.   while (i--) { *tp += c; tp += tj; }
  243.   return *this;
  244. }
  245.  
  246. <T>Vec&
  247. <T>Vec::operator-=(const <T>Vec& u)
  248. {
  249.   register i = u.length();
  250.   lengthCheck(i);
  251.   register <T>* up = u.data();
  252.   register <T>* tp = data();
  253.   register uj = u.stride();
  254.   register tj = stride();
  255.   while (i--) { *tp -= *up;  up += uj; tp += tj; }
  256.   return *this;
  257. }
  258.  
  259. <T>Vec&
  260. <T>Vec::operator-=(<T> scalar)
  261. {
  262.   register i = length();
  263.   register <T>* tp = data();
  264.   register tj = stride();
  265.   REGISTER <T> c = scalar;
  266.   while (i--) { *tp -= c; tp += tj; }
  267.   return *this;
  268. }
  269.  
  270. <T>Vec&
  271. <T>Vec::operator*=(const <T>Vec& u)
  272. {
  273.   register i = u.length();
  274.   lengthCheck(i);
  275.   register <T>* up = u.data();
  276.   register <T>* tp = data();
  277.   register uj = u.stride();
  278.   register tj = stride();
  279.   while (i--) { *tp *= *up;  up += uj; tp += tj; }
  280.   return *this;
  281. }
  282.  
  283. <T>Vec&
  284. <T>Vec::operator*=(<T> scalar)
  285. {
  286.   register i = length();
  287.   register <T>* tp = data();
  288.   register tj = stride();
  289.   REGISTER <T> c = scalar;
  290.   while (i--) { *tp *= c; tp += tj; }
  291.   return *this;
  292. }
  293.  
  294. #if HAS_DIVIDE
  295. <T>Vec&
  296. <T>Vec::operator/=(const <T>Vec& u)
  297. {
  298.   register i = u.length();
  299.   lengthCheck(i);
  300.   register <T>* up = u.data();
  301.   register <T>* tp = data();
  302.   register uj = u.stride();
  303.   register tj = stride();
  304.   while (i--) { *tp /= *up;  up += uj; tp += tj; }
  305.   return *this;
  306. }
  307.  
  308. <T>Vec&
  309. <T>Vec::operator/=(<T> scalar)
  310. {
  311.   register i = length();
  312.   register <T>* tp = data();
  313.   register tj = stride();
  314.   REGISTER <T> c = scalar;
  315.   while (i--) { *tp /= c; tp += tj; }
  316.   return *this;
  317. }
  318.  
  319. #endif
  320.