开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
globals.hpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：25k
源码类别：

生物技术

开发平台：

C/C++

globals.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: globals.hpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:48:46  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.8
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef GUI_MATH___GLOBALS__HPP
  11. #define GUI_MATH___GLOBALS__HPP
  13. /*  $Id: globals.hpp,v 1000.2 2004/06/01 19:48:46 gouriano Exp $
  14.  * ===========================================================================
  15.  *
  16.  *                            PUBLIC DOMAIN NOTICE
  17.  *               National Center for Biotechnology Information
  18.  *
  19.  *  This software / database is a "United States Government Work" under the
  20.  *  terms of the United States Copyright Act.  It was written as part of
  21.  *  the author's official duties as a United States Government employee and
  22.  *  thus cannot be copyrighted.  This software / database is freely available
  23.  *  to the public for use. The National Library of Medicine and the U.S.
  24.  *  Government have not placed any restriction on its use or reproduction.
  25.  *
  26.  *  Although all reasonable efforts have been taken to ensure the accuracy
  27.  *  and reliability of the software and data, the NLM and the U.S.
  28.  *  Government do not and cannot warrant the performance or results that
  29.  *  may be obtained by using this software or data. The NLM and the U.S.
  30.  *  Government disclaim all warranties, express or implied, including
  31.  *  warranties of performance, merchantability or fitness for any particular
  32.  *  purpose.
  33.  *
  34.  *  Please cite the author in any work or product based on this material.
  35.  *
  36.  * ===========================================================================
  37.  *
  38.  * Authors:  Mike DiCuccio
  39.  *
  40.  * File Description:
  41.  *
  42.  */
  44. #include <corelib/ncbistd.hpp>
  45. #include <vector>
  47. /** @addtogroup GUI_MATH
  48.  *
  49.  * @{
  50.  */
  52. BEGIN_NCBI_SCOPE
  54. // predeclarations of the types we use
  55. template <class T> class CVect2;
  56. template <class T> class CVect3;
  57. template <class T> class CVect4;
  58. template <class T> class CMatrix3;
  59. template <class T> class CMatrix4;
  61. END_NCBI_SCOPE
  63. // Promotion rules
  64. // we keep these in a separate file because they're long
  65. #include <gui/math/promote.hpp>
  67. #include <gui/math/vect2.hpp>
  68. #include <gui/math/vect3.hpp>
  69. #include <gui/math/vect4.hpp>
  70. #include <gui/math/matrix3.hpp>
  71. #include <gui/math/matrix4.hpp>
  73. // general utilities
  74. #include <math.h>
  75. #include <gui/math/math.hpp>
  78. BEGIN_NCBI_SCOPE
  80. //
  81. //
  82. // Global operators
  83. //
  84. //
  88. //
  89. // 
  90. // CVect<> templates
  91. // 
  92. //
  94. //
  95. // global addition: CVect*<> + CVect*<>
  96. //
  97. template <class T, class U>
  98. inline CVect2< NCBI_PROMOTE(T,U) >
  99. operator+ (const CVect2<T>& v1, const CVect2<U>& v2)
  100. {
  101.     return
  102.         CVect2< NCBI_PROMOTE(T,U) >
  103.         (v1[0]+v2[0], v1[1]+v2[1]);
  104. }
  107. template <class T, class U>
  108. inline CVect3< NCBI_PROMOTE(T,U) >
  109. operator+ (const CVect3<T>& v1, const CVect3<U>& v2)
  110. {
  111.     return
  112.         CVect3< NCBI_PROMOTE(T,U) >
  113.         (v1[0]+v2[0], v1[1]+v2[1], v1[2]+v2[2]);
  114. }
  117. template <class T, class U>
  118. inline CVect4< NCBI_PROMOTE(T,U) >
  119. operator+ (const CVect4<T>& v1, const CVect4<U>& v2)
  120. {
  121.     return
  122.         CVect4< NCBI_PROMOTE(T,U) >
  123.         (v1[0]+v2[0], v1[1]+v2[1], v1[2]+v2[2], v1[3]+v2[3]);
  124. }
  127. //
  128. // global addition: const + CVect*<>
  129. // we do this with macros because not all compilers support partial template
  130. // specialization
  131. //
  133. #define NCBI_ADD_VECT2(type) 
  134. template <class U> 
  135. inline CVect2< NCBI_PROMOTE(type,U) > 
  136. operator+ (type v1, const CVect2<U>& v2) 
  137. { 
  138.     return 
  139.         CVect2< NCBI_PROMOTE(type,U) > 
  140.         (v1 + v2[0], v1 + v2[1]); 
  141. } 
  142. template <class T> 
  143. inline CVect2< NCBI_PROMOTE(T,type) > 
  144. operator+ (const CVect2<T>& v1, type v2) 
  145. { 
  146.     return 
  147.         CVect2< NCBI_PROMOTE(T,type) > 
  148.         (v1[0] + v2, v1[1] + v2); 
  149. }
  152. NCBI_ADD_VECT2(int)
  153. NCBI_ADD_VECT2(float)
  154. NCBI_ADD_VECT2(double)
  156. #undef NCBI_ADD_VECT2
  159. #define NCBI_ADD_VECT3(type) 
  160. template <class U> 
  161. inline CVect3< NCBI_PROMOTE(type,U) > 
  162. operator+ (type v1, const CVect3<U>& v2) 
  163. { 
  164.     return 
  165.         CVect3< NCBI_PROMOTE(type,U) > 
  166.         (v1 + v2[0], v1 + v2[1], v1 + v2[2]); 
  167. } 
  168. template <class T> 
  169. inline CVect3< NCBI_PROMOTE(T,type) > 
  170. operator+ (const CVect3<T>& v1, type v2) 
  171. { 
  172.     return 
  173.         CVect3< NCBI_PROMOTE(T,type) > 
  174.         (v1[0] + v2, v1[1] + v2, v1[2] + v2); 
  175. }
  178. NCBI_ADD_VECT3(int)
  179. NCBI_ADD_VECT3(float)
  180. NCBI_ADD_VECT3(double)
  182. #undef NCBI_ADD_VECT3
  185. #define NCBI_ADD_VECT4(type) 
  186. template <class U> 
  187. inline CVect4< NCBI_PROMOTE(type,U) > 
  188. operator+ (type v1, const CVect4<U>& v2) 
  189. { 
  190.     return 
  191.         CVect4< NCBI_PROMOTE(type,U) > 
  192.         (v1 + v2[0], v1 + v2[1], v1 + v2[2], v1 + v2[3]); 
  193. } 
  194. template <class T> 
  195. inline CVect4< NCBI_PROMOTE(T,type) > 
  196. operator+ (const CVect4<T>& v1, type v2) 
  197. { 
  198.     return 
  199.         CVect4< NCBI_PROMOTE(T,type) > 
  200.         (v1[0] + v2, v1[1] + v2, v1[2] + v2, v1[3] + v2); 
  201. }
  204. NCBI_ADD_VECT4(int)
  205. NCBI_ADD_VECT4(float)
  206. NCBI_ADD_VECT4(double)
  208. #undef NCBI_ADD_VECT4
  211. //
  212. // global unary negation
  213. //
  214. template <class T>
  215. inline CVect2<T>
  216. operator- (const CVect2<T>& v)
  217. {
  218.     return CVect2<T> (-v[0], -v[1]);
  219. }
  222. template <class T>
  223. inline CVect3<T>
  224. operator- (const CVect3<T>& v)
  225. {
  226.     return CVect3<T> (-v[0], -v[1], -v[2]);
  227. }
  230. template <class T>
  231. inline CVect4<T>
  232. operator- (const CVect4<T>& v)
  233. {
  234.     return CVect4<T> (-v[0], -v[1], -v[2], -v[3]);
  235. }
  237. //
  238. // global subtraction: CVect*<> - CVect*<>
  239. //
  240. template <class T, class U>
  241. inline CVect2< NCBI_PROMOTE(T,U) >
  242. operator- (const CVect2<T>& v1, const CVect2<U>& v2)
  243. {
  244.     return
  245.         CVect2< NCBI_PROMOTE(T,U) >
  246.         (v1[0]-v2[0], v1[1]-v2[1]);
  247. }
  250. template <class T, class U>
  251. inline CVect3< NCBI_PROMOTE(T,U) >
  252. operator- (const CVect3<T>& v1, const CVect3<U>& v2)
  253. {
  254.     return
  255.         CVect3< NCBI_PROMOTE(T,U) >
  256.         (v1[0]-v2[0], v1[1]-v2[1], v1[2]-v2[2]);
  257. }
  260. template <class T, class U>
  261. inline CVect4< NCBI_PROMOTE(T,U) >
  262. operator- (const CVect4<T>& v1, const CVect4<U>& v2)
  263. {
  264.     return
  265.         CVect4< NCBI_PROMOTE(T,U) >
  266.         (v1[0]-v2[0], v1[1]-v2[1], v1[2]-v2[2], v1[3]-v2[3]);
  267. }
  270. //
  271. // global subtraction: const + CVect*<>
  272. // we do this with macros because not all compilers support partial template
  273. // specialization
  274. //
  276. #define NCBI_SUBTRACT_VECT2(type) 
  277. template <class U> 
  278. inline CVect2< NCBI_PROMOTE(type,U) > 
  279. operator- (type v1, const CVect2<U>& v2) 
  280. { 
  281.     return 
  282.         CVect2< NCBI_PROMOTE(type,U) > 
  283.         (v1 - v2[0], v1 - v2[1]); 
  284. } 
  285. template <class T> 
  286. inline CVect2< NCBI_PROMOTE(T,type) > 
  287. operator- (const CVect2<T>& v1, type v2) 
  288. { 
  289.     return 
  290.         CVect2< NCBI_PROMOTE(T,type) > 
  291.         (v1[0] - v2, v1[1] - v2); 
  292. }
  295. NCBI_SUBTRACT_VECT2(int)
  296. NCBI_SUBTRACT_VECT2(float)
  297. NCBI_SUBTRACT_VECT2(double)
  299. #undef NCBI_SUBTRACT_VECT2
  302. #define NCBI_SUBTRACT_VECT3(type) 
  303. template <class U> 
  304. inline CVect3< NCBI_PROMOTE(type,U) > 
  305. operator- (type v1, const CVect3<U>& v2) 
  306. { 
  307.     return 
  308.         CVect3< NCBI_PROMOTE(type,U) > 
  309.         (v1 - v2[0], v1 - v2[1], v1 - v2[2]); 
  310. } 
  311. template <class T> 
  312. inline CVect3< NCBI_PROMOTE(T,type) > 
  313. operator- (const CVect3<T>& v1, type v2) 
  314. { 
  315.     return 
  316.         CVect3< NCBI_PROMOTE(T,type) > 
  317.         (v1[0] - v2, v1[1] - v2, v1[2] - v2); 
  318. }
  321. NCBI_SUBTRACT_VECT3(int)
  322. NCBI_SUBTRACT_VECT3(float)
  323. NCBI_SUBTRACT_VECT3(double)
  325. #undef NCBI_SUBTRACT_VECT3
  328. #define NCBI_SUBTRACT_VECT4(type) 
  329. template <class U> 
  330. inline CVect4< NCBI_PROMOTE(type,U) > 
  331. operator- (type v1, const CVect4<U>& v2) 
  332. { 
  333.     return 
  334.         CVect4< NCBI_PROMOTE(type,U) > 
  335.         (v1 - v2[0], v1 - v2[1], v1 - v2[2], v1 - v2[3]); 
  336. } 
  337. template <class T> 
  338. inline CVect4< NCBI_PROMOTE(T,type) > 
  339. operator- (const CVect4<T>& v1, type v2) 
  340. { 
  341.     return 
  342.         CVect4< NCBI_PROMOTE(T,type) > 
  343.         (v1[0] - v2, v1[1] - v2, v1[2] - v2, v1[3] - v2); 
  344. }
  347. NCBI_SUBTRACT_VECT4(int)
  348. NCBI_SUBTRACT_VECT4(float)
  349. NCBI_SUBTRACT_VECT4(double)
  351. #undef NCBI_SUBTRACT_VECT4
  355. //
  356. // global subtraction: const + CVect*<>
  357. // we do this with macros because not all compilers support partial template
  358. // specialization
  359. //
  361. #define NCBI_MULTIPLY_VECT2(type) 
  362. template <class U> 
  363. inline CVect2< NCBI_PROMOTE(type,U) > 
  364. operator* (type v1, const CVect2<U>& v2) 
  365. { 
  366.     return 
  367.         CVect2< NCBI_PROMOTE(type,U) > 
  368.         (v1 * v2[0], v1 * v2[1]); 
  369. } 
  370. template <class T> 
  371. inline CVect2< NCBI_PROMOTE(T,type) > 
  372. operator* (const CVect2<T>& v1, type v2) 
  373. { 
  374.     return 
  375.         CVect2< NCBI_PROMOTE(T,type) > 
  376.         (v1[0] * v2, v1[1] * v2); 
  377. }
  380. NCBI_MULTIPLY_VECT2(int)
  381. NCBI_MULTIPLY_VECT2(float)
  382. NCBI_MULTIPLY_VECT2(double)
  384. #undef NCBI_MULTIPLY_VECT2
  387. #define NCBI_MULTIPLY_VECT3(type) 
  388. template <class U> 
  389. inline CVect3< NCBI_PROMOTE(type,U) > 
  390. operator* (type v1, const CVect3<U>& v2) 
  391. { 
  392.     return 
  393.         CVect3< NCBI_PROMOTE(type,U) > 
  394.         (v1 * v2[0], v1 * v2[1], v1 * v2[2]); 
  395. } 
  396. template <class T> 
  397. inline CVect3< NCBI_PROMOTE(T,type) > 
  398. operator* (const CVect3<T>& v1, type v2) 
  399. { 
  400.     return 
  401.         CVect3< NCBI_PROMOTE(T,type) > 
  402.         (v1[0] * v2, v1[1] * v2, v1[2] * v2); 
  403. }
  406. NCBI_MULTIPLY_VECT3(int)
  407. NCBI_MULTIPLY_VECT3(float)
  408. NCBI_MULTIPLY_VECT3(double)
  410. #undef NCBI_MULTIPLY_VECT3
  413. #define NCBI_MULTIPLY_VECT4(type) 
  414. template <class U> 
  415. inline CVect4< NCBI_PROMOTE(type,U) > 
  416. operator* (type v1, const CVect4<U>& v2) 
  417. { 
  418.     return 
  419.         CVect4< NCBI_PROMOTE(type,U) > 
  420.         (v1 * v2[0], v1 * v2[1], v1 * v2[2], v1 * v2[3]); 
  421. } 
  422. template <class T> 
  423. inline CVect4< NCBI_PROMOTE(T,type) > 
  424. operator* (const CVect4<T>& v1, type v2) 
  425. { 
  426.     return 
  427.         CVect4< NCBI_PROMOTE(T,type) > 
  428.         (v1[0] * v2, v1[1] * v2, v1[2] * v2, v1[3] * v2); 
  429. }
  432. NCBI_MULTIPLY_VECT4(int)
  433. NCBI_MULTIPLY_VECT4(float)
  434. NCBI_MULTIPLY_VECT4(double)
  436. #undef NCBI_MULTIPLY_VECT4
  442. //
  443. // global multiplication: CVect*<> * CVect*<>
  444. // we define this as dot!
  445. //
  446. template <class T, class U>
  447. inline NCBI_PROMOTE(T,U)
  448. operator* (const CVect2<T>& v1, const CVect2<U>& v2)
  449. {
  450.     return (v1[0] * v2[0] +
  451.             v1[1] * v2[1]);
  452. }
  455. template <class T, class U>
  456. inline NCBI_PROMOTE(T,U)
  457. operator* (const CVect3<T>& v1, const CVect3<U>& v2)
  458. {
  459.     return (v1[0] * v2[0] +
  460.             v1[1] * v2[1] +
  461.             v1[2] * v2[2]);
  462. }
  465. template <class T, class U>
  466. inline NCBI_PROMOTE(T,U)
  467. operator* (const CVect4<T>& v1, const CVect4<U>& v2)
  468. {
  469.     return (v1[0] * v2[0] +
  470.             v1[1] * v2[1] +
  471.             v1[2] * v2[2] +
  472.             v1[3] * v2[3]);
  473. }
  477. //
  478. // global division: CVect*<> / const
  479. //
  480. template <class T, class U>
  481. inline CVect2< NCBI_PROMOTE(T,U) >
  482. operator/ (const CVect2<T>& v1, U v2)
  483. {
  484.     v2 = T(1) / v2;
  485.     return
  486.         CVect2< NCBI_PROMOTE(T,U) >
  487.         (v1[0]*v2, v1[1]*v2);
  488. }
  491. template <class T, class U>
  492. inline CVect3< NCBI_PROMOTE(T,U) >
  493. operator/ (const CVect3<T>& v1, U v2)
  494. {
  495.     v2 = T(1) / v2;
  496.     return
  497.         CVect3< NCBI_PROMOTE(T,U) >
  498.         (v1[0]*v2, v1[1]*v2, v1[2]*v2);
  499. }
  502. template <class T, class U>
  503. inline CVect4< NCBI_PROMOTE(T,U) >
  504. operator/ (const CVect4<T>& v1, U v2)
  505. {
  506.     v2 = T(1) / v2;
  507.     return
  508.         CVect4< NCBI_PROMOTE(T,U) >
  509.         (v1[0]*v2, v1[1]*v2, v1[2]*v2, v1[3]*v2);
  510. }
  513. //
  514. // global comparison: equals
  515. // 
  516. template <class T, class U>
  517. inline bool
  518. operator== (const CVect2<T>& v1, const CVect2<U>& v2)
  519. {
  520.     return (v1[0] == v2[0]  &&  
  521.             v1[1] == v2[1]);
  522. }
  525. template <class T, class U>
  526. inline bool
  527. operator== (const CVect3<T>& v1, const CVect3<U>& v2)
  528. {
  529.     return (v1[0] == v2[0]  &&  
  530.             v1[1] == v2[1]  &&  
  531.             v1[2] == v2[2]);
  532. }
  535. template <class T, class U>
  536. inline bool
  537. operator== (const CVect4<T>& v1, const CVect4<U>& v2)
  538. {
  539.     return (v1[0] == v2[0]  &&  
  540.             v1[1] == v2[1]  &&  
  541.             v1[2] == v2[2]  &&  
  542.             v1[3] == v2[3]);
  543. }
  546. //
  547. // global comparison: less than
  548. // 
  549. template <class T, class U>
  550. inline bool
  551. operator< (const CVect2<T>& v1, const CVect2<U>& v2)
  552. {
  553.     if (v1[0] < v2[0]) {
  554.         return true;
  555.     } else if (v1[0] > v2[0]) {
  556.         return false;
  557.     }
  559.     if (v1[1] < v2[1]) {
  560.         return true;
  561.     }
  563.     return false;
  564. }
  567. template <class T, class U>
  568. inline bool
  569. operator< (const CVect3<T>& v1, const CVect3<U>& v2)
  570. {
  571.     if (v1[0] < v2[0]) {
  572.         return true;
  573.     } else if (v1[0] > v2[0]) {
  574.         return false;
  575.     }
  577.     if (v1[1] < v2[1]) {
  578.         return true;
  579.     } else if (v1[1] > v2[1]) {
  580.         return false;
  581.     }
  583.     if (v1[2] < v2[2]) {
  584.         return true;
  585.     }
  587.     return false;
  588. }
  591. template <class T, class U>
  592. inline bool
  593. operator< (const CVect4<T>& v1, const CVect4<U>& v2)
  594. {
  595.     if (v1[0] < v2[0]) {
  596.         return true;
  597.     } else if (v1[0] > v2[0]) {
  598.         return false;
  599.     }
  601.     if (v1[1] < v2[1]) {
  602.         return true;
  603.     } else if (v1[1] > v2[1]) {
  604.         return false;
  605.     }
  607.     if (v1[2] < v2[2]) {
  608.         return true;
  609.     } else if (v1[2] > v2[2]) {
  610.         return false;
  611.     }
  613.     if (v1[3] < v2[3]) {
  614.         return true;
  615.     }
  617.     return false;
  618. }
  621. //
  622. //
  623. //
  624. // Matrices
  625. //
  626. //
  627. //
  630. //
  631. // global addition: matrix + matrix
  632. //
  633. template <class T, class U>
  634. inline CMatrix3< NCBI_PROMOTE(T,U) >
  635. operator+ (const CMatrix3<T>& m1, const CMatrix3<U>& m2)
  636. {
  637.     return
  638.         CMatrix3< NCBI_PROMOTE(T,U) >
  639.         (m1[0]+m2[0], m1[1]+m2[1], m1[2]+m2[2],
  640.          m1[3]+m2[3], m1[4]+m2[4], m1[5]+m2[5],
  641.          m1[6]+m2[6], m1[7]+m2[7], m1[8]+m2[8]);
  642. }
  645. template <class T, class U>
  646. inline CMatrix4< NCBI_PROMOTE(T,U) >
  647. operator+ (const CMatrix4<T>& m1, const CMatrix4<U>& m2)
  648. {
  649.     return
  650.         CMatrix4< NCBI_PROMOTE(T,U) >
  651.         (m1[ 0]+m2[ 0], m1[ 1]+m2[ 1], m1[ 2]+m2[ 2], m1[ 3]+m2[ 3], 
  652.          m1[ 4]+m2[ 4], m1[ 5]+m2[ 5], m1[ 6]+m2[ 6], m1[ 7]+m2[ 7], 
  653.          m1[ 8]+m2[ 8], m1[ 9]+m2[ 9], m1[10]+m2[10], m1[11]+m2[11], 
  654.          m1[12]+m2[12], m1[13]+m2[13], m1[14]+m2[14], m1[15]+m2[15]);
  655. }
  658. //
  659. // global addition: scalar + matrix
  660. //
  661. #define NCBI_ADD_MATRIX3(type) 
  662. template <class U> 
  663. inline CMatrix3< NCBI_PROMOTE(type,U) > 
  664. operator+ (type s, const CMatrix3<U>& m) 
  665. { 
  666.     return 
  667.         CMatrix3< NCBI_PROMOTE(type,U) > 
  668.         (m[0]+s, m[1]+s, m[2]+s, 
  669.          m[3]+s, m[4]+s, m[5]+s, 
  670.          m[6]+s, m[7]+s, m[8]+s); 
  671. } 
  672. template <class T> 
  673. inline CMatrix3< NCBI_PROMOTE(T,type) > 
  674. operator+ (const CMatrix3<T>& m, type s) 
  675. { 
  676.     return 
  677.         CMatrix3< NCBI_PROMOTE(T,type) > 
  678.         (m[0]+s, m[1]+s, m[2]+s, 
  679.          m[3]+s, m[4]+s, m[5]+s, 
  680.          m[6]+s, m[7]+s, m[8]+s); 
  681. }
  684. NCBI_ADD_MATRIX3(int)
  685. NCBI_ADD_MATRIX3(float)
  686. NCBI_ADD_MATRIX3(double)
  688. #undef NCBI_ADD_MATRIX3
  691. #define NCBI_ADD_MATRIX4(type) 
  692. template <class U> 
  693. inline CMatrix4< NCBI_PROMOTE(type,U) > 
  694. operator+ (type s, const CMatrix4<U>& m) 
  695. { 
  696.     return 
  697.         CMatrix4< NCBI_PROMOTE(type,U) > 
  698.         (m[ 0]+s, m[ 1]+s, m[ 2]+s, m[ 3]+s,  
  699.          m[ 4]+s, m[ 5]+s, m[ 6]+s, m[ 7]+s,  
  700.          m[ 8]+s, m[ 9]+s, m[10]+s, m[11]+s,  
  701.          m[12]+s, m[13]+s, m[14]+s, m[15]+s); 
  702. } 
  703. template <class T> 
  704. inline CMatrix4< NCBI_PROMOTE(T,type) > 
  705. operator+ (const CMatrix4<T>& m, type s) 
  706. { 
  707.     return 
  708.         CMatrix4< NCBI_PROMOTE(T,type) > 
  709.         (m[ 0]+s, m[ 1]+s, m[ 2]+s, m[ 3]+s,  
  710.          m[ 4]+s, m[ 5]+s, m[ 6]+s, m[ 7]+s,  
  711.          m[ 8]+s, m[ 9]+s, m[10]+s, m[11]+s,  
  712.          m[12]+s, m[13]+s, m[14]+s, m[15]+s); 
  713. }
  715. NCBI_ADD_MATRIX4(int)
  716. NCBI_ADD_MATRIX4(float)
  717. NCBI_ADD_MATRIX4(double)
  719. #undef NCBI_ADD_MATRIX3
  722. //
  723. // global addition: scalar - matrix
  724. //
  725. #define NCBI_SUBTRACT_MATRIX3(type) 
  726. template <class U> 
  727. inline CMatrix3< NCBI_PROMOTE(type,U) > 
  728. operator- (type s, const CMatrix3<U>& m) 
  729. { 
  730.     return 
  731.         CMatrix3< NCBI_PROMOTE(type,U) > 
  732.         (m[0]-s, m[1]-s, m[2]-s, 
  733.          m[3]-s, m[4]-s, m[5]-s, 
  734.          m[6]-s, m[7]-s, m[8]-s); 
  735. } 
  736. template <class T> 
  737. inline CMatrix3< NCBI_PROMOTE(T,type) > 
  738. operator- (const CMatrix3<T>& m, type s) 
  739. { 
  740.     return 
  741.         CMatrix3< NCBI_PROMOTE(T,type) > 
  742.         (m[0]-s, m[1]-s, m[2]-s, 
  743.          m[3]-s, m[4]-s, m[5]-s, 
  744.          m[6]-s, m[7]-s, m[8]-s); 
  745. }
  748. NCBI_SUBTRACT_MATRIX3(int)
  749. NCBI_SUBTRACT_MATRIX3(float)
  750. NCBI_SUBTRACT_MATRIX3(double)
  752. #undef NCBI_SUBTRACT_MATRIX3
  755. #define NCBI_SUBTRACT_MATRIX4(type) 
  756. template <class U> 
  757. inline CMatrix4< NCBI_PROMOTE(type,U) > 
  758. operator- (type s, const CMatrix4<U>& m) 
  759. { 
  760.     return 
  761.         CMatrix4< NCBI_PROMOTE(type,U) > 
  762.         (m[ 0]-s, m[ 1]-s, m[ 2]-s, m[ 3]-s,  
  763.          m[ 4]-s, m[ 5]-s, m[ 6]-s, m[ 7]-s,  
  764.          m[ 8]-s, m[ 9]-s, m[10]-s, m[11]-s,  
  765.          m[12]-s, m[13]-s, m[14]-s, m[15]-s); 
  766. } 
  767. template <class T> 
  768. inline CMatrix4< NCBI_PROMOTE(T,type) > 
  769. operator- (const CMatrix4<T>& m, type s) 
  770. { 
  771.     return 
  772.         CMatrix4< NCBI_PROMOTE(T,type) > 
  773.         (m[ 0]-s, m[ 1]-s, m[ 2]-s, m[ 3]-s,  
  774.          m[ 4]-s, m[ 5]-s, m[ 6]-s, m[ 7]-s,  
  775.          m[ 8]-s, m[ 9]-s, m[10]-s, m[11]-s,  
  776.          m[12]-s, m[13]-s, m[14]-s, m[15]-s); 
  777. }
  779. NCBI_SUBTRACT_MATRIX4(int)
  780. NCBI_SUBTRACT_MATRIX4(float)
  781. NCBI_SUBTRACT_MATRIX4(double)
  783. #undef NCBI_SUBTRACT_MATRIX3
  786. //
  787. // global addition: scalar * matrix
  788. //
  789. #define NCBI_MULTIPLY_MATRIX3(type) 
  790. template <class U> 
  791. inline CMatrix3< NCBI_PROMOTE(type,U) > 
  792. operator* (type s, const CMatrix3<U>& m) 
  793. { 
  794.     return 
  795.         CMatrix3< NCBI_PROMOTE(type,U) > 
  796.         (m[0]*s, m[1]*s, m[2]*s, 
  797.          m[3]*s, m[4]*s, m[5]*s, 
  798.          m[6]*s, m[7]*s, m[8]*s); 
  799. } 
  800. template <class T> 
  801. inline CMatrix3< NCBI_PROMOTE(T,type) > 
  802. operator* (const CMatrix3<T>& m, type s) 
  803. { 
  804.     return 
  805.         CMatrix3< NCBI_PROMOTE(T,type) > 
  806.         (m[0]*s, m[1]*s, m[2]*s, 
  807.          m[3]*s, m[4]*s, m[5]*s, 
  808.          m[6]*s, m[7]*s, m[8]*s); 
  809. }
  812. NCBI_MULTIPLY_MATRIX3(int)
  813. NCBI_MULTIPLY_MATRIX3(float)
  814. NCBI_MULTIPLY_MATRIX3(double)
  816. #undef NCBI_MULTIPLY_MATRIX3
  819. #define NCBI_MULTIPLY_MATRIX4(type) 
  820. template <class U> 
  821. inline CMatrix4< NCBI_PROMOTE(type,U) > 
  822. operator* (type s, const CMatrix4<U>& m) 
  823. { 
  824.     return 
  825.         CMatrix4< NCBI_PROMOTE(type,U) > 
  826.         (m[ 0]*s, m[ 1]*s, m[ 2]*s, m[ 3]*s,  
  827.          m[ 4]*s, m[ 5]*s, m[ 6]*s, m[ 7]*s,  
  828.          m[ 8]*s, m[ 9]*s, m[10]*s, m[11]*s,  
  829.          m[12]*s, m[13]*s, m[14]*s, m[15]*s); 
  830. } 
  831. template <class T> 
  832. inline CMatrix4< NCBI_PROMOTE(T,type) > 
  833. operator* (const CMatrix4<T>& m, type s) 
  834. { 
  835.     return 
  836.         CMatrix4< NCBI_PROMOTE(T,type) > 
  837.         (m[ 0]*s, m[ 1]*s, m[ 2]*s, m[ 3]*s,  
  838.          m[ 4]*s, m[ 5]*s, m[ 6]*s, m[ 7]*s,  
  839.          m[ 8]*s, m[ 9]*s, m[10]*s, m[11]*s,  
  840.          m[12]*s, m[13]*s, m[14]*s, m[15]*s); 
  841. }
  843. NCBI_MULTIPLY_MATRIX4(int)
  844. NCBI_MULTIPLY_MATRIX4(float)
  845. NCBI_MULTIPLY_MATRIX4(double)
  847. #undef NCBI_MULTIPLY_MATRIX3
  850. //
  851. // global subtraction: matrix - matrix
  852. //
  853. template <class T, class U>
  854. inline CMatrix3< NCBI_PROMOTE(T,U) >
  855. operator- (const CMatrix3<T>& m1, const CMatrix3<U>& m2)
  856. {
  857.     return
  858.         CMatrix3< NCBI_PROMOTE(T,U) >
  859.         (m1[0]-m2[0], m1[1]-m2[1], m1[2]-m2[2],
  860.          m1[3]-m2[3], m1[4]-m2[4], m1[5]-m2[5],
  861.          m1[6]-m2[6], m1[7]-m2[7], m1[8]-m2[8]);
  862. }
  865. template <class T, class U>
  866. inline CMatrix4< NCBI_PROMOTE(T,U) >
  867. operator- (const CMatrix4<T>& m1, const CMatrix4<U>& m2)
  868. {
  869.     return
  870.         CMatrix4< NCBI_PROMOTE(T,U) >
  871.         (m1[ 0]-m2[ 0], m1[ 1]-m2[ 1], m1[ 2]-m2[ 2], m1[ 3]-m2[ 3], 
  872.          m1[ 4]-m2[ 4], m1[ 5]-m2[ 5], m1[ 6]-m2[ 6], m1[ 7]-m2[ 7], 
  873.          m1[ 8]-m2[ 8], m1[ 9]-m2[ 9], m1[10]-m2[10], m1[11]-m2[11], 
  874.          m1[12]-m2[12], m1[13]-m2[13], m1[14]-m2[14], m1[15]-m2[15]);
  875. }
  878. //
  879. // global multiplication: matrix * CVect*<>
  880. // vector assumed to be a column vector!
  881. //
  882. template <class T, class U>
  883. inline CVect3< NCBI_PROMOTE(T,U) >
  884. operator* (const CMatrix3<T>& m, const CVect3<U>& v)
  885. {
  886.     return
  887.         CVect3< NCBI_PROMOTE(T,U) >
  888.         (m[0]*v[0] + m[1]*v[1] + m[2]*v[2],
  889.          m[3]*v[0] + m[4]*v[1] + m[5]*v[2],
  890.          m[6]*v[0] + m[7]*v[1] + m[8]*v[2] );
  891. }
  894. template <class T, class U>
  895. inline CVect4< NCBI_PROMOTE(T,U) >
  896. operator* (const CMatrix4<T>& m, const CVect4<U>& v)
  897. {
  898.     return
  899.         CVect4< NCBI_PROMOTE(T,U) >
  900.         (m[ 0]*v[0] + m[ 1]*v[1] + m[ 2]*v[2] + m[ 3]*v[3],
  901.          m[ 4]*v[0] + m[ 5]*v[1] + m[ 6]*v[2] + m[ 7]*v[3],
  902.          m[ 8]*v[0] + m[ 9]*v[1] + m[10]*v[2] + m[11]*v[3],
  903.          m[12]*v[0] + m[13]*v[1] + m[14]*v[2] + m[15]*v[3] );
  904. }
  906. //
  907. // global multiplication: CVect*<> * matrix
  908. // vector assumed to be a row vector!
  909. //
  910. template <class T, class U>
  911. inline CVect3< NCBI_PROMOTE(T,U) >
  912. operator* (const CVect3<T>& v, const CMatrix3<U>& m)
  913. {
  914.     return
  915.         CVect3< NCBI_PROMOTE(T,U) >
  916.         (v[0]*m[0] + v[1]*m[3] + v[2]*m[6],
  917.          v[0]*m[1] + v[1]*m[4] + v[2]*m[7],
  918.          v[0]*m[2] + v[1]*m[5] + v[2]*m[8] );
  919. }
  922. template <class T, class U>
  923. inline CVect4< NCBI_PROMOTE(T,U) >
  924. operator* (const CVect4<T>& v, const CMatrix4<U>& m)
  925. {
  926.     return
  927.         CVect4< NCBI_PROMOTE(T,U) >
  928.         (v[0]*m[ 0] + v[1]*m[ 4] + v[2]*m[ 8] + m[12]*v[3],
  929.          v[0]*m[ 1] + v[1]*m[ 5] + v[2]*m[ 9] + m[13]*v[3],
  930.          v[0]*m[ 2] + v[1]*m[ 6] + v[2]*m[10] + m[14]*v[3],
  931.          v[0]*m[ 3] + v[1]*m[ 7] + v[2]*m[11] + m[15]*v[3] );
  932. }
  935. //
  936. // global multiplication: matrix + matrix
  937. //
  938. template <class T, class U>
  939. inline CMatrix3< NCBI_PROMOTE(T,U) >
  940. operator* (const CMatrix3<T>& m1, const CMatrix3<U>& m2)
  941. {
  942.     return
  943.         CMatrix3< NCBI_PROMOTE(T,U) >
  944.         (m1[0]*m2[0] + m1[1]*m2[3] + m1[2]*m2[6],
  945.          m1[0]*m2[1] + m1[1]*m2[4] + m1[2]*m2[7],
  946.          m1[0]*m2[2] + m1[1]*m2[5] + m1[2]*m2[8],
  948.          m1[3]*m2[0] + m1[4]*m2[3] + m1[5]*m2[6],
  949.          m1[3]*m2[1] + m1[4]*m2[4] + m1[5]*m2[7],
  950.          m1[3]*m2[2] + m1[4]*m2[5] + m1[5]*m2[8],
  952.          m1[6]*m2[0] + m1[7]*m2[3] + m1[8]*m2[6],
  953.          m1[6]*m2[1] + m1[7]*m2[4] + m1[8]*m2[7],
  954.          m1[6]*m2[2] + m1[7]*m2[5] + m1[8]*m2[8]);
  955. }
  958. template <class T, class U>
  959. inline CMatrix4< NCBI_PROMOTE(T,U) >
  960. operator* (const CMatrix4<T>& m1, const CMatrix4<U>& m2)
  961. {
  962.     return
  963.         CMatrix4< NCBI_PROMOTE(T,U) >
  964.         (m1[ 0]*m2[ 0] + m1[ 1]*m2[ 4] + m1[ 2]*m2[ 8] + m1[ 3]*m2[12],
  965.          m1[ 0]*m2[ 1] + m1[ 1]*m2[ 5] + m1[ 2]*m2[ 9] + m1[ 3]*m2[13],
  966.          m1[ 0]*m2[ 2] + m1[ 1]*m2[ 6] + m1[ 2]*m2[10] + m1[ 3]*m2[14],
  967.          m1[ 0]*m2[ 3] + m1[ 1]*m2[ 7] + m1[ 2]*m2[11] + m1[ 3]*m2[15],
  969.          m1[ 4]*m2[ 0] + m1[ 5]*m2[ 4] + m1[ 6]*m2[ 8] + m1[ 7]*m2[12],
  970.          m1[ 4]*m2[ 1] + m1[ 5]*m2[ 5] + m1[ 6]*m2[ 9] + m1[ 7]*m2[13],
  971.          m1[ 4]*m2[ 2] + m1[ 5]*m2[ 6] + m1[ 6]*m2[10] + m1[ 7]*m2[14],
  972.          m1[ 4]*m2[ 3] + m1[ 5]*m2[ 7] + m1[ 6]*m2[11] + m1[ 7]*m2[15],
  974.          m1[ 8]*m2[ 0] + m1[ 9]*m2[ 4] + m1[10]*m2[ 8] + m1[11]*m2[12],
  975.          m1[ 8]*m2[ 1] + m1[ 9]*m2[ 5] + m1[10]*m2[ 9] + m1[11]*m2[13],
  976.          m1[ 8]*m2[ 2] + m1[ 9]*m2[ 6] + m1[10]*m2[10] + m1[11]*m2[14],
  977.          m1[ 8]*m2[ 3] + m1[ 9]*m2[ 7] + m1[10]*m2[11] + m1[11]*m2[15],
  979.          m1[12]*m2[ 0] + m1[13]*m2[ 4] + m1[14]*m2[ 8] + m1[15]*m2[12],
  980.          m1[12]*m2[ 1] + m1[13]*m2[ 5] + m1[14]*m2[ 9] + m1[15]*m2[13],
  981.          m1[12]*m2[ 2] + m1[13]*m2[ 6] + m1[14]*m2[10] + m1[15]*m2[14],
  982.          m1[12]*m2[ 3] + m1[13]*m2[ 7] + m1[14]*m2[11] + m1[15]*m2[15]);
  983. }
  985. //
  986. // global division: matrix / scalar
  987. //
  988. template <class T, class U>
  989. inline CMatrix3< NCBI_PROMOTE(T,U) >
  990. operator/ (const CMatrix3<T>& m1, U s)
  991. {
  992.     s = T(1) / s;
  993.     return
  994.         CMatrix3< NCBI_PROMOTE(T,U) >
  995.         (m1[0]*s, m1[1]*s, m1[2]*s,
  996.          m1[3]*s, m1[4]*s, m1[5]*s,
  997.          m1[6]*s, m1[7]*s, m1[8]*s);
  998. }
  1001. template <class T, class U>
  1002. inline CMatrix4< NCBI_PROMOTE(T,U) >
  1003. operator/ (const CMatrix4<T>& m1, U s)
  1004. {
  1005.     s = T(1) / s;
  1006.     return
  1007.         CMatrix4< NCBI_PROMOTE(T,U) >
  1008.         (m1[ 0]*s, m1[ 1]*s, m1[ 2]*s, m1[ 3]*s, 
  1009.          m1[ 4]*s, m1[ 5]*s, m1[ 6]*s, m1[ 7]*s, 
  1010.          m1[ 8]*s, m1[ 9]*s, m1[10]*s, m1[11]*s, 
  1011.          m1[12]*s, m1[13]*s, m1[14]*s, m1[15]*s);
  1012. }
  1016. END_NCBI_SCOPE
  1018. /* @} */
  1021. /*
  1022.  * ===========================================================================
  1023.  * $Log: globals.hpp,v $
  1024.  * Revision 1000.2  2004/06/01 19:48:46  gouriano
  1025.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.8
  1026.  *
  1027.  * Revision 1.8  2004/05/11 18:53:50  dicuccio
  1028.  * Added doxygen modules info
  1029.  *
  1030.  * Revision 1.7  2004/04/26 17:26:18  ucko
  1031.  * Fix a typo in Vect4 comparison.
  1032.  *
  1033.  * Revision 1.6  2004/03/10 14:29:25  dicuccio
  1034.  * Cleaned up include guards.  Rearranged include of promotion rules to guard
  1035.  * agains undefined classes
  1036.  *
  1037.  * Revision 1.5  2004/02/09 17:37:44  dicuccio
  1038.  * Moved matrix and prmote.hpp to utils/math
  1039.  *
  1040.  * Revision 1.4  2004/01/23 13:54:52  dicuccio
  1041.  * Lots of fixes.  Wrapped promote type designation in a macro.  Dropped use of
  1042.  * partial template specialization due to lack of support in MSVC
  1043.  *
  1044.  * Revision 1.3  2003/12/22 19:14:20  dicuccio
  1045.  * Fixed lots of bugs in referencing non-existent functions
  1046.  *
  1047.  * Revision 1.2  2003/09/29 15:11:24  dicuccio
  1048.  * Lots of clean-up.  Use _ASSERT instead of assert.  Use 'typename' where
  1049.  * needed
  1050.  *
  1051.  * Revision 1.1  2003/06/09 19:30:50  dicuccio
  1052.  * Initial revision
  1053.  *
  1054.  * ===========================================================================
  1055.  */
  1057. #endif  // GUI_MATH___GLOBALS__HPP