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.81 $ $Name: rel9_0 $
00009  *  @date $Date: 2005/11/23 23:54:43 $
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_LESS_THAN(VAR1, VAR2, RVAL) \
00114 if (!(VAR1 < VAR2)) { \
00115     psError(PS_ERR_UNKNOWN, true, \
00116             "Error: %s is not less than %s (%d, %d)", #VAR1, #VAR2, VAR1, VAR2); \
00117     return(RVAL); \
00118 }
00119 
00120 #define PS_ASSERT_INT_LESS_THAN_OR_EQUAL(VAR1, VAR2, RVAL) \
00121 if (!(VAR1 <= VAR2)) { \
00122     psError(PS_ERR_UNKNOWN, true, \
00123             "Error: %s is not less than %s (%d, %d)", #VAR1, #VAR2, VAR1, VAR2); \
00124     return(RVAL); \
00125 }
00126 
00127 #define PS_ASSERT_INT_LARGER_THAN(NAME1, NAME2, RVAL) \
00128 if (!((NAME1) > (NAME2))) { \
00129     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00130             "Error: !(%s > %s) (%d %d).", \
00131             #NAME1, #NAME2, NAME1, NAME2); \
00132     return(RVAL); \
00133 }
00134 
00135 #define PS_ASSERT_INT_LARGER_THAN_OR_EQUAL(NAME1, NAME2, RVAL) \
00136 if (!((NAME1) >= (NAME2))) { \
00137     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00138             "Error: !(%s >= %s) (%d %d).", \
00139             #NAME1, #NAME2, NAME1, NAME2); \
00140     return(RVAL); \
00141 }
00142 #define PS_ASSERT_FLOAT_LARGER_THAN(NAME1, NAME2, RVAL) \
00143 if (!((NAME1) > (NAME2))) { \
00144     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00145             "Error: !(%s > %s) (%f %f).", \
00146             #NAME1, #NAME2, NAME1, NAME2); \
00147     return(RVAL); \
00148 }
00149 
00150 #define PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(NAME1, NAME2, RVAL) \
00151 if (!((NAME1) >= (NAME2))) { \
00152     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00153             "Error: !(%s >= %s) (%f %f).", \
00154             #NAME1, #NAME2, NAME1, NAME2); \
00155     return(RVAL); \
00156 }
00157 
00158 // Produce an error if (NAME1 > NAME2)
00159 // XXX: Get rid of this, use above macros.
00160 #define PS_INT_COMPARE(NAME1, NAME2, RVAL) \
00161 if ((NAME1) > (NAME2)) { \
00162     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00163             "Error: (%s > %s) (%d %d).", \
00164             #NAME1, #NAME2, NAME1, NAME2); \
00165     return(RVAL); \
00166 }
00167 
00168 // Produce an error if ((NAME1 > NAME2)
00169 // XXX: Get rid of this, use above macros.
00170 #define PS_FLOAT_COMPARE(NAME1, NAME2, RVAL) \
00171 if ((NAME1) > (NAME2)) { \
00172     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00173             "Error: (%s > %s) (%f %f)", \
00174             #NAME1, #NAME2, NAME1, NAME2); \
00175     return(RVAL); \
00176 }
00177 
00178 #define PS_ASSERT_FLOAT_NON_EQUAL(NAME1, NAME2, RVAL) \
00179 if (fabs((NAME2) - (NAME1)) < FLT_EPSILON) { \
00180     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00181             "Error: %s and %s are equal.", \
00182             #NAME1, #NAME2); \
00183     return(RVAL); \
00184 }
00185 
00186 #define PS_ASSERT_FLOAT_EQUAL(NAME1, NAME2, RVAL) \
00187 if (fabs((NAME2) - (NAME1)) > FLT_EPSILON) { \
00188     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00189             "Error: %s and %s are not equal.", \
00190             #NAME1, #NAME2); \
00191     return(RVAL); \
00192 }
00193 
00194 // Return an error if the arg is lies outside the supplied range.
00195 #define PS_ASSERT_FLOAT_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
00196 if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
00197     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00198             "Error: %s, %f, is out of range.  Must be between %f and %f.", \
00199             #NAME, NAME, LOWER, UPPER); \
00200     return RVAL; \
00201 }
00202 
00203 #define PS_ASSERT_DOUBLE_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
00204 if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
00205     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00206             "Error: %s, %lf, is out of range.  Must be between %lf and %lf.", \
00207             #NAME, NAME, LOWER, UPPER); \
00208     return RVAL; \
00209 }
00210 
00211 // Return an error if the arg lies outside the supplied range
00212 #define PS_ASSERT_LONG_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
00213 if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
00214     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00215             "Error: %s, %lld, is out of range.", \
00216             #NAME, NAME, LOWER, UPPER); \
00217     return RVAL; \
00218 }
00219 
00220 /*****************************************************************************
00221 Macros which take a generic psLib type and determine if it is NULL, or has
00222 the wrong type.
00223 *****************************************************************************/
00224 #define PS_WARN_PTR_NON_NULL(NAME) \
00225 if ((NAME) == NULL) { \
00226     psLogMsg(__func__, PS_LOG_WARN, "WARNING: %s is NULL.", #NAME); \
00227 } \
00228 
00229 #define PS_ASSERT_PTR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, return RVAL)
00230 #define PS_ASSERT_GENERAL_PTR_NON_NULL(NAME, CLEANUP) \
00231 if ((NAME) == NULL) { \
00232     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00233             "Unallowable operation: %s is NULL.", \
00234             #NAME); \
00235     CLEANUP; \
00236 }
00237 
00238 #define PS_ASSERT_PTR_TYPE(NAME, TYPE, RVAL) \
00239 if ((NAME)->type.type != TYPE) { \
00240     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00241             "Unallowable operation: %s has incorrect type.", \
00242             #NAME); \
00243     return(RVAL); \
00244 }
00245 
00246 #define PS_ASSERT_PTR_DIMEN(NAME, DIMEN, RVAL) PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, return RVAL)
00247 #define PS_ASSERT_GENERAL_PTR_DIMEN(NAME, DIMEN, CLEANUP) \
00248 if ((NAME)->type.dimen != DIMEN) { \
00249     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00250             "Unallowable operation: %s has incorrect dimensionality.", \
00251             #NAME); \
00252     CLEANUP; \
00253 }
00254 
00255 #define PS_ASSERT_PTR_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
00256 if ((NAME)->type.dimen == DIMEN) { \
00257     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00258             "Unallowable operation: %s has incorrect dimensionality.", \
00259             #NAME); \
00260     CLEANUP; \
00261 }
00262 
00263 
00264 #define PS_ASSERT_PTRS_SIZE_EQUAL(PTR1, PTR2, RVAL) \
00265 if (PTR1->n != PTR2->n) { \
00266     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00267             "ptr %s has size %d, ptr %s has size %d.", \
00268             #PTR1, PTR1->n, #PTR2, PTR2->n); \
00269     return(RVAL); \
00270 }
00271 
00272 #define PS_ASSERT_PTR_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
00273 #define PS_ASSERT_PTRS_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
00274 if (PTR1->type.type != PTR2->type.type) { \
00275     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00276             "ptr %s has type %d, ptr %s has type %d.", \
00277             #PTR1, PTR1->type.type, #PTR2, PTR2->type.type); \
00278     CLEANUP; \
00279 }
00280 
00281 
00282 /*****************************************************************************
00283     PS_VECTOR macros:
00284  *****************************************************************************/
00285 #define PS_ASSERT_VECTOR_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, return RVAL)
00286 #define PS_ASSERT_GENERAL_VECTOR_NON_NULL(NAME, CLEANUP) \
00287 if ((NAME) == NULL || (NAME)->data.U8 == NULL) { \
00288     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00289             "Unallowable operation: psVector %s or its data is NULL.", \
00290             #NAME); \
00291     CLEANUP; \
00292 } \
00293 
00294 #define PS_ASSERT_VECTOR_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, return RVAL)
00295 #define PS_ASSERT_GENERAL_VECTOR_NON_EMPTY(NAME, CLEANUP) \
00296 if ((NAME)->n < 1) { \
00297     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00298             "Unallowable operation: psVector %s has no elements.", \
00299             #NAME); \
00300     CLEANUP; \
00301 } \
00302 
00303 #define PS_ASSERT_VECTOR_TYPE_F32_OR_F64(NAME, RVAL) \
00304 if (((NAME)->type.type != PS_TYPE_F32) && ((NAME)->type.type != PS_TYPE_F64)) { \
00305     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00306             "psVector %s: bad type(%d)", \
00307             #NAME, NAME->type.type); \
00308     return(RVAL); \
00309 } \
00310 
00311 #define PS_ASSERT_VECTOR_TYPE_S16_S32_F32(NAME, RVAL) \
00312 if (((NAME)->type.type != PS_TYPE_S16) && ((NAME)->type.type != PS_TYPE_S32) && ((NAME)->type.type != PS_TYPE_F32)) { \
00313     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00314             "psVector %s: bad type(%d)", \
00315             #NAME, NAME->type.type); \
00316     return(RVAL); \
00317 } \
00318 
00319 #define PS_ASSERT_VECTOR_TYPE(NAME, TYPE, RVAL) \
00320 if ((NAME)->type.type != TYPE) { \
00321     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00322             "Unallowable operation: psVector %s has incorrect type.", \
00323             #NAME); \
00324     return(RVAL); \
00325 }
00326 
00327 #define PS_ASSERT_VECTORS_SIZE_EQUAL(VEC1, VEC2, RVAL) \
00328 if (VEC1->n != VEC2->n) { \
00329     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00330             "psVector %s has size %d, psVector %s has size %d.", \
00331             #VEC1, VEC1->n, #VEC2, VEC2->n); \
00332     return(RVAL); \
00333 }
00334 
00335 #define PS_ASSERT_VECTOR_SIZE(VEC, SIZE, RVAL) \
00336 if (VEC->n != SIZE) { \
00337     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00338             "psVector %s has size %d, should be %d." \
00339             #VEC, VEC->n, SIZE); \
00340     return(RVAL); \
00341 }
00342 
00343 #define PS_ASSERT_VECTOR_TYPE_EQUAL(VEC1, VEC2, RVAL) \
00344 if (VEC1->type.type != VEC2->type.type) { \
00345     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00346             "psVector %s has size %d, psVector %s has size %d.", \
00347             #VEC1, VEC1->type.type, #VEC2, VEC2->type.type); \
00348     return(RVAL); \
00349 }
00350 
00351 #define PS_VECTOR_F64_TO_F32(X64, X32) \
00352 psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \
00353 for (int i=0;i<X64->n;i++) { \
00354     X32->data.F32[i] = (float) X64->data.F64[i]; \
00355 } \
00356 
00357 #define PS_VECTOR_F32_TO_F64(X32, X64) \
00358 psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \
00359 for (int i=0;i<X32->n;i++) { \
00360     X64->data.F64[i] = (float) X32->data.F32[i]; \
00361 } \
00362 
00363 #define PS_VECTOR_PRINT_F32(NAME) \
00364 if (NAME != NULL) { \
00365     for (int my_i=0;my_i<(NAME)->n;my_i++) { \
00366         printf("%s->data.F32[%d] is %f\n", #NAME, my_i, (NAME)->data.F32[my_i]); \
00367     } \
00368     printf("\n"); \
00369 } else {\
00370     printf("MACRO WARNING: vector %s is NULL.\n", #NAME); \
00371 }\
00372 
00373 #define PS_VECTOR_PRINT_F64(NAME) \
00374 if (NAME != NULL) { \
00375     for (int my_i=0;my_i<(NAME)->n;my_i++) { \
00376         printf("%s->data.F64[%d] is %f\n", #NAME, my_i, (NAME)->data.F64[my_i]); \
00377     } \
00378     printf("\n"); \
00379 } else {\
00380     printf("MACRO WARNING: vector %s is NULL.\n", #NAME); \
00381 }\
00382 
00383 #define PS_VECTOR_CONVERT_F64_TO_F32_STATIC(OLD, NEW_PTR32, NEW_STATIC32) \
00384 if (OLD->type.type == PS_TYPE_F32) { \
00385     NEW_PTR32 = (psVector *) OLD; \
00386 } else if (OLD->type.type == PS_TYPE_F64) { \
00387     NEW_STATIC32 = psVectorRecycle(NEW_STATIC32, OLD->n, PS_TYPE_F32); \
00388     p_psMemSetPersistent(NEW_STATIC32, true); \
00389     p_psMemSetPersistent(NEW_STATIC32->data.U8, true); \
00390     for (i=0; i < OLD->n ; i++) { \
00391         NEW_STATIC32->data.F32[i] = (float) OLD->data.F64[i]; \
00392     } \
00393     NEW_PTR32 = NEW_STATIC32; \
00394 } \
00395 
00396 #define PS_VECTOR_CONVERT_F32_TO_F64_STATIC(OLD, NEW_PTR64, NEW_STATIC64) \
00397 if (OLD->type.type == PS_TYPE_F64) { \
00398     NEW_PTR64 = (psVector *) OLD; \
00399 } else if (OLD->type.type == PS_TYPE_F32) { \
00400     NEW_STATIC64 = psVectorRecycle(NEW_STATIC64, OLD->n, PS_TYPE_F64); \
00401     p_psMemSetPersistent(NEW_STATIC64, true); \
00402     p_psMemSetPersistent(NEW_STATIC64->data.U8, true); \
00403     for (i=0; i < OLD->n ; i++) { \
00404         NEW_STATIC64->data.F64[i] = (double) OLD->data.F32[i]; \
00405     } \
00406     NEW_PTR64 = NEW_STATIC64; \
00407 } \
00408 
00409 #define PS_VECTOR_GEN_YERR_STATIC_F32(VEC, N) \
00410 VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \
00411 p_psMemSetPersistent(VEC, true); \
00412 p_psMemSetPersistent(VEC->data.U8, true); \
00413 for (int i=0;i<N;i++) { \
00414     VEC->data.F32[i] = 1.0; \
00415 } \
00416 
00417 #define PS_VECTOR_GEN_YERR_STATIC_F64(VEC, N) \
00418 VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \
00419 p_psMemSetPersistent(VEC, true); \
00420 p_psMemSetPersistent(VEC->data.U8, true); \
00421 for (int i=0;i<N;i++) { \
00422     VEC->data.F64[i] = 1.0; \
00423 } \
00424 
00425 #define PS_VECTOR_GEN_X_INDEX_STATIC_F32(VEC, N) \
00426 VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \
00427 p_psMemSetPersistent(VEC, true); \
00428 p_psMemSetPersistent(VEC->data.U8, true); \
00429 for (int i=0;i<N;i++) { \
00430     VEC->data.F32[i] = (float) i; \
00431 } \
00432 
00433 #define PS_VECTOR_GEN_X_INDEX_STATIC_F64(VEC, N) \
00434 VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \
00435 p_psMemSetPersistent(VEC, true); \
00436 p_psMemSetPersistent(VEC->data.U8, true); \
00437 for (int i=0;i<N;i++) { \
00438     VEC->data.F64[i] = (float) i; \
00439 } \
00440 
00441 #define PS_VECTOR_GEN_STATIC_RECYCLED(NAME, SIZE, TYPE) \
00442 static psVector *NAME = NULL; \
00443 (NAME) = psVectorRecycle((NAME), SIZE, TYPE); \
00444 p_psMemSetPersistent((NAME), true); \
00445 p_psMemSetPersistent((NAME)->data.U8, true); \
00446 
00447 #define PS_VECTOR_DECLARE_ALLOC_STATIC(NAME, SIZE, TYPE) \
00448 static psVector *(NAME) = NULL; \
00449 if ((NAME) == NULL) { \
00450     (NAME) = psVectorAlloc(SIZE, TYPE); \
00451     p_psMemSetPersistent((NAME), true); \
00452 } \
00453 
00454 #define PS_VECTOR_SET_U8(NAME, VALUE) \
00455 for (int i = 0 ; i < (NAME)->n ; i++) { \
00456     (NAME)->data.U8[i] = VALUE; \
00457 }\
00458 
00459 #define PS_VECTOR_SET_U16(NAME, VALUE) \
00460 for (int i = 0 ; i < (NAME)->n ; i++) { \
00461     (NAME)->data.U16[i] = VALUE; \
00462 }\
00463 
00464 #define PS_VECTOR_SET_U32(NAME, VALUE) \
00465 for (int i = 0 ; i < (NAME)->n ; i++) { \
00466     (NAME)->data.U32[i] = VALUE; \
00467 }\
00468 
00469 #define PS_VECTOR_SET_U64(NAME, VALUE) \
00470 for (int i = 0 ; i < (NAME)->n ; i++) { \
00471     (NAME)->data.U64[i] = VALUE; \
00472 }\
00473 
00474 #define PS_VECTOR_SET_S8(NAME, VALUE) \
00475 for (int i = 0 ; i < (NAME)->n ; i++) { \
00476     (NAME)->data.S8[i] = VALUE; \
00477 }\
00478 
00479 #define PS_VECTOR_SET_S16(NAME, VALUE) \
00480 for (int i = 0 ; i < (NAME)->n ; i++) { \
00481     (NAME)->data.S16[i] = VALUE; \
00482 }\
00483 
00484 #define PS_VECTOR_SET_S32(NAME, VALUE) \
00485 for (int i = 0 ; i < (NAME)->n ; i++) { \
00486     (NAME)->data.S32[i] = VALUE; \
00487 }\
00488 
00489 #define PS_VECTOR_SET_S64(NAME, VALUE) \
00490 for (int i = 0 ; i < (NAME)->n ; i++) { \
00491     (NAME)->data.S64[i] = VALUE; \
00492 }\
00493 
00494 #define PS_VECTOR_SET_F64(NAME, VALUE) \
00495 for (int i = 0 ; i < (NAME)->n ; i++) { \
00496     (NAME)->data.F64[i] = VALUE; \
00497 }\
00498 
00499 #define PS_VECTOR_SET_F32(NAME, VALUE) \
00500 for (int i = 0 ; i < (NAME)->n ; i++) { \
00501     (NAME)->data.F32[i] = VALUE; \
00502 }\
00503 
00504 
00505 /*****************************************************************************
00506     PS_POLY macros:
00507 *****************************************************************************/
00508 #define PS_ASSERT_POLY1D(NAME, RVAL) \
00509 if (false == psMemCheckPolynomial1D(NAME)) { \
00510     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00511             "Unallowable operation: argument %s is not a psPolynomial1D struct.\n",\
00512             #NAME); \
00513     return(RVAL); \
00514 } \
00515 
00516 #define PS_ASSERT_POLY_NON_NULL(NAME, RVAL) \
00517 if ((NAME) == NULL || (NAME)->coeff == NULL) { \
00518     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00519             "Unallowable operation: polynomial %s or its coeffs is NULL.", \
00520             #NAME); \
00521     return(RVAL); \
00522 } \
00523 
00524 #define PS_ASSERT_POLY_TYPE(NAME, TYPE, RVAL) \
00525 if ((NAME)->type != TYPE) { \
00526     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00527             "Unallowable operation: polynomial %s has wrong type.", #NAME); \
00528     return(RVAL); \
00529 } \
00530 
00531 // The following macros declare and allocate a static polynomial of the
00532 // specified order and type.
00533 
00534 #define PS_POLY_1D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00535 static psPolynomial1D *(NAME) = NULL; \
00536 if ((NAME) == NULL) { \
00537     (NAME) = psPolynomial1DAlloc(ORDER, TYPE); \
00538     p_psMemSetPersistent((NAME), true); \
00539     p_psMemSetPersistent((NAME)->coeff, true); \
00540     p_psMemSetPersistent((NAME)->coeffErr, true); \
00541     p_psMemSetPersistent((NAME)->mask, true); \
00542 } \
00543 
00544 #define PS_POLY_2D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00545 static psPolynomial2D *(NAME) = NULL; \
00546 if ((NAME) == NULL) { \
00547     (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
00548     p_psMemSetPersistent((NAME), true); \
00549 } \
00550 
00551 #define PS_POLY_3D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00552 static psPolynomial3D *(NAME) = NULL; \
00553 if ((NAME) == NULL) { \
00554     (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
00555     p_psMemSetPersistent((NAME), true); \
00556 } \
00557 
00558 #define PS_POLY_4D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00559 static psPolynomial4D *(NAME) = NULL; \
00560 if ((NAME) == NULL) { \
00561     (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
00562     p_psMemSetPersistent((NAME), true); \
00563 } \
00564 
00565 #define PS_POLY_1D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00566 static psPolynomial1D *(NAME) = NULL; \
00567 if ((NAME) == NULL) { \
00568     (NAME) = psPolynomial1DAlloc(ORDER, TYPE); \
00569     p_psMemSetPersistent((NAME), true); \
00570 } \
00571 
00572 #define PS_POLY_2D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00573 static psPolynomial2D *(NAME) = NULL; \
00574 if ((NAME) == NULL) { \
00575     (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
00576     p_psMemSetPersistent((NAME), true); \
00577 } \
00578 
00579 #define PS_POLY_3D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00580 static psPolynomial3D *(NAME) = NULL; \
00581 if ((NAME) == NULL) { \
00582     (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
00583     p_psMemSetPersistent((NAME), true); \
00584 } \
00585 
00586 #define PS_POLY_4D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00587 static psPolynomial4D *(NAME) = NULL; \
00588 if ((NAME) == NULL) { \
00589     (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
00590     p_psMemSetPersistent((NAME), true); \
00591 } \
00592 
00593 #define PS_POLY_PRINT_1D(NAME) \
00594 printf("Poly %s: (nX) is (%d)\n", #NAME, NAME->nX);\
00595 for (psS32 i = 0 ; i < NAME->nX+1 ; i++) {\
00596     printf("%s->coeff[%d] is %f\n", #NAME, i, NAME->coeff[i]); \
00597 }\
00598 
00599 #define PS_POLY_PRINT_2D(NAME) \
00600 printf("Poly %s: (nX, nY) is (%d, %d)\n", #NAME, NAME->nX, NAME->nY);\
00601 for (psS32 i = 0 ; i < NAME->nX+1 ; i++) {\
00602     for (psS32 j = 0 ; j < NAME->nY+1 ; j++) {\
00603         printf("%s->coeff[%d][%d] is %f\n", #NAME, i, j, NAME->coeff[i][j]); \
00604     }\
00605 }\
00606 
00607 #define PS_PRINT_PLANE_TRANSFORM(NAME) \
00608 { \
00609     printf("---------------------- Plane Transform ----------------------\n"); \
00610     printf("x:\n"); \
00611     PS_POLY_PRINT_2D(NAME->x); \
00612     printf("y:\n"); \
00613     PS_POLY_PRINT_2D(NAME->y); \
00614 } \
00615 
00616 
00617 /*****************************************************************************
00618     PS_SPLINE macros:
00619 *****************************************************************************/
00620 #define PS_ASSERT_SPLINE(NAME, RVAL) \
00621 if (false == psMemCheckSpline1D(NAME)) { \
00622     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00623             "Unallowable operation: argument %s is not a psSpline1D struct.\n",\
00624             #NAME); \
00625     return(RVAL); \
00626 } \
00627 
00628 #define PS_ASSERT_SPLINE_NON_NULL(NAME, RVAL) \
00629 if ((NAME) == NULL) { \
00630     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00631             "Unallowable operation: psSpline1D %s is NULL.", \
00632             #NAME); \
00633     return(RVAL); \
00634 } \
00635 
00636 /*****************************************************************************
00637     PS_IMAGE macros:
00638 *****************************************************************************/
00639 #define PS_ASSERT_IMAGE_NON_NULL(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, return RVAL)
00640 #define PS_ASSERT_GENERAL_IMAGE_NON_NULL(NAME, CLEANUP) \
00641 if ((NAME) == NULL || (NAME)->data.V == NULL) { \
00642     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00643             "Unallowable operation: psImage %s or its data is NULL.", \
00644             #NAME); \
00645     CLEANUP; \
00646 }
00647 
00648 #define PS_ASSERT_IMAGE_NON_EMPTY(NAME, RVAL) PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, return RVAL)
00649 #define PS_ASSERT_GENERAL_IMAGE_NON_EMPTY(NAME, CLEANUP) \
00650 if ((NAME)->numCols < 1 || (NAME)->numRows < 1) { \
00651     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00652             "Unallowable operation: psImage %s has zero rows or columns (%dx%d).", \
00653             #NAME, (NAME)->numCols, (NAME)->numRows); \
00654     CLEANUP; \
00655 }
00656 
00657 #define PS_ASSERT_IMAGE_TYPE(NAME, TYPE, RVAL) \
00658 if ((NAME)->type.type != TYPE) { \
00659     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00660             "Unallowable operation: psImage %s has incorrect type.", \
00661             #NAME); \
00662     return(RVAL); \
00663 }
00664 
00665 #define PS_ASSERT_IMAGES_SIZE_EQUAL(NAME1, NAME2, RVAL) \
00666 if (((NAME1)->numCols != (NAME2)->numCols) || \
00667         ((NAME1)->numRows != (NAME2)->numRows)) { \
00668     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00669             "Unallowable operation: psImages %s and %s are not the same size.", \
00670             #NAME1, #NAME2); \
00671     return(RVAL); \
00672 }
00673 
00674 #define PS_ASSERT_IMAGE_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
00675 if (((NAME1)->numCols != NUM_COLS) || \
00676         ((NAME1)->numRows != NUM_ROWS)) { \
00677     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00678             "Unallowable operation: psImages %s is not the correct size.", \
00679             #NAME1); \
00680     return(RVAL); \
00681 }
00682 
00683 #define PS_IMAGE_PRINT_F32(NAME) \
00684 printf("======== printing %s ========\n", #NAME); \
00685 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00686     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00687         printf("%.2f ", (NAME)->data.F32[i][j]); \
00688     } \
00689     printf("\n"); \
00690 }\
00691 
00692 #define PS_IMAGE_PRINT_F64(NAME) \
00693 printf("======== printing %s ========\n", #NAME); \
00694 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00695     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00696         printf("%.2f ", (NAME)->data.F64[i][j]); \
00697     } \
00698     printf("\n"); \
00699 }\
00700 
00701 #define PS_IMAGE_SET_U8(NAME, VALUE) \
00702 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00703     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00704         (NAME)->data.U8[i][j] = (VALUE); \
00705     } \
00706 }\
00707 
00708 #define PS_IMAGE_SET_U16(NAME, VALUE) \
00709 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00710     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00711         (NAME)->data.U16[i][j] = (VALUE); \
00712     } \
00713 }\
00714 
00715 #define PS_IMAGE_SET_U32(NAME, VALUE) \
00716 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00717     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00718         (NAME)->data.U32[i][j] = (VALUE); \
00719     } \
00720 }\
00721 
00722 #define PS_IMAGE_SET_U64(NAME, VALUE) \
00723 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00724     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00725         (NAME)->data.U64[i][j] = (VALUE); \
00726     } \
00727 }\
00728 
00729 #define PS_IMAGE_SET_S8(NAME, VALUE) \
00730 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00731     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00732         (NAME)->data.S8[i][j] = (VALUE); \
00733     } \
00734 }\
00735 
00736 #define PS_IMAGE_SET_S16(NAME, VALUE) \
00737 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00738     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00739         (NAME)->data.S16[i][j] = (VALUE); \
00740     } \
00741 }\
00742 
00743 #define PS_IMAGE_SET_S32(NAME, VALUE) \
00744 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00745     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00746         (NAME)->data.S32[i][j] = (VALUE); \
00747     } \
00748 }\
00749 
00750 #define PS_IMAGE_SET_S64(NAME, VALUE) \
00751 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00752     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00753         (NAME)->data.S64[i][j] = (VALUE); \
00754     } \
00755 }\
00756 
00757 #define PS_IMAGE_SET_F32(NAME, VALUE) \
00758 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00759     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00760         (NAME)->data.F32[i][j] = (VALUE); \
00761     } \
00762 }\
00763 
00764 #define PS_IMAGE_SET_F64(NAME, VALUE) \
00765 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00766     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00767         (NAME)->data.F64[i][j] = (VALUE); \
00768     } \
00769 }\
00770 
00771 /*****************************************************************************
00772     PS_READOUT macros:
00773 *****************************************************************************/
00774 #define PS_ASSERT_READOUT_NON_NULL(NAME, RVAL) \
00775 if ((NAME) == NULL || (NAME)->image == NULL) { \
00776     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00777             "Unallowable operation: psReadout %s or its data is NULL.", \
00778             #NAME); \
00779     return(RVAL); \
00780 }
00781 
00782 #define PS_ASSERT_READOUT_NON_EMPTY(NAME, RVAL) \
00783 if ((NAME)->image->numCols < 1 || (NAME)->image->numRows < 1) { \
00784     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00785             "Unallowable operation: psReadout %s or its data is NULL.", #NAME); \
00786     return(RVAL); \
00787 }
00788 
00789 #define PS_ASSERT_READOUT_TYPE(NAME, TYPE, RVAL) \
00790 if ((NAME)->image->type.type != TYPE) { \
00791     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00792             "Unallowable operation: psImage %s has incorrect type.", #NAME); \
00793     return(RVAL); \
00794 }
00795 
00796 /*****************************************************************************
00797     Misc. macros:
00798  *****************************************************************************/
00799 #define PS_MAX(A, B) \
00800 (((A) > (B)) ? (A) : (B))
00801 
00802 #define PS_MIN(A, B) \
00803 (((A) < (B)) ? (A) : (B))
00804 
00805 #define PS_SQR(A) \
00806 ((A) * (A))
00807 
00808 #define PRINT_MEMLEAKS(NUM) \
00809 printf("A: ---------------------------------------- (ID: %d)\n", NUM); \
00810 memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); \
00811 printf("B: ---------------------------------------- (%d)\n", memLeaks); \
00812 
00813 # define PS_SWAP(X,Y) {double tmp=(X); (X) = (Y); (Y) = tmp;}