Index: /trunk/psLib/src/dataManip/psFunctions.c =================================================================== --- /trunk/psLib/src/dataManip/psFunctions.c (revision 4527) +++ /trunk/psLib/src/dataManip/psFunctions.c (revision 4528) @@ -7,6 +7,6 @@ * polynomials. It also contains a Gaussian functions. * - * @version $Revision: 1.115 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-07-01 22:01:17 $ + * @version $Revision: 1.116 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-09 02:11:01 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -280,5 +280,5 @@ Polynomial coefficients will be accessed in [w][x][y][z] fashion. *****************************************************************************/ -static psF32 ordPolynomial1DEval(psF32 x, const psPolynomial1D* poly) +static psF64 ordPolynomial1DEval(psF64 x, const psPolynomial1D* poly) { psS32 loop_x = 0; @@ -310,5 +310,5 @@ // XXX: How does the mask vector effect Crenshaw's formula? // XXX: We assume that x is scaled between -1.0 and 1.0; -static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* poly) +static psF64 chebPolynomial1DEval(psF64 x, const psPolynomial1D* poly) { PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0); @@ -392,6 +392,6 @@ } -static psF32 ordPolynomial2DEval(psF32 x, - psF32 y, +static psF64 ordPolynomial2DEval(psF64 x, + psF64 y, const psPolynomial2D* poly) { @@ -418,5 +418,5 @@ } -static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* poly) +static psF64 chebPolynomial2DEval(psF64 x, psF64 y, const psPolynomial2D* poly) { PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0); @@ -455,5 +455,5 @@ } -static psF32 ordPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* poly) +static psF64 ordPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly) { psS32 loop_x = 0; @@ -483,5 +483,5 @@ } -static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* poly) +static psF64 chebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly) { PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0); @@ -527,5 +527,5 @@ } -static psF32 ordPolynomial4DEval(psF32 x, psF32 y, psF32 z, psF32 t, const psPolynomial4D* poly) +static psF64 ordPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly) { psS32 loop_x = 0; @@ -561,5 +561,5 @@ } -static psF32 chebPolynomial4DEval(psF32 x, psF32 y, psF32 z, psF32 t, const psPolynomial4D* poly) +static psF64 chebPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly) { PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0); @@ -1069,5 +1069,5 @@ This routine must allocate memory for the polynomial structures. *****************************************************************************/ -psPolynomial1D* psPolynomial1DAlloc(unsigned int n, +psPolynomial1D* psPolynomial1DAlloc(int n, psPolynomialType type) { @@ -1094,6 +1094,6 @@ } -psPolynomial2D* psPolynomial2DAlloc(unsigned int nX, unsigned int nY, - psPolynomialType type) +psPolynomial2D* psPolynomial2DAlloc( int nX, int nY, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(nX, NULL); @@ -1130,6 +1130,6 @@ } -psPolynomial3D* psPolynomial3DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ, - psPolynomialType type) +psPolynomial3D* psPolynomial3DAlloc( int nX, int nY, int nZ, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(nX, NULL); @@ -1176,6 +1176,6 @@ } -psPolynomial4D* psPolynomial4DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ, unsigned int nT, - psPolynomialType type) +psPolynomial4D* psPolynomial4DAlloc( int nX, int nY, int nZ, int nT, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(nX, NULL); @@ -1431,6 +1431,6 @@ -psDPolynomial1D* psDPolynomial1DAlloc(unsigned int n, - psPolynomialType type) +psDPolynomial1D* psDPolynomial1DAlloc( int n, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(n, NULL); @@ -1456,6 +1456,6 @@ } -psDPolynomial2D* psDPolynomial2DAlloc(unsigned int nX, unsigned int nY, - psPolynomialType type) +psDPolynomial2D* psDPolynomial2DAlloc( int nX, int nY, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(nX, NULL); @@ -1492,6 +1492,6 @@ } -psDPolynomial3D* psDPolynomial3DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ, - psPolynomialType type) +psDPolynomial3D* psDPolynomial3DAlloc( int nX, int nY, int nZ, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(nX, NULL); @@ -1538,6 +1538,6 @@ } -psDPolynomial4D* psDPolynomial4DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ, unsigned int nT, - psPolynomialType type) +psDPolynomial4D* psDPolynomial4DAlloc( int nX, int nY, int nZ, int nT, + psPolynomialType type) { PS_ASSERT_INT_POSITIVE(nX, NULL); @@ -1822,8 +1822,8 @@ XXX: What should be the defualty type for knots be? psF32 is assumed. *****************************************************************************/ -psSpline1D *psSpline1DAlloc(unsigned int numSplines, - unsigned int order, - float min, - float max) +psSpline1D *psSpline1DAlloc( int numSplines, + int order, + float min, + float max) { PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL); @@ -1867,5 +1867,5 @@ *****************************************************************************/ psSpline1D *psSpline1DAllocGeneric(const psVector *bounds, - unsigned int order) + int order) { PS_ASSERT_VECTOR_NON_NULL(bounds, NULL); @@ -2045,5 +2045,5 @@ psScalar *p_psVectorInterpolate(psVector *domain, psVector *range, - unsigned int order, + int order, psScalar *x) { Index: /trunk/psLib/src/dataManip/psFunctions.h =================================================================== --- /trunk/psLib/src/dataManip/psFunctions.h (revision 4527) +++ /trunk/psLib/src/dataManip/psFunctions.h (revision 4528) @@ -12,6 +12,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.52 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-07-01 22:01:17 $ + * @version $Revision: 1.53 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-09 02:11:01 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -75,5 +75,5 @@ psPolynomialType type; ///< Polynomial type psElemType ctype; ///< Polynomial precision - unsigned int n; ///< Number of terms + int n; ///< Number of terms psF32 *coeff; ///< Coefficients psF32 *coeffErr; ///< Error in coefficients @@ -87,6 +87,6 @@ psPolynomialType type; ///< Polynomial type psElemType ctype; ///< Polynomial precision - unsigned int nX; ///< Number of terms in x - unsigned int nY; ///< Number of terms in y + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y psF32 **coeff; ///< Coefficients psF32 **coeffErr; ///< Error in coefficients @@ -100,7 +100,7 @@ psPolynomialType type; ///< Polynomial type psElemType ctype; ///< Polynomial precision - unsigned int nX; ///< Number of terms in x - unsigned int nY; ///< Number of terms in y - unsigned int nZ; ///< Number of terms in z + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z psF32 ***coeff; ///< Coefficients psF32 ***coeffErr; ///< Error in coefficients @@ -114,8 +114,8 @@ psPolynomialType type; ///< Polynomial type psElemType ctype; ///< Polynomial precision - unsigned int nX; ///< Number of terms in x - unsigned int nY; ///< Number of terms in y - unsigned int nZ; ///< Number of terms in z - unsigned int nT; ///< Number of terms in t + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + int nT; ///< Number of terms in t psF32 ****coeff; ///< Coefficients psF32 ****coeffErr; ///< Error in coefficients @@ -130,5 +130,5 @@ */ psPolynomial1D* psPolynomial1DAlloc( - unsigned int n, ///< Number of terms + int n, ///< Number of terms psPolynomialType type ///< Polynomial Type ); @@ -139,6 +139,6 @@ */ psPolynomial2D* psPolynomial2DAlloc( - unsigned int nX, ///< Number of terms in x - unsigned int nY, ///< Number of terms in y + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y psPolynomialType type ///< Polynomial Type ); @@ -149,7 +149,7 @@ */ psPolynomial3D* psPolynomial3DAlloc( - unsigned int nX, ///< Number of terms in x - unsigned int nY, ///< Number of terms in y - unsigned int nZ, ///< Number of terms in z + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ, ///< Number of terms in z psPolynomialType type ///< Polynomial Type ); @@ -160,8 +160,8 @@ */ psPolynomial4D* psPolynomial4DAlloc( - unsigned int nX, ///< Number of terms in x - unsigned int nY, ///< Number of terms in y - unsigned int nZ, ///< Number of terms in z - unsigned int nT, ///< Number of terms in t + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ, ///< Number of terms in z + int nT, ///< Number of terms in t psPolynomialType type ///< Polynomial Type ); @@ -259,5 +259,5 @@ { psPolynomialType type; ///< Polynomial type - unsigned int n; ///< Number of terms + int n; ///< Number of terms psF64 *coeff; ///< Coefficients psF64 *coeffErr; ///< Error in coefficients @@ -270,6 +270,6 @@ { psPolynomialType type; ///< Polynomial type - unsigned int nX; ///< Number of terms in x - unsigned int nY; ///< Number of terms in y + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y psF64 **coeff; ///< Coefficients psF64 **coeffErr; ///< Error in coefficients @@ -282,7 +282,7 @@ { psPolynomialType type; ///< Polynomial type - unsigned int nX; ///< Number of terms in x - unsigned int nY; ///< Number of terms in y - unsigned int nZ; ///< Number of terms in z + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z psF64 ***coeff; ///< Coefficients psF64 ***coeffErr; ///< Error in coefficients @@ -295,8 +295,8 @@ { psPolynomialType type; ///< Polynomial type - unsigned int nX; ///< Number of terms in w - unsigned int nY; ///< Number of terms in x - unsigned int nZ; ///< Number of terms in y - unsigned int nT; ///< Number of terms in z + int nX; ///< Number of terms in w + int nY; ///< Number of terms in x + int nZ; ///< Number of terms in y + int nT; ///< Number of terms in z psF64 ****coeff; ///< Coefficients psF64 ****coeffErr; ///< Error in coefficients @@ -310,5 +310,5 @@ */ psDPolynomial1D* psDPolynomial1DAlloc( - unsigned int n, ///< Number of terms + int n, ///< Number of terms psPolynomialType type ///< Polynomial Type ); @@ -319,6 +319,6 @@ */ psDPolynomial2D* psDPolynomial2DAlloc( - unsigned int nX, ///< Number of terms in x - unsigned int nY, ///< Number of terms in y + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y psPolynomialType type ///< Polynomial Type ); @@ -329,7 +329,7 @@ */ psDPolynomial3D* psDPolynomial3DAlloc( - unsigned int nX, ///< Number of terms in x - unsigned int nY, ///< Number of terms in y - unsigned int nZ, ///< Number of terms in z + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ, ///< Number of terms in z psPolynomialType type ///< Polynomial Type ); @@ -340,8 +340,8 @@ */ psDPolynomial4D* psDPolynomial4DAlloc( - unsigned int nX, ///< Number of terms in w - unsigned int nY, ///< Number of terms in x - unsigned int nZ, ///< Number of terms in y - unsigned int nT, ///< Number of terms in z + int nX, ///< Number of terms in w + int nY, ///< Number of terms in x + int nZ, ///< Number of terms in y + int nT, ///< Number of terms in z psPolynomialType type ///< Polynomial Type ); @@ -450,6 +450,6 @@ */ psSpline1D *psSpline1DAlloc( - unsigned int n, ///< Number of spline polynomials - unsigned int order, ///< Order of spline polynomials + int n, ///< Number of spline polynomials + int order, ///< Order of spline polynomials float min, ///< Lower boundary value of spline polynomials float max ///< Upper boundary value of spline polynomials @@ -464,5 +464,5 @@ psSpline1D *psSpline1DAllocGeneric( const psVector *bounds, ///< Bounds for spline polynomials - unsigned int order ///< Order of spline polynomials + int order ///< Order of spline polynomials ); @@ -503,5 +503,5 @@ psVector *domain, ///< Domain (x coords) for interpolation psVector *range, ///< Range (y coords) for interpolation - unsigned int order, ///< Order of interpolation function + int order, ///< Order of interpolation function psScalar *x ///< Location at which to evaluate ); Index: /trunk/psLib/src/dataManip/psMinimize.c =================================================================== --- /trunk/psLib/src/dataManip/psMinimize.c (revision 4527) +++ /trunk/psLib/src/dataManip/psMinimize.c (revision 4528) @@ -9,6 +9,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.123 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-06-20 22:42:30 $ + * @version $Revision: 1.124 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-09 02:11:01 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -1357,11 +1357,11 @@ XXX: type F32 is done via vector conversion only. *****************************************************************************/ -psPolynomial1D* psVectorFitPolynomial1D(psPolynomial1D* myPoly, +psPolynomial1D* psVectorFitPolynomial1D(psPolynomial1D* poly, const psVector* x, const psVector* y, const psVector* yErr) { - PS_ASSERT_POLY_NON_NULL(myPoly, NULL); - PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL); + PS_ASSERT_POLY_NON_NULL(poly, NULL); + PS_ASSERT_INT_NONNEGATIVE(poly->n, NULL); PS_ASSERT_VECTOR_NON_NULL(y, NULL); PS_ASSERT_VECTOR_NON_EMPTY(y, NULL); @@ -1389,5 +1389,5 @@ if (x == NULL) { PS_VECTOR_GEN_X_INDEX_STATIC_F64(x64Static, y->n); - if (myPoly->type == PS_POLYNOMIAL_CHEB) { + if (poly->type == PS_POLYNOMIAL_CHEB) { p_psNormalizeVectorRangeF64(x64Static, -1.0, 1.0); } @@ -1396,5 +1396,5 @@ PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL); PS_VECTOR_CONVERT_F32_TO_F64_STATIC(x, x64, x64Static); - if (myPoly->type == PS_POLYNOMIAL_CHEB) { + if (poly->type == PS_POLYNOMIAL_CHEB) { p_psNormalizeVectorRangeF64(x64, -1.0, 1.0); } @@ -1405,8 +1405,8 @@ // Call the appropriate vector fitting routine. psPolynomial1D *rc = NULL; - if (myPoly->type == PS_POLYNOMIAL_CHEB) { - rc = vectorFitPolynomial1DCheby(myPoly, x64, y64, yErr64); - } else if (myPoly->type == PS_POLYNOMIAL_ORD) { - rc = vectorFitPolynomial1DOrd(myPoly, x64, y64, yErr64); + if (poly->type == PS_POLYNOMIAL_CHEB) { + rc = vectorFitPolynomial1DCheby(poly, x64, y64, yErr64); + } else if (poly->type == PS_POLYNOMIAL_ORD) { + rc = vectorFitPolynomial1DOrd(poly, x64, y64, yErr64); } else { psError(PS_ERR_BAD_PARAMETER_VALUE, true, @@ -1419,5 +1419,5 @@ } - return(myPoly); + return(poly); } @@ -1432,6 +1432,6 @@ psMinimization *min = psAlloc(sizeof(psMinimization)); - min->maxIter = maxIter; - min->tol = tol; + *(int*)&min->maxIter = maxIter; + *(float*)&min->tol = tol; min->value = 0.0; min->iter = 0; @@ -1993,6 +1993,6 @@ for (i=0;idata.U8[i] == 0) { - dummyMin.maxIter = PS_MINIMIZE_POWELL_LINEMIN_MAX_ITERATIONS; - dummyMin.tol = PS_MINIMIZE_POWELL_LINEMIN_ERROR_TOLERANCE; + *(int*)&dummyMin.maxIter = PS_MINIMIZE_POWELL_LINEMIN_MAX_ITERATIONS; + *(float*)&dummyMin.tol = PS_MINIMIZE_POWELL_LINEMIN_ERROR_TOLERANCE; mul = p_psLineMin(&dummyMin, Q, Index: /trunk/psLib/src/dataManip/psMinimize.h =================================================================== --- /trunk/psLib/src/dataManip/psMinimize.h (revision 4527) +++ /trunk/psLib/src/dataManip/psMinimize.h (revision 4528) @@ -8,6 +8,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.48 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-06-21 03:01:37 $ + * @version $Revision: 1.49 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-09 02:11:01 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -38,19 +38,19 @@ /** A data structure for minimization routines. - * + * * Contains numerical analysis parameters/values */ typedef struct { - psS32 maxIter; ///< Convergence limit - psF32 tol; ///< Error Tolerance - psF32 value; ///< Value of function at minimum - psS32 iter; ///< Number of iterations to date - psF32 lastDelta; ///< The last difference for the fit + const int maxIter; ///< Convergence limit + const float tol; ///< Error Tolerance + float value; ///< Value of function at minimum + int iter; ///< Number of iterations to date + float lastDelta; ///< The last difference for the fit } psMinimization; /** Allocates a psMinimization structure. - * + * * @return psMinimization* : a new psMinimization struct */ @@ -74,5 +74,5 @@ */ psPolynomial1D* psVectorFitPolynomial1D( - psPolynomial1D* myPoly, ///< Polynomial to fit + psPolynomial1D* poly, ///< Polynomial to fit const psVector* x, ///< Ordinates (or NULL to just use the indices) const psVector* y, ///< Coordinates @@ -81,8 +81,8 @@ /** Derive a one-dimensional spline fit. - * - * Given a psSpline1D data structure and a set of x,y vectors, this routine + * + * Given a psSpline1D data structure and a set of x,y vectors, this routine * generates the linear splines which satisfy those data points. - * + * * @return psSpline1D*: the calculated one-dimensional splines */ @@ -96,17 +96,17 @@ /** Specifies the format of a user-defined function that the general Levenberg- * Marquardt minimizer routine will accept. - * - * @return psF64: the single float value of the function given the parameters, + * + * @return float: the single float value of the function given the parameters, * positions, and derivatives. */ typedef -psF64 (*psMinimizeLMChi2Func)( +float (*psMinimizeLMChi2Func)( psVector *deriv, ///< derivatives of the function - psVector *params, ///< the parameters used to evaluate the function - psVector *x ///< positions for evaluation + const psVector *params, ///< the parameters used to evaluate the function + const psVector *x ///< positions for evaluation ); /** Minimizes a specified function based on the Levenberg-Marquardt method. - * + * * @return bool: True if successful. */ @@ -123,5 +123,5 @@ /** Use specified alpha, beta, params to generate a new guess for Alpha, Beta, Params - * + * * @return psBool: True if successful. */ @@ -138,5 +138,5 @@ /** Function used to set parameters for generating "best guess" in minimizing Chi-Squared value. - * + * * @return psF64: Chi-squared value for new guess */ @@ -153,10 +153,10 @@ /** Specifies the format of a user-defined function that the general Powell * minimizer routine will accept. - * - * @return psF32: the single float value of the function given the parameters + * + * @return float: the single float value of the function given the parameters * and coordinate vectors. */ typedef -psF32 (*psMinimizePowellFunc)( +float (*psMinimizePowellFunc)( const psVector *params, ///< Parameters used to evaluate the function const psArray *coords ///< Coordinates at which to evaluate @@ -164,5 +164,5 @@ /** Minimizes a specified function based on the Powell method. - * + * * @return bool: True if successful. */ @@ -177,5 +177,5 @@ /** Calculates the one-dimensional Gaussian in a format acceptable to the Levenberg- * Marquardt minimizer routine. - * + * * @return psVector*: Calculated values */ @@ -188,5 +188,5 @@ /** Calculates the one-dimensional Gaussian in a format acceptable to the Powell * chi-squared minimizer routine. - * + * * @return psVector*: Calculated values */ @@ -198,5 +198,5 @@ /** Specifies the format of a user-defined function that the general Powell chi- * squared minimizer routine will accept. - * + * * @return psVector*: Calculated values given the parameters and coordinates. */ @@ -208,5 +208,5 @@ /** Minimizes a specified function based on the Powell chi-squared method. - * + * * @return bool: True is successful. */ @@ -222,5 +222,5 @@ /** Gauss-Jordan numerical solver. - * + * * @return bool: True if successful. */ Index: /trunk/psLib/test/dataManip/verified/tst_psMinimize04.stderr =================================================================== --- /trunk/psLib/test/dataManip/verified/tst_psMinimize04.stderr (revision 4527) +++ /trunk/psLib/test/dataManip/verified/tst_psMinimize04.stderr (revision 4528) @@ -2,3 +2,3 @@ Following should generate an error for null input polynomial.