/indra/llmath/tests/v4math_test.cpp

https://bitbucket.org/lindenlab/viewer-beta/ · C++ · 382 lines · 331 code · 24 blank · 27 comment · 124 complexity · 7aa006ba0845841a29780715609ddb93 MD5 · raw file

  1. /**
  2. * @file v4math_test.cpp
  3. * @author Adroit
  4. * @date 2007-03
  5. * @brief v4math test cases.
  6. *
  7. * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  8. * Second Life Viewer Source Code
  9. * Copyright (C) 2010, Linden Research, Inc.
  10. *
  11. * This library is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU Lesser General Public
  13. * License as published by the Free Software Foundation;
  14. * version 2.1 of the License only.
  15. *
  16. * This library is distributed in the hope that it will be useful,
  17. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19. * Lesser General Public License for more details.
  20. *
  21. * You should have received a copy of the GNU Lesser General Public
  22. * License along with this library; if not, write to the Free Software
  23. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24. *
  25. * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
  26. * $/LicenseInfo$
  27. */
  28. #include "linden_common.h"
  29. #include "../test/lltut.h"
  30. #include "llsd.h"
  31. #include "../m4math.h"
  32. #include "../v4math.h"
  33. #include "../llquaternion.h"
  34. namespace tut
  35. {
  36. struct v4math_data
  37. {
  38. };
  39. typedef test_group<v4math_data> v4math_test;
  40. typedef v4math_test::object v4math_object;
  41. tut::v4math_test v4math_testcase("v4math_h");
  42. template<> template<>
  43. void v4math_object::test<1>()
  44. {
  45. LLVector4 vec4;
  46. ensure("1:LLVector4:Fail to initialize " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
  47. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  48. LLVector4 vec4a(x,y,z);
  49. ensure("2:LLVector4:Fail to initialize " ,((x == vec4a.mV[VX]) && (y == vec4a.mV[VY]) && (z == vec4a.mV[VZ])&& (1.0f == vec4a.mV[VW])));
  50. LLVector4 vec4b(x,y,z,w);
  51. ensure("3:LLVector4:Fail to initialize " ,((x == vec4b.mV[VX]) && (y == vec4b.mV[VY]) && (z == vec4b.mV[VZ])&& (w == vec4b.mV[VW])));
  52. const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
  53. LLVector4 vec4c(vec);
  54. ensure("4:LLVector4:Fail to initialize " ,((vec[0] == vec4c.mV[VX]) && (vec[1] == vec4c.mV[VY]) && (vec[2] == vec4c.mV[VZ])&& (vec[3] == vec4c.mV[VW])));
  55. LLVector3 vec3(-2.23f,1.01f,42.3f);
  56. LLVector4 vec4d(vec3);
  57. ensure("5:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4d.mV[VX]) && (vec3.mV[VY] == vec4d.mV[VY]) && (vec3.mV[VZ] == vec4d.mV[VZ])&& (1.f == vec4d.mV[VW])));
  58. F32 w1 = -.234f;
  59. LLVector4 vec4e(vec3,w1);
  60. ensure("6:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4e.mV[VX]) && (vec3.mV[VY] == vec4e.mV[VY]) && (vec3.mV[VZ] == vec4e.mV[VZ])&& (w1 == vec4e.mV[VW])));
  61. }
  62. template<> template<>
  63. void v4math_object::test<2>()
  64. {
  65. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  66. LLVector4 vec4;
  67. vec4.setVec(x,y,z);
  68. ensure("1:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
  69. vec4.clearVec();
  70. ensure("2:clearVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
  71. vec4.setVec(x,y,z,w);
  72. ensure("3:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (w == vec4.mV[VW])));
  73. vec4.zeroVec();
  74. ensure("4:zeroVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (0 == vec4.mV[VW])));
  75. LLVector3 vec3(-2.23f,1.01f,42.3f);
  76. vec4.clearVec();
  77. vec4.setVec(vec3);
  78. ensure("5:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (1.f == vec4.mV[VW])));
  79. F32 w1 = -.234f;
  80. vec4.zeroVec();
  81. vec4.setVec(vec3,w1);
  82. ensure("6:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (w1 == vec4.mV[VW])));
  83. const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
  84. LLVector4 vec4a;
  85. vec4a.setVec(vec);
  86. ensure("7:setVec:Fail to initialize " ,((vec[0] == vec4a.mV[VX]) && (vec[1] == vec4a.mV[VY]) && (vec[2] == vec4a.mV[VZ])&& (vec[3] == vec4a.mV[VW])));
  87. }
  88. template<> template<>
  89. void v4math_object::test<3>()
  90. {
  91. F32 x = 10.f, y = -2.3f, z = -.023f;
  92. LLVector4 vec4(x,y,z);
  93. ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), (F32) sqrt(x*x + y*y + z*z)));
  94. ensure("magVecSquared:Fail ", is_approx_equal(vec4.magVecSquared(), (x*x + y*y + z*z)));
  95. }
  96. template<> template<>
  97. void v4math_object::test<4>()
  98. {
  99. F32 x = 10.f, y = -2.3f, z = -.023f;
  100. LLVector4 vec4(x,y,z);
  101. F32 mag = vec4.normVec();
  102. mag = 1.f/ mag;
  103. ensure("1:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
  104. x = 0.000000001f, y = 0.000000001f, z = 0.000000001f;
  105. vec4.clearVec();
  106. vec4.setVec(x,y,z);
  107. mag = vec4.normVec();
  108. ensure("2:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
  109. }
  110. template<> template<>
  111. void v4math_object::test<5>()
  112. {
  113. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  114. LLVector4 vec4(x,y,z,w);
  115. vec4.abs();
  116. ensure("abs:Fail " ,((x == vec4.mV[VX]) && (-y == vec4.mV[VY]) && (-z == vec4.mV[VZ])&& (-w == vec4.mV[VW])));
  117. vec4.clearVec();
  118. ensure("isExactlyClear:Fail " ,(TRUE == vec4.isExactlyClear()));
  119. vec4.zeroVec();
  120. ensure("isExactlyZero:Fail " ,(TRUE == vec4.isExactlyZero()));
  121. }
  122. template<> template<>
  123. void v4math_object::test<6>()
  124. {
  125. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  126. LLVector4 vec4(x,y,z,w),vec4a;
  127. vec4a = vec4.scaleVec(vec4);
  128. ensure("scaleVec:Fail " ,(is_approx_equal(x*x, vec4a.mV[VX]) && is_approx_equal(y*y, vec4a.mV[VY]) && is_approx_equal(z*z, vec4a.mV[VZ])&& is_approx_equal(w*w, vec4a.mV[VW])));
  129. }
  130. template<> template<>
  131. void v4math_object::test<7>()
  132. {
  133. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  134. LLVector4 vec4(x,y,z,w);
  135. ensure("1:operator [] failed " ,( x == vec4[0]));
  136. ensure("2:operator [] failed " ,( y == vec4[1]));
  137. ensure("3:operator [] failed " ,( z == vec4[2]));
  138. ensure("4:operator [] failed " ,( w == vec4[3]));
  139. x = 23.f, y = -.2361f, z = 3.25;
  140. vec4.setVec(x,y,z);
  141. F32 &ref1 = vec4[0];
  142. ensure("5:operator [] failed " ,( ref1 == vec4[0]));
  143. F32 &ref2 = vec4[1];
  144. ensure("6:operator [] failed " ,( ref2 == vec4[1]));
  145. F32 &ref3 = vec4[2];
  146. ensure("7:operator [] failed " ,( ref3 == vec4[2]));
  147. F32 &ref4 = vec4[3];
  148. ensure("8:operator [] failed " ,( ref4 == vec4[3]));
  149. }
  150. template<> template<>
  151. void v4math_object::test<8>()
  152. {
  153. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  154. const F32 val[16] = {
  155. 1.f, 2.f, 3.f, 0.f,
  156. .34f, .1f, -.5f, 0.f,
  157. 2.f, 1.23f, 1.234f, 0.f,
  158. .89f, 0.f, 0.f, 0.f
  159. };
  160. LLMatrix4 mat(val);
  161. LLVector4 vec4(x,y,z,w),vec4a;
  162. vec4.rotVec(mat);
  163. vec4a.setVec(x,y,z,w);
  164. vec4a.rotVec(mat);
  165. ensure_equals("1:rotVec: Fail " ,vec4a, vec4);
  166. F32 a = 2.32f, b = -23.2f, c = -34.1112f, d = 1.010112f;
  167. LLQuaternion q(a,b,c,d);
  168. LLVector4 vec4b(a,b,c,d),vec4c;
  169. vec4b.rotVec(q);
  170. vec4c.setVec(a, b, c, d);
  171. vec4c.rotVec(q);
  172. ensure_equals("2:rotVec: Fail " ,vec4b, vec4c);
  173. }
  174. template<> template<>
  175. void v4math_object::test<9>()
  176. {
  177. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  178. LLVector4 vec4(x,y,z,w),vec4a;;
  179. std::ostringstream stream1, stream2;
  180. stream1 << vec4;
  181. vec4a.setVec(x,y,z,w);
  182. stream2 << vec4a;
  183. ensure("operator << failed",(stream1.str() == stream2.str()));
  184. }
  185. template<> template<>
  186. void v4math_object::test<10>()
  187. {
  188. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
  189. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
  190. LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
  191. vec4b = vec4a + vec4;
  192. ensure("1:operator+:Fail to initialize " ,(is_approx_equal(x1+x2,vec4b.mV[VX]) && is_approx_equal(y1+y2,vec4b.mV[VY]) && is_approx_equal(z1+z2,vec4b.mV[VZ])));
  193. x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
  194. vec4.clearVec();
  195. vec4a.clearVec();
  196. vec4.setVec(x1,y1,z1);
  197. vec4a +=vec4;
  198. ensure_equals("2:operator+=: Fail to initialize", vec4a,vec4);
  199. vec4a += vec4;
  200. ensure("3:operator+=:Fail to initialize " ,(is_approx_equal(2*x1,vec4a.mV[VX]) && is_approx_equal(2*y1,vec4a.mV[VY]) && is_approx_equal(2*z1,vec4a.mV[VZ])));
  201. }
  202. template<> template<>
  203. void v4math_object::test<11>()
  204. {
  205. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
  206. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
  207. LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
  208. vec4b = vec4a - vec4;
  209. ensure("1:operator-:Fail to initialize " ,(is_approx_equal(x2-x1,vec4b.mV[VX]) && is_approx_equal(y2-y1,vec4b.mV[VY]) && is_approx_equal(z2-z1,vec4b.mV[VZ])));
  210. x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
  211. vec4.clearVec();
  212. vec4a.clearVec();
  213. vec4.setVec(x1,y1,z1);
  214. vec4a -=vec4;
  215. ensure_equals("2:operator-=: Fail to initialize" , vec4a,-vec4);
  216. vec4a -=vec4;
  217. ensure("3:operator-=:Fail to initialize " ,(is_approx_equal(-2*x1,vec4a.mV[VX]) && is_approx_equal(-2*y1,vec4a.mV[VY]) && is_approx_equal(-2*z1,vec4a.mV[VZ])));
  218. }
  219. template<> template<>
  220. void v4math_object::test<12>()
  221. {
  222. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
  223. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
  224. LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
  225. F32 res = vec4 * vec4a;
  226. ensure("1:operator* failed " ,is_approx_equal(res, x1*x2 + y1*y2 + z1*z2));
  227. vec4a.clearVec();
  228. F32 mulVal = 4.2f;
  229. vec4a = vec4 * mulVal;
  230. ensure("2:operator* failed " ,is_approx_equal(x1*mulVal,vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
  231. vec4a.clearVec();
  232. vec4a = mulVal * vec4 ;
  233. ensure("3:operator* failed " ,is_approx_equal(x1*mulVal, vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
  234. vec4 *= mulVal;
  235. ensure("4:operator*= failed " ,is_approx_equal(x1*mulVal, vec4.mV[VX]) && is_approx_equal(y1*mulVal, vec4.mV[VY])&& is_approx_equal(z1*mulVal, vec4.mV[VZ]));
  236. }
  237. template<> template<>
  238. void v4math_object::test<13>()
  239. {
  240. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
  241. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
  242. LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2),vec4b;
  243. vec4b = vec4 % vec4a;
  244. ensure("1:operator% failed " ,is_approx_equal(y1*z2 - y2*z1, vec4b.mV[VX]) && is_approx_equal(z1*x2 -z2*x1, vec4b.mV[VY]) && is_approx_equal(x1*y2-x2*y1, vec4b.mV[VZ]));
  245. vec4 %= vec4a;
  246. ensure_equals("operator%= failed " ,vec4,vec4b);
  247. }
  248. template<> template<>
  249. void v4math_object::test<14>()
  250. {
  251. F32 x = 1.f, y = 2.f, z = -1.1f,div = 4.2f;
  252. F32 t = 1.f / div;
  253. LLVector4 vec4(x,y,z), vec4a;
  254. vec4a = vec4/div;
  255. ensure("1:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
  256. x = 1.23f, y = 4.f, z = -2.32f;
  257. vec4.clearVec();
  258. vec4a.clearVec();
  259. vec4.setVec(x,y,z);
  260. vec4a = vec4/div;
  261. ensure("2:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
  262. vec4 /= div;
  263. ensure("3:operator/ failed " ,is_approx_equal(x*t, vec4.mV[VX]) && is_approx_equal(y*t, vec4.mV[VY])&& is_approx_equal(z*t, vec4.mV[VZ]));
  264. }
  265. template<> template<>
  266. void v4math_object::test<15>()
  267. {
  268. F32 x = 1.f, y = 2.f, z = -1.1f;
  269. LLVector4 vec4(x,y,z), vec4a;
  270. ensure("operator!= failed " ,(vec4 != vec4a));
  271. vec4a = vec4;
  272. ensure("operator== failed " ,(vec4 ==vec4a));
  273. }
  274. template<> template<>
  275. void v4math_object::test<16>()
  276. {
  277. F32 x = 1.f, y = 2.f, z = -1.1f;
  278. LLVector4 vec4(x,y,z), vec4a;
  279. vec4a = - vec4;
  280. ensure("operator- failed " , (vec4 == - vec4a));
  281. }
  282. template<> template<>
  283. void v4math_object::test<17>()
  284. {
  285. F32 x = 1.f, y = 2.f, z = -1.1f,epsilon = .23425f;
  286. LLVector4 vec4(x,y,z), vec4a(x,y,z);
  287. ensure("1:are_parallel: Fail " ,(TRUE == are_parallel(vec4a,vec4,epsilon)));
  288. x = 21.f, y = 12.f, z = -123.1f;
  289. vec4a.clearVec();
  290. vec4a.setVec(x,y,z);
  291. ensure("2:are_parallel: Fail " ,(FALSE == are_parallel(vec4a,vec4,epsilon)));
  292. }
  293. template<> template<>
  294. void v4math_object::test<18>()
  295. {
  296. F32 x = 1.f, y = 2.f, z = -1.1f;
  297. F32 angle1, angle2;
  298. LLVector4 vec4(x,y,z), vec4a(x,y,z);
  299. angle1 = angle_between(vec4, vec4a);
  300. vec4.normVec();
  301. vec4a.normVec();
  302. angle2 = acos(vec4 * vec4a);
  303. ensure_approximately_equals("1:angle_between: Fail " ,angle1,angle2,8);
  304. F32 x1 = 21.f, y1 = 2.23f, z1 = -1.1f;
  305. LLVector4 vec4b(x,y,z), vec4c(x1,y1,z1);
  306. angle1 = angle_between(vec4b, vec4c);
  307. vec4b.normVec();
  308. vec4c.normVec();
  309. angle2 = acos(vec4b * vec4c);
  310. ensure_approximately_equals("2:angle_between: Fail " ,angle1,angle2,8);
  311. }
  312. template<> template<>
  313. void v4math_object::test<19>()
  314. {
  315. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.f, z2 = 1.f;
  316. F32 val1,val2;
  317. LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
  318. val1 = dist_vec(vec4,vec4a);
  319. val2 = (F32) sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
  320. ensure_equals("dist_vec: Fail ",val2, val1);
  321. val1 = dist_vec_squared(vec4,vec4a);
  322. val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
  323. ensure_equals("dist_vec_squared: Fail ",val2, val1);
  324. }
  325. template<> template<>
  326. void v4math_object::test<20>()
  327. {
  328. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, w1 = -.23f, x2 = 1.3f, y2 = 1.f, z2 = 1.f,w2 = .12f;
  329. F32 val = 2.3f,val1,val2,val3,val4;
  330. LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2);
  331. val1 = x1 + (x2 - x1)* val;
  332. val2 = y1 + (y2 - y1)* val;
  333. val3 = z1 + (z2 - z1)* val;
  334. val4 = w1 + (w2 - w1)* val;
  335. LLVector4 vec4b = lerp(vec4,vec4a,val);
  336. ensure("lerp failed", ((val1 ==vec4b.mV[VX])&& (val2 ==vec4b.mV[VY]) && (val3 ==vec4b.mV[VZ])&& (val4 ==vec4b.mV[VW])));
  337. }
  338. template<> template<>
  339. void v4math_object::test<21>()
  340. {
  341. F32 x = 1.f, y = 2.f, z = -1.1f;
  342. LLVector4 vec4(x,y,z);
  343. LLVector3 vec3 = vec4to3(vec4);
  344. ensure("vec4to3 failed", ((x == vec3.mV[VX])&& (y == vec3.mV[VY]) && (z == vec3.mV[VZ])));
  345. LLVector4 vec4a = vec3to4(vec3);
  346. ensure_equals("vec3to4 failed",vec4a,vec4);
  347. }
  348. template<> template<>
  349. void v4math_object::test<22>()
  350. {
  351. F32 x = 1.f, y = 2.f, z = -1.1f;
  352. LLVector4 vec4(x,y,z);
  353. LLSD llsd = vec4.getValue();
  354. LLVector3 vec3(llsd);
  355. LLVector4 vec4a = vec3to4(vec3);
  356. ensure_equals("getValue failed",vec4a,vec4);
  357. }
  358. }