Index: /trunk/psLib/src/dataManip/psFunctions.h =================================================================== --- /trunk/psLib/src/dataManip/psFunctions.h (revision 1463) +++ /trunk/psLib/src/dataManip/psFunctions.h (revision 1464) @@ -13,6 +13,6 @@ * @author George Gusciora, MHPCC * -* @version $Revision: 1.18 $ $Name: not supported by cvs2svn $ -* @date $Date: 2004-08-09 23:40:55 $ +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-11 02:35:58 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -31,26 +31,37 @@ /** Evaluate a non-normalized Gaussian with the given mean and sigma at the - given coordianate. Note that this is not a Gaussian deviate. The - evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] */ - -float psGaussian(float x, ///< Value at which to evaluate - float mean, ///< Mean for the Gaussian - float stddev, ///< Standard deviation for the Gaussian - bool normal ///< Indicates whether result should be normalized - ); + * given coordianate. + * + * Note that this is not a Gaussian deviate. The evaluated Gaussian is: + * \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + * + * @return float value on the gaussian curve given the input parameters + */ +float psGaussian( + float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev, ///< Standard deviation for the Gaussian + bool normal ///< Indicates whether result should be normalized +); /** Produce a vector of random numbers from a Gaussian distribution with - the specified mean and sigma */ -psVector* psGaussianDev(float mean, ///< The mean of the Gaussian - float sigma, ///< The sigma of the Gaussian - int Npts); ///< The size of the vector + * the specified mean and sigma + * + * @return psVector* vector of random numbers + * + */ +psVector* psGaussianDev( + float mean, ///< The mean of the Gaussian + float sigma, ///< The sigma of the Gaussian + int Npts ///< The size of the vector +); /** One-dimensional polynomial */ typedef struct { - int n; ///< Number of terms - float *coeff; ///< Coefficients - float *coeffErr; ///< Error in coefficients - char *mask; ///< Coefficient mask + int n; ///< Number of terms + float *coeff; ///< Coefficients + float *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask } psPolynomial1D; @@ -59,9 +70,9 @@ typedef struct { - int nX, - nY; ///< Number of terms in x and y - float **coeff; ///< Coefficients - float **coeffErr; ///< Error in coefficients - char **mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + float **coeff; ///< Coefficients + float **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask } psPolynomial2D; @@ -70,10 +81,10 @@ typedef struct { - int nX, - nY, - nZ; ///< Number of terms in x, y and z - float ***coeff; ///< Coefficients - float ***coeffErr; ///< Error in coefficients - char ***mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ***coeff; ///< Coefficients + float ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficients mask } psPolynomial3D; @@ -82,58 +93,94 @@ typedef struct { - int nW, - nX, - nY, - nZ; ///< Number of terms in w, x, y and z - float ****coeff; ///< Coefficients - float ****coeffErr; ///< Error in coefficients - char ****mask; ///< Coefficients mask + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ****coeff; ///< Coefficients + float ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask } psPolynomial4D; -/** Functions **************************************************************/ - -/** Constructor */ -psPolynomial1D* psPolynomial1DAlloc(int n ///< Number of terms - ); - -/** Constructor */ -psPolynomial2D* psPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y - ); - -/** Constructor */ -psPolynomial3D* psPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z - ); - -/** Constructor */ -psPolynomial4D* psPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and - // z - ); - -/** Evaluate 1D polynomial */ -float psPolynomial1DEval(float x, ///< Value at which to evaluate - const psPolynomial1D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 2D polynomial */ -float psPolynomial2DEval(float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - const psPolynomial2D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 3D polynomial */ -float psPolynomial3DEval(float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - float z, ///< Value z at which to evaluate - const psPolynomial3D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 4D polynomial */ -float psPolynomial4DEval(float w, ///< Value w at which to evaluate - float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - float z, ///< Value z at which to evaluate - const psPolynomial4D* myPoly ///< Coefficients for the polynomial - ); + +/** Allocates a psPolynomial1D structure with n terms + * + * @return psPolynomial1D* new 1-D polynomial struct + */ +psPolynomial1D* psPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a 2-D polynomial structure + * + * @return psPolynomial2D* new 2-D polynomial struct + */ +psPolynomial2D* psPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a 3-D polynomial structure + * + * @return psPolynomial3D* new 3-D polynomial struct + */ +psPolynomial3D* psPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a 4-D polynomial structure + * + * @return psPolynomial4D* new 4-D polynomial struct + */ +psPolynomial4D* psPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial1DEval( + float x, ///< location at which to evaluate + const psPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial2DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + const psPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial3DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial4DEval( + float w, ///< w location at which to evaluate + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial4D* myPoly ///< Coefficients for the polynomial +); /*****************************************************************************/ @@ -144,8 +191,8 @@ typedef struct { - int n; ///< Number of terms - double *coeff; ///< Coefficients - double *coeffErr; ///< Error in coefficients - char *mask; ///< Coefficient mask + int n; ///< Number of terms + double *coeff; ///< Coefficients + double *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask } psDPolynomial1D; @@ -154,9 +201,9 @@ typedef struct { - int nX, - nY; ///< Number of terms in x and y - double **coeff; ///< Coefficients - double **coeffErr; ///< Error in coefficients - char **mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + double **coeff; ///< Coefficients + double **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask } psDPolynomial2D; @@ -165,10 +212,10 @@ typedef struct { - int nX, - nY, - nZ; ///< Number of terms in x, y and z - double ***coeff; ///< Coefficients - double ***coeffErr; ///< Error in coefficients - char ***mask; ///< Coefficient mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ***coeff; ///< Coefficients + double ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficient mask } psDPolynomial3D; @@ -177,56 +224,93 @@ typedef struct { - int nW, - nX, - nY, - nZ; ///< Number of terms in w, x, y and z - double ****coeff; ///< Coefficients - double ****coeffErr; ///< Error in coefficients - char ****mask; ///< Coefficients mask + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ****coeff; ///< Coefficients + double ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask } psDPolynomial4D; -/** Constructor */ -psDPolynomial1D* psDPolynomial1DAlloc(int n ///< Number of terms - ); - -/** Constructor */ -psDPolynomial2D* psDPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y - ); - -/** Constructor */ -psDPolynomial3D* psDPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z - ); - -/** Constructor */ -psDPolynomial4D* psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and - // z - ); - -/** Evaluate 1D polynomial (double precision) */ -double psDPolynomial1DEval(double x, ///< Value at which to evaluate - const psDPolynomial1D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 2D polynomial (double precision) */ -double psDPolynomial2DEval(double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - const psDPolynomial2D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 3D polynomial (double precision) */ -double psDPolynomial3DEval(double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - double z, ///< Value z at which to evaluate - const psDPolynomial3D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 4D polynomial (double precision) */ -double psDPolynomial4DEval(double w, ///< Value w at which to evaluate - double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - double z, ///< Value z at which to evaluate - const psDPolynomial4D* myPoly ///< Coefficients for the polynomial - ); +/** Allocates a double-precision 1-D polynomial structure with n terms + * + * @return psPolynomial1D* new double-precision 1-D polynomial struct + */ +psDPolynomial1D* psDPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a double-precision 2-D polynomial structure + * + * @return psPolynomial2D* new double-precision 2-D polynomial struct + */ +psDPolynomial2D* psDPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a double-precision 3-D polynomial structure + * + * @return psPolynomial3D* new double-precision 3-D polynomial struct + */ +psDPolynomial3D* psDPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a double-precision 4-D polynomial structure + * + * @return psPolynomial4D* new double-precision 4-D polynomial struct + */ +psDPolynomial4D* psDPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a double-precision 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial1DEval( + double x, ///< Value at which to evaluate + const psDPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial2DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial3DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial4DEval( + double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D* myPoly ///< Coefficients for the polynomial +); /* \} */// End of MathGroup Functions Index: /trunk/psLib/src/dataManip/psMatrix.h =================================================================== --- /trunk/psLib/src/dataManip/psMatrix.h (revision 1463) +++ /trunk/psLib/src/dataManip/psMatrix.h (revision 1464) @@ -22,6 +22,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-08-09 23:40:55 $ + * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 02:35:58 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -43,8 +43,9 @@ * @return psImage* : Pointer to LU decomposed psImage. */ -psImage* psMatrixLUD(psImage* outImage, ///< Image to return, or NULL. - psVector* outPerm, ///< Output permutation vector used by psMatrixLUSolve. - psImage* inImage ///< Image to decompose. - ); +psImage* psMatrixLUD( + psImage* outImage, ///< Image to return, or NULL. + psVector* outPerm, ///< Output permutation vector used by psMatrixLUSolve. + psImage* inImage ///< Image to decompose. +); /** LU Solution of psImage matrix. @@ -57,10 +58,10 @@ * @return psVector* : Pointer to psVector solution of matrix equation. */ -psVector* psMatrixLUSolve(psVector* outVector, ///< Vector to return, or NULL. - const psImage* luImage, ///< LU-decomposed matrix. - const psVector* inVector, ///< Vector right-hand-side of equation. - const psVector* inPerm ///< Permutation vector resulting from psMatrixLUD - // function. - ); +psVector* psMatrixLUSolve( + psVector* outVector, ///< Vector to return, or NULL. + const psImage* luImage, ///< LU-decomposed matrix. + const psVector* inVector, ///< Vector right-hand-side of equation. + const psVector* inPerm ///< Permutation vector resulting from psMatrixLUD function. +); /** Invert psImage matrix. @@ -73,8 +74,9 @@ * @return psImage* : Pointer to inverted psImage. */ -psImage* psMatrixInvert(psImage* outImage, ///< Image to return, or NULL for in-place substitution. - const psImage* inImage, ///< Image to be inverted - float *restrict det ///< Determinant to return, or NULL - ); +psImage* psMatrixInvert( + psImage* outImage, ///< Image to return, or NULL for in-place substitution. + const psImage* inImage, ///< Image to be inverted + float *restrict det ///< Determinant to return, or NULL +); /** Calculate psImage matrix determinant. @@ -86,6 +88,7 @@ * @return float: Determinant from psImage. */ -float *psMatrixDeterminant(const psImage* restrict inMatrix ///< Image used to calculate determinant. - ); +float *psMatrixDeterminant( + const psImage* restrict inMatrix ///< Image used to calculate determinant. +); /** Performs psImage matrix multiplication. @@ -98,8 +101,9 @@ * @return psImage* : Pointer to resulting psImage. */ -psImage* psMatrixMultiply(psImage* outImage, ///< Matrix to return, or NULL. - psImage* inImage1, ///< First input image. - psImage* inImage2 ///< Second input image. - ); +psImage* psMatrixMultiply( + psImage* outImage, ///< Matrix to return, or NULL. + psImage* inImage1, ///< First input image. + psImage* inImage2 ///< Second input image. +); /** Transpose matrix. @@ -112,7 +116,8 @@ * @return psImage* : Pointer to transposed psImage. */ -psImage* psMatrixTranspose(psImage* outImage, ///< Image to return, or NULL - const psImage* inImage ///< Image to transpose - ); +psImage* psMatrixTranspose( + psImage* outImage, ///< Image to return, or NULL + const psImage* inImage ///< Image to transpose +); /** Calculate matrix eigenvectors. @@ -124,7 +129,8 @@ * @return psImage* : Pointer to matrix of Eigenvectors. */ -psImage* psMatrixEigenvectors(psImage* outImage, ///< Eigenvectors to return, or NULL. - psImage* inImage ///< Input image. - ); +psImage* psMatrixEigenvectors( + psImage* outImage, ///< Eigenvectors to return, or NULL. + psImage* inImage ///< Input image. +); /** Convert matrix to vector. @@ -137,7 +143,8 @@ * @return psVector* : Pointer to psVector. */ -psVector* psMatrixToVector(psVector* outVector, ///< Vector to return, or NULL. - psImage* inImage ///< Image to convert. - ); +psVector* psMatrixToVector( + psVector* outVector, ///< Vector to return, or NULL. + psImage* inImage ///< Image to convert. +); /** Convert vector to matrix. @@ -150,7 +157,8 @@ * @return psVector* : Pointer to psIamge. */ -psImage* psVectorToMatrix(psImage* outImage, ///< Matrix to return, or NULL. - psVector* inVector ///< Vector to convert. - ); +psImage* psVectorToMatrix( + psImage* outImage, ///< Matrix to return, or NULL. + psVector* inVector ///< Vector to convert. +); /// @} Index: /trunk/psLib/src/dataManip/psMatrixVectorArithmetic.h =================================================================== --- /trunk/psLib/src/dataManip/psMatrixVectorArithmetic.h (revision 1463) +++ /trunk/psLib/src/dataManip/psMatrixVectorArithmetic.h (revision 1464) @@ -30,6 +30,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-08-09 23:40:55 $ + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 02:37:55 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -55,9 +55,10 @@ * @return psType* : Pointer to either psImage or psVector. */ -psType* psBinaryOp(void *out, // / Output type, either psImage or psVector. - void *in1, // / First input, either psImage or psVector. - char *op, // / Operator. - void *in2 // / Second input, either psImage or psVector. - ); +psType* psBinaryOp( + void *out, ///< Output type, either psImage or psVector. + void *in1, ///< First input, either psImage or psVector. + char *op, ///< Operator. + void *in2 ///< Second input, either psImage or psVector. +); /** Perform simple unary arithmetic with images or vectors @@ -77,8 +78,9 @@ * @return psType* : Pointer to either psImage or psVector. */ -psType* psUnaryOp(void *out, // / Output type, either psImage or psVector. - void *in, // / Input, either psImage or psVector. - char *op // / Operator. - ); +psType* psUnaryOp( + void *out, ///< Output type, either psImage or psVector. + void *in, ///< Input, either psImage or psVector. + char *op ///< Operator. +); /// @} Index: /trunk/psLib/src/math/psMatrix.h =================================================================== --- /trunk/psLib/src/math/psMatrix.h (revision 1463) +++ /trunk/psLib/src/math/psMatrix.h (revision 1464) @@ -22,6 +22,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-08-09 23:40:55 $ + * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-08-11 02:35:58 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -43,8 +43,9 @@ * @return psImage* : Pointer to LU decomposed psImage. */ -psImage* psMatrixLUD(psImage* outImage, ///< Image to return, or NULL. - psVector* outPerm, ///< Output permutation vector used by psMatrixLUSolve. - psImage* inImage ///< Image to decompose. - ); +psImage* psMatrixLUD( + psImage* outImage, ///< Image to return, or NULL. + psVector* outPerm, ///< Output permutation vector used by psMatrixLUSolve. + psImage* inImage ///< Image to decompose. +); /** LU Solution of psImage matrix. @@ -57,10 +58,10 @@ * @return psVector* : Pointer to psVector solution of matrix equation. */ -psVector* psMatrixLUSolve(psVector* outVector, ///< Vector to return, or NULL. - const psImage* luImage, ///< LU-decomposed matrix. - const psVector* inVector, ///< Vector right-hand-side of equation. - const psVector* inPerm ///< Permutation vector resulting from psMatrixLUD - // function. - ); +psVector* psMatrixLUSolve( + psVector* outVector, ///< Vector to return, or NULL. + const psImage* luImage, ///< LU-decomposed matrix. + const psVector* inVector, ///< Vector right-hand-side of equation. + const psVector* inPerm ///< Permutation vector resulting from psMatrixLUD function. +); /** Invert psImage matrix. @@ -73,8 +74,9 @@ * @return psImage* : Pointer to inverted psImage. */ -psImage* psMatrixInvert(psImage* outImage, ///< Image to return, or NULL for in-place substitution. - const psImage* inImage, ///< Image to be inverted - float *restrict det ///< Determinant to return, or NULL - ); +psImage* psMatrixInvert( + psImage* outImage, ///< Image to return, or NULL for in-place substitution. + const psImage* inImage, ///< Image to be inverted + float *restrict det ///< Determinant to return, or NULL +); /** Calculate psImage matrix determinant. @@ -86,6 +88,7 @@ * @return float: Determinant from psImage. */ -float *psMatrixDeterminant(const psImage* restrict inMatrix ///< Image used to calculate determinant. - ); +float *psMatrixDeterminant( + const psImage* restrict inMatrix ///< Image used to calculate determinant. +); /** Performs psImage matrix multiplication. @@ -98,8 +101,9 @@ * @return psImage* : Pointer to resulting psImage. */ -psImage* psMatrixMultiply(psImage* outImage, ///< Matrix to return, or NULL. - psImage* inImage1, ///< First input image. - psImage* inImage2 ///< Second input image. - ); +psImage* psMatrixMultiply( + psImage* outImage, ///< Matrix to return, or NULL. + psImage* inImage1, ///< First input image. + psImage* inImage2 ///< Second input image. +); /** Transpose matrix. @@ -112,7 +116,8 @@ * @return psImage* : Pointer to transposed psImage. */ -psImage* psMatrixTranspose(psImage* outImage, ///< Image to return, or NULL - const psImage* inImage ///< Image to transpose - ); +psImage* psMatrixTranspose( + psImage* outImage, ///< Image to return, or NULL + const psImage* inImage ///< Image to transpose +); /** Calculate matrix eigenvectors. @@ -124,7 +129,8 @@ * @return psImage* : Pointer to matrix of Eigenvectors. */ -psImage* psMatrixEigenvectors(psImage* outImage, ///< Eigenvectors to return, or NULL. - psImage* inImage ///< Input image. - ); +psImage* psMatrixEigenvectors( + psImage* outImage, ///< Eigenvectors to return, or NULL. + psImage* inImage ///< Input image. +); /** Convert matrix to vector. @@ -137,7 +143,8 @@ * @return psVector* : Pointer to psVector. */ -psVector* psMatrixToVector(psVector* outVector, ///< Vector to return, or NULL. - psImage* inImage ///< Image to convert. - ); +psVector* psMatrixToVector( + psVector* outVector, ///< Vector to return, or NULL. + psImage* inImage ///< Image to convert. +); /** Convert vector to matrix. @@ -150,7 +157,8 @@ * @return psVector* : Pointer to psIamge. */ -psImage* psVectorToMatrix(psImage* outImage, ///< Matrix to return, or NULL. - psVector* inVector ///< Vector to convert. - ); +psImage* psVectorToMatrix( + psImage* outImage, ///< Matrix to return, or NULL. + psVector* inVector ///< Vector to convert. +); /// @} Index: /trunk/psLib/src/math/psPolynomial.h =================================================================== --- /trunk/psLib/src/math/psPolynomial.h (revision 1463) +++ /trunk/psLib/src/math/psPolynomial.h (revision 1464) @@ -13,6 +13,6 @@ * @author George Gusciora, MHPCC * -* @version $Revision: 1.18 $ $Name: not supported by cvs2svn $ -* @date $Date: 2004-08-09 23:40:55 $ +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-11 02:35:58 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -31,26 +31,37 @@ /** Evaluate a non-normalized Gaussian with the given mean and sigma at the - given coordianate. Note that this is not a Gaussian deviate. The - evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] */ - -float psGaussian(float x, ///< Value at which to evaluate - float mean, ///< Mean for the Gaussian - float stddev, ///< Standard deviation for the Gaussian - bool normal ///< Indicates whether result should be normalized - ); + * given coordianate. + * + * Note that this is not a Gaussian deviate. The evaluated Gaussian is: + * \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + * + * @return float value on the gaussian curve given the input parameters + */ +float psGaussian( + float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev, ///< Standard deviation for the Gaussian + bool normal ///< Indicates whether result should be normalized +); /** Produce a vector of random numbers from a Gaussian distribution with - the specified mean and sigma */ -psVector* psGaussianDev(float mean, ///< The mean of the Gaussian - float sigma, ///< The sigma of the Gaussian - int Npts); ///< The size of the vector + * the specified mean and sigma + * + * @return psVector* vector of random numbers + * + */ +psVector* psGaussianDev( + float mean, ///< The mean of the Gaussian + float sigma, ///< The sigma of the Gaussian + int Npts ///< The size of the vector +); /** One-dimensional polynomial */ typedef struct { - int n; ///< Number of terms - float *coeff; ///< Coefficients - float *coeffErr; ///< Error in coefficients - char *mask; ///< Coefficient mask + int n; ///< Number of terms + float *coeff; ///< Coefficients + float *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask } psPolynomial1D; @@ -59,9 +70,9 @@ typedef struct { - int nX, - nY; ///< Number of terms in x and y - float **coeff; ///< Coefficients - float **coeffErr; ///< Error in coefficients - char **mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + float **coeff; ///< Coefficients + float **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask } psPolynomial2D; @@ -70,10 +81,10 @@ typedef struct { - int nX, - nY, - nZ; ///< Number of terms in x, y and z - float ***coeff; ///< Coefficients - float ***coeffErr; ///< Error in coefficients - char ***mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ***coeff; ///< Coefficients + float ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficients mask } psPolynomial3D; @@ -82,58 +93,94 @@ typedef struct { - int nW, - nX, - nY, - nZ; ///< Number of terms in w, x, y and z - float ****coeff; ///< Coefficients - float ****coeffErr; ///< Error in coefficients - char ****mask; ///< Coefficients mask + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ****coeff; ///< Coefficients + float ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask } psPolynomial4D; -/** Functions **************************************************************/ - -/** Constructor */ -psPolynomial1D* psPolynomial1DAlloc(int n ///< Number of terms - ); - -/** Constructor */ -psPolynomial2D* psPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y - ); - -/** Constructor */ -psPolynomial3D* psPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z - ); - -/** Constructor */ -psPolynomial4D* psPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and - // z - ); - -/** Evaluate 1D polynomial */ -float psPolynomial1DEval(float x, ///< Value at which to evaluate - const psPolynomial1D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 2D polynomial */ -float psPolynomial2DEval(float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - const psPolynomial2D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 3D polynomial */ -float psPolynomial3DEval(float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - float z, ///< Value z at which to evaluate - const psPolynomial3D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 4D polynomial */ -float psPolynomial4DEval(float w, ///< Value w at which to evaluate - float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - float z, ///< Value z at which to evaluate - const psPolynomial4D* myPoly ///< Coefficients for the polynomial - ); + +/** Allocates a psPolynomial1D structure with n terms + * + * @return psPolynomial1D* new 1-D polynomial struct + */ +psPolynomial1D* psPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a 2-D polynomial structure + * + * @return psPolynomial2D* new 2-D polynomial struct + */ +psPolynomial2D* psPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a 3-D polynomial structure + * + * @return psPolynomial3D* new 3-D polynomial struct + */ +psPolynomial3D* psPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a 4-D polynomial structure + * + * @return psPolynomial4D* new 4-D polynomial struct + */ +psPolynomial4D* psPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial1DEval( + float x, ///< location at which to evaluate + const psPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial2DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + const psPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial3DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial4DEval( + float w, ///< w location at which to evaluate + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial4D* myPoly ///< Coefficients for the polynomial +); /*****************************************************************************/ @@ -144,8 +191,8 @@ typedef struct { - int n; ///< Number of terms - double *coeff; ///< Coefficients - double *coeffErr; ///< Error in coefficients - char *mask; ///< Coefficient mask + int n; ///< Number of terms + double *coeff; ///< Coefficients + double *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask } psDPolynomial1D; @@ -154,9 +201,9 @@ typedef struct { - int nX, - nY; ///< Number of terms in x and y - double **coeff; ///< Coefficients - double **coeffErr; ///< Error in coefficients - char **mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + double **coeff; ///< Coefficients + double **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask } psDPolynomial2D; @@ -165,10 +212,10 @@ typedef struct { - int nX, - nY, - nZ; ///< Number of terms in x, y and z - double ***coeff; ///< Coefficients - double ***coeffErr; ///< Error in coefficients - char ***mask; ///< Coefficient mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ***coeff; ///< Coefficients + double ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficient mask } psDPolynomial3D; @@ -177,56 +224,93 @@ typedef struct { - int nW, - nX, - nY, - nZ; ///< Number of terms in w, x, y and z - double ****coeff; ///< Coefficients - double ****coeffErr; ///< Error in coefficients - char ****mask; ///< Coefficients mask + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ****coeff; ///< Coefficients + double ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask } psDPolynomial4D; -/** Constructor */ -psDPolynomial1D* psDPolynomial1DAlloc(int n ///< Number of terms - ); - -/** Constructor */ -psDPolynomial2D* psDPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y - ); - -/** Constructor */ -psDPolynomial3D* psDPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z - ); - -/** Constructor */ -psDPolynomial4D* psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and - // z - ); - -/** Evaluate 1D polynomial (double precision) */ -double psDPolynomial1DEval(double x, ///< Value at which to evaluate - const psDPolynomial1D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 2D polynomial (double precision) */ -double psDPolynomial2DEval(double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - const psDPolynomial2D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 3D polynomial (double precision) */ -double psDPolynomial3DEval(double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - double z, ///< Value z at which to evaluate - const psDPolynomial3D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 4D polynomial (double precision) */ -double psDPolynomial4DEval(double w, ///< Value w at which to evaluate - double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - double z, ///< Value z at which to evaluate - const psDPolynomial4D* myPoly ///< Coefficients for the polynomial - ); +/** Allocates a double-precision 1-D polynomial structure with n terms + * + * @return psPolynomial1D* new double-precision 1-D polynomial struct + */ +psDPolynomial1D* psDPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a double-precision 2-D polynomial structure + * + * @return psPolynomial2D* new double-precision 2-D polynomial struct + */ +psDPolynomial2D* psDPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a double-precision 3-D polynomial structure + * + * @return psPolynomial3D* new double-precision 3-D polynomial struct + */ +psDPolynomial3D* psDPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a double-precision 4-D polynomial structure + * + * @return psPolynomial4D* new double-precision 4-D polynomial struct + */ +psDPolynomial4D* psDPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a double-precision 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial1DEval( + double x, ///< Value at which to evaluate + const psDPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial2DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial3DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial4DEval( + double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D* myPoly ///< Coefficients for the polynomial +); /* \} */// End of MathGroup Functions Index: /trunk/psLib/src/math/psSpline.h =================================================================== --- /trunk/psLib/src/math/psSpline.h (revision 1463) +++ /trunk/psLib/src/math/psSpline.h (revision 1464) @@ -13,6 +13,6 @@ * @author George Gusciora, MHPCC * -* @version $Revision: 1.18 $ $Name: not supported by cvs2svn $ -* @date $Date: 2004-08-09 23:40:55 $ +* @version $Revision: 1.19 $ $Name: not supported by cvs2svn $ +* @date $Date: 2004-08-11 02:35:58 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -31,26 +31,37 @@ /** Evaluate a non-normalized Gaussian with the given mean and sigma at the - given coordianate. Note that this is not a Gaussian deviate. The - evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] */ - -float psGaussian(float x, ///< Value at which to evaluate - float mean, ///< Mean for the Gaussian - float stddev, ///< Standard deviation for the Gaussian - bool normal ///< Indicates whether result should be normalized - ); + * given coordianate. + * + * Note that this is not a Gaussian deviate. The evaluated Gaussian is: + * \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f] + * + * @return float value on the gaussian curve given the input parameters + */ +float psGaussian( + float x, ///< Value at which to evaluate + float mean, ///< Mean for the Gaussian + float stddev, ///< Standard deviation for the Gaussian + bool normal ///< Indicates whether result should be normalized +); /** Produce a vector of random numbers from a Gaussian distribution with - the specified mean and sigma */ -psVector* psGaussianDev(float mean, ///< The mean of the Gaussian - float sigma, ///< The sigma of the Gaussian - int Npts); ///< The size of the vector + * the specified mean and sigma + * + * @return psVector* vector of random numbers + * + */ +psVector* psGaussianDev( + float mean, ///< The mean of the Gaussian + float sigma, ///< The sigma of the Gaussian + int Npts ///< The size of the vector +); /** One-dimensional polynomial */ typedef struct { - int n; ///< Number of terms - float *coeff; ///< Coefficients - float *coeffErr; ///< Error in coefficients - char *mask; ///< Coefficient mask + int n; ///< Number of terms + float *coeff; ///< Coefficients + float *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask } psPolynomial1D; @@ -59,9 +70,9 @@ typedef struct { - int nX, - nY; ///< Number of terms in x and y - float **coeff; ///< Coefficients - float **coeffErr; ///< Error in coefficients - char **mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + float **coeff; ///< Coefficients + float **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask } psPolynomial2D; @@ -70,10 +81,10 @@ typedef struct { - int nX, - nY, - nZ; ///< Number of terms in x, y and z - float ***coeff; ///< Coefficients - float ***coeffErr; ///< Error in coefficients - char ***mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ***coeff; ///< Coefficients + float ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficients mask } psPolynomial3D; @@ -82,58 +93,94 @@ typedef struct { - int nW, - nX, - nY, - nZ; ///< Number of terms in w, x, y and z - float ****coeff; ///< Coefficients - float ****coeffErr; ///< Error in coefficients - char ****mask; ///< Coefficients mask + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + float ****coeff; ///< Coefficients + float ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask } psPolynomial4D; -/** Functions **************************************************************/ - -/** Constructor */ -psPolynomial1D* psPolynomial1DAlloc(int n ///< Number of terms - ); - -/** Constructor */ -psPolynomial2D* psPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y - ); - -/** Constructor */ -psPolynomial3D* psPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z - ); - -/** Constructor */ -psPolynomial4D* psPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and - // z - ); - -/** Evaluate 1D polynomial */ -float psPolynomial1DEval(float x, ///< Value at which to evaluate - const psPolynomial1D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 2D polynomial */ -float psPolynomial2DEval(float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - const psPolynomial2D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 3D polynomial */ -float psPolynomial3DEval(float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - float z, ///< Value z at which to evaluate - const psPolynomial3D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 4D polynomial */ -float psPolynomial4DEval(float w, ///< Value w at which to evaluate - float x, ///< Value x at which to evaluate - float y, ///< Value y at which to evaluate - float z, ///< Value z at which to evaluate - const psPolynomial4D* myPoly ///< Coefficients for the polynomial - ); + +/** Allocates a psPolynomial1D structure with n terms + * + * @return psPolynomial1D* new 1-D polynomial struct + */ +psPolynomial1D* psPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a 2-D polynomial structure + * + * @return psPolynomial2D* new 2-D polynomial struct + */ +psPolynomial2D* psPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a 3-D polynomial structure + * + * @return psPolynomial3D* new 3-D polynomial struct + */ +psPolynomial3D* psPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a 4-D polynomial structure + * + * @return psPolynomial4D* new 4-D polynomial struct + */ +psPolynomial4D* psPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial1DEval( + float x, ///< location at which to evaluate + const psPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial2DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + const psPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial3DEval( + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +float psPolynomial4DEval( + float w, ///< w location at which to evaluate + float x, ///< x location at which to evaluate + float y, ///< y location at which to evaluate + float z, ///< z location at which to evaluate + const psPolynomial4D* myPoly ///< Coefficients for the polynomial +); /*****************************************************************************/ @@ -144,8 +191,8 @@ typedef struct { - int n; ///< Number of terms - double *coeff; ///< Coefficients - double *coeffErr; ///< Error in coefficients - char *mask; ///< Coefficient mask + int n; ///< Number of terms + double *coeff; ///< Coefficients + double *coeffErr; ///< Error in coefficients + char *mask; ///< Coefficient mask } psDPolynomial1D; @@ -154,9 +201,9 @@ typedef struct { - int nX, - nY; ///< Number of terms in x and y - double **coeff; ///< Coefficients - double **coeffErr; ///< Error in coefficients - char **mask; ///< Coefficients mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + double **coeff; ///< Coefficients + double **coeffErr; ///< Error in coefficients + char **mask; ///< Coefficients mask } psDPolynomial2D; @@ -165,10 +212,10 @@ typedef struct { - int nX, - nY, - nZ; ///< Number of terms in x, y and z - double ***coeff; ///< Coefficients - double ***coeffErr; ///< Error in coefficients - char ***mask; ///< Coefficient mask + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ***coeff; ///< Coefficients + double ***coeffErr; ///< Error in coefficients + char ***mask; ///< Coefficient mask } psDPolynomial3D; @@ -177,56 +224,93 @@ typedef struct { - int nW, - nX, - nY, - nZ; ///< Number of terms in w, x, y and z - double ****coeff; ///< Coefficients - double ****coeffErr; ///< Error in coefficients - char ****mask; ///< Coefficients mask + int nW; ///< Number of terms in w + int nX; ///< Number of terms in x + int nY; ///< Number of terms in y + int nZ; ///< Number of terms in z + double ****coeff; ///< Coefficients + double ****coeffErr; ///< Error in coefficients + char ****mask; ///< Coefficients mask } psDPolynomial4D; -/** Constructor */ -psDPolynomial1D* psDPolynomial1DAlloc(int n ///< Number of terms - ); - -/** Constructor */ -psDPolynomial2D* psDPolynomial2DAlloc(int nX, int nY ///< Number of terms in x and y - ); - -/** Constructor */ -psDPolynomial3D* psDPolynomial3DAlloc(int nX, int nY, int nZ ///< Number of terms in x, y and z - ); - -/** Constructor */ -psDPolynomial4D* psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ ///< Number of terms in w, x, y and - // z - ); - -/** Evaluate 1D polynomial (double precision) */ -double psDPolynomial1DEval(double x, ///< Value at which to evaluate - const psDPolynomial1D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 2D polynomial (double precision) */ -double psDPolynomial2DEval(double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - const psDPolynomial2D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 3D polynomial (double precision) */ -double psDPolynomial3DEval(double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - double z, ///< Value z at which to evaluate - const psDPolynomial3D* myPoly ///< Coefficients for the polynomial - ); - -/** Evaluate 4D polynomial (double precision) */ -double psDPolynomial4DEval(double w, ///< Value w at which to evaluate - double x, ///< Value x at which to evaluate - double y, ///< Value y at which to evaluate - double z, ///< Value z at which to evaluate - const psDPolynomial4D* myPoly ///< Coefficients for the polynomial - ); +/** Allocates a double-precision 1-D polynomial structure with n terms + * + * @return psPolynomial1D* new double-precision 1-D polynomial struct + */ +psDPolynomial1D* psDPolynomial1DAlloc( + int n ///< Number of terms +); + +/** Allocates a double-precision 2-D polynomial structure + * + * @return psPolynomial2D* new double-precision 2-D polynomial struct + */ +psDPolynomial2D* psDPolynomial2DAlloc( + int nX, ///< Number of terms in x + int nY ///< Number of terms in y +); + +/** Allocates a double-precision 3-D polynomial structure + * + * @return psPolynomial3D* new double-precision 3-D polynomial struct + */ +psDPolynomial3D* psDPolynomial3DAlloc( + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Allocates a double-precision 4-D polynomial structure + * + * @return psPolynomial4D* new double-precision 4-D polynomial struct + */ +psDPolynomial4D* psDPolynomial4DAlloc( + int nW, ///< Number of terms in w + int nX, ///< Number of terms in x + int nY, ///< Number of terms in y + int nZ ///< Number of terms in z +); + +/** Evaluates a double-precision 1-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial1DEval( + double x, ///< Value at which to evaluate + const psDPolynomial1D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 2-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial2DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + const psDPolynomial2D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 3-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial3DEval( + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial3D* myPoly ///< Coefficients for the polynomial +); + +/** Evaluates a double-precision 4-D polynomial at specific coordinates. + * + * @return float result of polynomial at given location + */ +double psDPolynomial4DEval( + double w, ///< Value w at which to evaluate + double x, ///< Value x at which to evaluate + double y, ///< Value y at which to evaluate + double z, ///< Value z at which to evaluate + const psDPolynomial4D* myPoly ///< Coefficients for the polynomial +); /* \} */// End of MathGroup Functions