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.63 $ $Name: rel5_0 $
00009  *  @date $Date: 2005/03/31 23:01:46 $
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  */
00017 
00018 /*****************************************************************************
00019 These constants are used by various functions in the psLib.
00020  *****************************************************************************/
00021 #define PS_DETERMINE_BRACKET_STEP_SIZE 0.10
00022 #define PS_MAX_LMM_ITERATIONS 100
00023 #define PS_MAX_MINIMIZE_ITERATIONS 100
00024 #define PS_LEFT_SPLINE_DERIV 0.0
00025 #define PS_RIGHT_SPLINE_DERIV 0.0
00026 /*****************************************************************************
00027 These are common mathimatical constants used by various functions in the psLib.
00028  *****************************************************************************/
00029 #define PS_ONE 1.0
00030 #define PS_PI   3.1415926535897932384626433832795029  /* pi */
00031 #define PS_PI_2 1.5707963267948966192313216916397514  /* pi/2 */
00032 #define PS_PI_4 0.7853981633974483096156608458198757  /* pi/4 */
00033 #define PS_1_PI 0.3183098861837906715377675267450287  /* 1/pi */
00034 #define PS_2_PI 0.6366197723675813430755350534900574  /* 2/pi */
00035 
00036 #define PS_COT(X) (1.0 / atan(X))
00037 #define DEG_TO_RAD(DEGREES) ((DEGREES) * PS_PI / 180.0)
00038 #define MIN_TO_RAD(MINUTES) ((MINUTES) * PS_PI / (180.0 * 60.0))
00039 #define SEC_TO_RAD(SECONDS) ((SECONDS) * PS_PI / (180.0 * 60.0 * 60.0))
00040 #define RAD_TO_DEG(RADIANS) ((RADIANS) * 180.0 / PS_PI)
00041 #define RAD_TO_MIN(RADIANS) ((RADIANS) * 180.0 * 60.0 / PS_PI)
00042 #define RAD_TO_SEC(RADIANS) ((RADIANS) * 180.0 * 60.0 * 60.0 / PS_PI)
00043 
00044 /*****************************************************************************
00045  
00046 *****************************************************************************/
00047 
00048 #define PS_INT_CHECK_EQUALS(NAME1, NAME2, RVAL) \
00049 if (NAME1 == NAME2) { \
00050     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00051             "Error: %s and %s are equal.", \
00052             #NAME1, #NAME2); \
00053     return(RVAL); \
00054 }
00055 
00056 #define PS_INT_CHECK_NON_EQUALS(NAME1, NAME2, RVAL) \
00057 if (NAME1 != NAME2) { \
00058     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00059             "Error: %s and %s are not equal.", \
00060             #NAME1, #NAME2); \
00061     return(RVAL); \
00062 }
00063 
00064 #define PS_INT_CHECK_NON_NEGATIVE(NAME, RVAL) \
00065 if (NAME < 0) { \
00066     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00067             "Error: %s is less than 0.", #NAME); \
00068     return(RVAL); \
00069 }
00070 
00071 #define PS_INT_CHECK_POSITIVE(NAME, RVAL) \
00072 if (NAME < 1) { \
00073     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00074             "Error: %s is 0 or less.", #NAME); \
00075     return(RVAL); \
00076 }
00077 
00078 #define PS_INT_CHECK_ZERO(NAME, RVAL) \
00079 if (NAME < 1) { \
00080     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00081             "Error: %s is 0.", #NAME); \
00082     return(RVAL); \
00083 }
00084 
00085 #define PS_INT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
00086 if ((int)NAME < LOWER || (int)NAME > UPPER) { \
00087     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00088             "Error: %s, %d, is out of range.  Must be between %d and %d.", \
00089             #NAME,(int)NAME,LOWER,UPPER); \
00090     return RVAL; \
00091 }
00092 
00093 // Produce an error if (NAME1 > NAME2)
00094 #define PS_INT_COMPARE(NAME1, NAME2, RVAL) \
00095 if (NAME1 > NAME2) { \
00096     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00097             "Error: (%s > %s) (%d %d).", \
00098             #NAME1, #NAME2, NAME1, NAME2); \
00099     return(RVAL); \
00100 }
00101 
00102 
00103 // Produce an error if ((NAME1 > NAME2)
00104 #define PS_FLOAT_COMPARE(NAME1, NAME2, RVAL) \
00105 if (NAME1 > NAME2) { \
00106     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00107             "Error: (%s > %s) (%f %f)", \
00108             #NAME1, #NAME2, NAME1, NAME2); \
00109     return(RVAL); \
00110 }
00111 
00112 #define PS_FLOAT_CHECK_NON_EQUAL(NAME1, NAME2, RVAL) \
00113 if (fabs(NAME2 - NAME1) < FLT_EPSILON) { \
00114     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00115             "Error: %s and %s are equal.", \
00116             #NAME1, #NAME2); \
00117     return(RVAL); \
00118 }
00119 
00120 #define PS_FLOAT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
00121 if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
00122     psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
00123             "Error: %s, %f, is out of range.  Must be between %f and %f.", \
00124             #NAME, NAME, LOWER, UPPER); \
00125     return RVAL; \
00126 }
00127 
00128 /*****************************************************************************
00129 Macros which take a generic psLib type and determine if it is NULL, or has
00130 the wrong type.
00131 *****************************************************************************/
00132 #define PS_PTR_CHECK_NULL(NAME, RVAL) PS_PTR_CHECK_NULL_GENERAL(NAME, return RVAL)
00133 #define PS_PTR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
00134 if (NAME == NULL) { \
00135     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00136             "Unallowable operation: %s is NULL.", \
00137             #NAME); \
00138     CLEANUP; \
00139 }
00140 
00141 #define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \
00142 if (NAME->type.type != TYPE) { \
00143     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00144             "Unallowable operation: %s has incorrect type.", \
00145             #NAME); \
00146     return(RVAL); \
00147 }
00148 
00149 #define PS_PTR_CHECK_DIMEN(NAME, DIMEN, RVAL) PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, return RVAL)
00150 #define PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, CLEANUP) \
00151 if (NAME->type.dimen != DIMEN) { \
00152     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00153             "Unallowable operation: %s has incorrect dimensionality.", \
00154             #NAME); \
00155     CLEANUP; \
00156 }
00157 
00158 #define PS_PTR_CHECK_DIMEN_GENERAL_NOT(NAME, DIMEN, CLEANUP) \
00159 if (NAME->type.dimen == DIMEN) { \
00160     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00161             "Unallowable operation: %s has incorrect dimensionality.", \
00162             #NAME); \
00163     CLEANUP; \
00164 }
00165 
00166 
00167 #define PS_PTR_CHECK_SIZE_EQUAL(PTR1, PTR2, RVAL) \
00168 if (PTR1->n != PTR2->n) { \
00169     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00170             "ptr %s has size %d, ptr %s has size %d.", \
00171             #PTR1, PTR1->n, #PTR2, PTR2->n); \
00172     return(RVAL); \
00173 }
00174 
00175 #define PS_PTR_CHECK_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
00176 
00177 #define PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
00178 if (PTR1->type.type != PTR2->type.type) { \
00179     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00180             "ptr %s has type %d, ptr %s has type %d.", \
00181             #PTR1, PTR1->type.type, #PTR2, PTR2->type.type); \
00182     CLEANUP; \
00183 }
00184 
00185 
00186 /*****************************************************************************
00187     PS_VECTOR macros:
00188  *****************************************************************************/
00189 #define PS_VECTOR_CHECK_NULL(NAME, RVAL) PS_VECTOR_CHECK_NULL_GENERAL(NAME, return RVAL)
00190 #define PS_VECTOR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
00191 if (NAME == NULL || NAME->data.U8 == NULL) { \
00192     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00193             "Unallowable operation: psVector %s or its data is NULL.", \
00194             #NAME); \
00195     CLEANUP; \
00196 } \
00197 
00198 // XXX: The above macro is seg faulting on occasion in pmObjects.
00199 #define PS_ORIG_VECTOR_CHECK_NULL(NAME, RVAL) \
00200 if (NAME == NULL || NAME->data.U8 == NULL) { \
00201     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00202             "Unallowable operation: psVector %s or its data is NULL.", \
00203             #NAME); \
00204     return(RVAL); \
00205 } \
00206 
00207 
00208 #define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) PS_VECTOR_CHECK_EMPTY_GENERAL(NAME, return RVAL)
00209 #define PS_VECTOR_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
00210 if (NAME->n < 1) { \
00211     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00212             "Unallowable operation: psVector %s has no elements.", \
00213             #NAME); \
00214     CLEANUP; \
00215 } \
00216 
00217 #define PS_VECTOR_CHECK_TYPE_F32_OR_F64(NAME, RVAL) \
00218 if ((NAME->type.type != PS_TYPE_F32) && (NAME->type.type != PS_TYPE_F64)) { \
00219     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00220             "psVector %s: bad type(%d)", \
00221             #NAME, NAME->type.type); \
00222     return(RVAL); \
00223 } \
00224 
00225 #define PS_VECTOR_CHECK_TYPE_S16_S32_F32(NAME, RVAL) \
00226 if ((NAME->type.type != PS_TYPE_S16) && (NAME->type.type != PS_TYPE_S32) && (NAME->type.type != PS_TYPE_F32)) { \
00227     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00228             "psVector %s: bad type(%d)", \
00229             #NAME, NAME->type.type); \
00230     return(RVAL); \
00231 } \
00232 
00233 #define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \
00234 if (NAME->type.type != TYPE) { \
00235     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00236             "Unallowable operation: psVector %s has incorrect type.", \
00237             #NAME); \
00238     return(RVAL); \
00239 }
00240 
00241 #define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \
00242 if (VEC1->n != VEC2->n) { \
00243     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00244             "psVector %s has size %d, psVector %s has size %d.", \
00245             #VEC1, VEC1->n, #VEC2, VEC2->n); \
00246     return(RVAL); \
00247 }
00248 
00249 #define PS_VECTOR_CHECK_TYPE_EQUAL(VEC1, VEC2, RVAL) \
00250 if (VEC1->type.type != VEC2->type.type) { \
00251     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00252             "psVector %s has size %d, psVector %s has size %d.", \
00253             #VEC1, VEC1->type.type, #VEC2, VEC2->type.type); \
00254     return(RVAL); \
00255 }
00256 
00257 #define PS_VECTOR_F64_TO_F32(X64, X32) \
00258 psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \
00259 for (int i=0;i<X64->n;i++) { \
00260     X32->data.F32[i] = (float) X64->data.F64[i]; \
00261 } \
00262 
00263 #define PS_VECTOR_F32_TO_F64(X32, X64) \
00264 psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \
00265 for (int i=0;i<X32->n;i++) { \
00266     X64->data.F64[i] = (float) X32->data.F32[i]; \
00267 } \
00268 
00269 #define PS_VECTOR_PRINT_F32(NAME) \
00270 for (int my_i=0;my_i<NAME->n;my_i++) { \
00271     printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \
00272 } \
00273 printf("\n"); \
00274 
00275 
00276 #define PS_VECTOR_CONVERT_F64_TO_F32_STATIC(OLD, NEW_PTR32, NEW_STATIC32) \
00277 if (OLD->type.type == PS_TYPE_F32) { \
00278     NEW_PTR32 = (psVector *) OLD; \
00279 } else if (OLD->type.type == PS_TYPE_F64) { \
00280     NEW_STATIC32 = psVectorRecycle(NEW_STATIC32, OLD->n, PS_TYPE_F32); \
00281     p_psMemSetPersistent(NEW_STATIC32, true); \
00282     p_psMemSetPersistent(NEW_STATIC32->data.U8, true); \
00283     for (i=0; i < OLD->n ; i++) { \
00284         NEW_STATIC32->data.F32[i] = (float) OLD->data.F64[i]; \
00285     } \
00286     NEW_PTR32 = NEW_STATIC32; \
00287 } \
00288 
00289 #define PS_VECTOR_CONVERT_F32_TO_F64_STATIC(OLD, NEW_PTR64, NEW_STATIC64) \
00290 if (OLD->type.type == PS_TYPE_F64) { \
00291     NEW_PTR64 = (psVector *) OLD; \
00292 } else if (OLD->type.type == PS_TYPE_F32) { \
00293     NEW_STATIC64 = psVectorRecycle(NEW_STATIC64, OLD->n, PS_TYPE_F64); \
00294     p_psMemSetPersistent(NEW_STATIC64, true); \
00295     p_psMemSetPersistent(NEW_STATIC64->data.U8, true); \
00296     for (i=0; i < OLD->n ; i++) { \
00297         NEW_STATIC64->data.F64[i] = (double) OLD->data.F32[i]; \
00298     } \
00299     NEW_PTR64 = NEW_STATIC64; \
00300 } \
00301 
00302 #define PS_VECTOR_GEN_YERR_STATIC_F32(VEC, N) \
00303 VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \
00304 p_psMemSetPersistent(VEC, true); \
00305 p_psMemSetPersistent(VEC->data.U8, true); \
00306 for (int i=0;i<N;i++) { \
00307     VEC->data.F32[i] = 1.0; \
00308 } \
00309 
00310 #define PS_VECTOR_GEN_YERR_STATIC_F64(VEC, N) \
00311 VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \
00312 p_psMemSetPersistent(VEC, true); \
00313 p_psMemSetPersistent(VEC->data.U8, true); \
00314 for (int i=0;i<N;i++) { \
00315     VEC->data.F64[i] = 1.0; \
00316 } \
00317 
00318 #define PS_VECTOR_GEN_X_INDEX_STATIC_F32(VEC, N) \
00319 VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \
00320 p_psMemSetPersistent(VEC, true); \
00321 p_psMemSetPersistent(VEC->data.U8, true); \
00322 for (int i=0;i<N;i++) { \
00323     VEC->data.F32[i] = (float) i; \
00324 } \
00325 
00326 #define PS_VECTOR_GEN_X_INDEX_STATIC_F64(VEC, N) \
00327 VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \
00328 p_psMemSetPersistent(VEC, true); \
00329 p_psMemSetPersistent(VEC->data.U8, true); \
00330 for (int i=0;i<N;i++) { \
00331     VEC->data.F64[i] = (float) i; \
00332 } \
00333 
00334 #define PS_VECTOR_GEN_STATIC_RECYCLED(NAME, SIZE, TYPE) \
00335 static psVector *NAME = NULL; \
00336 NAME = psVectorRecycle(NAME, SIZE, TYPE); \
00337 p_psMemSetPersistent(NAME, true); \
00338 p_psMemSetPersistent(NAME->data.U8, true); \
00339 
00340 #define PS_VECTOR_DECLARE_ALLOC_STATIC(NAME, SIZE, TYPE) \
00341 static psVector *NAME = NULL; \
00342 if (NAME == NULL) { \
00343     NAME = psVectorAlloc(SIZE, TYPE); \
00344     p_psMemSetPersistent(NAME, true); \
00345 } \
00346 
00347 #define PS_VECTOR_SET_U8(NAME, VALUE) \
00348 for (int i = 0 ; i < (NAME)->n ; i++) { \
00349     (NAME)->data.U8[i] = VALUE; \
00350 }\
00351 
00352 #define PS_VECTOR_SET_U16(NAME, VALUE) \
00353 for (int i = 0 ; i < (NAME)->n ; i++) { \
00354     (NAME)->data.U16[i] = VALUE; \
00355 }\
00356 
00357 #define PS_VECTOR_SET_U32(NAME, VALUE) \
00358 for (int i = 0 ; i < (NAME)->n ; i++) { \
00359     (NAME)->data.U32[i] = VALUE; \
00360 }\
00361 
00362 #define PS_VECTOR_SET_U64(NAME, VALUE) \
00363 for (int i = 0 ; i < (NAME)->n ; i++) { \
00364     (NAME)->data.U64[i] = VALUE; \
00365 }\
00366 
00367 #define PS_VECTOR_SET_S8(NAME, VALUE) \
00368 for (int i = 0 ; i < (NAME)->n ; i++) { \
00369     (NAME)->data.S8[i] = VALUE; \
00370 }\
00371 
00372 #define PS_VECTOR_SET_S16(NAME, VALUE) \
00373 for (int i = 0 ; i < (NAME)->n ; i++) { \
00374     (NAME)->data.S16[i] = VALUE; \
00375 }\
00376 
00377 #define PS_VECTOR_SET_S32(NAME, VALUE) \
00378 for (int i = 0 ; i < (NAME)->n ; i++) { \
00379     (NAME)->data.S32[i] = VALUE; \
00380 }\
00381 
00382 #define PS_VECTOR_SET_S64(NAME, VALUE) \
00383 for (int i = 0 ; i < (NAME)->n ; i++) { \
00384     (NAME)->data.S64[i] = VALUE; \
00385 }\
00386 
00387 #define PS_VECTOR_SET_F64(NAME, VALUE) \
00388 for (int i = 0 ; i < (NAME)->n ; i++) { \
00389     (NAME)->data.F64[i] = VALUE; \
00390 }\
00391 
00392 #define PS_VECTOR_SET_F32(NAME, VALUE) \
00393 for (int i = 0 ; i < (NAME)->n ; i++) { \
00394     (NAME)->data.F32[i] = VALUE; \
00395 }\
00396 
00397 
00398 /*****************************************************************************
00399     PS_POLY macros:
00400 *****************************************************************************/
00401 #define PS_POLY_CHECK_NULL(NAME, RVAL) \
00402 if (NAME == NULL || NAME->coeff == NULL) { \
00403     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00404             "Unallowable operation: polynomial %s or its coeffs is NULL.", \
00405             #NAME); \
00406     return(RVAL); \
00407 } \
00408 
00409 #define PS_POLY_CHECK_TYPE(NAME, TYPE, RVAL) \
00410 if (NAME->type != TYPE) { \
00411     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00412             "Unallowable operation: polynomial %s has wrong type.", #NAME); \
00413     return(RVAL); \
00414 } \
00415 
00416 // The following macros declare and allocate a static polynomial of the
00417 // specified order and type.
00418 
00419 #define PS_POLY_1D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00420 static psPolynomial1D *NAME = NULL; \
00421 if (NAME == NULL) { \
00422     NAME = psPolynomial1DAlloc(ORDER, TYPE); \
00423     p_psMemSetPersistent(NAME, true); \
00424     p_psMemSetPersistent(NAME->coeff, true); \
00425     p_psMemSetPersistent(NAME->coeffErr, true); \
00426     p_psMemSetPersistent(NAME->mask, true); \
00427 } \
00428 
00429 #define PS_POLY_2D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00430 static psPolynomial2D *NAME = NULL; \
00431 if (NAME == NULL) { \
00432     NAME = psPolynomial2DAlloc(ORDER, TYPE); \
00433     p_psMemSetPersistent(NAME, true); \
00434 } \
00435 
00436 #define PS_POLY_3D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00437 static psPolynomial3D *NAME = NULL; \
00438 if (NAME == NULL) { \
00439     NAME = psPolynomial3DAlloc(ORDER, TYPE); \
00440     p_psMemSetPersistent(NAME, true); \
00441 } \
00442 
00443 #define PS_POLY_4D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00444 static psPolynomial4D *NAME = NULL; \
00445 if (NAME == NULL) { \
00446     NAME = psPolynomial4DAlloc(ORDER, TYPE); \
00447     p_psMemSetPersistent(NAME, true); \
00448 } \
00449 
00450 #define PS_POLY_1D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00451 static psPolynomial1D *NAME = NULL; \
00452 if (NAME == NULL) { \
00453     NAME = psPolynomial1DAlloc(ORDER, TYPE); \
00454     p_psMemSetPersistent(NAME, true); \
00455 } \
00456 
00457 #define PS_POLY_2D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00458 static psPolynomial2D *NAME = NULL; \
00459 if (NAME == NULL) { \
00460     NAME = psPolynomial2DAlloc(ORDER, TYPE); \
00461     p_psMemSetPersistent(NAME, true); \
00462 } \
00463 
00464 #define PS_POLY_3D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00465 static psPolynomial3D *NAME = NULL; \
00466 if (NAME == NULL) { \
00467     NAME = psPolynomial3DAlloc(ORDER, TYPE); \
00468     p_psMemSetPersistent(NAME, true); \
00469 } \
00470 
00471 #define PS_POLY_4D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
00472 static psPolynomial4D *NAME = NULL; \
00473 if (NAME == NULL) { \
00474     NAME = psPolynomial4DAlloc(ORDER, TYPE); \
00475     p_psMemSetPersistent(NAME, true); \
00476 } \
00477 
00478 /*****************************************************************************
00479     PS_IMAGE macros:
00480 *****************************************************************************/
00481 #define PS_IMAGE_CHECK_NULL(NAME, RVAL) PS_IMAGE_CHECK_NULL_GENERAL(NAME, return RVAL)
00482 #define PS_IMAGE_CHECK_NULL_GENERAL(NAME, CLEANUP) \
00483 if (NAME == NULL || NAME->data.V == NULL) { \
00484     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00485             "Unallowable operation: psImage %s or its data is NULL.", \
00486             #NAME); \
00487     CLEANUP; \
00488 }
00489 
00490 #define PS_IMAGE_CHECK_EMPTY(NAME, RVAL) PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, return RVAL)
00491 #define PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
00492 if (NAME->numCols < 1 || NAME->numRows < 1) { \
00493     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00494             "Unallowable operation: psImage %s has zero rows or columns (%dx%d).", \
00495             #NAME, NAME->numCols, NAME->numRows); \
00496     CLEANUP; \
00497 }
00498 
00499 #define PS_IMAGE_CHECK_TYPE(NAME, TYPE, RVAL) \
00500 if (NAME->type.type != TYPE) { \
00501     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00502             "Unallowable operation: psImage %s has incorrect type.", \
00503             #NAME); \
00504     return(RVAL); \
00505 }
00506 
00507 #define PS_IMAGE_CHECK_SIZE_EQUAL(NAME1, NAME2, RVAL) \
00508 if ((NAME1->numCols != NAME2->numCols) || \
00509         (NAME1->numRows != NAME2->numRows)) { \
00510     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00511             "Unallowable operation: psImages %s and %s are not the same size.", \
00512             #NAME1, #NAME2); \
00513     return(RVAL); \
00514 }
00515 
00516 #define PS_IMAGE_CHECK_SIZE(NAME1, NUM_COLS, NUM_ROWS, RVAL) \
00517 if ((NAME1->numCols != NUM_COLS) || \
00518         (NAME1->numRows != NUM_ROWS)) { \
00519     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00520             "Unallowable operation: psImages %s is not the correct size.", \
00521             #NAME1); \
00522     return(RVAL); \
00523 }
00524 
00525 #define PS_IMAGE_PRINT_F32(NAME) \
00526 printf("======== printing %s ========\n", #NAME); \
00527 for (int i = 0 ; i < NAME->numRows ; i++) { \
00528     for (int j = 0 ; j < NAME->numCols ; j++) { \
00529         printf("%.2f ", NAME->data.F32[i][j]); \
00530     } \
00531     printf("\n"); \
00532 }\
00533 
00534 #define PS_IMAGE_SET_U8(NAME, VALUE) \
00535 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00536     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00537         (NAME)->data.U8[i][j] = (VALUE); \
00538     } \
00539 }\
00540 
00541 #define PS_IMAGE_SET_U16(NAME, VALUE) \
00542 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00543     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00544         (NAME)->data.U16[i][j] = (VALUE); \
00545     } \
00546 }\
00547 
00548 #define PS_IMAGE_SET_U32(NAME, VALUE) \
00549 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00550     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00551         (NAME)->data.U32[i][j] = (VALUE); \
00552     } \
00553 }\
00554 
00555 #define PS_IMAGE_SET_U64(NAME, VALUE) \
00556 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00557     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00558         (NAME)->data.U64[i][j] = (VALUE); \
00559     } \
00560 }\
00561 
00562 #define PS_IMAGE_SET_S8(NAME, VALUE) \
00563 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00564     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00565         (NAME)->data.S8[i][j] = (VALUE); \
00566     } \
00567 }\
00568 
00569 #define PS_IMAGE_SET_S16(NAME, VALUE) \
00570 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00571     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00572         (NAME)->data.S16[i][j] = (VALUE); \
00573     } \
00574 }\
00575 
00576 #define PS_IMAGE_SET_S32(NAME, VALUE) \
00577 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00578     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00579         (NAME)->data.S32[i][j] = (VALUE); \
00580     } \
00581 }\
00582 
00583 #define PS_IMAGE_SET_S64(NAME, VALUE) \
00584 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00585     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00586         (NAME)->data.S64[i][j] = (VALUE); \
00587     } \
00588 }\
00589 
00590 #define PS_IMAGE_SET_F32(NAME, VALUE) \
00591 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00592     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00593         (NAME)->data.F32[i][j] = (VALUE); \
00594     } \
00595 }\
00596 
00597 #define PS_IMAGE_SET_F64(NAME, VALUE) \
00598 for (int i = 0 ; i < (NAME)->numRows ; i++) { \
00599     for (int j = 0 ; j < (NAME)->numCols ; j++) { \
00600         (NAME)->data.F64[i][j] = (VALUE); \
00601     } \
00602 }\
00603 
00604 /*****************************************************************************
00605     PS_READOUT macros:
00606 *****************************************************************************/
00607 #define PS_READOUT_CHECK_NULL(NAME, RVAL) \
00608 if (NAME == NULL || NAME->image == NULL) { \
00609     psError(PS_ERR_BAD_PARAMETER_NULL, true, \
00610             "Unallowable operation: psReadout %s or its data is NULL.", \
00611             #NAME); \
00612     return(RVAL); \
00613 }
00614 
00615 #define PS_READOUT_CHECK_EMPTY(NAME, RVAL) \
00616 if (NAME->image->numCols < 1 || NAME->image->numRows < 1) { \
00617     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
00618             "Unallowable operation: psReadout %s or its data is NULL.", #NAME); \
00619     return(RVAL); \
00620 }
00621 
00622 #define PS_READOUT_CHECK_TYPE(NAME, TYPE, RVAL) \
00623 if (NAME->image->type.type != TYPE) { \
00624     psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
00625             "Unallowable operation: psImage %s has incorrect type.", #NAME); \
00626     return(RVAL); \
00627 }
00628 
00629 /*****************************************************************************
00630     Misc. macros:
00631  *****************************************************************************/
00632 #define PS_MAX(A, B) \
00633 (((A) > (B)) ? (A) : (B)) \
00634 
00635 #define PS_MIN(A, B) \
00636 (((A) < (B)) ? (A) : (B)) \
00637 
00638 #define PS_SQR(A) \
00639 ((A) * (A)) \
00640 
00641 #ifdef DARWIN
00642 #define PS_SQRT_F32(A) ((float) sqrt(A))
00643 #else
00644 #define PS_SQRT_F32(A) (sqrtf(A))
00645 #endif