Pan-STARRS Foundation Library: psConstants.h Source File

00001 /** @file  psConstants.h
00002  *
00003  *  This file will hold definitions of various constants as well as common
00004  *  macros used throughout psLib.
00005  *
00006  *  @author GLG, MHPCC
00007  *
00008  *  @version $Revision: 1.1.1.1 $ $Name:  $
00009  *  @date $Date: 2005/06/15 21:08:12 $
00010  *
00011  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
00012  *
00013  *  XXX: Add parenthesis around all arguments so that these macros can be
00014  *       called with complex expressions.
00015  *
00016  *  XXX: All functions which use the PS_CHECK macros must be scrutinized so
00017  *  that we ensure that an argument which is expected to be output is
00018  *  psFree'ed before reurning NULL.
00019  *
00020  *  XXX: The macros have a name similar to PS_CHECK_CONDITION() and generally
00021  *  throw a psError if the CONDITION is true.  However, some throw the error
00022  *  if the CONDITION is false.  This should be consistant.
00023  *
00024  *  XXX: rename all these with form PS_ASSERT_CONDITION().
00025  *
00026  */
00027 
00028 #include<math.h> // for M_PI
00029 
00030 /*****************************************************************************
00031 These constants are used by various functions in the psLib.
00032  *****************************************************************************/
00033 #define PS_DETERMINE_BRACKET_STEP_SIZE 0.10
00034 #define PS_MAX_LMM_ITERATIONS 100
00035 #define PS_MAX_MINIMIZE_ITERATIONS 100
00036 #define PS_LEFT_SPLINE_DERIV 0.0
00037 #define PS_RIGHT_SPLINE_DERIV 0.0
00038 /*****************************************************************************
00039 These are common mathimatical constants used by various functions in the psLib.
00040  *****************************************************************************/
00041 #ifndef M_PI
00042 #define M_PI   3.1415926535897932384626433832795029  /* pi */
00043 #define M_PI_2 1.5707963267948966192313216916397514  /* pi/2 */
00044 #define M_PI_4 0.7853981633974483096156608458198757  /* pi/4 */
00045 #define M_1_PI 0.3183098861837906715377675267450287  /* 1/pi */
00046 #define M_2_PI 0.6366197723675813430755350534900574  /* 2/pi */
00047 #endif // #ifndef M_PI
00048 
00049 #define DEG_TO_RAD(DEGREES) ((DEGREES) * M_PI / 180.0)
00050 #define MIN_TO_RAD(MINUTES) ((MINUTES) * M_PI / (180.0 * 60.0))
00051 #define SEC_TO_RAD(SECONDS) ((SECONDS) * M_PI / (180.0 * 60.0 * 60.0))
00052 #define RAD_TO_DEG(RADIANS) ((RADIANS) * 180.0 / M_PI)
00053 #define RAD_TO_MIN(RADIANS) ((RADIANS) * 180.0 * 60.0 / M_PI)
00054 #define RAD_TO_SEC(RADIANS) ((RADIANS) * 180.0 * 60.0 * 60.0 / M_PI)
00055 
00056 /*****************************************************************************
00057  
00058 *****************************************************************************/
00059 
00060 #define PS_ASSERT_INT_UNEQUAL(NAME1, NAME2, RVAL) \
00061 if ((NAME1) == (NAME2)) { \
00062     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00063             "Error: %s and %s are equal.", \
00064             #NAME1, #NAME2); \
00065     return(RVAL); \
00066 }
00067 
00068 #define PS_ASSERT_INT_EQUAL(NAME1, NAME2, RVAL) \
00069 if ((NAME1) != (NAME2)) { \
00070     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00071             "Error: %s and %s are not equal.", \
00072             #NAME1, #NAME2); \
00073     return(RVAL); \
00074 }
00075 
00076 #define PS_ASSERT_INT_NONNEGATIVE(NAME, RVAL) \
00077 if ((NAME) < 0) { \
00078     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00079             "Error: %s is less than 0.", #NAME); \
00080     return(RVAL); \
00081 }
00082 
00083 #define PS_ASSERT_INT_POSITIVE(NAME, RVAL) \
00084 if ((NAME) < 1) { \
00085     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00086             "Error: %s is 0 or less.", #NAME); \
00087     return(RVAL); \
00088 }
00089 
00090 #define PS_ASSERT_INT_ZERO(NAME, RVAL) \
00091 if ((NAME) != 0) { \
00092     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00093             "Error: %s is 0.", #NAME); \
00094     return(RVAL); \
00095 }
00096 
00097 #define PS_ASSERT_INT_NONZERO(NAME, RVAL) \
00098 if ((NAME) == 0) { \
00099     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00100             "Error: %s is 0.", #NAME); \
00101     return(RVAL); \
00102 }
00103 
00104 // XXX: Where did these int casts come from?
00105 #define PS_ASSERT_INT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
00106 if ((int)(NAME) < LOWER || (int)(NAME) > UPPER) { \
00107     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00108             "Error: %s, %d, is out of range.  Must be between %d and %d.", \
00109             #NAME,(int)NAME,LOWER,UPPER); \
00110     return RVAL; \
00111 }
00112 
00113 #define PS_ASSERT_INT_LARGER_THAN(NAME1, NAME2, RVAL) \
00114 if (!((NAME1) > (NAME2))) { \
00115     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00116             "Error: !(%s > %s) (%d %d).", \
00117             #NAME1, #NAME2, NAME1, NAME2); \
00118     return(RVAL); \
00119 }
00120 
00121 #define PS_ASSERT_INT_LARGER_THAN_OR_EQUAL(NAME1, NAME2, RVAL) \
00122 if (!((NAME1) >= (NAME2))) { \
00123     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00124             "Error: !(%s >= %s) (%d %d).", \
00125             #NAME1, #NAME2, NAME1, NAME2); \
00126     return(RVAL); \
00127 }
00128 #define PS_ASSERT_FLOAT_LARGER_THAN(NAME1, NAME2, RVAL) \
00129 if (!((NAME1) > (NAME2))) { \
00130     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00131             "Error: !(%s > %s) (%f %f).", \
00132             #NAME1, #NAME2, NAME1, NAME2); \
00133     return(RVAL); \
00134 }
00135 
00136 #define PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(NAME1, NAME2, RVAL) \
00137 if (!((NAME1) >= (NAME2))) { \
00138     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00139             "Error: !(%s >= %s) (%f %f).", \
00140             #NAME1, #NAME2, NAME1, NAME2); \
00141     return(RVAL); \
00142 }
00143 
00144 // Produce an error if (NAME1 > NAME2)
00145 // XXX: Get rid of this, use above macros.
00146 #define PS_INT_COMPARE(NAME1, NAME2, RVAL) \
00147 if ((NAME1) > (NAME2)) { \
00148     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00149             "Error: (%s > %s) (%d %d).", \
00150             #NAME1, #NAME2, NAME1, NAME2); \
00151     return(RVAL); \
00152 }
00153 
00154 // Produce an error if ((NAME1 > NAME2)
00155 // XXX: Get rid of this, use above macros.
00156 #define PS_FLOAT_COMPARE(NAME1, NAME2, RVAL) \
00157 if ((NAME1) > (NAME2)) { \
00158     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00159             "Error: (%s > %s) (%f %f)", \
00160             #NAME1, #NAME2, NAME1, NAME2); \
00161     return(RVAL); \
00162 }
00163 
00164 #define PS_ASSERT_FLOAT_NON_EQUAL(NAME1, NAME2, RVAL) \
00165 if (fabs((NAME2) - (NAME1)) < FLT_EPSILON) { \
00166     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00167             "Error: %s and %s are equal.", \
00168             #NAME1, #NAME2); \
00169     return(RVAL); \
00170 }
00171 
00172 #define PS_ASSERT_FLOAT_EQUAL(NAME1, NAME2, RVAL) \
00173 if (fabs((NAME2) - (NAME1)) > FLT_EPSILON) { \
00174     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00175             "Error: %s and %s are not equal.", \
00176             #NAME1, #NAME2); \
00177     return(RVAL); \
00178 }
00179 
00180 // Return an error if the arg is lies outside the supplied range.
00181 #define PS_ASSERT_FLOAT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
00182 if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
00183     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00184             "Error: %s, %f, is out of range.  Must be between %f and %f.", \
00185             #NAME, NAME, LOWER, UPPER); \
00186     return RVAL; \
00187 }
00188 
00189 // Return an error if the arg lies outside the supplied range
00190 #define PS_ASSERT_LONG_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
00191 if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
00192     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00193             "Error: %s, %lld, is out of range.", \
00194             #NAME, NAME, LOWER, UPPER); \
00195     return RVAL; \
00196 }
00197 
00198 /*****************************************************************************
00199 Macros which take a generic psLib type and determine if it is NULL, or has
00200 the wrong type.
00201 *****************************************************************************/
00202 #define PS_ASSERT_PTR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, return RVAL)
00203 #define PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, CLEANUP) \
00204 if ((NAME) == NULL) { \
00205     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00206             "Unallowable operation: %s is NULL.", \
00207             #NAME); \
00208     CLEANUP; \
00209 }
00210 
00211 #define PS_ASSERT_PTR_TYPE(NAME, TYPE, RVAL) \
00212 if ((NAME)->type.type != TYPE) { \
00213     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00214             "Unallowable operation: %s has incorrect type.", \
00215             #NAME); \
00216     return(RVAL); \
00217 }
00218 
00219 #define PS_ASSERT_PTR_DIMEN(NAME, DIMEN, RVAL) PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, return RVAL)
00220 #define PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, CLEANUP) \
00221 if ((NAME)->type.dimen != DIMEN) { \
00222     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00223             "Unallowable operation: %s has incorrect dimensionality.", \
00224             #NAME); \
00225     CLEANUP; \
00226 }
00227 
00228 #define PS_ASSERT_PTR_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
00229 if ((NAME)->type.dimen == DIMEN) { \
00230     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00231             "Unallowable operation: %s has incorrect dimensionality.", \
00232             #NAME); \
00233     CLEANUP; \
00234 }
00235 
00236 
00237 #define PS_ASSERT_PTRS_SIZE_EQUAL(PTR1, PTR2, RVAL) \
00238 if (PTR1->n != PTR2->n) { \
00239     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00240             "ptr %s has size %d, ptr %s has size %d.", \
00241             #PTR1, PTR1->n, #PTR2, PTR2->n); \
00242     return(RVAL); \
00243 }
00244 
00245 #define PS_ASSERT_PTR_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
00246 #define PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
00247 if (PTR1->type.type != PTR2->type.type) { \
00248     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00249             "ptr %s has type %d, ptr %s has type %d.", \
00250             #PTR1, PTR1->type.type, #PTR2, PTR2->type.type); \
00251     CLEANUP; \
00252 }
00253 
00254 
00255 /*****************************************************************************
00256     PS_VECTOR macros:
00257  *****************************************************************************/
00258 #define PS_ASSERT_VECTOR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, return RVAL)
00259 #define PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, CLEANUP) \
00260 if ((NAME) == NULL || (NAME)->data.U8 == NULL) { \
00261     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00262             "Unallowable operation: psVector %s or its data is NULL.", \
00263             #NAME); \
00264     CLEANUP; \
00265 } \
00266 
00267 #define PS_ASSERT_VECTOR_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, return RVAL)
00268 #define PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, CLEANUP) \
00269 if ((NAME)->n < 1) { \
00270     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00271             "Unallowable operation: psVector %s has no elements.", \
00272             #NAME); \
00273     CLEANUP; \
00274 } \
00275 
00276 #define PS_ASSERT_VECTOR_TYPE_F32_OR_F64(NAME, RVAL) \
00277 if (((NAME)->type.type != PS_TYPE_F32) && ((NAME)->type.type != PS_TYPE_F64)) { \
00278     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00279             "psVector %s: bad type(%d)", \
00280             #NAME, NAME->type.type); \
00281     return(RVAL); \
00282 } \
00283 
00284 #define PS_ASSERT_VECTOR_TYPE_S16_S32_F32(NAME, RVAL) \
00285 if (((NAME)->type.type != PS_TYPE_S16) && ((NAME)->type.type != PS_TYPE_S32) && ((NAME)->type.type != PS_TYPE_F32)) { \
00286     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00287             "psVector %s: bad type(%d)", \
00288             #NAME, NAME->type.type); \
00289     return(RVAL); \
00290 } \
00291 
00292 #define PS_ASSERT_VECTOR_TYPE(NAME, TYPE, RVAL) \
00293 if ((NAME)->type.type != TYPE) { \
00294     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00295             "Unallowable operation: psVector %s has incorrect type.", \
00296             #NAME); \
00297     return(RVAL); \
00298 }
00299 
00300 #define PS_ASSERT_VECTORS_SIZE_EQUAL(VEC1, VEC2, RVAL) \
00301 if (VEC1->n != VEC2->n) { \
00302     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00303             "psVector %s has size %d, psVector %s has size %d.", \
00304             #VEC1, VEC1->n, #VEC2, VEC2->n); \
00305     return(RVAL); \
00306 }
00307 
00308 #define PS_ASSERT_VECTOR_SIZE(VEC, SIZE, RVAL) \
00309 if (VEC->n != SIZE) { \
00310     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00311             "psVector %s has size %d, should be %d." \
00312             #VEC, VEC->n, SIZE); \
00313     return(RVAL); \
00314 }
00315 
00316 #define PS_ASSERT_VECTOR_TYPE_EQUAL(VEC1, VEC2, RVAL) \
00317 if (VEC1->type.type != VEC2->type.type) { \
00318     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00319             "psVector %s has size %d, psVector %s has size %d.", \
00320             #VEC1, VEC1->type.type, #VEC2, VEC2->type.type); \
00321     return(RVAL); \
00322 }
00323 
00324 #define PS_VECTOR_F64_TO_F32(X64, X32) \
00325 psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \
00326 for (int i=0;i<X64->n;i++) { \
00327     X32->data.F32[i] = (float) X64->data.F64[i]; \
00328 } \
00329 
00330 #define PS_VECTOR_F32_TO_F64(X32, X64) \
00331 psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \
00332 for (int i=0;i<X32->n;i++) { \
00333     X64->data.F64[i] = (float) X32->data.F32[i]; \
00334 } \
00335 
00336 #define PS_VECTOR_PRINT_F32(NAME) \
00337 for (int my_i=0;my_i<(NAME)->n;my_i++) { \
00338     printf("%s->data.F32[%d] is %f\n", #NAME, my_i, (NAME)->data.F32[my_i]); \
00339 } \
00340 printf("\n"); \
00341 
00342 
00343 #define PS_VECTOR_CONVERT_F64_TO_F32_STATIC(OLD, NEW_PTR32, NEW_STATIC32) \
00344 if (OLD->type.type == PS_TYPE_F32) { \
00345     NEW_PTR32 = (psVector *) OLD; \
00346 } else if (OLD->type.type == PS_TYPE_F64) { \
00347     NEW_STATIC32 = psVectorRecycle(NEW_STATIC32, OLD->n, PS_TYPE_F32); \
00348     p_psMemSetPersistent(NEW_STATIC32, true); \
00349     p_psMemSetPersistent(NEW_STATIC32->data.U8, true); \
00350     for (i=0; i < OLD->n ; i++) { \
00351         NEW_STATIC32->data.F32[i] = (float) OLD->data.F64[i]; \
00352     } \
00353     NEW_PTR32 = NEW_STATIC32; \
00354 } \
00355 
00356 #define PS_VECTOR_CONVERT_F32_TO_F64_STATIC(OLD, NEW_PTR64, NEW_STATIC64) \
00357 if (OLD->type.type == PS_TYPE_F64) { \
00358     NEW_PTR64 = (psVector *) OLD; \
00359 } else if (OLD->type.type == PS_TYPE_F32) { \
00360     NEW_STATIC64 = psVectorRecycle(NEW_STATIC64, OLD->n, PS_TYPE_F64); \
00361     p_psMemSetPersistent(NEW_STATIC64, true); \
00362     p_psMemSetPersistent(NEW_STATIC64->data.U8, true); \
00363     for (i=0; i < OLD->n ; i++) { \
00364         NEW_STATIC64->data.F64[i] = (double) OLD->data.F32[i]; \
00365     } \
00366     NEW_PTR64 = NEW_STATIC64; \
00367 } \
00368 
00369 #define PS_VECTOR_GEN_YERR_STATIC_F32(VEC, N) \
00370 VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \
00371 p_psMemSetPersistent(VEC, true); \
00372 p_psMemSetPersistent(VEC->data.U8, true); \
00373 for (int i=0;i<N;i++) { \
00374     VEC->data.F32[i] = 1.0; \
00375 } \
00376 
00377 #define PS_VECTOR_GEN_YERR_STATIC_F64(VEC, N) \
00378 VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \
00379 p_psMemSetPersistent(VEC, true); \
00380 p_psMemSetPersistent(VEC->data.U8, true); \
00381 for (int i=0;i<N;i++) { \
00382     VEC->data.F64[i] = 1.0; \
00383 } \
00384 
00385 #define PS_VECTOR_GEN_X_INDEX_STATIC_F32(VEC, N) \
00386 VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \
00387 p_psMemSetPersistent(VEC, true); \
00388 p_psMemSetPersistent(VEC->data.U8, true); \
00389 for (int i=0;i<N;i++) { \
00390     VEC->data.F32[i] = (float) i; \
00391 } \
00392 
00393 #define PS_VECTOR_GEN_X_INDEX_STATIC_F64(VEC, N) \
00394 VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \
00395 p_psMemSetPersistent(VEC, true); \
00396 p_psMemSetPersistent(VEC->data.U8, true); \
00397 for (int i=0;i<N;i++) { \
00398     VEC->data.F64[i] = (float) i; \
00399 } \
00400 
00401 #define PS_VECTOR_GEN_STATIC_RECYCLED(NAME, SIZE, TYPE) \
00402 static psVector *NAME = NULL; \
00403 (NAME) = psVectorRecycle((NAME), SIZE, TYPE); \
00404 p_psMemSetPersistent((NAME), true); \
00405 p_psMemSetPersistent((NAME)->data.U8, true); \
00406 
00407 #define PS_VECTOR_DECLARE_ALLOC_STATIC(NAME, SIZE, TYPE) \
00408 static psVector *(NAME) = NULL; \
00409 if ((NAME) == NULL) { \
00410     (NAME) = psVectorAlloc(SIZE, TYPE); \
00411     p_psMemSetPersistent((NAME), true); \
00412 } \
00413 
00414 #define PS_VECTOR_SET_U8(NAME, VALUE) \
00415 for (int i = 0 ; i < (NAME)->n ; i++) { \
00416     (NAME)->data.U8[i] = VALUE; \
00417 }\
00418 
00419 #define PS_VECTOR_SET_U16(NAME, VALUE) \
00420 for (int i = 0 ; i < (NAME)->n ; i++) { \
00421     (NAME)->data.U16[i] = VALUE; \
00422 }\
00423 
00424 #define PS_VECTOR_SET_U32(NAME, VALUE) \
00425 for (int i = 0 ; i < (NAME)->n ; i++) { \
00426     (NAME)->data.U32[i] = VALUE; \
00427 }\
00428 
00429 #define PS_VECTOR_SET_U64(NAME, VALUE) \
00430 for (int i = 0 ; i < (NAME)->n ; i++) { \
00431     (NAME)->data.U64[i] = VALUE; \
00432 }\
00433 
00434 #define PS_VECTOR_SET_S8(NAME, VALUE) \
00435 for (int i = 0 ; i < (NAME)->n ; i++) { \
00436     (NAME)->data.S8[i] = VALUE; \
00437 }\
00438 
00439 #define PS_VECTOR_SET_S16(NAME, VALUE) \
00440 for (int i = 0 ; i < (NAME)->n ; i++) { \
00441     (NAME)->data.S16[i] = VALUE; \
00442 }\
00443 
00444 #define PS_VECTOR_SET_S32(NAME, VALUE) \
00445 for (int i = 0 ; i < (NAME)->n ; i++) { \
00446     (NAME)->data.S32[i] = VALUE; \
00447 }\
00448 
00449 #define PS_VECTOR_SET_S64(NAME, VALUE) \
00450 for (int i = 0 ; i < (NAME)->n ; i++) { \
00451     (NAME)->data.S64[i] = VALUE; \
00452 }\
00453 
00454 #define PS_VECTOR_SET_F64(NAME, VALUE) \
00455 for (int i = 0 ; i < (NAME)->n ; i++) { \
00456     (NAME)->data.F64[i] = VALUE; \
00457 }\
00458 
00459 #define PS_VECTOR_SET_F32(NAME, VALUE) \
00460 for (int i = 0 ; i < (NAME)->n ; i++) { \
00461     (NAME)->data.F32[i] = VALUE; \
00462 }\
00463 
00464 
00465 /*****************************************************************************
00466     PS_POLY macros:
00467 *****************************************************************************/
00468 #define PS_ASSERT_POLY_NON_NULL(NAME, RVAL) \
00469 if ((NAME) == NULL || (NAME)->coeff == NULL) { \
00470     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00471             "Unallowable operation: polynomial %s or its coeffs is NULL.", \
00472             #NAME); \
00473     return(RVAL); \
00474 } \
00475 
00476 #define PS_ASSERT_POLY_TYPE(NAME, TYPE, RVAL) \
00477 if ((NAME)->type != TYPE) { \
00478     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00479             "Unallowable operation: polynomial %s has wrong type.", #NAME); \
00480     return(RVAL); \
00481 } \
00482 
00483 // The following macros declare and allocate a static polynomial of the
00484 // specified order and type.
00485 
00486 #define PS_POLY_1D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00487 static psPolynomial1D *(NAME) = NULL; \
00488 if ((NAME) == NULL) { \
00489     (NAME) = psPolynomial1DAlloc(ORDER, TYPE); \
00490     p_psMemSetPersistent((NAME), true); \
00491     p_psMemSetPersistent((NAME)->coeff, true); \
00492     p_psMemSetPersistent((NAME)->coeffErr, true); \
00493     p_psMemSetPersistent((NAME)->mask, true); \
00494 } \
00495 
00496 #define PS_POLY_2D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00497 static psPolynomial2D *(NAME) = NULL; \
00498 if ((NAME) == NULL) { \
00499     (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
00500     p_psMemSetPersistent((NAME), true); \
00501 } \
00502 
00503 #define PS_POLY_3D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00504 static psPolynomial3D *(NAME) = NULL; \
00505 if ((NAME) == NULL) { \
00506     (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
00507     p_psMemSetPersistent((NAME), true); \
00508 } \
00509 
00510 #define PS_POLY_4D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00511 static psPolynomial4D *(NAME) = NULL; \
00512 if ((NAME) == NULL) { \
00513     (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
00514     p_psMemSetPersistent((NAME), true); \
00515 } \
00516 
00517 #define PS_POLY_1D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00518 static psPolynomial1D *(NAME) = NULL; \
00519 if ((NAME) == NULL) { \
00520     (NAME) = psPolynomial1DAlloc(ORDER, TYPE); \
00521     p_psMemSetPersistent((NAME), true); \
00522 } \
00523 
00524 #define PS_POLY_2D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00525 static psPolynomial2D *(NAME) = NULL; \
00526 if ((NAME) == NULL) { \
00527     (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
00528     p_psMemSetPersistent((NAME), true); \
00529 } \
00530 
00531 #define PS_POLY_3D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00532 static psPolynomial3D *(NAME) = NULL; \
00533 if ((NAME) == NULL) { \
00534     (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
00535     p_psMemSetPersistent((NAME), true); \
00536 } \
00537 
00538 #define PS_POLY_4D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00539 static psPolynomial4D *(NAME) = NULL; \
00540 if ((NAME) == NULL) { \
00541     (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
00542     p_psMemSetPersistent((NAME), true); \
00543 } \
00544 
00545 /*****************************************************************************
00546     PS_IMAGE macros:
00547 *****************************************************************************/
00548 #define PS_ASSERT_IMAGE_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, return RVAL)
00549 #define PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, CLEANUP) \
00550 if ((NAME) == NULL || (NAME)->data.V == NULL) { \
00551     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00552             "Unallowable operation: psImage %s or its data is NULL.", \
00553             #NAME); \
00554     CLEANUP; \
00555 }
00556 
00557 #define PS_ASSERT_IMAGE_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, return RVAL)
00558 #define PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, CLEANUP) \
00559 if ((NAME)->numCols < 1 || (NAME)->numRows < 1) { \
00560     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00561             "Unallowable operation: psImage %s has zero rows or columns (%dx%d).", \
00562             #NAME, (NAME)->numCols, (NAME)->numRows); \
00563     CLEANUP; \
00564 }
00565 
00566 #define PS_ASSERT_IMAGE_TYPE(NAME, TYPE, RVAL) \
00567 if ((NAME)->type.type != TYPE) { \
00568     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00569             "Unallowable operation: psImage %s has incorrect type.", \
00570             #NAME); \
00571     return(RVAL); \
00572 }
00573 
00574 #define PS_ASSERT_IMAGES_SIZE_EQUAL(NAME1, NAME2, RVAL) \
00575 if (((NAME1)->numCols != (NAME2)->numCols) || \
00576         ((NAME1)->numRows != (NAME2)->numRows)) { \
00577     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00578             "Unallowable operation: psImages %s and %s are not the same size.", \
00579             #NAME1, #NAME2); \
00580     return(RVAL); \
00581 }
00582 
00583 #define PS_ASSERT_IMAGE_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
00584 if (((NAME1)->numCols != NUM_COLS) || \
00585         ((NAME1)->numRows != NUM_ROWS)) { \
00586     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00587             "Unallowable operation: psImages %s is not the correct size.", \
00588             #NAME1); \
00589     return(RVAL); \
00590 }
00591 
00592 #define PS_IMAGE_PRINT_F32(NAME) \
00593 printf("======== printing %s ========\n", #NAME); \
00594 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00595     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00596         printf("%.2f ", (NAME)->data.F32[i][j]); \
00597     } \
00598     printf("\n"); \
00599 }\
00600 
00601 #define PS_IMAGE_SET_U8(NAME, VALUE) \
00602 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00603     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00604         (NAME)->data.U8[i][j] = (VALUE); \
00605     } \
00606 }\
00607 
00608 #define PS_IMAGE_SET_U16(NAME, VALUE) \
00609 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00610     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00611         (NAME)->data.U16[i][j] = (VALUE); \
00612     } \
00613 }\
00614 
00615 #define PS_IMAGE_SET_U32(NAME, VALUE) \
00616 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00617     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00618         (NAME)->data.U32[i][j] = (VALUE); \
00619     } \
00620 }\
00621 
00622 #define PS_IMAGE_SET_U64(NAME, VALUE) \
00623 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00624     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00625         (NAME)->data.U64[i][j] = (VALUE); \
00626     } \
00627 }\
00628 
00629 #define PS_IMAGE_SET_S8(NAME, VALUE) \
00630 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00631     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00632         (NAME)->data.S8[i][j] = (VALUE); \
00633     } \
00634 }\
00635 
00636 #define PS_IMAGE_SET_S16(NAME, VALUE) \
00637 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00638     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00639         (NAME)->data.S16[i][j] = (VALUE); \
00640     } \
00641 }\
00642 
00643 #define PS_IMAGE_SET_S32(NAME, VALUE) \
00644 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00645     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00646         (NAME)->data.S32[i][j] = (VALUE); \
00647     } \
00648 }\
00649 
00650 #define PS_IMAGE_SET_S64(NAME, VALUE) \
00651 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00652     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00653         (NAME)->data.S64[i][j] = (VALUE); \
00654     } \
00655 }\
00656 
00657 #define PS_IMAGE_SET_F32(NAME, VALUE) \
00658 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00659     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00660         (NAME)->data.F32[i][j] = (VALUE); \
00661     } \
00662 }\
00663 
00664 #define PS_IMAGE_SET_F64(NAME, VALUE) \
00665 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00666     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00667         (NAME)->data.F64[i][j] = (VALUE); \
00668     } \
00669 }\
00670 
00671 /*****************************************************************************
00672     PS_READOUT macros:
00673 *****************************************************************************/
00674 #define PS_ASSERT_READOUT_NON_NULL(NAME, RVAL) \
00675 if ((NAME) == NULL || (NAME)->image == NULL) { \
00676     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00677             "Unallowable operation: psReadout %s or its data is NULL.", \
00678             #NAME); \
00679     return(RVAL); \
00680 }
00681 
00682 #define PS_ASSERT_READOUT_NON_EMPTY(NAME, RVAL) \
00683 if ((NAME)->image->numCols < 1 || (NAME)->image->numRows < 1) { \
00684     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00685             "Unallowable operation: psReadout %s or its data is NULL.", #NAME); \
00686     return(RVAL); \
00687 }
00688 
00689 #define PS_ASSERT_READOUT_TYPE(NAME, TYPE, RVAL) \
00690 if ((NAME)->image->type.type != TYPE) { \
00691     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00692             "Unallowable operation: psImage %s has incorrect type.", #NAME); \
00693     return(RVAL); \
00694 }
00695 
00696 /*****************************************************************************
00697     Misc. macros:
00698  *****************************************************************************/
00699 #define PS_MAX(A, B) \
00700 (((A) > (B)) ? (A) : (B))
00701 
00702 #define PS_MIN(A, B) \
00703 (((A) < (B)) ? (A) : (B))
00704 
00705 #define PS_SQR(A) \
00706 ((A) * (A))