Changeset 12431

Timestamp:

Mar 13, 2007, 2:39:51 PM (19 years ago)

Author:

Paul Price

Message:

Removing complex number support. No-one was using it, and it prevents compilation on Solaris.

Location:

trunk/psLib

Files:

• src/db/psDB.c (modified) (6 diffs)
• src/fits/psFits.c (modified) (2 diffs)
• src/fits/psFitsTable.c (modified) (2 diffs)
• src/imageops/psImageGeomManip.c (modified) (15 diffs)
• src/imageops/psImageGeomManip.h (modified) (9 diffs)
• src/imageops/psImageMaskOps.c (modified) (2 diffs)
• src/imageops/psImagePixelExtract.c (modified) (5 diffs)
• src/imageops/psImagePixelManip.c (modified) (7 diffs)
• src/imageops/psImagePixelManip.h (modified) (4 diffs)
• src/imageops/psImageStats.c (modified) (2 diffs)
• src/imageops/psImageStructManip.c (modified) (3 diffs)
• src/imageops/psImageStructManip.h (modified) (2 diffs)
• src/math/psBinaryOp.c (modified) (3 diffs)
• src/math/psUnaryOp.c (modified) (5 diffs)
• src/mathtypes/psImage.c (modified) (21 diffs)
• src/mathtypes/psImage.h (modified) (9 diffs)
• src/mathtypes/psScalar.c (modified) (4 diffs)
• src/mathtypes/psScalar.h (modified) (5 diffs)
• src/mathtypes/psVector.c (modified) (12 diffs)
• src/mathtypes/psVector.h (modified) (5 diffs)
• src/sys/psType.h (modified) (9 diffs)
• test/imageops/tap_psImageGeomManip.c (modified) (2 diffs)
• test/imageops/tap_psImageInterpolate.c (modified) (2 diffs)
• test/imageops/tap_psImagePixelManip.c (modified) (7 diffs)
• test/math/tap_psMatrix02.c (modified) (3 diffs)
• test/math/tap_psMatrixVectorArithmetic01.c (modified) (10 diffs)
• test/math/tap_psMatrixVectorArithmetic02.c (modified) (35 diffs)
• test/math/tap_psMatrixVectorArithmetic03.c (modified) (4 diffs)
• test/mathtypes/tap_psImage.c (modified) (3 diffs)
• test/mathtypes/tap_psScalar.c (modified) (3 diffs)
• test/mathtypes/tap_psVector.c (modified) (3 diffs)
• test/sys/tap_psMemory.c (modified) (2 diffs)
• test/types/tap_psMetadataConfigFormat.c (modified) (1 diff)
• test/types/tap_psMetadata_printing.c (modified) (2 diffs)

trunk/psLib/src/db/psDB.c

@@ -12 +12 @@
  *  @author Joshua Hoblitt
  *
- *  @version $Revision: 1.139 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-10 01:24:40 $
+ *  @version $Revision: 1.140 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright (C) 2005-2006  Joshua Hoblitt, University of Hawaii
@@ -504 +504 @@
     case PS_DATA_F64:
         PS_STR_ARRAY_TO_PTYPE(column->data.F64, stringColumn, atof, psF64, PS_DATA_F64);
-        break;
-    case PS_TYPE_C32:
-        // this is a bogus SQL type
-        PS_STR_ARRAY_TO_PTYPE(column->data.C32, stringColumn, atof, psC32, PS_TYPE_C32);
-        break;
-    case PS_TYPE_C64:
-        // this is a bogus SQL type
-        PS_STR_ARRAY_TO_PTYPE(column->data.C64, stringColumn, atof, psC64, PS_TYPE_C64);
         break;
     case PS_DATA_BOOL:
@@ -2189 +2181 @@
         psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_F32, "FLOAT");
         psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_F64, "DOUBLE");
-        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
-        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
         // XXX Since BOOL is added after S8 all "TINYINT" data will appear in
         // the database as boolean data.  There does not seem to be any way to
@@ -2336 +2326 @@
         psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_F32,    psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT,      false));
         psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_F64,    psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE,     false));
-        // bogus type
-        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C32,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        // bogus type
-        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C64,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
         psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_BOOL,   psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
         // XXX: removed PS_DATA_PTR, can this be removed too?
@@ -2468 +2454 @@
         PS_NAN_ALLOC(myNaN, psF64, NAN);
         break;
-    case PS_TYPE_C32:
-        // this is a bogus SQL type
-        PS_NAN_ALLOC(myNaN, psC32, NAN);
-        break;
-    case PS_TYPE_C64:
-        // this is a bogus SQL type
-        PS_NAN_ALLOC(myNaN, psC64, NAN);
-        break;
     case PS_DATA_BOOL:
         // XXX: what is NaN for a bool?
@@ -2522 +2500 @@
     case PS_DATA_F64:
         isNaN = PS_IS_NAN(psF64, data, NAN);
-        break;
-    case PS_TYPE_C32:
-        // this is a bogus SQL type
-        isNaN = PS_IS_NAN(psC32, data, NAN);
-        break;
-    case PS_TYPE_C64:
-        // this is a bogus SQL type
-        isNaN = PS_IS_NAN(psC64, data, NAN);
         break;
     case PS_DATA_BOOL:

trunk/psLib/src/fits/psFits.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-02-22 21:47:29 $
+ *  @version $Revision: 1.62 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -524 +524 @@
     case TDOUBLE:
         return PS_TYPE_F64;
-    case TCOMPLEX:
-        return PS_TYPE_C32;
-    case TDBLCOMPLEX:
-        return PS_TYPE_C64;
     case TLOGICAL:
         return PS_TYPE_BOOL;

trunk/psLib/src/fits/psFitsTable.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-02-07 23:52:53 $
+ *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -447 +447 @@
     case PS_TYPE_F64:
         return 'D';
-    case PS_TYPE_C32:
-        return 'C';
-    case PS_TYPE_C64:
-        return 'M';
     case PS_TYPE_BOOL:
         return 'L';

trunk/psLib/src/imageops/psImageGeomManip.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-08 22:12:56 $
+ *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -20 +20 @@
 #endif
 
-#include <complex.h>
 #include <math.h>                          // for isfinite(), etc.
 #include <stdlib.h>
@@ -158 +157 @@
         PS_IMAGE_REBIN_CASE(F32);
         PS_IMAGE_REBIN_CASE(F64);
-        //        PS_IMAGE_REBIN_CASE(C32);      Not valid since psVectorStats doesn't allow
-        //        PS_IMAGE_REBIN_CASE(C64);      Not valid since psVectorStats doesn't allow
 
     default: {
@@ -241 +238 @@
         PSIMAGE_RESAMPLE_CASE(F32)
         PSIMAGE_RESAMPLE_CASE(F64)
-        PSIMAGE_RESAMPLE_CASE(C32)
-        PSIMAGE_RESAMPLE_CASE(C64)
     default: {
             char* typeStr;
@@ -312 +307 @@
                        const psImage* input,
                        float angle,
-                       double complex exposed,
+                       double exposed,
                        psImageInterpolateMode mode)
 {
@@ -356 +351 @@
             PSIMAGE_ROTATE_LEFT_90(F32);
             PSIMAGE_ROTATE_LEFT_90(F64);
-            PSIMAGE_ROTATE_LEFT_90(C32);
-            PSIMAGE_ROTATE_LEFT_90(C64);
 
         default: {
@@ -402 +395 @@
             PSIMAGE_ROTATE_180_CASE(F32);
             PSIMAGE_ROTATE_180_CASE(F64);
-            PSIMAGE_ROTATE_180_CASE(C32);
-            PSIMAGE_ROTATE_180_CASE(C64);
 
         default: {
@@ -447 +438 @@
             PSIMAGE_ROTATE_RIGHT_90(F32);
             PSIMAGE_ROTATE_RIGHT_90(F64);
-            PSIMAGE_ROTATE_RIGHT_90(C32);
-            PSIMAGE_ROTATE_RIGHT_90(C64);
 
         default: {
@@ -504 +493 @@
 
         #define PSIMAGE_ROTATE_ARBITRARY_LOOP(TYPE,MODE) { \
-            if (creal(exposed) < PS_MIN_##TYPE || \
-                    creal(exposed) > PS_MAX_##TYPE || \
-                    cimag(exposed) < PS_MIN_##TYPE || \
-                    cimag(exposed) > PS_MAX_##TYPE) { \
+            if (exposed < PS_MIN_##TYPE || \
+                    exposed > PS_MAX_##TYPE || \
+                    exposed < PS_MIN_##TYPE || \
+                    exposed > PS_MAX_##TYPE) { \
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
                         _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
                         "exposed", \
-                        creal(exposed),cimag(exposed), \
+                        exposed, exposed, \
                         PS_TYPE_##TYPE##_NAME,  \
                         (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
@@ -566 +555 @@
             PSIMAGE_ROTATE_ARBITRARY_LOOP(F64,MODE); \
             break; \
-        case PS_TYPE_C32: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(C32,MODE); \
-            break; \
-        case PS_TYPE_C64: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(C64,MODE); \
-            break; \
         default: { \
                 char* typeStr; \
@@ -690 +673 @@
                       float dx,
                       float dy,
-                      double complex exposed,
+                      double exposed,
                       psImageInterpolateMode mode)
 {
@@ -714 +697 @@
     #define PSIMAGE_SHIFT_CASE(MODE,TYPE) \
 case PS_TYPE_##TYPE: \
-    if (creal(exposed) < PS_MIN_##TYPE || \
-            creal(exposed) > PS_MAX_##TYPE || \
-            cimag(exposed) < PS_MIN_##TYPE || \
-            cimag(exposed) > PS_MAX_##TYPE) { \
+    if (exposed < PS_MIN_##TYPE || \
+            exposed > PS_MAX_##TYPE || \
+            exposed < PS_MIN_##TYPE || \
+            exposed > PS_MAX_##TYPE) { \
         psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
                 _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
                 "exposed", \
-                creal(exposed),cimag(exposed), \
+                exposed,exposed, \
                 PS_TYPE_##TYPE##_NAME,  \
                 (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
@@ -755 +738 @@
         PSIMAGE_SHIFT_CASE(MODE,F32); \
         PSIMAGE_SHIFT_CASE(MODE,F64); \
-        PSIMAGE_SHIFT_CASE(MODE,C32); \
-        PSIMAGE_SHIFT_CASE(MODE,C64); \
-        \
+       \
     default: { \
             char* typeStr; \
@@ -1029 +1010 @@
             FLIP_X_CASE(PS_TYPE_F32, F32);
             FLIP_X_CASE(PS_TYPE_F64, F64);
-            FLIP_X_CASE(PS_TYPE_C32, C32);
-            FLIP_X_CASE(PS_TYPE_C64, C64);
         default:
             psFree(output);
@@ -1050 +1029 @@
             FLIP_Y_CASE(PS_TYPE_F32, F32);
             FLIP_Y_CASE(PS_TYPE_F64, F64);
-            FLIP_Y_CASE(PS_TYPE_C32, C32);
-            FLIP_Y_CASE(PS_TYPE_C64, C64);
         default:
             psFree(output);

trunk/psLib/src/imageops/psImageGeomManip.h

@@ -6 +6 @@
  * @author Robert DeSonia, MHPCC
  *
- * @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-01-23 22:47:23 $
+ * @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-03-14 00:39:50 $
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
@@ -27 +27 @@
  *  specified the number of pixels used to define a new pixel in the output image.
  *  The output image is generated from all input image pixels. This function is
- *  defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64.
+ *  defined for psU8, psS8, psS16, psF32, psF64.
  *
  *  @return psImage    new image formed by rebinning input image.
@@ -65 +65 @@
  *  center pixel of the image. The rotation is specified in the sense that a
  *  positive angle is an anti-clockwise rotation. This function must be
- *  defined for the following types: psU8, psU16, psS8, psS16, psF32, psF64,
- *  psC32, psC64.
+ *  defined for the following types: psU8, psU16, psS8, psS16, psF32, psF64.
  *
  *  @return psImage*     the rotated image result.
@@ -74 +73 @@
     const psImage* input,              ///< input image
     float angle,                       ///< the rotation angle in radians.
-    double complex exposed,            ///< the output image pixel values for non-imagery areas
+    double exposed,                    ///< the output image pixel values for non-imagery areas
     psImageInterpolateMode mode        ///< the interpolation mode used
 );
@@ -85 +84 @@
  *  output image are lost. Newly exposed pixels are set to the value given by
  *  exposed. This function must be defined for the following types: psU8,
- *  psU16, psS8, psS16, psF32, psF64, psC32, psC64.
+ *  psU16, psS8, psS16, psF32, psF64.
  *
  *  @return psImage*     the shifted image result.
@@ -94 +93 @@
     float dx,                          ///< the shift in x direction.
     float dy,                          ///< the shift in y direction.
-    double complex exposed,            ///< the output image pixel values for non-imagery areas
+    double exposed,                    ///< the output image pixel values for non-imagery areas
     psImageInterpolateMode mode        ///< the interpolation mode to use
 );
@@ -105 +104 @@
  *  output image are lost. Newly exposed pixels are set to the value given by
  *  exposed. This function must be defined for the following types: psU8,
- *  psU16, psS8, psS16, psF32, psF64, psC32, psC64.
+ *  psU16, psS8, psS16, psF32, psF64.
  *
  *  This implementation uses a NxN kernel generated based on the interpolation method
  *  the image is first shifted by a fractional amount with the kernel, then
- *  shifted in place by an integer amount. 
+ *  shifted in place by an integer amount.
  *
  *  XXX the integer shift portion is not implemented
@@ -136 +135 @@
  *  The output image is the same dimensions as the input image.  Edge pixels
  *  wrap to the other side (no values are lost).  This function is
- *  defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64.
+ *  defined for psU8, psS8, psS16, psF32, psF64.
  *
  *  @return psImage* the rolled version of the input image.
@@ -169 +168 @@
  *  return to the user. This function must be capable of handling the following
  *  types for the input (with corresponding types for the output): psF32, psF64.
- 
+
  *
  *  @return psImage*    The transformed image.

trunk/psLib/src/imageops/psImageMaskOps.c

@@ -8 +8 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-01-09 22:38:52 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -18 +18 @@
 #endif
 
-#include <complex.h>
 #include <math.h>                          // for isfinite(), etc.
 #include <stdlib.h>

trunk/psLib/src/imageops/psImagePixelExtract.c

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-01-09 22:38:52 $
+ *  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -103 +103 @@
         VECTOR_STORE_ROW_CASE(F32);
         VECTOR_STORE_ROW_CASE(F64);
-        VECTOR_STORE_ROW_CASE(C32);
-        VECTOR_STORE_ROW_CASE(C64);
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
@@ -193 +191 @@
         VECTOR_STORE_COL_CASE(F32);
         VECTOR_STORE_COL_CASE(F64);
-        VECTOR_STORE_COL_CASE(C32);
-        VECTOR_STORE_COL_CASE(C64);
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
@@ -463 +459 @@
             PSIMAGE_CUT_VERTICAL(F32);
             PSIMAGE_CUT_VERTICAL(F64);
-            PSIMAGE_CUT_VERTICAL(C32); // Not a requirement
-            PSIMAGE_CUT_VERTICAL(C64); // Not a requirement
         default: {
                 char* typeStr;
@@ -715 +709 @@
         LINEAR_CUT_CASE(F32);
         LINEAR_CUT_CASE(F64);
-        LINEAR_CUT_CASE(C32);
-        LINEAR_CUT_CASE(C64);
 
     default: {

trunk/psLib/src/imageops/psImagePixelManip.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-06 03:09:58 $
+ *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -20 +20 @@
 #endif
 
-#include <complex.h>
 #include <math.h>                          // for isfinite(), etc.
 #include <stdlib.h>
@@ -90 +89 @@
         break;
 
-        #define psImageClipCaseComplex(type,absfcn)\
-    case PS_TYPE_##type: { \
-            if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
-                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
-                        "vmin",vmin, PS_TYPE_##type##_NAME, \
-                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
-            } \
-            if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
-                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
-                        "vmax",vmax, PS_TYPE_##type##_NAME, \
-                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
-            } \
-            for (psU32 row = 0;row<numRows;row++) { \
-                ps##type* inputRow = input->data.type[row]; \
-                for (psU32 col = 0; col < numCols; col++) { \
-                    if (absfcn(inputRow[col]) < min) { \
-                        inputRow[col] = (ps##type)vmin; \
-                        numClipped++; \
-                    } else if (absfcn(inputRow[col]) > max) { \
-                        inputRow[col] = (ps##type)vmax; \
-                        numClipped++; \
-                    } \
-                } \
-            } \
-        } \
-        break;
-
         psImageClipCase(S8)
         psImageClipCase(S16)
@@ -129 +99 @@
         psImageClipCase(F32)
         psImageClipCase(F64)
-        psImageClipCaseComplex(C32, cabsf)
-        psImageClipCaseComplex(C64, cabs)
 
     default: {
@@ -174 +142 @@
         psImageClipNaNCase(F32)
         psImageClipNaNCase(F64)
-        psImageClipNaNCase(C32)
-        psImageClipNaNCase(C64)
 
     default: {
@@ -331 +297 @@
         psImageOverlayCase(F32,NAN);
         psImageOverlayCase(F64,NAN);
-        psImageOverlayCase(C32,NAN);
-        psImageOverlayCase(C64,NAN);
 
     default: {
@@ -347 +311 @@
 }
 
-int psImageClipComplexRegion(psImage* input,
-                             double complex min,
-                             double complex vmin,
-                             double complex max,
-                             double complex vmax)
-{
-    psS32 numClipped = 0;
-    psU32 numRows;
-    psU32 numCols;
-    psF64 realMin = creal(min);
-    psF64 imagMin = cimag(min);
-    psF64 realMax = creal(max);
-    psF64 imagMax = cimag(max);
-
-    if (input == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("Can not operate on a NULL psImage."));
-        return 0;
-    }
-
-    if (realMax < realMin) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                _("Specified real-portion of min value, %g, can not be greater than the real-portion of max value, %g."),
-                (double)realMin, (double)realMax);
-        return 0;
-    }
-    if (imagMax < imagMin) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                _("Specified imaginary-portion of min value, %g, can not be greater than the imaginary-portion of max value, %g."),
-                (double)imagMin, (double)imagMax);
-        return 0;
-    }
-
-    numRows = input->numRows;
-    numCols = input->numCols;
-
-    #define psImageClipComplexRegionCase(type,realfcn,imagfcn) \
-case PS_TYPE_##type: { \
-        if (realfcn(vmin) < PS_MIN_##type || imagfcn(vmin) < PS_MIN_##type || \
-                realfcn(vmin) > PS_MAX_##type || imagfcn(vmin) > PS_MAX_##type ) { \
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                    _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
-                    "vmin", creal(vmin), cimag(vmin), \
-                    PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
-            break; \
-        } \
-        if (realfcn(vmax) > PS_MAX_##type || imagfcn(vmax) > PS_MAX_##type || \
-                realfcn(vmax) < PS_MIN_##type || imagfcn(vmax) < PS_MIN_##type ) { \
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                    _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
-                    "vmax", creal(vmax), cimag(vmax), \
-                    PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
-            break; \
-        } \
-        for (psU32 row = 0;row<numRows;row++) { \
-            ps##type* inputRow = input->data.type[row]; \
-            for (psU32 col = 0; col < numCols; col++) { \
-                if ( (realfcn(inputRow[col]) > realMax) || (imagfcn(inputRow[col]) > imagMax) ) { \
-                    inputRow[col] = (ps##type)vmax; \
-                    numClipped++; \
-                } else if ( (realfcn(inputRow[col]) < realMin) || (imagfcn(inputRow[col]) < imagMin) ){ \
-                    inputRow[col] = (ps##type)vmin; \
-                    numClipped++; \
-                } \
-            } \
-        } \
-    } \
-    break;
-
-    switch (input->type.type) {
-
-        psImageClipComplexRegionCase(C32, crealf, cimagf)
-        psImageClipComplexRegionCase(C64, creal, cimag)
-
-    default: {
-            char* typeStr;
-            PS_TYPE_NAME(typeStr,input->type.type);
-            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    _("Specified psImage type, %s, is not supported."),
-                    typeStr);
-        }
-    }
-
-    return numClipped;
-}

trunk/psLib/src/imageops/psImagePixelManip.h

@@ -5 +5 @@
  * @author Robert DeSonia, MHPCC
  *
- * @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-01-23 22:47:23 $
+ * @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-03-14 00:39:50 $
  *
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -26 +26 @@
  *  All pixels with values less than min are set to the value vmin.  all pixels
  *  with values greater than max are set to the value vmax. This function is
- *  defined for psU8, psU16, psS8, psS16, psF32, psF64, psC32, and psC64.
+ *  defined for psU8, psU16, psS8, psS16, psF32, psF64.
  *
  *  @return int     The number of clipped pixels
@@ -38 +38 @@
 );
 
-/** Clip image values outside of a specified complex region
- *
- *  All pixels outside of the rectangular region in complex space formed by
- *  the min and max input parameters are set to the value vmax (if either
- *  the real or imaginary portion exceeds the respective max values), or vmin.
- *  This function is defined for psC32, and psC64 imagery only.
- *
- *  @return int     The number of clipped pixels
- */
-int psImageClipComplexRegion(
-    psImage* input,                    ///< the image to clip
-    double complex min,                ///< the minimum image value allowed
-    double complex vmin,               ///< the value pixels < min are set to
-    double complex max,                ///< the maximum image value allowed
-    double complex vmax                ///< the value pixels > max are set to
-);
-
 /** Clip NaN image pixels to given value.
  *
  *  Pixels with NaN, +Inf, or -Inf values are set to the specified value. This
- *  function is defined for psF32, psF64, psC32, and psC64.
+ *  function is defined for psF32, psF64.
  *
  *  @return int     The number of clipped pixels
@@ -74 +57 @@
  *  OVERLAY value to image value), "-" (subtract OVERLAY from image), "*"
  *  (multiply OVERLAY times image), "/" (divide image by OVERLAY).  This
- *  function is defined for psU8, psS8, psS16, psF32, psF64, psC32, and psC64.
+ *  function is defined for psU8, psS8, psS16, psF32, psF64.
  *
  *  @return int         0 if success, non-zero if failed.

trunk/psLib/src/imageops/psImageStats.c

@@ -9 +9 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.105 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-02-13 03:08:17 $
+ *  @version $Revision: 1.106 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -634 +634 @@
     case PS_TYPE_F32:
     case PS_TYPE_F64:
-    case PS_TYPE_C32:
-    case PS_TYPE_C64:
     default:
         // XXX this should include the mask type (as a string)

trunk/psLib/src/imageops/psImageStructManip.c

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-01-09 22:38:52 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -239 +239 @@
             PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
             break; \
-        case PS_TYPE_C32: \
-            PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_C64: \
-            PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
-            break; \
         default: \
             break; \
@@ -280 +274 @@
     case PS_TYPE_F64:
         PSIMAGE_COPY_CASE(output, F64);
-        break;
-    case PS_TYPE_C32:
-        PSIMAGE_COPY_CASE(output, C32);
-        break;
-    case PS_TYPE_C64:
-        PSIMAGE_COPY_CASE(output, C64);
         break;
     default: {

trunk/psLib/src/imageops/psImageStructManip.h

@@ -5 +5 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2007-01-23 22:47:23 $
+*  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-03-14 00:39:50 $
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
 */
@@ -29 +29 @@
  *  parent image in that dimension. The entire subraster must be contained within the raster of
  *  the parent image. Note that the refCounter for the parent should be incremented.  This
- *  function must be defined for the following types: psU8, psU16, psS8, psS16, psF32, psF64,
- *  psC32, psC64.
+ *  function must be defined for the following types: psU8, psU16, psS8, psS16, psF32, psF64.
  *
  *  @return psImage* : Pointer to psImage.

trunk/psLib/src/math/psBinaryOp.c

@@ -30 +30 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-01-09 22:38:52 $
+ *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -323 +323 @@
     DIM1##_##DIM2(OUT,IN1,OP,IN2,F64);                                                                       \
     break;                                                                                                   \
-case PS_TYPE_C32:                                                                                            \
-    DIM1##_##DIM2(OUT,IN1,OP,IN2,C32);                                                                       \
-    break;                                                                                                   \
-case PS_TYPE_C64:                                                                                            \
-    DIM1##_##DIM2(OUT,IN1,OP,IN2,C64);                                                                       \
-    break;                                                                                                   \
-default:                                                                                                     \
-    /* char* strType;                                                                                        \
-    PS_TYPE_NAME(strType,IN1->type);                                                                         \
-    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
-            _("Specified data type, %s, is not supported."),                                                             \
-            strType);  */                                                                                    \
-    if (OUT != IN1 && OUT != IN2) {                                                                          \
-        psFree(OUT);                                                                                         \
+default: {                                                                                                   \
+        char* strType;                                                                                       \
+        PS_TYPE_NAME(strType,IN1->type);                                                                     \
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                             \
+                _("Specified data type, %s, is not supported."),                                             \
+                strType);                                                                                    \
+        if (OUT != IN1 && OUT != IN2) {                                                                      \
+            psFree(OUT);                                                                                     \
+        }                                                                                                    \
+        return NULL;                                                                                         \
     }                                                                                                        \
-    return NULL;                                                                                             \
 }
 
@@ -364 +359 @@
     } else {                                                                                                 \
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
-                "Types (%x,%x) are not appropriate for logical OR.\n", IN1->type, IN2->type);               \
+                "Types (%x,%x) are not appropriate for logical OR.\n", IN1->type, IN2->type);                \
         return NULL;                                                                                         \
     }                                                                                                        \
 } else if (!strncmp(OP, "^", 1)) {                                                                           \
-    if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
-        BINARY_TYPE(DIM1,DIM2,OUT,IN1,cpow(*i1,*i2),IN2);                                                    \
-    } else {                                                                                                 \
-        BINARY_TYPE(DIM1,DIM2,OUT,IN1,pow(*i1,*i2),IN2);                                                     \
-    }                                                                                                        \
+    BINARY_TYPE(DIM1,DIM2,OUT,IN1,pow(*i1,*i2),IN2);                                                         \
 } else if (!strncmp(OP, "min", 3)) {                                                                         \
-    if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
-                _("The minimum operation is not supported with complex data."));                                                  \
-        if (OUT != IN1 && OUT != IN2) {                                                                      \
-            psFree(OUT);                                                                                     \
-        }                                                                                                    \
-        return NULL;                                                                                         \
-    } else {                                                                                                 \
-        BINARY_TYPE(DIM1,DIM2,OUT,IN1,fmin(*i1,*i2),IN2);                                                    \
-    }                                                                                                        \
+    BINARY_TYPE(DIM1,DIM2,OUT,IN1,fmin(*i1,*i2),IN2);                                                        \
 } else if (!strncmp(OP, "max", 3)) {                                                                         \
-    if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
-                _("The maximum operation is not supported with complex data."));                                                  \
-        if (OUT != IN1 && OUT != IN2) {                                                                      \
-            psFree(OUT);                                                                                     \
-        }                                                                                                    \
-        return NULL;                                                                                         \
-    } else {                                                                                                 \
-        BINARY_TYPE(DIM1,DIM2,OUT,IN1,fmax(*i1,*i2),IN2);                                                    \
-    }                                                                                                        \
+    BINARY_TYPE(DIM1,DIM2,OUT,IN1,fmax(*i1,*i2),IN2);                                                        \
 } else {                                                                                                     \
     psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                                \
-            _("Specified operation, %s, is not supported."),                                                     \
+            _("Specified operation, %s, is not supported."),                                                 \
             OP);                                                                                             \
     if (OUT != IN1 && OUT != IN2) {                                                                          \

trunk/psLib/src/math/psUnaryOp.c

@@ -31 +31 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-01-09 22:38:53 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -45 +45 @@
  ******************************************************************************/
 #include <string.h>
-#include <complex.h>
 #include <math.h>
 #include <stdint.h>
@@ -123 +122 @@
 #define UNARY_TYPE(DIM,OUT,IN,OP) \
 switch (IN->type) { \
+case PS_TYPE_U8: \
+    DIM(OUT,IN,OP,U8); \
+    break; \
+case PS_TYPE_U16: \
+    DIM(OUT,IN,OP,U16); \
+    break; \
+case PS_TYPE_U32: \
+    DIM(OUT,IN,OP,U32); \
+    break; \
+case PS_TYPE_U64: \
+    DIM(OUT,IN,OP,U64); \
+    break; \
+case PS_TYPE_S8: \
+    DIM(OUT,IN,OP,S8); \
+    break; \
+case PS_TYPE_S16: \
+    DIM(OUT,IN,OP,S16); \
+    break; \
 case PS_TYPE_S32: \
     DIM(OUT,IN,OP,S32); \
     break; \
+case PS_TYPE_S64: \
+    DIM(OUT,IN,OP,S64); \
+    break; \
 case PS_TYPE_F32: \
     DIM(OUT,IN,OP,F32); \
@@ -131 +151 @@
 case PS_TYPE_F64: \
     DIM(OUT,IN,OP,F64); \
-    break; \
-case PS_TYPE_C32: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_S8: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_U8: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_S16: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_U16: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_U32: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_S64: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_U64: \
-    DIM(OUT,IN,OP,C32); \
-    break; \
-case PS_TYPE_C64: \
-    DIM(OUT,IN,OP,C32); \
     break; \
 default: { \
@@ -174 +167 @@
 #define UNARY_OP(DIM,OUT,IN,OP) \
 if(!strncmp(OP, "abs", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,cabs((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,fabs((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,fabs((double)*i1)); \
 } else if(!strncmp(OP, "sqrt", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,csqrt((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,sqrt((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,sqrt((double)*i1)); \
 } else if(!strncmp(OP, "exp", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,cexp((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,exp((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,exp((double)*i1)); \
 } else if(!strncmp(OP, "ln", 2)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,clog((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,log((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,log((double)*i1)); \
 } else if(!strncmp(OP, "ten", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,cpow(10.0,(double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,pow(10.0,(double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,pow(10.0,(double)*i1)); \
 } else if(!strncmp(OP, "log", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,clog((double complex)*i1)/log(10.0)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,log10((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,log10((double)*i1)); \
 } else if(!strncmp(OP, "sin", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,csin((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,sin((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,sin((double)*i1)); \
 } else if(!strncmp(OP, "dsin", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,csin((double complex)*i1*D2R)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,sin((double)*i1*D2R)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,sin((double)*i1*D2R)); \
 } else if(!strncmp(OP, "cos", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,ccos((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,cos((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,cos((double)*i1)); \
 } else if(!strncmp(OP, "dcos", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,ccos((double complex)*i1*D2R)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,cos((double)*i1*D2R)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,cos((double)*i1*D2R)); \
 } else if(!strncmp(OP, "tan", 3)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,ctan((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,tan((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,tan((double)*i1)); \
 } else if(!strncmp(OP, "dtan", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,ctan((double complex)*i1*D2R)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,tan((double)*i1*D2R)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,tan((double)*i1*D2R)); \
 } else if(!strncmp(OP, "asin", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,casin((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,asin((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,asin((double)*i1)); \
 } else if(!strncmp(OP, "dasin", 5)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,R2D*casin((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,(R2D*asin((double)*i1))); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,(R2D*asin((double)*i1))); \
 } else if(!strncmp(OP, "acos", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,cacos((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,acos((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,acos((double)*i1)); \
 } else if(!strncmp(OP, "dacos", 5)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,R2D*cacos((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,R2D*acos((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,R2D*acos((double)*i1)); \
 } else if(!strncmp(OP, "atan", 4)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,catan((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,atan((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,atan((double)*i1)); \
 } else if(!strncmp(OP, "datan", 5)) { \
-    if(PS_IS_PSELEMTYPE_COMPLEX(IN->type)) { \
-        UNARY_TYPE(DIM,OUT,IN,R2D*catan((double complex)*i1)); \
-    } else { \
-        UNARY_TYPE(DIM,OUT,IN,R2D*atan((double)*i1)); \
-    } \
+    UNARY_TYPE(DIM,OUT,IN,R2D*atan((double)*i1)); \
 } else { \
     psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified operation, %s, is not supported."), OP); \

trunk/psLib/src/mathtypes/psImage.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.124 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-09 20:16:40 $
+ *  @version $Revision: 1.125 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:50 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -31 +31 @@
 #include "psString.h"
 
-
-
-#define SQUARE(x) ((x)*(x))
-#define MIN(x,y) (((x) > (y)) ? (y) : (x))
-#define MAX(x,y) (((x) > (y)) ? (x) : (y))
 
 static void imageFree(psImage* image)
@@ -209 +204 @@
                 int x,
                 int y,
-                double complex value)
+                double value)
 {
     PS_ASSERT_IMAGE_NON_NULL(image, false);
@@ -276 +271 @@
         IMAGE_SET_CASE(F32);
         IMAGE_SET_CASE(F64);
-        IMAGE_SET_CASE(C32);
-        IMAGE_SET_CASE(C64);
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psImage Data Type\n");
@@ -286 +279 @@
 }
 
-double complex psImageGet(const psImage *image,
+double psImageGet(const psImage *image,
                           int x,
                           int y)
@@ -354 +347 @@
         IMAGE_GET_CASE(F32);
         IMAGE_GET_CASE(F64);
-        IMAGE_GET_CASE(C32);
-        IMAGE_GET_CASE(C64);
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psImage Data Type\n");
@@ -485 +476 @@
             PSIMAGE_BUFFER_COPY(F64,OUTTYPE); \
             break; \
-        case PS_TYPE_C32: \
-            PSIMAGE_BUFFER_COPY(C32,OUTTYPE); \
-            break; \
-        case PS_TYPE_C64: \
-            PSIMAGE_BUFFER_COPY(C64,OUTTYPE); \
-            break; \
         default: \
             break; \
@@ -526 +511 @@
     case PS_TYPE_F64:
         PSIMAGE_BUFFER_COPY_CASE(output, F64);
-        break;
-    case PS_TYPE_C32:
-        PSIMAGE_BUFFER_COPY_CASE(output, C32);
-        break;
-    case PS_TYPE_C64:
-        PSIMAGE_BUFFER_COPY_CASE(output, C64);
         break;
     default: {
@@ -593 +572 @@
 }
 
-double complex psImagePixelInterpolate(const psImage* input,
+double psImagePixelInterpolate(const psImage* input,
                                        float x,
                                        float y,
                                        const psImage* mask,
                                        psMaskType maskVal,
-                                       double complex unexposedValue,
+                                       double unexposedValue,
                                        psImageInterpolateMode mode)
 {
@@ -660 +639 @@
         PSIMAGE_PIXEL_INTERPOLATE_CASE(F32);
         PSIMAGE_PIXEL_INTERPOLATE_CASE(F64);
-        PSIMAGE_PIXEL_INTERPOLATE_CASE(C32);
-        PSIMAGE_PIXEL_INTERPOLATE_CASE(C64);
     default: {
             char* typeStr;
@@ -729 +706 @@
         float y, \
         const psImage* mask, \
-        psU32 maskVal, \
+        psMaskType maskVal, \
         RETURNTYPE unexposedValue) \
 { \
@@ -759 +736 @@
 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64)
 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64)
-PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64)
-PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64)
 
 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \
@@ -768 +743 @@
         float y, \
         const psImage* mask, \
-        psU32 maskVal, \
+        psMaskType maskVal, \
         RETURNTYPE unexposedValue) \
 { \
     int floorX = floor((x) - 0.5); \
     int floorY = floor((y) - 0.5); \
-    psF64 fracX = x - 0.5 - floorX; \
-    psF64 fracY = y - 0.5 - floorY; \
-    psS32 lastX = input->numCols - 1; \
-    psS32 lastY = input->numRows - 1; \
-    ps##TYPE V00 = 0; \
-    ps##TYPE V01 = 0; \
-    ps##TYPE V10 = 0; \
-    ps##TYPE V11 = 0; \
-    bool valid00 = false; \
-    bool valid01 = false; \
-    bool valid10 = false; \
-    bool valid11 = false; \
+    float fracX = x - 0.5 - floorX; \
+    float fracY = y - 0.5 - floorY; \
+    int lastX = input->numCols - 1; \
+    int lastY = input->numRows - 1; \
+    ps##TYPE V00; \
+    ps##TYPE V01; \
+    ps##TYPE V10; \
+    ps##TYPE V11; \
+    bool valid00; \
+    bool valid01; \
+    bool valid10; \
+    bool valid11; \
     \
     if (floorY >= 0 && floorY <= lastY) { \
@@ -791 +766 @@
             valid00 = (mask == NULL) || \
                       ((mask->data.PS_TYPE_MASK_DATA[floorY][floorX] & maskVal) == 0); \
+        } else { \
+            valid00 = false; \
         } \
         if (floorX >= -1 && floorX < lastX) { \
@@ -796 +773 @@
             valid10 = (mask == NULL) || \
                       ((mask->data.PS_TYPE_MASK_DATA[floorY][floorX+1] & maskVal) == 0); \
+        } else { \
+            valid10 = false; \
         } \
+    } else { \
+        valid00 = false; \
+        valid10 = false; \
     } \
     if (floorY >= -1 && floorY < lastY) { \
@@ -803 +785 @@
             valid01 = (mask == NULL) || \
                       ((mask->data.PS_TYPE_MASK_DATA[floorY+1][floorX] & maskVal) == 0); \
+        } else { \
+            valid01 = false; \
         } \
         if (floorX >= -1 && floorX < lastX) { \
@@ -808 +792 @@
             valid11 = (mask == NULL) || \
                       ((mask->data.PS_TYPE_MASK_DATA[floorY+1][floorX+1] & maskVal) == 0); \
+        } else { \
+            valid11 = false; \
         } \
+    } else { \
+        valid01 = false; \
+        valid11 = false; \
     } \
     \
@@ -814 +803 @@
     if (valid00 && valid10 && valid01 && valid11) { \
         /* formula from the ADD */ \
-        /* XXX this had V01 and V10 exchanged! */ \
         return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \
                V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \
@@ -864 +852 @@
         float y, \
         const psImage* mask, \
-        psU32 maskVal, \
+        psMaskType maskVal, \
         RETURNTYPE unexposedValue) \
 { \
@@ -917 +905 @@
 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,)
 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,)
 
 PSIMAGE_PIXEL_INTERPOLATE_BICUBE(U8,psF64,U8,)
@@ -930 +916 @@
 PSIMAGE_PIXEL_INTERPOLATE_BICUBE(F32,psF64,F32,)
 PSIMAGE_PIXEL_INTERPOLATE_BICUBE(F64,psF64,F64,)
-PSIMAGE_PIXEL_INTERPOLATE_BICUBE(C32,psC64,C32,)
-PSIMAGE_PIXEL_INTERPOLATE_BICUBE(C64,psC64,C64,)
 
 // Variance Version
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE)
-PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,PS_SQR)
+PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,PS_SQR)

trunk/psLib/src/mathtypes/psImage.h

@@ -9 +9 @@
  * @author Joshua Hoblitt, University of Hawaii
  *
- * @version $Revision: 1.89 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-03-09 20:16:40 $
+ * @version $Revision: 1.90 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-03-14 00:39:51 $
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
@@ -20 +20 @@
 /// @{
 
-#include <complex.h>
 #include <stdio.h>
 #include "psType.h"
@@ -70 +69 @@
         psF32** F32;                   ///< Single-precision float data.
         psF64** F64;                   ///< Double-precision float data.
-        psC32** C32;                   ///< Single-precision complex data.
-        psC64** C64;                   ///< Double-precision complex data.
         psPtr*  V;                     ///< Pointer to data.
     } data;                            ///< Union for data types.
@@ -143 +140 @@
 bool psImageSet(
     psImage *image,                     ///< the image to set
-    int x,                             ///< x-position
-    int y,                             ///< y-position
-    double complex value               ///< specified value to set
+    int x,                              ///< x-position
+    int y,                              ///< y-position
+    double value                        ///< specified value to set
 );
 
@@ -152 +149 @@
  *  A negative value for the x or y positions means index from the end.
  *
- *  @return complex: The value at the specified x,y position.
- */
-double complex psImageGet(
+ *  @return double: The value at the specified x,y position.
+ */
+double psImageGet(
     const psImage *image,              ///< the image from which to get
     int x,                             ///< x-position
@@ -230 +227 @@
 /** Interpolate image pixel value given floating point coordinates.
  *
- *  @return complex    Pixel value interpolated from image or unexposedValue if
+ *  @return double    Pixel value interpolated from image or unexposedValue if
  *                   given x,y doesn't coorespond to a valid image location
  */
-double complex psImagePixelInterpolate(
+double psImagePixelInterpolate(
     const psImage* input,              ///< input image for interpolation
     float x,                           ///< column location to derive value of
@@ -239 +236 @@
     const psImage* mask,               ///< if not NULL, the mask of the input image
     psMaskType maskVal,                ///< the mask value
-    double complex unexposedValue,            ///< return value if x,y location is not in image.
+    double unexposedValue,             ///< return value if x,y location is not in image.
     psImageInterpolateMode mode        ///< interpolation mode
 );
@@ -250 +247 @@
         float y,                       /**< row location ot derive value of */ \
         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
-        psU32 maskVal,                 /**< the mask value */ \
+        psMaskType maskVal,            /**< the mask value */ \
         RETURNTYPE unexposedValue      /**< return value if x,y location is not in image. */ \
                                                    );
@@ -264 +261 @@
 PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S64,psF64) \
 PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F32,psF64) \
-PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64) \
-PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C32,psC64) \
-PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C64,psC64)
+PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64)
 
 #ifndef SWIG

trunk/psLib/src/mathtypes/psScalar.c

@@ -8 +8 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-02-08 02:42:46 $
+ *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -34 +34 @@
                           unsigned int lineno,
                           const char *func,
-                          double complex value,
+                          double value,
                           psElemType type)
 {
@@ -75 +75 @@
     case PS_TYPE_F64:
         scalar->data.F64 = (psF64) value;
-        break;
-    case PS_TYPE_C32:
-        scalar->data.C32 = (psC32) value;
-        break;
-    case PS_TYPE_C64:
-        scalar->data.C64 = (psC64) value;
         break;
     default:
@@ -148 +142 @@
         newScalar =  p_psScalarAlloc(file, lineno, func, value->data.F64, dataType);
         break;
-    case PS_TYPE_C32:
-        newScalar =  p_psScalarAlloc(file, lineno, func, value->data.C32, dataType);
-        break;
-    case PS_TYPE_C64:
-        newScalar =  p_psScalarAlloc(file, lineno, func, value->data.C64, dataType);
-        break;
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,

trunk/psLib/src/mathtypes/psScalar.h

@@ -8 +8 @@
  * @author Joshua Hoblitt, University of Hawaii
  *
- * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-02-08 02:42:46 $
+ * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-03-14 00:39:51 $
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
@@ -41 +41 @@
         psF32 F32;              ///< Single-precision float data.
         psF64 F64;              ///< Double-precision float data.
-        psC32 C32;              ///< Single-precision complex data.
-        psC64 C64;              ///< Double-precision complex data.
     } data;                     ///< Union for data types.
 }
@@ -56 +54 @@
  *
  * Uses psLib memory allocation functions to create scalar data as defined by the psType type.
- * Accepts a complex 64 bit float for input value, as max size, but resizes according to
- * correct type.
+ * Accepts a double for input value, as max size, but resizes according to correct type.
  *
  * @return psScalar*   Pointer to a new psScalar.
@@ -63 +60 @@
 #ifdef DOXYGEN
 psScalar* psScalarAlloc(
-    double complex value,               ///< Data to be put into psScalar
+    double value,                       ///< Data to be put into psScalar
     psElemType type                     ///< Type of data to be held by psScalar
 );
@@ -71 +68 @@
     unsigned int lineno,                ///< Line number of caller
     const char *func,                   ///< Function name of caller
-    double complex value,               ///< Data to be put into psScalar
+    double value,                       ///< Data to be put into psScalar
     psElemType type                     ///< Type of data to be held by psScalar
 );

trunk/psLib/src/mathtypes/psVector.c

@@ -10 +10 @@
 *  @author Joshua Hoblitt, University of Hawaii
 *
-*  @version $Revision: 1.95 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2007-03-09 20:16:40 $
+*  @version $Revision: 1.96 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-03-14 00:39:51 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -33 +33 @@
 #include "psAssert.h"
 #include "psString.h"
-
-typedef struct
-{
-    union {
-        psU8* U8;                      ///< Unsigned 8-bit integer data.
-        psU16* U16;                    ///< Unsigned 16-bit integer data.
-        psU32* U32;                    ///< Unsigned 32-bit integer data.
-        psU64* U64;                    ///< Unsigned 64-bit integer data.
-        psS8* S8;                      ///< Signed 8-bit integer data.
-        psS16* S16;                    ///< Signed 16-bit integer data.
-        psS32* S32;                    ///< Signed 32-bit integer data.
-        psS64* S64;                    ///< Signed 64-bit integer data.
-        psF32* F32;                    ///< Single-precision float data.
-        psF64* F64;                    ///< Double-precision float data.
-        psC32* C32;                    ///< Single-precision complex data.
-        psC64* C64;                    ///< Double-precision complex data.
-    } data;
-    psU32 index;
-}
-indexedVector;
-
-static void vectorFree(psVector* psVec);
 
 static void vectorFree(psVector* psVec)
@@ -270 +248 @@
             PSVECTOR_COPY_SAME_CASE(F32);
             PSVECTOR_COPY_SAME_CASE(F64);
-            PSVECTOR_COPY_SAME_CASE(C32);
-            PSVECTOR_COPY_SAME_CASE(C64);
         default: {
                 char* typeStr;
@@ -326 +302 @@
             PSVECTOR_COPY(F64,OUTTYPE); \
             break; \
-        case PS_TYPE_C32: \
-            PSVECTOR_COPY(C32,OUTTYPE); \
-            break; \
-        case PS_TYPE_C64: \
-            PSVECTOR_COPY(C64,OUTTYPE); \
-            break; \
         default: { \
                 char* typeStr; \
@@ -355 +325 @@
         PSVECTOR_COPY_CASE(F32);
         PSVECTOR_COPY_CASE(F64);
-        PSVECTOR_COPY_CASE(C32);
-        PSVECTOR_COPY_CASE(C64);
     default: {
             char* typeStr;
@@ -560 +528 @@
     break;
 
-    #define APPEND_ELEMENTS_CASE_COMPLEX(TYPE,CREAL,CIMAG) \
-case PS_TYPE_##TYPE: \
-    for (lcv=0; lcv < size && ! full; lcv++) { \
-        snprintf(tempStr, maxLength, "%s%g%+gi", prefix, \
-                 CREAL(vector->data.TYPE[lcv]), \
-                 CIMAG(vector->data.TYPE[lcv])); \
-        strncat(str,tempStr,maxLength); \
-        full = (strlen(str) > maxLength-2); \
-        prefix = ","; \
-    } \
-    break;
-
     int lcv;
     char* prefix = "[";
@@ -585 +541 @@
         APPEND_ELEMENTS_CASE(F32,double,"%g")
         APPEND_ELEMENTS_CASE(F64,double,"%g")
-        APPEND_ELEMENTS_CASE_COMPLEX(C32,crealf,cimagf)
-        APPEND_ELEMENTS_CASE_COMPLEX(C64,creal,cimag)
     default:
         snprintf(str,maxLength,"[...]");
@@ -822 +776 @@
 bool psVectorSet(psVector *input,
                  long position,
-                 double complex value)
+                 double value)
 {
     if (input == NULL) {
@@ -880 +834 @@
         input->data.F64[position] = (psF64)value;
         break;
-    case PS_TYPE_C32:
-        input->data.C32[position] = (psC32)value;
-        break;
-    case PS_TYPE_C64:
-        input->data.C64[position] = (psC64)value;
-        break;
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psVector Data Type\n");
@@ -894 +842 @@
 }
 
-double complex psVectorGet(const psVector *input,
+double psVectorGet(const psVector *input,
                            long position)
 {
@@ -941 +889 @@
     case PS_TYPE_F64:
         return input->data.F64[position];
-        break;
-    case PS_TYPE_C32:
-        return input->data.C32[position];
-        break;
-    case PS_TYPE_C64:
-        return input->data.C64[position];
         break;
     default:
@@ -992 +934 @@
     case PS_TYPE_F32:
     case PS_TYPE_F64:
-    case PS_TYPE_C32:
-    case PS_TYPE_C64:
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,

trunk/psLib/src/mathtypes/psVector.h

@@ -10 +10 @@
  * @author Joshua Hoblitt, University of Hawaii
  *
- * @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-03-09 20:16:40 $
+ * @version $Revision: 1.67 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-03-14 00:39:51 $
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
@@ -45 +45 @@
         psF32* F32;                    ///< Single-precision float data.
         psF64* F64;                    ///< Double-precision float data.
-        psC32* C32;                    ///< Single-precision complex data.
-        psC64* C64;                    ///< Double-precision complex data.
     } data;
     void *lock;                        ///< Optional lock for thread safety.
@@ -227 +225 @@
 /** Sort an array of floats.
  *
- *  Sorts an array of floats in ascending order.  This function is valid for
- *  all non-complex data types.
+ *  Sorts an array of floats in ascending order.
  *
  *  @return  psVector*     Pointer to sorted psVector.
@@ -334 +331 @@
  */
 bool psVectorSet(
-    psVector *input,                   ///< Input vector to set
-    long position,                     ///< vector position
-    double complex value               ///< value to set
+    psVector *input,                    ///< Input vector to set
+    long position,                      ///< vector position
+    double value                        ///< value to set
 );
 
@@ -344 +341 @@
  *  A negative position means index from the end.
  *
- *  @return complex:        Value of the input vector at the specified position.
- */
-double complex psVectorGet(
+ *  @return double:        Value of the input vector at the specified position.
+ */
+double psVectorGet(
     const psVector *input,             ///< Input vector from which to get value
     long position                      ///< vector position

trunk/psLib/src/sys/psType.h

@@ -10 +10 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.56 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2007-02-08 01:59:28 $
+*  @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-03-14 00:39:51 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -22 +22 @@
 /// @{
 
-#include <complex.h>
 #include <stdint.h>
 #include <float.h>
@@ -50 +49 @@
 typedef float psF32;                   ///< 32-bit floating point
 typedef double psF64;                  ///< 64-bit floating point
-
-#ifdef SWIG
-/** 32-bit complex value */
-typedef struct
-{
-    float re, im;
-}
-psC32;
-
-
-/** 64-bit complex value */
-typedef struct
-{
-    double re,im;
-}
-psC64;
-
-
-#else // SWIG
-typedef float complex psC32;          ///< complex with 32-bit floating point Real and Imagary numbers
-typedef double complex psC64;         ///< complex with 64-bit floating point Real and Imagary numbers
-#endif // !SWIG
-
 typedef char* psString;                ///< string value
 typedef void* psPtr;                   ///< void pointer
+
 // XXX psBool can't be removed until all macros that 'generate' this type are
 // fixed -JH
@@ -98 +75 @@
     PS_TYPE_F32  = 0x0404,             ///< Single-precision Floating point.
     PS_TYPE_F64  = 0x0408,             ///< Double-precision floating point.
-    PS_TYPE_C32  = 0x0808,             ///< Complex numbers consisting of single-precision floating point.
-    PS_TYPE_C64  = 0x0810,             ///< Complex numbers consisting of double-precision floating point.
     PS_TYPE_BOOL = 0x1301              ///< Boolean.
 } psElemType;
@@ -170 +145 @@
 #define PS_MIN_F32       -FLT_MAX      /**< minimum valid psF32 value */
 #define PS_MIN_F64       -DBL_MAX      /**< minimum valid psF64 value */
-#define PS_MIN_C32       -FLT_MAX      /**< minimum valid real or imaginary psC32 value */
-#define PS_MIN_C64       -DBL_MAX      /**< minimum valid real or imaginary psC32 value */
 
 #define PS_MAX_S8        INT8_MAX      /**< maximum valid psS8 value */
@@ -183 +156 @@
 #define PS_MAX_F32       FLT_MAX       /**< maximum valid psF32 value */
 #define PS_MAX_F64       DBL_MAX       /**< maximum valid psF64 value */
-#define PS_MAX_C32       FLT_MAX       /**< maximum valid real or imaginary psC32 value */
-#define PS_MAX_C64       DBL_MAX       /**< maximum valid real or imaginary psC32 value */
 
 #define PS_TYPE_BOOL_NAME "psBool"
@@ -197 +168 @@
 #define PS_TYPE_F32_NAME  "psF32"
 #define PS_TYPE_F64_NAME  "psF64"
-#define PS_TYPE_C32_NAME  "psC32"
-#define PS_TYPE_C64_NAME  "psC64"
 
 #define PS_TYPE_NAME(value,type) \
@@ -234 +203 @@
 case PS_TYPE_F64: \
     value = PS_TYPE_F64_NAME; \
-    break; \
-case PS_TYPE_C32: \
-    value = PS_TYPE_C32_NAME; \
-    break; \
-case PS_TYPE_C64: \
-    value = PS_TYPE_C64_NAME; \
     break; \
 default: \
@@ -261 +224 @@
 /// Macro to determine if the psElemType is unsigned.
 #define PS_IS_PSELEMTYPE_UNSIGNED(x) ((x & 0x200) == 0x200)
-/// Macro to determine if the psElemType is a real (non-complex) floating-point type.
+/// Macro to determine if the psElemType is a real floating-point type.
 #define PS_IS_PSELEMTYPE_REAL(x) ((x & 0x400) == 0x400)
-/// Macro to determine if the psElemType is complex number type.
-#define PS_IS_PSELEMTYPE_COMPLEX(x) ((x & 0x800) == 0x800)
 /// Macro to determine if the psElemType is boolean type.
 #define PS_IS_PSELEMTYPE_BOOL(x) ((x & 0x1000) == 0x1000)

trunk/psLib/test/imageops/tap_psImageGeomManip.c

@@ -6 +6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-06 02:37:41 $
+ *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -531 +531 @@
         testRollType(S16);
         testRollType(F64);
-        testRollType(C32);
-        testRollType(C64);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     }

trunk/psLib/test/imageops/tap_psImageInterpolate.c

@@ -5 +5 @@
  * @author Eric Van Alst, MHPCC
  *
- * @version $Revision: 1.1 $
+ * @version $Revision: 1.2 $
  *          $Name: not supported by cvs2svn $
- * @date $Date: 2007-01-30 00:13:01 $
+ * @date $Date: 2007-03-14 00:39:51 $
  *
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -68 +68 @@
     CHECK_INTERP_BY_TYPE(F32)
     CHECK_INTERP_BY_TYPE(F64)
-    CHECK_INTERP_BY_TYPE(C32)
-    CHECK_INTERP_BY_TYPE(C64)
 
     // testInterpolateError(void)

trunk/psLib/test/imageops/tap_psImagePixelManip.c

@@ -6 +6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-12 20:46:45 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -96 +96 @@
         }
 
-        #define testImageClipByComplexType(datatype) \
-        { \
-            psU32 c = 128; \
-            psU32 r = 256; \
-            psF64 min; \
-            psF64 max; \
-            psS32 numClipped = 0; \
-            psS32 retVal; \
-            psMemId id = psMemGetId(); \
-            psImage *img = psImageAlloc(c,r,PS_TYPE_##datatype); \
-            for (psU32 row=0;row<r;row++) { \
-                ps##datatype* imgRow = img->data.datatype[row]; \
-                for (psU32 col=0;col<c;col++) { \
-                    imgRow[col] = (ps##datatype)(row+I*col); \
-                } \
-            } \
-            min = (float)r/2.0f; \
-            max = (float)r; \
-            \
-            retVal = psImageClip(img,min,-1.0f,max,-2.0f); \
-            \
-            numClipped = 0; \
-            bool errorFlag = false; \
-            for (psU32 row=0;row<r;row++) { \
-                ps##datatype* imgRow = img->data.datatype[row]; \
-                for (psU32 col=0;col<c;col++) { \
-                    ps##datatype value = row+I*col; \
-                    if (cabs(value) < min) { \
-                        numClipped++; \
-                        value = -1.0f; \
-                    } else if (cabs(value) > max) { \
-                        numClipped++; \
-                        value = -2.0f; \
-                    } \
-                    if (fabsf(creal(imgRow[col])-creal(value)) > FLT_EPSILON || \
-                            fabsf(cimag(imgRow[col])-cimag(value)) > FLT_EPSILON) { \
-                        diag("Pixel value is not as expected (%.2f+%.2fi vs %.2f+%.2fi) at %u,%u", \
-                             creal(imgRow[col]),cimag(imgRow[col]),creal(value),cimag(value),col,row); \
-                        errorFlag = true; \
-                    } \
-                } \
-            } \
-            ok(!errorFlag, "psImageClip() produced the correct data values"); \
-            ok(retVal == numClipped, "Got the expected number of clips"); \
-            psFree(img); \
-            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
-        }
-
         testImageClipByType(F64);
         testImageClipByType(F32);
@@ -152 +104 @@
         testImageClipByType(U16);
         testImageClipByType(U8);
-        testImageClipByComplexType(C32);
-        testImageClipByComplexType(C64);
-
 
         psF64 min=0.0;
@@ -241 +190 @@
         testImageClipNaNByType(F32);
         testImageClipNaNByType(F64);
-        testImageClipNaNByType(C32);
-        testImageClipNaNByType(C64);
 
         // Verify the retuned integer is zero, psImage structure input is unmodified
@@ -251 +198 @@
 
         // Verify program execution doesn't stop if the input image type is something
-        // other than F32, F64, C32, C64.
+        // other than F32, F64.
         img = psImageAlloc(c,r,PS_TYPE_S32);
         // Following should be an error (incorrect type)
@@ -260 +207 @@
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     }
-
-
-    // testImageClipComplexRegion()
-    {
-        psMemId id = psMemGetId();
-        psImage* img = NULL;
-        psU32 c = 1024;
-        psU32 r = 2048;
-        psS32 numClipped = 0;
-        psS32 retVal;
-
-        // psImageClipNaN shall modified pixel values of NaN with a specified value
-
-        // 1. Create a complex image with a wide range of complex values
-        //
-        // 2. call psImageClipComplexRegion with min and max where there is at least
-        //    2 pixels in the image above) that is:
-        //   a) real(p) < real(min) && complex(p) < complex(min),
-        //   b) real(p) < real(min) && complex(min) < complex(p) < complex(max)
-        //   c) real(min) < real(p) < real(max) && complex(p) < complex(min)
-        //   d) real(min) < real(p) < real(max) && complex(min) < complex(p) < complex(max)
-        //   e) real(p) > real(max) && complex(min) < complex(p) < complex(max)
-        //   f) real(pmin) < real(p) < real(max) && complex(p) > complex(max)
-        //   g) real(p) > real(max) && complex(p) > complex(max)
-        //   h) real(p) < real(min) && complex(p) > complex(max)
-        //   i) real(p) > real(max) && complex(p) < complex(min)
-        //
-        // 3. verify that All pixels in case (a), (b), and (c) have the value vmin
-        //
-        // 4. verify that all pixels in case (d) are unchanged from input
-        //
-        // 5. verify that all pixels in case (e), (f), (g), (h), and (i) have the
-        //    value vmax
-        #define testImageClipComplexByType(datatype,MIN,MAX) \
-        { \
-            psMemId id = psMemGetId(); \
-            img = psImageAlloc(c,r,PS_TYPE_##datatype); \
-            for (unsigned row=0;row<r;row++) { \
-                ps##datatype* imgRow = img->data.datatype[row]; \
-                for (unsigned col=0;col<c;col++) { \
-                    imgRow[col] = row+I*col; \
-                } \
-            } \
-            \
-            retVal = psImageClipComplexRegion(img,MIN,-1.0-1.0*I,MAX,-2.0-2.0*I); \
-            \
-            numClipped = 0; \
-            bool errorFlag = false; \
-            for (unsigned row=0;row<r;row++) { \
-                ps##datatype* imgRow = img->data.datatype[row]; \
-                for (unsigned col=0;col<c;col++) { \
-                    ps##datatype value = (ps##datatype)(row+I*col); \
-                    if ( (row > creal(MAX)) || (col > cimag(MAX)) ) { \
-                        numClipped++; \
-                        value = -2.0-2.0*I; \
-                    } else if ((row < creal(MIN)) || (col < cimag(MIN)) ) { \
-                        numClipped++; \
-                        value = -1.0-1.0*I; \
-                    } \
-                    if (cabs(imgRow[col]-value) > FLT_EPSILON) { \
-                        diag("Pixel value is not as expected (%g%+gi vs %g%+gi) at %d,%d", \
-                             creal(imgRow[col]),cimag(imgRow[col]),creal(value),cimag(value),col,row); \
-                        errorFlag = true; \
-                    } \
-                } \
-            } \
-            ok(!errorFlag, "psImageClip() produced the correct data values"); \
-            ok(retVal == numClipped, "Got the expected number of clips"); \
-            psFree(img); \
-            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
-        }
-
-        complex double min = ((double)r)/5.0+I*((double)c)/4.0;
-        complex double max = ((double)r)/3.0+I*((double)c)/2.0;
-
-        // Testing clipping at %g%+gi to %g%+gi for psC32, creal(min),cimag(min),creal(max),cimag(max));
-
-        testImageClipComplexByType(C32,min,max);
-
-        // Testing clipping at %g%+gi to %g%+gi for psC64, creal(min),cimag(min),creal(max),cimag(max));
-        testImageClipComplexByType(C64,min,max);
-
-        //  6. Call psImageClipComplexRegion with NULL input parameter; should error
-        //     but not stop execution.
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(NULL,0,0,0,0);
-        ok(retVal == 0, "Expected zero return for clips of a NULL image");
-
-        img = psImageAlloc(c,r,PS_TYPE_C32);
-        for (unsigned row=0;row<r;row++)
-        {
-            psC32* imgRow = img->data.C32[row];
-            for (unsigned col=0;col<c;col++) {
-                imgRow[col] = row+I*col;
-            }
-        }
-
-        //  7. Call psImageClipComplexRegion with min > max; should error and return 0,
-        //     but not stop execution
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,10.0+I*1.0,-1.0,5.0+5.0*I,-2.0);
-        ok(retVal == 0, "Expected zero return for creal(min)>creal(max)");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,1.0+I*10.0,-1.0,5.0+5.0*I,-2.0);
-        ok(retVal == 0, "Expected zero return for cimag(min)>cimag(max)");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,10.0+I*10.0,-1.0,5.0+5.0*I,-2.0);
-        ok(retVal == 0, "Expected zero return for min>max");
-
-        //  8. Call psImageClipComplexRegion with the follow vmin/vmax values; each
-        //     should error and return 0, but not stop execution
-        //      a) vmin < datatype region's minimum
-        //      b) vmax < datatype region's minimum
-        //      c) vmin > datatype region's maximum
-        //      d) vmax > datatype region's maximum
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          -2.0*(double)FLT_MAX,
-                                          5.0+5.0*I,
-                                          0.0);
-        ok(retVal == 0, "Expected zero return for vmin not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          2.0*(double)FLT_MAX,
-                                          5.0+5.0*I,
-                                          0.0);
-        ok(retVal == 0, "Expected zero return for vmin not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          FLT_EPSILON-2.0*(double)FLT_MAX*I,
-                                          5.0+5.0*I,
-                                          0.0);
-        ok(retVal == 0, "Expected zero return for vmin not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          FLT_EPSILON+2.0*(double)FLT_MAX*I,
-                                          5.0+5.0*I,
-                                          0.0);
-        ok(retVal == 0, "Expected zero return for vmin not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          0.0,
-                                          5.0+5.0*I,
-                                          -2.0*(double)FLT_MAX);
-        ok(retVal == 0, "Expected zero return for vmax not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          0.0,
-                                          5.0+5.0*I,
-                                          2.0*(double)FLT_MAX);
-        ok(retVal == 0, "Expected zero return for vmax not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          0.0,
-                                          5.0+5.0*I,
-                                          FLT_EPSILON-2.0*(double)FLT_MAX*I);
-        ok(retVal == 0, "Expected zero return for vmax not in datatype range");
-
-        // Following should be an error
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          0.0,
-                                          5.0+5.0*I,
-                                          FLT_EPSILON+2.0*(double)FLT_MAX*I);
-        ok(retVal == 0, "Expected zero return for vmax not in datatype range");
-
-        // now check if vmin > vmax is OK
-        for (unsigned row=0;row<r;row++)
-        {
-            psC32* imgRow = img->data.C32[row];
-            for (unsigned col=0;col<c;col++) {
-                imgRow[col] = row+I*col;
-            }
-        }
-        retVal = psImageClipComplexRegion(img,
-                                          1.0+I*1.0,
-                                          10.0,
-                                          5.0+5.0*I,
-                                          0.0);
-        ok(retVal != 0, "Didn't expect zero return for vmin > vmax");
-        psFree(img);
-        img = NULL;
-
-        //  9. Call psImageClipComplexRegion with the max value out of datatype's
-        //     range; should clip as expected (see step 1-5). Repeat with min value
-        //     out of datatype's range.
-
-        testImageClipComplexByType(C32,-(double)FLT_MAX*2.0-I*(double)FLT_MAX*2.0,10.0+I*10.0);
-        testImageClipComplexByType(C32,10.0+I*10.0,(double)FLT_MAX*2.0+I*(double)FLT_MAX*2.0);
-
-        // Verify program execution doesn't stop if the input image type is something
-        // other than C32, C64.
-        img = psImageAlloc(c,r,PS_TYPE_S32);
-        // Following should be an error (incorrect type)
-        // XXX: Verify error
-        retVal = psImageClipComplexRegion(img,2.0,10.0,5.0,0.0);
-        ok(retVal == 0, "Expected zero return for clip of incorrect image type");
-        psFree(img);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
-
 
     // testImageOverlay()
@@ -568 +287 @@
 
 
-        //      testOverlayType(C64);
-        //        testOverlayType(C32);
         //        testOverlayType(F64);
         //        testOverlayType(F32);

trunk/psLib/test/math/tap_psMatrix02.c

@@ -12 +12 @@
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2006-12-20 20:02:29 $
+ *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -56 +56 @@
         psMemId id = psMemGetId();
         psImage *outImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64);
-        psImage *badImage1 = (psImage*)psImageAlloc(3, 3, PS_TYPE_C32);
+        psImage *badImage1 = (psImage*)psImageAlloc(3, 3, PS_TYPE_U8);
         psMemIncrRefCounter(outImage);
         ok(psMatrixTranspose(outImage, badImage1) == NULL, "psMatrixTranspose(): inImage = outImage results in NULL return");
@@ -69 +69 @@
         psMemId id = psMemGetId();
         psImage *inImage = (psImage*)psImageAlloc(3, 3, PS_TYPE_F64);
-        psImage *badImage1 = (psImage*)psImageAlloc(3, 3, PS_TYPE_C32);
+        psImage *badImage1 = (psImage*)psImageAlloc(3, 3, PS_TYPE_U8);
         badImage1 = psMatrixTranspose(badImage1, inImage);
         ok(badImage1 != NULL, "psMatrixTranspose() results in non-NULL return");

trunk/psLib/test/math/tap_psMatrixVectorArithmetic01.c

@@ -4 +4 @@
  *
  *  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
+ *     Matrix-matrix with +,-,*,/ with S32, F32, F64
+ *     Matrix-vector with +,-,*,/ with S32, F32, F64
+ *     Matrix-scalar with +,-,*,/ with S32, F32, F64
  *
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-01-30 00:11:31 $
+ *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -140 +140 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, +, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMM(+,C32,10.0+10.0i,10.0+10.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, +, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     testBinaryOpMM(-,S32,20,10,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, -, S32)");
@@ -161 +158 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, *, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMM(*,C32,20.0+20.0i,10.0+10.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, *, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     testBinaryOpMM(/,S32,20,10,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, /, S32)");
@@ -172 +166 @@
     testBinaryOpMM(/,F64,20.0,10.0,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, /, F64)");
-    ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMM(/,C32,20.0+20.0i,10.0+10.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-matrix, /, C32)");
     ok(memoryFlag== false, "no memory leaks");
 
@@ -187 +178 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, +, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMV(+,C32,10.0+10.0i,5.0+5.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, +, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     testBinaryOpMV(-,S32,20,5,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, -, S32)");
@@ -208 +196 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, *, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMV(*,C32,20.0+20.0i,5.0+5.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, *, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     testBinaryOpMV(/,S32,20,5,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, /, S32)");
@@ -219 +204 @@
     testBinaryOpMV(/,F64,20.0,5.0,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, /, F64)");
-    ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMV(/,C32,20.0+20.0i,5.0+5.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-vector, /, C32)");
     ok(memoryFlag== false, "no memory leaks");
 
@@ -234 +216 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, +, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMS(+,C32,10.0+10.0i,5.0+5.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, +, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     testBinaryOpMS(-,S32,20,5,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, -, S32)");
@@ -255 +234 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, *, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMS(*,C32,20.0+20.0i,5.0+5.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, *, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     testBinaryOpMS(/,S32,20,5,3,2,errorFlag,memoryFlag);
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, /, S32)");
@@ -267 +243 @@
     ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, /, F64)");
     ok(memoryFlag== false, "no memory leaks");
-    testBinaryOpMS(/,C32,20.0+20.0i,5.0+5.0i,3,2,errorFlag,memoryFlag);
-    ok(errorFlag== false, "psBinaryOp(): was successful: (matrix-scalar, /, C32)");
-    ok(memoryFlag== false, "no memory leaks");
     return 0;
 }

trunk/psLib/test/math/tap_psMatrixVectorArithmetic02.c

@@ -5 +5 @@
  *
  *  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
+ *     Matrix with all math operators with S32, F32, F64
+ *     Vector with all math operators with S32, F32, F64
  *
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-01-06 00:48:54 $
+ *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -142 +142 @@
     ok(errorFlag== false, "psUnaryOp(): abs was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( abs, C32, -10.0 - 10.0i, 0.0 + 0.0i, 3, 2,10+10i, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): abs was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( exp, S32, 10, 0, 3, 2, exp(10), errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): exp was successful");
@@ -154 +151 @@
     ok(errorFlag== false, "psUnaryOp(): exp was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( exp, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2, cexp(1.0+1.0i), errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): exp was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( ln, S32, 10, 0, 3, 2, clog(10), errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): ln was successful");
@@ -166 +160 @@
     ok(errorFlag== false, "psUnaryOp(): ln was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( ln, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3, 2, clog(10.0+10.0i), errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): ln was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( ten, S32, 3, 0, 3, 2, 1000, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): ten was successful");
@@ -178 +169 @@
     ok(errorFlag== false, "psUnaryOp(): ten was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( ten, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 2, 10.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): ten was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( log, S32, 1000, 0, 3, 2, 3, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): log was successful");
@@ -190 +178 @@
     ok(errorFlag== false, "psUnaryOp(): log was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( log, C32, 1000.0 + 0.0i, 0.0 + 0.0i, 3, 2, 3, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): log was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( sin, S32, M_PI_2, 0, 3, 2, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): sin was successful");
@@ -202 +187 @@
     ok(errorFlag== false, "psUnaryOp(): sin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( sin, C32, M_PI_2 + 0.0i, 0.0 + 0.0i, 3, 2, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): sin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( dsin, S32, 90, 0, 3, 2 , 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dsin was successful");
@@ -214 +196 @@
     ok(errorFlag== false, "psUnaryOp(): dsin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( dsin, C32, 90.0 + 00.0i, 0.0 + 0.0i, 3, 2, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dsin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( cos, S32, 0, 0, 3, 2, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): cos was successful");
@@ -226 +205 @@
     ok(errorFlag== false, "psUnaryOp(): cos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( cos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): cos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( dcos, S32, 0, 0, 3, 2, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dcos was successful");
@@ -238 +214 @@
     ok(errorFlag== false, "psUnaryOp(): dcos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( dcos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dcos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( tan, S32, M_PI_4, 0, 3, 2, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): tan was successful");
@@ -250 +223 @@
     ok(errorFlag== false, "psUnaryOp(): tan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( tan, C32, M_PI_4 + 0.0i, 0.0 + 0.0i, 3, 2, 1, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): tan was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( dtan, S32, 45, 0, 3, 2, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dtan was successful");
@@ -262 +232 @@
     ok(errorFlag== false, "psUnaryOp(): dtan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( dtan, C32, 45.0 + 45.0i, 0.0 + 0.0i, 3, 2, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dtan was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( asin, S32, 1, 0, 3, 2, M_PI_2, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): asin was successful");
@@ -274 +241 @@
     ok(errorFlag== false, "psUnaryOp(): asin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( asin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2, M_PI_2, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): asin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( dasin, S32, 1.0, 0, 3, 2, 90, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dasin was successful");
@@ -286 +250 @@
     ok(errorFlag== false, "psUnaryOp(): dasin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( dasin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 2, 90.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dasin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( acos, S32, 0, 0, 3, 2, M_PI_2, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): acos was successful");
@@ -298 +259 @@
     ok(errorFlag== false, "psUnaryOp(): acos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( acos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, M_PI_2, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): acos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( dacos, S32, 0, 0, 3, 2, 90, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dacos was successful");
@@ -310 +268 @@
     ok(errorFlag== false, "psUnaryOp(): dacos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( dacos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 2, 90.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dacos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( atan, S32, 1, 0, 3, 2, M_PI_4, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): atan was successful");
@@ -322 +277 @@
     ok(errorFlag== false, "psUnaryOp(): atan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( atan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 2, M_PI_4, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): atan was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpM( datan, S32, 1, 0, 3, 2, 45, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): datan was successful");
@@ -334 +286 @@
     ok(errorFlag== false, "psUnaryOp(): datan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpM( datan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 2, 45.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): datan was successful");
-    ok(memoryFlag== false, "no memory leaks");
 
     testUnaryOpV( abs, S32, -10, 0, 3, 10, errorFlag, memoryFlag);
@@ -347 +296 @@
     ok(errorFlag== false, "psUnaryOp(): abs was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( abs, C32, -10.0 - 10.0i, 0.0 + 0.0i, 3, 10+10i, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): abs was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( exp, S32, 10, 0, 3, cexp(10), errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): exp was successful");
@@ -359 +305 @@
     ok(errorFlag== false, "psUnaryOp(): exp was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( exp, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, cexp(1.0+1.0i), errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): exp was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( ln, S32, 10, 0, 3, clog(10), errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): ln was successful");
@@ -371 +314 @@
     ok(errorFlag== false, "psUnaryOp(): ln was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( ln, C32, 10.0 + 10.0i, 0.0 + 0.0i, 3, clog(10.0+10.0i), errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): ln was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( ten, S32, 3, 0, 3, 1000, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): ten was successful");
@@ -383 +323 @@
     ok(errorFlag== false, "psUnaryOp(): ten was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( ten, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 10.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): ten was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( log, S32, 1000, 0, 3,  3, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): log was successful");
@@ -395 +332 @@
     ok(errorFlag== false, "psUnaryOp(): log was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( log, C32, 1000.0 + 0.0i, 0.0 + 0.0i, 3, 3, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): log was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( sin, S32, M_PI_2, 0, 3, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): sin was successful");
@@ -407 +341 @@
     ok(errorFlag== false, "psUnaryOp(): sin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( sin, C32, M_PI_2 + 0.0i, 0.0 + 0.0i, 3, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): sin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( dsin, S32, 90, 0, 3, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dsin was successful");
@@ -419 +350 @@
     ok(errorFlag== false, "psUnaryOp(): dsin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( dsin, C32, 90.0 + 00.0i, 0.0 + 0.0i, 3, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dsin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( cos, S32, 0, 0, 3, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): cos was successful");
@@ -431 +359 @@
     ok(errorFlag== false, "psUnaryOp(): cos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( cos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): cos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( dcos, S32, 0, 0, 3, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dcos was successful");
@@ -443 +368 @@
     ok(errorFlag== false, "psUnaryOp(): dcos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( dcos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dcos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( tan, S32, M_PI_4, 0, 3, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): tan was successful");
@@ -455 +377 @@
     ok(errorFlag== false, "psUnaryOp(): tan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( tan, C32, M_PI_4 + 0.0i, 0.0 + 0.0i, 3, 1, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): tan was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( dtan, S32, 45, 0, 3, 1, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dtan was successful");
@@ -467 +386 @@
     ok(errorFlag== false, "psUnaryOp(): dtan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( dtan, C32, 45.0 + 45.0i, 0.0 + 0.0i, 3, 1.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dtan was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( asin, S32, 1, 0, 3, M_PI_2, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): asin was successful");
@@ -479 +395 @@
     ok(errorFlag== false, "psUnaryOp(): asin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( asin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, M_PI_2, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): asin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( dasin, S32, 1.0, 0, 3, 90, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dasin was successful");
@@ -491 +404 @@
     ok(errorFlag== false, "psUnaryOp(): dasin was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( dasin, C32, 1.0 + 1.0i, 0.0 + 0.0i, 3, 90.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dasin was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( acos, S32, 0, 0, 3, M_PI_2, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): acos was successful");
@@ -503 +413 @@
     ok(errorFlag== false, "psUnaryOp(): acos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( acos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, M_PI_2, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): acos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( dacos, S32, 0, 0, 3, 90, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): dacos was successful");
@@ -515 +422 @@
     ok(errorFlag== false, "psUnaryOp(): dacos was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( dacos, C32, 0.0 + 0.0i, 0.0 + 0.0i, 3, 90.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): dacos was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( atan, S32, 1, 0, 3, M_PI_4, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): atan was successful");
@@ -527 +431 @@
     ok(errorFlag== false, "psUnaryOp(): atan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( atan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, M_PI_4, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): atan was successful");
-    ok(memoryFlag== false, "no memory leaks");
     testUnaryOpV( datan, S32, 1, 0, 3, 45, errorFlag, memoryFlag);
     ok(errorFlag== false, "psUnaryOp(): datan was successful");
@@ -539 +440 @@
     ok(errorFlag== false, "psUnaryOp(): datan was successful");
     ok(memoryFlag== false, "no memory leaks");
-    testUnaryOpV( datan, C32, 1.0 + 0.0i, 0.0 + 0.0i, 3, 45.0, errorFlag, memoryFlag);
-    ok(errorFlag== false, "psUnaryOp(): datan was successful");
-    ok(memoryFlag== false, "no memory leaks");
 
     return 0;

trunk/psLib/test/math/tap_psMatrixVectorArithmetic03.c

@@ -9 +9 @@
  *     Inconsistent dimensionality
  *     Division by zero
- *     Attempt to use min with complex numbers
- *     Attempt to use max with complex numbers
  *     Invalid operation
  *
@@ -17 +15 @@
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-01-06 00:48:54 $
+ *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -56 +54 @@
     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);
@@ -203 +200 @@
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     }
-
-    // Attempt to use min with complex numbers
-    // Following should generate error message
-    if (0) {
-        psMemId id = psMemGetId();
-        psImage* image6 = (psImage*)psBinaryOp(image6, image5, "min", image5);
-        ok(image6 == NULL, "psUnaryOp returned NULL with min of complex numbers");
-        psFree(image6);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
-
-
-    // Attempt to use max with complex numbers
-    // Following should generate an error message
-    if (0) {
-        psMemId id = psMemGetId();
-        psImage* image6 = (psImage*)psBinaryOp(image6, image5, "max", image5);
-        ok(image6 == NULL, "psUnaryOp returned NULL with max of complex numbers");
-        psFree(image6);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
-
 
     // Invalid operation

trunk/psLib/test/mathtypes/tap_psImage.c

@@ -6 +6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-03 01:25:22 $
+ *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -81 +81 @@
     psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64,
                           PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64,
-                          PS_TYPE_F32, PS_TYPE_F64, PS_TYPE_C32, PS_TYPE_C64};
+                          PS_TYPE_F32, PS_TYPE_F64 };
 
     for (psU32 t=0;t<types;t++) {
@@ -200 +200 @@
                     }
                     ok(!errorFlag, "psImageAlloc() set data correctly (F64)");
-                }
-                break;
-            case PS_TYPE_C32: {
-                    psU32 rows = numRows[i];
-                    psU32 cols = numCols[i];
-
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            image->data.C32[r][c] = r + I * c;
-                        }
-                    }
-                    bool errorFlag = false;
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            if(fabsf(crealf(image->data.C32[r][c]) - r) > FLT_EPSILON ||
-                                    fabsf(cimagf(image->data.C32[r][c]) - c) > FLT_EPSILON) {
-                                diag("Set all pixels in complex image at (%d,%d)",c,r);
-                                errorFlag = true;
-                            }
-                        }
-                    }
-                    ok(!errorFlag, "psImageAlloc() set data correctly (C32)");
                 }
                 break;

trunk/psLib/test/mathtypes/tap_psScalar.c

@@ -5 +5 @@
  *  @author Eric Van Alst, MHPCC
  *
- *  @version $Revision: 1.1 $
+ *  @version $Revision: 1.2 $
  *           $Name: not supported by cvs2svn $
- *  @date $Date: 2006-12-18 19:10:56 $
+ *  @date $Date: 2007-03-14 00:39:51 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -77 +77 @@
     tstScalarAllocByType(F32,26);
     tstScalarAllocByType(F64,28);
-    tstScalarAllocByType(C32,30);
-    tstScalarAllocByType(C64,32);
 }
 
@@ -107 +105 @@
     tstScalarCopyByType(F32,180);
     tstScalarCopyByType(F64,190);
-    tstScalarCopyByType(C32,200);
-    tstScalarCopyByType(C64,210);
 }
 

trunk/psLib/test/mathtypes/tap_psVector.c

@@ -279 +279 @@
         psFree(vec);
     }
-
-    // XXX: Looks like the C32 case was removed from psVectorInit().
-    if (0) {
-        psVector *vec = psVectorAlloc(1, PS_TYPE_C32);
-        psC32 vC32 = 1.23 + 1.19I;
-        ok(psVectorInit(vec, vC32), "C32 Case");
-        psFree(vec);
-    }
-
-    // XXX: Looks like the C64 case was removed from psVectorInit().
-    if (0) {
-        psVector *vec = psVectorAlloc(1, PS_TYPE_C64);
-        psC64 vC64 = 2.13 + 2.31I;
-        ok(psVectorInit(vec, vC64), "C64 Case");
-        psFree(vec);
-    }
-
 
 
@@ -455 +438 @@
     TEST_VECTOR_TO_STRING(PS_TYPE_F64,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
 
-    // Must test complex types separately from macro
-
-    // XXX: Looks like the C32 case was removed from psVectorInit().
-    if (0) {
-        psVector *vec = psVectorAlloc(1, PS_TYPE_C32);
-        vec->n = 1;
-        psC32 vC32 = 1.23 + 1.19I;
-        psVectorInit(vec, vC32);
-        psString result = psVectorToString(vec, 100);
-        \
-        psString expected = "[1.23+1.19i]";
-        ok(strcmp(result,expected) == 0,                                   \
-           "psVectorToString expected:result = %s:%s", expected, result );
-        \
-        psFree(vec);
-    }
-
-    // XXX: Looks like the C64 case was removed from psVectorInit().
-    if (0) {
-        psVector *vec = psVectorAlloc(1, PS_TYPE_C64);
-        vec->n = 1;
-        psC64 vC64 = 2.13 + 2.31I;
-        psVectorInit(vec, vC64);
-        psString result = psVectorToString(vec, 100);
-        \
-        psString expected = "[2.13+2.31i]";
-        ok(strcmp(result,expected) == 0,                                   \
-           "psVectorToString expected:result = %s:%s", expected, result );
-        \
-        psFree(vec);
-    }
-
-
-
 
     diag("p_psVectorGetElementF64() tests");
@@ -526 +475 @@
 
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F64,2, psF64, -123.123);
-
-    // Need different test for complex types since NAN returned.
-
-    #define TEST_VECTOR_GET_C_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE,      \
-                                          INIT_VALUE )                                                        \
-    {                                                                       \
-        psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
-        vec->n = SIZE;                                                      \
-        VALUE_TYPE initValue = INIT_VALUE;                                  \
-        psVectorInit(vec, initValue);                                       \
-        psF64 result = p_psVectorGetElementF64(vec, 0);                     \
-        ok(isnan(result),                                                   \
-           "p_psVectorGetElementF64 expected NAN/nan got %f", result);     \
-        \
-        psFree(vec);                                                        \
-    }
-
-    TEST_VECTOR_GET_C_ELEMENT_F64(PS_TYPE_C32,1, psC32, 1.23+1.19I);
-
-    TEST_VECTOR_GET_C_ELEMENT_F64(PS_TYPE_C64,100, psC64, -1.23-1.19I);
-
-
 
 

trunk/psLib/test/sys/tap_psMemory.c

@@ -6 +6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2007-02-06 20:31:57 $
+*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-03-14 00:39:51 $
 *
 *  XXXX: Several tests fail with an Abort and are commented out.
@@ -726 +726 @@
 
     psScalar *scalar;
-    psC64 c64 = 1.1 + 7I;
-    scalar = psScalarAlloc(c64, PS_TYPE_F64);
+    psF64 f64 = 1.1;
+    scalar = psScalarAlloc(f64, PS_TYPE_F64);
     okay = psMemCheckType(PS_DATA_SCALAR, scalar);
     if ( ! okay )

trunk/psLib/test/types/tap_psMetadataConfigFormat.c

@@ -67 +67 @@
         psFree(list);
         psFree(md);
-    }
-
-
-    //Return NULL for attempting to format vector with type = complex
-    {
-        psMemId id = psMemGetId();
-        psVector *vec = psVectorAlloc(60, PS_TYPE_C64);
-        for (int i = 0; i < 5; i++)
-        {
-            vec->data.C64[i] = i+1;
-        }
-        md = psMetadataAlloc();
-        psMetadataAddVector(md, PS_LIST_TAIL, "vectorC64", 0, "", vec);
-        out = psMetadataConfigFormat(md);
-        ok( out == NULL,
-            "psMetadataConfigFormat:         return NULL for metadata containing a "
-            "Complex vector.");
-        psFree(vec);
-        psFree(md);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     }
 

trunk/psLib/test/types/tap_psMetadata_printing.c

@@ -153 +153 @@
         psImageSet(image, 0, 0, 1);
         psMetadataAddImage(md, PS_LIST_TAIL, "image1", 0, "I am an Image", image);
-     
+
         psHash *hash = psHashAlloc(1);
         psHashAdd(hash, "hash", image);
         psMetadataAddHash(md, PS_LIST_TAIL, "hash1", 0, "I am a Hash", hash);
-     
+
         psLookupTable *lookup = psLookupTableAlloc("table2.dat", "%s", 0);
         psMetadataAddLookupTable(md, PS_LIST_TAIL, "lookup", 0, "I am a LookupTable", lookup);
-     
+
         psArray *array = psArrayAlloc(1);
         psArraySet(array, 0, image);
         psMetadataAddArray(md, PS_LIST_TAIL, "array", 0, "I am an Array", array);
-     
+
         psFree(array);
         psFree(lookup);
@@ -230 +230 @@
     psFree(md2);
 
-    //Return false for unsupported vector type (C32)
-    md2 = psMetadataAlloc();
-    psVector *vector = psVectorAlloc(2, PS_TYPE_C32);
-    psMetadataAddVector(md2, PS_LIST_HEAD, "name here", 0, "I vector", vector);
-    {
-        ok ( !psMetadataPrint(NULL, md2, 2),
-             "psMetadataPrint:            return false for metadata with unknown vector-type.");
-    }
-    psFree(vector);
-    psFree(md2);
-
     //Valid case where fd is NULL -> stdout
     md2 = psMetadataAlloc();