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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
v3dmath_test.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：15k
源码类别：

游戏引擎

开发平台：

C++ Builder

v3dmath_test.cpp：源码内容
  1. /**
  2.  * @file v3dmath_test.cpp
  3.  * @author Adroit
  4.  * @date 2007-03
  5.  * @brief v3dmath test cases.
  6.  *
  7.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2007-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34.  
  35. #include "linden_common.h"
  36. #include "llsd.h"
  37. #include "../test/lltut.h"
  39. #include "../llquaternion.h"
  40. #include "../m3math.h"
  41. #include "../v4math.h"
  42. #include "../v3dmath.h"
  43. #include "../v3dmath.h"
  45. namespace tut
  46. {
  47. struct v3dmath_data
  48. {
  49. };
  50. typedef test_group<v3dmath_data> v3dmath_test;
  51. typedef v3dmath_test::object v3dmath_object;
  52. tut::v3dmath_test v3dmath_testcase("v3dmath");
  54. template<> template<>
  55. void v3dmath_object::test<1>()
  56. {
  57. LLVector3d vec3D;
  58. ensure("1:LLVector3d:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
  59. F64 x = 2.32f, y = 1.212f, z = -.12f;
  60. LLVector3d vec3Da(x,y,z);
  61. ensure("2:LLVector3d:Fail to initialize ", ((2.32f == vec3Da.mdV[VX]) && (1.212f == vec3Da.mdV[VY]) && (-.12f == vec3Da.mdV[VZ])));
  62. const F64 vec[3] = {1.2f ,3.2f, -4.2f};
  63. LLVector3d vec3Db(vec);
  64. ensure("3:LLVector3d:Fail to initialize ", ((1.2f == vec3Db.mdV[VX]) && (3.2f == vec3Db.mdV[VY]) && (-4.2f == vec3Db.mdV[VZ])));
  65. LLVector3 vec3((F32)x,(F32)y,(F32)z);
  66. LLVector3d vec3Dc(vec3);
  67. ensure_equals("4:LLVector3d Fail to initialize",vec3Da,vec3Dc);
  68. }
  70. template<> template<>
  71. void v3dmath_object::test<2>()
  72. {
  73. S32 a = -235;
  74. LLSD llsd(a);
  75. LLVector3d vec3d(llsd);
  76. LLSD sd = vec3d.getValue();
  77. LLVector3d vec3da(sd);
  78. ensure("1:getValue:Fail ", (vec3d == vec3da));
  79. }
  81. template<> template<>
  82. void v3dmath_object::test<3>()
  83. {
  84. F64 a = 232345521.411132;
  85. LLSD llsd(a);
  86. LLVector3d vec3d;
  87. vec3d.setValue(llsd);
  88. LLSD sd = vec3d.getValue();
  89. LLVector3d vec3da(sd);
  90. ensure("1:setValue:Fail to initialize ", (vec3d == vec3da));
  91. }
  93. template<> template<>
  94. void v3dmath_object::test<4>()
  95. {
  96. F64 a[3] = {222231.43222, 12345.2343, -434343.33222};
  97. LLSD llsd;
  98. llsd[0] = a[0];
  99. llsd[1] = a[1];
  100. llsd[2] = a[2];
  101. LLVector3d vec3D;
  102. vec3D = (LLVector3d)llsd;
  103. ensure("1:operator=:Fail to initialize ", ((llsd[0].asReal()== vec3D.mdV[VX]) && (llsd[1].asReal() == vec3D.mdV[VY]) && (llsd[2].asReal() == vec3D.mdV[VZ])));
  104. }
  106. template<> template<>
  107. void v3dmath_object::test<5>()
  108. {
  109. F64 x = 2.32f, y = 1.212f, z = -.12f;
  110. LLVector3d vec3D(x,y,z);
  111. vec3D.clearVec();
  112. ensure("1:clearVec:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
  113. vec3D.setVec(x,y,z);
  114. ensure("2:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
  115. vec3D.zeroVec();
  116. ensure("3:zeroVec:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
  117. vec3D.clearVec();
  118. LLVector3 vec3((F32)x,(F32)y,(F32)z);
  119. vec3D.setVec(vec3);
  120. ensure("4:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
  121. vec3D.clearVec();
  122. const F64 vec[3] = {x,y,z};
  123. vec3D.setVec(vec);
  124. ensure("5:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
  125. LLVector3d vec3Da;
  126. vec3Da.setVec(vec3D);
  127. ensure_equals("6:setVec: Fail to initialize", vec3D, vec3Da);
  128. }
  130. template<> template<>
  131. void v3dmath_object::test<6>()
  132. {
  133. F64 x = -2.32, y = 1.212, z = -.12;
  134. LLVector3d vec3D(x,y,z);
  135. vec3D.abs();
  136. ensure("1:abs:Fail  ", ((-x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (-z == vec3D.mdV[VZ])));
  137. ensure("2:isNull():Fail ", (FALSE == vec3D.isNull()));
  138. vec3D.clearVec();
  139. x =.00000001, y = .000001001, z = .000001001;
  140. vec3D.setVec(x,y,z);
  141. ensure("3:isNull():Fail ", (TRUE == vec3D.isNull()));
  142. ensure("4:isExactlyZero():Fail ", (FALSE == vec3D.isExactlyZero()));
  143. x =.0000000, y = .00000000, z = .00000000;
  144. vec3D.setVec(x,y,z);
  145. ensure("5:isExactlyZero():Fail ", (TRUE == vec3D.isExactlyZero()));
  146. }
  148. template<> template<>
  149. void v3dmath_object::test<7>()
  150. {
  151. F64 x = -2.32, y = 1.212, z = -.12;
  152. LLVector3d vec3D(x,y,z);
  154. ensure("1:operator [] failed",( x ==  vec3D[0]));
  155. ensure("2:operator [] failed",( y ==  vec3D[1]));
  156. ensure("3:operator [] failed",( z ==  vec3D[2]));
  157. vec3D.clearVec();
  158. x = 23.23, y = -.2361, z = 3.25;
  159. vec3D.setVec(x,y,z);
  160. F64 &ref1 = vec3D[0];
  161. ensure("4:operator [] failed",( ref1 ==  vec3D[0]));
  162. F64 &ref2 = vec3D[1];
  163. ensure("5:operator [] failed",( ref2 ==  vec3D[1]));
  164. F64 &ref3 = vec3D[2];
  165. ensure("6:operator [] failed",( ref3 ==  vec3D[2]));
  166. }
  168. template<> template<>
  169. void v3dmath_object::test<8>()
  170. {
  171. F32 x = 1.f, y = 2.f, z = -1.f;
  172. LLVector4 vec4(x,y,z);
  173. LLVector3d vec3D;
  174. vec3D = vec4;
  175. ensure("1:operator=:Fail to initialize ", ((vec4.mV[VX] == vec3D.mdV[VX]) && (vec4.mV[VY] == vec3D.mdV[VY]) && (vec4.mV[VZ] == vec3D.mdV[VZ])));
  176. }
  178. template<> template<>
  179. void v3dmath_object::test<9>()
  180. {
  181. F64 x1 = 1.78787878, y1 = 232322.2121, z1 = -12121.121212;
  182. F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
  183. LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2),vec3Db;
  184. vec3Db = vec3Da+ vec3D;
  185. ensure("1:operator+:Fail to initialize ", ((x1+x2 == vec3Db.mdV[VX]) && (y1+y2 == vec3Db.mdV[VY]) && (z1+z2 == vec3Db.mdV[VZ])));
  186. x1 = -2.45, y1 = 2.1, z1 = 3.0;
  187. vec3D.clearVec();
  188. vec3Da.clearVec();
  189. vec3D.setVec(x1,y1,z1);
  190. vec3Da += vec3D;
  191. ensure_equals("2:operator+=: Fail to initialize", vec3Da,vec3D);
  192. vec3Da += vec3D;
  193. ensure("3:operator+=:Fail to initialize ", ((2*x1 == vec3Da.mdV[VX]) && (2*y1 == vec3Da.mdV[VY]) && (2*z1 == vec3Da.mdV[VZ])));
  194. }
  196. template<> template<>
  197. void v3dmath_object::test<10>()
  198. {
  199. F64 x1 = 1., y1 = 2., z1 = -1.1;
  200. F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
  201. LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2),vec3Db;
  202. vec3Db = vec3Da - vec3D;
  203. ensure("1:operator-:Fail to initialize ", ((x2-x1 == vec3Db.mdV[VX]) && (y2-y1 == vec3Db.mdV[VY]) && (z2-z1 == vec3Db.mdV[VZ])));
  204. x1 = -2.45, y1 = 2.1, z1 = 3.0;
  205. vec3D.clearVec();
  206. vec3Da.clearVec();
  207. vec3D.setVec(x1,y1,z1);
  208. vec3Da -=vec3D;
  209. ensure("2:operator-=:Fail to initialize ", ((2.45 == vec3Da.mdV[VX]) && (-2.1 == vec3Da.mdV[VY]) && (-3.0 == vec3Da.mdV[VZ])));
  210. vec3Da -= vec3D;
  211. ensure("3:operator-=:Fail to initialize ", ((-2*x1 == vec3Da.mdV[VX]) && (-2*y1 == vec3Da.mdV[VY]) && (-2*z1 == vec3Da.mdV[VZ])));
  212. }
  213. template<> template<>
  214. void v3dmath_object::test<11>()
  215. {
  216. F64 x1 = 1., y1 = 2., z1 = -1.1;
  217. F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
  218. LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2);
  219. F64 res = vec3D * vec3Da;
  220. ensure_approximately_equals(
  221. "1:operator* failed",
  222. res,
  223. (x1*x2 + y1*y2 + z1*z2),
  224. 8);
  225. vec3Da.clearVec();
  226. F64 mulVal = 4.2;
  227. vec3Da = vec3D * mulVal;
  228. ensure_approximately_equals(
  229. "2a:operator* failed",
  230. vec3Da.mdV[VX],
  231. x1*mulVal,
  232. 8);
  233. ensure_approximately_equals(
  234. "2b:operator* failed",
  235. vec3Da.mdV[VY],
  236. y1*mulVal,
  237. 8);
  238. ensure_approximately_equals(
  239. "2c:operator* failed",
  240. vec3Da.mdV[VZ],
  241. z1*mulVal,
  242. 8);
  243. vec3Da.clearVec();
  244. vec3Da = mulVal * vec3D;
  245. ensure_approximately_equals(
  246. "3a:operator* failed",
  247. vec3Da.mdV[VX],
  248. x1*mulVal,
  249. 8);
  250. ensure_approximately_equals(
  251. "3b:operator* failed",
  252. vec3Da.mdV[VY],
  253. y1*mulVal,
  254. 8);
  255. ensure_approximately_equals(
  256. "3c:operator* failed",
  257. vec3Da.mdV[VZ],
  258. z1*mulVal,
  259. 8);
  260. vec3D *= mulVal;
  261. ensure_approximately_equals(
  262. "4a:operator*= failed",
  263. vec3D.mdV[VX],
  264. x1*mulVal,
  265. 8);
  266. ensure_approximately_equals(
  267. "4b:operator*= failed",
  268. vec3D.mdV[VY],
  269. y1*mulVal,
  270. 8);
  271. ensure_approximately_equals(
  272. "4c:operator*= failed",
  273. vec3D.mdV[VZ],
  274. z1*mulVal,
  275. 8);
  276. }
  278. template<> template<>
  279. void v3dmath_object::test<12>()
  280. {
  281. F64 x1 = 1., y1 = 2., z1 = -1.1;
  282. F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
  283. F64 val1, val2, val3;
  284. LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2), vec3Db;
  285. vec3Db = vec3D % vec3Da;
  286. val1 = y1*z2 - y2*z1;
  287. val2 = z1*x2 -z2*x1;
  288. val3 = x1*y2-x2*y1;
  289. ensure("1:operator% failed",(val1 == vec3Db.mdV[VX]) && (val2 == vec3Db.mdV[VY]) && (val3 == vec3Db.mdV[VZ])); 
  290. vec3D %= vec3Da;
  291. ensure("2:operator%= failed",
  292.        is_approx_equal(vec3D.mdV[VX],vec3Db.mdV[VX]) &&
  293.        is_approx_equal(vec3D.mdV[VY],vec3Db.mdV[VY]) &&
  294.        is_approx_equal(vec3D.mdV[VZ],vec3Db.mdV[VZ]) ); 
  295. }
  297. template<> template<>
  298. void v3dmath_object::test<13>()
  299. {
  300. F64 x1 = 1., y1 = 2., z1 = -1.1,div = 4.2;
  301. F64 t = 1.f / div;
  302. LLVector3d vec3D(x1,y1,z1), vec3Da;
  303. vec3Da = vec3D/div;
  304. ensure_approximately_equals(
  305. "1a:operator/ failed",
  306. vec3Da.mdV[VX],
  307. x1*t,
  308. 8);
  309. ensure_approximately_equals(
  310. "1b:operator/ failed",
  311. vec3Da.mdV[VY],
  312. y1*t,
  313. 8);
  314. ensure_approximately_equals(
  315. "1c:operator/ failed",
  316. vec3Da.mdV[VZ],
  317. z1*t,
  318. 8);
  319. x1 = 1.23, y1 = 4., z1 = -2.32;
  320. vec3D.clearVec();
  321. vec3Da.clearVec();
  322. vec3D.setVec(x1,y1,z1);
  323. vec3Da = vec3D/div;
  324. ensure_approximately_equals(
  325. "2a:operator/ failed",
  326. vec3Da.mdV[VX],
  327. x1*t,
  328. 8);
  329. ensure_approximately_equals(
  330. "2b:operator/ failed",
  331. vec3Da.mdV[VY],
  332. y1*t,
  333. 8);
  334. ensure_approximately_equals(
  335. "2c:operator/ failed",
  336. vec3Da.mdV[VZ],
  337. z1*t,
  338. 8);
  339. vec3D /= div;
  340. ensure_approximately_equals(
  341. "3a:operator/= failed",
  342. vec3D.mdV[VX],
  343. x1*t,
  344. 8);
  345. ensure_approximately_equals(
  346. "3b:operator/= failed",
  347. vec3D.mdV[VY],
  348. y1*t,
  349. 8);
  350. ensure_approximately_equals(
  351. "3c:operator/= failed",
  352. vec3D.mdV[VZ],
  353. z1*t,
  354. 8);
  355. }
  357. template<> template<>
  358. void v3dmath_object::test<14>()
  359. {
  360. F64 x1 = 1., y1 = 2., z1 = -1.1;
  361. LLVector3d vec3D(x1,y1,z1), vec3Da;
  362. ensure("1:operator!= failed",(TRUE == (vec3D !=vec3Da)));
  363. vec3Da = vec3D;
  364. ensure("2:operator== failed",(vec3D ==vec3Da)); 
  365. vec3D.clearVec();
  366. vec3Da.clearVec();
  367. x1 = .211, y1 = 21.111, z1 = 23.22;
  368. vec3D.setVec(x1,y1,z1);
  369. vec3Da.setVec(x1,y1,z1);
  370. ensure("3:operator== failed",(vec3D ==vec3Da)); 
  371. ensure("4:operator!= failed",(FALSE == (vec3D !=vec3Da)));
  372. }
  374. template<> template<>
  375. void v3dmath_object::test<15>()
  376. {
  377. F64 x1 = 1., y1 = 2., z1 = -1.1;
  378. LLVector3d vec3D(x1,y1,z1), vec3Da;
  379. std::ostringstream stream1, stream2;
  380. stream1 << vec3D;
  381. vec3Da.setVec(x1,y1,z1);
  382. stream2 << vec3Da;
  383. ensure("1:operator << failed",(stream1.str() == stream2.str()));
  384. }
  386. template<> template<>
  387. void v3dmath_object::test<16>()
  388. {
  389. F64 x1 = 1.23, y1 = 2.0, z1 = 4.;
  390. std::string buf("1.23 2. 4");
  391. LLVector3d vec3D, vec3Da(x1,y1,z1);
  392. LLVector3d::parseVector3d(buf, &vec3D);
  393. ensure_equals("1:parseVector3d: failed " , vec3D, vec3Da);
  394. }
  396. template<> template<>
  397. void v3dmath_object::test<17>()
  398. {
  399. F64 x1 = 1., y1 = 2., z1 = -1.1;
  400. LLVector3d vec3D(x1,y1,z1), vec3Da;
  401. vec3Da = -vec3D;
  402. ensure("1:operator- failed", (vec3D == - vec3Da));
  403. }
  405. template<> template<>
  406. void v3dmath_object::test<18>()
  407. {
  408. F64 x = 1., y = 2., z = -1.1;
  409. LLVector3d vec3D(x,y,z);
  410. F64 res = (x*x + y*y + z*z) - vec3D.magVecSquared();
  411. ensure("1:magVecSquared:Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));
  412. res = fsqrtf(x*x + y*y + z*z) - vec3D.magVec();
  413. ensure("2:magVec: Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));
  414. }
  416. template<> template<>
  417. void v3dmath_object::test<19>()
  418. {
  419. F64 x = 1., y = 2., z = -1.1;
  420. LLVector3d vec3D(x,y,z);
  421. F64 mag = vec3D.normVec();
  422. mag = 1.f/ mag;
  423. ensure_approximately_equals(
  424. "1a:normVec: Fail ",
  425. vec3D.mdV[VX],
  426. x * mag,
  427. 8);
  428. ensure_approximately_equals(
  429. "1b:normVec: Fail ",
  430. vec3D.mdV[VY],
  431. y * mag,
  432. 8);
  433. ensure_approximately_equals(
  434. "1c:normVec: Fail ",
  435. vec3D.mdV[VZ],
  436. z * mag,
  437. 8);
  438. x = 0.000000001, y = 0.000000001, z = 0.000000001;
  439. vec3D.clearVec();
  440. vec3D.setVec(x,y,z);
  441. mag = vec3D.normVec();
  442. ensure_approximately_equals(
  443. "2a:normVec: Fail ",
  444. vec3D.mdV[VX],
  445. x * mag,
  446. 8);
  447. ensure_approximately_equals(
  448. "2b:normVec: Fail ",
  449. vec3D.mdV[VY],
  450. y * mag,
  451. 8);
  452. ensure_approximately_equals(
  453. "2c:normVec: Fail ",
  454. vec3D.mdV[VZ],
  455. z * mag,
  456. 8);
  457. }
  459. template<> template<>
  460. void v3dmath_object::test<20>()
  461. {
  462. F64 x1 = 1111.232222;
  463. F64 y1 = 2222222222.22;
  464. F64 z1 = 422222222222.0;
  465. std::string buf("1111.232222 2222222222.22 422222222222");
  466. LLVector3d vec3Da, vec3Db(x1,y1,z1);
  467. LLVector3d::parseVector3d(buf, &vec3Da);
  468. ensure_equals("1:parseVector3 failed", vec3Da, vec3Db);
  469. }
  471. template<> template<>
  472. void v3dmath_object::test<21>()
  473. {
  474. F64 x1 = 1., y1 = 2., z1 = -1.1;
  475. F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
  476. F64 val = 2.3f,val1,val2,val3;
  477. val1 = x1 + (x2 - x1)* val;
  478. val2 = y1 + (y2 - y1)* val;
  479. val3 = z1 + (z2 - z1)* val;
  480. LLVector3d vec3Da(x1,y1,z1),vec3Db(x2,y2,z2);
  481. LLVector3d vec3d = lerp(vec3Da,vec3Db,val);
  482. ensure("1:lerp failed", ((val1 ==vec3d.mdV[VX])&& (val2 ==vec3d.mdV[VY]) && (val3 ==vec3d.mdV[VZ])));
  483. }
  485. template<> template<>
  486. void v3dmath_object::test<22>()
  487. {
  488. F64 x = 2.32, y = 1.212, z = -.12;
  489. F64 min = 0.0001, max = 3.0;
  490. LLVector3d vec3d(x,y,z);
  491. ensure("1:clamp:Fail ", (TRUE == (vec3d.clamp(min, max))));
  492. x = 0.000001f, z = 5.3f;
  493. vec3d.setVec(x,y,z);
  494. ensure("2:clamp:Fail ", (TRUE == (vec3d.clamp(min, max))));
  495. }
  497. template<> template<>
  498. void v3dmath_object::test<23>()
  499. {
  500. F64 x = 10., y = 20., z = -15.;
  501. F64 epsilon = .23425;
  502. LLVector3d vec3Da(x,y,z), vec3Db(x,y,z);
  503. ensure("1:are_parallel: Fail ", (TRUE == are_parallel(vec3Da,vec3Db,epsilon)));
  504. F64 x1 = -12., y1 = -20., z1 = -100.;
  505. vec3Db.clearVec();
  506. vec3Db.setVec(x1,y1,z1);
  507. ensure("2:are_parallel: Fail ", (FALSE == are_parallel(vec3Da,vec3Db,epsilon)));
  508. }
  510. template<> template<>
  511. void v3dmath_object::test<24>()
  512. {
  513. #if LL_WINDOWS && _MSC_VER < 1400
  514. skip("This fails on VS2003!");
  515. #else
  516. F64 x = 10., y = 20., z = -15.;
  517. F64 angle1, angle2;
  518. LLVector3d vec3Da(x,y,z), vec3Db(x,y,z);
  519. angle1 = angle_between(vec3Da, vec3Db);
  520. ensure("1:angle_between: Fail ", (0 == angle1));
  521. F64 x1 = -1., y1 = -20., z1 = -1.;
  522. vec3Da.clearVec();
  523. vec3Da.setVec(x1,y1,z1);
  524. angle2 = angle_between(vec3Da, vec3Db);
  525. vec3Db.normVec();
  526. vec3Da.normVec();
  527. F64 angle = vec3Db*vec3Da;
  528. angle = acos(angle);
  529. ensure("2:angle_between: Fail ", (angle == angle2));
  530. #endif
  531. }
  532. }