LRAUV  revA
AuvMath_Test.h
Go to the documentation of this file.
1 
9 #ifndef _AUVMATH_TEST_H_
10 #define _AUVMATH_TEST_H_
11 
12 #include "data/Slate.h"
13 #include "utils/AuvMath.h"
14 
15 #include <cxxtest/TestSuite.h>
16 
22 class AuvMath_Test : public CxxTest::TestSuite
23 {
24 public:
25 
26  void testAreaContains( void )
27  {
28  float x0[] = {0, 3, 3, 0, 1, 2, 2, 1};
29  float y0[] = {0, 0, 3, 3, 1, 1, 2, 2};
30  float x1[] = {3, 3, 0, 0, 2, 2, 1, 1};
31  float y1[] = {0, 3, 3, 0, 1, 2, 2, 1};
32 
33  TS_ASSERT( !AuvMath::AreaContains( -0.5, -0.5, 8, x0, y0, x1, y1 ) );
34  TS_ASSERT( AuvMath::AreaContains( 0.5, 0.5, 8, x0, y0, x1, y1 ) );
35  TS_ASSERT( !AuvMath::AreaContains( 1.5, 1.5, 8, x0, y0, x1, y1 ) );
36  TS_ASSERT( AuvMath::AreaContains( 2.5, 2.5, 8, x0, y0, x1, y1 ) );
37  TS_ASSERT( !AuvMath::AreaContains( 3.5, 3.5, 8, x0, y0, x1, y1 ) );
38  TS_ASSERT( AuvMath::AreaContains( 1, 0.5, 8, x0, y0, x1, y1 ) );
39  TS_ASSERT( AuvMath::AreaContains( 0.5, 1, 8, x0, y0, x1, y1 ) );
40  TS_ASSERT( AuvMath::AreaContains( 2, 0.5, 8, x0, y0, x1, y1 ) );
41  TS_ASSERT( AuvMath::AreaContains( 0.5, 2, 8, x0, y0, x1, y1 ) );
42  }
43 
45  void testLimit( void )
46  {
47  // char
48  signed char cMin = -128, cMid = 0, cMax = 127;
49  TS_ASSERT_EQUALS( AuvMath::Limit( cMin, cMin, cMax ), cMin );
50  TS_ASSERT_EQUALS( AuvMath::Limit( cMid, cMin, cMax ), cMid );
51  TS_ASSERT_EQUALS( AuvMath::Limit( cMax, cMin, cMax ), cMax );
52  TS_ASSERT_EQUALS( AuvMath::Limit( cMax, cMin, cMax ), cMax );
53  TS_ASSERT_EQUALS( AuvMath::Limit( cMin, cMid, cMax ), cMid );
54  TS_ASSERT_EQUALS( AuvMath::Limit( cMax, cMin, cMid ), cMid );
55  // unsigned char
56  unsigned char ucMin = 0, ucMid = 128, ucMax = 255;
57  TS_ASSERT_EQUALS( AuvMath::Limit( ucMin, ucMin, ucMax ), ucMin );
58  TS_ASSERT_EQUALS( AuvMath::Limit( ucMid, ucMin, ucMax ), ucMid );
59  TS_ASSERT_EQUALS( AuvMath::Limit( ucMax, ucMin, ucMax ), ucMax );
60  TS_ASSERT_EQUALS( AuvMath::Limit( ucMax, ucMin, ucMax ), ucMax );
61  TS_ASSERT_EQUALS( AuvMath::Limit( ucMin, ucMid, ucMax ), ucMid );
62  TS_ASSERT_EQUALS( AuvMath::Limit( ucMax, ucMin, ucMid ), ucMid );
63  // int
64  int iMin = -2147483647, iMid = 0, iMax = 2147483647;
65  TS_ASSERT_EQUALS( AuvMath::Limit( iMin, iMin, iMax ), iMin );
66  TS_ASSERT_EQUALS( AuvMath::Limit( iMid, iMin, iMax ), iMid );
67  TS_ASSERT_EQUALS( AuvMath::Limit( iMax, iMin, iMax ), iMax );
68  TS_ASSERT_EQUALS( AuvMath::Limit( iMax, iMin, iMax ), iMax );
69  TS_ASSERT_EQUALS( AuvMath::Limit( iMin, iMid, iMax ), iMid );
70  TS_ASSERT_EQUALS( AuvMath::Limit( iMax, iMin, iMid ), iMid );
71  // unsigned int
72  unsigned int uiMin = 0, uiMid = 2147483648U, uiMax = 4294967295U;
73  TS_ASSERT_EQUALS( AuvMath::Limit( uiMin, uiMin, uiMax ), uiMin );
74  TS_ASSERT_EQUALS( AuvMath::Limit( uiMid, uiMin, uiMax ), uiMid );
75  TS_ASSERT_EQUALS( AuvMath::Limit( uiMax, uiMin, uiMax ), uiMax );
76  TS_ASSERT_EQUALS( AuvMath::Limit( uiMax, uiMin, uiMax ), uiMax );
77  TS_ASSERT_EQUALS( AuvMath::Limit( uiMin, uiMid, uiMax ), uiMid );
78  TS_ASSERT_EQUALS( AuvMath::Limit( uiMax, uiMin, uiMid ), uiMid );
79  // float
80  float fMin = -INFINITY, fMid = 0, fMax = INFINITY, fNan = nanf( "" ), fRes;
81  TS_ASSERT_EQUALS( AuvMath::Limit( fMin, fMin, fMax ), fMin );
82  TS_ASSERT_EQUALS( AuvMath::Limit( fMid, fMin, fMax ), fMid );
83  TS_ASSERT_EQUALS( AuvMath::Limit( fMax, fMin, fMax ), fMax );
84  TS_ASSERT_EQUALS( AuvMath::Limit( fMax, fMin, fMax ), fMax );
85  TS_ASSERT_EQUALS( AuvMath::Limit( fMin, fMid, fMax ), fMid );
86  TS_ASSERT_EQUALS( AuvMath::Limit( fMax, fMin, fMid ), fMid );
87  fRes = AuvMath::Limit( fNan, fMin, fMax );
88  TS_ASSERT_DIFFERS( fRes, fRes );
89  fRes = AuvMath::Limit( fMid, fNan, fMax );
90  TS_ASSERT_DIFFERS( fRes, fRes );
91  fRes = AuvMath::Limit( fMid, fMin, fNan );
92  TS_ASSERT_DIFFERS( fRes, fRes );
93  // double
94  double dMin = -INFINITY, dMid = 0, dMax = INFINITY, dNan = nan( "" ), dRes;
95  TS_ASSERT_EQUALS( AuvMath::Limit( dMin, dMin, dMax ), dMin );
96  TS_ASSERT_EQUALS( AuvMath::Limit( dMid, dMin, dMax ), dMid );
97  TS_ASSERT_EQUALS( AuvMath::Limit( dMax, dMin, dMax ), dMax );
98  TS_ASSERT_EQUALS( AuvMath::Limit( dMax, dMin, dMax ), dMax );
99  TS_ASSERT_EQUALS( AuvMath::Limit( dMin, dMid, dMax ), dMid );
100  TS_ASSERT_EQUALS( AuvMath::Limit( dMax, dMin, dMid ), dMid );
101  dRes = AuvMath::Limit( dNan, dMin, dMax );
102  TS_ASSERT_DIFFERS( dRes, dRes );
103  dRes = AuvMath::Limit( dMid, dNan, dMax );
104  TS_ASSERT_DIFFERS( dRes, dRes );
105  dRes = AuvMath::Limit( dMid, dMin, dNan );
106  TS_ASSERT_DIFFERS( dRes, dRes );
107  }
108 
110  void testMin( void )
111  {
112  // char
113  signed char cMin = -128, cMid = 0, cMax = 127;
114  TS_ASSERT_EQUALS( AuvMath::Min( cMin, cMax ), cMin );
115  TS_ASSERT_EQUALS( AuvMath::Min( cMax, cMin ), cMin );
116  TS_ASSERT_EQUALS( AuvMath::Min( cMin, cMid ), cMin );
117  TS_ASSERT_EQUALS( AuvMath::Min( cMid, cMin ), cMin );
118  TS_ASSERT_EQUALS( AuvMath::Min( cMid, cMax ), cMid );
119  TS_ASSERT_EQUALS( AuvMath::Min( cMax, cMid ), cMid );
120  // unsigned char
121  unsigned char ucMin = 0, ucMid = 128, ucMax = 255;
122  TS_ASSERT_EQUALS( AuvMath::Min( ucMin, ucMax ), ucMin );
123  TS_ASSERT_EQUALS( AuvMath::Min( ucMax, ucMin ), ucMin );
124  TS_ASSERT_EQUALS( AuvMath::Min( ucMin, ucMid ), ucMin );
125  TS_ASSERT_EQUALS( AuvMath::Min( ucMid, ucMin ), ucMin );
126  TS_ASSERT_EQUALS( AuvMath::Min( ucMid, ucMax ), ucMid );
127  TS_ASSERT_EQUALS( AuvMath::Min( ucMax, ucMid ), ucMid );
128  // int
129  int iMin = -2147483647, iMid = 0, iMax = 2147483647;
130  TS_ASSERT_EQUALS( AuvMath::Min( iMin, iMax ), iMin );
131  TS_ASSERT_EQUALS( AuvMath::Min( iMax, iMin ), iMin );
132  TS_ASSERT_EQUALS( AuvMath::Min( iMin, iMid ), iMin );
133  TS_ASSERT_EQUALS( AuvMath::Min( iMid, iMin ), iMin );
134  TS_ASSERT_EQUALS( AuvMath::Min( iMid, iMax ), iMid );
135  TS_ASSERT_EQUALS( AuvMath::Min( iMax, iMid ), iMid );
136  // unsigned int
137  unsigned int uiMin = 0, uiMid = 2147483648U, uiMax = 4294967295U;
138  TS_ASSERT_EQUALS( AuvMath::Min( uiMin, uiMax ), uiMin );
139  TS_ASSERT_EQUALS( AuvMath::Min( uiMax, uiMin ), uiMin );
140  TS_ASSERT_EQUALS( AuvMath::Min( uiMin, uiMid ), uiMin );
141  TS_ASSERT_EQUALS( AuvMath::Min( uiMid, uiMin ), uiMin );
142  TS_ASSERT_EQUALS( AuvMath::Min( uiMid, uiMax ), uiMid );
143  TS_ASSERT_EQUALS( AuvMath::Min( uiMax, uiMid ), uiMid );
144  // float
145  float fMin = -INFINITY, fMid = 0, fMax = INFINITY, fNan = nanf( "" ), fRes;
146  TS_ASSERT_EQUALS( AuvMath::Min( fMin, fMax ), fMin );
147  TS_ASSERT_EQUALS( AuvMath::Min( fMax, fMin ), fMin );
148  TS_ASSERT_EQUALS( AuvMath::Min( fMin, fMid ), fMin );
149  TS_ASSERT_EQUALS( AuvMath::Min( fMid, fMin ), fMin );
150  TS_ASSERT_EQUALS( AuvMath::Min( fMid, fMax ), fMid );
151  TS_ASSERT_EQUALS( AuvMath::Min( fMax, fMid ), fMid );
152  fRes = AuvMath::Min( fNan, fMax );
153  TS_ASSERT_DIFFERS( fRes, fRes );
154  fRes = AuvMath::Min( fMin, fNan );
155  TS_ASSERT_DIFFERS( fRes, fRes );
156  fRes = AuvMath::Min( fMid, fNan );
157  TS_ASSERT_DIFFERS( fRes, fRes );
158  // double
159  double dMin = -INFINITY, dMid = 0, dMax = INFINITY, dNan = nan( "" ), dRes;
160  TS_ASSERT_EQUALS( AuvMath::Min( dMin, dMax ), dMin );
161  TS_ASSERT_EQUALS( AuvMath::Min( dMax, dMin ), dMin );
162  TS_ASSERT_EQUALS( AuvMath::Min( dMin, dMid ), dMin );
163  TS_ASSERT_EQUALS( AuvMath::Min( dMid, dMin ), dMin );
164  TS_ASSERT_EQUALS( AuvMath::Min( dMid, dMax ), dMid );
165  TS_ASSERT_EQUALS( AuvMath::Min( dMax, dMid ), dMid );
166  dRes = AuvMath::Min( dNan, dMax );
167  TS_ASSERT_DIFFERS( dRes, dRes );
168  dRes = AuvMath::Min( dMin, dNan );
169  TS_ASSERT_DIFFERS( dRes, dRes );
170  dRes = AuvMath::Min( dMid, dNan );
171  TS_ASSERT_DIFFERS( dRes, dRes );
172  }
173 
175  void testMax( void )
176  {
177  // char
178  signed char cMin = -128, cMid = 0, cMax = 127;
179  TS_ASSERT_EQUALS( AuvMath::Max( cMin, cMax ), cMax );
180  TS_ASSERT_EQUALS( AuvMath::Max( cMax, cMin ), cMax );
181  TS_ASSERT_EQUALS( AuvMath::Max( cMin, cMid ), cMid );
182  TS_ASSERT_EQUALS( AuvMath::Max( cMid, cMin ), cMid );
183  TS_ASSERT_EQUALS( AuvMath::Max( cMid, cMax ), cMax );
184  TS_ASSERT_EQUALS( AuvMath::Max( cMax, cMid ), cMax );
185  // unsigned char
186  unsigned char ucMin = 0, ucMid = 128, ucMax = 255;
187  TS_ASSERT_EQUALS( AuvMath::Max( ucMin, ucMax ), ucMax );
188  TS_ASSERT_EQUALS( AuvMath::Max( ucMax, ucMin ), ucMax );
189  TS_ASSERT_EQUALS( AuvMath::Max( ucMin, ucMid ), ucMid );
190  TS_ASSERT_EQUALS( AuvMath::Max( ucMid, ucMin ), ucMid );
191  TS_ASSERT_EQUALS( AuvMath::Max( ucMid, ucMax ), ucMax );
192  TS_ASSERT_EQUALS( AuvMath::Max( ucMax, ucMid ), ucMax );
193  // int
194  int iMin = -2147483647, iMid = 0, iMax = 2147483647;
195  TS_ASSERT_EQUALS( AuvMath::Max( iMin, iMax ), iMax );
196  TS_ASSERT_EQUALS( AuvMath::Max( iMax, iMin ), iMax );
197  TS_ASSERT_EQUALS( AuvMath::Max( iMin, iMid ), iMid );
198  TS_ASSERT_EQUALS( AuvMath::Max( iMid, iMin ), iMid );
199  TS_ASSERT_EQUALS( AuvMath::Max( iMid, iMax ), iMax );
200  TS_ASSERT_EQUALS( AuvMath::Max( iMax, iMid ), iMax );
201  // unsigned int
202  unsigned int uiMin = 0, uiMid = 2147483648U, uiMax = 4294967295U;
203  TS_ASSERT_EQUALS( AuvMath::Max( uiMin, uiMax ), uiMax );
204  TS_ASSERT_EQUALS( AuvMath::Max( uiMax, uiMin ), uiMax );
205  TS_ASSERT_EQUALS( AuvMath::Max( uiMin, uiMid ), uiMid );
206  TS_ASSERT_EQUALS( AuvMath::Max( uiMid, uiMin ), uiMid );
207  TS_ASSERT_EQUALS( AuvMath::Max( uiMid, uiMax ), uiMax );
208  TS_ASSERT_EQUALS( AuvMath::Max( uiMax, uiMid ), uiMax );
209  // float
210  float fMin = -INFINITY, fMid = 0, fMax = INFINITY, fNan = nanf( "" ), fRes;
211  TS_ASSERT_EQUALS( AuvMath::Max( fMin, fMax ), fMax );
212  TS_ASSERT_EQUALS( AuvMath::Max( fMax, fMin ), fMax );
213  TS_ASSERT_EQUALS( AuvMath::Max( fMin, fMid ), fMid );
214  TS_ASSERT_EQUALS( AuvMath::Max( fMid, fMin ), fMid );
215  TS_ASSERT_EQUALS( AuvMath::Max( fMid, fMax ), fMax );
216  TS_ASSERT_EQUALS( AuvMath::Max( fMax, fMid ), fMax );
217  fRes = AuvMath::Max( fNan, fMax );
218  TS_ASSERT_DIFFERS( fRes, fRes );
219  fRes = AuvMath::Max( fMin, fNan );
220  TS_ASSERT_DIFFERS( fRes, fRes );
221  fRes = AuvMath::Max( fMid, fNan );
222  TS_ASSERT_DIFFERS( fRes, fRes );
223  // double
224  double dMin = -INFINITY, dMid = 0, dMax = INFINITY, dNan = nan( "" ), dRes;
225  TS_ASSERT_EQUALS( AuvMath::Max( dMin, dMax ), dMax );
226  TS_ASSERT_EQUALS( AuvMath::Max( dMax, dMin ), dMax );
227  TS_ASSERT_EQUALS( AuvMath::Max( dMin, dMid ), dMid );
228  TS_ASSERT_EQUALS( AuvMath::Max( dMid, dMin ), dMid );
229  TS_ASSERT_EQUALS( AuvMath::Max( dMid, dMax ), dMax );
230  TS_ASSERT_EQUALS( AuvMath::Max( dMax, dMid ), dMax );
231  dRes = AuvMath::Max( dNan, dMax );
232  TS_ASSERT_DIFFERS( dRes, dRes );
233  dRes = AuvMath::Max( dMin, dNan );
234  TS_ASSERT_DIFFERS( dRes, dRes );
235  dRes = AuvMath::Max( dMid, dNan );
236  TS_ASSERT_DIFFERS( dRes, dRes );
237  }
238 
240  void testSwap( void )
241  {
242  // char
243  signed char cMin = -128, cMax = 127;
244  AuvMath::Swap( cMin, cMax );
245  TS_ASSERT_EQUALS( cMin, 127 );
246  TS_ASSERT_EQUALS( cMax, -128 );
247 
248  // unsigned char
249  unsigned char ucMin = 0, ucMax = 255;
250  AuvMath::Swap( ucMin, ucMax );
251  TS_ASSERT_EQUALS( ucMin, 255 );
252  TS_ASSERT_EQUALS( ucMax, 0 );
253 
254  // int
255  int iMin = -2147483647, iMax = 2147483647;
256  AuvMath::Swap( iMin, iMax );
257  TS_ASSERT_EQUALS( iMin, 2147483647 );
258  TS_ASSERT_EQUALS( iMax, -2147483647 );
259 
260  // unsigned int
261  unsigned int uiMin = 0, uiMax = 4294967295U;
262  AuvMath::Swap( uiMin, uiMax );
263  TS_ASSERT_EQUALS( uiMin, 4294967295U );
264  TS_ASSERT_EQUALS( uiMax, 0U );
265 
266  // float
267  float fMin = -INFINITY, fMax = INFINITY, fNan = nanf( "" );
268  AuvMath::Swap( fMin, fMax );
269  TS_ASSERT_EQUALS( fMin, ( float )INFINITY );
270  TS_ASSERT_EQUALS( fMax, ( float ) - INFINITY );
271  AuvMath::Swap( fMin, fNan );
272  TS_ASSERT_EQUALS( fNan, INFINITY );
273  TS_ASSERT_DIFFERS( fMin, fMin );
274 
275  // double
276  double dMin = -INFINITY, dMax = INFINITY, dNan = nan( "" );
277  AuvMath::Swap( dMin, dMax );
278  TS_ASSERT_EQUALS( dMin, INFINITY );
279  TS_ASSERT_EQUALS( dMax, -INFINITY );
280  AuvMath::Swap( dMin, dNan );
281  TS_ASSERT_EQUALS( dNan, INFINITY );
282  TS_ASSERT_DIFFERS( dMin, dMin );
283  }
284 
286  void testModPi( void )
287  {
288  // float
289  float fN721 = D2R( -721 ), fN360 = D2R( -360 ), fN181 = D2R( -181 ), fN179 = D2R( -179 ), fN1 = D2R( -1 );
290  float f0 = 0, fNan = nanf( "" ), fDelta = 1e-6, fRes;
291  float f1 = D2R( 1 ), f179 = D2R( 179 ), f181 = D2R( 181 ), f360 = D2R( 360 ), f721 = D2R( 721 );
292  TS_ASSERT_DELTA( AuvMath::ModPi( fN721 ), fN1, fDelta );
293  TS_ASSERT_DELTA( AuvMath::ModPi( fN360 ), f0, fDelta );
294  TS_ASSERT_DELTA( AuvMath::ModPi( fN181 ), f179, fDelta );
295  TS_ASSERT_DELTA( AuvMath::ModPi( fN179 ), fN179, fDelta );
296  TS_ASSERT_DELTA( AuvMath::ModPi( f0 ), f0, fDelta );
297  TS_ASSERT_DELTA( AuvMath::ModPi( f179 ), f179, fDelta );
298  TS_ASSERT_DELTA( AuvMath::ModPi( f181 ), fN179, fDelta );
299  TS_ASSERT_DELTA( AuvMath::ModPi( f360 ), f0, fDelta );
300  TS_ASSERT_DELTA( AuvMath::ModPi( f721 ), f1, fDelta );
301  fRes = AuvMath::ModPi( fNan );
302  TS_ASSERT_DIFFERS( fRes, fRes );
303  // double
304  double dN721 = D2R( -721 ), dN360 = D2R( -360 ), dN181 = D2R( -181 ), dN179 = D2R( -179 ), dN1 = D2R( -1 );
305  double d0 = 0, dNan = nanf( "" ), dDelta = 1e-6, dRes;
306  double d1 = D2R( 1 ), d179 = D2R( 179 ), d181 = D2R( 181 ), d360 = D2R( 360 ), d721 = D2R( 721 );
307  TS_ASSERT_DELTA( AuvMath::ModPi( dN721 ), dN1, dDelta );
308  TS_ASSERT_DELTA( AuvMath::ModPi( dN360 ), d0, dDelta );
309  TS_ASSERT_DELTA( AuvMath::ModPi( dN181 ), d179, dDelta );
310  TS_ASSERT_DELTA( AuvMath::ModPi( dN179 ), dN179, dDelta );
311  TS_ASSERT_DELTA( AuvMath::ModPi( d0 ), d0, dDelta );
312  TS_ASSERT_DELTA( AuvMath::ModPi( d179 ), d179, dDelta );
313  TS_ASSERT_DELTA( AuvMath::ModPi( d181 ), dN179, dDelta );
314  TS_ASSERT_DELTA( AuvMath::ModPi( d360 ), d0, dDelta );
315  TS_ASSERT_DELTA( AuvMath::ModPi( d721 ), d1, dDelta );
316  dRes = AuvMath::ModPi( dNan );
317  TS_ASSERT_DIFFERS( dRes, dRes );
318  }
319 
321  void testNanZero( void )
322  {
323  // float
324  float fMin = -INFINITY, fMid = 0, fMax = INFINITY, fNan = nanf( "" );
325  TS_ASSERT_EQUALS( AuvMath::NanZero( fMin ), fMin );
326  TS_ASSERT_EQUALS( AuvMath::NanZero( fMid ), fMid );
327  TS_ASSERT_EQUALS( AuvMath::NanZero( fMax ), fMax );
328  TS_ASSERT_EQUALS( AuvMath::NanZero( fNan ), 0 );
329  // double
330  double dMin = -INFINITY, dMid = 0, dMax = INFINITY, dNan = nan( "" );
331  TS_ASSERT_EQUALS( AuvMath::NanZero( dMin ), dMin );
332  TS_ASSERT_EQUALS( AuvMath::NanZero( dMid ), dMid );
333  TS_ASSERT_EQUALS( AuvMath::NanZero( dMax ), dMax );
334  TS_ASSERT_EQUALS( AuvMath::NanZero( dNan ), 0 );
335  }
336 
338  void testRound( void )
339  {
340  // float
341  float fMin = -128, fMid = 0, fMax = 128, fNan = nanf( "" ), fDiv = 3.5, fRes;
342  TS_ASSERT_EQUALS( AuvMath::Round( fMin, fDiv ), -129.5 );
343  TS_ASSERT_EQUALS( AuvMath::Round( fMid, fDiv ), 0 );
344  TS_ASSERT_EQUALS( AuvMath::Round( fMax, fDiv ), 129.5 );
345  fRes = AuvMath::Round( fMin, fNan );
346  TS_ASSERT_DIFFERS( fRes, fRes );
347  fRes = AuvMath::Round( fNan, fDiv );
348  TS_ASSERT_DIFFERS( fRes, fRes );
349  fRes = AuvMath::Round( fDiv, fMid );
350  TS_ASSERT_DIFFERS( fRes, fRes );
351  // double
352  double dMin = -128, dMid = 0, dMax = 128, dNan = nanf( "" ), dDiv = 3.5, dRes;
353  TS_ASSERT_EQUALS( AuvMath::Round( dMin, dDiv ), -129.5 );
354  TS_ASSERT_EQUALS( AuvMath::Round( dMid, dDiv ), 0 );
355  TS_ASSERT_EQUALS( AuvMath::Round( dMax, dDiv ), 129.5 );
356  dRes = AuvMath::Round( dMin, dNan );
357  TS_ASSERT_DIFFERS( dRes, dRes );
358  dRes = AuvMath::Round( dNan, dDiv );
359  TS_ASSERT_DIFFERS( dRes, dRes );
360  dRes = AuvMath::Round( dDiv, dMid );
361  TS_ASSERT_DIFFERS( dRes, dRes );
362  }
363 
364 
366  void testSign( void )
367  {
368  // char
369  signed char cMin = -128, cMid = 0, cMax = 127;
370  TS_ASSERT_EQUALS( AuvMath::Sign( cMin ), -1 );
371  TS_ASSERT_EQUALS( AuvMath::Sign( cMid ), 0 );
372  TS_ASSERT_EQUALS( AuvMath::Sign( cMax ), 1 );
373  // int
374  int iMin = -2147483647, iMid = 0, iMax = 2147483647;
375  TS_ASSERT_EQUALS( AuvMath::Sign( iMin ), -1 );
376  TS_ASSERT_EQUALS( AuvMath::Sign( iMid ), 0 );
377  TS_ASSERT_EQUALS( AuvMath::Sign( iMax ), 1 );
378  // unsigned int
379  // float
380  float fMin = -INFINITY, fMid = 0, fMax = INFINITY, fNan = nanf( "" ), fRes;
381  TS_ASSERT_EQUALS( AuvMath::Sign( fMin ), -1 );
382  TS_ASSERT_EQUALS( AuvMath::Sign( fMid ), 0 );
383  TS_ASSERT_EQUALS( AuvMath::Sign( fMax ), 1 );
384  fRes = AuvMath::Sign( fNan );
385  TS_ASSERT_DIFFERS( fRes, fRes );
386  // double
387  double dMin = -INFINITY, dMid = 0, dMax = INFINITY, dNan = nan( "" ), dRes;
388  TS_ASSERT_EQUALS( AuvMath::Sign( dMin ), -1 );
389  TS_ASSERT_EQUALS( AuvMath::Sign( dMid ), 0 );
390  TS_ASSERT_EQUALS( AuvMath::Sign( dMax ), 1 );
391  dRes = AuvMath::Sign( dNan );
392  TS_ASSERT_DIFFERS( dRes, dRes );
393  }
394 
396  void testFindLtEqIndex( void )
397  {
398  // float
399  float foo[] = {1, 2, 3.14159f, 4, 5, 5.12345678f, 6};
400  // Out of bounds checks
401  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 0.0f, 0, 6 ), -1 );
402  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 1.0f, 1, 6 ), -1 );
403  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 7.0f, 0, 6 ), -1 );
404  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 6.0f, 0, 5 ), -1 );
405  // Lookup checks
406  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 1.0f, 0, 6 ), 0 );
407  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 1.1f, 0, 6 ), 0 );
408  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 2.0f, 0, 6 ), 1 );
409  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 3.1415f, 0, 6 ), 1 );
410  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 3.14159f, 0, 6 ), 2 );
411  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 3.141592f, 0, 6 ), 2 );
412  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 5.2f, 0, 6 ), 5 );
413  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( foo, 6.0f, 0, 6 ), 6 );
414 
415  // double
416  double doo[] = {1, 2, 3.14159, 4, 5, 5.12345678, 6};
417  // Out of bounds checks
418  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 0.0, 0, 6 ), -1 );
419  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 1.0, 1, 6 ), -1 );
420  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 7.0, 0, 6 ), -1 );
421  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 6.0, 0, 5 ), -1 );
422  // Lookup checks
423  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 1.0, 0, 6 ), 0 );
424  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 1.1, 0, 6 ), 0 );
425  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 2.0, 0, 6 ), 1 );
426  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 3.1415, 0, 6 ), 1 );
427  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 3.14159, 0, 6 ), 2 );
428  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 3.141592, 0, 6 ), 2 );
429  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 5.2, 0, 6 ), 5 );
430  TS_ASSERT_EQUALS( AuvMath::FindLtEqIndex( doo, 6.0, 0, 6 ), 6 );
431 
432  }
433 
435  void testInterpolate1D( void )
436  {
437  // float
438  float foo[] = {1.0, 5.0}, fRes;
439  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.00f, foo[ 0 ], foo[ 1 ], 1.0f, 2.0f ), 1.0f );
440  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.25f, foo[ 0 ], foo[ 1 ], 1.0f, 2.0f ), 2.0f );
441  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.50f, foo[ 0 ], foo[ 1 ], 1.0f, 2.0f ), 3.0f );
442  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.75f, foo[ 0 ], foo[ 1 ], 1.0f, 2.0f ), 4.0f );
443  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 2.00f, foo[ 0 ], foo[ 1 ], 1.0f, 2.0f ), 5.0f );
444  fRes = AuvMath::Interpolate1D( 2.00f, foo[ 0 ], foo[ 1 ], 1.0f, 1.0f );
445  TS_ASSERT_DIFFERS( fRes, fRes );
446 
447  // double
448  double doo[] = {1.0, 5.0}, dRes;
449  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.00, doo[ 0 ], doo[ 1 ], 1.0, 2.0 ), 1.0 );
450  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.25, doo[ 0 ], doo[ 1 ], 1.0, 2.0 ), 2.0 );
451  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.50, doo[ 0 ], doo[ 1 ], 1.0, 2.0 ), 3.0 );
452  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 1.75, doo[ 0 ], doo[ 1 ], 1.0, 2.0 ), 4.0 );
453  TS_ASSERT_EQUALS( AuvMath::Interpolate1D( 2.00, doo[ 0 ], doo[ 1 ], 1.0, 2.0 ), 5.0 );
454  dRes = AuvMath::Interpolate1D( 2.00, doo[ 0 ], doo[ 1 ], 1.0, 1.0 );
455  TS_ASSERT_DIFFERS( dRes, dRes );
456  }
457 
459  void testInterpolate2D( void )
460  {
461  // float
462  float foo[ 2 ][ 2 ] = {{1.0, 5.0}, {3.0, 7.0}}, fRes;
463  TS_ASSERT_EQUALS( AuvMath::Interpolate2D( 1.5f, 3.5f, foo, 1.0f, 2.0f, 3.0f, 4.0f ), 4.0f );
464  fRes = AuvMath::Interpolate2D( 1.5f, 3.5f, foo, 1.0f, 1.0f, 3.0f, 4.0f );
465  TS_ASSERT_DIFFERS( fRes, fRes );
466  fRes = AuvMath::Interpolate2D( 1.5f, 3.5f, foo, 1.0f, 2.0f, 3.0f, 3.0f );
467  TS_ASSERT_DIFFERS( fRes, fRes );
468 
469  float moo[ 2 ][ 2 ] = { { 20.6948, 9.32573 }, { 36.8355, 62.5137 } };
470  TS_ASSERT_DELTA( AuvMath::Interpolate2D( 36.8f, -121.8f, moo, 36.7967f, 36.8067f, -121.8054f, -121.7954f ), 26.5f, 1.0f );
471 
472  // double
473  double doo[ 2 ][ 2 ] = {{1.0, 5.0}, {3.0, 7.0}}, dRes;
474  TS_ASSERT_EQUALS( AuvMath::Interpolate2D( 1.5, 3.5, doo, 1.0, 2.0, 3.0, 4.0 ), 4.0 );
475  dRes = AuvMath::Interpolate2D( 1.5, 3.5, doo, 1.0, 1.0, 3.0, 4.0 );
476  TS_ASSERT_DIFFERS( dRes, dRes );
477  dRes = AuvMath::Interpolate2D( 1.5, 3.5, doo, 1.0, 2.0, 3.0, 3.0 );
478  TS_ASSERT_DIFFERS( dRes, dRes );
479  }
480 
482  void testInterpolate3D( void )
483  {
484  // float
485  float foo[ 2 ][ 2 ][ 2 ] = {{{1.0, 5.0}, {3.0, 7.0}}, {{5.0, 9.0}, {7.0, 11.0}}}, fRes;
486  TS_ASSERT_EQUALS( AuvMath::Interpolate3D( 1.5f, 3.5f, 5.5f, foo, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f ), 6.0f );
487  fRes = AuvMath::Interpolate3D( 1.5f, 3.5f, 5.5f, foo, 1.0f, 1.0f, 3.0f, 4.0f, 5.0f, 6.0f );
488  TS_ASSERT_DIFFERS( fRes, fRes );
489  fRes = AuvMath::Interpolate3D( 1.5f, 3.5f, 5.5f, foo, 1.0f, 2.0f, 3.0f, 3.0f, 5.0f, 6.0f );
490  TS_ASSERT_DIFFERS( fRes, fRes );
491  fRes = AuvMath::Interpolate3D( 1.5f, 3.5f, 5.5f, foo, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 5.0f );
492  TS_ASSERT_DIFFERS( fRes, fRes );
493 
494  // double
495  double doo[ 2 ][ 2 ][ 2 ] = {{{1.0, 5.0}, {3.0, 7.0}}, {{5.0, 9.0}, {7.0, 11.0}}}, dRes;
496  TS_ASSERT_EQUALS( AuvMath::Interpolate3D( 1.5, 3.5, 5.5, doo, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ), 6.0 );
497  dRes = AuvMath::Interpolate3D( 1.5, 3.5, 5.5, doo, 1.0, 1.0, 3.0, 4.0, 5.0, 6.0 );
498  TS_ASSERT_DIFFERS( dRes, dRes );
499  dRes = AuvMath::Interpolate3D( 1.5, 3.5, 5.5, doo, 1.0, 2.0, 3.0, 3.0, 5.0, 6.0 );
500  TS_ASSERT_DIFFERS( dRes, dRes );
501  dRes = AuvMath::Interpolate3D( 1.5, 3.5, 5.5, doo, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0 );
502  TS_ASSERT_DIFFERS( dRes, dRes );
503  }
504 
506  void testInterpolate4D( void )
507  {
508  // float
509  float foo[ 2 ][ 2 ][ 2 ][ 2 ] = {{{{1.0, 5.0}, {3.0, 7.0}}, {{5.0, 9.0}, {7.0, 11.0}}}, {{{11.0, 15.0}, {13.0, 17.0}}, {{15.0, 19.0}, {17.0, 21.0}}}}, fRes;
510  TS_ASSERT_EQUALS( AuvMath::Interpolate4D( 1.5f, 3.5f, 5.5f, 7.5f, foo, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f ), 11.0f );
511  fRes = AuvMath::Interpolate4D( 1.5f, 3.5f, 5.5f, 7.5f, foo, 1.0f, 1.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f );
512  TS_ASSERT_DIFFERS( fRes, fRes );
513  fRes = AuvMath::Interpolate4D( 1.5f, 3.5f, 5.5f, 7.5f, foo, 1.0f, 2.0f, 3.0f, 3.0f, 5.0f, 6.0f, 7.0f, 8.0f );
514  TS_ASSERT_DIFFERS( fRes, fRes );
515  fRes = AuvMath::Interpolate4D( 1.5f, 3.5f, 5.5f, 7.5f, foo, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 5.0f, 7.0f, 8.0f );
516  TS_ASSERT_DIFFERS( fRes, fRes );
517  fRes = AuvMath::Interpolate4D( 1.5f, 3.5f, 5.5f, 7.5f, foo, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 7.0f );
518  TS_ASSERT_DIFFERS( fRes, fRes );
519 
520  // double
521  double doo[ 2 ][ 2 ][ 2 ][ 2 ] = {{{{1.0, 5.0}, {3.0, 7.0}}, {{5.0, 9.0}, {7.0, 11.0}}}, {{{11.0, 15.0}, {13.0, 17.0}}, {{15.0, 19.0}, {17.0, 21.0}}}}, dRes;
522  TS_ASSERT_EQUALS( AuvMath::Interpolate4D( 1.5, 3.5, 5.5, 7.5, doo, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ), 11.0 );
523  dRes = AuvMath::Interpolate4D( 1.5, 3.5, 5.5, 7.5, doo, 1.0, 1.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 );
524  TS_ASSERT_DIFFERS( dRes, dRes );
525  dRes = AuvMath::Interpolate4D( 1.5, 3.5, 5.5, 7.5, doo, 1.0, 2.0, 3.0, 3.0, 5.0, 6.0, 7.0, 8.0 );
526  TS_ASSERT_DIFFERS( dRes, dRes );
527  dRes = AuvMath::Interpolate4D( 1.5, 3.5, 5.5, 7.5, doo, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 7.0, 8.0 );
528  TS_ASSERT_DIFFERS( dRes, dRes );
529  dRes = AuvMath::Interpolate4D( 1.5, 3.5, 5.5, 7.5, doo, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 7.0 );
530  TS_ASSERT_DIFFERS( dRes, dRes );
531  }
532 
533  // AuvMath::BulkModulus %Unit Tests
534  void testBulkModulus( void )
535  {
536  TS_ASSERT_DELTA( AuvMath::BulkModulus( 35, 283.15, 4e7 ), 2404604869.0, 1.0 )
537  TS_ASSERT_DELTA( AuvMath::BulkModulus( 35, 298.15, 1e8 ), 2710894504.0, 1.0 );
538  }
539 
540  // AuvMath::Density %Unit Tests
541  void testDensity( void )
542  {
543  TS_ASSERT_DELTA( AuvMath::Density( 34.567, 278.15, 2e7 ), 1036.409, 0.001 );
544  TS_ASSERT_DELTA( AuvMath::Density( 35, 298.15, 1e8 ), 1062.53817, 0.00001 );
545  }
546 
547  // AuvMath::OceanDepth %Unit Tests
548  void testOceanDepth( void )
549  {
550  TS_ASSERT_DELTA( AuvMath::OceanDepth( 5e7, 0.628318531 ), 4906.08, 0.01 );
551  TS_ASSERT_DELTA( AuvMath::OceanDepth( 1e8, 1.570796327 ), 9674.23, 0.01 );
552  TS_ASSERT_DELTA( AuvMath::OceanDepth( 17e4, 0 ), 17, 0.1 );
553  }
554 
555  // AuvMath::OceanPressure %Unit Tests
556  void testOceanPressure( void )
557  {
558  TS_ASSERT_DELTA( AuvMath::OceanPressure( 4906.08, 0.628318531 ), 5e7, 4.1e4 );
559  TS_ASSERT_DELTA( AuvMath::OceanPressure( 9674.23, 1.570796327 ), 1e8, 7.2e4 );
560  }
561 
562  // AuvMath::ShellSort
563  void testShellSort( void )
564  {
565  double array1[] = {5, 4, 3, 2, 1};
566  double sarray1[] = {1, 2, 3, 4, 5};
567  int array1Len = sizeof( array1 ) / sizeof( array1[0] );
568 
569  AuvMath::ShellSort( array1, array1Len );
570  TS_ASSERT_SAME_DATA( array1, sarray1, array1Len );
571 
572  //int i;
573  //for( i=0; i< array1Len; i++ ) printf("array1[%d] = %ld\n",i, array1[i]);
574 
575  double array2[] = {1576130,
576  9705927,
577  9571669,
578  4853756,
579  8002804,
580  1418863,
581  4217612,
582  9157355,
583  7922073,
584  9594924
585  };
586 
587  double sarray2[] = { 1418863,
588  1576130,
589  4217612,
590  4853756,
591  7922073,
592  8002804,
593  9157355,
594  9571669,
595  9594924,
596  9705927
597  };
598  int array2Len = sizeof( array2 ) / sizeof( array2[0] );
599 
600  AuvMath::ShellSort( array2, array2Len );
601  TS_ASSERT_SAME_DATA( array2, sarray2, array2Len );
602 
603  //for( i=0; i< array2Len; i++ ) printf("array2[%d] = %ld\n",i, array2[i]);
604 
605  double array3[] = {5, -4, 3, -2, 1};
606  double sarray3[] = { -4, -2, 1, 3, 5};
607  int array3Len = sizeof( array3 ) / sizeof( array3[0] );
608 
609  AuvMath::ShellSort( array3, array3Len );
610  TS_ASSERT_SAME_DATA( array3, sarray3, array3Len );
611  }
612 };
613 
614 #endif // _AUVMATH_TEST_H
AuvMath::Max
static T Max(const T &a, const T &b)
Returns the greater of the two arguments If either input is nan, nan is returned Unit tests in AuvMat...
Definition: AuvMath.h:100
AuvMath::OceanPressure
static double OceanPressure(const double &depth, const double &latitude)
OceanPressure (depth, latitude)
Definition: AuvMath.cpp:530
AuvMath::Interpolate3D
static T Interpolate3D(const T &x, const T &y, const T &z, T data[][2][2], const T &x0, const T &x1, const T &y0, const T &y1, const T &z0, const T &z1)
Examines a 2x2x2 data field for the value, where x0 <= x <= x1, y0 <= y <= y1, z0 <= z <= z1 Unit tes...
Definition: AuvMath.cpp:326
AuvMath::ModPi
static T ModPi(const T &angle)
modulo Pi function: If input is nan, nan is returned Unit tests in AuvMath_Test.testModPi ...
Definition: AuvMath.cpp:107
AuvMath_Test::testSwap
void testSwap(void)
AuvMath::Swap Unit Tests.
Definition: AuvMath_Test.h:240
AuvMath::NanZero
static T NanZero(const T &value)
Casts nan values to zero – otherwise returns the value Unit tests in AuvMath_Test.testNanZero.
Definition: AuvMath.cpp:118
AuvMath_Test::testDensity
void testDensity(void)
Definition: AuvMath_Test.h:541
AuvMath_Test::testFindLtEqIndex
void testFindLtEqIndex(void)
FindLtEqIndex Unit Tests.
Definition: AuvMath_Test.h:396
AuvMath::AreaContains
static bool AreaContains(float x, float y, int segments, float *x0, float *y0, float *x1, float *y1)
Definition: AuvMath.cpp:555
D2R
#define D2R(x)
A macro for converting degrees to radians.
Definition: AuvMath.h:40
AuvMath::Interpolate2D
static T Interpolate2D(const T &x, const T &y, T data[][2], const T &x0, const T &x1, const T &y0, const T &y1)
Examines a 2x2 data field for the value, where x0 <= x <= x1, y0 <= y <= y1, Unit tests in AuvMath_Te...
Definition: AuvMath.cpp:299
AuvMath::Interpolate4D
static T Interpolate4D(const T &w, const T &x, const T &y, const T &z, T data[][2][2][2], const T &w0, const T &w1, const T &x0, const T &x1, const T &y0, const T &y1, const T &z0, const T &z1)
Examines a 2x2x2x2 data field for the value, where w0 <= w <= w1, x0 <= x <= x1, y0 <= y <= y1...
Definition: AuvMath.cpp:366
AuvMath::Swap
static void Swap(T &a, T &b)
Swaps the two arguments.
Definition: AuvMath.h:114
AuvMath_Test::testInterpolate1D
void testInterpolate1D(void)
AuvMath::Interpolate1D Unit Tests.
Definition: AuvMath_Test.h:435
AuvMath_Test
Units tests for class AuvMath
Definition: AuvMath_Test.h:22
AuvMath_Test::testLimit
void testLimit(void)
AuvMath::Limit Unit Tests.
Definition: AuvMath_Test.h:45
AuvMath_Test::testModPi
void testModPi(void)
AuvMath::ModPi Unit Tests.
Definition: AuvMath_Test.h:286
AuvMath_Test::testShellSort
void testShellSort(void)
Definition: AuvMath_Test.h:563
AuvMath::BulkModulus
static double BulkModulus(double salinity, double temperature, double pressure)
Seawater bulk modulus (S,T,P)
Definition: AuvMath.cpp:420
AuvMath::Limit
static T Limit(const T &value, const T &limit1, const T &limit2)
Makes sure a variable falls within defined limits...
Definition: AuvMath.cpp:20
AuvMath::Density
static double Density(double salinity, double temperature, double pressure)
Seawater density (S,T,P)
Definition: AuvMath.cpp:476
AuvMath.h
Contains the AuvMath class declaration.
AuvMath_Test::testInterpolate3D
void testInterpolate3D(void)
AuvMath::Interpolate3D Unit Tests.
Definition: AuvMath_Test.h:482
AuvMath::FindLtEqIndex
static int FindLtEqIndex(const T *values, const T &value, const unsigned int indexMin, const unsigned int indexMax)
Finds the index within an array where the value is <= the supplied value Searches from indexMin to in...
Definition: AuvMath.cpp:239
AuvMath_Test::testSign
void testSign(void)
AuvMath::Sign Unit Tests.
Definition: AuvMath_Test.h:366
AuvMath_Test::testAreaContains
void testAreaContains(void)
Definition: AuvMath_Test.h:26
AuvMath_Test::testOceanDepth
void testOceanDepth(void)
Definition: AuvMath_Test.h:548
AuvMath::Sign
static T Sign(const T &x)
Returns signum function: If input is nan, nan is returned Unit tests in AuvMath_Test.testSign.
Definition: AuvMath.cpp:226
AuvMath::Min
static T Min(const T &a, const T &b)
Returns the lesser of the two arguments If either input is nan, nan is returned Unit tests in AuvMath...
Definition: AuvMath.h:91
AuvMath::ShellSort
static void ShellSort(T array[], int arraySize)
Definition: AuvMath.h:282
AuvMath_Test::testNanZero
void testNanZero(void)
AuvMath::NanZero Unit Tests.
Definition: AuvMath_Test.h:321
AuvMath_Test::testMin
void testMin(void)
AuvMath::Min Unit Tests.
Definition: AuvMath_Test.h:110
AuvMath_Test::testOceanPressure
void testOceanPressure(void)
Definition: AuvMath_Test.h:556
AuvMath_Test::testMax
void testMax(void)
AuvMath::Max Unit Tests.
Definition: AuvMath_Test.h:175
AuvMath_Test::testBulkModulus
void testBulkModulus(void)
Definition: AuvMath_Test.h:534
AuvMath_Test::testInterpolate4D
void testInterpolate4D(void)
AuvMath::Interpolate4D Unit Tests.
Definition: AuvMath_Test.h:506
AuvMath_Test::testRound
void testRound(void)
AuvMath::Round Unit Tests.
Definition: AuvMath_Test.h:338
AuvMath_Test::testInterpolate2D
void testInterpolate2D(void)
AuvMath::Interpolate2D Unit Tests.
Definition: AuvMath_Test.h:459
AuvMath::Round
static T Round(const T &value, const T &divisor)
Makes sure a variable is divisible by specified divisor...
Definition: AuvMath.cpp:202
AuvMath::Interpolate1D
static T Interpolate1D(const T &x, const T &data0, const T &data1, const T &x0, const T &x1)
Examines a 2 element data field for the value, where x0 <= x <= x1 Unit tests in AuvMath_Test.testInterpolate1D.
Definition: AuvMath.cpp:279
Slate.h
Contains the Slate class definition.
AuvMath::OceanDepth
static double OceanDepth(const double &pressure, const double &latitude)
OceanDepth (pressure, latitude)
Definition: AuvMath.cpp:508