Index: /trunk/psLib/src/dataManip/psConstants.h =================================================================== --- /trunk/psLib/src/dataManip/psConstants.h (revision 2214) +++ /trunk/psLib/src/dataManip/psConstants.h (revision 2215) @@ -6,6 +6,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-10-27 20:20:11 $ + * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-10-27 20:29:12 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -24,10 +24,74 @@ *****************************************************************************/ - - -/***************************************************************************** - - *****************************************************************************/ -#define CONVERT_VECTOR_F64_TO_F32(OLD, NEW_PTR32, NEW_STATIC32) \ +#define PS_ONE 1.0 +/***************************************************************************** +Macros which take a generic psLib type and determine if it is NULL, or has +the wrong type. +*****************************************************************************/ +#define PS_PTR_CHECK_NULL(NAME, RVAL) \ +if (NAME == NULL) { \ + psError(__func__,"Unallowable operation: %s is NULL.", #NAME); \ + return(RVAL); \ +} + +#define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \ +if (NAME->type.type != TYPE) { \ + psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ + return(RVAL); \ +} + +/***************************************************************************** + PS_VECTOR macros: + *****************************************************************************/ +#define PS_VECTOR_CHECK_TYPE_F32_OR_F64(VEC, RVAL) \ +if ((VEC->type.type != PS_TYPE_F32) && (VEC->type.type != PS_TYPE_F64)) { \ + psAbort(__func__, "Bad type for VEC (%d)", VEC->type.type); \ + return(RVAL); \ +} \ + +#define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \ +if (NAME->type.type != TYPE) { \ + psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ + return(RVAL); \ +} + +#define PS_VECTOR_CHECK_NULL(NAME, RVAL) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Unallowable operation: %s or its data is NULL.", #NAME); \ + return(RVAL); \ +} \ + +#define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) \ +if (NAME->n < 1) { \ + psError(__func__,"Unallowable operation: %s has zero n value.", #NAME); \ + return(RVAL); \ +} \ + +#define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \ +if (VEC1->n != VEC2->n) { \ + psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ + return(RVAL); \ +} + +#define PS_VECTOR_F64_TO_F32(X64, X32) \ +psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \ +for (int i=0;in;i++) { \ + X32->data.F32[i] = (float) X64->data.F64[i]; \ +} \ + +#define PS_VECTOR_F32_TO_F64(X32, X64) \ +psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \ +for (int i=0;in;i++) { \ + X64->data.F64[i] = (float) X32->data.F32[i]; \ +} \ + +#define PS_VECTOR_PRINT(NAME) \ +for (int my_i=0;my_in;my_i++) { \ + printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \ +} \ +printf("\n"); \ + + +#define PS_VECTOR_CONVERT_F64_TO_F32_STATIC(OLD, NEW_PTR32, NEW_STATIC32) \ if (OLD->type.type == PS_TYPE_F32) { \ NEW_PTR32 = (psVector *) OLD; \ @@ -42,5 +106,5 @@ } \ -#define CONVERT_VECTOR_F32_TO_F64(OLD, NEW_PTR64, NEW_STATIC64) \ +#define PS_VECTOR_CONVERT_F32_TO_F64_STATIC(OLD, NEW_PTR64, NEW_STATIC64) \ if (OLD->type.type == PS_TYPE_F64) { \ NEW_PTR64 = (psVector *) OLD; \ @@ -55,5 +119,5 @@ } \ -#define GEN_PERSIST_YERR_VEC_F32(VEC, N) \ +#define PS_VECTOR_GEN_YERR_STATIC_F32(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \ p_psMemSetPersistent(VEC, true); \ @@ -63,5 +127,5 @@ } \ -#define GEN_PERSIST_YERR_VEC_F64(VEC, N) \ +#define PS_VECTOR_GEN_YERR_STATIC_F64(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \ p_psMemSetPersistent(VEC, true); \ @@ -71,5 +135,5 @@ } \ -#define GEN_PERSIST_X_INDEX_VEC_F32(VEC, N) \ +#define PS_VECTOR_GEN_X_INDEX_STATIC_F32(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \ p_psMemSetPersistent(VEC, true); \ @@ -79,5 +143,5 @@ } \ -#define GEN_PERSIST_X_INDEX_VEC_F64(VEC, N) \ +#define PS_VECTOR_GEN_X_INDEX_STATIC_F64(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \ p_psMemSetPersistent(VEC, true); \ @@ -87,5 +151,5 @@ } \ -#define GEN_STATIC_RECYCLED_VECTOR(NAME, SIZE, TYPE) \ +#define PS_VECTOR_GEN_STATIC_RECYCLED(NAME, SIZE, TYPE) \ static psVector *NAME = NULL; \ NAME = psVectorRecycle(NAME, SIZE, TYPE); \ @@ -95,75 +159,5 @@ /***************************************************************************** -Macros which take a generic psLib type and determine if it is NULL, or has -the wrong type. -*****************************************************************************/ -#define PS_PTR_CHECK_NULL(NAME, RVAL) \ -if (NAME == NULL) { \ - psError(__func__,"Unallowable operation: %s is NULL.", #NAME); \ - return(RVAL); \ -} - -#define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \ -if (NAME->type.type != TYPE) { \ - psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ - return(RVAL); \ -} - - -/***************************************************************************** -Macros which take a psVector type and determine if it is NULL, or has the -wrong type. - *****************************************************************************/ -#define PS_VECTOR_CHECK_TYPE_F32_OR_F64(VEC, RVAL) \ -if ((VEC->type.type != PS_TYPE_F32) && (VEC->type.type != PS_TYPE_F64)) { \ - psAbort(__func__, "Bad type for VEC (%d)", VEC->type.type); \ - return(RVAL); \ -} \ - -#define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \ -if (NAME->type.type != TYPE) { \ - psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ - return(RVAL); \ -} - -#define PS_VECTOR_CHECK_NULL(NAME, RVAL) \ -if (NAME == NULL || NAME->data.V == NULL) { \ - psError(__func__,"Unallowable operation: %s or its data is NULL.", #NAME); \ - return(RVAL); \ -} \ - -#define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) \ -if (NAME->n < 1) { \ - psError(__func__,"Unallowable operation: %s has zero n value.", #NAME); \ - return(RVAL); \ -} \ - -#define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \ -if (VEC1->n != VEC2->n) { \ - psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ - return(RVAL); \ -} - -#define PS_VECTOR_F64_TO_F32(X64, X32) \ -psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \ -for (int i=0;in;i++) { \ - X32->data.F32[i] = (float) X64->data.F64[i]; \ -} \ - -#define PS_VECTOR_F32_TO_F64(X32, X64) \ -psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \ -for (int i=0;in;i++) { \ - X64->data.F64[i] = (float) X32->data.F32[i]; \ -} \ - -#define PS_VECTOR_PRINT(NAME) \ -for (int my_i=0;my_in;my_i++) { \ - printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \ -} \ -printf("\n"); \ - - -/***************************************************************************** - + PS_POLY macros: *****************************************************************************/ #define PS_POLY_CHECK_NULL(NAME, NULL) \ @@ -174,5 +168,5 @@ /***************************************************************************** - + PS_IMAGE macros: *****************************************************************************/ #define PS_IMAGE_CHECK_NULL(NAME, RVAL) \ @@ -195,5 +189,5 @@ } /***************************************************************************** - + PS_READOUT macros: *****************************************************************************/ /** Preprocessor macro to generate error on a NULL image */ @@ -204,10 +198,6 @@ } - - - - -/***************************************************************************** - +/***************************************************************************** + Misc. macros: *****************************************************************************/ #define PS_MAX(A, B) \ Index: /trunk/psLib/src/dataManip/psMinimize.c =================================================================== --- /trunk/psLib/src/dataManip/psMinimize.c (revision 2214) +++ /trunk/psLib/src/dataManip/psMinimize.c (revision 2215) @@ -9,6 +9,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.68 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-10-27 20:20:11 $ + * @version $Revision: 1.69 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-10-27 20:29:12 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -255,22 +255,22 @@ PS_PTR_CHECK_NULL(y, NULL); PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL); - CONVERT_VECTOR_F64_TO_F32(y, y32, y32Static); + PS_VECTOR_CONVERT_F64_TO_F32_STATIC(y, y32, y32Static); // If yErr==NULL, set all errors equal. if (yErr == NULL) { - GEN_PERSIST_YERR_VEC_F32(yErr32Static, y->n); + PS_VECTOR_GEN_YERR_STATIC_F32(yErr32Static, y->n); yErr32 = yErr32Static; } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL); - CONVERT_VECTOR_F64_TO_F32(yErr, yErr32, yErr32Static); + PS_VECTOR_CONVERT_F64_TO_F32_STATIC(yErr, yErr32, yErr32Static); } // If x==NULL, create an x32 vector with x values set to (0:n). if (x == NULL) { - GEN_PERSIST_X_INDEX_VEC_F32(x32Static, y->n); + PS_VECTOR_GEN_X_INDEX_STATIC_F32(x32Static, y->n); x32 = x32Static; } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL); - CONVERT_VECTOR_F64_TO_F32(x, x32, x32Static); + PS_VECTOR_CONVERT_F64_TO_F32_STATIC(x, x32, x32Static); } PS_VECTOR_CHECK_SIZE_EQUAL(x32, y32, NULL); @@ -668,5 +668,5 @@ double fac; double sum; - GEN_STATIC_RECYCLED_VECTOR(f, n, PS_TYPE_F64); + PS_VECTOR_GEN_STATIC_RECYCLED(f, n, PS_TYPE_F64); psScalar *fScalar; psScalar tmpScalar; @@ -866,18 +866,18 @@ PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL); - CONVERT_VECTOR_F32_TO_F64(y, y64, y64Static); + PS_VECTOR_CONVERT_F32_TO_F64_STATIC(y, y64, y64Static); // If yErr==NULL, set all errors equal. if (yErr == NULL) { - GEN_PERSIST_YERR_VEC_F64(yErr64Static, y->n); + PS_VECTOR_GEN_YERR_STATIC_F64(yErr64Static, y->n); yErr64 = yErr64Static; } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL); - CONVERT_VECTOR_F32_TO_F64(yErr, yErr64, yErr64Static); + PS_VECTOR_CONVERT_F32_TO_F64_STATIC(yErr, yErr64, yErr64Static); } // If x==NULL, create an x64 vector with x values set to (0:n). if (x == NULL) { - GEN_PERSIST_X_INDEX_VEC_F64(x64Static, y->n); + PS_VECTOR_GEN_X_INDEX_STATIC_F64(x64Static, y->n); if (myPoly->type == PS_POLYNOMIAL_CHEB) { p_psNormalizeVector(x64Static); @@ -886,5 +886,5 @@ } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL); - CONVERT_VECTOR_F32_TO_F64(x, x64, x64Static); + PS_VECTOR_CONVERT_F32_TO_F64_STATIC(x, x64, x64Static); } PS_VECTOR_CHECK_SIZE_EQUAL(x64, y64, NULL); Index: /trunk/psLib/src/math/psConstants.h =================================================================== --- /trunk/psLib/src/math/psConstants.h (revision 2214) +++ /trunk/psLib/src/math/psConstants.h (revision 2215) @@ -6,6 +6,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-10-27 20:20:11 $ + * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-10-27 20:29:12 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -24,10 +24,74 @@ *****************************************************************************/ - - -/***************************************************************************** - - *****************************************************************************/ -#define CONVERT_VECTOR_F64_TO_F32(OLD, NEW_PTR32, NEW_STATIC32) \ +#define PS_ONE 1.0 +/***************************************************************************** +Macros which take a generic psLib type and determine if it is NULL, or has +the wrong type. +*****************************************************************************/ +#define PS_PTR_CHECK_NULL(NAME, RVAL) \ +if (NAME == NULL) { \ + psError(__func__,"Unallowable operation: %s is NULL.", #NAME); \ + return(RVAL); \ +} + +#define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \ +if (NAME->type.type != TYPE) { \ + psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ + return(RVAL); \ +} + +/***************************************************************************** + PS_VECTOR macros: + *****************************************************************************/ +#define PS_VECTOR_CHECK_TYPE_F32_OR_F64(VEC, RVAL) \ +if ((VEC->type.type != PS_TYPE_F32) && (VEC->type.type != PS_TYPE_F64)) { \ + psAbort(__func__, "Bad type for VEC (%d)", VEC->type.type); \ + return(RVAL); \ +} \ + +#define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \ +if (NAME->type.type != TYPE) { \ + psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ + return(RVAL); \ +} + +#define PS_VECTOR_CHECK_NULL(NAME, RVAL) \ +if (NAME == NULL || NAME->data.V == NULL) { \ + psError(__func__,"Unallowable operation: %s or its data is NULL.", #NAME); \ + return(RVAL); \ +} \ + +#define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) \ +if (NAME->n < 1) { \ + psError(__func__,"Unallowable operation: %s has zero n value.", #NAME); \ + return(RVAL); \ +} \ + +#define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \ +if (VEC1->n != VEC2->n) { \ + psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ + return(RVAL); \ +} + +#define PS_VECTOR_F64_TO_F32(X64, X32) \ +psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \ +for (int i=0;in;i++) { \ + X32->data.F32[i] = (float) X64->data.F64[i]; \ +} \ + +#define PS_VECTOR_F32_TO_F64(X32, X64) \ +psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \ +for (int i=0;in;i++) { \ + X64->data.F64[i] = (float) X32->data.F32[i]; \ +} \ + +#define PS_VECTOR_PRINT(NAME) \ +for (int my_i=0;my_in;my_i++) { \ + printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \ +} \ +printf("\n"); \ + + +#define PS_VECTOR_CONVERT_F64_TO_F32_STATIC(OLD, NEW_PTR32, NEW_STATIC32) \ if (OLD->type.type == PS_TYPE_F32) { \ NEW_PTR32 = (psVector *) OLD; \ @@ -42,5 +106,5 @@ } \ -#define CONVERT_VECTOR_F32_TO_F64(OLD, NEW_PTR64, NEW_STATIC64) \ +#define PS_VECTOR_CONVERT_F32_TO_F64_STATIC(OLD, NEW_PTR64, NEW_STATIC64) \ if (OLD->type.type == PS_TYPE_F64) { \ NEW_PTR64 = (psVector *) OLD; \ @@ -55,5 +119,5 @@ } \ -#define GEN_PERSIST_YERR_VEC_F32(VEC, N) \ +#define PS_VECTOR_GEN_YERR_STATIC_F32(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \ p_psMemSetPersistent(VEC, true); \ @@ -63,5 +127,5 @@ } \ -#define GEN_PERSIST_YERR_VEC_F64(VEC, N) \ +#define PS_VECTOR_GEN_YERR_STATIC_F64(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \ p_psMemSetPersistent(VEC, true); \ @@ -71,5 +135,5 @@ } \ -#define GEN_PERSIST_X_INDEX_VEC_F32(VEC, N) \ +#define PS_VECTOR_GEN_X_INDEX_STATIC_F32(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F32); \ p_psMemSetPersistent(VEC, true); \ @@ -79,5 +143,5 @@ } \ -#define GEN_PERSIST_X_INDEX_VEC_F64(VEC, N) \ +#define PS_VECTOR_GEN_X_INDEX_STATIC_F64(VEC, N) \ VEC = psVectorRecycle(VEC, N, PS_TYPE_F64); \ p_psMemSetPersistent(VEC, true); \ @@ -87,5 +151,5 @@ } \ -#define GEN_STATIC_RECYCLED_VECTOR(NAME, SIZE, TYPE) \ +#define PS_VECTOR_GEN_STATIC_RECYCLED(NAME, SIZE, TYPE) \ static psVector *NAME = NULL; \ NAME = psVectorRecycle(NAME, SIZE, TYPE); \ @@ -95,75 +159,5 @@ /***************************************************************************** -Macros which take a generic psLib type and determine if it is NULL, or has -the wrong type. -*****************************************************************************/ -#define PS_PTR_CHECK_NULL(NAME, RVAL) \ -if (NAME == NULL) { \ - psError(__func__,"Unallowable operation: %s is NULL.", #NAME); \ - return(RVAL); \ -} - -#define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \ -if (NAME->type.type != TYPE) { \ - psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ - return(RVAL); \ -} - - -/***************************************************************************** -Macros which take a psVector type and determine if it is NULL, or has the -wrong type. - *****************************************************************************/ -#define PS_VECTOR_CHECK_TYPE_F32_OR_F64(VEC, RVAL) \ -if ((VEC->type.type != PS_TYPE_F32) && (VEC->type.type != PS_TYPE_F64)) { \ - psAbort(__func__, "Bad type for VEC (%d)", VEC->type.type); \ - return(RVAL); \ -} \ - -#define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \ -if (NAME->type.type != TYPE) { \ - psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \ - return(RVAL); \ -} - -#define PS_VECTOR_CHECK_NULL(NAME, RVAL) \ -if (NAME == NULL || NAME->data.V == NULL) { \ - psError(__func__,"Unallowable operation: %s or its data is NULL.", #NAME); \ - return(RVAL); \ -} \ - -#define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) \ -if (NAME->n < 1) { \ - psError(__func__,"Unallowable operation: %s has zero n value.", #NAME); \ - return(RVAL); \ -} \ - -#define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \ -if (VEC1->n != VEC2->n) { \ - psError(__func__,"Vector %s has size %d, Vector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \ - return(RVAL); \ -} - -#define PS_VECTOR_F64_TO_F32(X64, X32) \ -psVector *X32 = psVectorAlloc(X64->n, PS_TYPE_F32); \ -for (int i=0;in;i++) { \ - X32->data.F32[i] = (float) X64->data.F64[i]; \ -} \ - -#define PS_VECTOR_F32_TO_F64(X32, X64) \ -psVector *X64 = psVectorAlloc(X32->n, PS_TYPE_F64); \ -for (int i=0;in;i++) { \ - X64->data.F64[i] = (float) X32->data.F32[i]; \ -} \ - -#define PS_VECTOR_PRINT(NAME) \ -for (int my_i=0;my_in;my_i++) { \ - printf("%s->data.F32[%d] is %f\n", #NAME, my_i, NAME->data.F32[my_i]); \ -} \ -printf("\n"); \ - - -/***************************************************************************** - + PS_POLY macros: *****************************************************************************/ #define PS_POLY_CHECK_NULL(NAME, NULL) \ @@ -174,5 +168,5 @@ /***************************************************************************** - + PS_IMAGE macros: *****************************************************************************/ #define PS_IMAGE_CHECK_NULL(NAME, RVAL) \ @@ -195,5 +189,5 @@ } /***************************************************************************** - + PS_READOUT macros: *****************************************************************************/ /** Preprocessor macro to generate error on a NULL image */ @@ -204,10 +198,6 @@ } - - - - -/***************************************************************************** - +/***************************************************************************** + Misc. macros: *****************************************************************************/ #define PS_MAX(A, B) \ Index: /trunk/psLib/src/math/psMinimize.c =================================================================== --- /trunk/psLib/src/math/psMinimize.c (revision 2214) +++ /trunk/psLib/src/math/psMinimize.c (revision 2215) @@ -9,6 +9,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.68 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-10-27 20:20:11 $ + * @version $Revision: 1.69 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-10-27 20:29:12 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -255,22 +255,22 @@ PS_PTR_CHECK_NULL(y, NULL); PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL); - CONVERT_VECTOR_F64_TO_F32(y, y32, y32Static); + PS_VECTOR_CONVERT_F64_TO_F32_STATIC(y, y32, y32Static); // If yErr==NULL, set all errors equal. if (yErr == NULL) { - GEN_PERSIST_YERR_VEC_F32(yErr32Static, y->n); + PS_VECTOR_GEN_YERR_STATIC_F32(yErr32Static, y->n); yErr32 = yErr32Static; } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL); - CONVERT_VECTOR_F64_TO_F32(yErr, yErr32, yErr32Static); + PS_VECTOR_CONVERT_F64_TO_F32_STATIC(yErr, yErr32, yErr32Static); } // If x==NULL, create an x32 vector with x values set to (0:n). if (x == NULL) { - GEN_PERSIST_X_INDEX_VEC_F32(x32Static, y->n); + PS_VECTOR_GEN_X_INDEX_STATIC_F32(x32Static, y->n); x32 = x32Static; } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL); - CONVERT_VECTOR_F64_TO_F32(x, x32, x32Static); + PS_VECTOR_CONVERT_F64_TO_F32_STATIC(x, x32, x32Static); } PS_VECTOR_CHECK_SIZE_EQUAL(x32, y32, NULL); @@ -668,5 +668,5 @@ double fac; double sum; - GEN_STATIC_RECYCLED_VECTOR(f, n, PS_TYPE_F64); + PS_VECTOR_GEN_STATIC_RECYCLED(f, n, PS_TYPE_F64); psScalar *fScalar; psScalar tmpScalar; @@ -866,18 +866,18 @@ PS_VECTOR_CHECK_TYPE_F32_OR_F64(y, NULL); - CONVERT_VECTOR_F32_TO_F64(y, y64, y64Static); + PS_VECTOR_CONVERT_F32_TO_F64_STATIC(y, y64, y64Static); // If yErr==NULL, set all errors equal. if (yErr == NULL) { - GEN_PERSIST_YERR_VEC_F64(yErr64Static, y->n); + PS_VECTOR_GEN_YERR_STATIC_F64(yErr64Static, y->n); yErr64 = yErr64Static; } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(yErr, NULL); - CONVERT_VECTOR_F32_TO_F64(yErr, yErr64, yErr64Static); + PS_VECTOR_CONVERT_F32_TO_F64_STATIC(yErr, yErr64, yErr64Static); } // If x==NULL, create an x64 vector with x values set to (0:n). if (x == NULL) { - GEN_PERSIST_X_INDEX_VEC_F64(x64Static, y->n); + PS_VECTOR_GEN_X_INDEX_STATIC_F64(x64Static, y->n); if (myPoly->type == PS_POLYNOMIAL_CHEB) { p_psNormalizeVector(x64Static); @@ -886,5 +886,5 @@ } else { PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL); - CONVERT_VECTOR_F32_TO_F64(x, x64, x64Static); + PS_VECTOR_CONVERT_F32_TO_F64_STATIC(x, x64, x64Static); } PS_VECTOR_CHECK_SIZE_EQUAL(x64, y64, NULL);