Index: trunk/psLib/test/dataManip/tst_psFunc00.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc00.c (revision 4528) +++ (revision ) @@ -1,642 +1,0 @@ -/** tst_Func00.c -* -* This routine must ensure that the psPolynomial structures are -* allocated and deallocated by the psPolynomialXXXlloc() procedures. -* It also calls the various psPolynomialXXXEval() procedures. -* -* The F32 and F64 polynomials are tested for all orders (1 - 4) and for -* both ordinary and chebyshev polynomials. -* -* NOTE: This test code requries the stdout file to verify that the results -* are good. -* -* XXX: Modify these tests so that polynomials with a variety of different -* orders are created. -* -* @version $Revision: 1.23 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-29 03:23:19 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -* -*****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" - -// Defines -#define ORDER 3 - -static psS32 testPolynomial1DAlloc(void); -static psS32 testPolynomial2DAlloc(void); -static psS32 testPolynomial3DAlloc(void); -static psS32 testPolynomial4DAlloc(void); -static psS32 testDPolynomial1DAlloc(void); -static psS32 testDPolynomial2DAlloc(void); -static psS32 testDPolynomial3DAlloc(void); -static psS32 testDPolynomial4DAlloc(void); - -testDescription tests[] = { - {testPolynomial1DAlloc,578,"psPolynomial1DAlloc",0,false}, - {testPolynomial2DAlloc,578,"psPolynomial2DAlloc",0,false}, - {testPolynomial3DAlloc,578,"psPolynomial3DAlloc",0,false}, - {testPolynomial4DAlloc,578,"psPolynomial4DAlloc",0,false}, - {testDPolynomial1DAlloc,579,"psDPolynomial1DAlloc",0,false}, - {testDPolynomial2DAlloc,579,"psDPolynomial2DAlloc",0,false}, - {testDPolynomial3DAlloc,579,"psDPolynomial3DAlloc",0,false}, - {testDPolynomial4DAlloc,579,"psDPolynomial4DAlloc",0,false}, - {NULL} - }; - - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - - return !runTestSuite(stderr,"psPolynomialXD", tests, argc, argv); -} - - -// This test will allocate a 1D polynomial and verify the structure allocated -psS32 testPolynomial1DAlloc(void) -{ - psPolynomial1D* my1DPoly = NULL; - - // Allocate polynomial - my1DPoly = psPolynomial1DAlloc(ORDER,PS_POLYNOMIAL_ORD); - // Verify structure allocated - if(my1DPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my1DPoly->n != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my1DPoly->n, ORDER); - return 2; - } - if(my1DPoly->type != PS_POLYNOMIAL_ORD) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my1DPoly->type, PS_POLYNOMIAL_ORD); - return 3; - } - for(psS32 i = 0; i < ORDER; i++) { - if(my1DPoly->coeff[i] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg", - i, my1DPoly->coeff[i], 0.0); - return 4; - } - if(my1DPoly->coeffErr[i] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d] %lg not as expected %lg", - i, my1DPoly->coeffErr[i], 0.0); - return 5; - } - if(my1DPoly->mask[i] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d] %d not as expected %d", - i, my1DPoly->mask[i], 0); - return 6; - } - } - psFree(my1DPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial1DAlloc(-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 7; - } - */ - return 0; -} - -// This test will allocate a 1D polynomial and verify the structure allocated -psS32 testDPolynomial1DAlloc(void) -{ - psDPolynomial1D* my1DDPoly = NULL; - - // Allocate polynomial - my1DDPoly = psDPolynomial1DAlloc(ORDER,PS_POLYNOMIAL_CHEB); - // Verify structure allocated - if(my1DDPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my1DDPoly->n != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my1DDPoly->n, ORDER); - return 2; - } - if(my1DDPoly->type != PS_POLYNOMIAL_CHEB) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my1DDPoly->type, PS_POLYNOMIAL_CHEB); - return 3; - } - for(psS32 i = 0; i < ORDER; i++) { - if(my1DDPoly->coeff[i] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg", - i, my1DDPoly->coeff[i], 0.0); - return 4; - } - if(my1DDPoly->coeffErr[i] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d] %lg not as expected %lg", - i, my1DDPoly->coeffErr[i], 0.0); - return 5; - } - if(my1DDPoly->mask[i] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d] %d not as expected %d", - i, my1DDPoly->mask[i], 0); - return 6; - } - } - psFree(my1DDPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial1DAlloc(-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 7; - } - */ - return 0; -} - -// This test will allocate a 2D polynomial and verify the structure allocated -psS32 testPolynomial2DAlloc(void) -{ - psPolynomial2D* my2DPoly = NULL; - - // Allocate polynomial - my2DPoly = psPolynomial2DAlloc(ORDER,ORDER+1,PS_POLYNOMIAL_ORD); - // Verify structure allocated - if(my2DPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my2DPoly->nX != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my2DPoly->nX, ORDER); - return 2; - } - // Verify polynomial structure members set properly - if(my2DPoly->nY != ORDER+1) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my2DPoly->nY, ORDER+1); - return 3; - } - if(my2DPoly->type != PS_POLYNOMIAL_ORD) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my2DPoly->type, PS_POLYNOMIAL_ORD); - return 4; - } - for(psS32 i = 0; i < ORDER; i++) { - for(psS32 j = 0; j < ORDER+1; j++) { - if(my2DPoly->coeff[i][j] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg", - i, j, my2DPoly->coeff[i][j], 0.0); - return 5; - } - if(my2DPoly->coeffErr[i][j] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d] %lg not as expected %lg", - i, j, my2DPoly->coeffErr[i][j], 0.0); - return 6; - } - if(my2DPoly->mask[i][j] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d", - i, j, my2DPoly->mask[i][j], 0); - return 7; - } - } - } - psFree(my2DPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial2DAlloc(-1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 8; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 9; - } - */ - return 0; -} - -// This test will allocate a 2D polynomial and verify the structure allocated -psS32 testDPolynomial2DAlloc(void) -{ - psDPolynomial2D* my2DDPoly = NULL; - - // Allocate polynomial - my2DDPoly = psDPolynomial2DAlloc(ORDER,ORDER+1,PS_POLYNOMIAL_CHEB); - // Verify structure allocated - if(my2DDPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my2DDPoly->nX != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my2DDPoly->nX, ORDER); - return 2; - } - // Verify polynomial structure members set properly - if(my2DDPoly->nY != ORDER+1) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my2DDPoly->nY, ORDER+1); - return 3; - } - if(my2DDPoly->type != PS_POLYNOMIAL_CHEB) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my2DDPoly->type, PS_POLYNOMIAL_ORD); - return 4; - } - for(psS32 i = 0; i < ORDER; i++) { - for(psS32 j = 0; j < ORDER+1; j++) { - if(my2DDPoly->coeff[i][j] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg", - i, j, my2DDPoly->coeff[i][j], 0.0); - return 5; - } - if(my2DDPoly->coeffErr[i][j] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d] %lg not as expected %lg", - i, j, my2DDPoly->coeffErr[i][j], 0.0); - return 6; - } - if(my2DDPoly->mask[i][j] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d", - i, j, my2DDPoly->mask[i][j], 0); - return 7; - } - } - } - psFree(my2DDPoly); - /* - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial2DAlloc(-1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 8; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 9; - } - */ - return 0; -} - -// This test will allocate a 3D polynomial and verify the structure allocated -psS32 testPolynomial3DAlloc(void) -{ - psPolynomial3D* my3DPoly = NULL; - - // Allocate polynomial - my3DPoly = psPolynomial3DAlloc(ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD); - // Verify structure allocated - if(my3DPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my3DPoly->nX != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my3DPoly->nX, ORDER); - return 2; - } - // Verify polynomial structure members set properly - if(my3DPoly->nY != ORDER+1) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my3DPoly->nY, ORDER+1); - return 3; - } - // Verify polynomial structure members set properly - if(my3DPoly->nZ != ORDER+2) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my3DPoly->nZ, ORDER+2); - return 4; - } - if(my3DPoly->type != PS_POLYNOMIAL_ORD) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my3DPoly->type, PS_POLYNOMIAL_ORD); - return 5; - } - for(psS32 i = 0; i < ORDER; i++) { - for(psS32 j = 0; j < ORDER+1; j++) { - for(psS32 k = 0; k < ORDER+2; k++) { - if(my3DPoly->coeff[i][j][k] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg", - i, j, k, my3DPoly->coeff[i][j][k], 0.0); - return 6; - } - if(my3DPoly->coeffErr[i][j][k] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d] %lg not as expected %lg", - i, j, k, my3DPoly->coeffErr[i][j][k], 0.0); - return 7; - } - if(my3DPoly->mask[i][j][k] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d", - i, j, k, my3DPoly->mask[i][j][k], 0); - return 8; - } - } - } - } - psFree(my3DPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial3DAlloc(-1,1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 9; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial3DAlloc(1,-1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 10; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 11; - } - */ - return 0; -} - -// This test will allocate a 3D polynomial and verify the structure allocated -psS32 testDPolynomial3DAlloc(void) -{ - psDPolynomial3D* my3DDPoly = NULL; - - // Allocate polynomial - my3DDPoly = psDPolynomial3DAlloc(ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_CHEB); - // Verify structure allocated - if(my3DDPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my3DDPoly->nX != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my3DDPoly->nX, ORDER); - return 2; - } - // Verify polynomial structure members set properly - if(my3DDPoly->nY != ORDER+1) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my3DDPoly->nY, ORDER+1); - return 3; - } - // Verify polynomial structure members set properly - if(my3DDPoly->nZ != ORDER+2) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my3DDPoly->nZ, ORDER+2); - return 4; - } - if(my3DDPoly->type != PS_POLYNOMIAL_CHEB) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my3DDPoly->type, PS_POLYNOMIAL_ORD); - return 5; - } - for(psS32 i = 0; i < ORDER; i++) { - for(psS32 j = 0; j < ORDER+1; j++) { - for(psS32 k = 0; k < ORDER+2; k++) { - if(my3DDPoly->coeff[i][j][k] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg", - i, j, k, my3DDPoly->coeff[i][j][k], 0.0); - return 6; - } - if(my3DDPoly->coeffErr[i][j][k] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d] %lg not as expected %lg", - i, j, k, my3DDPoly->coeffErr[i][j][k], 0.0); - return 7; - } - if(my3DDPoly->mask[i][j][k] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d", - i, j, k, my3DDPoly->mask[i][j][k], 0); - return 8; - } - } - } - } - psFree(my3DDPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial3DAlloc(-1,1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 9; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial3DAlloc(1,-1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 10; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 11; - } - */ - return 0; -} - -// This test will allocate a 4D polynomial and verify the structure allocated -psS32 testPolynomial4DAlloc(void) -{ - psPolynomial4D* my4DPoly = NULL; - - // Allocate polynomial - my4DPoly = psPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD); - // Verify structure allocated - if(my4DPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my4DPoly->nY != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DPoly->nY, ORDER); - return 2; - } - // Verify polynomial structure members set properly - if(my4DPoly->nZ != ORDER+1) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DPoly->nZ, ORDER+1); - return 3; - } - // Verify polynomial structure members set properly - if(my4DPoly->nT != ORDER+2) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DPoly->nT, ORDER+2); - return 4; - } - // Verify polynomial structure members set properly - if(my4DPoly->nX != ORDER+3) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DPoly->nX, ORDER+3); - return 5; - } - if(my4DPoly->type != PS_POLYNOMIAL_ORD) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my4DPoly->type, PS_POLYNOMIAL_ORD); - return 6; - } - for(psS32 i = 0; i < ORDER+3; i++) { - for(psS32 j = 0; j < ORDER; j++) { - for(psS32 k = 0; k < ORDER+1; k++) { - for(psS32 l = 0; l < ORDER+2; l++) { - if(my4DPoly->coeff[i][j][k][l] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d][%d] %lg not as expected %lg", - i, j, k, l, my4DPoly->coeff[i][j][k][l], 0.0); - return 7; - } - if(my4DPoly->coeffErr[i][j][k][l] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d][l] %lg not as expected %lg", - i, j, k, l, my4DPoly->coeffErr[i][j][k][l], 0.0); - return 8; - } - if(my4DPoly->mask[i][j][k][l] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d][%d][%d] %d not as expected %d", - i, j, k, l, my4DPoly->mask[i][j][k][l], 0); - return 9; - } - } - } - } - } - psFree(my4DPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial4DAlloc(-1,1,1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 10; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial4DAlloc(1,-1,1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 11; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial4DAlloc(1,1,-1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 12; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psPolynomial4DAlloc(1,1,1,-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 13; - } - */ - return 0; -} - -// This test will allocate a 4D polynomial and verify the structure allocated -psS32 testDPolynomial4DAlloc(void) -{ - psDPolynomial4D* my4DDPoly = NULL; - - // Allocate polynomial - my4DDPoly = psDPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD); - // Verify structure allocated - if(my4DDPoly == NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); - return 1; - } - // Verify polynomial structure members set properly - if(my4DDPoly->nY != ORDER) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DDPoly->nY, ORDER); - return 2; - } - // Verify polynomial structure members set properly - if(my4DDPoly->nZ != ORDER+1) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DDPoly->nZ, ORDER+1); - return 3; - } - // Verify polynomial structure members set properly - if(my4DDPoly->nT != ORDER+2) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DDPoly->nT, ORDER+2); - return 4; - } - // Verify polynomial structure members set properly - if(my4DDPoly->nX != ORDER+3) { - psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d", - my4DDPoly->nX, ORDER+3); - return 5; - } - if(my4DDPoly->type != PS_POLYNOMIAL_ORD) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", - my4DDPoly->type, PS_POLYNOMIAL_ORD); - return 6; - } - for(psS32 i = 0; i < ORDER+3; i++) { - for(psS32 j = 0; j < ORDER; j++) { - for(psS32 k = 0; k < ORDER+1; k++) { - for(psS32 l = 0; l < ORDER+2; l++) { - if(my4DDPoly->coeff[i][j][k][l] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d][%d] %lg not as expected %lg", - i, j, k, l, my4DDPoly->coeff[i][j][k][l], 0.0); - return 7; - } - if(my4DDPoly->coeffErr[i][j][k][l] != 0.0) { - psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d][l] %lg not as expected %lg", - i, j, k, l, my4DDPoly->coeffErr[i][j][k][l], 0.0); - return 8; - } - if(my4DDPoly->mask[i][j][k][l] != 0) { - psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d][%d][%d] %d not as expected %d", - i, j, k, l, my4DDPoly->mask[i][j][k][l], 0); - return 9; - } - } - } - } - } - psFree(my4DDPoly); - - /* // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial4DAlloc(-1,1,1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 10; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial4DAlloc(1,-1,1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 11; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial4DAlloc(1,1,-1,1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 12; - } - // Attempt to allocate with negative order - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms"); - if(psDPolynomial4DAlloc(1,1,1,-1,PS_POLYNOMIAL_ORD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL"); - return 13; - } - */ - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psFunc01.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc01.c (revision 4528) +++ (revision ) @@ -1,76 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psGaussian() shall evaluate a - specified Gaussian at some X. - - It also tests the p_psGaussianDev() procedure. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psFunctions.h" -#define MY_MEAN 30.0 -#define MY_STDEV 2.0 -#define N 30 -psS32 main() -{ - psS32 testStatus = true; - float x = 0.0; - psS32 memLeaks; - psS32 currentId = psMemGetId(); - psVector *myGaussData = NULL; - printPositiveTestHeader(stdout, - "psFunctions functions", - "psGaussian()"); - - - for (x = 0.0 ; x < (MY_MEAN * 2.0) ; x+= 1.0) { - printf("normal psGaussian(%f) is %f\n", x, psGaussian(x, MY_MEAN, MY_STDEV, true)); - x = x + 1.0; - } - - for (x = 0.0 ; x < (MY_MEAN * 2.0) ; x+= 1.0) { - printf("NON-normal psGaussian(%f) is %f\n", x, psGaussian(x, MY_MEAN, MY_STDEV, false)); - x = x + 1.0; - } - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psGaussian()", - testStatus); - - - printPositiveTestHeader(stdout, - "psFunctions functions", - "p_psGaussianDev()"); - - myGaussData = p_psGaussianDev(MY_MEAN, MY_STDEV, N); - for (psS32 i = 0; i < N ; i++) { - printf("Gaussian Deviate [%d] is %f\n", i, myGaussData->data.F32[i]); - } - - if ( myGaussData->type.type != PS_TYPE_F32) { - psAbort(__func__,"p_psGaussianDev did not return a vector of type F32"); - } - - psFree(myGaussData); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "p_psGaussianDev()", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psFunc02.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc02.c (revision 4528) +++ (revision ) @@ -1,446 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DAlloc() function properly - allocates the spline data structure. It allocates both linear and cubic - splines with a variety of min/max ranges. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psFunctions.h" - -#define N 4 -#define LINEAR 1 -#define CUBIC 3 - -psS32 main() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector* bounds; - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): linear, normal"); - - tmpSpline = psSpline1DAlloc(N, LINEAR, 1.0, 10.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != LINEAR+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(): linear, normal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): linear, min/max are equal"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAlloc(N, LINEAR, 1.0, 1.0); - - if (tmpSpline != NULL) { - printf("ERROR: allocated psSpline1D data structure when min==max\n"); - testStatus = false; - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(): linear, min/max are equal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): linear, min > max."); - - tmpSpline = psSpline1DAlloc(N, LINEAR, 1.0, -1.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != LINEAR+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(): linear, min > max.", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(), cubic, normal"); - - tmpSpline = psSpline1DAlloc(N, CUBIC, 1.0, 10.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != CUBIC+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;idata.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(): cubic, normal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): cubic, min/max are equal"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - tmpSpline = psSpline1DAlloc(N, CUBIC, 1.0, 1.0); - - if (tmpSpline != NULL) { - printf("ERROR: allocated psSpline1D data structure when min==max\n"); - testStatus = false; - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(): cubic, min/max are equal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): cubic, min > max."); - - tmpSpline = psSpline1DAlloc(N, CUBIC, 1.0, -1.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != CUBIC+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(): cubic, min > max.", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): linear, normal"); - - bounds = psVectorAlloc(5,PS_TYPE_F32); - bounds->n = bounds->nalloc; - for(psU32 n = 0; n < 5; n++ ) { - bounds->data.F32[n] = (n+1) * 2; - } - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != LINEAR+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - psFree(bounds); - psFree(tmpSpline); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psFunctions functions", - "psSpline1DAllocGeneric(): linear, normal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - ///XXX: REMOVED FOLLOWING TEST AFTER CHANGING TO UNSIGNED INT/// - /* testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): negative order"); - - bounds = psVectorAlloc(5,PS_TYPE_F32); - bounds->n = bounds->nalloc; - for(psU32 n = 0; n < 5; n++ ) { - bounds->data.F32[n] = (n+1) * 2; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAllocGeneric(bounds, -1); - if (tmpSpline != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return null for negative order"); - return 10; - } - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psFunctions functions", - "psSpline1DAllocGeneric(): negative order", - testStatus); - */ - psFree(bounds); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): bound equal to NULL"); - - bounds = NULL; - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return null for bounds equal to NULL"); - return 20; - } - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psFunctions functions", - "psSpline1DAllocGeneric(): bound equal to NULL", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): bounds with zero elements"); - - bounds = psVectorAlloc(5,PS_TYPE_F32); - bounds->n = 0; - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return null for negative order"); - return 30; - } - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psFunctions functions", - "psSpline1DAllocGeneric(): bounds with zero elements", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psFunc03.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc03.c (revision 4528) +++ (revision ) @@ -1,150 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DAllocGeneric() function properly - allocates the spline data structure. - - XXX: test bounds? - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psFunctions.h" - -#define N 10 -#define LINEAR 1 -#define CUBIC 3 - -psS32 main() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *bounds; - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): linear"); - bounds = psVectorAlloc(N+1, PS_TYPE_F32); - for (i=0;idata.F32[i] = (float) (3 * i); - } - - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != LINEAR+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[i] != bounds->data.F32[i]) { - printf("ERROR: psSpline1D->knots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - } - - psFree(tmpSpline); - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAllocGeneric(): linear", - testStatus); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): cubic"); - bounds = psVectorAlloc(N+1, PS_TYPE_F32); - for (i=0;idata.F32[i] = (float) (3 * i); - } - - tmpSpline = psSpline1DAllocGeneric(bounds, CUBIC); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->n != CUBIC+1) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[i] != bounds->data.F32[i]) { - printf("ERROR: psSpline1D->knots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - } - - psFree(tmpSpline); - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAllocGeneric(): cubic", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psFunc04.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc04.c (revision 4528) +++ (revision ) @@ -1,133 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DEval() function works - properly. It creates a spline with psSpline1DAlloc(), creates a set of - data values, sets the spline polynomials with psVectorFitSpline1D(), then - calls psSpline1DEval() on new data values and ensures that the results - are correct. - - XXX: figure out the memory deallocator - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psFunctions.h" - -#define N 8 - -psS32 t00() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - float x; - float y; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *data; - - psTraceSetLevel(".", 0); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc()"); - data = psVectorAlloc(N+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(N, 1, 1.0, 10.0); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - } - psVectorFitSpline1D(tmpSpline, data, data, NULL); - - for (i=0;i FLT_EPSILON) { - printf("ERROR: f(%f) is %f\n", x, y); - testStatus = true; - } - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - psFree(data); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc()", - testStatus); - - return (!testStatus); -} - -psS32 t01() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - float x; - float y; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *data; - - psTraceSetLevel(".", 0); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc()"); - data = psVectorAlloc(N+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(N, 1, 1.0, 10.0); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - } - psVectorFitSpline1D(tmpSpline, data, data, NULL); - - for (i=0;i FLT_EPSILON) { - printf("ERROR: f(%f) is %f\n", x, y); - testStatus = true; - } - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - psFree(data); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc()", - testStatus); - - return (!testStatus); -} - -psS32 main() -{ - t00(); - // t01(); -} Index: trunk/psLib/test/dataManip/tst_psFunc05.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc05.c (revision 4528) +++ (revision ) @@ -1,82 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DEvalVector() function works - properly. It creates a spline with psSpline1DAlloc(), (1-D functions - are used for the spline polynomials) creates a set of data values, sets - the spline polynomials with psVectorFitSpline1D(), then calls - psSpline1DEvalVector() on new data values and ensures that the results - are correct. - - XXX: Only F32 types are tested here. F64 types are tested elsewhere. - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psFunctions.h" -#define N 8 -#define SPLINE_ORDER 1 - -psS32 main() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *data; - psVector *x; - psVector *y; - - psTraceSetLevel(".", 0); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc()"); - data = psVectorAlloc(N+1, PS_TYPE_F32); - x = psVectorAlloc(N+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(N, SPLINE_ORDER, 1.0, 10.0); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - } - - psVectorFitSpline1D(tmpSpline, data, data, NULL); - - for (i=0;idata.F32[i] = 0.5 + (float) i+1; - } - - y = psSpline1DEvalVector( - tmpSpline, - x - ); - - for (i=0;idata.F32[i]-y->data.F32[i]) > FLT_EPSILON) { - printf("ERROR: f(%f) is %f\n", x->data.F32[i], y->data.F32[i]); - testStatus = true; - } - } - - psFree(tmpSpline); - - psFree(x); - psFree(y); - psFree(data); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc()", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psFunc07.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc07.c (revision 4528) +++ (revision ) @@ -1,181 +1,0 @@ -/***************************************************************************** -This routine must ensure that the psVectorFitSpline1D() function works -properly. It creates a spline with psSpline1DAlloc(), creates a set of data -values, sets the spline polynomials with psVectorFitSpline1D(), then calls -psSpline1DEval() on new data values and ensures that the results are correct. - -F32 and F64 versions are used here. - -XXX: The spline eval functions are F32 only, while the spline fit functions -are F32 and F64. - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psFunctions.h" - -#define NUM_SPLINES 50 -#define A 4.0 -#define B -3.0 -#define C 0.2 -#define D 0.1 -#define MIN 1.0 -#define MAX 30 -#define ERROR_TOLERANCE 0.10 -#define OFFSET (NUM_SPLINES * ERROR_TOLERANCE) - -float myFunc(float x) -{ - return(A + x * (B + x * (C + x * (D)))); -} - -psS32 t00() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 currentId = psMemGetId(); - psS32 i; - psSpline1D *tmpSpline = NULL; - psVector *x = NULL; - psVector *newX = NULL; - psVector *y = NULL; - psVector *newY = NULL; - - psTraceSetLevel(".", 0); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - x = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F32); - newX = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F32); - y = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(NUM_SPLINES, 3, MIN, MAX); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - y->data.F32[i] = myFunc(x->data.F32[i]); - } - - for (i=0;idata.F32[i]= ((x->data.F32[i] + x->data.F32[i+1])/2.0); - } - newX->data.F32[NUM_SPLINES] = x->data.F32[NUM_SPLINES]; - /****************************************************************************/ - /* psLib Code */ - /****************************************************************************/ - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F32 versions"); - - psVectorFitSpline1D(tmpSpline, x, y, NULL); - newY = psSpline1DEvalVector( - tmpSpline, - newX - ); - - for (i=OFFSET;idata.F32[i] - myFunc(newX->data.F32[i]) ) > fabs( ERROR_TOLERANCE * myFunc(newX->data.F32[i]) ) ) { - printf("ERROR[%d]: f(%f) is %f. Should be %f\n", i, - newX->data.F32[i], newY->data.F32[i], myFunc(newX->data.F32[i])); - testStatus = false; - } - } - - psFree(x); - psFree(newX); - psFree(y); - psFree(tmpSpline); - psFree(newY); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F32 versions", - testStatus); - - return (!testStatus); -} - -// This is the F64 version of the above test code. -psS32 t01() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 currentId = psMemGetId(); - psS32 i; - psSpline1D *tmpSpline = NULL; - psVector *x = NULL; - psVector *newX = NULL; - psVector *y = NULL; - psVector *newY = NULL; - - psTraceSetLevel(".", 0); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - x = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F64); - newX = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F64); - y = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F64); - tmpSpline = psSpline1DAlloc(NUM_SPLINES, 3, MIN, MAX); - - for (i=0;idata.F64[i] = tmpSpline->knots->data.F32[i]; - y->data.F64[i] = myFunc(x->data.F64[i]); - } - - for (i=0;idata.F64[i]= ((x->data.F64[i] + x->data.F64[i+1])/2.0); - } - newX->data.F64[NUM_SPLINES] = x->data.F64[NUM_SPLINES]; - /****************************************************************************/ - /* psLib Code */ - /****************************************************************************/ - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F64 versions"); - - psVectorFitSpline1D(tmpSpline, x, y, NULL); - newY = psSpline1DEvalVector( - tmpSpline, - newX - ); - - for (i=OFFSET;idata.F32[i] - myFunc(newX->data.F64[i]) ) > fabs( ERROR_TOLERANCE * myFunc((float)newX->data.F64[i]) ) ) { - printf("ERROR[%d]: f(%f) is %f. Should be %f\n", i, - newX->data.F64[i], newY->data.F32[i], myFunc((float)newX->data.F64[i])); - testStatus = false; - } - } - - psFree(x); - psFree(newX); - psFree(y); - psFree(tmpSpline); - psFree(newY); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psFunctions functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F64 versions", - testStatus); - - return (!testStatus); -} - -psS32 main() -{ - // t00(); - t01(); -} Index: trunk/psLib/test/dataManip/tst_psFunc08.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc08.c (revision 4528) +++ (revision ) @@ -1,334 +1,0 @@ -/** tst_psFunc08.c -* -* This test driver will exercise the psPolynomialXDEval functions for both -* ORD and CHEB type polynomials. -* -* @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-05-19 22:50:05 $ -* -* XXX: Probably should test single- and multi-dimensional polynomials in -* which one diminsion is constant (n == 1). -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -* -***************************************************************************/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TERMS 4 -#define TESTPOINTS 5 -#define ERROR_TOL 0.001 - -static psS32 testPoly1DEval(void); -static psS32 testDPoly1DEval(void); -static psS32 testPoly1DEvalVector(void); -static psS32 testDPoly1DEvalVector(void); - -testDescription tests[] = { - {testPoly1DEval,000,"psPolynomial1DEval",0,false}, - {testDPoly1DEval,000,"psDPolynomial1DEval",0,false}, - {testPoly1DEvalVector,000,"psPolynomial1DEvalVector",0,false}, - {testDPoly1DEvalVector,000,"psDPolynomial1DEvalVector",0,false}, - {NULL} - }; - -psF32 poly1DCoeff[TERMS] = { -4.3, 2.3, -3.2, 1.9}; -psF64 Dpoly1DCoeff[TERMS] = { -4.3, 2.3, -3.2, 1.9}; -psF32 poly1DMask[TERMS] = { 0, 0, 1, 0 }; - -psF32 poly1DXValue[TESTPOINTS] = { 2.550000, -9.8000, 0.00134, -12.2500, 0.000}; -psF64 Dpoly1DXValue[TESTPOINTS] = { 2.550000, -9.8000, 0.00134, -12.2500, 0.000}; -psF32 poly1DXResult[TESTPOINTS] = {33.069613, -1815.1048, -4.296918, -3525.1797, -4.3000}; -psF64 Dpoly1DXResult[TESTPOINTS] = {33.069613, -1815.1048, -4.296918, -3525.1797, -4.3000}; - -psF32 poly1DXChebValue[TESTPOINTS] = { -0.99, -0.33, 0.125, 0.564, 0.875}; -psF64 Dpoly1DXChebValue[TESTPOINTS] = { -0.99, -0.33, 0.125, 0.564, 0.875}; -psF32 poly1DXChebResult[TESTPOINTS] = { -1.401196, 1.016252, 0.257813, 0.089625, 1.429688}; -psF64 Dpoly1DXChebResult[TESTPOINTS] = { -1.401196, 1.016252, 0.257813, 0.089625, 1.429688}; - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - - return !runTestSuite(stderr,"psPolynomialXDEval", tests, argc, argv); -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testPoly1DEval(void) -{ - psF32 result; - psF32 resultCheb; - - // Allocate polynomial structure - psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD); - psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - polyOrd->coeff[i] = poly1DCoeff[i]; - polyOrd->mask[i] = poly1DMask[i]; - polyCheb->coeff[i] = 1.0; - polyCheb->mask[i] = poly1DMask[i]; - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psPolynomial1DEval(polyOrd,poly1DXValue[i]); - if(fabs(poly1DXResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %g not as expected %g", - result, poly1DXResult[i]); - return i; - } - resultCheb = psPolynomial1DEval(polyCheb,poly1DXChebValue[i]); - if(fabs(poly1DXChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, poly1DXChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psPolynomial1DAlloc(TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psPolynomial1DEval(polyOrd,0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testDPoly1DEval(void) -{ - psF64 result; - psF64 resultCheb; - - // Allocate polynomial structure - psDPolynomial1D* polyOrd = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD); - psDPolynomial1D* polyCheb = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - polyOrd->coeff[i] = Dpoly1DCoeff[i]; - polyOrd->mask[i] = poly1DMask[i]; - polyCheb->coeff[i] = 1.0; - polyCheb->mask[i] = poly1DMask[i]; - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psDPolynomial1DEval(polyOrd,Dpoly1DXValue[i]); - if(fabs(Dpoly1DXResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg", - result, Dpoly1DXResult[i]); - return i; - } - resultCheb = psDPolynomial1DEval(polyCheb,Dpoly1DXChebValue[i]); - if(fabs(Dpoly1DXChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, Dpoly1DXChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psDPolynomial1DAlloc(TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psDPolynomial1DEval(polyOrd,0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -psS32 testPoly1DEvalVector(void) -{ - // Allocate polynomial - psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD); - psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - polyOrd->coeff[i] = poly1DCoeff[i]; - polyOrd->mask[i] = poly1DMask[i]; - polyCheb->coeff[i] = 1.0; - polyCheb->mask[i] = poly1DMask[i]; - } - - // Create input vectors - psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrd->data.F32[i] = poly1DXValue[i]; - inputCheb->data.F32[i] = poly1DXChebValue[i]; - } - - // Evaluate the vectors - psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F32); - return 2; - } - psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F32); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(poly1DXResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g", - i, outputOrd->data.F32[i], poly1DXResult[i]); - return i*5; - } - if(fabs(poly1DXChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g", - i, outputCheb->data.F32[i], poly1DXChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrd->type.type = PS_TYPE_U8; - if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 62; - } - inputOrd->type.type = PS_TYPE_F32; - - psFree(inputOrd); - psFree(inputCheb); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - -psS32 testDPoly1DEvalVector(void) -{ - // Allocate polynomial - psDPolynomial1D* polyOrd = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD); - psDPolynomial1D* polyCheb = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - polyOrd->coeff[i] = poly1DCoeff[i]; - polyOrd->mask[i] = poly1DMask[i]; - polyCheb->coeff[i] = 1.0; - polyCheb->mask[i] = poly1DMask[i]; - } - - // Create input vectors - psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrd->data.F64[i] = poly1DXValue[i]; - inputCheb->data.F64[i] = poly1DXChebValue[i]; - } - - // Evaluate the vectors - psVector* outputOrd = psDPolynomial1DEvalVector(polyOrd, inputOrd); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F64); - return 2; - } - psVector* outputCheb = psDPolynomial1DEvalVector(polyCheb, inputCheb); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F64); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(poly1DXResult[i]-outputOrd->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %lg not equal to expected %lg", - i, outputOrd->data.F64[i], poly1DXResult[i]); - return i*5; - } - if(fabs(poly1DXChebResult[i]-outputCheb->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %lg not equal to expected %lg", - i, outputCheb->data.F64[i], poly1DXChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psDPolynomial1DEvalVector(NULL, inputOrd) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial1DEvalVector(polyOrd,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrd->type.type = PS_TYPE_U8; - if(psDPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 62; - } - inputOrd->type.type = PS_TYPE_F64; - - psFree(inputOrd); - psFree(inputCheb); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psFunc09.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc09.c (revision 4528) +++ (revision ) @@ -1,411 +1,0 @@ -/** tst_psFunc09.c -* -* This test driver will exercise the psPolynomialXDEval functions for both -* ORD and CHEB type polynomials. -* -* @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-04-07 20:27:42 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -* -***************************************************************************/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TERMS 4 -#define TESTPOINTS 5 -#define ERROR_TOL 0.001 - -static psS32 testPoly2DEval(void); -static psS32 testDPoly2DEval(void); -static psS32 testPoly2DEvalVector(void); -static psS32 testDPoly2DEvalVector(void); - -testDescription tests[] = { - {testPoly2DEval,583,"psPolynomial2DEval",0,false}, - {testDPoly2DEval,582,"psDPolynomial2DEval",0,false}, - {testPoly2DEvalVector,000,"psPolynomial2DEvalVector",0,false}, - {testDPoly2DEvalVector,000,"psDPolynomial2DEvalVector",0,false}, - {NULL} - }; - -psF32 poly2DCoeff[TERMS][TERMS] = { { -4.3, 2.3, -3.2, 1.9}, - { 1.2, 0.7, -0.3, 1.3}, - { 0.4, -2.9, 0.8, -3.1}, - { -1.1, 2.1, 1.9, 0.6} - }; -psF64 Dpoly2DCoeff[TERMS][TERMS] = { { -4.3, 2.3, -3.2, 1.9}, - { 1.2, 0.7, -0.3, 1.3}, - { 0.4, -2.9, 0.8, -3.1}, - { -1.1, 2.1, 1.9, 0.6} - }; -psF32 poly2DMask[TERMS][TERMS] = { { 0, 0, 0, 1}, - { 0, 0, 1, 0}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }; - -psF32 poly2DXYValue[TESTPOINTS][2] = { { 1.40, 0.55}, - { -0.55, 1.40}, - { 0.00, 2.34}, - { -0.88, 0.00}, - { 3.45, -0.78} - }; -psF32 Dpoly2DXYValue[TESTPOINTS][2] = { { 1.40, 0.55}, - { -0.55, 1.40}, - { 0.00, 2.34}, - { -0.88, 0.00}, - { 3.45, -0.78} - }; -psF32 poly2DResult[TESTPOINTS] = { -3.415938, -14.765687, -16.43992, -4.606381, -22.650702 }; -psF64 Dpoly2DResult[TESTPOINTS] = { -3.415938, -14.765687, -16.43992, -4.606381, -22.650702 }; - -psF32 poly2DXYChebValue[TESTPOINTS][2] = { { 0.500, 0.500}, - { 0.000, 0.250}, - { -0.250, 0.000}, - { 0.990, 0.150}, - { 0.333, -0.666} - }; -psF32 Dpoly2DXYChebValue[TESTPOINTS][2] = { { 0.500, 0.500}, - { 0.000, 0.250}, - { -0.250, 0.000}, - { 0.990, 0.150}, - { 0.333, -0.666} - }; -psF32 poly2DChebResult[TESTPOINTS] = { 0.750000, 1.687500, 0.625000, -0.113040, 0.386786 }; -psF32 Dpoly2DChebResult[TESTPOINTS] = { 0.750000, 1.687500, 0.625000, -0.113040, 0.386786 }; - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - - return !runTestSuite(stderr,"psPolynomialXDEval", tests, argc, argv); -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testPoly2DEval(void) -{ - psF32 result; - psF32 resultCheb; - - // Allocate polynomial structure - psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD); - psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - polyOrd->coeff[i][j] = poly2DCoeff[i][j]; - polyOrd->mask[i][j] = poly2DMask[i][j]; - polyCheb->coeff[i][j] = 1.0; - polyCheb->mask[i][j] = poly2DMask[i][j]; - } - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psPolynomial2DEval(polyOrd,poly2DXYValue[i][0],poly2DXYValue[i][1]); - if(fabs(poly2DResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %g not as expected %g", - result, poly2DResult[i]); - return i; - } - resultCheb = psPolynomial2DEval(polyCheb,poly2DXYChebValue[i][0], poly2DXYChebValue[i][1]); - if(fabs(poly2DChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, poly2DChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psPolynomial2DEval(polyOrd,0.0, 0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testDPoly2DEval(void) -{ - psF64 result; - psF64 resultCheb; - - // Allocate polynomial structure - psDPolynomial2D* polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD); - psDPolynomial2D* polyCheb = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - polyOrd->coeff[i][j] = poly2DCoeff[i][j]; - polyOrd->mask[i][j] = poly2DMask[i][j]; - polyCheb->coeff[i][j] = 1.0; - polyCheb->mask[i][j] = poly2DMask[i][j]; - } - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psDPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]); - if(fabs(Dpoly2DResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg", - result, Dpoly2DResult[i]); - return i; - } - resultCheb = psDPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]); - if(fabs(Dpoly2DChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, Dpoly2DChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psDPolynomial2DEval(polyOrd,0.0, 0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -psS32 testPoly2DEvalVector(void) -{ - // Allocate polynomial - psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD); - psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - polyOrd->coeff[i][j] = poly2DCoeff[i][j]; - polyOrd->mask[i][j] = poly2DMask[i][j]; - polyCheb->coeff[i][j] = 1.0; - polyCheb->mask[i][j] = poly2DMask[i][j]; - } - } - - // Create input vectors - psVector* inputOrdX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputOrdY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrdX->data.F32[i] = poly2DXYValue[i][0]; - inputOrdY->data.F32[i] = poly2DXYValue[i][1]; - inputChebX->data.F32[i] = poly2DXYChebValue[i][0]; - inputChebY->data.F32[i] = poly2DXYChebValue[i][1]; - } - - // Evaluate the vectors - psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F32); - return 2; - } - psVector* outputCheb = psPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F32); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(poly2DResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g", - i, outputOrd->data.F32[i], poly2DResult[i]); - return i*5; - } - if(fabs(poly2DChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g", - i, outputCheb->data.F32[i], poly2DChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial2DEvalVector(polyOrd,NULL, inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial2DEvalVector(polyOrd, inputOrdX, NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 62; - } - - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdX->type.type = PS_TYPE_U8; - if(psPolynomial2DEvalVector(polyOrd,inputOrdX,inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 63; - } - inputOrdX->type.type = PS_TYPE_F32; - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdY->type.type = PS_TYPE_U8; - if(psPolynomial2DEvalVector(polyOrd,inputOrdX,inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 64; - } - inputOrdY->type.type = PS_TYPE_F32; - - psFree(inputOrdX); - psFree(inputOrdY); - psFree(inputChebX); - psFree(inputChebY); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - -psS32 testDPoly2DEvalVector(void) -{ - // Allocate polynomial - psDPolynomial2D* polyOrd = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD); - psDPolynomial2D* polyCheb = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - polyOrd->coeff[i][j] = poly2DCoeff[i][j]; - polyOrd->mask[i][j] = poly2DMask[i][j]; - polyCheb->coeff[i][j] = 1.0; - polyCheb->mask[i][j] = poly2DMask[i][j]; - } - } - - // Create input vectors - psVector* inputOrdX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputOrdY = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrdX->data.F64[i] = poly2DXYValue[i][0]; - inputOrdY->data.F64[i] = poly2DXYValue[i][1]; - inputChebX->data.F64[i] = poly2DXYChebValue[i][0]; - inputChebY->data.F64[i] = poly2DXYChebValue[i][1]; - } - - // Evaluate the vectors - psVector* outputOrd = psDPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F64); - return 2; - } - psVector* outputCheb = psDPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F64); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(poly2DResult[i]-outputOrd->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %lg not equal to expected %lg", - i, outputOrd->data.F64[i], poly2DResult[i]); - return i*5; - } - if(fabs(poly2DChebResult[i]-outputCheb->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %lg not equal to expected %lg", - i, outputCheb->data.F64[i], poly2DChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psDPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 62; - } - - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdX->type.type = PS_TYPE_U8; - if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 63; - } - inputOrdX->type.type = PS_TYPE_F64; - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdY->type.type = PS_TYPE_U8; - if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 64; - } - inputOrdY->type.type = PS_TYPE_F64; - - psFree(inputOrdX); - psFree(inputOrdY); - psFree(inputChebX); - psFree(inputChebY); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psFunc10.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc10.c (revision 4528) +++ (revision ) @@ -1,514 +1,0 @@ -/** tst_psFunc10.c -* -* This test driver will exercise the psPolynomialXDEval functions for both -* ORD and CHEB type polynomials. -* -* @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-04-07 20:27:42 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -* -***************************************************************************/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TERMS 4 -#define TESTPOINTS 5 -#define ERROR_TOL 0.001 - -static psS32 testPoly3DEval(void); -static psS32 testDPoly3DEval(void); -static psS32 testPoly3DEvalVector(void); -static psS32 testDPoly3DEvalVector(void); - -testDescription tests[] = { - {testPoly3DEval,583,"psPolynomial3DEval",0,false}, - {testDPoly3DEval,582,"psDPolynomial3DEval",0,false}, - {testPoly3DEvalVector,000,"psPolynomial3DEvalVector",0,false}, - {testDPoly3DEvalVector,000,"psDPolynomial3DEvalVector",0,false}, - {NULL} - }; - -psF32 poly3DCoeff[TERMS][TERMS][TERMS] = { { { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }; -psF64 Dpoly3DCoeff[TERMS][TERMS][TERMS] = { { { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }; - - -psF32 poly3DMask[TERMS][TERMS][TERMS] = { { { 0, 0, 0, 1}, - { 0, 0, 1, 0}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }, - { { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0} - }, - { { 0, 1, 0, 0}, - { 0, 0, 1, 0}, - { 0, 1, 0, 0}, - { 0, 0, 1, 0} - }, - { { 1, 0, 0, 0}, - { 0, 0, 0, 1}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }, - }; - -psF32 poly3DXYZValue[TESTPOINTS][3] = { { 0.450, -0.780, 0.500}, - { 0.297, 0.153, -0.354}, - { 0.000, 0.153, -0.354}, - { 0.297, 0.000, -0.354}, - { 0.297, 0.153, 0.000} - }; -psF64 Dpoly3DXYZValue[TESTPOINTS][3] = { { 0.450, -0.780, 0.500}, - { 0.297, 0.153, -0.354}, - { 0.000, 0.153, -0.354}, - { 0.297, 0.000, -0.354}, - { 0.297, 0.153, 0.000} - }; -psF32 poly3DResult[TESTPOINTS] = { -1.298691, -2.011591, -1.359247, -2.548266, -1.139072}; -psF64 Dpoly3DResult[TESTPOINTS] = { -1.298691, -2.011591, -1.359247, -2.548266, -1.139072}; - - -psF32 poly3DXYZChebValue[TESTPOINTS][3] = { { 0.000, 0.250, -0.250}, - { -0.250, 0.000, 0.250}, - { 0.250, -0.250, 0.000}, - { 0.100, -0.300, -0.400}, - { 0.990, -0.010, 0.500} - }; -psF64 Dpoly3DXYZChebValue[TESTPOINTS][3] = { { 0.000, 0.250, -0.250}, - { -0.250, 0.000, 0.250}, - { 0.250, -0.250, 0.000}, - { 0.100, -0.300, -0.400}, - { 0.990, -0.010, 0.500} - }; -psF32 poly3DChebResult[TESTPOINTS] = { 1.230469, 1.687500, 0.187500, -1.452707, 2.032344 }; -psF64 Dpoly3DChebResult[TESTPOINTS] = { 1.230469, 1.687500, 0.187500, -1.452707, 2.032344 }; - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - - return !runTestSuite(stderr,"psPolynomialXDEval", tests, argc, argv); -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testPoly3DEval(void) -{ - psF32 result; - psF32 resultCheb; - - // Allocate polynomial structure - psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_ORD); - psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - polyOrd->coeff[i][j][k] = poly3DCoeff[i][j][k]; - polyOrd->mask[i][j][k] = poly3DMask[i][j][k]; - polyCheb->coeff[i][j][k] = 1.0; - polyCheb->mask[i][j][k] = poly3DMask[i][j][k]; - } - } - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psPolynomial3DEval(polyOrd,poly3DXYZValue[i][0],poly3DXYZValue[i][1], - poly3DXYZValue[i][2]); - if(fabs(poly3DResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %g not as expected %g", - result, poly3DResult[i]); - return i; - } - resultCheb = psPolynomial3DEval(polyCheb,poly3DXYZChebValue[i][0], poly3DXYZChebValue[i][1], - poly3DXYZChebValue[i][2]); - if(fabs(poly3DChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, poly3DChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testDPoly3DEval(void) -{ - psF64 result; - psF64 resultCheb; - - // Allocate polynomial structure - psDPolynomial3D* polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psDPolynomial3D* polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - polyOrd->coeff[i][j][k] = Dpoly3DCoeff[i][j][k]; - polyOrd->mask[i][j][k] = poly3DMask[i][j][k]; - polyCheb->coeff[i][j][k] = 1.0; - polyCheb->mask[i][j][k] = poly3DMask[i][j][k]; - } - } - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psDPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1], - Dpoly3DXYZValue[i][2]); - if(fabs(Dpoly3DResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg", - result, Dpoly3DResult[i]); - return i; - } - resultCheb = psDPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1], - Dpoly3DXYZChebValue[i][2]); - if(fabs(Dpoly3DChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, Dpoly3DChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psDPolynomial3DAlloc(TERMS, TERMS, TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psDPolynomial3DEval(polyOrd,0.0, 0.0, 0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -psS32 testPoly3DEvalVector(void) -{ - // Allocate polynomial - psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - polyOrd->coeff[i][j][k] = poly3DCoeff[i][j][k]; - polyOrd->mask[i][j][k] = poly3DMask[i][j][k]; - polyCheb->coeff[i][j][k] = 1.0; - polyCheb->mask[i][j][k] = poly3DMask[i][j][k]; - } - } - } - - // Create input vectors - psVector* inputOrdX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputOrdY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputOrdZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrdX->data.F32[i] = poly3DXYZValue[i][0]; - inputOrdY->data.F32[i] = poly3DXYZValue[i][1]; - inputOrdZ->data.F32[i] = poly3DXYZValue[i][2]; - inputChebX->data.F32[i] = poly3DXYZChebValue[i][0]; - inputChebY->data.F32[i] = poly3DXYZChebValue[i][1]; - inputChebZ->data.F32[i] = poly3DXYZChebValue[i][2]; - } - - // Evaluate the vectors - psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F32); - return 2; - } - psVector* outputCheb = psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F32); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(poly3DResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g", - i, outputOrd->data.F32[i], poly3DResult[i]); - return i*5; - } - if(fabs(poly3DChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g", - i, outputCheb->data.F32[i], poly3DChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psPolynomial3DEvalVector(NULL, inputOrdX, inputOrdY, inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial3DEvalVector(polyOrd,NULL, inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial3DEvalVector(polyOrd, inputOrdX, NULL,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 62; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial3DEvalVector(polyOrd, inputOrdX,inputOrdY,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 63; - } - - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdX->type.type = PS_TYPE_U8; - if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 65; - } - inputOrdX->type.type = PS_TYPE_F32; - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdY->type.type = PS_TYPE_U8; - if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 66; - } - inputOrdY->type.type = PS_TYPE_F32; - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdZ->type.type = PS_TYPE_U8; - if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 67; - } - inputOrdZ->type.type = PS_TYPE_F32; - - psFree(inputOrdX); - psFree(inputOrdY); - psFree(inputOrdZ); - psFree(inputChebX); - psFree(inputChebY); - psFree(inputChebZ); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - -psS32 testDPoly3DEvalVector(void) -{ - // Allocate polynomial - psDPolynomial3D* polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psDPolynomial3D* polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - polyOrd->coeff[i][j][k] = Dpoly3DCoeff[i][j][k]; - polyOrd->mask[i][j][k] = poly3DMask[i][j][k]; - polyCheb->coeff[i][j][k] = 1.0; - polyCheb->mask[i][j][k] = poly3DMask[i][j][k]; - } - } - } - - // Create input vectors - psVector* inputOrdX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputOrdY = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputOrdZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrdX->data.F64[i] = Dpoly3DXYZValue[i][0]; - inputOrdY->data.F64[i] = Dpoly3DXYZValue[i][1]; - inputOrdZ->data.F64[i] = Dpoly3DXYZValue[i][2]; - inputChebX->data.F64[i] = Dpoly3DXYZChebValue[i][0]; - inputChebY->data.F64[i] = Dpoly3DXYZChebValue[i][1]; - inputChebZ->data.F64[i] = Dpoly3DXYZChebValue[i][2]; - } - - // Evaluate the vectors - psVector* outputOrd = psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F64); - return 2; - } - psVector* outputCheb = psDPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F64); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(Dpoly3DResult[i]-outputOrd->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %lg not equal to expected %lg", - i, outputOrd->data.F64[i], Dpoly3DResult[i]); - return i*5; - } - if(fabs(Dpoly3DChebResult[i]-outputCheb->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %lg not equal to expected %lg", - i, outputCheb->data.F64[i], Dpoly3DChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psDPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 62; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 63; - } - - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdX->type.type = PS_TYPE_U8; - if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 64; - } - inputOrdX->type.type = PS_TYPE_F64; - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdY->type.type = PS_TYPE_U8; - if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 65; - } - inputOrdY->type.type = PS_TYPE_F64; - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdZ->type.type = PS_TYPE_U8; - if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 66; - } - inputOrdZ->type.type = PS_TYPE_F64; - - psFree(inputOrdX); - psFree(inputOrdY); - psFree(inputOrdZ); - psFree(inputChebX); - psFree(inputChebY); - psFree(inputChebZ); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psFunc11.c =================================================================== --- trunk/psLib/test/dataManip/tst_psFunc11.c (revision 4528) +++ (revision ) @@ -1,804 +1,0 @@ -/** tst_psFunc11.c -* -* This test driver will exercise the psPolynomialXDEval functions for both -* ORD and CHEB type polynomials. -* -* @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-04-07 20:27:42 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -* -***************************************************************************/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TERMS 4 -#define TESTPOINTS 5 -#define ERROR_TOL 0.001 - -static psS32 testPoly4DEval(void); -static psS32 testDPoly4DEval(void); -static psS32 testPoly4DEvalVector(void); -static psS32 testDPoly4DEvalVector(void); - -testDescription tests[] = { - {testPoly4DEval,583,"psPolynomial4DEval",0,false}, - {testDPoly4DEval,582,"psDPolynomial4DEval",0,false}, - {testPoly4DEvalVector,000,"psPolynomial4DEvalVector",0,false}, - {testDPoly4DEvalVector,000,"psDPolynomial4DEvalVector",0,false}, - {NULL} - }; - -psF32 poly4DCoeff[TERMS][TERMS][TERMS][TERMS] = { - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }, - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }, - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }, - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - } - }; -psF64 Dpoly4DCoeff[TERMS][TERMS][TERMS][TERMS] = { - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }, - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }, - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - }, - { - { - { -1.1, 1.2, -1.3, 1.4}, - { 1.5, -1.6, 1.7, -1.8}, - { 0.1, -0.2, 0.3, -0.4}, - { -0.5, 0.6, -0.7, 0.8} - }, - { - { -2.1, 2.2, -2.3, 2.4}, - { 2.5, -2.6, 2.7, -2.8}, - { 3.1, -3.2, 3.3, -3.4}, - { -3.5, 3.6, -3.7, 3.8} - }, - { { -4.1, 4.2, -4.3, 4.4}, - { 4.5, -4.6, 4.7, -4.8}, - { 5.1, -5.2, 5.3, -5.4}, - { -5.5, 5.6, -5.7, 5.8} - }, - { { -6.1, 6.2, -6.3, 6.4}, - { 6.5, -6.6, 6.7, -6.8}, - { 7.1, -7.2, 7.3, -7.4}, - { -7.5, 7.6, -7.7, 7.8} - } - } - }; - -psF32 poly4DMask[TERMS][TERMS][TERMS][TERMS] = { - { - { - { 0, 0, 0, 1}, - { 0, 0, 1, 0}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }, - { - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0} - }, - { - { 0, 1, 0, 0}, - { 0, 0, 1, 0}, - { 0, 1, 0, 0}, - { 0, 0, 1, 0} - }, - { - { 1, 0, 0, 0}, - { 0, 0, 0, 1}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - } - }, - { - { - { 0, 0, 0, 1}, - { 0, 0, 1, 0}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }, - { - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0} - }, - { - { 0, 1, 0, 0}, - { 0, 0, 1, 0}, - { 0, 1, 0, 0}, - { 0, 0, 1, 0} - }, - { - { 1, 0, 0, 0}, - { 0, 0, 0, 1}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - } - }, - { - { - { 0, 0, 0, 1}, - { 0, 0, 1, 0}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }, - { - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0} - }, - { - { 0, 1, 0, 0}, - { 0, 0, 1, 0}, - { 0, 1, 0, 0}, - { 0, 0, 1, 0} - }, - { - { 1, 0, 0, 0}, - { 0, 0, 0, 1}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - } - }, - { - { - { 0, 0, 0, 1}, - { 0, 0, 1, 0}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - }, - { - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0}, - { 1, 0, 0, 0} - }, - { - { 0, 1, 0, 0}, - { 0, 0, 1, 0}, - { 0, 1, 0, 0}, - { 0, 0, 1, 0} - }, - { - { 1, 0, 0, 0}, - { 0, 0, 0, 1}, - { 1, 0, 0, 0}, - { 0, 0, 0, 1} - } - } - }; - -psF32 poly4DWXYZValue[TESTPOINTS][4] = { - { 0.450, -0.780, 0.500, -0.123}, - { 0.297, 0.153, -0.354, 0.000}, - { 0.000, 0.153, -0.354, 0.321}, - { 0.297, 0.000, -0.354, 0.321}, - { 0.297, 0.153, 0.000, 0.321} - }; -psF64 Dpoly4DWXYZValue[TESTPOINTS][4] = { - { 0.450, -0.780, 0.500, -0.123}, - { 0.297, 0.153, -0.354, 0.000}, - { 0.000, 0.153, -0.354, 0.321}, - { 0.297, 0.000, -0.354, 0.321}, - { 0.297, 0.153, 0.000, 0.321} - }; - -psF32 poly4DResult[TESTPOINTS] = { -3.588753, -2.439566, -1.175955, -1.645497, -1.216915}; -psF64 Dpoly4DResult[TESTPOINTS] = { -3.588753, -2.439566, -1.175955, -1.645497, -1.216915}; - -psF32 poly4DWXYZChebValue[TESTPOINTS][4] = { - { 0.100, 0.000, 0.250, -0.250}, - { 0.100, -0.250, 0.000, 0.250}, - { 0.100, 0.250, -0.250, 0.000}, - { 0.300, 0.200, -0.300, -0.400}, - { -0.780, 0.990, -0.010, 0.500} - }; -psF64 Dpoly4DWXYZChebValue[TESTPOINTS][4] = { - { 0.100, 0.000, 0.250, -0.250}, - { 0.100, -0.250, 0.000, 0.250}, - { 0.100, 0.250, -0.250, 0.000}, - { 0.300, 0.200, -0.300, -0.400}, - { -0.780, 0.990, -0.010, 0.500} - }; -psF32 poly4DChebResult[TESTPOINTS] = { -0.216563, -0.297000, -0.033000, 0.432198, 1.785601 }; -psF64 Dpoly4DChebResult[TESTPOINTS] = { -0.216563, -0.297000, -0.033000, 0.432198, 1.785601 }; - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - - return !runTestSuite(stderr,"psPolynomialXDEval", tests, argc, argv); -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testPoly4DEval(void) -{ - psF32 result; - psF32 resultCheb; - - // Allocate polynomial structure - psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - for(psS32 l = 0; l < TERMS; l++) { - polyOrd->coeff[i][j][k][l] = poly4DCoeff[i][j][k][l]; - polyOrd->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - polyCheb->coeff[i][j][k][l] = 1.0; - polyCheb->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - } - } - } - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psPolynomial4DEval(polyOrd,poly4DWXYZValue[i][0],poly4DWXYZValue[i][1], - poly4DWXYZValue[i][2], poly4DWXYZValue[i][3]); - if(fabs(poly4DResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %g not as expected %g", - result, poly4DResult[i]); - return i; - } - resultCheb = psPolynomial4DEval(polyCheb,poly4DWXYZChebValue[i][0], poly4DWXYZChebValue[i][1], - poly4DWXYZChebValue[i][2], poly4DWXYZChebValue[i][3]); - if(fabs(poly4DChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, poly4DChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -// This test will verify operation of 1D polynomial evaluation -psS32 testDPoly4DEval(void) -{ - psF64 result; - psF64 resultCheb; - - // Allocate polynomial structure - psDPolynomial4D* polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psDPolynomial4D* polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - for(psS32 l = 0; l < TERMS; l++) { - polyOrd->coeff[i][j][k][l] = Dpoly4DCoeff[i][j][k][l]; - polyOrd->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - polyCheb->coeff[i][j][k][l] = 1.0; - polyCheb->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - } - } - } - } - // Evaluate test points and verify results - for(psS32 i = 0; i < TESTPOINTS; i++) { - result = psDPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1], - Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]); - if(fabs(Dpoly4DResult[i]-result) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg", - result, Dpoly4DResult[i]); - return i; - } - resultCheb = psDPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1], - Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]); - if(fabs(Dpoly4DChebResult[i]-resultCheb) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg", - resultCheb, Dpoly4DChebResult[i]); - return 5*i; - } - } - psFree(polyOrd); - psFree(polyCheb); - - // Allocate polynomial with invalid type - polyOrd = psDPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99); - // Attempt to evaluation invalid polynomial type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type"); - result = psDPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0); - if ( !isnan(result) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type"); - return 20; - } - psFree(polyOrd); - - return 0; -} - -psS32 testPoly4DEvalVector(void) -{ - // Allocate polynomial - psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - for(psS32 l = 0; l < TERMS; l++) { - polyOrd->coeff[i][j][k][l] = poly4DCoeff[i][j][k][l]; - polyOrd->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - polyCheb->coeff[i][j][k][l] = 1.0; - polyCheb->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - } - } - } - } - - // Create input vectors - psVector* inputOrdW = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputOrdX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputOrdY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputOrdZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebW = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - psVector* inputChebZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F32); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrdW->data.F32[i] = poly4DWXYZValue[i][0]; - inputOrdX->data.F32[i] = poly4DWXYZValue[i][1]; - inputOrdY->data.F32[i] = poly4DWXYZValue[i][2]; - inputOrdZ->data.F32[i] = poly4DWXYZValue[i][3]; - inputChebW->data.F32[i] = poly4DWXYZChebValue[i][0]; - inputChebX->data.F32[i] = poly4DWXYZChebValue[i][1]; - inputChebY->data.F32[i] = poly4DWXYZChebValue[i][2]; - inputChebZ->data.F32[i] = poly4DWXYZChebValue[i][3]; - } - - // Evaluate the vectors - psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F32); - return 2; - } - psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F32); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(poly4DResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g", - i, outputOrd->data.F32[i], poly4DResult[i]); - return i*5; - } - if(fabs(poly4DChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g", - i, outputCheb->data.F32[i], poly4DChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psPolynomial4DEvalVector(NULL, inputOrdW, inputOrdX, inputOrdY, inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX, inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial4DEvalVector(polyOrd, inputOrdW, NULL, inputOrdY, inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 62; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial4DEvalVector(polyOrd, inputOrdW, inputOrdX,NULL,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 63; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psPolynomial4DEvalVector(polyOrd, inputOrdW, inputOrdX,inputOrdY,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 64; - } - - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdX->type.type = PS_TYPE_U8; - if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 65; - } - inputOrdX->type.type = PS_TYPE_F32; - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdY->type.type = PS_TYPE_U8; - if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 66; - } - inputOrdY->type.type = PS_TYPE_F32; - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdZ->type.type = PS_TYPE_U8; - if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 67; - } - inputOrdZ->type.type = PS_TYPE_F32; - // Attempt to invoke function with a non F32 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdW->type.type = PS_TYPE_U8; - if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector"); - return 68; - } - inputOrdW->type.type = PS_TYPE_F32; - - psFree(inputOrdW); - psFree(inputOrdX); - psFree(inputOrdY); - psFree(inputOrdZ); - psFree(inputChebW); - psFree(inputChebX); - psFree(inputChebY); - psFree(inputChebZ); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - -psS32 testDPoly4DEvalVector(void) -{ - // Allocate polynomial - psDPolynomial4D* polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD); - psDPolynomial4D* polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB); - - // Set polynomial members - for(psS32 i = 0; i < TERMS; i++) { - for(psS32 j = 0; j < TERMS; j++) { - for(psS32 k = 0; k < TERMS; k++) { - for(psS32 l = 0; l < TERMS; l++) { - polyOrd->coeff[i][j][k][l] = Dpoly4DCoeff[i][j][k][l]; - polyOrd->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - polyCheb->coeff[i][j][k][l] = 1.0; - polyCheb->mask[i][j][k][l] = poly4DMask[i][j][k][l]; - } - } - } - } - - // Create input vectors - psVector* inputOrdW = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputOrdX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputOrdY = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputOrdZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebW = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - psVector* inputChebZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F64); - for(psS32 i = 0; i < TESTPOINTS; i++) { - inputOrdW->data.F64[i] = Dpoly4DWXYZValue[i][0]; - inputOrdX->data.F64[i] = Dpoly4DWXYZValue[i][1]; - inputOrdY->data.F64[i] = Dpoly4DWXYZValue[i][2]; - inputOrdZ->data.F64[i] = Dpoly4DWXYZValue[i][3]; - inputChebW->data.F64[i] = Dpoly4DWXYZChebValue[i][0]; - inputChebX->data.F64[i] = Dpoly4DWXYZChebValue[i][1]; - inputChebY->data.F64[i] = Dpoly4DWXYZChebValue[i][2]; - inputChebZ->data.F64[i] = Dpoly4DWXYZChebValue[i][3]; - } - - // Evaluate the vectors - psVector* outputOrd = psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ); - if(outputOrd == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputOrd->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputOrd->type.type, PS_TYPE_F64); - return 2; - } - psVector* outputCheb = psDPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ); - if(outputCheb == NULL) { - psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL."); - return 1; - } - if(outputCheb->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d", - outputCheb->type.type, PS_TYPE_F64); - return 2; - } - - // Verify the results - for(psS32 i = 0; i < TESTPOINTS; i++) { - if(fabs(Dpoly4DResult[i]-outputOrd->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Result[%d] %lg not equal to expected %lg", - i, outputOrd->data.F64[i], Dpoly4DResult[i]); - return i*5; - } - if(fabs(Dpoly4DChebResult[i]-outputCheb->data.F64[i]) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %lg not equal to expected %lg", - i, outputCheb->data.F64[i], Dpoly4DChebResult[i]); - return i*10; - } - } - - // Attempt to invoke function with null polynomial - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial"); - if(psDPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial"); - return 60; - } - - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 61; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 62; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 63; - } - // Attempt to invoke function with null input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector"); - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector"); - return 64; - } - - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdX->type.type = PS_TYPE_U8; - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 65; - } - inputOrdX->type.type = PS_TYPE_F64; - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdY->type.type = PS_TYPE_U8; - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 66; - } - inputOrdY->type.type = PS_TYPE_F64; - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdZ->type.type = PS_TYPE_U8; - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 67; - } - inputOrdZ->type.type = PS_TYPE_F64; - // Attempt to invoke function with a non F64 type input vector - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type"); - inputOrdW->type.type = PS_TYPE_U8; - if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector"); - return 68; - } - inputOrdW->type.type = PS_TYPE_F64; - - psFree(inputOrdX); - psFree(inputOrdY); - psFree(inputOrdZ); - psFree(inputOrdW); - psFree(inputChebW); - psFree(inputChebX); - psFree(inputChebY); - psFree(inputChebZ); - psFree(outputOrd); - psFree(outputCheb); - psFree(polyOrd); - psFree(polyCheb); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psHist00.c =================================================================== --- trunk/psLib/test/dataManip/tst_psHist00.c (revision 4528) +++ (revision ) @@ -1,125 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psHistogram structure is correctly - allocated and deallocated by the procedure psHistogramAlloc(). - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#define LOWER 20.0 -#define UPPER 30.0 - -psS32 main() -{ - psHistogram *myHist = NULL; - psS32 testStatus = true; - psS32 memLeaks = 0; - psS32 i = 0; - psS32 nb = 0; - psS32 numBins = 0; - psS32 currentId = 0; - - currentId = psMemGetId(); - for (nb=0;nb<4;nb++) { - if (nb == 0) - numBins = 1; - if (nb == 1) - numBins = 2; - if (nb == 2) - numBins = 10; - if (nb == 3) - numBins = 20; - /*********************************************************************/ - /* Allocate and initialize data structures */ - /*********************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate the psHistogram structure."); - - myHist = psHistogramAlloc(LOWER, UPPER, numBins); - - if (myHist->nums->n != numBins) { - printf("ERROR: myHist->nums->n is wrong size (%ld)\n", myHist->nums->n); - testStatus = false; - } - - if (myHist->bounds->n != numBins+1) { - printf("ERROR: myHist->bounds->n is wrong size (%ld)\n", myHist->bounds->n); - testStatus = false; - } - - for (i=0;inums->data.F32[i] != 0.0) { - printf("ERROR: myHist->nums->data.U32[%d] not initialized to 0.\n", i); - testStatus = false; - } - myHist->nums->data.F32[i] = 0.0; - } - - if (myHist->minNum != 0) { - printf("ERROR: myHist->minNum is %d\n", myHist->minNum); - testStatus = false; - } - - if (myHist->maxNum != 0) { - printf("myHist->maxNum is %d\n", myHist->maxNum); - testStatus = false; - } - - if (myHist->uniform != true) { - printf("ERROR: myHist->uniform is %d\n", myHist->uniform); - testStatus = false; - } - - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1]); - } - - psMemCheckCorruption(1); - psFree(myHist); - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Allocate the psHistogram structure.", - testStatus); - } - - - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate the psHistogram structure. (UPPER -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#define LOWER 20.0 -#define UPPER 30.0 - -psS32 main() -{ - psHistogram *myHist = NULL; - psVector *myBounds = NULL; - psS32 testStatus = true; - psS32 memLeaks = 0; - psS32 i = 0; - psS32 nb = 0; - psS32 numBins = 0; - psS32 currentId = 0; - - currentId = psMemGetId(); - for (nb=0;nb<4;nb++) { - if (nb == 0) - numBins = 1; - if (nb == 1) - numBins = 2; - if (nb == 2) - numBins = 10; - if (nb == 3) - numBins = 20; - /*********************************************************************/ - /* Allocate and initialize data structures */ - /*********************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate the psHistogram structure."); - myBounds = psVectorAlloc(numBins+1, PS_TYPE_F32); - myBounds->n = myBounds->nalloc; - for (i=0;idata.F32[i] = LOWER + ((UPPER - LOWER) / (float) numBins) * - (float) i; - } - myHist = psHistogramAllocGeneric(myBounds); - - if (myHist->nums->n != numBins) { - printf("ERROR: myHist->nums->n is wrong size (%ld)\n", myHist->nums->n); - testStatus = false; - } - - if (myHist->bounds->n != numBins+1) { - printf("ERROR: myHist->bounds->n is wrong size (%ld)\n", myHist->bounds->n); - testStatus = false; - } - - for (i=0;inums->data.F32[i] != 0.0) { - printf("ERROR: myHist->nums->data.F32[%d] not initialized to 0.\n", i); - testStatus = false; - } - myHist->nums->data.F32[i] = 0.0; - } - - if (myHist->minNum != 0) { - printf("ERROR: myHist->minNum is %d\n", myHist->minNum); - testStatus = false; - } - - if (myHist->maxNum != 0) { - printf("myHist->maxNum is %d\n", myHist->maxNum); - testStatus = false; - } - - if (myHist->uniform != false) { - printf("ERROR: myHist->uniform is %d\n", myHist->uniform); - testStatus = false; - } - - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1]); - } - psMemCheckCorruption(1); - psFree(myHist); - psMemCheckCorruption(1); - psFree(myBounds); - - printFooter(stdout, - "psStats functions", - "Allocate the psHistogram structure.", - testStatus); - } - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Deallocate the psHistogram structure."); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Deallocate the psHistogram structure.", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psHist02.c =================================================================== --- trunk/psLib/test/dataManip/tst_psHist02.c (revision 4528) +++ (revision ) @@ -1,190 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psHistogram structure is correctly - populated by the procedure psGetArrayHistogram(). - -*****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#define MISC_FLOAT_NUMBER 345.0 -#define MISC_INT_NUMBER 345 -#define LOWER 20.0 -#define UPPER 30.0 -#define NUM_DATA 10000 - -psS32 main() -{ - psHistogram * myHist = NULL; - psHistogram *myHist2 = NULL; - psVector *myData = NULL; - psVector *myMask = NULL; - psS32 testStatus = true; - psS32 memLeaks = 0; - psS32 nb = 0; - psS32 numBins = 0; - psS32 i = 0; - psS32 currentId = 0; - - currentId = psMemGetId(); - - /*********************************************************************/ - /* Allocate and initialize data structures */ - /*********************************************************************/ - myData = psVectorAlloc( NUM_DATA, PS_TYPE_F32 ); - myData->n = myData->nalloc; - for ( i = 0;i < NUM_DATA;i++ ) { - myData->data.F32[ i ] = LOWER + ( ( UPPER - LOWER ) / ( float ) NUM_DATA ) * ( float ) i; - } - - myMask = psVectorAlloc( NUM_DATA, PS_TYPE_U8 ); - myMask->n = myMask->nalloc; - for ( i = 0;i < NUM_DATA;i++ ) { - if ( i >= ( NUM_DATA / 2 ) ) { - myMask->data.U8[ i ] = 1; - } else { - myMask->data.U8[ i ] = 0; - } - } - - for ( nb = 0;nb < 4;nb++ ) { - if ( nb == 0 ) - numBins = 1; - if ( nb == 1 ) - numBins = 2; - if ( nb == 2 ) - numBins = 10; - if ( nb == 3 ) - numBins = 20; - - /*********************************************************************/ - /* Allocate and Perform Histogram, no mask */ - /*********************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "Allocate and Perform Histogram, no mask" ); - - myHist = psHistogramAlloc( LOWER, UPPER, numBins ); - myHist = psVectorHistogram( myHist, myData, NULL, NULL, 0 ); - - for ( i = 0;i < numBins;i++ ) { - printf( "Bin number %d bounds: (%.2f - %.2f) data (%f)\n", i, - myHist->bounds->data.F32[ i ], - myHist->bounds->data.F32[ i + 1 ], - myHist->nums->data.F32[ i ] ); - } - psMemCheckCorruption( 1 ); - psFree( myHist ); - psMemCheckCorruption( 1 ); - - printFooter( stdout, - "psStats functions", - "Allocate and Perform Histogram, no mask", - testStatus ); - - /*********************************************************************/ - /* Allocate and Perform Histogram with mask */ - /*********************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "Allocate and Perform Histogram with mask" ); - - myHist = psHistogramAlloc( LOWER, UPPER, numBins ); - myHist = psVectorHistogram( myHist, myData, NULL, myMask, 1 ); - - for ( i = 0;i < numBins;i++ ) { - printf( "Bin number %d bounds: (%6.3f - %6.3f) data (%f)\n", i, - myHist->bounds->data.F32[ i ], - myHist->bounds->data.F32[ i + 1 ], - myHist->nums->data.F32[ i ] ); - } - psMemCheckCorruption( 1 ); - psFree( myHist ); - psMemCheckCorruption( 1 ); - - printFooter( stdout, - "psStats functions", - "Allocate and Perform Histogram with mask", - testStatus ); - } - psFree( myMask ); - - printPositiveTestHeader( stdout, - "psStats functions", - "Calling psVectorHistogram() with various NULL inputs." ); - - - - // ******************************************************************** - // Verify the return value is null and program execution doesn't stop, - // if input parameter myHist is null. - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - myHist2 = psVectorHistogram( NULL, myData, NULL, NULL, 0 ); - if ( myHist2 != NULL ) { - printf( "ERROR: myHist2!=NULL\n" ); - testStatus = false; - } - psFree( myData ); - - - // ******************************************************************** - // Verify the return value is the same as the input parameter myHist and - // program execution doesn't stop, if the input parameter myArray is - // null. - - myHist = psHistogramAlloc( LOWER, UPPER, numBins ); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - myHist = psVectorHistogram( myHist, NULL, NULL, NULL, 0 ); - if ( myHist == NULL ) { - printf( "ERROR: myHist==NULL\n" ); - testStatus = false; - } - psFree( myHist ); - - - // exit(0); - // ******************************************************************** - // Verify the return value is the same as the input parameter myHist and - // program execution doesn't stop, if the input parameter myArray has no - // elements. - // NOTE: This code segment is commented out because psVectorAlloc returns - // NULL if called with an N element data. - /* - myData = psVectorAlloc(0, PS_TYPE_F32); - myData->n = myData->nalloc; - myHist = psHistogramAlloc(LOWER, UPPER, numBins); - myHist = psVectorHistogram(myHist, NULL, NULL, NULL, 0); - if (myHist == NULL) { - printf("ERROR: myHist==NULL\n"); - testStatus = false; - } - psFree(myHist); - psFree(myData); - */ - printFooter( stdout, - "psStats functions", - "Calling psVectorHistogram() with various NULL inputs.", - testStatus ); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "Deallocate the psHistogram structure." ); - - psMemCheckCorruption( 1 ); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if ( 0 != memLeaks ) { - psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); - } - psMemCheckCorruption( 1 ); - - printFooter( stdout, - "psStats functions", - "Deallocate the psHistogram structure.", - testStatus ); - - return ( !testStatus ); -} Index: trunk/psLib/test/dataManip/tst_psHist03.c =================================================================== --- trunk/psLib/test/dataManip/tst_psHist03.c (revision 4528) +++ (revision ) @@ -1,128 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psHistogram structure is correctly - allocated and deallocated by the procedure psHistogramAllocGeneric() and - that it can be populated correctly by psVectorHistogram(). - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#define LOWER 20.0 -#define UPPER 30.0 -#define NUM_DATA 20 - -psS32 main() -{ - psHistogram *myHist = NULL; - psVector *myBounds = NULL; - psVector *myData = psVectorAlloc( NUM_DATA, PS_TYPE_F32 ); - psS32 testStatus = true; - psS32 memLeaks = 0; - psS32 i = 0; - psS32 nb = 0; - psS32 numBins = 0; - psS32 currentId = 0; - - currentId = psMemGetId(); - - psTraceSetLevel(".psLib", 0); - - myData->n = myData->nalloc; - for ( i = 0;i < NUM_DATA;i++ ) { - myData->data.F32[ i ] = LOWER + ( ( UPPER - LOWER ) / ( float ) NUM_DATA ) * ( float ) i; - } - - for (nb=0;nb<4;nb++) { - if (nb == 0) - numBins = 1; - if (nb == 1) - numBins = 2; - if (nb == 2) - numBins = 10; - if (nb == 3) - numBins = 20; - /*********************************************************************/ - /* Allocate and initialize data structures */ - /*********************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate the psHistogram structure."); - myBounds = psVectorAlloc(numBins+1, PS_TYPE_F32); - myBounds->n = myBounds->nalloc; - for (i=0;idata.F32[i] = LOWER + ((UPPER - LOWER) / (float) numBins) * - (float) i; - } - myHist = psHistogramAllocGeneric(myBounds); - - if (myHist->nums->n != numBins) { - printf("ERROR: myHist->nums->n is wrong size (%ld)\n", myHist->nums->n); - testStatus = false; - } - - if (myHist->bounds->n != numBins+1) { - printf("ERROR: myHist->bounds->n is wrong size (%ld)\n", myHist->bounds->n); - testStatus = false; - } - - for (i=0;inums->data.F32[i] != 0.0) { - printf("ERROR: myHist->nums->data.F32[%d] not initialized to 0.\n", i); - testStatus = false; - } - myHist->nums->data.F32[i] = 0.0; - } - - if (myHist->minNum != 0) { - printf("ERROR: myHist->minNum is %d\n", myHist->minNum); - testStatus = false; - } - - if (myHist->maxNum != 0) { - printf("myHist->maxNum is %d\n", myHist->maxNum); - testStatus = false; - } - - if (myHist->uniform != false) { - printf("ERROR: myHist->uniform is %d\n", myHist->uniform); - testStatus = false; - } - - myHist = psVectorHistogram( myHist, myData, NULL, NULL, 0 ); - for (i=0;ibounds->data.F32[i], - myHist->bounds->data.F32[i+1], - myHist->nums->data.F32[i]); - } - - psMemCheckCorruption(1); - psFree(myHist); - psMemCheckCorruption(1); - psFree(myBounds); - - printFooter(stdout, - "psStats functions", - "Allocate the psHistogram structure.", - testStatus); - } - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Deallocate the psHistogram structure."); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Deallocate the psHistogram structure.", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psMatrix01.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix01.c (revision 4528) +++ (revision ) @@ -1,131 +1,0 @@ -/** @file tst_psMatrix_01.c -* -* @brief Test driver for psMatrix transpose function -* -* This test driver contains the following tests for psMatrix test point 1: -* A) Create input and output images -* B) Transpose input image into output image -* C) Transpose input image into auto allocated NULL output image -* D) Free images and check for leaks -* -* @author Ross Harman, MHPCC -* -* @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-04-07 20:27:42 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -* -*/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TOLERANCE 0.000001 - -#define CHECK_MATRIX(IMAGE) \ -for(psU32 i=0; inumRows; i++) { \ - for(psU32 j=0; jnumCols; j++) { \ - if(IMAGE->type.type == PS_TYPE_F64) { \ - if(fabs(IMAGE->data.F64[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %lf vs %lf\n", i, j, \ - IMAGE->data.F64[i][j], truthMatrix[i][j]); \ - } \ - } else if(IMAGE->type.type == PS_TYPE_F32){ \ - if(fabs(IMAGE->data.F32[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %f vs %lf\n", i, j, \ - IMAGE->data.F32[i][j], truthMatrix[i][j]); \ - } \ - } \ - } \ -} - - -psS32 main( psS32 argc, char* argv[] ) -{ - psImage * tempImage = NULL; - - double truthMatrix[3][3] = {{1, 4, 7}, - {2, 5, 8}, - {3, 6, 9}}; - - // Test A - Create input and output images - printPositiveTestHeader(stdout, "psMatrix", "Create input and output images"); - psImage *inImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psImage *outImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - inImage->data.F64[0][0] = 1; - inImage->data.F64[0][1] = 2; - inImage->data.F64[0][2] = 3; - inImage->data.F64[1][0] = 4; - inImage->data.F64[1][1] = 5; - inImage->data.F64[1][2] = 6; - inImage->data.F64[2][0] = 7; - inImage->data.F64[2][1] = 8; - inImage->data.F64[2][2] = 9; - psImage *inImageF32 = (psImage*)psImageAlloc(3, 3, PS_TYPE_F32); - psImage *outImageF32 = (psImage*)psImageAlloc(3, 3, PS_TYPE_F32); - inImageF32->data.F32[0][0] = 1; - inImageF32->data.F32[0][1] = 2; - inImageF32->data.F32[0][2] = 3; - inImageF32->data.F32[1][0] = 4; - inImageF32->data.F32[1][1] = 5; - inImageF32->data.F32[1][2] = 6; - inImageF32->data.F32[2][0] = 7; - inImageF32->data.F32[2][1] = 8; - inImageF32->data.F32[2][2] = 9; - printFooter(stdout, "psMatrix", "Create input and output images", true); - - - // Test B - Transpose input image into output image - printPositiveTestHeader(stdout, "psMatrix", "Transpose input image into output image"); - tempImage = outImage; - outImage = psMatrixTranspose(outImage, inImage); - CHECK_MATRIX(outImage); - if (outImage->type.dimen != PS_DIMEN_IMAGE) { - printf( "Error: Resulting image is not PS_DIMEN_IMAGE\n"); - } else if (outImage != tempImage) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - - tempImage = outImageF32; - outImageF32 = psMatrixTranspose(outImageF32, inImageF32); - CHECK_MATRIX(outImageF32); - if (outImageF32->type.dimen != PS_DIMEN_IMAGE) { - printf("Error: Resulting image is not PS_DIMEN_IMAGE\n"); - } else if (outImageF32 != tempImage) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - printFooter(stdout, "psMatrix", "Transpose input image into output image", true); - - - // Test C - Transpose input image into auto allocated NULL output image - printPositiveTestHeader(stdout, "psMatrix", "Transpose input image into auto allocated NULL output image"); - psImage *outImageNull = NULL; - outImageNull = psMatrixTranspose(outImageNull, inImage); - CHECK_MATRIX(outImageNull); - - psImage *outImageNullF32 = NULL; - outImageNullF32 = psMatrixTranspose(outImageNullF32, inImageF32); - CHECK_MATRIX(outImageNullF32); - printFooter(stdout, "psMatrix", "Transpose input image into auto allocated NULL output image", true); - - - // Test D - Free images and check for leaks - printPositiveTestHeader(stdout, "psMatrix", "Free images and check for leaks"); - psFree(inImage); - psFree(outImage); - psFree(outImageNull); - psFree(inImageF32); - psFree(outImageF32); - psFree(outImageNullF32); - psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false); - if (nLeaks != 0) { - printf("ERROR: Found %d memory leaks\n", nLeaks); - } - psS32 nBad = psMemCheckCorruption(0); - if (nBad) { - printf("ERROR: Found %d bad memory blocks\n", nBad); - } - printFooter(stdout, "psMatrix" , "Free images and check for leaks", true); - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrix02.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix02.c (revision 4528) +++ (revision ) @@ -1,100 +1,0 @@ -/** @file tst_psMatrix_02.c - * - * @brief Test driver for negative tests for psMatrix transpose function - * - * This test driver contains the following tests for psMatrix test point 2: - * A) Input pointer same as output pointer - * B) Null input psImage - * C) Incorrect type for input pointer - * D) Incorrect type for output pointer - * E) Matrix not square for output pointer - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - -psS32 main(psS32 argc, - char* argv[]) -{ - psImage *nullImage = NULL; - psImage *inImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psImage *outImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psImage *badImage1 = (psImage*)psImageAlloc(3, 3, PS_TYPE_C32); - psImage *badImage2 = (psImage*)psImageAlloc(3, 2, PS_TYPE_F64); - - // Test A - Input pointer same as output pointer - printPositiveTestHeader(stdout,"psMatrix", "Input pointer same as output pointer"); - psMemIncrRefCounter(inImage); - if (psMatrixTranspose(inImage, inImage) != NULL) { - psError(PS_ERR_UNKNOWN, true, - "inImage = outImage didn't results in NULL return"); - return 1; - } - if (psMemGetRefCounter(inImage) != 1) { - psError(PS_ERR_UNKNOWN, true, - "the output image was not freed on an error."); - return 2; - } - printFooter(stdout, "psMatrix", "Input pointer same as output pointer", true); - - // Test B - Null input psImage - printPositiveTestHeader(stdout,"psMatrix", "Null input psImage"); - psMemIncrRefCounter(outImage); - if (psMatrixTranspose(outImage, nullImage) != NULL) { - psError(PS_ERR_UNKNOWN, true, - "inImage = outImage didn't results in NULL return"); - return 3; - } - if (psMemGetRefCounter(outImage) != 1) { - psError(PS_ERR_UNKNOWN, true, - "the output image was not freed on an error."); - return 4; - } - printFooter(stdout, "psMatrix", "Null input psImage", true); - - // Test C - Incorrect type for input pointer - printPositiveTestHeader(stdout,"psMatrix", "Incorrect type for input pointer"); - psMemIncrRefCounter(outImage); - if (psMatrixTranspose(outImage, badImage1) != NULL) { - psError(PS_ERR_UNKNOWN, true, - "inImage = outImage didn't results in NULL return"); - return 5; - } - if (psMemGetRefCounter(outImage) != 1) { - psError(PS_ERR_UNKNOWN, true, - "the output image was not freed on an error."); - return 6; - } - printFooter(stdout, "psMatrix", "Incorrect type for input pointer", true); - - // Test D - Incorrect type for output pointer - printPositiveTestHeader(stdout,"psMatrix", "Incorrect type for output pointer"); - badImage1 = psMatrixTranspose(badImage1, inImage); - if (badImage1 == NULL) { - psError(PS_ERR_UNKNOWN, true, - "inImage = outImage didn't results in NULL return"); - return 7; - } - // check that the type was changed. - if (badImage1->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN, true, - "the output image was not freed on an error."); - return 8; - } - printFooter(stdout, "psMatrix", "Incorrect type for output pointer", true); - - // Test E - Matrix not square for output pointer - printPositiveTestHeader(stdout,"psMatrix", "Matrix not square for output pointer"); - psMatrixTranspose(badImage2, inImage); - printFooter(stdout, "psMatrix", "Matrix not square for output pointer", true); - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrix03.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix03.c (revision 4528) +++ (revision ) @@ -1,234 +1,0 @@ -/** @file tst_psMatrix_03.c - * - * @brief Test driver for psMatrix LU functions - * - * This test driver contains the following tests for psMatrix test point 3: - * A) Create input and output images and vectors - * B) Calculate LU matrix - * C) Determine solution to matrix equation - * D) Free input and output images and vectors - * E) Attempt to use null image input argument - * F) Attempt to use null input vector argument - * G) ttempt to use null LU image argument - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TOLERANCE 0.000001 - -#define CHECK_MATRIX(IMAGE) \ -for(psU32 i=0; inumRows; i++) { \ - for(psU32 j=0; jnumCols; j++) { \ - if(IMAGE->type.type == PS_TYPE_F64) { \ - if(fabs(IMAGE->data.F64[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %lf vs %lf\n", i, j, \ - IMAGE->data.F64[i][j], truthMatrix[i][j]); \ - } \ - } else if(IMAGE->type.type == PS_TYPE_F32){ \ - if(fabs(IMAGE->data.F32[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %f vs %lf\n", i, j, \ - IMAGE->data.F32[i][j], truthMatrix[i][j]); \ - } \ - } \ - } \ -} - -#define CHECK_VECTOR(VECTOR) \ -for(psU32 i=0; in; i++) { \ - if(VECTOR->type.type == PS_TYPE_F64) { \ - if(fabs(VECTOR->data.F64[i]-truthVector[i]) > TOLERANCE) { \ - printf("Vector values at element %d don't agree %lf vs %lf\n", i, \ - VECTOR->data.F64[i], truthVector[i]); \ - } \ - } else if(VECTOR->type.type == PS_TYPE_F32){ \ - if(fabs(VECTOR->data.F32[i]-truthVector[i]) > TOLERANCE) { \ - printf("Vector values at element %d don't agree %f vs %lf\n", i, \ - VECTOR->data.F32[i], truthVector[i]); \ - } \ - } \ -} - - -psS32 main(psS32 argc, char* argv[]) -{ - psImage *luImage = NULL; - psImage *inImage = NULL; - psImage *tempImage = NULL; - psVector *tempVector = NULL; - psVector *perm = NULL; - psVector *outVector = NULL; - psVector *inVector = NULL; - psImage *luImage32 = NULL; - psImage *inImage32 = NULL; - psImage *tempImage32 = NULL; - psVector *tempVector32 = NULL; - psVector *perm32 = NULL; - psVector *outVector32 = NULL; - psVector *inVector32 = NULL; - - double truthVector[3] = { - 4.000000, - -2.000000, - 3.000000 - }; - - double truthMatrix[3][3] = {{4.000000, 5.000000, 6.000000}, - {0.750000, -2.750000, -6.500000}, - {0.500000, -0.545455, -0.545455}}; - - - // Test A - Create input and output images and vectors - printPositiveTestHeader(stdout, "psMatrix", "Create input and output images and vectors"); - luImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - perm = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - outVector = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - inVector = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - inImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - inImage->data.F64[0][0] = 2; - inImage->data.F64[0][1] = 4; - inImage->data.F64[0][2] = 6; - inImage->data.F64[1][0] = 4; - inImage->data.F64[1][1] = 5; - inImage->data.F64[1][2] = 6; - inImage->data.F64[2][0] = 3; - inImage->data.F64[2][1] = 1; - inImage->data.F64[2][2] = -2; - inVector->data.F64[0] = 18.0; - inVector->data.F64[1] = 24.0; - inVector->data.F64[2] = 4.0; - inVector->n = 3; - luImage32 = (psImage*)psImageAlloc(3, 3, PS_TYPE_F32); - outVector32 = (psVector*)psVectorAlloc(3, PS_TYPE_F32); - inVector32 = (psVector*)psVectorAlloc(3, PS_TYPE_F32); - inImage32 = (psImage*)psImageAlloc(3, 3, PS_TYPE_F32); - inImage32->data.F32[0][0] = 2; - inImage32->data.F32[0][1] = 4; - inImage32->data.F32[0][2] = 6; - inImage32->data.F32[1][0] = 4; - inImage32->data.F32[1][1] = 5; - inImage32->data.F32[1][2] = 6; - inImage32->data.F32[2][0] = 3; - inImage32->data.F32[2][1] = 1; - inImage32->data.F32[2][2] = -2; - inVector32->data.F32[0] = 18.0; - inVector32->data.F32[1] = 24.0; - inVector32->data.F32[2] = 4.0; - inVector32->n = 3; - printFooter(stdout, "psMatrix", "Create input and output images and vectors", true); - - - // Test B - Calculate LU matrix - printPositiveTestHeader(stdout, "psMatrix", "Calculate LU matrix"); - tempImage = luImage; - luImage = psMatrixLUD(luImage, &perm, inImage); - CHECK_MATRIX(luImage); - if(luImage->type.dimen != PS_DIMEN_IMAGE) { - printf("Error: Resulting image is not PS_DIMEN_IMAGE\n"); - } else if(luImage != tempImage) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - - tempImage32 = luImage32; - luImage32 = psMatrixLUD(luImage32, &perm32, inImage32); - CHECK_MATRIX(luImage32); - if(luImage32->type.dimen != PS_DIMEN_IMAGE) { - printf("Error: Resulting image is not PS_DIMEN_IMAGE\n"); - } else if(luImage32 != tempImage32) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - printFooter(stdout, "psMatrix", "Calculate LU matrix", true); - - // Test C - Determine solution to matrix equation - printPositiveTestHeader(stdout, "psMatrix", "Determine solution to matrix equation"); - tempVector = outVector; - outVector = psMatrixLUSolve(outVector, luImage, inVector, perm); - CHECK_VECTOR(outVector); - if(outVector->type.dimen != PS_DIMEN_VECTOR) { - printf("Error: Resulting image is not PS_DIMEN_VECTOR\n"); - } else if(outVector != tempVector) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - - tempVector32 = outVector32; - outVector32 = psMatrixLUSolve(outVector32, luImage32, inVector32, perm32); - CHECK_VECTOR(outVector32); - if(outVector32->type.dimen != PS_DIMEN_VECTOR) { - printf("Error: Resulting image is not PS_DIMEN_VECTOR\n"); - } else if(outVector32 != tempVector32) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - printFooter(stdout, "psMatrix", "Determine solution to matrix equation", true); - - - // Test D - Free input and output images and vectors - printPositiveTestHeader(stdout, "psMatrix", "Free input and output images and vectors"); - psFree(inImage); - psFree(luImage); - psFree(perm); - psFree(outVector); - psFree(inVector); - psFree(inImage32); - psFree(luImage32); - psFree(perm32); - psFree(outVector32); - psFree(inVector32); - if( psMemCheckLeaks(0, NULL, stdout, false) ) { - psError(PS_ERR_UNKNOWN,true,"Memory leaks detected"); - return 10; - } - psS32 nBad = psMemCheckCorruption(0); - if(nBad) { - printf("ERROR: Found %d bad memory blocks\n", nBad); - } - printFooter(stdout, "psMatrix" ,"Free input and output images and vectors", true); - - - // Test E - Attempt to use null image input argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null image input argument", - "Invalid operation: inImage or its data is NULL.", 0); - psImage *imageTest = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psMatrixLUD(imageTest, NULL, NULL); - printFooter(stdout, "psMatrix", "Attempt to use null image input argument", true); - - - // Test F - Attempt to use null input vector argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null input vector argument", - "Invalid operation: inVector or its data is NULL.", 0); - psVector *vectorBad = NULL; - psVector *vectorBadOut = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - psVector *permBad = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - imageTest = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psMatrixLUSolve(vectorBadOut, imageTest, vectorBad, permBad); - printFooter(stdout, "psMatrix", "Attempt to use null input vector argument", true); - - - // Test G - Attempt to use null LU image argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null LU image argument", - "Invalid operation: inImage or its data is NULL.", 0); - vectorBadOut = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - psMatrixLUSolve(vectorBadOut, NULL, vectorBad, permBad); - printFooter(stdout, "psMatrix", "Attempt to use null LU image argument", true); - - psFree(permBad); - psFree(imageTest); - - if( psMemCheckLeaks(0, NULL, stdout, false) ) { - psError(PS_ERR_UNKNOWN,true,"Memory leaks detected"); - return 10; - } - nBad = psMemCheckCorruption(0); - if(nBad) { - printf("ERROR: Found %d bad memory blocks\n", nBad); - } - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrix04.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix04.c (revision 4528) +++ (revision ) @@ -1,163 +1,0 @@ -/** @file tst_psMatrix_04.c - * - * @brief Test driver for psMatrix invert function - * - * This test driver contains the following tests for psMatrix test point 4: - * A) Create input and output images - * B) Invert matrix and calculate determinant - * C) Calculate determinant only - * D) Free input and output images - * E) Attempt to use null input image argument - * F) Attempt to use null input float argument - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - - -#define TOLERANCE 0.000001 - -#define CHECK_MATRIX(IMAGE) \ -for(psU32 i=0; inumRows; i++) { \ - for(psU32 j=0; jnumCols; j++) { \ - if(IMAGE->type.type == PS_TYPE_F64) { \ - if(fabs(IMAGE->data.F64[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %lf vs %lf\n", i, j, \ - IMAGE->data.F64[i][j], truthMatrix[i][j]); \ - } \ - } else if(IMAGE->type.type == PS_TYPE_F32){ \ - if(fabs(IMAGE->data.F32[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %f vs %lf\n", i, j, \ - IMAGE->data.F32[i][j], truthMatrix[i][j]); \ - } \ - } \ - } \ -} - -#define CHECK_VALUE(VALUE) \ -if(fabs(VALUE-truthValue) > TOLERANCE) { \ - printf("Values don't agree %lf vs %lf\n", VALUE, truthValue); \ -} - -psS32 main(psS32 argc, char* argv[]) -{ - float det = 0.0f; - float *det2 = NULL; - psImage *outImage = NULL; - psImage *inImage = NULL; - psImage *tempImage = NULL; - psImage *outImage32 = NULL; - psImage *inImage32 = NULL; - psImage *tempImage32 = NULL; - - double truthMatrix[3][3] = {{4.0000000, -4.333333, -2.333333}, - {-1.000000, 1.666667, 0.666667}, - {-1.000000, 0.666667, 0.666667}}; - double truthValue = 3.0; - - - // Test A - Create input and output images - printPositiveTestHeader(stdout, "psMatrix", "Create input and output images"); - outImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - inImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - inImage->data.F64[0][0] = 2; - inImage->data.F64[0][1] = 4; - inImage->data.F64[0][2] = 3; - inImage->data.F64[1][0] = 0; - inImage->data.F64[1][1] = 1; - inImage->data.F64[1][2] = -1; - inImage->data.F64[2][0] = 3; - inImage->data.F64[2][1] = 5; - inImage->data.F64[2][2] = 7; - - outImage32 = (psImage*)psImageAlloc(3, 3, PS_TYPE_F32); - inImage32 = (psImage*)psImageAlloc(3, 3, PS_TYPE_F32); - inImage32->data.F32[0][0] = 2; - inImage32->data.F32[0][1] = 4; - inImage32->data.F32[0][2] = 3; - inImage32->data.F32[1][0] = 0; - inImage32->data.F32[1][1] = 1; - inImage32->data.F32[1][2] = -1; - inImage32->data.F32[2][0] = 3; - inImage32->data.F32[2][1] = 5; - inImage32->data.F32[2][2] = 7; - printFooter(stdout, "psMatrix", "Create input and output images", true); - - - // Test B - Invert matrix and calculate determinant - printPositiveTestHeader(stdout, "psMatrix", "Invert matrix and calculate determinant"); - tempImage = outImage; - outImage = psMatrixInvert(outImage, inImage, &det); - CHECK_MATRIX(outImage); - CHECK_VALUE(det); - if(outImage->type.dimen != PS_DIMEN_IMAGE) { - printf("Error: Resulting image is not PS_DIMEN_IMAGE\n"); - } else if(outImage != tempImage) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - det = 0.0f; - tempImage32 = outImage32; - outImage32 = psMatrixInvert(outImage32, inImage32, &det); - CHECK_MATRIX(outImage32); - CHECK_VALUE(det); - if(outImage32->type.dimen != PS_DIMEN_IMAGE) { - printf("Error: Resulting image is not PS_DIMEN_IMAGE\n"); - } else if(outImage32 != tempImage32) { - printf("Error: Return pointer not equal to output argument pointer\n"); - } - printFooter(stdout, "psMatrix", "Invert matrix and calculate determinant", true); - - - // Test C - Calculate determinant only - printPositiveTestHeader(stdout, "psMatrix", "Calculate determinant only"); - det2 = psMatrixDeterminant(inImage); - CHECK_VALUE(*det2); - psFree(det2); - det2 = psMatrixDeterminant(inImage32); - CHECK_VALUE(*det2); - psFree(det2); - printFooter(stdout, "psMatrix", "Calculate determinant only", true); - - - // Test D - Free input and output images - printPositiveTestHeader(stdout, "psMatrix", "Free input and output images"); - psFree(outImage); - psFree(inImage); - psFree(outImage32); - psFree(inImage32); - if(psMemCheckLeaks(0, NULL, stdout, false) != 0 ) { - psError(PS_ERR_UNKNOWN,true,"Memory leaks detected."); - return 10; - } - psS32 nBad = psMemCheckCorruption(0); - if(nBad) { - printf("ERROR: Found %d bad memory blocks\n", nBad); - } - printFooter(stdout, "psMatrix" ,"Free input and output images", true); - - - // Test E - Attempt to use null input image argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null input image argument", - "Invalid operation: inImage or its data is NULL.", 0); - psImage *badOutImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psMatrixInvert(badOutImage, NULL, &det); - printFooter(stdout, "psMatrix", "Attempt to use null input image argument", true); - - - // Test F - Attempt to use null input float argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null input float argument", - "Invalid operation: determinant argument is NULL.", 0); - psImage *badInImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64); - psMatrixInvert(badOutImage, badInImage, NULL); - printFooter(stdout, "psMatrix", "Attempt to use null input float argument", true); - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrix05.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix05.c (revision 4528) +++ (revision ) @@ -1,118 +1,0 @@ -/** @file tst_psMatrix_05.c -* -* @brief Test driver for psMatrix multiplication function -* -* This test driver contains the following tests for psMatrix test point 5: -* A) Create input and output images -* B) Multiply images -* C) Free input and output images -* -* @author Ross Harman, MHPCC -* -* @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-08 22:28:08 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -* -*/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TOLERANCE 0.000001 - -#define CHECK_MATRIX(IMAGE) \ -for(psU32 i=0; inumRows; i++) { \ - for(psU32 j=0; jnumCols; j++) { \ - if(IMAGE->type.type == PS_TYPE_F64) { \ - if(fabs(IMAGE->data.F64[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %lf vs %lf\n", i, j, \ - IMAGE->data.F64[i][j], truthMatrix[i][j]); \ - } \ - } else if(IMAGE->type.type == PS_TYPE_F32){ \ - if(fabs(IMAGE->data.F32[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %f vs %lf\n", i, j, \ - IMAGE->data.F32[i][j], truthMatrix[i][j]); \ - } \ - } \ - } \ -} - - -psS32 main( psS32 argc, - char* argv[] ) -{ - psImage * outImage = NULL; - psImage *inImage1 = NULL; - psImage *inImage2 = NULL; - psImage * outImage32 = NULL; - psImage *inImage132 = NULL; - psImage *inImage232 = NULL; - - double truthMatrix[3][3] = {{ 0.0, 52.0}, - {-14.0, 51.0}}; - - // Test A - Create input and output images - printPositiveTestHeader(stdout, "psMatrix", "Create input and output images"); - outImage = (psImage*) psImageAlloc(2, 2, PS_TYPE_F64); - inImage1 = (psImage*) psImageAlloc(3, 2, PS_TYPE_F64); - inImage2 = (psImage*) psImageAlloc(2, 3, PS_TYPE_F64); - inImage1->data.F64[0][0] = 2; - inImage1->data.F64[0][1] = 3; - inImage1->data.F64[0][2] = 4; - inImage1->data.F64[1][0] = -1; - inImage1->data.F64[1][1] = 2; - inImage1->data.F64[1][2] = 5; - inImage2->data.F64[0][0] = 4; - inImage2->data.F64[0][1] = 1; - inImage2->data.F64[1][0] = 0; - inImage2->data.F64[1][1] = 6; - inImage2->data.F64[2][0] = -2; - inImage2->data.F64[2][1] = 8; - outImage32 = (psImage*)psImageAlloc(2, 2, PS_TYPE_F32); - inImage132 = (psImage*)psImageAlloc(3, 2, PS_TYPE_F32); - inImage232 = (psImage*)psImageAlloc(2, 3, PS_TYPE_F32); - inImage132->data.F32[0][0] = 2; - inImage132->data.F32[0][1] = 3; - inImage132->data.F32[0][2] = 4; - inImage132->data.F32[1][0] = -1; - inImage132->data.F32[1][1] = 2; - inImage132->data.F32[1][2] = 5; - inImage232->data.F32[0][0] = 4; - inImage232->data.F32[0][1] = 1; - inImage232->data.F32[1][0] = 0; - inImage232->data.F32[1][1] = 6; - inImage232->data.F32[2][0] = -2; - inImage232->data.F32[2][1] = 8; - printFooter( stdout, "psMatrix", "Create input and output images", true ); - - - // Test B - Multiply images - printPositiveTestHeader(stdout, "psMatrix", "Multiply images"); - psMatrixMultiply(outImage, inImage1, inImage2); - CHECK_MATRIX(outImage); - psMatrixMultiply(outImage32, inImage132, inImage232); - CHECK_MATRIX(outImage32); - printFooter(stdout, "psMatrix", "Multiply images", true); - - - // Test C - Free input and output images - printPositiveTestHeader( stdout, "psMatrix", "Free input and output images" ); - psFree(outImage); - psFree(inImage1); - psFree(inImage2); - psFree(outImage32); - psFree(inImage132); - psFree(inImage232); - psS32 nLeaks = psMemCheckLeaks( 0, NULL, stdout, false ); - if ( nLeaks != 0 ) { - printf( "ERROR: Found %d memory leaks\n", nLeaks ); - } - psS32 nBad = psMemCheckCorruption( 0 ); - if ( nBad ) { - printf( "ERROR: Found %d bad memory blocks\n", nBad ); - } - printFooter( stdout, "psMatrix" , "Free input and output images", true ); - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrix06.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix06.c (revision 4528) +++ (revision ) @@ -1,124 +1,0 @@ -/** @file tst_psMatrix_06.c -* -* @brief Test driver for psMatrix Eigenvectors function -* -* This test driver contains the following tests for psMatrix test point 6: -* A) Create input and output images -* B) Calculate Eigenvectors -* C) Free input and output images -* -* @author Ross Harman, MHPCC -* -* @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-04-07 20:27:42 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -* -*/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define TOLERANCE 0.000001 - -#define CHECK_MATRIX(IMAGE) \ -for(psU32 i=0; inumRows; i++) { \ - for(psU32 j=0; jnumCols; j++) { \ - if(IMAGE->type.type == PS_TYPE_F64) { \ - if(fabs(IMAGE->data.F64[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %lf vs %lf\n", i, j, \ - IMAGE->data.F64[i][j], truthMatrix[i][j]); \ - } \ - } else if(IMAGE->type.type == PS_TYPE_F32){ \ - if(fabs(IMAGE->data.F32[i][j]-truthMatrix[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %f vs %lf\n", i, j, \ - IMAGE->data.F32[i][j], truthMatrix[i][j]); \ - } \ - } \ - } \ -} - - -psS32 main(psS32 argc, char* argv[]) -{ - psImage * outImage = NULL; - psImage *inImage = NULL; - psImage * outImage32 = NULL; - psImage *inImage32 = NULL; - - double truthMatrix[4][4] = {{0.792608, 0.582076, -0.179186, -0.029193}, - {0.451923, -0.370502, 0.741918, 0.328712}, - {0.322416, -0.509579, -0.100228, -0.791411}, - {0.252161, -0.514048, -0.638283, 0.514553}}; - - - // Test A - Create input and output images - printPositiveTestHeader( stdout, "psMatrix", "Create input and output images" ); - outImage = (psImage*) psImageAlloc(4, 4, PS_TYPE_F64); - inImage = (psImage*) psImageAlloc(4, 4, PS_TYPE_F64); - - inImage->data.F64[0][0] = 1./1.; - inImage->data.F64[0][1] = 1./2.; - inImage->data.F64[0][2] = 1./3.; - inImage->data.F64[0][3] = 1./4.; - inImage->data.F64[1][0] = 1./2.; - inImage->data.F64[1][1] = 1./3.; - inImage->data.F64[1][2] = 1./4.; - inImage->data.F64[1][3] = 1./5.; - inImage->data.F64[2][0] = 1./3.; - inImage->data.F64[2][1] = 1./4.; - inImage->data.F64[2][2] = 1./5.; - inImage->data.F64[2][3] = 1./6.; - inImage->data.F64[3][0] = 1./4.; - inImage->data.F64[3][1] = 1./5.; - inImage->data.F64[3][2] = 1./6.; - inImage->data.F64[3][3] = 1./7.; - - outImage32 = (psImage*) psImageAlloc(4, 4, PS_TYPE_F32); - inImage32 = (psImage*) psImageAlloc(4, 4, PS_TYPE_F32); - inImage32->data.F32[0][0] = 1./1.; - inImage32->data.F32[0][1] = 1./2.; - inImage32->data.F32[0][2] = 1./3.; - inImage32->data.F32[0][3] = 1./4.; - inImage32->data.F32[1][0] = 1./2.; - inImage32->data.F32[1][1] = 1./3.; - inImage32->data.F32[1][2] = 1./4.; - inImage32->data.F32[1][3] = 1./5.; - inImage32->data.F32[2][0] = 1./3.; - inImage32->data.F32[2][1] = 1./4.; - inImage32->data.F32[2][2] = 1./5.; - inImage32->data.F32[2][3] = 1./6.; - inImage32->data.F32[3][0] = 1./4.; - inImage32->data.F32[3][1] = 1./5.; - inImage32->data.F32[3][2] = 1./6.; - inImage32->data.F32[3][3] = 1./7.; - printFooter(stdout, "psMatrix", "Create input and output images", true); - - - // Test B - Calculate Eigenvectors - printPositiveTestHeader(stdout, "psMatrix", "Calculate Eigenvectors"); - psMatrixEigenvectors(outImage, inImage); - CHECK_MATRIX(outImage); - psMatrixEigenvectors(outImage32, inImage32); - CHECK_MATRIX(outImage32); - printFooter(stdout, "psMatrix", "Calculate Eigenvectors", true); - - - // Test C - Free input and output images - printPositiveTestHeader(stdout, "psMatrix", "Free input and output images"); - psFree(outImage); - psFree(inImage); - psFree(outImage32); - psFree(inImage32); - psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false); - if (nLeaks != 0) { - printf("ERROR: Found %d memory leaks\n", nLeaks); - } - psS32 nBad = psMemCheckCorruption(0); - if (nBad) { - printf("ERROR: Found %d bad memory blocks\n", nBad); - } - printFooter(stdout, "psMatrix" , "Free input and output images", true); - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrix07.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrix07.c (revision 4528) +++ (revision ) @@ -1,313 +1,0 @@ -/** @file tst_psMatrix_07.c - * - * @brief Test driver for psMatrix vector conversion functions - * - * This test driver contains the following tests for psMatrix test point 7: - * A) Create input and output images and vectors - * B) Convert matrix to PS_DIMEN_VECTOR vector - * C) Attempt to use null image input argument - * D) Convert matrix to PS_DIMEN_TRANSV vector - * E) Improper image size - * F) Convert PS_DIMEN_VECTOR vector to matrix - * G) Attempt to use null input vector argument - * H) Convert PS_DIMEN_TRANSV vector to matrix - * I) Free input and output images and vectors - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - - -#define TOLERANCE 0.000001 - -#define CHECK_MATRIX(IMAGE,TRUTH) \ -for(psU32 i=0; inumRows; i++) { \ - for(psU32 j=0; jnumCols; j++) { \ - if(IMAGE->type.type == PS_TYPE_F64) { \ - if(fabs(IMAGE->data.F64[i][j]-TRUTH[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %lf vs %lf\n", i, j, \ - IMAGE->data.F64[i][j], TRUTH[i][j]); \ - } \ - } else if(IMAGE->type.type == PS_TYPE_F32){ \ - if(fabs(IMAGE->data.F32[i][j]-TRUTH[i][j]) > TOLERANCE) { \ - printf("Matrix values at element %d, %d don't agree %f vs %f\n", i, j, \ - IMAGE->data.F32[i][j], TRUTH[i][j]); \ - } \ - } \ - } \ -} - -#define CHECK_VECTOR(VECTOR) \ -for(psU32 i=0; in; i++) { \ - if(VECTOR->type.type == PS_TYPE_F64) { \ - if(fabs(VECTOR->data.F64[i]-truthVector[i]) > TOLERANCE) { \ - printf("Vector values at element %d don't agree %lf vs %lf\n", i, \ - VECTOR->data.F64[i], truthVector[i]); \ - } \ - } else if(VECTOR->type.type == PS_TYPE_F32){ \ - if(fabs(VECTOR->data.F32[i]-truthVector_32[i]) > TOLERANCE) { \ - printf("Vector values at element %d don't agree %f vs %lf\n", i, \ - VECTOR->data.F32[i], truthVector[i]); \ - } \ - } \ -} - - -psS32 main(psS32 argc, char* argv[]) -{ - psVector *v1 = NULL; - psVector *v1_32 = NULL; - psVector *tempVector = NULL; - psVector *tempVector_32 = NULL; - psImage *tempImage = NULL; - psImage *tempImage_32 = NULL; - psImage *m1 = NULL; - psImage *m1_32 = NULL; - psVector *v2 = NULL; - psVector *v2_32 = NULL; - psVector *v3 = NULL; - psVector *v3_32 = NULL; - psImage *m2 = NULL; - psImage *m2_32 = NULL; - psImage *m3 = NULL; - psImage *m3_32 = NULL; - psImage *m4 = NULL; - psImage *m4_32 = NULL; - psImage *badImage = NULL; - psImage *badImage_32 = NULL; - - psF64 truthVector[3] = {0.0, 1.0, 2.0}; - psF32 truthVector_32[3] = {0.0, 1.0, 2.0}; - psF64 truthMatrix[3][1] = {{0.0}, {1.0}, {2.0}}; - psF32 truthMatrix_32[3][1] = {{0.0}, {1.0}, {2.0}}; - - // Test A - Create input and output images - printPositiveTestHeader(stdout, "psMatrix", "Create input and output images and vectors"); - v1 = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - v1_32 = (psVector*)psVectorAlloc(3, PS_TYPE_F32); - m1 = (psImage*)psImageAlloc(1, 3, PS_TYPE_F64); - m1_32 = (psImage*)psImageAlloc(1,3,PS_TYPE_F32); - v2 = (psVector*)psVectorAlloc(3, PS_TYPE_F64); - v2_32 = (psVector*)psVectorAlloc(3,PS_TYPE_F32); - m2 = (psImage*)psImageAlloc(1, 3, PS_TYPE_F64); - m2_32 = (psImage*)psImageAlloc(1,3,PS_TYPE_F32); - m3 = (psImage*)psImageAlloc(3, 1, PS_TYPE_F64); - m3_32 = (psImage*)psImageAlloc(3,1,PS_TYPE_F32); - m4 = (psImage*)psImageAlloc(3, 1, PS_TYPE_F64); - m4_32 = (psImage*)psImageAlloc(3,1,PS_TYPE_F32); - badImage = (psImage*)psImageAlloc(2, 2, PS_TYPE_F64); - badImage_32 = (psImage*)psImageAlloc(2,2,PS_TYPE_F32); - m1->data.F64[0][0] = 0.0; - m1->data.F64[1][0] = 1.0; - m1->data.F64[2][0] = 2.0; - m1_32->data.F32[0][0] = 0.0; - m1_32->data.F32[1][0] = 1.0; - m1_32->data.F32[2][0] = 2.0; - v2->data.F64[0] = 0.0; - v2->data.F64[1] = 1.0; - v2->data.F64[2] = 2.0; - v2->n = 3; - v2_32->data.F32[0] = 0.0; - v2_32->data.F32[1] = 1.0; - v2_32->data.F32[2] = 2.0; - v2_32->n = 3; - m4->data.F64[0][0] = 0.0; - m4->data.F64[0][1] = 1.0; - m4->data.F64[0][2] = 2.0; - m4_32->data.F32[0][0] = 0.0; - m4_32->data.F32[0][1] = 1.0; - m4_32->data.F32[0][2] = 2.0; - printFooter(stdout, "psMatrix", "Create input and output images and vectors", true); - - // Test B - Convert matrix to PS_DIMEN_VECTOR vector - printPositiveTestHeader(stdout, "psMatrix", "Convert matrix to PS_DIMEN_VECTOR vector"); - tempVector = v1; - v1 = psMatrixToVector(v1, m1); - CHECK_VECTOR(v1); - if(v1->type.dimen != PS_DIMEN_VECTOR) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_VECTOR"); - return 1; - } else if(v1 != tempVector) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 2; - } - tempVector_32 = v1_32; - v1_32 = psMatrixToVector(v1_32, m1_32); - CHECK_VECTOR(v1_32); - if(v1_32->type.dimen != PS_DIMEN_VECTOR) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_VECTOR"); - return 1; - } else if(v1_32 != tempVector_32) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 2; - } - printFooter(stdout, "psMatrix", "Convert matrix to PS_DIMEN_VECTOR vector", true); - - - // Test C - Attempt to use null image input argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null image input argument", - "Invalid operation: inImage or its data is NULL.", 0); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error."); - v1 = psMatrixToVector(v1, NULL); - if(v1 != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with NULL input"); - return 3; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error."); - v1_32 = psMatrixToVector(v1_32, NULL); - if(v1_32 != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with NULL input"); - return 3; - } - printFooter(stdout, "psMatrix", "Attempt to use null image input argument", true); - - - // Test D - Convert matrix to PS_DIMEN_TRANSV vector - printPositiveTestHeader(stdout, "psMatrix", "Convert matrix to PS_DIMEN_TRANSV vector"); - v3 = psVectorAlloc(3, PS_TYPE_F64); - tempVector = v3; - v3->type.dimen = PS_DIMEN_TRANSV; - psMatrixToVector(v3, m4); - CHECK_VECTOR(v3); - if(v3->type.dimen != PS_DIMEN_TRANSV) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_TRANSV"); - return 4; - } else if(v3 != tempVector) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 5; - } - v3_32 = psVectorAlloc(3, PS_TYPE_F32); - tempVector_32 = v3_32; - v3_32->type.dimen = PS_DIMEN_TRANSV; - psMatrixToVector(v3_32, m4_32); - CHECK_VECTOR(v3_32); - if(v3_32->type.dimen != PS_DIMEN_TRANSV) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_TRANSV"); - return 6; - } else if(v3_32 != tempVector_32) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 7; - } - printFooter(stdout, "psMatrix", "Convert matrix to PS_DIMEN_TRANSV vector", true); - - - // Test E - Improper image size - printNegativeTestHeader(stdout,"psMatrix", "Improper image size", - "Image does not have dim with 1 col or 1 row: (2 x 2).", 0); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); - if(psMatrixToVector(v1, badImage) != NULL ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with improper sizes"); - return 8; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); - if(psMatrixToVector(v1_32, badImage_32) != NULL ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with improper sizes"); - return 9; - } - printFooter(stdout, "psMatrix", "Improper image size", true); - - - // Test F - Convert PS_DIMEN_VECTOR vector to matrix - printPositiveTestHeader(stdout, "psMatrix", "Convert PS_DIMEN_VECTOR vector to matrix"); - tempImage = m2; - m2 = psVectorToMatrix(m2, v2); - CHECK_MATRIX(m2,truthMatrix); - if(m2->type.dimen != PS_DIMEN_IMAGE) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_IMAGE"); - return 10; - } else if(m2 != tempImage) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 11; - } - tempImage_32 = m2_32; - m2_32 = psVectorToMatrix(m2_32, v2_32); - CHECK_MATRIX(m2_32,truthMatrix_32); - if(m2_32->type.dimen != PS_DIMEN_IMAGE) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_IMAGE"); - return 10; - } else if(m2_32 != tempImage_32) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 11; - } - printFooter(stdout, "psMatrix", "Convert PS_DIMEN_VECTOR vector to matrix", true); - - - // Test G - Attempt to use null input vector argument - printNegativeTestHeader(stdout,"psMatrix", "Attempt to use null input vector argument", - "Invalid operation: inVector or its data is NULL.", 0); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - if(psVectorToMatrix(m2, NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return output image"); - return 12; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - if(psVectorToMatrix(m2_32, NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return output image"); - return 13; - } - printFooter(stdout, "psMatrix", "Attempt to use null input vector argument", true); - - - // Test H - Convert PS_DIMEN_TRANSV vector to matrix - printPositiveTestHeader(stdout, "psMatrix", "Convert PS_DIMEN_TRANSV vector to matrix"); - v2->type.dimen = PS_DIMEN_TRANSV; - tempImage = m3; - psVectorToMatrix(m3, v2); - CHECK_MATRIX(m3, truthMatrix); - if(m3->type.dimen != PS_DIMEN_IMAGE) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_IMAGE"); - return 14; - } else if(m3 != tempImage) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 15; - } - v2_32->type.dimen = PS_DIMEN_TRANSV; - tempImage_32 = m3_32; - psVectorToMatrix(m3_32, v2_32); - CHECK_MATRIX(m3_32, truthMatrix_32); - if(m3_32->type.dimen != PS_DIMEN_IMAGE) { - psError(PS_ERR_UNKNOWN,true,"Resulting image is not PS_DIMEN_IMAGE"); - return 16; - } else if(m3_32 != tempImage_32) { - psError(PS_ERR_UNKNOWN,true,"Return pointer not equal to output argument pointer"); - return 17; - } - printFooter(stdout, "psMatrix", "Convert PS_DIMEN_TRANSV vector to matrix", true); - - - // Test I - Free input and output images - printPositiveTestHeader(stdout, "psMatrix", "Free input and output images and vectors"); - psFree(m1); - psFree(v1); - psFree(v2); - psFree(v3); - psFree(m3); - psFree(m4); - psFree(m1_32); - psFree(v1_32); - psFree(v2_32); - psFree(v3_32); - psFree(m3_32); - psFree(m4_32); - psFree(badImage); - psFree(badImage_32); - if( psMemCheckLeaks(0, NULL, stdout, false) != 0) { - psError(PS_ERR_UNKNOWN,true,"Memory leaks detected."); - return 10; - } - psS32 nBad = psMemCheckCorruption(0); - if(nBad) { - printf("ERROR: Found %d bad memory blocks\n", nBad); - } - printFooter(stdout, "psMatrix" ,"Free input and output images and vectors", true); - - return 0; -} Index: trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic01.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic01.c (revision 4528) +++ (revision ) @@ -1,205 +1,0 @@ -/** @file tst_psMatrixVectorArithmetic01.c - * - * @brief Test driver for psMatrixVector arithmetic functions - * - * This test driver tests combinations of matrix, vector, and scalar binary operations including: - * Matrix-matrix with +,-,*,/ with S32, F32, F64, C32 - * Matrix-vector with +,-,*,/ with S32, F32, F64, C32 - * Matrix-scalar with +,-,*,/ with S32, F32, F64, C32 - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - -#define PRINT_SCALAR(SCALAR,TYPE) \ -if(PS_IS_PSELEMTYPE_COMPLEX(SCALAR->type.type)) { \ - printf("%f+%fi ", creal(SCALAR->data.TYPE), cimag(SCALAR->data.TYPE)); \ -} else if(PS_IS_PSELEMTYPE_INT(SCALAR->type.type)) { \ - printf("%d ", (psS32)SCALAR->data.TYPE); \ -} else { \ - printf("%f ", (double)SCALAR->data.TYPE); \ -} \ -printf("\n\n"); - -#define PRINT_VECTOR(VECTOR,TYPE) \ -for(psS32 i=0; in; i++) { \ - if(PS_IS_PSELEMTYPE_COMPLEX(VECTOR->type.type)) { \ - printf("%f+%fi ", creal(VECTOR->data.TYPE[i]), cimag(VECTOR->data.TYPE[i])); \ - } else if(PS_IS_PSELEMTYPE_INT(VECTOR->type.type)) { \ - printf("%d ", (psS32)VECTOR->data.TYPE[i]); \ - } else { \ - printf("%f ", (double)VECTOR->data.TYPE[i]); \ - } \ -} \ -printf("\n\n"); - - -#define PRINT_MATRIX(IMAGE,TYPE) \ -for(psS32 i=IMAGE->numRows-1; i>-1; i--) { \ - for(psS32 j=0; jnumCols; j++) { \ - if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) { \ - printf("%f+%fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j])); \ - } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) { \ - printf("%d ", (psS32)IMAGE->data.TYPE[i][j]); \ - } else { \ - printf("%f ", (double)IMAGE->data.TYPE[i][j]); \ - } \ - } \ - printf("\n"); \ -} \ -printf("\n"); - - -#define CREATE_AND_SET_VECTOR(NAME,TYPE,VALUE,SIZE) \ -psVector *NAME = (psVector*)psVectorAlloc(SIZE, PS_TYPE_##TYPE); \ -for(psS32 i=0; idata.TYPE[i] = VALUE; \ -} \ -NAME->n = SIZE; - - -#define CREATE_AND_SET_IMAGE(NAME,TYPE,VALUE,NROWS,NCOLS) \ -psImage *NAME = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ -for(psS32 i=0; inumRows; i++) { \ - for(psS32 j=0; jnumCols; j++) { \ - NAME->data.TYPE[i][j] = VALUE; \ - } \ -} - - -#define CHECK_MEMORY \ -if(psMemCheckLeaks(0, NULL, stdout, false) != 0 ) { \ - psError(PS_ERR_UNKNOWN,true,"Memory leaks detected."); \ - return 10; \ -} \ -psS32 nBad = psMemCheckCorruption(0); \ -if(nBad) { \ - printf("ERROR: Found %d bad memory blocks\n", nBad); \ -} - - -psS32 main(psS32 argc, char* argv[]) -{ - - // Test matrix-matrix binary operations - #define testBinaryOpMM(OP,TYPE,VALUE1,VALUE2,NROWS,NCOLS) \ - { \ - printPositiveTestHeader(stdout, "psMatrixVectorArithmetic", "Test matrix-matrix psBinaryOp"); \ - printf("Operation: %s\n", #OP); \ - CREATE_AND_SET_IMAGE(inImage,TYPE,VALUE1,NROWS,NCOLS); \ - CREATE_AND_SET_IMAGE(outImage,TYPE,VALUE2,NROWS,NCOLS); \ - printf("Input:\n"); \ - PRINT_MATRIX(inImage,TYPE); \ - PRINT_MATRIX(outImage,TYPE); \ - outImage = (psImage*)psBinaryOp(outImage, inImage, #OP, outImage); \ - printf("Output:\n"); \ - PRINT_MATRIX(outImage,TYPE); \ - psFree(inImage); \ - psFree(outImage); \ - CHECK_MEMORY; \ - printFooter(stdout, "psMatrixVectorArithmetic", "Test matrix-matrix psBinaryOp", true); \ - } - - testBinaryOpMM(+,S32,10,10,3,2); - testBinaryOpMM(+,F32,10.0,10.0,3,2); - testBinaryOpMM(+,F64,10.0,10.0,3,2); - testBinaryOpMM(+,C32,10.0+10.0i,10.0+10.0i,3,2); - testBinaryOpMM(-,S32,20,10,3,2); - testBinaryOpMM(-,F32,20.0,10.0,3,2); - testBinaryOpMM(-,F64,20.0,10.0,3,2); - testBinaryOpMM(*,C32,20.0+20.0i,10.0+10.0i,3,2); - testBinaryOpMM(*,S32,20,10,3,2); - testBinaryOpMM(*,F32,20.0,10.0,3,2); - testBinaryOpMM(*,F64,20.0,10.0,3,2); - testBinaryOpMM(*,C32,20.0+20.0i,10.0+10.0i,3,2); - testBinaryOpMM(/,C32,20.0+20.0i,10.0+10.0i,3,2); - testBinaryOpMM(/,S32,20,10,3,2); - testBinaryOpMM(/,F32,20.0,10.0,3,2); - testBinaryOpMM(/,F64,20.0,10.0,3,2); - testBinaryOpMM(/,C32,20.0+20.0i,10.0+10.0i,3,2); - - // Test Matrix-Vector binary operations - #define testBinaryOpMV(OP,TYPE,VALUE1,VALUE2,NROWS,NCOLS) \ - { \ - printPositiveTestHeader(stdout, "psMatrixVectorArithmetic", "Test matrix-vector psBinaryOp"); \ - printf("Operation: %s\n", #OP); \ - CREATE_AND_SET_IMAGE(outImage,TYPE,VALUE1,NROWS,NCOLS); \ - CREATE_AND_SET_VECTOR(inVector,TYPE,VALUE2,NROWS); \ - printf("Input:\n"); \ - PRINT_MATRIX(outImage,TYPE); \ - PRINT_VECTOR(inVector,TYPE); \ - outImage = (psImage*)psBinaryOp(outImage, outImage, #OP, inVector); \ - printf("Output:\n"); \ - PRINT_MATRIX(outImage,TYPE); \ - psFree(inVector); \ - psFree(outImage); \ - CHECK_MEMORY; \ - printFooter(stdout, "psMatrixVectorArithmetic", "Test matrix-vector psBinaryOp", true); \ - } - - testBinaryOpMV(+,S32,10,5,3,2); - testBinaryOpMV(+,F32,10.0,5.0,3,2); - testBinaryOpMV(+,F64,10.0,5.0,3,2); - testBinaryOpMV(+,C32,10.0+10.0i,5.0+5.0i,3,2); - testBinaryOpMV(-,S32,20,5,3,2); - testBinaryOpMV(-,F32,20.0,5.0,3,2); - testBinaryOpMV(-,F64,20.0,5.0,3,2); - testBinaryOpMV(*,C32,20.0+20.0i,5.0+5.0i,3,2); - testBinaryOpMV(*,S32,20,5,3,2); - testBinaryOpMV(*,F32,20.0,5.0,3,2); - testBinaryOpMV(*,F64,20.0,5.0,3,2); - testBinaryOpMV(*,C32,20.0+20.0i,5.0+5.0i,3,2); - testBinaryOpMV(/,C32,20.0+20.0i,5.0+5.0i,3,2); - testBinaryOpMV(/,S32,20,5,3,2); - testBinaryOpMV(/,F32,20.0,5.0,3,2); - testBinaryOpMV(/,F64,20.0,5.0,3,2); - testBinaryOpMV(/,C32,20.0+20.0i,5.0+5.0i,3,2); - - // Test Matrix-Scalar binary operations - #define testBinaryOpMS(OP,TYPE,VALUE1,VALUE2,NROWS,NCOLS) \ - { \ - printPositiveTestHeader(stdout, "psMatrixVectorArithmetic", "Test matrix-scalar psBinaryOp"); \ - printf("Operation: %s\n", #OP); \ - CREATE_AND_SET_IMAGE(outImage,TYPE,VALUE1,NROWS,NCOLS); \ - psScalar *inScalar = (psScalar*)psScalarAlloc(VALUE2,PS_TYPE_##TYPE); \ - printf("Input:\n"); \ - PRINT_MATRIX(outImage,TYPE); \ - PRINT_SCALAR(inScalar,TYPE); \ - outImage = (psImage*)psBinaryOp(outImage, outImage, #OP, psScalarCopy(inScalar)); \ - printf("Output:\n"); \ - PRINT_MATRIX(outImage,TYPE); \ - psFree(inScalar); \ - psFree(outImage); \ - CHECK_MEMORY; \ - printFooter(stdout, "psMatrixVectorArithmetic", "Test matrix-scalar psBinaryOp", true); \ - } - - testBinaryOpMS(+,S32,10,5,3,2); - testBinaryOpMS(+,F32,10.0,5.0,3,2); - testBinaryOpMS(+,F64,10.0,5.0,3,2); - testBinaryOpMS(+,C32,10.0+10.0i,5.0+5.0i,3,2); - testBinaryOpMS(-,S32,20,5,3,2); - testBinaryOpMS(-,F32,20.0,5.0,3,2); - testBinaryOpMS(-,F64,20.0,5.0,3,2); - testBinaryOpMS(*,C32,20.0+20.0i,5.0+5.0i,3,2); - testBinaryOpMS(*,S32,20,5,3,2); - testBinaryOpMS(*,F32,20.0,5.0,3,2); - testBinaryOpMS(*,F64,20.0,5.0,3,2); - testBinaryOpMS(*,C32,20.0+20.0i,5.0+5.0i,3,2); - testBinaryOpMS(/,C32,20.0+20.0i,5.0+5.0i,3,2); - testBinaryOpMS(/,S32,20,5,3,2); - testBinaryOpMS(/,F32,20.0,5.0,3,2); - testBinaryOpMS(/,F64,20.0,5.0,3,2); - testBinaryOpMS(/,C32,20.0+20.0i,5.0+5.0i,3,2); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c (revision 4528) +++ (revision ) @@ -1,269 +1,0 @@ - -/** @file tst_psMatrixVectorArithmetic02.c - * - * @brief Test driver for psMatrixVector arithmetic functions - * - * This test driver tests combinations of matrix, vector, and scalar unary operations including: - * Matrix with all math operators with S32, F32, F64, C32 - * Vector with all math operators with S32, F32, F64, C32 - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-05-11 22:02:16 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - -#include - - -#define CHECK_VECTOR(VECTOR,TYPE,TRUTH) \ -for(psS32 i=0; in; i++) { \ - if(cabs(VECTOR->data.TYPE[i])-cabs(TRUTH) > FLT_EPSILON){ \ - printf("ERROR:Truth and calculated values don't match for vector operation:\n"); \ - if(PS_IS_PSELEMTYPE_COMPLEX(VECTOR->type.type)) { \ - printf("Truth: %.2f%+.2fi\n", creal(VECTOR->data.TYPE[i]), cimag(VECTOR->data.TYPE[i])); \ - printf("Calculated: %.2f%+.2fi\n", creal(TRUTH), cimag(TRUTH)); \ - } else if(PS_IS_PSELEMTYPE_INT(VECTOR->type.type)) { \ - printf("Truth: %d\n", (psS32)(VECTOR->data.TYPE[i])); \ - printf("Calculated: %d\n", (psS32)(TRUTH)); \ - } else { \ - printf("Truth: %.2f\n", (double)(VECTOR->data.TYPE[i])); \ - printf("Calculated: %.2f\n", (double)(TRUTH)); \ - } \ - } \ -} \ -printf("\n"); - - -#define CHECK_MATRIX(IMAGE,TYPE,TRUTH) \ -for(psS32 i=IMAGE->numRows-1; i>-1; i--) { \ - for(psS32 j=0; jnumCols; j++) { \ - if(cabs(IMAGE->data.TYPE[i][j])-cabs(TRUTH) > FLT_EPSILON){ \ - printf("ERROR:Truth and calculated values don't match for matrix operation:\n"); \ - if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) { \ - printf("Truth: %.2f%+.2fi\n", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j])); \ - printf("Calculated: %.2f%+.2fi\n", creal(TRUTH), cimag(TRUTH)); \ - } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) { \ - printf("Truth: %d\n", (psS32)(IMAGE->data.TYPE[i][j])); \ - printf("Calculated: %d\n", (psS32)(TRUTH)); \ - } else { \ - printf("Truth: %.2f\n", (double)(IMAGE->data.TYPE[i][j])); \ - printf("Calculated: %.2f\n", (double)(TRUTH)); \ - } \ - } \ - } \ - printf("\n"); \ -} \ -printf("\n"); - - -#define CREATE_AND_SET_VECTOR(NAME,TYPE,VALUE,SIZE) \ -psVector *NAME = (psVector*)psVectorAlloc(SIZE, PS_TYPE_##TYPE); \ -for(psS32 i=0; idata.TYPE[i] = VALUE; \ -} \ -NAME->n = SIZE; - - -#define CREATE_AND_SET_IMAGE(NAME,TYPE,VALUE,NROWS,NCOLS) \ -psImage *NAME = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ -for(psS32 i=0; inumRows; i++) { \ - for(psS32 j=0; jnumCols; j++) { \ - NAME->data.TYPE[i][j] = VALUE; \ - } \ -} - - -#define CHECK_MEMORY \ -if( psMemCheckLeaks(0, NULL, stdout, false) != 0 ) { \ - psError(PS_ERR_UNKNOWN, true,"Memory leaks detected."); \ - return 50; \ -} \ -psS32 nBad = psMemCheckCorruption(0); \ -if(nBad) { \ - psError(PS_ERR_UNKNOWN, true,"ERROR: Found %d bad memory blocks\n", nBad); \ - return 51; \ -} - - -psS32 main( psS32 argc, char* argv[] ) -{ - - // Test matrix unary operations - #define testUnaryOpM(OP,TYPE,VALUE1,VALUE2,NROWS,NCOLS,TRUTH) \ - { \ - printPositiveTestHeader(stdout, "psMatrixVectorArithmetic", "Test matrix psUnaryOp"); \ - printf("Operation: %s\n", #OP); \ - CREATE_AND_SET_IMAGE(inImage,TYPE,VALUE1,NROWS,NCOLS); \ - CREATE_AND_SET_IMAGE(outImage,TYPE,VALUE2,NROWS,NCOLS); \ - outImage = (psImage*)psUnaryOp(outImage, inImage, #OP); \ - CHECK_MATRIX(outImage,TYPE,TRUTH); \ - psFree(inImage); \ - psFree(outImage); \ - CHECK_MEMORY; \ - printFooter(stdout, "psMatrixVectorArithmetic", "Test matrix psUnaryOp", true); \ - } - - testUnaryOpM( abs, S32, -10, 0, 3, 2, 10 ); - testUnaryOpM( abs, F32, -10.0, 0.0, 3, 2, 10.0 ); - testUnaryOpM( abs, F64, -10.0, 0.0, 3, 2, 10.0 ); - testUnaryOpM( abs, C32, -10.0 - 10.0i, 0.0 + 0.0i, 3, 2,10+10i ); - testUnaryOpM( exp, S32, 10, 0, 3, 2, cexp(10)); - testUnaryOpM( exp, F32, 10.0, 0.0, 3, 2, cexp(10.0) ); - testUnaryOpM( exp, F64, 10.0, 0.0, 3, 2, cexp(10.0) ); - testUnaryOpM( exp, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2, cexp(1.0+1.0i) ); - testUnaryOpM( ln, S32, 10, 0, 3, 2, clog(10) ); - testUnaryOpM( ln, F32, 10.0, 0.0, 3, 2, clog(10.0) ); - testUnaryOpM( ln, F64, 10.0, 0.0, 3, 2, clog(10.0) ); - testUnaryOpM( ln, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3, 2, clog(10.0+10.0i) ); - testUnaryOpM( ten, S32, 3, 0, 3, 2, 1000 ); - testUnaryOpM( ten, F32, 3.0, 0.0, 3, 2, 1000 ); - testUnaryOpM( ten, F64, 3.0, 0.0, 3, 2, 1000 ); - testUnaryOpM( ten, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 2, 10.0 ); - testUnaryOpM( log, S32, 1000, 0, 3, 2, 3 ); - testUnaryOpM( log, F32, 1000.0, 0.0, 3, 2, 3 ); - testUnaryOpM( log, F64, 1000.0, 0.0, 3, 2, 3 ); - testUnaryOpM( log, C32, 1000.0 + 0.0i, 0.0 + 0.0i, 3, 2, 3 ); - testUnaryOpM( sin, S32, M_PI_2, 0, 3, 2, 1 ); - testUnaryOpM( sin, F32, M_PI_2, 0.0, 3, 2, 1.0 ); - testUnaryOpM( sin, F64, M_PI_2, 0.0, 3, 2, 1.0 ); - testUnaryOpM( sin, C32, M_PI_2 + 0.0i, 0.0 + 0.0i, 3, 2, 1.0 ); - testUnaryOpM( dsin, S32, 90, 0, 3, 2 , 1); - testUnaryOpM( dsin, F32, 90.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( dsin, F64, 90.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( dsin, C32, 90.0 + 00.0i, 0.0 + 0.0i, 3, 2, 1.0 ); - testUnaryOpM( cos, S32, 0, 0, 3, 2, 1 ); - testUnaryOpM( cos, F32, 0.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( cos, F64, 0.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( cos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, 1.0 ); - testUnaryOpM( dcos, S32, 0, 0, 3, 2, 1 ); - testUnaryOpM( dcos, F32, 0.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( dcos, F64, 0.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( dcos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, 1.0 ); - testUnaryOpM( tan, S32, M_PI_4, 0, 3, 2, 1); - testUnaryOpM( tan, F32, M_PI_4, 0.0, 3, 2, 1.0 ); - testUnaryOpM( tan, F64, M_PI_4, 0.0, 3, 2, 1.0 ); - testUnaryOpM( tan, C32, M_PI_4 + 0.0i, 0.0 + 0.0i, 3, 2, 1 ); - testUnaryOpM( dtan, S32, 45, 0, 3, 2, 1 ); - testUnaryOpM( dtan, F32, 45.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( dtan, F64, 45.0, 0.0, 3, 2, 1.0 ); - testUnaryOpM( dtan, C32, 45.0 + 45.0i, 0.0 + 0.0i, 3, 2, 1.0 ); - testUnaryOpM( asin, S32, 1, 0, 3, 2, M_PI_2); - testUnaryOpM( asin, F32, 1.0, 0.0, 3, 2, M_PI_2 ); - testUnaryOpM( asin, F64, 1.0, 0.0, 3, 2, M_PI_2); - testUnaryOpM( asin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2, M_PI_2); - testUnaryOpM( dasin, S32, 1.0, 0, 3, 2, 90 ); - testUnaryOpM( dasin, F32, 1.0, 0.0, 3, 2, 90.0 ); - testUnaryOpM( dasin, F64, 1.0, 0.0, 3, 2, 90.0 ); - testUnaryOpM( dasin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2, 90.0 ); - testUnaryOpM( acos, S32, 0, 0, 3, 2, M_PI_2); - testUnaryOpM( acos, F32, 0.0, 0.0, 3, 2, M_PI_2 ); - testUnaryOpM( acos, F64, 0.0, 0.0, 3, 2, M_PI_2 ); - testUnaryOpM( acos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, M_PI_2 ); - testUnaryOpM( dacos, S32, 0, 0, 3, 2, 90 ); - testUnaryOpM( dacos, F32, 0.0, 0.0, 3, 2, 90.0 ); - testUnaryOpM( dacos, F64, 0.0, 0.0, 3, 2, 90.0 ); - testUnaryOpM( dacos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, 90.0 ); - testUnaryOpM( atan, S32, 1, 0, 3, 2, M_PI_4); - testUnaryOpM( atan, F32, 1.0, 0.0, 3, 2, M_PI_4 ); - testUnaryOpM( atan, F64, 1.0, 0.0, 3, 2, M_PI_4); - testUnaryOpM( atan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 2, M_PI_4); - testUnaryOpM( datan, S32, 1, 0, 3, 2, 45 ); - testUnaryOpM( datan, F32, 1.0, 0.0, 3, 2, 45.0 ); - testUnaryOpM( datan, F64, 1.0, 0.0, 3, 2, 45.0 ); - testUnaryOpM( datan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 2, 45.0 ); - - - // Test vector unary operations - #define testUnaryOpV(OP,TYPE,VALUE1,VALUE2,SIZE,TRUTH) \ - { \ - printPositiveTestHeader(stdout, "psMatrixVectorArithmetic", "Test vector psUnaryOp"); \ - printf("Operation: %s\n", #OP); \ - CREATE_AND_SET_VECTOR(inVector,TYPE,VALUE1,SIZE); \ - CREATE_AND_SET_VECTOR(outVector,TYPE,VALUE2,SIZE); \ - outVector = (psVector*)psUnaryOp(outVector, inVector, #OP); \ - CHECK_VECTOR(outVector,TYPE,TRUTH); \ - psFree(inVector); \ - psFree(outVector); \ - CHECK_MEMORY; \ - printFooter(stdout, "psMatrixVectorArithmetic", "Test vector psUnaryOp", true); \ - } - - testUnaryOpV( abs, S32, -10, 0, 3, 10 ); - testUnaryOpV( abs, F32, -10.0, 0.0, 3, 10.0 ); - testUnaryOpV( abs, F64, -10.0, 0.0, 3, 10.0 ); - testUnaryOpV( abs, C32, -10.0 - 10.0i, 0.0 + 0.0i, 3, 10+10i ); - testUnaryOpV( exp, S32, 10, 0, 3, cexp(10)); - testUnaryOpV( exp, F32, 10.0, 0.0, 3, cexp(10.0) ); - testUnaryOpV( exp, F64, 10.0, 0.0, 3, cexp(10.0) ); - testUnaryOpV( exp, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, cexp(1.0+1.0i) ); - testUnaryOpV( ln, S32, 10, 0, 3, clog(10) ); - testUnaryOpV( ln, F32, 10.0, 0.0, 3, clog(10.0) ); - testUnaryOpV( ln, F64, 10.0, 0.0, 3, clog(10.0) ); - testUnaryOpV( ln, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3, clog(10.0+10.0i) ); - testUnaryOpV( ten, S32, 3, 0, 3, 1000 ); - testUnaryOpV( ten, F32, 3.0, 0.0, 3, 1000 ); - testUnaryOpV( ten, F64, 3.0, 0.0, 3, 1000 ); - testUnaryOpV( ten, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 10.0 ); - testUnaryOpV( log, S32, 1000, 0, 3, 3 ); - testUnaryOpV( log, F32, 1000.0, 0.0, 3, 3 ); - testUnaryOpV( log, F64, 1000.0, 0.0, 3, 3 ); - testUnaryOpV( log, C32, 1000.0 + 0.0i, 0.0 + 0.0i, 3, 3 ); - testUnaryOpV( sin, S32, M_PI_2, 0, 3, 1 ); - testUnaryOpV( sin, F32, M_PI_2, 0.0, 3, 1.0 ); - testUnaryOpV( sin, F64, M_PI_2, 0.0, 3, 1.0 ); - testUnaryOpV( sin, C32, M_PI_2 + 0.0i, 0.0 + 0.0i, 3, 1.0 ); - testUnaryOpV( dsin, S32, 90, 0, 3, 1); - testUnaryOpV( dsin, F32, 90.0, 0.0, 3, 1.0 ); - testUnaryOpV( dsin, F64, 90.0, 0.0, 3, 1.0 ); - testUnaryOpV( dsin, C32, 90.0 + 00.0i, 0.0 + 0.0i, 3, 1.0 ); - testUnaryOpV( cos, S32, 0, 0, 3, 1 ); - testUnaryOpV( cos, F32, 0.0, 0.0, 3, 1.0 ); - testUnaryOpV( cos, F64, 0.0, 0.0, 3, 1.0 ); - testUnaryOpV( cos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 1.0 ); - testUnaryOpV( dcos, S32, 0, 0, 3, 1 ); - testUnaryOpV( dcos, F32, 0.0, 0.0, 3, 1.0 ); - testUnaryOpV( dcos, F64, 0.0, 0.0, 3, 1.0 ); - testUnaryOpV( dcos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 1.0 ); - testUnaryOpV( tan, S32, M_PI_4, 0, 3, 1); - testUnaryOpV( tan, F32, M_PI_4, 0.0, 3, 1.0 ); - testUnaryOpV( tan, F64, M_PI_4, 0.0, 3, 1.0 ); - testUnaryOpV( tan, C32, M_PI_4 + 0.0i, 0.0 + 0.0i, 3, 1 ); - testUnaryOpV( dtan, S32, 45, 0, 3, 1 ); - testUnaryOpV( dtan, F32, 45.0, 0.0, 3, 1.0 ); - testUnaryOpV( dtan, F64, 45.0, 0.0, 3, 1.0 ); - testUnaryOpV( dtan, C32, 45.0 + 45.0i, 0.0 + 0.0i, 3, 1.0 ); - testUnaryOpV( asin, S32, 1, 0, 3, M_PI_2); - testUnaryOpV( asin, F32, 1.0, 0.0, 3, M_PI_2 ); - testUnaryOpV( asin, F64, 1.0, 0.0, 3, M_PI_2); - testUnaryOpV( asin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, M_PI_2); - testUnaryOpV( dasin, S32, 1.0, 0, 3, 90 ); - testUnaryOpV( dasin, F32, 1.0, 0.0, 3, 90.0 ); - testUnaryOpV( dasin, F64, 1.0, 0.0, 3, 90.0 ); - testUnaryOpV( dasin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 90.0 ); - testUnaryOpV( acos, S32, 0, 0, 3, M_PI_2); - testUnaryOpV( acos, F32, 0.0, 0.0, 3, M_PI_2 ); - testUnaryOpV( acos, F64, 0.0, 0.0, 3, M_PI_2 ); - testUnaryOpV( acos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, M_PI_2 ); - testUnaryOpV( dacos, S32, 0, 0, 3, 90 ); - testUnaryOpV( dacos, F32, 0.0, 0.0, 3, 90.0 ); - testUnaryOpV( dacos, F64, 0.0, 0.0, 3, 90.0 ); - testUnaryOpV( dacos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 90.0 ); - testUnaryOpV( atan, S32, 1, 0, 3, M_PI_4); - testUnaryOpV( atan, F32, 1.0, 0.0, 3, M_PI_4 ); - testUnaryOpV( atan, F64, 1.0, 0.0, 3, M_PI_4); - testUnaryOpV( atan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, M_PI_4); - testUnaryOpV( datan, S32, 1, 0, 3, 45 ); - testUnaryOpV( datan, F32, 1.0, 0.0, 3, 45.0 ); - testUnaryOpV( datan, F64, 1.0, 0.0, 3, 45.0 ); - testUnaryOpV( datan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 45.0 ); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic03.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic03.c (revision 4528) +++ (revision ) @@ -1,314 +1,0 @@ -/** @file tst_psMatrixVectorArithmetic03.c - * - * @brief Test driver for psMatrixVector arithmetic functions - * - * This test driver contains negative tests for psBinaryOp and psUanryOp: - * Check for NULL arguments - * Inconsistent element types - * Inconsistent element count - * Inconsistent dimensionality - * Division by zero - * Attempt to use min with complex numbers - * Attempt to use max with complex numbers - * Invalid operation - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - -#define PRINT_VECTOR(VECTOR,TYPE) \ -for(psS32 i=0; in; i++) { \ - if(PS_IS_PSELEMTYPE_COMPLEX(VECTOR->type.type)) { \ - printf("%f+%fi ", creal(VECTOR->data.TYPE[i]), cimag(VECTOR->data.TYPE[i])); \ - } else if(PS_IS_PSELEMTYPE_INT(VECTOR->type.type)) { \ - printf("%d ", (psS32)VECTOR->data.TYPE[i]); \ - } else { \ - printf("%f ", (double)VECTOR->data.TYPE[i]); \ - } \ -} \ -printf("\n\n"); - -#define PRINT_MATRIX(IMAGE,TYPE) \ -for(psS32 i=IMAGE->numRows-1; i>-1; i--) { \ - for(psS32 j=0; jnumCols; j++) { \ - if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) { \ - printf("%f+%fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j])); \ - } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) { \ - printf("%d ", (psS32)IMAGE->data.TYPE[i][j]); \ - } else { \ - printf("%f ", (double)IMAGE->data.TYPE[i][j]); \ - } \ - } \ - printf("\n"); \ -} \ -printf("\n"); - - -#define CREATE_AND_SET_VECTOR(NAME,TYPE,VALUE,SIZE) \ -psVector *NAME = (psVector*)psVectorAlloc(SIZE, PS_TYPE_##TYPE); \ -for(psS32 i=0; idata.TYPE[i] = VALUE; \ -} \ -NAME->n = SIZE; - - -#define CREATE_AND_SET_IMAGE(NAME,TYPE,VALUE,NROWS,NCOLS) \ -psImage *NAME = (psImage*)psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ -for(psS32 i=0; inumRows; i++) { \ - for(psS32 j=0; jnumCols; j++) { \ - NAME->data.TYPE[i][j] = VALUE; \ - } \ -} - - -psS32 main(psS32 argc, char* argv[]) -{ - CREATE_AND_SET_IMAGE(image1,F64,0,3,3); - CREATE_AND_SET_IMAGE(image2,F64,0,3,3); - CREATE_AND_SET_IMAGE(image3,F32,0,3,3); - CREATE_AND_SET_IMAGE(image4,F64,0,2,2); - CREATE_AND_SET_IMAGE(image5,C32,1+1i,3,3); - CREATE_AND_SET_VECTOR(vector1,F64,0,2); - CREATE_AND_SET_VECTOR(vector2,F64,0,3); - - // Check for NULL output argument - printPositiveTestHeader(stdout,"psBinaryOp", "Check for output generated"); - psImage* image6 = (psImage*)psBinaryOp(NULL, image1, "+", image2); - if (image6 == NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp failed to make an image given no output to recycle."); - return 1; - } - printFooter(stdout,"psBinaryOp","Check for output generated",true); - - // Check for NULL input argument #1 - printPositiveTestHeader(stdout,"psBinaryOp","Check for null input arg 1"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, NULL, "+", image2); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given a NULL first operand."); - return 2; - } - printFooter(stdout,"psBinaryOp","Check for null input arg 1",true); - - // Check for NULL input argument #2 - printPositiveTestHeader(stdout,"psBinaryOp","Check for null input arg 2"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, image1, "+", NULL); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given a NULL second operand."); - return 3; - } - printFooter(stdout,"psBinaryOp","Check for null input arg 2",true); - - // Check for NULL operand - printPositiveTestHeader(stdout,"psBinaryOp","Check for null operand"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, image1, NULL, image2); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given a NULL operator."); - return 4; - } - printFooter(stdout,"psBinaryOp","Check for null operand",true); - - // Check for null output - printPositiveTestHeader(stdout,"psUnaryOp","Check for null output"); - image6 = (psImage*)psUnaryOp(NULL, image1, "sin"); - if (image6 == NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp failed to make an image given no output to recycle."); - return 5; - } - printFooter(stdout,"psUnaryOp","Check for null output",true); - - // Check for NULL input arg - printPositiveTestHeader(stdout,"psUnaryOp","Check for null input"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psUnaryOp(image6, NULL, "sin"); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp returned a result given a NULL operand."); - return 6; - } - printFooter(stdout,"psUnaryOp","Check for null input",true); - - // Check for NULL operand - printPositiveTestHeader(stdout,"psUnaryOp","Check for null operator"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psUnaryOp(image6, image1, NULL); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp returned a result given a NULL operator."); - return 7; - } - printFooter(stdout,"psUnaryOp","Check for null operator",true); - - // Inconsistent element types - printPositiveTestHeader(stdout,"psBinaryOp", "Inconsistent element types"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, image3, "+", image2); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given operands of different types."); - return 8; - } - printFooter(stdout,"psBinaryOp","Inconsistent element types",true); - - // Check unary op to convert to correct type - printPositiveTestHeader(stdout,"psUnaryOp","Check output type conversion"); - image6 = psImageCopy(image6,image2,PS_TYPE_F64); - image6 = (psImage*)psUnaryOp(image6, image3, "sin"); - if (image6 == NULL || image6->type.type != PS_TYPE_F32) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp failed to convert the type of the output."); - return 9; - } - printFooter(stdout,"psUnaryOp","Check output type conversion",true); - - // Inconsistent element count - printPositiveTestHeader(stdout,"psBinaryOp","Check for inconsistent elements"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, image4, "+", image2); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given operands of different sizes."); - return 10; - } - printFooter(stdout,"psBinaryOp","Check for inconsistent elements",true); - - // Inconsistent element in input and output - printPositiveTestHeader(stdout,"psUnaryOp","Check inconsistent elements in input and output"); - image6 = psImageCopy(image6,image2,PS_TYPE_F64); - image6 = (psImage*)psUnaryOp(image6, image4, "sin"); - if (image6 == NULL || - image6->numCols != image6->numCols || - image6->numRows != image6->numRows) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp failed to resize the output."); - return 11; - } - printFooter(stdout,"psUnaryOp","Check inconsistent elements in input and output",true); - - // Inconsistent size of input 1 and input 2 - printPositiveTestHeader(stdout,"psBinaryOp","Check inconsistent size"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, vector1, "+", image2); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given operands of different sizes."); - return 12; - } - printFooter(stdout,"psBinaryOp","Check inconsistent size",true); - - // Inconsistent size of input 1 and input 2 - printPositiveTestHeader(stdout,"psBinaryOp","Check inconsistent size"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - vector1->type.dimen = PS_DIMEN_TRANSV; - image6 = (psImage*)psBinaryOp(image6, vector1, "+", image2); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned a result given operands of different sizes."); - return 13; - } - printFooter(stdout, "psBinaryOp", "Check inconsistent size", true); - - - // Inconsistent dimensionality - printPositiveTestHeader(stdout,"psUnaryOp","Check inconsistent dimensionality"); - image6 = psImageCopy(image6,image2,PS_TYPE_F64); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an two error messages"); - image6 = (psImage*)psUnaryOp(image6, vector2, "sin"); - if (image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp returned result given wrong type out parameter."); - return 14; - } - printFooter(stdout,"psUnaryOp","Check inconsistent dimensionality",true); - - // Attempt to use min with complex numbers - printPositiveTestHeader(stdout,"psBinaryOp","Attempt to use min with complex numbers"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); - image6 = (psImage*)psBinaryOp(image6, image5, "min", image5); - if(image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp returned result with min of complex numbers"); - return 15; - } - printFooter(stdout, "psBinaryOp", "Attempt to use min with complex numbers", true); - - - // Attempt to use max with complex numbers - printPositiveTestHeader(stdout,"psBinaryOp","Attempt to use max with complex numbers"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psBinaryOp(image6, image5, "max", image5); - if(image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp returned result with max of complex numbers"); - return 16; - } - printFooter(stdout, "psBinaryOp", "Attempt to use max with complex numbers", true); - - - // Invalid operation - printPositiveTestHeader(stdout,"psBinary","Attempt to use invalid operator"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error messgae"); - image6 = (psImage*)psBinaryOp(image6, image1, "yarg", image2); - if(image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psBinaryOp returned result with invalid operator"); - return 17; - } - printFooter(stdout,"psBinaryOp","Attempt to use invalid operator",true); - - printPositiveTestHeader(stdout,"psUnaryOp","Attempt to use invalid operator"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - image6 = (psImage*)psUnaryOp(image6, image1, "yarg"); - if(image6 != NULL) { - psLogMsg(__func__,PS_LOG_ERROR,"psUnaryOp returned result with invalid operator"); - return 18; - } - printFooter(stdout, "psUnaryOp", "Attempt to use invalid operator", true); - - CREATE_AND_SET_VECTOR(vector4,F64,0,3); - CREATE_AND_SET_VECTOR(vector5,F64,0,3); - - // Input parameter with dimension of PS_DIMEN_OTHER - printPositiveTestHeader(stdout,"psBinaryOp","Attempt to use input with PS_DIMEN_OTHER"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - vector4->type.dimen = PS_DIMEN_OTHER; - if ( psBinaryOp(NULL,vector4,"+",vector5) != NULL) { - psError(PS_ERR_UNKNOWN, true,"psBinaryOp should return null when input dimen PS_DIMEN_OTHER."); - return 19; - } - vector4->type.dimen = PS_DIMEN_VECTOR; - printFooter(stdout,"psBinaryOp","Attempt to use input with PS_DIMEN_OTHER",true); - - // Input parameter with dimension of PS_DIMEN_OTHER - printPositiveTestHeader(stdout,"psUnaryOp","Attempt to use input with PS_DIMEN_OTHER"); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - vector4->type.dimen = PS_DIMEN_OTHER; - if ( psUnaryOp(NULL,vector4,"sin") != NULL ) { - psError(PS_ERR_UNKNOWN,true,"psUnaryOp should return null when input dimen PS_DIMEN_OTHER"); - return 20; - } - vector4->type.dimen = PS_DIMEN_VECTOR; - printFooter(stdout,"psUnaryOp","Attempt to use input with PS_DIMEN_OTHER",true); - - psFree(vector4); - psFree(vector5); - psFree(image1); - psFree(image2); - psFree(image3); - psFree(image4); - psFree(image5); - psFree(vector1); - psFree(vector2); - - psS32 nLeaks = psMemCheckLeaks(0,NULL,stdout,false); - if(nLeaks != 0) { - psError(PS_ERR_UNKNOWN,true,"Memory leaks detected"); - return 50; - } - psS32 nBad = psMemCheckCorruption(0); - if(nBad) { - psError(PS_ERR_UNKNOWN,true,"Memory corruption detected"); - return 51; - } - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic04.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic04.c (revision 4528) +++ (revision ) @@ -1,212 +1,0 @@ -/** @file tst_psMatrixVectorArithmetic04.c - * - * @brief Test driver for psBinary arithmetic operations with scalars - * - * This test driver will test the following binary operation with scalar inputs - * vector addition with scalar in first argument - * image addition with scalar in second argument - * - * @author Eric Van Alst, MHPCC - * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-04-07 20:27:42 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - * - */ - -#include "pslib_strict.h" -#include "psTest.h" - -static psS32 testBinOpScalarFirst(void); -static psS32 testBinOpScalarSecond(void); -static psS32 testBinOpScalarBoth(void); -static psS32 testUnaryOpScalar(void); - -testDescription testsBinary[] = { - {testBinOpScalarFirst,737,"psBinaryOp",0,false}, - {testBinOpScalarSecond,737,"psBinaryOp",0,false}, - {testBinOpScalarBoth,737,"psBinaryOp",0,false}, - {NULL} - }; - -testDescription testUnary[] = { - {testUnaryOpScalar,737,"psUnaryOp",0,false}, - {NULL} - }; - -// Create vector -#define CREATE_AND_SET_VECTOR(NAME,TYPE,VALUE,SIZE) \ -psVector *NAME = psVectorAlloc(SIZE,PS_TYPE_##TYPE); \ -for(psS32 i=0; idata.TYPE[i] = VALUE; \ -} \ -NAME->n = SIZE; - -// Create image -#define CREATE_AND_SET_IMAGE(NAME,TYPE,VALUE,NROWS,NCOLS) \ -psImage *NAME = psImageAlloc(NCOLS,NROWS,PS_TYPE_##TYPE); \ -for(psS32 i=0; inumRows; i++) { \ - for(psS32 j=0; jnumCols; j++) { \ - NAME->data.TYPE[i][j] = VALUE; \ - } \ -} - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - - runTestSuite(stderr,"psBinaryOp",testsBinary,argc,argv); - runTestSuite(stderr,"psUnaryOp",testUnary,argc,argv); - - return 0; -} - -psS32 testBinOpScalarFirst(void) -{ - CREATE_AND_SET_VECTOR(vector1,S8,1,5) - CREATE_AND_SET_VECTOR(vector2,S8,0,5) - - psScalar* inScalar1 = psScalarAlloc(2,PS_TYPE_S8); - - // Add vector and scalar - vector2 = (psVector*)psBinaryOp(vector2,inScalar1,"+",vector1); - // Verify the result vector - for(psS32 i=0; in; i++) { - if(vector2->data.S8[i] != 3 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return vector[%d]",i); - return 1; - } - } - psFree(vector1); - psFree(vector2); - - CREATE_AND_SET_VECTOR(vector3,S8,1,5); - CREATE_AND_SET_VECTOR(vector4,S8,0,3); - - psScalar* inScalar2 = psScalarAlloc(2,PS_TYPE_S8); - vector4->type.dimen = PS_DIMEN_TRANSV; - vector4 = (psVector*)psBinaryOp(vector4,inScalar2,"+",vector3); - for(psS32 i=0; in; i++) { - if(vector4->data.S8[i] != 3 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return vector[%d]",i); - return 2; - } - } - psFree(vector3); - psFree(vector4); - - CREATE_AND_SET_IMAGE(image1,S8,1,5,5) - psImage* image2 = NULL; - - psScalar* inScalar3 = psScalarAlloc(2,PS_TYPE_S8); - - image2 = (psImage*)psBinaryOp(image2,inScalar3,"+",image1); - for(psS32 i=0; inumRows; i++) { - for(psS32 j=0; jnumCols; j++) { - if(image2->data.S8[i][j] != 3 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return image[%d][%d]",i,j); - return 10; - } - } - } - psFree(image1); - psFree(image2); - - return 0; -} - -psS32 testBinOpScalarSecond(void) -{ - CREATE_AND_SET_VECTOR(vector1,S8,1,5) - CREATE_AND_SET_VECTOR(vector2,S8,0,5) - - psScalar* inScalar1 = psScalarAlloc(2,PS_TYPE_S8); - - vector2 = (psVector*)psBinaryOp(vector2,vector1,"+",inScalar1); - for(psS32 i=0; in; i++) { - if(vector2->data.S8[i] != 3 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return vector[%d]",i); - return 1; - } - } - psFree(vector1); - psFree(vector2); - - CREATE_AND_SET_VECTOR(vector3,S8,1,5); - CREATE_AND_SET_VECTOR(vector4,S8,0,3); - - psScalar* inScalar2 = psScalarAlloc(2,PS_TYPE_S8); - vector4->type.dimen = PS_DIMEN_TRANSV; - vector4 = (psVector*)psBinaryOp(vector4,vector3,"+",inScalar2); - for(psS32 i=0; in; i++) { - if(vector4->data.S8[i] != 3 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return vector[%d]",i); - return 2; - } - } - psFree(vector3); - psFree(vector4); - - CREATE_AND_SET_IMAGE(image1,S8,1,5,5); - psImage* image2 = NULL; - - psScalar* inScalar3 = psScalarAlloc(2,PS_TYPE_S8); - - image2 = (psImage*)psBinaryOp(image2,image1,"+",inScalar3); - for(psS32 i=0; inumRows; i++) { - for(psS32 j=0; jnumCols; j++) { - if(image2->data.S8[i][j] != 3 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return image[%d][%d]",i,j); - return 10; - } - } - } - psFree(image1); - psFree(image2); - - return 0; -} - -psS32 testBinOpScalarBoth(void) -{ - psScalar* inScalar1 = psScalarAlloc(1,PS_TYPE_S8); - psScalar* inScalar2 = psScalarAlloc(2,PS_TYPE_S8); - psScalar* outScalar = psScalarAlloc(4,PS_TYPE_S8); - - outScalar = (psScalar*)psBinaryOp(outScalar,inScalar1,"+",inScalar2); - if(outScalar->data.S8 != 3) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return scalar"); - return 3; - } - psFree(outScalar); - - psScalar* inScalar3 = psScalarAlloc(10,PS_TYPE_S8); - psScalar* inScalar4 = psScalarAlloc(20,PS_TYPE_S8); - psScalar* outScalar1 = NULL; - - outScalar1 = (psScalar*)psBinaryOp(outScalar1,inScalar3,"+",inScalar4); - if(outScalar1->data.S8 != 30 ) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return scalar"); - return 4; - } - psFree(outScalar1); - - return 0; -} - -psS32 testUnaryOpScalar(void) -{ - psScalar* inScalar = psScalarAlloc(-1,PS_TYPE_F32); - psScalar* outScalar = NULL; - - outScalar = (psScalar*)psUnaryOp(outScalar,inScalar,"abs"); - if(outScalar->data.F32 != 1) { - psError(PS_ERR_UNKNOWN,true,"Unexpected value in return scalar = %d in = %d",outScalar->data.F32,inScalar->data.F32); - return 5; - } - psFree(outScalar); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psMinimize00.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize00.c (revision 4528) +++ (revision ) @@ -1,166 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psMinimizeChi2 function correctly - minimizes an arbitrary function. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define NUM_DATA 10 -#define DATA_WIDTH 2 -#define NUM_PARAMS 4 - -float myFunc(const psVector *restrict myData, - const psVector *restrict myParams) -{ - float x = myData->data.F32[0]; - float y = myData->data.F32[1]; - float A = myParams->data.F32[0]; - float B = myParams->data.F32[1]; - float C = myParams->data.F32[2]; - float D = myParams->data.F32[3]; - float tmp = 0.0; - - tmp = (A * x) + (B*x*x) + (C*y*y) + (D*x*x*y); - // printf("--------- myFunc((%.1f %.1f) %.1f %.1f %.1f %.1f) is %.1f ---------\n", - // x, y, A, B, C, D, tmp); - - return(tmp); -} - -float myFuncDeriv(const psVector *restrict myData, - const psVector *restrict myParams, - psS32 whichParamDeriv) -{ - float x = myData->data.F32[0]; - float y = myData->data.F32[1]; - float tmp = 0.0; - - if (whichParamDeriv == 0) { - tmp = 1.0; - tmp = x; - } else - if (whichParamDeriv == 1) { - tmp = x; - tmp = x*x; - } else - if (whichParamDeriv == 2) { - tmp = y; - tmp = y*y; - } else - if (whichParamDeriv == 3) { - tmp = x * x * y; - } - - // printf("--------- myFuncDeriv((%.1f %.1f) %.1f %.1f %.1f %.1f (%d)) is %.1f ---------\n", - // x, y, myParams->data.F32[0], myParams->data.F32[1], - // myParams->data.F32[2], myParams->data.F32[3], whichParamDeriv, tmp); - return(tmp); -} - - -psS32 main() -{ - psImage *domain = NULL; - psVector *data = NULL; - psVector *errors = NULL; - psVector *initialGuess = NULL; - psVector *paramMask = NULL; - psVector *tmpVecPtr = NULL; - float chiSq = 0.0; - psS32 i = 0; - psS32 j = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psVector *theParams = NULL; - - domain = psImageAlloc(DATA_WIDTH, NUM_DATA, PS_TYPE_F32); - data = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - errors = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - initialGuess = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - paramMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - tmpVecPtr = psVectorAlloc(DATA_WIDTH, PS_TYPE_F32); - - - //--------- myFunc((0.0 1.0) -8.6 -7.6 14.6 5.0) is 6.0 --------- - - initialGuess->data.F32[0] = -8.6; - initialGuess->data.F32[1] = -7.6; - initialGuess->data.F32[2] = 14.6; - initialGuess->data.F32[3] = 5.0; - - // Build the data. - initialGuess->data.F32[0] = 2.0; - initialGuess->data.F32[1] = 3.0; - initialGuess->data.F32[2] = 4.0; - initialGuess->data.F32[3] = 5.0; - - - for (i = 0; idata.F32[i][j] = (float) (i + j); - } - } - for (i = 0; idata.F32[i] = 0.1; - } - - // printf("========== Setting Data Values ==========\n"); - for (i = 0; idata.F32[j] = domain->data.F32[i][j]; - } - data->data.F32[i] = myFunc(tmpVecPtr, initialGuess); - } - // printf("=========================================\n"); - - for (i=0;idata.F32[i]+= 1.0; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimizeChi2(): no masks"); - - theParams = psMinimizeChi2(myFunc, - myFuncDeriv, - domain, - data, - errors, - initialGuess, - NULL, - &chiSq); - for (i=0;idata.F32[i]); - } - - printf("chiSq is %f\n", chiSq); - psMemCheckCorruption(1); - printFooter(stdout, - "psMinimize functions", - "psMinimizeChi2(): no masks", - testStatus); - - - psMemCheckCorruption(1); - psFree(domain); - psFree(data); - psFree(errors); - psFree(initialGuess); - psFree(paramMask); - psFree(tmpVecPtr); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psMinimize01.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize01.c (revision 4528) +++ (revision ) @@ -1,172 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psMinimizeChi2 function correctly - minimizes an arbitrary function. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define NUM_DATA 40 -#define DATA_WIDTH 1 -#define NUM_PARAMS 3 - -// The function is f(x) = (A * e^(lambda x)) + b - -float myFunc(const psVector *restrict myData, - const psVector *restrict myParams) -{ - float x = myData->data.F32[0]; - float A = myParams->data.F32[0]; - float lambda = myParams->data.F32[1]; - float b = myParams->data.F32[2]; - float tmp = A * exp(-lambda * x) + b; - - // printf("--------- myFunc((%.1f) %.1f %.1f %.1f) is %.1f ---------\n", - // x, A, lambda, b, tmp); - - return(tmp); -} - -float myFuncDeriv(const psVector *restrict myData, - const psVector *restrict myParams, - psS32 whichParamDeriv) -{ - float x = myData->data.F32[0]; - float A = myParams->data.F32[0]; - float lambda = myParams->data.F32[1]; - float tmp = 0.0; - - if (whichParamDeriv == 0) { - tmp = exp(-lambda * x); - } else - if (whichParamDeriv == 1) { - tmp = -x * A * exp(-lambda * x); - } else - if (whichParamDeriv == 2) { - tmp = 1.0; - } - - // printf("--------- myFuncDeriv((%.1f) %.1f %.1f %.1f, %d) is %.1f ---------\n", - // x, A, lambda, myParams->data.F32[2], whichParamDeriv, tmp); - - return(tmp); -} - -psS32 main() -{ - psImage *domain = NULL; - psVector *data = NULL; - psVector *errors = NULL; - psVector *initialGuess = NULL; - psVector *paramMask = NULL; - psVector *tmpVecPtr = NULL; - float chiSq = 0.0; - psS32 i = 0; - psVector *theParams = NULL; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - domain = psImageAlloc(DATA_WIDTH, NUM_DATA, PS_TYPE_F32); - data = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - errors = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - initialGuess = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - paramMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - tmpVecPtr = psVectorAlloc(DATA_WIDTH, PS_TYPE_F32); - - // Build the data. - initialGuess->data.F32[0] = 1.0; - initialGuess->data.F32[1] = 0.0; - initialGuess->data.F32[2] = 0.0; - - for (i = 0; idata.F32[i] = 0.1; - domain->data.F32[i][0] = (float) i; - } - - printf("========== Setting Data Values ==========\n"); - data->data.F32[0] = 6.013392; - data->data.F32[1] = 5.515377; - data->data.F32[2] = 5.261095; - data->data.F32[3] = 4.777455; - data->data.F32[4] = 4.451353; - data->data.F32[5] = 3.904903; - data->data.F32[6] = 3.504387; - data->data.F32[7] = 3.414999; - data->data.F32[8] = 3.242736; - data->data.F32[9] = 3.122204; - data->data.F32[10] = 2.837632; - data->data.F32[11] = 2.534700; - data->data.F32[12] = 2.439173; - data->data.F32[13] = 2.380830; - data->data.F32[14] = 2.316090; - data->data.F32[15] = 2.060826; - data->data.F32[16] = 1.945679; - data->data.F32[17] = 1.914126; - data->data.F32[18] = 1.759509; - data->data.F32[19] = 1.665067; - data->data.F32[20] = 1.737926; - data->data.F32[21] = 1.575523; - data->data.F32[22] = 1.525066; - data->data.F32[23] = 1.409607; - data->data.F32[24] = 1.395209; - data->data.F32[25] = 1.416887; - data->data.F32[26] = 1.376042; - data->data.F32[27] = 1.260955; - data->data.F32[28] = 1.289627; - data->data.F32[29] = 1.422672; - data->data.F32[30] = 1.228287; - data->data.F32[31] = 1.199176; - data->data.F32[32] = 1.189989; - data->data.F32[33] = 0.930076; - data->data.F32[34] = 1.224608; - data->data.F32[35] = 1.147376; - data->data.F32[36] = 1.114001; - data->data.F32[37] = 1.195118; - data->data.F32[38] = 1.269581; - data->data.F32[39] = 1.061982; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimizeChi2(): no masks"); - - theParams = psMinimizeChi2(myFunc, - myFuncDeriv, - domain, - data, - errors, - initialGuess, - NULL, - &chiSq); - - for (i=0;idata.F32[i]); - } - printf("chiSq is %f\n", chiSq); - - psMemCheckCorruption(1); - printFooter(stdout, - "psMinimize functions", - "psMinimizeChi2(): no masks", - testStatus); - psMemCheckCorruption(1); - psFree(domain); - psFree(data); - psFree(errors); - psFree(initialGuess); - psFree(paramMask); - psFree(tmpVecPtr); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psMinimize02.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize02.c (revision 4528) +++ (revision ) @@ -1,168 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psMinimize function correctly - minimizes an arbitrary function. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define DATA_WIDTH 2 -#define NUM_PARAMS 2 - -float myFunc0(const psVector *restrict myParams, - const psVector *restrict myCoords) -{ - float P0 = myCoords->data.F32[0]; - float P1 = myCoords->data.F32[1]; - float x = myParams->data.F32[0]; - float y = myParams->data.F32[1]; - float tmp = 0.0; - - tmp = 10.0 * (x - P0) * (x - P0) + 20.0 * (y - P1) * (y - P1) + 30.0; - // printf("--------- myFunc((%.1f %.1f) %.1f %.1f) is %.1f ---------\n", - // printf("--------- myFunc() params: (%.1f %.1f) coords: (%.1f %.1f) is %.1f ---------\n", - // x, y, P0, P1, tmp); - - return(tmp); -} - -float myFuncDeriv0(const psVector *restrict myParams, - const psVector *restrict myCoords, - psS32 whichParamDeriv) -{ - float P0 = myCoords->data.F32[0]; - float P1 = myCoords->data.F32[1]; - float x = myParams->data.F32[0]; - float y = myParams->data.F32[1]; - float tmp = 0.0; - - if (whichParamDeriv == 0) { - tmp = 20.0 * (x - P0); - } else - if (whichParamDeriv == 1) { - tmp = 40.0 * (y - P1); - } - - // printf("--------- myFuncDeriv((%.1f %.1f) %.1f %.1f (%d)) is %.1f ---------\n", - // x, y, myParams->data.F32[0], myParams->data.F32[1], whichParamDeriv, tmp); - return(tmp); -} - - -float myFunc(const psVector *restrict myParams, - const psVector *restrict myCoords) -{ - float x = myCoords->data.F32[0]; - float y = myCoords->data.F32[1]; - float A = myParams->data.F32[0]; - float B = myParams->data.F32[1]; - float C = myParams->data.F32[2]; - float D = myParams->data.F32[3]; - float tmp = 0.0; - - tmp = (A * x) + (B*x*x) + (C*y*y) + (D*x*x*y); - printf("--------- myFunc((%.1f %.1f) %.1f %.1f %.1f %.1f) is %.1f ---------\n", - x, y, A, B, C, D, tmp); - - return(tmp); -} - -float myFuncDeriv(const psVector *restrict myParams, - const psVector *restrict myCoords, - psS32 whichParamDeriv) -{ - float x = myCoords->data.F32[0]; - float y = myCoords->data.F32[1]; - float tmp = 0.0; - - if (whichParamDeriv == 0) { - tmp = 1.0; - tmp = x; - } else - if (whichParamDeriv == 1) { - tmp = x; - tmp = x*x; - } else - if (whichParamDeriv == 2) { - tmp = y; - tmp = y*y; - } else - if (whichParamDeriv == 3) { - tmp = x * x * y; - } - - printf("--------- myFuncDeriv((%.1f %.1f) %.1f %.1f %.1f %.1f (%d)) is %.1f ---------\n", - x, y, myParams->data.F32[0], myParams->data.F32[1], - myParams->data.F32[2], myParams->data.F32[3], whichParamDeriv, tmp); - return(tmp); -} - - -psS32 main() -{ - psVector *initialGuess = NULL; - psVector *paramMask = NULL; - psVector *coord = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psVector *theParams = NULL; - - initialGuess = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - paramMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - coord = psVectorAlloc(DATA_WIDTH, PS_TYPE_F32); - - - //--------- myFunc((0.0 1.0) -8.6 -7.6 14.6 5.0) is 6.0 --------- - - // Build the data. - initialGuess->data.F32[0] = 5.0; - initialGuess->data.F32[1] = 7.0; - - for (i=0;idata.F32[i] = (float) i; - } - coord->data.F32[0] = 1.0; - coord->data.F32[1] = 2.0; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimize(): no masks"); - - for (i=0;idata.F32[i]); - - theParams = psMinimize(initialGuess, - myFunc0, - myFuncDeriv0, - coord, - NULL); - - for (i=0;idata.F32[i]); - - psMemCheckCorruption(1); - printFooter(stdout, - "psMinimize functions", - "psMinimize(): no masks", - testStatus); - - psMemCheckCorruption(1); - psFree(initialGuess); - psFree(paramMask); - psFree(coord); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psMinimize03.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize03.c (revision 4528) +++ (revision ) @@ -1,172 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psMinimize function correctly - minimizes an arbitrary function. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define DATA_WIDTH 2 -#define NUM_PARAMS 4 - -float myFunc0(const psVector *restrict myParams, - const psVector *restrict myCoords) -{ - float P0 = myCoords->data.F32[0]; - float P1 = myCoords->data.F32[1]; - float x = myParams->data.F32[0]; - float y = myParams->data.F32[1]; - float tmp = 0.0; - - tmp = 10.0 * (x - P0) * (x - P0) + 20.0 * (y - P1) * (y - P1) + 30.0; - // printf("--------- myFunc((%.1f %.1f) %.1f %.1f) is %.1f ---------\n", - // printf("--------- myFunc() params: (%.1f %.1f) coords: (%.1f %.1f) is %.1f ---------\n", - // x, y, P0, P1, tmp); - - return(tmp); -} - -float myFuncDeriv0(const psVector *restrict myParams, - const psVector *restrict myCoords, - psS32 whichParamDeriv) -{ - float P0 = myCoords->data.F32[0]; - float P1 = myCoords->data.F32[1]; - float x = myParams->data.F32[0]; - float y = myParams->data.F32[1]; - float tmp = 0.0; - - if (whichParamDeriv == 0) { - tmp = 20.0 * (x - P0); - } else - if (whichParamDeriv == 1) { - tmp = 40.0 * (y - P1); - } - - // printf("--------- myFuncDeriv((%.1f %.1f) %.1f %.1f (%d)) is %.1f ---------\n", - // x, y, myParams->data.F32[0], myParams->data.F32[1], whichParamDeriv, tmp); - return(tmp); -} - - -float myFunc(const psVector *restrict myParams, - const psVector *restrict myCoords) -{ - float x = myCoords->data.F32[0]; - float y = myCoords->data.F32[1]; - float A = myParams->data.F32[0]; - float B = myParams->data.F32[1]; - float C = myParams->data.F32[2]; - float D = myParams->data.F32[3]; - float tmp = 0.0; - - tmp = (A * x) + (B*x*x) + (C*y*y) + (D*x*x*y); - printf("-- myFunc() params: (%.1f %.1f %.1f %.1f) coords: (%.1f %.1f) is %.1f ---------\n", - A, B, C, D, x, y, tmp); - - return(tmp); -} - -float myFuncDeriv(const psVector *restrict myParams, - const psVector *restrict myCoords, - psS32 whichParamDeriv) -{ - float x = myCoords->data.F32[0]; - float y = myCoords->data.F32[1]; - float tmp = 0.0; - - if (whichParamDeriv == 0) { - tmp = 1.0; - tmp = x; - } else - if (whichParamDeriv == 1) { - tmp = x; - tmp = x*x; - } else - if (whichParamDeriv == 2) { - tmp = y; - tmp = y*y; - } else - if (whichParamDeriv == 3) { - tmp = x * x * y; - } - - printf("--------- myFuncDeriv((%.1f %.1f) %.1f %.1f %.1f %.1f (%d)) is %.1f ---------\n", - x, y, myParams->data.F32[0], myParams->data.F32[1], - myParams->data.F32[2], myParams->data.F32[3], whichParamDeriv, tmp); - return(tmp); -} - - -psS32 main() -{ - psVector *initialGuess = NULL; - psVector *paramMask = NULL; - psVector *coord = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psVector *theParams = NULL; - - initialGuess = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - paramMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - coord = psVectorAlloc(DATA_WIDTH, PS_TYPE_F32); - - - //--------- myFunc((0.0 1.0) -8.6 -7.6 14.6 5.0) is 6.0 --------- - - // Build the data. - initialGuess->data.F32[0] = 2.0; - initialGuess->data.F32[1] = 3.0; - initialGuess->data.F32[2] = 4.0; - initialGuess->data.F32[3] = 5.0; - - for (i=0;idata.F32[i] = (float) i; - } - coord->data.F32[0] = 1.0; - coord->data.F32[1] = 2.0; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimize(): no masks"); - - for (i=0;idata.F32[i]); - - theParams = psMinimize(initialGuess, - myFunc, - myFuncDeriv, - coord, - NULL); - - for (i=0;idata.F32[i]); - - printf("Function is %.1f\n", myFunc(theParams, coord)); - - psMemCheckCorruption(1); - printFooter(stdout, - "psMinimize functions", - "psMinimize(): no masks", - testStatus); - - psMemCheckCorruption(1); - psFree(initialGuess); - psFree(paramMask); - psFree(coord); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psMinimize04.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize04.c (revision 4528) +++ (revision ) @@ -1,274 +1,0 @@ -/***************************************************************************** -This routine must ensure that the psVectorFitPolynomial1D works correctly. -We create a vectors of data points (x and y), and populate them with the -values from an arbitrary function setData(). We then call -psVectorFitPolynomial1D() with a regular polynomial data structure. We then -evaluate the polynomial with the coefficients generated above and determine -if they are within an error tolerance of the expected values. - - t00(): all input vectors are non-NULL. - t01(): yErr is NULL. - t02(): x, yErr is NULL. - t03(): x, y, yErr is NULL. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define NUM_DATA 10 -#define POLY_ORDER 5 -#define A 3.0 -#define B 2.0 -#define C 3.0 -#define ERROR_TOLERANCE 0.10 -#define YERR 1.0 -double setData(double x) -{ - return(A + (B * x) + (C * x * x)); -} - -psS32 t00() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psVector *yErr = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - double expectData; - double actualData; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (i=0;idata.F64[i] = (double) i; - y->data.F64[i] = setData(x->data.F64[i]); - yErr->data.F64[i] = YERR; - // printf("Original data %d: (%.1f %.1f)\n", i, x->data.F64[i], y->data.F64[i]); - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): equal difference in variable yErr"); - - psVectorFitPolynomial1D(myPoly, x, y, yErr); - - // for (i=0;icoeff[i]); - // } - - for (i=0;idata.F64[i]); - actualData = psPolynomial1DEval( - myPoly, - x->data.F64[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F64[i], actualData, expectData); - testStatus = false; - } - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F64[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(yErr); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): equal differences in variable yErr", - testStatus); - - return (!testStatus); -} - -psS32 t01() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - double expectData; - double actualData; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (i=0;idata.F64[i] = (double) i; - y->data.F64[i] = setData(x->data.F64[i]); - // printf("Original data %d: (%.1f %.1f)\n", i, x->data.F64[i], y->data.F64[i]); - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, x, y, NULL); - - // for (i=0;icoeff[i]); - // } - - for (i=0;idata.F64[i]); - actualData = psPolynomial1DEval( - myPoly, - x->data.F64[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F64[i], actualData, expectData); - testStatus = false; - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F64[i], actualData, expectData); - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): yErr is NULL", - testStatus); - - return (!testStatus); -} - -psS32 t02() -{ - psPolynomial1D *myPoly = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - double expectData; - double actualData; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (i=0;idata.F64[i] = setData((double) i); - // printf("Original data %d: (%.1f)\n", i, y->data.F64[i]); - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): x, yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, NULL, y, NULL); - - // for (i=0;icoeff[i]); - // } - - for (i=0;i fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, (double) i, actualData, expectData); - testStatus = false; - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, (double) i, actualData, expectData); - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): x, yErr is NULL", - testStatus); - - return (!testStatus); -} - -psS32 t03() -{ - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psPolynomial1D *myPoly = NULL; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): all inputs are NULL"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for null input polynomial."); - myPoly = psVectorFitPolynomial1D(NULL, NULL, NULL, NULL); - if ( myPoly != NULL ) { - psError(PS_ERR_UNKNOWN, true,"A null polynomial should have returned a null pointer."); - testStatus = false; - } - - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): all inputs are NULL", - testStatus); - - return (!testStatus); -} - - -psS32 main() -{ - t00(); - t01(); - t02(); - t03(); -} Index: trunk/psLib/test/dataManip/tst_psMinimize04_F32.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize04_F32.c (revision 4528) +++ (revision ) @@ -1,268 +1,0 @@ -/***************************************************************************** -This routine must ensure that the psVectorFitPolynomial1D works correctly. -We create a vectors of data points (x and y), and populate them with the -values from an arbitrary function setData(). We then call -psVectorFitPolynomial1D() with a regular polynomial data structure. We then -evaluate the polynomial with the coefficients generated above and determine -if they are within an error tolerance of the expected values. - - t00(): all input vectors are non-NULL. - t01(): yErr is NULL. - t02(): x, yErr is NULL. - t03(): x, y, yErr is NULL. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define NUM_DATA 10 -#define POLY_ORDER 5 -#define A 3.0 -#define B 2.0 -#define C 3.0 -#define ERROR_TOLERANCE 0.10 -#define YERR 10.0 -float setData(float x) -{ - return(A + (B * x) + (C * x * x)); -} - -psS32 t00() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psVector *yErr = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - float expectData; - float actualData; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - - for (i=0;idata.F32[i] = (float) i; - y->data.F32[i] = setData(x->data.F32[i]); - yErr->data.F32[i] = YERR; - // printf("Original data %d: (%.1f %.1f)\n", i, x->data.F32[i], y->data.F32[i]); - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): equal errors in yErr"); - - psVectorFitPolynomial1D(myPoly, x, y, yErr); - - // for (i=0;icoeff[i]); - // } - - for (i=0;idata.F32[i]); - actualData = psPolynomial1DEval( - myPoly, - x->data.F32[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F32[i], actualData, expectData); - testStatus = false; - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F32[i], actualData, expectData); - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(yErr); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): equal errors in yErr", - testStatus); - - return (!testStatus); -} - -psS32 t01() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - float expectData; - float actualData; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - - for (i=0;idata.F32[i] = (float) i; - y->data.F32[i] = setData(x->data.F32[i]); - // printf("Original data %d: (%.1f %.1f)\n", i, x->data.F32[i], y->data.F32[i]); - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, x, y, NULL); - - // for (i=0;icoeff[i]); - // } - - for (i=0;idata.F32[i]); - actualData = psPolynomial1DEval( - myPoly, - x->data.F32[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F32[i], actualData, expectData); - testStatus = false; - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F32[i], actualData, expectData); - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): yErr is NULL", - testStatus); - - return (!testStatus); -} - -psS32 t02() -{ - psPolynomial1D *myPoly = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - float expectData; - float actualData; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - - for (i=0;idata.F32[i] = setData((float) i); - // printf("Original data %d: (%.1f)\n", i, y->data.F32[i]); - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): x, yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, NULL, y, NULL); - - // for (i=0;icoeff[i]); - // } - - for (i=0;i fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, (float) i, actualData, expectData); - testStatus = false; - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, (float) i, actualData, expectData); - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): x, yErr is NULL", - testStatus); - - return (!testStatus); -} - -psS32 t03() -{ - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): all inputs are NULL"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments."); - psVectorFitPolynomial1D(NULL, NULL, NULL, NULL); - - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): all inputs are NULL", - testStatus); - - return (!testStatus); -} - - -psS32 main() -{ - t00(); - t01(); - t02(); - t03(); -} Index: trunk/psLib/test/dataManip/tst_psMinimize04b.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize04b.c (revision 4528) +++ (revision ) @@ -1,259 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psVectorFitPolynomial1D works correctly. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define NUM_DATA 21 -#define POLY_ORDER 10 -#define A 2.0 -#define B 3.0 -#define C 2.0 -#define D 4.0 -#define E 5.0 -#define ERROR_TOLERANCE 0.10 -#define IGNORE (ERROR_TOLERANCE * NUM_DATA) - -double setData(double x) -{ - return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x)); -} - -psS32 t00() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psVector *yErr = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (i=0;idata.F64[i] = (double) i; - y->data.F64[i] = setData(x->data.F64[i]); - yErr->data.F64[i] = 1.0; - } - p_psNormalizeVectorRangeF64(x, -1.0, 1.0); - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, equal errors in yErr"); - - psVectorFitPolynomial1D(myPoly, x, y, yErr); - - // Remove for testing since print out differs from platforms - // for (i=0;icoeff[i]); - // } - - // We don't test the first or last few data items. - for (i=IGNORE;idata.F64[i]; - double actualData = psPolynomial1DEval( - myPoly, - x->data.F64[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F64[i], actualData, expectData); - testStatus = false; - } - // Remove for testing since print out differs from platforms - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F64[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(yErr); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, equal errors in yErr", - testStatus); - return (!testStatus); -} - - -psS32 t01() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (i=0;idata.F64[i] = (double) i; - y->data.F64[i] = setData(x->data.F64[i]); - } - p_psNormalizeVectorRangeF64(x, -1.0, 1.0); - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, x, y, NULL); - - // We don't test the first or last few data items. - for (i=IGNORE;idata.F64[i]; - double actualData = psPolynomial1DEval( - myPoly, - x->data.F64[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F64[i], actualData, expectData); - testStatus = false; - } - // Remove for testing since print out differs from platforms - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F64[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL", - testStatus); - return (!testStatus); -} - - -psS32 t02() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (i=0;idata.F64[i] = (double) i; - y->data.F64[i] = setData(x->data.F64[i]); - } - p_psNormalizeVectorRangeF64(x, -1.0, 1.0); - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, NULL, y, NULL); - // psVectorFitPolynomial1D(myPoly, x, y, NULL); - - // We don't test the first or last few data items. - for (i=IGNORE;idata.F64[i]; - double actualData = psPolynomial1DEval(myPoly, x->data.F64[i]); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.2f %.2f), expected was (%.2f)\n", - i, x->data.F64[i], actualData, expectData); - testStatus = false; - } - // Remove for testing since print out differs from platforms - // } else { - // printf("Fitted data %d: (%.2f %.2f), expected was (%.2f)\n", - // i, x->data.F64[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL", - testStatus); - return (!testStatus); -} - -psS32 t03() -{ - psPolynomial1D *myPoly = NULL; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for null arguments."); - myPoly = psVectorFitPolynomial1D(NULL, NULL, NULL, NULL); - if (myPoly != NULL) { - printf("ERROR: psVectorFitPolynomial1D() returned a non-NULL polynomial.\n"); - testStatus = false; - } - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL", - testStatus); - return (!testStatus); -} - -psS32 main() -{ - t00(); - t01(); - t02(); - t03(); -} Index: trunk/psLib/test/dataManip/tst_psMinimize04b_F32.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize04b_F32.c (revision 4528) +++ (revision ) @@ -1,261 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psVectorFitPolynomial1D works correctly. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psFunctions.h" -#include "psMinimize.h" -#include -#define NUM_DATA 20 -#define POLY_ORDER 10 -#define A 2.0 -#define B 3.0 -#define C 2.0 -#define D 4.0 -#define E 5.0 -#define ERROR_TOLERANCE 0.10 -#define IGNORE (ERROR_TOLERANCE * NUM_DATA) - -float setData(float x) -{ - return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x)); -} - -psS32 t00() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psVector *yErr = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - - for (i=0;idata.F32[i] = (float) i; - y->data.F32[i] = setData(x->data.F32[i]); - yErr->data.F32[i] = 1.0; - } - p_psNormalizeVectorRangeF32(x, -1.0f, 1.0f); - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, equal errors in yErr"); - - psVectorFitPolynomial1D(myPoly, x, y, yErr); - - // Remove for testing since printout differs between platforms - // for (i=0;icoeff[i]); - // } - - // We don't test the first or last few data items. - for (i=IGNORE;idata.F32[i]; - float actualData = psPolynomial1DEval( - myPoly, - x->data.F32[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F32[i], actualData, expectData); - testStatus = false; - } - // REMOVE for testing since printout is different for different platforms - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F32[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(yErr); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, equal errors in yErr", - testStatus); - return (!testStatus); -} - - -psS32 t01() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - - for (i=0;idata.F32[i] = (float) i; - y->data.F32[i] = setData(x->data.F32[i]); - } - p_psNormalizeVectorRangeF32(x, -1.0f, 1.0f); - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, x, y, NULL); - - // We don't test the first or last few data items. - for (i=IGNORE;idata.F32[i]; - float actualData = psPolynomial1DEval( - myPoly, - x->data.F32[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F32[i], actualData, expectData); - testStatus = false; - } - // Removed for testing since printout different on different platforms - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F32[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL", - testStatus); - return (!testStatus); -} - - -psS32 t02() -{ - psPolynomial1D *myPoly = NULL; - psVector *x = NULL; - psVector *y = NULL; - psS32 i = 0; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB); - x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - - for (i=0;idata.F32[i] = (float) i; - y->data.F32[i] = setData(x->data.F32[i]); - } - p_psNormalizeVectorRangeF32(x, -1.0, 1.0); - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL"); - - psVectorFitPolynomial1D(myPoly, NULL, y, NULL); - - // We don't test the first or last few data items. - for (i=IGNORE;idata.F32[i]; - float actualData = psPolynomial1DEval( - myPoly, - x->data.F32[i] - ); - if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { - printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - i, x->data.F32[i], actualData, expectData); - testStatus = false; - } - // Remove for testing since printout different for different platforms - // } else { - // printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", - // i, x->data.F32[i], actualData, expectData); - // } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL", - testStatus); - return (!testStatus); -} - -psS32 t03() -{ - psPolynomial1D *myPoly = NULL; - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments."); - myPoly = psVectorFitPolynomial1D(NULL, NULL, NULL, NULL); - if (myPoly != NULL) { - printf("ERROR: psVectorFitPolynomial1D() returned a non-NULL polynomial.\n"); - testStatus = false; - } - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - printFooter(stdout, - "psMinimize functions", - "psVectorFitPolynomial1D(): CHEB, yErr is NULL", - testStatus); - return (!testStatus); -} - -psS32 main() -{ - t00(); - t01(); - t02(); - t03(); -} Index: trunk/psLib/test/dataManip/tst_psMinimize05.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize05.c (revision 4528) +++ (revision ) @@ -1,279 +1,0 @@ -/***************************************************************************** - This routine must ensure that psMinimizePowell() works correctly. - - We test with a NULL and non-NULL paramMask. - - XXX: Must verify the stderr for the NULL parameter tests. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include -#define N 5 -#define MIN_VALUE 20.0 -#define NUM_PARAMS 10 -#define ERROR_TOLERANCE 0.10 -float expectedParm[NUM_PARAMS]; -psS32 testStatus = true; - -/***************************************************************************** -myFunc(): This routine subtracts the associate value in expectedParm[] from -each parameter and then squares it, then sums that for all parameters, then -adds MIN_VALUE to it. The minimum for this function will be MIN_VALUE, and -will occur when each parameter equals the associated value in expectedParm[]. - -This procedure ignores the coordinates, other than to ensure that they were -passed correctly from psMinimizePowell(). - *****************************************************************************/ -float myFunc(psVector *myParams, - psArray *myCoords) -{ - float sum = 0.0; - float coordData = 0.0; - float expData = 0.0; - psS32 i; - - for (i=0;idata[i]))->data.F32[0]; - expData = (float) (i+10); - if (fabs(coordData - expData) > FLT_EPSILON) { - printf("ERROR(1): coordinate data was incorrectly passed to myFunc()\n"); - printf("ERROR(1): was (%f) should be (%f)\n", coordData, expData); - testStatus = false; - } - coordData = ((psVector *) (myCoords->data[i]))->data.F32[1]; - expData = (float) (i+3); - if (fabs(coordData - expData) > FLT_EPSILON) { - printf("ERROR(2): coordinate data was incorrectly passed to myFunc()\n"); - printf("ERROR(2): was (%f) should be (%f)\n", coordData, expData); - testStatus = false; - } - } - - - sum = 0.0; - for (i=0;idata.F32[i] - expectedParm[i]) * (myParams->data.F32[i] - expectedParm[i]); - } - sum = MIN_VALUE + (sum * sum); - - return(sum); -} - - -psS32 t00() -{ - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - psS32 i = 0; - psArray *myCoords; - psVector *myParams; - psVector *myParamMask; - psMinimization *min; - - psTraceSetLevel(".psLib", 0); - /************************************************************************** - *************************************************************************/ - myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - myParamMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_U8); - min = psMinimizationAlloc(100, 0.01); - - myCoords = psArrayAlloc(N); - for (i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); - ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10); - ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3); - } - for (i=0;idata.F32[i] = 0.0; - myParams->data.F32[i] = (float) i; - myParamMask->data.U8[i] = 0; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimizePowell()"); - - psMinimizePowell(min, - myParams, - myParamMask, - myCoords, - (psMinimizePowellFunc) myFunc); - - printf("\nThe minimum is %f (expected: %f)\n", min->value, MIN_VALUE); - - for (i=0;idata.F32[i], expectedParm[i]); - - if (fabs(myParams->data.F32[i] - expectedParm[i]) > fabs(ERROR_TOLERANCE * expectedParm[i])) { - printf("ERROR: Parameter %d: (%.1f), expected was (%.1f)\n", - i, myParams->data.F32[i], expectedParm[i]); - testStatus = false; - } else { - printf("Parameter %d: (%.1f), expected was (%.1f)\n", - i, myParams->data.F32[i], expectedParm[i]); - } - } - - - psFree(myCoords); - psFree(myParams); - psFree(myParamMask); - psFree(min); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - printFooter(stdout, - "psMinimize functions", - "psMinimizePowell()", - testStatus); - - - return (!testStatus); -} - -psS32 t01() -{ - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - psS32 i = 0; - psArray *myCoords; - psVector *myParams; - psMinimization *min; - - psTraceSetLevel(".psLib", 0); - /************************************************************************** - *************************************************************************/ - myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - min = psMinimizationAlloc(100, 0.01); - - myCoords = psArrayAlloc(N); - for (i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); - ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10); - ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3); - } - for (i=0;idata.F32[i] = 0.0; - myParams->data.F32[i] = (float) i; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimizePowell()"); - - psMinimizePowell(min, - myParams, - NULL, - myCoords, - (psMinimizePowellFunc) myFunc); - - printf("\nThe minimum is %f (expected: %f)\n", min->value, MIN_VALUE); - - for (i=0;idata.F32[i], expectedParm[i]); - - if (fabs(myParams->data.F32[i] - expectedParm[i]) > fabs(ERROR_TOLERANCE * expectedParm[i])) { - printf("ERROR: Parameter %d: (%.1f), expected was (%.1f)\n", - i, myParams->data.F32[i], expectedParm[i]); - testStatus = false; - } else { - printf("Parameter %d: (%.1f), expected was (%.1f)\n", - i, myParams->data.F32[i], expectedParm[i]); - } - } - - - psFree(myCoords); - psFree(myParams); - psFree(min); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - printFooter(stdout, - "psMinimize functions", - "psMinimizePowell()", - testStatus); - - - return (!testStatus); -} - -psS32 t02() -{ - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - psS32 i = 0; - psArray *myCoords; - psVector *myParams; - psVector *myParamMask; - psMinimization *min; - - psTraceSetLevel(".psLib", 0); - /************************************************************************** - *************************************************************************/ - myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - myParamMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_U8); - min = psMinimizationAlloc(100, 0.01); - - myCoords = psArrayAlloc(N); - for (i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); - ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10); - ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3); - } - for (i=0;idata.F32[i] = 0.0; - myParams->data.F32[i] = (float) i; - myParamMask->data.U8[i] = 0; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psMinimizePowell(): various NULL inputs"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null minimize."); - psMinimizePowell(NULL, myParams, myParamMask, myCoords, (psMinimizePowellFunc) myFunc); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null parameter vector"); - psMinimizePowell(min, NULL, myParamMask, myCoords,(psMinimizePowellFunc) myFunc); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null coords."); - psMinimizePowell(min, myParams, myParamMask, NULL, (psMinimizePowellFunc) myFunc); - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null function"); - psMinimizePowell(min, myParams, myParamMask, myCoords, NULL); - - psFree(myCoords); - psFree(myParams); - psFree(myParamMask); - psFree(min); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - printFooter(stdout, - "psMinimize functions", - "psMinimizePowell(): various NULL inputs", - testStatus); - - - return (!testStatus); -} - -psS32 main() -{ - t00(); - t01(); - t02(); -} Index: trunk/psLib/test/dataManip/tst_psMinimize06.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize06.c (revision 4528) +++ (revision ) @@ -1,107 +1,0 @@ -/***************************************************************************** - This routine must ensure that psMinimizeLM() works correctly. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include -#define NUM_ITERATIONS 10000 -#define ERR_TOL 0.0 -#define N 20 -#define MIN_VALUE 5.0 -#define NUM_PARAMS 3 -float expectedParm[NUM_PARAMS]; -psS32 testStatus = true; - -/***************************************************************************** -myFunc(): - sum = (param[0] * x[0]) + - (param[1] * x[1]) + - ... - *****************************************************************************/ -psF64 myFunc(psVector *deriv, - psVector *params, - psVector *x) -{ - if ((deriv == NULL) || - (params == NULL)) { - psError(PS_ERR_UNKNOWN, true, "deriv or params is NULL.\n"); - } - - psF64 sum = 0.0; - for (psS32 i=0 ; i < params->n ; i++) { - sum += (params->data.F32[i] * x->data.F32[i]); - deriv->data.F32[i] = params->data.F32[i]; - } - - return(sum); -} - - -psS32 t01() -{ - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - psS32 i = 0; - psArray *myCoords; - psVector *myParams; - psImage *myCovar; - psMinimization *min; - psVector *y; - - psTraceSetLevel(".psLib", 0); - /************************************************************************** - *************************************************************************/ - min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL); - myCovar = psImageAlloc(NUM_PARAMS, NUM_PARAMS, PS_TYPE_F32); - myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - myCoords = psArrayAlloc(N); - y = psVectorAlloc(N, PS_TYPE_F32); - - for (i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); - ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10); - ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3); - y->data.F32[i] = (float) i; - } - for (i=0;idata.F32[i] = (float) i; - myParams->data.F32[i] = expectedParm[i] * 1.3; - myParams->data.F32[i] = 0.0; - myParams->data.F32[i] = (float) (5 + i); - } - - psMinimizeLMChi2(min, - myCovar, - myParams, - NULL, - myCoords, - y, - NULL, - (psMinimizeLMChi2Func) myFunc); - - printf("\nThe chi-squared is %f\n", min->value); - for (i=0;idata.F32[i], expectedParm[i]); - } - - psFree(min); - psFree(myCovar); - psFree(myParams); - psFree(myCoords); - psFree(y); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - return (!testStatus); -} - -psS32 main() -{ - t01(); -} Index: trunk/psLib/test/dataManip/tst_psMinimize07.c =================================================================== --- trunk/psLib/test/dataManip/tst_psMinimize07.c (revision 4528) +++ (revision ) @@ -1,164 +1,0 @@ -/***************************************************************************** - This routine must ensure that psMinimizeLMChi2Gauss1D() works correctly. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include -#define NUM_ITERATIONS 100 -#define ERR_TOL 0.0 -#define N 24 -#define NUM_PARAMS 2 -#define MEAN 14.5 -#define STDEV 1.2 - -float expectedParm[NUM_PARAMS]; -psS32 testStatus = true; - -// This routine generates a vector of length "n" with the specified mean and -// stdev. -psVector *genGaussianVector(int n, float mean, float stdev) -{ - psVector *y = psVectorAlloc(n, PS_TYPE_F32); - - for (psS32 i=0;idata.F32[i] = psGaussian((float) i, mean, stdev, false); - } - return(y); -} - -// This routine tries to fit a Gaussian to a set of data points via the -// psMinimizeLMChi2() and psMinimizeLMChi2Gauss1D() functions. -psS32 t00() -{ - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - psS32 i = 0; - psArray *myCoords; - psVector *myParams; - psImage *myCovar; - psMinimization *min; - - psTraceSetLevel(".psLib.dataManip.psMinimize", 0); - /************************************************************************** - *************************************************************************/ - min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL); - myCovar = psImageAlloc(NUM_PARAMS, NUM_PARAMS, PS_TYPE_F32); - myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - myParams->data.F32[0] = MEAN * 0.7; - myParams->data.F32[1] = STDEV * 0.7; - myCoords = psArrayAlloc(N); - psVector *y = genGaussianVector(N, MEAN, STDEV); - - for (i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); - ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) i; - printf("Initial data %d: (%f, %f)\n", i, ((psVector *) (myCoords->data[i]))->data.F32[0], y->data.F32[i]); - } - - psMinimizeLMChi2(min, - myCovar, - myParams, - NULL, - myCoords, - y, - NULL, - (psMinimizeLMChi2Func) psMinimizeLMChi2Gauss1D); - - printf("\nThe chi-squared is %f\n", min->value); - - expectedParm[0] = MEAN; - expectedParm[1] = STDEV; - for (i=0;idata.F32[i], expectedParm[i]); - } - - psFree(min); - psFree(myCovar); - psFree(myParams); - psFree(myCoords); - psFree(y); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - return (!testStatus); -} - -// This routine tries to fit a Gaussian to a set of data points via the -// psMinimizeChi2Powell() function. -psS32 t01() -{ - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - psS32 i = 0; - psArray *myCoords; - psVector *myParams; - psImage *myCovar; - psMinimization *min; - - psTraceSetLevel(".psLib.dataManip.psMinimize", 0); - psTraceSetLevel(".psLib.dataManip.psMinimizeLMChi2Gauss1D", 0); - - psTraceSetLevel(".psLib.dataManip.psMinimizePowell", 0); - psTraceSetLevel(".psLib.dataManip.myPowellChi2Func", 0); - psTraceSetLevel(".psLib.dataManip.p_psLineMin", 0); - psTraceSetLevel(".psLib.dataManip.p_psDetermineBracket", 0); - psTraceSetLevel(".psLib.dataManip.psFunctions.psGaussian", 0); - psTraceSetLevel(".psLib.dataManip.psFunctions", 0); - psTraceSetLevel(".", 0); - // psTracePrintLevels(); - /************************************************************************** - *************************************************************************/ - min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL); - myCovar = psImageAlloc(NUM_PARAMS, NUM_PARAMS, PS_TYPE_F32); - myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); - myParams->data.F32[0] = MEAN * 0.7; - myParams->data.F32[1] = STDEV * 0.7; - myCoords = psArrayAlloc(N); - psVector *y = genGaussianVector(N, MEAN, STDEV); - - for (i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); - ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) i; - printf("Initial data %d: (%f, %f)\n", i, ((psVector *) (myCoords->data[i]))->data.F32[0], y->data.F32[i]); - } - - // psMinimizeChi2Powell(min, myParams, NULL, myCoords, y, NULL, - // (psMinimizeChi2PowellFunc) myFunc); - psMinimizeChi2Powell(min, myParams, NULL, myCoords, y, NULL, - (psMinimizeChi2PowellFunc) psMinimizePowellChi2Gauss1D); - - printf("\nThe chi-squared is %f\n", min->value); - - expectedParm[0] = MEAN; - expectedParm[1] = STDEV; - for (i=0;idata.F32[i], expectedParm[i]); - } - - psFree(min); - psFree(myCovar); - psFree(myParams); - psFree(myCoords); - psFree(y); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - return (!testStatus); -} - -psS32 main() -{ - t00(); - t01(); -} -//This code is - Index: trunk/psLib/test/dataManip/tst_psRandom.c =================================================================== --- trunk/psLib/test/dataManip/tst_psRandom.c (revision 4528) +++ (revision ) @@ -1,388 +1,0 @@ -/***************************************************************************** -This routine must ensure that the various random number generator functions -work properly. - - t00(): ensure that psRandom structs are properly allocated by psRandomAlloc(). - t01(): ensure that psRandomUniform() produces a sequence of numbers with - proper mean and stdev. - t02(): ensure that psRandomGaussian() produces a sequence of numbers with - proper mean and stdev. - t03(): ensure that psRandomPoisson() produces a sequence of numbers with - proper mean and stdev. - t04(): ensure that psRandomReset() properly seeds the random number - generator for psRandomUniform(). - t05(): ensure that psRandomReset() properly seeds the random number - generator for psRandomGaussian(). - t06(): ensure that psRandomReset() properly seeds the random number - generator for psRandomPoisson(). - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" - -#define NUM_DATA 10000 -#define SEED 54321 -#define SEED2 345 -#define UNIFORM_MEAN 0.5 -#define UNIFORM_STDEV 0.3 -#define GAUSSIAN_MEAN 0.0 -#define GAUSSIAN_STDEV 1.0 -#define POISSON_MEAN 15.0 -#define POISSON_STDEV (POISSON_MEAN / 4) -#define ERROR_TOLERANCE 0.1 -psS32 testStatus = true; - -static psS32 testRandomAlloc(void); -static psS32 testRandomUniform(void); -static psS32 testRandomGaussian(void); -static psS32 testRandomPoisson(void); -static psS32 testRandomResetUniform(void); -static psS32 testRandomResetGaussian(void); -static psS32 testRandomResetPoisson(void); - -testDescription tests[] = { - {testRandomAlloc,000,"psRandomAlloc",0,false}, - {testRandomUniform,000,"psRandomUniform",0,false}, - {testRandomGaussian,000,"psRandomGaussian",0,false}, - {testRandomPoisson,000,"psRandomPoisson",0,false}, - {testRandomResetUniform,000,"psRandomReset",0,false}, - {testRandomResetGaussian,000,"psRandomReset",0,false}, - {testRandomResetPoisson,000,"psRandomReset",0,false}, - {NULL} - }; - -psS32 main(psS32 argc, char* argv[]) -{ - if(!runTestSuite(stderr,"psRandom",tests,argc,argv)) { - return 1; - } - - return 0; -} - -psS32 testRandomAlloc(void) -{ - psRandom *myRNG = NULL; - - // Valid type allocation - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - if (myRNG->type != PS_RANDOM_TAUS) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",myRNG->type,PS_RANDOM_TAUS); - return 2; - } - psFree(myRNG); - - // Valid type allocation with seed equal to zero - psLogSetDestination("file:seed_msglog1.txt"); - myRNG = psRandomAlloc(PS_RANDOM_TAUS, 0); - psLogSetDestination("dest:stderr"); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 3; - } - if (myRNG->type != PS_RANDOM_TAUS) { - psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",myRNG->type,PS_RANDOM_TAUS); - return 4; - } - psFree(myRNG); - - // Invalid type allocation - psLogMsg(__func__,PS_LOG_INFO,"Invalid type, should generate error message"); - myRNG = psRandomAlloc(100,SEED); - if (myRNG != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type"); - return 5; - } - - // Negative seed value - myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5); - if(myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return allocated psRandom"); - return 6; - } - psFree(myRNG); - - return 0; -} - -psS32 testRandomUniform(void) -{ - psRandom *myRNG = NULL; - psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - - // Initialize vector data with random number - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans->data.F64[i] = psRandomUniform(myRNG); - } - // Perform vector stats on random data (mean, stdev) - stats = psVectorStats(stats, rans, NULL, NULL, 0); - stats->options = PS_STAT_SAMPLE_STDEV; - stats = psVectorStats(stats, rans, NULL, NULL, 0); - // Verify mean and stdev - if ((fabs(stats->sampleMean - UNIFORM_MEAN) / UNIFORM_MEAN) > ERROR_TOLERANCE) { - psError(PS_ERR_UNKNOWN,true,"psRandomUniform mean is %.2f, should be %.2f", - stats->sampleMean, UNIFORM_MEAN); - return 2; - } - if ((fabs(stats->sampleStdev - UNIFORM_STDEV) / UNIFORM_STDEV) > ERROR_TOLERANCE) { - psError(PS_ERR_UNKNOWN,true,"psRandomUniform stdev is %.2f, should be %.2f", - stats->sampleStdev, UNIFORM_STDEV); - return 3; - } - - psFree(myRNG); - psFree(rans); - psFree(stats); - - psLogMsg(__func__,PS_LOG_INFO,"NULL psRandom variable, should generate error message"); - if(psRandomUniform(NULL) != 0) { - psError(PS_ERR_UNKNOWN,true,"Did not return zero for null psRandom"); - return 4; - } - - return 0; -} - -psS32 testRandomGaussian(void) -{ - psRandom *myRNG = NULL; - psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - - // Initialize vector with random data - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans->data.F64[i] = psRandomGaussian(myRNG); - } - - // Perform vector stats on data (mean, stdev) - stats = psVectorStats(stats, rans, NULL, NULL, 0); - stats->options = PS_STAT_SAMPLE_STDEV; - stats = psVectorStats(stats, rans, NULL, NULL, 0); - - // Verify statistics - if ((fabs(stats->sampleMean - GAUSSIAN_MEAN) / 1.0) > ERROR_TOLERANCE) { - psError(PS_ERR_UNKNOWN,true,"psRandomGaussian mean is %.2f, should be %.2f", - stats->sampleMean, GAUSSIAN_MEAN); - return 2; - } - if ((fabs(stats->sampleStdev - GAUSSIAN_STDEV) / GAUSSIAN_STDEV) > ERROR_TOLERANCE) { - psError(PS_ERR_UNKNOWN,true,"psRandomGaussian stdev is %.2f, should be %.2f", - stats->sampleStdev, GAUSSIAN_STDEV); - return 3; - } - - psFree(myRNG); - psFree(rans); - psFree(stats); - - psLogMsg(__func__,PS_LOG_INFO,"NULL psRandom variable, should generate error message"); - if(psRandomGaussian(NULL) != 0) { - psError(PS_ERR_UNKNOWN,true,"Did not return zero for null psRandom"); - return 4; - } - - return 0; -} - -psS32 testRandomPoisson(void) -{ - psRandom *myRNG = NULL; - psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - - // Initialize vector with random data - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans->data.F64[i] = psRandomPoisson(myRNG, POISSON_MEAN); - } - - // Perform statistics on data - stats = psVectorStats(stats, rans, NULL, NULL, 0); - stats->options = PS_STAT_SAMPLE_STDEV; - stats = psVectorStats(stats, rans, NULL, NULL, 0); - if ((fabs(stats->sampleMean - POISSON_MEAN) / POISSON_MEAN) > ERROR_TOLERANCE) { - psError(PS_ERR_UNKNOWN,true,"psRandomPoisson mean is %.2f, should be %.2f", - stats->sampleMean, POISSON_MEAN); - return 2; - } - if ((fabs(stats->sampleStdev - POISSON_STDEV) / POISSON_STDEV) > ERROR_TOLERANCE) { - psError(PS_ERR_UNKNOWN,true,"psRandomPoisson stdev is %.2f, should be %.2f", - stats->sampleStdev, POISSON_STDEV); - return 3; - } - - psFree(myRNG); - psFree(rans); - psFree(stats); - - psLogMsg(__func__,PS_LOG_INFO,"NULL psRandom variable, should generate error message"); - if(psRandomPoisson(NULL, POISSON_MEAN) != 0) { - psError(PS_ERR_UNKNOWN,true,"Did not return zero for null psRandom"); - return 4; - } - - return 0; -} - -psS32 testRandomResetUniform(void) -{ - psRandom *myRNG = NULL; - psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - - // Random reset - psRandomReset(myRNG, SEED); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans00->data.F64[i] = psRandomUniform(myRNG); - } - psRandomReset(myRNG, SEED2); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans01->data.F64[i] = psRandomUniform(myRNG); - } - psRandomReset(myRNG, SEED); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans02->data.F64[i] = psRandomUniform(myRNG); - } - - // Verify reset to original seed produces same results - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - if (rans00->data.F64[i] != rans02->data.F64[i]) { - psError(PS_ERR_UNKNOWN,true,"psRandomUniform did not produce the same results with the same seed"); - return i+1; - } - } - - psFree(myRNG); - psFree(rans00); - psFree(rans01); - psFree(rans02); - - psRandom *myRNG1 = NULL; - myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED); - psLogSetDestination("file:seed_msglog2.txt"); - psRandomReset(myRNG1,0); - psLogSetDestination("dest:stderr"); - psFree(myRNG1); - - psLogMsg(__func__,PS_LOG_INFO,"Reset a NULL psRandom variable, should generate an error message"); - psRandomReset(NULL,SEED); - - return 0; -} - -psS32 testRandomResetGaussian(void) -{ - psRandom *myRNG = NULL; - psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - - // Initialize random data in vectors - psRandomReset(myRNG, SEED); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans00->data.F64[i] = psRandomGaussian(myRNG); - } - psRandomReset(myRNG, SEED2); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans01->data.F64[i] = psRandomGaussian(myRNG); - } - psRandomReset(myRNG, SEED); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans02->data.F64[i] = psRandomGaussian(myRNG); - } - - // Verify data from original seed produces same data after reset - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - if (rans00->data.F64[i] != rans02->data.F64[i]) { - psError(PS_ERR_UNKNOWN,true,"psRandomGaussian did not produce the same results with the same seed"); - return 2; - } - } - - psFree(myRNG); - psFree(rans00); - psFree(rans01); - psFree(rans02); - - return 0; -} - -psS32 testRandomResetPoisson(void) -{ - psRandom *myRNG = NULL; - psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); - return 1; - } - - // Initialize vectors with random data - psRandomReset(myRNG, SEED); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans00->data.F64[i] = psRandomPoisson(myRNG, POISSON_MEAN); - } - psRandomReset(myRNG, SEED2); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans01->data.F64[i] = psRandomPoisson(myRNG, POISSON_MEAN); - } - psRandomReset(myRNG, SEED); - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - rans02->data.F64[i] = psRandomPoisson(myRNG, POISSON_MEAN); - } - - // Verify the original seed produces same data after reset - for (psS32 i = 0 ; i < NUM_DATA ; i++) { - if (rans00->data.F64[i] != rans02->data.F64[i]) { - psError(PS_ERR_UNKNOWN,true,"psRandomPoisson did not produce the same results with the same seed"); - return 2; - } - } - - psFree(myRNG); - psFree(rans00); - psFree(rans01); - psFree(rans02); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psStats00.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats00.c (revision 4528) +++ (revision ) @@ -1,389 +1,0 @@ -/** @file tst_psStats00.c -* -* @brief Contains tests for psVectorStats with sample mean calculations -* -* We extensively test the code with data type PS_TYPE_F32. If these pass, we -* do a much simpler test with data types PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_F64. -* -* If the psStats,c code every changes such that vectors of different type -* are handled by different routines, then these tests must be extended. -* -* @author GLG, MHPCC -* -* @version $Revision: 1.18 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-07 23:31:32 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -*/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define ERROR_TOL 0.0001 -#define N 15 - -static psS32 testStatsSampleMeanF32(void); -static psS32 testStatsSampleMeanS8(void); -static psS32 testStatsSampleMeanU16(void); -static psS32 testStatsSampleMeanF64(void); - -testDescription tests[] = { - {testStatsSampleMeanF32, 512, "psVectorStats",0,false}, - {testStatsSampleMeanS8, 512, "psVectorStats",0,false}, - {testStatsSampleMeanU16, 512, "psVectorStats",0,false}, - {testStatsSampleMeanF64, 512, "psVectorStats",0,false}, - {NULL} - }; - -static psF32 samplesF32[N] = { 1.1, 2.2, -3.3, 4.4, 5.5, -6.6, 7.7, 8.8, -9.9, 10.0, - 11.01, -12.02, 13.03, 14.04, -15.05 }; -static psS8 samplesS8[N] = {1, 2, -3, 4, 5, -6, 7, 8, -9, 10, 11, -12, 13, 14, -15}; -static psU16 samplesU16[N] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; -static psF64 samplesF64[N] = { 1.1, 2.2, -3.3, 4.4, 5.5, -6.6, 7.7, 8.8, -9.9, 10.0, - 11.01, -12.02, 13.03, 14.04, -15.05 }; -static psF32 errorsF32[N] = { -0.10, 0.11, -0.12, 0.13, -0.14, 0.15, -0.16, 0.17, - -0.18, 0.19, -0.20, 0.21, -0.22, 0.23, -0.24 }; - -static psF64 expectedMeanNoMaskF32 = 2.060667; -static psF64 expectedMeanWithMaskF32 = 2.123846; -static psF64 expectedMeanNoMaskS8 = 2.000000; -static psF64 expectedMeanNoMaskU16 = 8.000000; -static psF64 expectedMeanNoMaskF64 = 2.060667; -static psF64 expectedMeanRangeNoMaskF32 = 0.137500; -static psF64 expectedMeanRangeWithMaskF32 = -0.366667; -static psF64 expectedWeightMeanNoMaskF32 = 1.807210; -static psF64 expectedWeightMeanWithMaskF32 = 1.890217; -static psF64 expectedWeightMeanNoMaskRangeF32 = 0.640952; -static psF64 expectedWeightMeanWithMaskRangeF32 = 0.046574; - -psF64 rtc(void); -psF64 sT, eT; -psF64 diff; - -#include -psS32 main(psS32 argc, char* argv[] ) -{ - psLogSetLevel(PS_LOG_INFO); - - return ( ! runTestSuite(stderr, "psVectorStats",tests,argc,argv) ); -} - -psS32 testStatsSampleMeanF32(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psVector* maskVector = NULL; - psVector* myErrors = NULL; - psF64 mean = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - myErrors = psVectorAlloc(N, PS_TYPE_F32); - myErrors->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - mean = 0.0; - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.F32[i] = samplesF32[i]; - myErrors->data.F32[i] = errorsF32[i]; - } - - // Set the mask vector and calculate the expected maximum. - for (psS32 i = 0; i < N; i++) { - - if (i > 1) { - maskVector->data.U8[i] = 0; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedMeanNoMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedMeanNoMaskF32); - return 1; - } - - // Invoke psVectorStats with no vector mask and error vector - myStats = psVectorStats(myStats, myVector, myErrors, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedWeightMeanNoMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedWeightMeanNoMaskF32); - return 10; - } - - // Invoke psVectorStats with no vector mask and data range - myStats->min = -10.0; - myStats->max = 8.0; - myStats->options = PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE; - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedMeanRangeNoMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f", - mean, expectedMeanRangeNoMaskF32); - return 2; - } - - // Invoke psVectorStats with no vector mask, errors and data range - myStats = psVectorStats(myStats, myVector, myErrors, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedWeightMeanNoMaskRangeF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f", - mean, expectedWeightMeanNoMaskRangeF32); - return 20; - } - myStats->options = PS_STAT_SAMPLE_MEAN; - - /*************************************************************************/ - /* Call psVectorStats() with vector mask=1. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - mean = myStats->sampleMean; - if ( fabs(mean - expectedMeanWithMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedMeanWithMaskF32); - return 3; - } - - // Invoke psVectorStats with vector mask and error vector - myStats = psVectorStats(myStats, myVector, myErrors, maskVector, 1); - mean = myStats->sampleMean; - if ( fabs(mean - expectedWeightMeanWithMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedWeightMeanWithMaskF32); - return 30; - } - - // Invoke psVectorStats with vector mask and data range - myStats->options = PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE; - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedMeanRangeWithMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f", - mean, expectedMeanRangeWithMaskF32); - return 4; - } - - // Invoke psVectorStats with vector mask, errors, and data range - myStats = psVectorStats(myStats, myVector, myErrors, maskVector, 1); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedWeightMeanWithMaskRangeF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f", - mean, expectedWeightMeanWithMaskRangeF32); - return 40; - } - myStats->options = PS_STAT_SAMPLE_MEAN; - - /*************************************************************************/ - /* Call psVectorStats() with vector mask=2. */ - /*************************************************************************/ - // Set the mask vector and calculate the expected maximum. - // Set the mask vector. - for (psS32 i = 0; i < N; i++) { - if (maskVector->data.U8[i] == 1) { - maskVector->data.U8[i] = 2; - } - } - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 2); - mean = myStats->sampleMean; - if (fabs(mean - expectedMeanWithMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean,expectedMeanWithMaskF32); - return 5; - } - - /*************************************************************************/ - /* Call psVectorStats() with vector mask=3. */ - /*************************************************************************/ - // Set the mask vector and calculate the expected maximum. - // Set the mask vector. - for (psS32 i = 0; i < N; i++) { - if (maskVector->data.U8[i] == 2) { - maskVector->data.U8[i] = 3; - } - } - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 4); - mean = myStats->sampleMean; - if (fabs(mean - expectedMeanNoMaskF32) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f", - mean,expectedMeanNoMaskF32); - return 6; - } - - // Mask all values and verify return is NAN - for(psS32 i = 0; i < N; i++) { - maskVector->data.U8[i] = 1; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate warning message"); - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - mean = myStats->sampleMean; - if( !isnan(mean) ) { - psError(PS_ERR_UNKNOWN,true,"Did not return NAN with all values masked"); - return 7; - } - - /*************************************************************************/ - /* Call psVectorStats() with NULL inputs. */ - /*************************************************************************/ - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - if( psVectorStats(myStats, NULL, NULL, NULL, 0) != myStats ) { - psError(PS_ERR_UNKNOWN,true,"psVectorStats did not return stats when input NULL"); - return 8; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - psStats *myStats2 = psVectorStats(NULL, myVector, NULL, NULL, 0); - if ( myStats2 != NULL ) { - psError(PS_ERR_UNKNOWN,true,"psVectorStats did not return NULL"); - return 9; - } - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - psFree(myStats); - psFree(myVector); - psFree(myErrors); - psFree(maskVector); - psFree(myStats2); - - return 0; -} - -psS32 testStatsSampleMeanS8(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 mean = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - myVector = psVectorAlloc(N, PS_TYPE_S8); - myVector->n = N; - - mean = 0.0; - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.S8[i] = samplesS8[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedMeanNoMaskS8) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedMeanNoMaskS8); - return 1; - } - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - psFree(myStats); - psFree(myVector); - - return 0; -} - -psS32 testStatsSampleMeanU16(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 mean = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - myVector = psVectorAlloc(N, PS_TYPE_U16); - myVector->n = N; - - mean = 0.0; - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.U16[i] = samplesU16[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedMeanNoMaskU16) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedMeanNoMaskU16); - return 1; - } - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - psFree(myStats); - psFree(myVector); - - return 0; -} - -psS32 testStatsSampleMeanF64(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 mean = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - myVector = psVectorAlloc(N, PS_TYPE_F64); - myVector->n = N; - - mean = 0.0; - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.F64[i] = samplesF64[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - mean = myStats->sampleMean; - // Verify return value is as expected - if ( fabs(mean - expectedMeanNoMaskF64) > ERROR_TOL ) { - psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f", - mean, expectedMeanNoMaskF64); - return 1; - } - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - psFree(myStats); - psFree(myVector); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psStats01.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats01.c (revision 4528) +++ (revision ) @@ -1,264 +1,0 @@ -/** @file tst_psStats01.c -* -* @brief Contains tests for psVectorStats with max calculations. -* -* We extensively test the code with data type PS_TYPE_F32. If these pass, we -* do a much simpler test with data types PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_F64. -* -* If the psStats,c code every changes such that vectors of different type -* are handled by different routines, then these tests must be extended. -* -* @author GLG, MHPCC -* -* @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-07 23:31:32 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -*/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define N 15 -#define ERROR_TOL 0.0001 - -static psS32 testStatsMaxF32(void); -static psS32 testStatsMaxS8(void); -static psS32 testStatsMaxU16(void); -static psS32 testStatsMaxF64(void); - -testDescription tests[] = { - {testStatsMaxF32, 518, "psVectorStats", 0, false}, - {testStatsMaxS8, 518, "psVectorStats", 0, false}, - {testStatsMaxU16, 518, "psVectorStats", 0, false}, - {testStatsMaxF64, 518, "psVectorStats", 0, false}, - {NULL} - }; - -static psF32 samplesF32[N] = { 1.1, 2.2, -3.3, 4.4, 5.5, -6.6, 7.7, 8.8, -9.9, 10.0, - 11.01, -12.02, 13.03, 14.04, -15.05 }; -static psS8 samplesS8[N] = {1, 2, -3, 4, 5, -6, 7, 8, -9, 10, 11, -12, 13, 14, -15}; -static psU16 samplesU16[N] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; -static psF64 samplesF64[N] = { 1.1, 2.2, -3.3, 4.4, 5.5, -6.6, 7.7, 8.8, -9.9, 10.0, - 11.01, -12.02, 13.03, 14.04, -15.05 }; - -static psF64 expectedMaxNoMaskF32 = 14.04; -static psF64 expectedMaxNoMaskS8 = 14.00; -static psF64 expectedMaxNoMaskU16 = 15.00; -static psF64 expectedMaxNoMaskF64 = 14.04; - -static psF64 expectedMaxWithMaskF32 = 13.03; -static psF64 expectedMaxRangeNoMaskF32 = 10.00; -static psF64 expectedMaxRangeWithMaskF32 = 13.03; - -psS32 main(psS32 argc, char* argv[] ) -{ - psLogSetLevel(PS_LOG_INFO); - - return ( ! runTestSuite(stderr, "psVectorStats", tests, argc, argv) ); -} - -psS32 testStatsMaxF32(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psVector* maskVector = NULL; - psF64 max = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MAX); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.F32[i] = samplesF32[i]; - } - - // Set the mask vector and calculate the expected maximum. - for (psS32 i = 0; i < N; i++) { - if (i < 13) { - maskVector->data.U8[i] = 0; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - max = myStats->max; - - if (fabs(max - expectedMaxNoMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max no mask return value %lf not as expected %lf", - max, expectedMaxNoMaskF32); - return 1; - } - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - max = myStats->max; - if (fabs(max - expectedMaxWithMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max with mask return value %lf not as expected %lf", - max, expectedMaxWithMaskF32); - return 2; - } - - // Invoke function with data range with no mask - myStats->options = PS_STAT_MAX | PS_STAT_USE_RANGE; - myStats->max = 10.1; - myStats->min = 0.0; - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - max = myStats->max; - - if(fabs(max - expectedMaxRangeNoMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max with range no mask %lf not as expected %lf", - max, expectedMaxRangeNoMaskF32); - return 3; - } - - // Invoke function with data range and mask - myStats->max = 14.0; - myStats->min = 0.0; - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - max = myStats->max; - if(fabs(max - expectedMaxRangeWithMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max with range with mask %lf not as expected %lf", - max, expectedMaxRangeWithMaskF32); - return 3; - } - - // Invoke function with data range with no valid data - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); - myStats->max = 100.00; - myStats->min = 90.00; - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - max = myStats->max; - - if(!isnan(max)) { - psError(PS_ERR_UNKNOWN,true,"Max with range with no valid elemenets did not return NAN"); - return 4; - } - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - return 0; -} - -psS32 testStatsMaxS8(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 max = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MAX); - myVector = psVectorAlloc(N, PS_TYPE_S8); - myVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.S8[i] = samplesS8[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - max = myStats->max; - - if (fabs(max - expectedMaxNoMaskS8) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max no mask return value %lf not as expected %lf", - max, expectedMaxNoMaskS8); - return 1; - } - - psFree(myStats); - psFree(myVector); - - return 0; -} - -psS32 testStatsMaxU16(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 max = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MAX); - myVector = psVectorAlloc(N, PS_TYPE_U16); - myVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.U16[i] = samplesU16[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - max = myStats->max; - - if (fabs(max - expectedMaxNoMaskU16) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max no mask return value %lf not as expected %lf", - max, expectedMaxNoMaskU16); - return 1; - } - - psFree(myStats); - psFree(myVector); - - return 0; -} - -psS32 testStatsMaxF64(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 max = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MAX); - myVector = psVectorAlloc(N, PS_TYPE_F64); - myVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.F64[i] = samplesF64[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - max = myStats->max; - - if (fabs(max - expectedMaxNoMaskF64) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Max no mask return value %lf not as expected %lf", - max, expectedMaxNoMaskF64); - return 1; - } - - psFree(myStats); - psFree(myVector); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psStats02.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats02.c (revision 4528) +++ (revision ) @@ -1,264 +1,0 @@ -/** @file tst_psStats02.c -* -* @brief Contains tests for psVectorStats with min calculations -* -* We extensively test the code with data type PS_TYPE_F32. If these pass, we -* do a much simpler test with data types PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_F64. -* -* If the psStats,c code every changes such that vectors of different type -* are handled by different routines, then these tests must be extended. -* -* @author GLG, MHPCC -* -* @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-07 23:26:19 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii -*/ - -#include "pslib_strict.h" -#include "psTest.h" - -#define N 15 -#define ERROR_TOL 0.0001 - -static psS32 testStatsMinF32(void); -static psS32 testStatsMinS8(void); -static psS32 testStatsMinU16(void); -static psS32 testStatsMinF64(void); - -testDescription tests[] = { - {testStatsMinF32, 518, "psVectorStats", 0, false}, - {testStatsMinS8, 518, "psVectorStats", 0, false}, - {testStatsMinU16, 518, "psVectorStats", 0, false}, - {testStatsMinF64, 518, "psVectorStats", 0, false}, - {NULL} - }; - -static psF32 samplesF32[N] = { 1.1, 2.2, -3.3, 4.4, 5.5, -6.6, 7.7, 8.8, -9.9, 10.0, - 11.01, -12.02, 13.03, 14.04, -15.05 }; -static psS8 samplesS8[N] = {1, 2, -3, 4, 5, -6, 7, 8, -9, 10, 11, -12, 13, 14, -15}; -static psU16 samplesU16[N] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; -static psF64 samplesF64[N] = { 1.1, 2.2, -3.3, 4.4, 5.5, -6.6, 7.7, 8.8, -9.9, 10.0, - 11.01, -12.02, 13.03, 14.04, -15.05 }; - -static psF64 expectedMinNoMaskF32 = -15.05; -static psF64 expectedMinNoMaskS8 = -15.00; -static psF64 expectedMinNoMaskU16 = 1.00; -static psF64 expectedMinNoMaskF64 = -15.05; - -static psF64 expectedMinWithMaskF32 = -12.02; -static psF64 expectedMinRangeNoMaskF32 = 1.10; -static psF64 expectedMinRangeWithMaskF32 = -12.02; - -psS32 main(psS32 argc, char* argv[] ) -{ - psLogSetLevel(PS_LOG_INFO); - - return ( ! runTestSuite(stderr, "psVectorStats", tests, argc, argv) ); -} - -psS32 testStatsMinF32(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psVector* maskVector = NULL; - psF64 min = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MIN); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.F32[i] = samplesF32[i]; - } - - // Set the mask vector and calculate the expected maximum. - for (psS32 i = 0; i < N; i++) { - if (i < 13) { - maskVector->data.U8[i] = 0; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - min = myStats->min; - - if (fabs(min - expectedMinNoMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min no mask return value %lf not as expected %lf", - min, expectedMinNoMaskF32); - return 1; - } - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - min = myStats->min; - if (fabs(min - expectedMinWithMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min with mask return value %lf not as expected %lf", - min, expectedMinWithMaskF32); - return 2; - } - - // Invoke function with data range with no mask - myStats->options = PS_STAT_MIN | PS_STAT_USE_RANGE; - myStats->max = 10.1; - myStats->min = 0.0; - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - min = myStats->min; - - if(fabs(min - expectedMinRangeNoMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min with range no mask %lf not as expected %lf", - min, expectedMinRangeNoMaskF32); - return 3; - } - - // Invoke function with data range and mask - myStats->max = 10.1; - myStats->min = -15.00; - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - min = myStats->min; - if(fabs(min - expectedMinRangeWithMaskF32) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min with range with mask %lf not as expected %lf", - min, expectedMinRangeWithMaskF32); - return 3; - } - - // Invoke function with data range with no valid data - psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); - myStats->max = 100.00; - myStats->min = 90.00; - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - min = myStats->min; - - if(!isnan(min)) { - psError(PS_ERR_UNKNOWN,true,"Min with range with no valid elemenets did not return NAN"); - return 4; - } - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - return 0; -} - -psS32 testStatsMinS8(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 min = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MIN); - myVector = psVectorAlloc(N, PS_TYPE_S8); - myVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.S8[i] = samplesS8[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - min = myStats->min; - - if (fabs(min - expectedMinNoMaskS8) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min no mask return value %lf not as expected %lf", - min, expectedMinNoMaskS8); - return 1; - } - - psFree(myStats); - psFree(myVector); - - return 0; -} - -psS32 testStatsMinU16(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 min = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MAX); - myVector = psVectorAlloc(N, PS_TYPE_U16); - myVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.U16[i] = samplesU16[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - min = myStats->min; - - if (fabs(min - expectedMinNoMaskU16) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min no mask return value %lf not as expected %lf", - min, expectedMinNoMaskU16); - return 1; - } - - psFree(myStats); - psFree(myVector); - - return 0; -} - -psS32 testStatsMinF64(void) -{ - psStats* myStats = NULL; - psVector* myVector = NULL; - psF64 min = 0.0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_MIN); - myVector = psVectorAlloc(N, PS_TYPE_F64); - myVector->n = N; - - // Set the appropriate values for the vector data. - for (psS32 i = 0; i < N; i++) { - myVector->data.F64[i] = samplesF64[i]; - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - min = myStats->min; - - if (fabs(min - expectedMinNoMaskF64) > ERROR_TOL) { - psError(PS_ERR_UNKNOWN,true,"Min no mask return value %lf not as expected %lf", - min, expectedMinNoMaskF64); - return 1; - } - - psFree(myStats); - psFree(myVector); - - return 0; -} - Index: trunk/psLib/test/dataManip/tst_psStats03.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats03.c (revision 4528) +++ (revision ) @@ -1,123 +1,0 @@ -/***************************************************************************** - This routine must ensure that PS_STAT_SAMPLE_MEDIAN is correctly computed - by the procedure psVectorStats(). - - XXX: Must add tests for various data types, other than psF32. Copy code - from tst_psStats00.c-tst_psStats02.c. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#define N1 1029 // This should be an odd number. -#define N ((4 * N1) + 1) - -psS32 main() -{ - psStats *myStats = NULL; - psS32 testStatus = true; - psS32 globalTestStatus = true; - psS32 i = 0; - psVector *myVector = NULL; - psVector *maskVector= NULL; - float median = 1e99; - float realMedianWithMask = (float) (N-3)/4; - float realMedianNoMask = (float) (N-1)/2; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEDIAN); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - // Set the appropriate values for the vector data. - for (i=0;idata.F32[i] = (float) i; - } - - // Set the mask vector and calculate the expected median. - for (i=0;idata.U8[i] = 0; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_MEDIAN: no vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - median = myStats->sampleMedian; - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The expected median was %f. The calculated median was %f.\n", - realMedianNoMask, median); - if (median == realMedianNoMask) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - - printFooter(stdout, - "psStats functions", - "PS_STAT_SAMPLE_MEDIAN: no vector mask", - testStatus); - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_MEDIAN: with vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - median = myStats->sampleMedian; - printf("Called psVectorStats() on a vector with last N/2 elements masked.\n"); - printf("The expected median was %f. The calculated median was %f.\n", - realMedianWithMask, median); - if (median == realMedianWithMask) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - - printFooter(stdout, - "psStats functions", - "PS_STAT_SAMPLE_MEDIAN: with vector mask", - testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "psStats(): deallocating memory"); - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psStats functions", - "psStats(): deallocating memory", - testStatus); - - return (!globalTestStatus); -} Index: trunk/psLib/test/dataManip/tst_psStats04.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats04.c (revision 4528) +++ (revision ) @@ -1,85 +1,0 @@ -/***************************************************************************** - This routine must ensure that PS_STAT_NVALUES is correctly computed - by the procedure psVectorStats(). - - Note: The NVALUES stat was removed from the IfA requirements spec. So, - this test is no longer in use. - - XXX: Must add tests for various data types, other than psF32. Copy code - from tst_psStats00.c-tst_psStats02.c. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#define N1 1029 -#define N ((4 * N1) + 1) - -psS32 main() -{ - psStats *myStats = NULL; - psS32 testStatus = true; - psS32 i = 0; - psVector *myVector = NULL; - psVector *maskVector= NULL; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_NVALUES); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - // Set the appropriate values for the vector data. - for (i=0;idata.F32[i] = (float) i; - } - - // Set the mask vector and calculate the expected maximum. - for (i=0;idata.U8[i] = 0; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_NVALUES"); - - myStats = psVectorStats(myStats, myVector, NULL, 0); - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The expected nvalues was %d. The calculated nvalues was %d.\n", - N, myStats->nValues); - if (myStats->nValues == N) { - testStatus = true; - } else { - testStatus = false; - } - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - myStats = psVectorStats(myStats, myVector, maskVector, 1); - printf("Called psVectorStats() on a vector with last N/2 elements masked.\n"); - printf("The expected nvalues was %d. The calculated nvalues was %d.\n", - N/2, myStats->nValues); - if (myStats->nValues == N/2) { - testStatus = true; - } else { - testStatus = false; - } - - printFooter(stdout, - "psHash functions", - "psHashAlloc()", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psStats05.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats05.c (revision 4528) +++ (revision ) @@ -1,75 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psStats structure is correctly - allocated and deallocated by the procedure psArrayStats(). - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#define MISC_FLOAT_NUMBER 345.0 - -psS32 main() -{ - psStats *myStats = NULL; - psS32 testStatus = true; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Allocate the psStats structure."); - - myStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - myStats->sampleMean = MISC_FLOAT_NUMBER; - myStats->sampleMedian = MISC_FLOAT_NUMBER; - myStats->sampleStdev = MISC_FLOAT_NUMBER; - myStats->sampleUQ = MISC_FLOAT_NUMBER; - myStats->sampleLQ = MISC_FLOAT_NUMBER; - myStats->robustMean = MISC_FLOAT_NUMBER; - myStats->robustMedian = MISC_FLOAT_NUMBER; - myStats->robustMode = MISC_FLOAT_NUMBER; - myStats->robustStdev = MISC_FLOAT_NUMBER; - myStats->robustUQ = MISC_FLOAT_NUMBER; - myStats->robustLQ = MISC_FLOAT_NUMBER; - myStats->robustN50 = MISC_FLOAT_NUMBER; - myStats->robustNfit = MISC_FLOAT_NUMBER; - myStats->clippedMean = MISC_FLOAT_NUMBER; - myStats->clippedStdev = MISC_FLOAT_NUMBER; - myStats->clipSigma = MISC_FLOAT_NUMBER; - myStats->clipIter = MISC_FLOAT_NUMBER; - myStats->min = MISC_FLOAT_NUMBER; - myStats->max = MISC_FLOAT_NUMBER; - myStats->binsize = MISC_FLOAT_NUMBER; - myStats->options = 0x0; - - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Allocate the psStats structure.", - testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "Deallocate the psStats structure."); - psFree(myStats); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - psMemCheckCorruption(1); - - printFooter(stdout, - "psStats functions", - "Deallocate the psStats structure.", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/dataManip/tst_psStats06.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats06.c (revision 4528) +++ (revision ) @@ -1,131 +1,0 @@ -/***************************************************************************** - This routine must ensure that PS_STAT_SAMPLE_STDEV is correctly computed - by the procedure psArrayStats(). - - XXX: Must add tests for various data types, other than psF32. Copy code - from tst_psStats00.c-tst_psStats02.c. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psTest.h" -#include "float.h" -#include - -#define N 15 - -psS32 main() -{ - psStats *myStats = NULL; - psS32 testStatus = true; - psS32 globalTestStatus = true; - psS32 i = 0; - psVector *myVector = NULL; - psVector *maskVector= NULL; - float stdev = 0.0; - // NOTE: These values were calculated by running the function on the data. - // A: They must be changed if we adjust the number of data points. - // B: We don't really know that they are correct. - float realStdevNoMask = 4.472136; - float realStdevWithMask = 2.160247; - psS32 count = 0; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_STDEV); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - stdev = 0.0; - // Set the appropriate values for the vector data. - for (i=0;idata.F32[i] = (float) i; - } - - // Set the mask vector and calculate the expected maximum. - for (i=0;idata.U8[i] = 0; - count++; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_STDEV: no vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - stdev = myStats->sampleStdev; - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The expected stdev was %f; the calculated stdev was %f\n", - realStdevNoMask, stdev); - if (fabs(stdev - realStdevNoMask) <= 2.0 * FLT_EPSILON) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_SAMPLE_STDEV: no vector mask", - testStatus); - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_STDEV: with vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - stdev = myStats->sampleStdev; - printf("Called psVectorStats() on a vector with last N/2 elements masked.\n"); - printf("The expected stdev was %f; the calculated stdev was %f\n", - realStdevWithMask, stdev); - if (fabs(stdev - realStdevWithMask) <= 2.0 * FLT_EPSILON) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - - printFooter(stdout, - "psVector functions", - "PS_STAT_SAMPLE_STDEV: with vector mask", - testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "psStats(): deallocating memory"); - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus); - - return (!globalTestStatus); -} Index: trunk/psLib/test/dataManip/tst_psStats07.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats07.c (revision 4528) +++ (revision ) @@ -1,498 +1,0 @@ -/***************************************************************************** - This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed - by the procedure psArrayStats(). - - XXX: Must add tests for various data types, other than psF32. Copy code - from tst_psStats00.c-tst_psStats02.c. -*****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psTest.h" -#include "float.h" -#include - -#define N 90 -#define MEAN 32.0 -#define STDEV 2.0 -#define ERROR_TOLERANCE 0.15 - -psS32 t00() -{ - psStats * myStats = NULL; - psS32 testStatus = true; - psS32 globalTestStatus = true; - psS32 i = 0; - psVector *myVector = NULL; - psVector *maskVector = NULL; - // NOTE: These values were calculated by running the function on the data. - // They must be changed if we adjust the number of data points. - // We don't really know that they are correct. - psS32 count = 0; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - float realMeanNoMask = MEAN; - float realMedianNoMask = MEAN; - float realModeNoMask = MEAN; - float realStdevNoMask = STDEV * 0.20; - float realLQNoMask = MEAN - ( 0.6 * STDEV ); - float realUQNoMask = MEAN + ( 0.6 * STDEV ); - psS32 realN50NoMask = N / 4; - psS32 realNfitNoMask = N / 4; - - psTraceSetLevel(".psLib.dataManip", 0); - psTraceSetLevel(".psLib.dataManip.psMinimize", 0); - psTraceSetLevel(".psLib.dataManip.psMinimizeLMChi2Gauss1D", 0); - psTraceSetLevel(".psLib.dataManip.psFunctions.psGaussian", 0); - psTraceSetLevel(".psLib.dataManip.psFunctions", 0); - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN | - PS_STAT_ROBUST_MEDIAN | - PS_STAT_ROBUST_MODE | - PS_STAT_ROBUST_STDEV | - PS_STAT_ROBUST_QUARTILE ); - - maskVector = psVectorAlloc( N, PS_TYPE_U8 ); - maskVector->n = N; - myVector = p_psGaussianDev( MEAN, STDEV, N ); - // Set the mask vector and calculate the expected maximum. - for ( i = 0;i < N;i++ ) { - if ( i < ( N / 2 ) ) { - maskVector->data.U8[ i ] = 0; - count++; - } else { - maskVector->data.U8[ i ] = 1; - } - } - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust mean: no vector mask" ); - - myStats = psVectorStats( myStats, myVector, NULL, NULL, 0 ); - - printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n", - realMeanNoMask, myStats->robustMean ); - - if ( fabs( myStats->robustMean - realMeanNoMask ) < ( ERROR_TOLERANCE * realMeanNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust mean: no vector mask", - testStatus ); - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Median: no vector mask" ); - - printf( "The expected Median was %.2f; the calculated Median was %.2f\n", - realMedianNoMask, myStats->robustMedian ); - if ( fabs( myStats->robustMedian - realMedianNoMask ) < ( ERROR_TOLERANCE * realMedianNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Median: no vector mask", - testStatus ); - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Mode: no vector mask" ); - - - printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n", - realModeNoMask, myStats->robustMode ); - if ( fabs( myStats->robustMode - realModeNoMask ) < ( ERROR_TOLERANCE * realModeNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Mode: no vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask" ); - - printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n", - realStdevNoMask, myStats->robustStdev ); - if ( fabs( myStats->robustStdev - realStdevNoMask ) < ( ERROR_TOLERANCE * realStdevNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask" ); - - printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n", - realLQNoMask, myStats->robustLQ ); - - if ( fabs( myStats->robustLQ - realLQNoMask ) < ( ERROR_TOLERANCE * realLQNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: upper quartile: no vector mask" ); - - printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n", - realUQNoMask, myStats->robustUQ ); - if ( fabs( myStats->robustUQ - realUQNoMask ) < ( ERROR_TOLERANCE * realUQNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust N50: no vector mask" ); - - // XXX: - realN50NoMask = myStats->robustN50; - - printf( "The expected N50 was %d; the calculated N50 was %d\n", - realN50NoMask, myStats->robustN50 ); - /* XXX: fix - if ( fabs( myStats->robustN50 - realN50NoMask ) < ( ERROR_TOLERANCE * realN50NoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - */ - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust N50: no vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask" ); - - // XXX: - realNfitNoMask = myStats->robustNfit; - - printf( "The expected Nfit was %d; the calculated Nfit was %d\n", - realNfitNoMask, myStats->robustNfit ); - /* XXX: fix - if ( fabs( myStats->robustNfit - realNfitNoMask ) < ( ERROR_TOLERANCE * realNfitNoMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - */ - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask", - testStatus ); - return(testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "psStats(): deallocating memory" ); - - psFree( myStats ); - psFree( myVector ); - psFree( maskVector ); - - psMemCheckCorruption( 1 ); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if ( 0 != memLeaks ) { - psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); - } - - printFooter( stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus ); - - return ( !globalTestStatus ); -} - - -psS32 t01() -{ - psStats * myStats = NULL; - psS32 testStatus = true; - psS32 globalTestStatus = true; - psS32 i = 0; - psVector *myVector = NULL; - psVector *maskVector = NULL; - // NOTE: These values were calculated by running the function on the data. - // A: They must be changed if we adjust the number of data points. - // B: We don't really know that they are correct. - psS32 count = 0; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - float realMeanWithMask = MEAN; - float realMedianWithMask = MEAN; - float realModeWithMask = MEAN; - float realStdevWithMask = STDEV * 0.20; - float realLQWithMask = MEAN; - float realUQWithMask = MEAN; - psS32 realN50WithMask = N / 4; - psS32 realNfitWithMask = N / 4; - - psTraceSetLevel(".psLib.dataManip.psStats", 0); - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN | - PS_STAT_ROBUST_MEDIAN | - PS_STAT_ROBUST_MODE | - PS_STAT_ROBUST_STDEV | - PS_STAT_ROBUST_QUARTILE ); - - maskVector = psVectorAlloc( N, PS_TYPE_U8 ); - maskVector->n = N; - myVector = p_psGaussianDev( MEAN, STDEV, N ); - // Set the mask vector and calculate the expected maximum. - for ( i = 0;i < N;i++ ) { - if ( i < ( N / 2 ) ) { - maskVector->data.U8[ i ] = 0; - count++; - } else { - maskVector->data.U8[ i ] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust mean: with vector mask" ); - - printf( "Calling psVectorStats() on a vector with elements masked.\n" ); - myStats = psVectorStats( myStats, myVector, NULL, maskVector, 1 ); - printf( "Called psVectorStats() on a vector with elements masked.\n" ); - printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n", - realMeanWithMask, myStats->robustMean ); - if ( fabs( myStats->robustMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust mean: with vector mask", - testStatus ); - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Median: with vector mask" ); - - printf( "The expected Median was %.2f; the calculated Median was %.2f\n", - realMedianWithMask, myStats->robustMedian ); - if ( fabs( myStats->robustMedian - realMedianWithMask ) < ( ERROR_TOLERANCE * realMedianWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Median: with vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Mode: with vector mask" ); - - printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n", - realModeWithMask, myStats->robustMode ); - if ( fabs( myStats->robustMode - realModeWithMask ) < ( ERROR_TOLERANCE * realModeWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Mode: with vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask" ); - - printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n", - realStdevWithMask, myStats->robustStdev ); - if ( fabs( myStats->robustStdev - realStdevWithMask ) < ( ERROR_TOLERANCE * realStdevWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask" ); - - printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n", - realLQWithMask, myStats->robustLQ ); - if ( fabs( myStats->robustLQ - realLQWithMask ) < ( ERROR_TOLERANCE * realLQWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: upper quartile: with vector mask" ); - - printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n", - realUQWithMask, myStats->robustUQ ); - if ( fabs( myStats->robustUQ - realUQWithMask ) < ( ERROR_TOLERANCE * realUQWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust N50: with vector mask" ); - - printf( "The expected N50 was %d; the calculated N50 was %d\n", - realN50WithMask, myStats->robustN50 ); - /* XXX: fix - if ( fabs( myStats->robustN50 - realN50WithMask ) < ( ERROR_TOLERANCE * realN50WithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - */ - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust N50: with vector mask", - testStatus ); - - - - printPositiveTestHeader( stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask" ); - - printf( "The expected Nfit was %d; the calculated Nfit was %d\n", - realNfitWithMask, myStats->robustNfit ); - /* XXX: fix - if ( fabs( myStats->robustNfit - realNfitWithMask ) < ( ERROR_TOLERANCE * realNfitWithMask ) ) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - */ - printFooter( stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask", - testStatus ); - - - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader( stdout, - "psStats functions", - "psStats(): deallocating memory" ); - - psFree( myStats ); - psFree( myVector ); - psFree( maskVector ); - - psMemCheckCorruption( 1 ); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if ( 0 != memLeaks ) { - psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); - } - - printFooter( stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus ); - - return ( !globalTestStatus ); -} - -psS32 main() -{ - t00(); - t01(); -} Index: trunk/psLib/test/dataManip/tst_psStats08.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats08.c (revision 4528) +++ (revision ) @@ -1,175 +1,0 @@ -/***************************************************************************** - This routine must ensure that PS_STAT_SAMPLE_QUARTILE is correctly computed - by the procedure psArrayStats(). - - XXX: Must add tests for various data types, other than psF32. Copy code - from tst_psStats00.c-tst_psStats02.c. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psTest.h" -#include "float.h" -#include - -#define N1 25 // -#define N (8 * N1) // Don't change this (N must be a multiple of 8) - -psS32 main() -{ - psStats *myStats = NULL; - psS32 testStatus = true; - psS32 globalTestStatus = true; - psS32 i = 0; - psVector *myVector = NULL; - psVector *maskVector= NULL; - // NOTE: These values were calculated by running the function on the data. - // A: They must be changed if we adjust the number of data points. - // B: We don't really know that they are correct. - float realLQNoMask = N/4.0; - float realUQNoMask = 3.0 * (N/4.0); - float realLQWithMask = N/8.0; - float realUQWithMask = 3.0 * (N/8.0); - psS32 count = 0; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_SAMPLE_QUARTILE); - myVector = psVectorAlloc(N, PS_TYPE_F32); - myVector->n = N; - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - // Set the appropriate values for the vector data. - for (i=0;idata.F32[i] = (float) i; - } - - // Set the mask vector and calculate the expected maximum. - for (i=0;idata.U8[i] = 0; - count++; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_LQ: no vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The expected sampleLQ was %f; the calculated sampleLQ was %f\n", - realLQNoMask, myStats->sampleLQ); - if (fabs(realLQNoMask - myStats->sampleLQ) <= 2.0 * FLT_EPSILON) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_SAMPLE_LQ: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_UQ: no vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, NULL, 0); - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The expected sampleUQ was %f; the calculated sampleUQ was %f\n", - realUQNoMask, myStats->sampleUQ); - if (fabs(realUQNoMask - myStats->sampleUQ) <= 2.0 * FLT_EPSILON) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_SAMPLE_UQ: no vector mask", - testStatus); - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_LQ: with vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - - printf("Called psVectorStats() on a vector with elements masked.\n"); - printf("The expected sampleLQ was %f; the calculated sampleLQ was %f\n", - realLQWithMask, myStats->sampleLQ); - if (fabs(realLQWithMask - myStats->sampleLQ) <= 2.0 * FLT_EPSILON) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_SAMPLE_LQ: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_SAMPLE_UQ: with vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1); - - printf("Called psVectorStats() on a vector with elements masked.\n"); - printf("The expected sampleUQ was %f; the calculated sampleUQ was %f\n", - realUQWithMask, myStats->sampleUQ); - if (fabs(realUQWithMask - myStats->sampleUQ) <= 2.0 * FLT_EPSILON) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_SAMPLE_UQ: with vector mask", - testStatus); - - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "psStats(): deallocating memory"); - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus); - - return (!globalTestStatus); -} Index: trunk/psLib/test/dataManip/tst_psStats09.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats09.c (revision 4528) +++ (revision ) @@ -1,149 +1,0 @@ -/***************************************************************************** - This routine must ensure that PS_STAT_CLIPPED_MEAN and - PS_STAT_CLIPPED_STDEV is calculate correctly by the procedure - psVectorStats(). - - XXX: Must add tests for various data types, other than psF32. Copy code - from tst_psStats00.c-tst_psStats02.c. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psTest.h" -#include "psImageStats.h" -#include "float.h" -#include - -#define N 500 -#define MY_MEAN 30.0 -#define MY_RANGE 2.0 - -psS32 main() -{ - psStats *myStats = NULL; - psS32 testStatus = true; - psS32 globalTestStatus = true; - psS32 i = 0; - psVector *maskVector= NULL; - psVector *myGaussData = NULL; - // NOTE: These values were calculated by running the function on the data. - // A: They must be changed if we adjust the number of data points. - // B: We don't really know that they are correct. - // float realclippedMeanNoMask = 0.0; - // float realclippedStdevNoMask = 0.0; - // float realclippedMeanWithMask = 0.0; - // float realclippedStdevWithMask = 0.0; - psS32 count = 0; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - - /*************************************************************************/ - /* Allocate and initialize data structures */ - /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_CLIPPED_MEAN | - PS_STAT_CLIPPED_STDEV); - - myGaussData = psVectorAlloc(N, PS_TYPE_F32); - myGaussData->n = myGaussData->nalloc; - for (i=0;idata.F32[i] = MY_MEAN - (MY_RANGE/1.9) + - (MY_RANGE) * ((float) i) / ((float) N); - } - - maskVector = psVectorAlloc(N, PS_TYPE_U8); - maskVector->n = N; - - // Set the mask vector and calculate the expected maximum. - for (i=0;idata.U8[i] = 0; - count++; - } else { - maskVector->data.U8[i] = 1; - } - } - - /*************************************************************************/ - /* Call psVectorStats() with no vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_CLIPPED_MEAN: no vector mask"); - - myStats = psVectorStats(myStats, myGaussData, NULL, NULL, 0); - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The calculated clippedMean was %.2f\n", myStats->clippedMean); - - printFooter(stdout, - "psVector functions", - "PS_STAT_CLIPPED_MEAN/STDEV: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_CLIPPED_STDEV: no vector mask"); - - printf("Called psVectorStats() on a vector with no elements masked.\n"); - printf("The calculated clippedStdev was %.2f\n", myStats->clippedStdev); - - printFooter(stdout, - "psVector functions", - "PS_STAT_CLIPPED_MEAN/STDEV: no vector mask", - testStatus); - - /*************************************************************************/ - /* Call psVectorStats() with vector mask. */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_CLIPPED_MEAN: vector mask"); - - myStats = psVectorStats(myStats, myGaussData, NULL, maskVector, 1); - - printf("Called psVectorStats() on a vector with elements masked.\n"); - printf("The calculated clippedMean was %.2f\n", myStats->clippedMean); - printFooter(stdout, - "psVector functions", - "PS_STAT_CLIPPED_MEAN/STDEV: vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_CLIPPED_STDEV: vector mask"); - - printf("Called psVectorStats() on a vector with elements masked.\n"); - printf("The calculated clippedStdev was %.2f\n", myStats->clippedStdev); - printFooter(stdout, - "psVector functions", - "PS_STAT_CLIPPED_MEAN/STDEV: vector mask", - testStatus); - - /*************************************************************************/ - /* Deallocate data structures */ - /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "psStats(): deallocating memory"); - - psFree(myStats); - psFree(myGaussData); - psFree(maskVector); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus); - - return (!globalTestStatus); -} Index: trunk/psLib/test/dataManip/tst_psVectorFFT.c =================================================================== --- trunk/psLib/test/dataManip/tst_psVectorFFT.c (revision 4528) +++ (revision ) @@ -1,642 +1,0 @@ -/** @file tst_psVectorFFT.c -* -* @brief Contains the tests for psFFT.[ch] -* -* -* @author Robert DeSonia, MHPCC -* -* @version $Revision: 1.17 $ $Name: not supported by cvs2svn $ -* @date $Date: 2005-06-17 23:44:22 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -*/ - -#include -#include - -#include "psTest.h" -#include "pslib_strict.h" - -#define GENIMAGE(img,c,r,TYP, valueFcn) \ -img = psImageAlloc(c,r,PS_TYPE_##TYP); \ -for (psU32 row=0;rowdata.TYP[row]; \ - for (psU32 col=0;coln = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI ); - } - - // 2. perform a forward transform - vec2 = psVectorFFT( NULL, vec, PS_FFT_FORWARD ); - if ( vec2->type.type != PS_TYPE_C32 ) { - psError(PS_ERR_UNKNOWN,true, "FFT didn't produce complex values?" ); - return 1; - } - - // 2a. verify output vector is same size as input - if ( vec2->n != vec->n ) { - psError(PS_ERR_UNKNOWN,true, "FFT didn't return vector with same size as input"); - return 10; - } - - - // 3. verify that the only significant component cooresponds to the freqency of the input in step 1. - for ( psU32 n = 0; n < 100; n++ ) { - if ( n == 1 || n == 99 ) { - if ( fabsf( cabsf( vec2->data.C32[ n ] ) - 50.0f ) > 0.1f ) { - psError(PS_ERR_UNKNOWN,true, "FFT didn't work for vector (n=%d)", n ); - return 2; - } - } else { - if ( fabsf( cabsf( vec2->data.C32[ n ] ) ) > 0.1f ) { - psError(PS_ERR_UNKNOWN,true, "FFT didn't work for vector (n=%d)", n ); - return 3; - } - } - } - - // 4. perform a reverse transform - vec3 = psVectorFFT( NULL, vec2, PS_FFT_REVERSE ); - if ( vec3->type.type != PS_TYPE_C32 ) { - psError(PS_ERR_UNKNOWN,true, "FFT didn't produce complex values?" ); - return 4; - } - if ( vec3->n != vec2->n ) { - psError(PS_ERR_UNKNOWN,true, "FFT didn't return vector with same size as input"); - return 40; - } - for ( psU32 n = 0; n < 100; n++ ) { - psF32 val = sinf( ( psF32 ) n / 50.0f * M_PI ); - psF32 vecVal = crealf( vec3->data.C32[ n ] ) / 100; - if ( fabsf( vecVal - val ) > 0.1f ) { - psError(PS_ERR_UNKNOWN,true, "Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)", - n, vecVal, val ); - return 5; - } - } - - // Perform a reverse transform with real flag set - vec4 = psVectorFFT(NULL,vec2, (PS_FFT_REVERSE | PS_FFT_REAL_RESULT)); - if(vec4->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"FFT with real result did not produce real values"); - return 80; - } - - // Perform vector FFT with invalid direction flags - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - if ( psVectorFFT(NULL,vec2,(psFFTFlags)0) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with invalid direction"); - return 70; - } - - psFree( vec ); - psFree( vec2 ); - psFree( vec3 ); - psFree( vec4 ); - - // Perform vector FFT with null input - if ( psVectorFFT(NULL,NULL,PS_FFT_FORWARD) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector"); - return 64; - } - - return 0; -} - -psS32 testVectorRealImaginary( void ) -{ - psVector * vec = NULL; - psVector* vec2 = NULL; - psVector* vec3 = NULL; - psVector* vec4 = NULL; - psVector* vec5 = NULL; - psVector* vec6 = NULL; - psVector* vec7 = NULL; - psVector* vec8 = NULL; - psVector* vec9 = NULL; - psVector* vec10 = NULL; - psVector* vec11 = NULL; - - /* - 1. create a C32 complex vector with distinctly different real and imaginary parts. - 2. call psVectorReal and psVectorImaginary - 3. compare results to the real/imaginary components of input - */ - - // 1. create a C32 complex vector with distinctly different real and imaginary parts. - vec = psVectorAlloc( 100, PS_TYPE_C32 ); - vec8 = psVectorAlloc( 100, PS_TYPE_C64 ); - vec10 = psVectorAlloc( 100, PS_TYPE_C64 ); - vec->n = vec->nalloc; - vec8->n = vec8->nalloc; - vec10->n = vec10->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.C32[ n ] = n + I * ( n * 2 ); - vec8->data.C64[n] = n + I * ( n * 2 ); - vec10->data.C64[n] = n + I * ( n * 2 ); - } - vec4 = psVectorAlloc( 100, PS_TYPE_F32); - vec4->n = vec4->nalloc; - vec6 = psVectorAlloc( 100, PS_TYPE_F32); - vec6->n = vec6->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec4->data.F32[n] = n; - vec6->data.F32[n] = n; - } - - // 2. call psVectorReal and psVectorImaginary - vec2 = psVectorReal( vec2, vec ); - if ( vec2 == NULL ) { - psError(PS_ERR_UNKNOWN,true, "psVectorReal returned a NULL?" ); - return 1; - } - if ( vec2->type.type != PS_TYPE_F32 ) { - psError(PS_ERR_UNKNOWN,true, "psVectorReal returned a wrong type (%d)?", - vec2->type.type ); - return 2; - } - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning."); - vec5 = psVectorReal(vec5, vec4); - if (vec5 == NULL) { - psError(PS_ERR_UNKNOWN,true,"psVectorReal returned NULL"); - return 10; - } - if ( vec5->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"psVectorReal returned the wrong type"); - return 11; - } - - vec9 = psVectorReal(vec9,vec8); - if(vec9 == NULL) { - psError(PS_ERR_UNKNOWN,true,"psVectorReal returned NULL"); - return 20; - } - if(vec9->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"psVectorReal returned the wrong type"); - return 21; - } - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning."); - vec3 = psVectorImaginary( vec3, vec ); - if ( vec3 == NULL ) { - psError(PS_ERR_UNKNOWN,true, "psVectorImaginary returned a NULL?" ); - return 3; - } - if ( vec3->type.type != PS_TYPE_F32 ) { - psError(PS_ERR_UNKNOWN,true, "psVectorImaginary returned a wrong type (%d)?", - vec3->type.type ); - return 4; - } - - vec7 = psVectorImaginary(vec7, vec6); - if(vec7 == NULL) { - psError(PS_ERR_UNKNOWN,true,"psVectorImage returned NULL"); - return 12; - } - if(vec7->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned the wrong type"); - return 13; - } - - vec11 = psVectorImaginary(vec11, vec10); - if(vec11 == NULL) { - psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned NULL"); - return 14; - } - if(vec11->type.type != PS_TYPE_F64) { - psError(PS_ERR_UNKNOWN,true,"psVectorImaginary returned the wrong type"); - return 15; - } - - // 3. compare results to the real/imaginary components of input - for ( psU32 n = 0; n < 100; n++ ) { - psF32 r = n; - psF32 i = ( n * 2 ); - psF64 rr = n; - psF64 ii = ( n * 2 ); - if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorReal didn't return the real portion at n=%d", - n ); - return 5; - } - if ( fabsf( vec3->data.F32[ n ] - i ) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorImaginary didn't return the real portion at n=%d", - n ); - return 6; - } - if ( fabsf( vec5->data.F32[n] - r) > FLT_EPSILON) { - psError(PS_ERR_UNKNOWN,true,"psVectorReal didn't return the real portion at n=%d",n); - return 50; - } - if ( fabsf( vec7->data.F32[n] - 0) > FLT_EPSILON) { - psError(PS_ERR_UNKNOWN,true,"psVectorImaginary did not return the imaginary portion at n=%d",n); - return 51; - } - if ( fabsf(vec9->data.F64[n] - rr) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true,"psVectorReal did not return the real portion at n=%d",n); - return 52; - } - if ( fabsf(vec11->data.F64[n] - ii) > FLT_EPSILON) { - psError(PS_ERR_UNKNOWN,true,"psVectorImaginary did not return the imaginary portion at n=%d",n); - return 53; - } - } - - psFree( vec ); - psFree( vec2 ); - psFree( vec3 ); - psFree( vec4 ); - psFree( vec5 ); - psFree( vec6 ); - psFree( vec7 ); - psFree( vec8 ); - psFree( vec9 ); - psFree( vec10 ); - psFree( vec11 ); - - // Perform vector Real with null input - if ( psVectorReal(NULL,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector"); - return 63; - } - // Perform vector Imaginary with null input - if ( psVectorImaginary(NULL,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector"); - return 73; - } - - return 0; -} - -psS32 testVectorComplex( void ) -{ - psVector * vec = NULL; - psVector* vec2 = NULL; - psVector* vec3 = NULL; - psVector* vec4 = NULL; - psVector* vec5 = NULL; - psVector* vec6 = NULL; - - /* - 1. create two unique psF32 vectors of the same size - 2. call psVectorComplex - 3. verify that the result is a psC32 - 4. call psVectorReal and psVectorImaginary on step 2 results - 5. compare step 4 results to input. - - 6. create a psF32 and a psF64 vector of the same size - 7. call psVectorComplex - 8. verify that an appropriate error occurred. - - 9. create two psf32 vectors of different sizes - 10. call psVectorComplex - 11. verify thet an appropriate error occurred. - */ - - // 1. create two unique psF32 vectors of the same size - vec = psVectorAlloc( 100, PS_TYPE_F32 ); - vec2 = psVectorAlloc( 100, PS_TYPE_F32 ); - vec4 = psVectorAlloc( 100, PS_TYPE_F64 ); - vec5 = psVectorAlloc( 100, PS_TYPE_F64 ); - vec->n = vec->nalloc; - vec2->n = vec2->nalloc; - vec4->n = vec4->nalloc; - vec5->n = vec5->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.F32[ n ] = n; - vec2->data.F32[ n ] = ( n * 2 ); - vec4->data.F64[ n ] = n; - vec5->data.F64[ n ] = ( n * 2 ); - } - - // 2. call psVectorComplex - vec3 = psVectorComplex( vec3, vec, vec2 ); - - // 3. verify that the result is a psC32 - if ( vec3->type.type != PS_TYPE_C32 ) { - psError(PS_ERR_UNKNOWN,true, "Vector Type from psVectorComplex is not complex? (%d)", - vec3->type.type ); - return 1; - } - - // 4. call psVectorReal and psVectorImaginary on step 2 results (not needed, just use crealf/cimagf) - // 5. compare step 4 results to input. - for ( psU32 n = 0; n < 100; n++ ) { - if ( fabsf( crealf( vec3->data.C32[ n ] ) - n ) > FLT_EPSILON || - fabsf( cimagf( vec3->data.C32[ n ] ) - ( n * 2 ) ) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorComplex result is invalid (n=%d, %.2f+%.2fi)", - n, crealf( vec3->data.C32[ n ] ), cimagf( vec3->data.C32[ n ] ) ); - return 2; - }; - } - - - // 6. create a psF32 and a psF64 vector of the same size - vec2 = psVectorRecycle( vec2, 100, PS_TYPE_F64 ); - - // 7. call psVectorComplex - psLogMsg(__func__, PS_LOG_INFO, "Following should be an error (type mismatch)." ); - vec3 = psVectorComplex( vec3, vec, vec2 ); - // 8. verify that an appropriate error occurred. (this partially has to be done via inspection) - if ( vec3 != NULL ) { - psError(PS_ERR_UNKNOWN,true, "psVectorComplex returned a vector though input types mismatched." ); - return 3; - } - - // 9. create two psf32 vectors of different sizes - vec2 = psVectorRecycle( vec2, 200, PS_TYPE_F32 ); - - // 10. call psVectorComplex - vec3 = psVectorComplex( vec3, vec, vec2 ); - - // 11. verify thet an appropriate error occurred. (actually, it isn't an error...) - if ( vec3->n != 100 ) { - psError(PS_ERR_UNKNOWN,true, "psVectorComplex returned a larger vector than the input supported (%d).", vec3->n ); - return 4; - } - - // Verify the function works with psF64 type - vec6 = psVectorComplex(vec6, vec4, vec5); - if( vec6->type.type != PS_TYPE_C64 ) { - psError(PS_ERR_UNKNOWN,true,"Vector return type is not complex"); - return 40; - } - - // Verify error message generated with input of invalid type - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - vec4->type.type = PS_TYPE_S8; - vec5->type.type = PS_TYPE_S8; - vec6 = psVectorComplex(vec6, vec4, vec5); - if(vec6 != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type"); - return 50; - } - vec4->type.type = PS_TYPE_F64; - vec5->type.type = PS_TYPE_F64; - - psFree( vec ); - psFree( vec2 ); - psFree( vec3 ); - psFree( vec4 ); - psFree( vec5 ); - - // Perform vector complex with null input - if ( psVectorComplex(NULL,NULL,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector"); - return 62; - } - - return 0; -} - -psS32 testVectorConjugate( void ) -{ - psVector * vec = NULL; - psVector* vec2 = NULL; - - /* - 1. create a psC32 with unique real and imaginary values. - 2. call psVectorConjugate - 3. verify result is psC32 - 4. verify each value is conjugate of input (a+bi -> a-bi) - */ - - // 1. create a psC32 with unique real and imaginary values. - vec = psVectorAlloc( 100, PS_TYPE_C32 ); - vec->n = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.C32[ n ] = n + I * ( n * 2 ); - } - - // 2. call psVectorConjugate - vec2 = psVectorConjugate( vec2, vec ); - - // 3. verify result is psC32 - if ( vec2->type.type != PS_TYPE_C32 ) { - psError(PS_ERR_UNKNOWN,true, "the psVectorConjugate didn't return a C32 vector" ); - return 1; - } - - // 4. verify each value is conjugate of input (a+bi -> a-bi) - for ( psU32 n = 0; n < 100; n++ ) { - if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON || - fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorConjugate result is invalid (n=%d, %.2f+%.2fi)", - n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) ); - return 2; - }; - } - - psFree( vec ); - - // Perform conjugate for non-complex number - vec = psVectorAlloc( 100, PS_TYPE_F32 ); - vec->n = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.F32[ n ] = n; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message."); - vec2 = psVectorConjugate(vec2,vec); - if(vec2->type.type != PS_TYPE_F32) { - psError(PS_ERR_UNKNOWN,true,"psVectorConjugate did not return a F32 vector"); - return 10; - } - for ( psU32 n = 0; n < 100; n++ ) { - if( vec->data.F32[n] != vec2->data.F32[n] ) { - psError(PS_ERR_UNKNOWN,true,"psVectorConjugate result is invalid (n=%d)",n); - return 11; - } - } - psFree(vec); - - // Perform vector conjugate with C64 type - vec = psVectorAlloc( 100, PS_TYPE_C64 ); - vec->n = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.C64[n] = n + I * ( n * 2 ); - } - vec2 = psVectorConjugate(vec2,vec); - if(vec2->type.type != PS_TYPE_C64) { - psError(PS_ERR_UNKNOWN,true,"psVectorConjugate did not return a C64 vector"); - return 12; - } - for ( psU32 n = 0; n < 100; n++ ) { - if ( fabsf( crealf(vec->data.C64[n]) - crealf(vec2->data.C64[n])) > FLT_EPSILON || - fabsf( cimagf(vec->data.C64[n]) + cimagf(vec2->data.C64[n])) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true,"psVectorConjugate result is invalid (n=%d)",n); - return 13; - } - } - psFree(vec); - - // Perform vector conjugate with null input (vec2 should be freed too) - if ( psVectorConjugate(vec2,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector"); - return 61; - } - - return 0; -} - -psS32 testVectorPowerSpectrum( void ) -{ - psVector * vec = NULL; - psVector* vec2 = NULL; - psVector* vec3 = NULL; - psVector* vec4 = NULL; - - psF32 val; - psF64 val1; - - /* - 1. create a psC32 vector with unique real and imaginary components - 2. call psVectorPowerSpectrum - 3. verify result is psF32 - 4. verify the values are the square of the absolute values of the original - */ - - // 1. create a psC32 vector with unique real and imaginary components - vec = psVectorAlloc( 100, PS_TYPE_C32 ); - vec->n = vec->nalloc; - vec3 = psVectorAlloc(100,PS_TYPE_C64); - vec3->n = vec3->nalloc; - for ( psU32 n = 0; n < 100; n++ ) { - vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI ); - vec3->data.C64[ n ] = n + I * sinf( ( ( psF64 ) n ) / 50.f * M_PI ); - } - - // 2. call psVectorPowerSpectrum - vec2 = psVectorPowerSpectrum( vec2, vec ); - vec4 = psVectorPowerSpectrum( vec4, vec3 ); - - // 3. verify result is psF32 - if ( vec2->type.type != PS_TYPE_F32 ) { - psError(PS_ERR_UNKNOWN,true, "the type was not PS_TYPE_F32." ); - return 1; - } - if ( vec4->type.type != PS_TYPE_F64 ) { - psError(PS_ERR_UNKNOWN,true,"psPowerSpectrum did not return type PS_TYPE_F64 type = %d",vec4->type.type); - return 20; - } - - // 3a. verify result is the same size a input - // Awaiting IfA direction on bug #228 - // if ( vec2->n != vec->n ) { - // psError(PS_ERR_UNKNOWN,true, "Output vector size different(%d) than input vector(%d)",vec2->n, vec->n); - // return 10; - // } - - // 4. verify the values are the square of the absolute values of the original - // (ADD specifies something else) - // P_0 = |C_0|^2/N^2 - // P_j = (|C_j|^2+|C_N-j|^2)/N^2 - // P_N/2 = |C_N/2|^2/N^2 - // where j = 1,2,...,(N/2-1) - - val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100; - val1= cabsf( vec3->data.C64[0] ) * cabsf(vec3->data.C64[0])/100/100; - if ( fabsf( vec2->data.F32[ 0 ] - val ) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=0, %.2f %.2f)", - vec2->data.F32[ 0 ], val ); - return 2; - } - if ( fabsf( vec4->data.C64[0] - val1 ) > FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum result is invalid (n=0)"); - return 21; - } - - for ( psU32 n = 1; n < 50; n++ ) { - val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) + - cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100; - val1 = (cabsf(vec3->data.C64[n]) * cabsf(vec3->data.C64[n]) + - cabsf(vec3->data.C64[100-n]) * cabsf(vec3->data.C64[100-n]))/100/100; - if ( fabsf( val - vec2->data.F32[ n ] ) > 10*FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)", - n, vec2->data.F32[ n ], val ); - return 2; - } - if (fabsf(val1 - vec4->data.F64[n]) > 10*FLT_EPSILON) { - psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum result is invalid (n=%d, %.2f %.2f)",n,vec4->data.F64[n],val1); - return 22; - } - } - - val = cabsf( vec->data.C32[ 50 ] ) * cabsf( vec->data.C32[ 50 ] ) / 100 / 100; - if ( fabsf( vec2->data.F32[ 50 ] - val ) > 10*FLT_EPSILON ) { - psError(PS_ERR_UNKNOWN,true, "psVectorPowerSpectrum result is invalid (n=50, %.2f %.2f)", - vec2->data.F32[ 0 ], val ); - return 2; - }; - - psFree( vec ); - psFree( vec2 ); - psFree( vec3 ); - psFree( vec4 ); - - // Perform vector power spectrum with non-complex number - vec = psVectorAlloc(100,PS_TYPE_F32); - vec->n = vec->nalloc; - for( psU32 n=0; n<100; n++) { - vec->data.F32[n] = n; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - if(psVectorPowerSpectrum(NULL,vec) != NULL) { - psError(PS_ERR_UNKNOWN,true,"psVectorPowerSpectrum did not return a null vector."); - return 10; - } - - // Perform vector power spectrum with null input - if ( psVectorPowerSpectrum(NULL,NULL) != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return NULL with null input vector"); - return 60; - } - - psFree(vec); - - return 0; -} Index: trunk/psLib/test/dataManip/verified/tst_psFunc00.stderr =================================================================== --- trunk/psLib/test/dataManip/verified/tst_psFunc00.stderr (revision 4528) +++ (revision ) @@ -1,72 +1,0 @@ -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psPolynomial1DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psPolynomial1DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psPolynomial2DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psPolynomial2DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psPolynomial3DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psPolynomial3DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psPolynomial4DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psPolynomial4DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psDPolynomial1DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial1DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psDPolynomial2DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial2DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psDPolynomial3DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial3DAlloc} | tst_psFunc00.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc00.c * -* TestPoint: psPolynomialXD{psDPolynomial4DAlloc} * -* TestType: Positive * -\**********************************************************************************/ - - ----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial4DAlloc} | tst_psFunc00.c) - Index: trunk/psLib/test/dataManip/verified/tst_psFunc01.stdout =================================================================== --- trunk/psLib/test/dataManip/verified/tst_psFunc01.stdout (revision 4528) +++ (revision ) @@ -1,108 +1,0 @@ -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc01.c * -* TestPoint: psFunctions functions{psGaussian()} * -* TestType: Positive * -\**********************************************************************************/ - -normal psGaussian(0.000000) is 0.000000 -normal psGaussian(2.000000) is 0.000000 -normal psGaussian(4.000000) is 0.000000 -normal psGaussian(6.000000) is 0.000000 -normal psGaussian(8.000000) is 0.000000 -normal psGaussian(10.000000) is 0.000000 -normal psGaussian(12.000000) is 0.000000 -normal psGaussian(14.000000) is 0.000000 -normal psGaussian(16.000000) is 0.000000 -normal psGaussian(18.000000) is 0.000000 -normal psGaussian(20.000000) is 0.000001 -normal psGaussian(22.000000) is 0.000067 -normal psGaussian(24.000000) is 0.002216 -normal psGaussian(26.000000) is 0.026995 -normal psGaussian(28.000000) is 0.120985 -normal psGaussian(30.000000) is 0.199471 -normal psGaussian(32.000000) is 0.120985 -normal psGaussian(34.000000) is 0.026995 -normal psGaussian(36.000000) is 0.002216 -normal psGaussian(38.000000) is 0.000067 -normal psGaussian(40.000000) is 0.000001 -normal psGaussian(42.000000) is 0.000000 -normal psGaussian(44.000000) is 0.000000 -normal psGaussian(46.000000) is 0.000000 -normal psGaussian(48.000000) is 0.000000 -normal psGaussian(50.000000) is 0.000000 -normal psGaussian(52.000000) is 0.000000 -normal psGaussian(54.000000) is 0.000000 -normal psGaussian(56.000000) is 0.000000 -normal psGaussian(58.000000) is 0.000000 -NON-normal psGaussian(0.000000) is 0.000000 -NON-normal psGaussian(2.000000) is 0.000000 -NON-normal psGaussian(4.000000) is 0.000000 -NON-normal psGaussian(6.000000) is 0.000000 -NON-normal psGaussian(8.000000) is 0.000000 -NON-normal psGaussian(10.000000) is 0.000000 -NON-normal psGaussian(12.000000) is 0.000000 -NON-normal psGaussian(14.000000) is 0.000000 -NON-normal psGaussian(16.000000) is 0.000000 -NON-normal psGaussian(18.000000) is 0.000000 -NON-normal psGaussian(20.000000) is 0.000004 -NON-normal psGaussian(22.000000) is 0.000335 -NON-normal psGaussian(24.000000) is 0.011109 -NON-normal psGaussian(26.000000) is 0.135335 -NON-normal psGaussian(28.000000) is 0.606531 -NON-normal psGaussian(30.000000) is 1.000000 -NON-normal psGaussian(32.000000) is 0.606531 -NON-normal psGaussian(34.000000) is 0.135335 -NON-normal psGaussian(36.000000) is 0.011109 -NON-normal psGaussian(38.000000) is 0.000335 -NON-normal psGaussian(40.000000) is 0.000004 -NON-normal psGaussian(42.000000) is 0.000000 -NON-normal psGaussian(44.000000) is 0.000000 -NON-normal psGaussian(46.000000) is 0.000000 -NON-normal psGaussian(48.000000) is 0.000000 -NON-normal psGaussian(50.000000) is 0.000000 -NON-normal psGaussian(52.000000) is 0.000000 -NON-normal psGaussian(54.000000) is 0.000000 -NON-normal psGaussian(56.000000) is 0.000000 -NON-normal psGaussian(58.000000) is 0.000000 - ----> TESTPOINT PASSED (psFunctions functions{psGaussian()} | tst_psFunc01.c) - -/***************************** TESTPOINT ******************************************\ -* TestFile: tst_psFunc01.c * -* TestPoint: psFunctions functions{p_psGaussianDev()} * -* TestType: Positive * -\**********************************************************************************/ - -Gaussian Deviate [0] is 30.267838 -Gaussian Deviate [1] is 29.823797 -Gaussian Deviate [2] is 33.348816 -Gaussian Deviate [3] is 31.467281 -Gaussian Deviate [4] is 31.995049 -Gaussian Deviate [5] is 27.444996 -Gaussian Deviate [6] is 25.206570 -Gaussian Deviate [7] is 28.641439 -Gaussian Deviate [8] is 29.921818 -Gaussian Deviate [9] is 31.787111 -Gaussian Deviate [10] is 29.964705 -Gaussian Deviate [11] is 27.406887 -Gaussian Deviate [12] is 28.664040 -Gaussian Deviate [13] is 30.363417 -Gaussian Deviate [14] is 31.662102 -Gaussian Deviate [15] is 28.903503 -Gaussian Deviate [16] is 28.723936 -Gaussian Deviate [17] is 30.014177 -Gaussian Deviate [18] is 28.660292 -Gaussian Deviate [19] is 28.344475 -Gaussian Deviate [20] is 31.225000 -Gaussian Deviate [21] is 29.264824 -Gaussian Deviate [22] is 29.421013 -Gaussian Deviate [23] is 28.166250 -Gaussian Deviate [24] is 28.832390 -Gaussian Deviate [25] is 30.129230 -Gaussian Deviate [26] is 30.093487 -Gaussian Deviate [27] is 28.498547 -Gaussian Deviate [28] is 29.711535 -Gaussian Deviate [29] is 32.951122 - ----> TESTPOINT PASSED (psFunctions functions{p_psGaussianDev()} | tst_psFunc01.c) - Index: trunk/psLib/test/dataManip/verified/tst_psFunc02.stderr =================================================================== --- trunk/psLib/test/dataManip/verified/tst_psFunc02.stderr (revision 4528) +++ (revision ) @@ -1,16 +1,0 @@ -