Index: /trunk/psLib/test/dataManip/Makefile =================================================================== --- /trunk/psLib/test/dataManip/Makefile (revision 1133) +++ /trunk/psLib/test/dataManip/Makefile (revision 1134) @@ -3,6 +3,6 @@ ## Makefile: test/sysUtils ## -## $Revision: 1.21 $ $Name: not supported by cvs2svn $ -## $Date: 2004-06-26 03:04:44 $ +## $Revision: 1.22 $ $Name: not supported by cvs2svn $ +## $Date: 2004-06-30 00:18:49 $ ## ## Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -27,4 +27,6 @@ tst_psMatrix06 \ tst_psMatrix07 \ + tst_psMatrixVectorArithmetic01 \ + tst_psMatrixVectorArithmetic02 \ tst_psStats00 \ tst_psStats01 \ @@ -78,5 +80,5 @@ cleandependencies: $(RM) $(DEPENDENCIES) - + builddir/%.d: %.c $(CC) -MM $(CFLAGS) -I$(PSLIB_INCL_DIR) $< | sed 's|\(.*\.o\)|builddir/\1|' > $@ Index: /trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c (revision 1134) +++ /trunk/psLib/test/dataManip/tst_psMatrixVectorArithmetic02.c (revision 1134) @@ -0,0 +1,272 @@ + +/** @file tst_psMatrix_02.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.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-06-30 00:18:49 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include "pslib.h" +#include "psTest.h" + +#include + + +#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", (int)SCALAR->data.TYPE); \ +} else { \ + printf("%f", (double)SCALAR->data.TYPE); \ +} \ +printf("\n\n"); + + +#define PRINT_VECTOR(VECTOR,TYPE) \ +for(int i=0; in; i++) { \ + if(PS_IS_PSELEMTYPE_COMPLEX(VECTOR->type.type)) { \ + printf("%f+%fi\n", creal(VECTOR->data.TYPE[i]), cimag(VECTOR->data.TYPE[i])); \ + } else if(PS_IS_PSELEMTYPE_INT(VECTOR->type.type)) { \ + printf("%d\n", (int)VECTOR->data.TYPE[i]); \ + } else { \ + printf("%f\n", (double)VECTOR->data.TYPE[i]); \ + } \ +} \ +printf("\n"); + + +#define PRINT_MATRIX(IMAGE,TYPE) \ +for(int i=IMAGE->numRows-1; i>-1; i--) { \ + for(int 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 ", (int)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(int 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(int i=0; inumRows; i++) { \ + for(int j=0; jnumCols; j++) { \ + NAME->data.TYPE[i][j] = VALUE; \ + } \ +} + + +#define CHECK_MEMORY \ +psMemCheckLeaks(0, NULL, stdout); \ +int nBad = psMemCheckCorruption(0); \ +if(nBad) { \ + printf("ERROR: Found %d bad memory blocks\n", nBad); \ +} + + +int main(int argc, char* argv[]) +{ + + // Test matrix unary operations + #define testBinaryOpM(OP,TYPE,VALUE1,VALUE2,NROWS,NCOLS) \ + { \ + 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); \ + printf("Input:\n"); \ + PRINT_MATRIX(inImage,TYPE); \ + PRINT_MATRIX(outImage,TYPE); \ + outImage = (psImage*)psUnaryOp(outImage, inImage, #OP); \ + printf("Output:\n"); \ + PRINT_MATRIX(outImage,TYPE); \ + psFree(inImage); \ + psFree(outImage); \ + CHECK_MEMORY; \ + printFooter(stdout, "psMatrixVectorArithmetic", "Test matrix psUnaryOp", true); \ + } + + testBinaryOpM(abs,S32,-10,0,3,2); + testBinaryOpM(abs,F32,-10.0,0.0,3,2); + testBinaryOpM(abs,F64,-10.0,0.0,3,2); + testBinaryOpM(abs,C32,-10.0-10.0i,0.0+0.0i,3,2); + testBinaryOpM(exp,S32,10,0,3,2); + testBinaryOpM(exp,F32,10.0,0.0,3,2); + testBinaryOpM(exp,F64,10.0,0.0,3,2); + testBinaryOpM(exp,C32,10.0+10.0i,0.0+0.0i,3,2); + testBinaryOpM(ln,S32,10,0,3,2); + testBinaryOpM(ln,F32,10.0,0.0,3,2); + testBinaryOpM(ln,F64,10.0,0.0,3,2); + testBinaryOpM(ln,C32,10.0+10.0i,0.0+0.0i,3,2); + testBinaryOpM(ten,S32,3,0,3,2); + testBinaryOpM(ten,F32,3.0,0.0,3,2); + testBinaryOpM(ten,F64,3.0,0.0,3,2); + testBinaryOpM(ten,C32,3.0+3.0i,0.0+0.0i,3,2); + testBinaryOpM(log,S32,1000,0,3,2); + testBinaryOpM(log,F32,1000.0,0.0,3,2); + testBinaryOpM(log,F64,1000.0,0.0,3,2); + testBinaryOpM(log,C32,1000.0+1000.0i,0.0+0.0i,3,2); + testBinaryOpM(sin,S32,M_PI_2,0,3,2); + testBinaryOpM(sin,F32,M_PI_2,0.0,3,2); + testBinaryOpM(sin,F64,M_PI_2,0.0,3,2); + testBinaryOpM(sin,C32,M_PI_2+1.57079632679489661923i,0.0+0.0i,3,2); + testBinaryOpM(dsin,S32,90,0,3,2); + testBinaryOpM(dsin,F32,90.0,0.0,3,2); + testBinaryOpM(dsin,F64,90.0,0.0,3,2); + testBinaryOpM(dsin,C32,90.0+90.0i,0.0+0.0i,3,2); + testBinaryOpM(cos,S32,0,0,3,2); + testBinaryOpM(cos,F32,0.0,0.0,3,2); + testBinaryOpM(cos,F64,0.0,0.0,3,2); + testBinaryOpM(cos,C32,0.0+0.0i,0.0+0.0i,3,2); + testBinaryOpM(dcos,S32,0,0,3,2); + testBinaryOpM(dcos,F32,0.0,0.0,3,2); + testBinaryOpM(dcos,F64,0.0,0.0,3,2); + testBinaryOpM(dcos,C32,0.0+0.0i,0.0+0.0i,3,2); + testBinaryOpM(tan,S32,M_PI_4,0,3,2); + testBinaryOpM(tan,F32,M_PI_4,0.0,3,2); + testBinaryOpM(tan,F64,M_PI_4,0.0,3,2); + testBinaryOpM(tan,C32,M_PI_4+0.78539816339744830962i,0.0+0.0i,3,2); + testBinaryOpM(dtan,S32,45,0,3,2); + testBinaryOpM(dtan,F32,45.0,0.0,3,2); + testBinaryOpM(dtan,F64,45.0,0.0,3,2); + testBinaryOpM(dtan,C32,45.0+45.0i,0.0+0.0i,3,2); + testBinaryOpM(asin,S32,1,0,3,2); + testBinaryOpM(asin,F32,1.0,0.0,3,2); + testBinaryOpM(asin,F64,1.0,0.0,3,2); + testBinaryOpM(asin,C32,1.0+1.0i,0.0+0.0i,3,2); + testBinaryOpM(dasin,S32,1.0,0,3,2); + testBinaryOpM(dasin,F32,1.0,0.0,3,2); + testBinaryOpM(dasin,F64,1.0,0.0,3,2); + testBinaryOpM(dasin,C32,1.0+1.0i,0.0+0.0i,3,2); + testBinaryOpM(acos,S32,0,0,3,2); + testBinaryOpM(acos,F32,0.0,0.0,3,2); + testBinaryOpM(acos,F64,0.0,0.0,3,2); + testBinaryOpM(acos,C32,0.0+0.0i,0.0+0.0i,3,2); + testBinaryOpM(dacos,S32,0,0,3,2); + testBinaryOpM(dacos,F32,0.0,0.0,3,2); + testBinaryOpM(dacos,F64,0.0,0.0,3,2); + testBinaryOpM(dacos,C32,0.0+0.0i,0.0+0.0i,3,2); + testBinaryOpM(atan,S32,1,0,3,2); + testBinaryOpM(atan,F32,1.0,0.0,3,2); + testBinaryOpM(atan,F64,1.0,0.0,3,2); + testBinaryOpM(atan,C32,1.0+1.0i,0.0+0.0i,3,2); + testBinaryOpM(datan,S32,1,0,3,2); + testBinaryOpM(datan,F32,1.0,0.0,3,2); + testBinaryOpM(datan,F64,1.0,0.0,3,2); + testBinaryOpM(datan,C32,1.0+1.0i,0.0+0.0i,3,2); + + + // Test vector unary operations + #define testBinaryOpV(OP,TYPE,VALUE1,VALUE2,SIZE) \ + { \ + 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); \ + printf("Input:\n"); \ + PRINT_VECTOR(inVector,TYPE); \ + PRINT_VECTOR(outVector,TYPE); \ + outVector = (psVector*)psUnaryOp(outVector, inVector, #OP); \ + printf("Output:\n"); \ + PRINT_VECTOR(outVector,TYPE); \ + psFree(inVector); \ + psFree(outVector); \ + CHECK_MEMORY; \ + printFooter(stdout, "psMatrixVectorArithmetic", "Test vector psUnaryOp", true); \ + } + + testBinaryOpV(abs,S32,-10,0,3); + testBinaryOpV(abs,F32,-10.0,0.0,3); + testBinaryOpV(abs,F64,-10.0,0.0,3); + testBinaryOpV(abs,C32,-10.0-10.0i,0.0+0.0i,3); + testBinaryOpV(exp,S32,10,0,3); + testBinaryOpV(exp,F32,10.0,0.0,3); + testBinaryOpV(exp,F64,10.0,0.0,3); + testBinaryOpV(exp,C32,10.0+10.0i,0.0+0.0i,3); + testBinaryOpV(ln,S32,10,0,3); + testBinaryOpV(ln,F32,10.0,0.0,3); + testBinaryOpV(ln,F64,10.0,0.0,3); + testBinaryOpV(ln,C32,10.0+10.0i,0.0+0.0i,3); + testBinaryOpV(ten,S32,3,0,3); + testBinaryOpV(ten,F32,3.0,0.0,3); + testBinaryOpV(ten,F64,3.0,0.0,3); + testBinaryOpV(ten,C32,3.0+3.0i,0.0+0.0i,3); + testBinaryOpV(log,S32,1000,0,3); + testBinaryOpV(log,F32,1000.0,0.0,3); + testBinaryOpV(log,F64,1000.0,0.0,3); + testBinaryOpV(log,C32,1000.0+1000.0i,0.0+0.0i,3); + testBinaryOpV(sin,S32,M_PI_2,0,3); + testBinaryOpV(sin,F32,M_PI_2,0.0,3); + testBinaryOpV(sin,F64,M_PI_2,0.0,3); + testBinaryOpV(sin,C32,M_PI_2+1.57079632679489661923i,0.0+0.0i,3); + testBinaryOpV(dsin,S32,90,0,3); + testBinaryOpV(dsin,F32,90.0,0.0,3); + testBinaryOpV(dsin,F64,90.0,0.0,3); + testBinaryOpV(dsin,C32,90.0+90.0i,0.0+0.0i,3); + testBinaryOpV(cos,S32,0,0,3); + testBinaryOpV(cos,F32,0.0,0.0,3); + testBinaryOpV(cos,F64,0.0,0.0,3); + testBinaryOpV(cos,C32,0.0+0.0i,0.0+0.0i,3); + testBinaryOpV(dcos,S32,0,0,3); + testBinaryOpV(dcos,F32,0.0,0.0,3); + testBinaryOpV(dcos,F64,0.0,0.0,3); + testBinaryOpV(dcos,C32,0.0+0.0i,0.0+0.0i,3); + testBinaryOpV(tan,S32,M_PI_4,0,3); + testBinaryOpV(tan,F32,M_PI_4,0.0,3); + testBinaryOpV(tan,F64,M_PI_4,0.0,3); + testBinaryOpV(tan,C32,M_PI_4+0.78539816339744830962i,0.0+0.0i,3); + testBinaryOpV(dtan,S32,45,0,3); + testBinaryOpV(dtan,F32,45.0,0.0,3); + testBinaryOpV(dtan,F64,45.0,0.0,3); + testBinaryOpV(dtan,C32,45.0+45.0i,0.0+0.0i,3); + testBinaryOpV(asin,S32,1,0,3); + testBinaryOpV(asin,F32,1.0,0.0,3); + testBinaryOpV(asin,F64,1.0,0.0,3); + testBinaryOpV(asin,C32,1.0+1.0i,0.0+0.0i,3); + testBinaryOpV(dasin,S32,1.0,0,3); + testBinaryOpV(dasin,F32,1.0,0.0,3); + testBinaryOpV(dasin,F64,1.0,0.0,3); + testBinaryOpV(dasin,C32,1.0+1.0i,0.0+0.0i,3); + testBinaryOpV(acos,S32,0,0,3); + testBinaryOpV(acos,F32,0.0,0.0,3); + testBinaryOpV(acos,F64,0.0,0.0,3); + testBinaryOpV(acos,C32,0.0+0.0i,0.0+0.0i,3); + testBinaryOpV(dacos,S32,0,0,3); + testBinaryOpV(dacos,F32,0.0,0.0,3); + testBinaryOpV(dacos,F64,0.0,0.0,3); + testBinaryOpV(dacos,C32,0.0+0.0i,0.0+0.0i,3); + testBinaryOpV(atan,S32,1,0,3); + testBinaryOpV(atan,F32,1.0,0.0,3); + testBinaryOpV(atan,F64,1.0,0.0,3); + testBinaryOpV(atan,C32,1.0+1.0i,0.0+0.0i,3); + testBinaryOpV(datan,S32,1,0,3); + testBinaryOpV(datan,F32,1.0,0.0,3); + testBinaryOpV(datan,F64,1.0,0.0,3); + testBinaryOpV(datan,C32,1.0+1.0i,0.0+0.0i,3); + + return 0; +} +