IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
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/src/mathtypes
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/mathtypes/psImage.c

    r12381 r12431  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.124 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2007-03-09 20:16:40 $
     11 *  @version $Revision: 1.125 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2007-03-14 00:39:50 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3131#include "psString.h"
    3232
    33 
    34 
    35 #define SQUARE(x) ((x)*(x))
    36 #define MIN(x,y) (((x) > (y)) ? (y) : (x))
    37 #define MAX(x,y) (((x) > (y)) ? (x) : (y))
    3833
    3934static void imageFree(psImage* image)
    … …  
    209204                int x,
    210205                int y,
    211                 double complex value)
     206                double value)
    212207{
    213208    PS_ASSERT_IMAGE_NON_NULL(image, false);
    … …  
    276271        IMAGE_SET_CASE(F32);
    277272        IMAGE_SET_CASE(F64);
    278         IMAGE_SET_CASE(C32);
    279         IMAGE_SET_CASE(C64);
    280273    default:
    281274        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psImage Data Type\n");
    … …  
    286279}
    287280
    288 double complex psImageGet(const psImage *image,
     281double psImageGet(const psImage *image,
    289282                          int x,
    290283                          int y)
    … …  
    354347        IMAGE_GET_CASE(F32);
    355348        IMAGE_GET_CASE(F64);
    356         IMAGE_GET_CASE(C32);
    357         IMAGE_GET_CASE(C64);
    358349    default:
    359350        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psImage Data Type\n");
    … …  
    485476            PSIMAGE_BUFFER_COPY(F64,OUTTYPE); \
    486477            break; \
    487         case PS_TYPE_C32: \
    488             PSIMAGE_BUFFER_COPY(C32,OUTTYPE); \
    489             break; \
    490         case PS_TYPE_C64: \
    491             PSIMAGE_BUFFER_COPY(C64,OUTTYPE); \
    492             break; \
    493478        default: \
    494479            break; \
    … …  
    526511    case PS_TYPE_F64:
    527512        PSIMAGE_BUFFER_COPY_CASE(output, F64);
    528         break;
    529     case PS_TYPE_C32:
    530         PSIMAGE_BUFFER_COPY_CASE(output, C32);
    531         break;
    532     case PS_TYPE_C64:
    533         PSIMAGE_BUFFER_COPY_CASE(output, C64);
    534513        break;
    535514    default: {
    … …  
    593572}
    594573
    595 double complex psImagePixelInterpolate(const psImage* input,
     574double psImagePixelInterpolate(const psImage* input,
    596575                                       float x,
    597576                                       float y,
    598577                                       const psImage* mask,
    599578                                       psMaskType maskVal,
    600                                        double complex unexposedValue,
     579                                       double unexposedValue,
    601580                                       psImageInterpolateMode mode)
    602581{
    … …  
    660639        PSIMAGE_PIXEL_INTERPOLATE_CASE(F32);
    661640        PSIMAGE_PIXEL_INTERPOLATE_CASE(F64);
    662         PSIMAGE_PIXEL_INTERPOLATE_CASE(C32);
    663         PSIMAGE_PIXEL_INTERPOLATE_CASE(C64);
    664641    default: {
    665642            char* typeStr;
    … …  
    729706        float y, \
    730707        const psImage* mask, \
    731         psU32 maskVal, \
     708        psMaskType maskVal, \
    732709        RETURNTYPE unexposedValue) \
    733710{ \
    … …  
    759736PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64)
    760737PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64)
    761 PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64)
    762 PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64)
    763738
    764739#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \
    … …  
    768743        float y, \
    769744        const psImage* mask, \
    770         psU32 maskVal, \
     745        psMaskType maskVal, \
    771746        RETURNTYPE unexposedValue) \
    772747{ \
    773748    int floorX = floor((x) - 0.5); \
    774749    int floorY = floor((y) - 0.5); \
    775     psF64 fracX = x - 0.5 - floorX; \
    776     psF64 fracY = y - 0.5 - floorY; \
    777     psS32 lastX = input->numCols - 1; \
    778     psS32 lastY = input->numRows - 1; \
    779     ps##TYPE V00 = 0; \
    780     ps##TYPE V01 = 0; \
    781     ps##TYPE V10 = 0; \
    782     ps##TYPE V11 = 0; \
    783     bool valid00 = false; \
    784     bool valid01 = false; \
    785     bool valid10 = false; \
    786     bool valid11 = false; \
     750    float fracX = x - 0.5 - floorX; \
     751    float fracY = y - 0.5 - floorY; \
     752    int lastX = input->numCols - 1; \
     753    int lastY = input->numRows - 1; \
     754    ps##TYPE V00; \
     755    ps##TYPE V01; \
     756    ps##TYPE V10; \
     757    ps##TYPE V11; \
     758    bool valid00; \
     759    bool valid01; \
     760    bool valid10; \
     761    bool valid11; \
    787762    \
    788763    if (floorY >= 0 && floorY <= lastY) { \
    … …  
    791766            valid00 = (mask == NULL) || \
    792767                      ((mask->data.PS_TYPE_MASK_DATA[floorY][floorX] & maskVal) == 0); \
     768        } else { \
     769            valid00 = false; \
    793770        } \
    794771        if (floorX >= -1 && floorX < lastX) { \
    … …  
    796773            valid10 = (mask == NULL) || \
    797774                      ((mask->data.PS_TYPE_MASK_DATA[floorY][floorX+1] & maskVal) == 0); \
     775        } else { \
     776            valid10 = false; \
    798777        } \
     778    } else { \
     779        valid00 = false; \
     780        valid10 = false; \
    799781    } \
    800782    if (floorY >= -1 && floorY < lastY) { \
    … …  
    803785            valid01 = (mask == NULL) || \
    804786                      ((mask->data.PS_TYPE_MASK_DATA[floorY+1][floorX] & maskVal) == 0); \
     787        } else { \
     788            valid01 = false; \
    805789        } \
    806790        if (floorX >= -1 && floorX < lastX) { \
    … …  
    808792            valid11 = (mask == NULL) || \
    809793                      ((mask->data.PS_TYPE_MASK_DATA[floorY+1][floorX+1] & maskVal) == 0); \
     794        } else { \
     795            valid11 = false; \
    810796        } \
     797    } else { \
     798        valid01 = false; \
     799        valid11 = false; \
    811800    } \
    812801    \
    … …  
    814803    if (valid00 && valid10 && valid01 && valid11) { \
    815804        /* formula from the ADD */ \
    816         /* XXX this had V01 and V10 exchanged! */ \
    817805        return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \
    818806               V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \
    … …  
    864852        float y, \
    865853        const psImage* mask, \
    866         psU32 maskVal, \
     854        psMaskType maskVal, \
    867855        RETURNTYPE unexposedValue) \
    868856{ \
    … …  
    917905PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,)
    918906PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,)
    919 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,)
    920 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,)
    921907
    922908PSIMAGE_PIXEL_INTERPOLATE_BICUBE(U8,psF64,U8,)
    … …  
    930916PSIMAGE_PIXEL_INTERPOLATE_BICUBE(F32,psF64,F32,)
    931917PSIMAGE_PIXEL_INTERPOLATE_BICUBE(F64,psF64,F64,)
    932 PSIMAGE_PIXEL_INTERPOLATE_BICUBE(C32,psC64,C32,)
    933 PSIMAGE_PIXEL_INTERPOLATE_BICUBE(C64,psC64,C64,)
    934918
    935919// Variance Version
    936 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE)
    937 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE)
    938 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE)
    939 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE)
    940 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE)
    941 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE)
    942 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE)
    943 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE)
    944 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE)
    945 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE)
    946 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE)
    947 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE)
     920PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,PS_SQR)
     921PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,PS_SQR)
     922PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,PS_SQR)
     923PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,PS_SQR)
     924PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,PS_SQR)
     925PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,PS_SQR)
     926PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,PS_SQR)
     927PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,PS_SQR)
     928PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,PS_SQR)
     929PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,PS_SQR)

  • trunk/psLib/src/mathtypes/psImage.h

    r12381 r12431  
    99 * @author Joshua Hoblitt, University of Hawaii
    1010 *
    11  * @version $Revision: 1.89 $ $Name: not supported by cvs2svn $
    12  * @date $Date: 2007-03-09 20:16:40 $
     11 * @version $Revision: 1.90 $ $Name: not supported by cvs2svn $
     12 * @date $Date: 2007-03-14 00:39:51 $
    1313 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1414 */
    … …  
    2020/// @{
    2121
    22 #include <complex.h>
    2322#include <stdio.h>
    2423#include "psType.h"
    … …  
    7069        psF32** F32;                   ///< Single-precision float data.
    7170        psF64** F64;                   ///< Double-precision float data.
    72         psC32** C32;                   ///< Single-precision complex data.
    73         psC64** C64;                   ///< Double-precision complex data.
    7471        psPtr*  V;                     ///< Pointer to data.
    7572    } data;                            ///< Union for data types.
    … …  
    143140bool psImageSet(
    144141    psImage *image,                     ///< the image to set
    145     int x,                             ///< x-position
    146     int y,                             ///< y-position
    147     double complex value               ///< specified value to set
     142    int x,                              ///< x-position
     143    int y,                              ///< y-position
     144    double value                        ///< specified value to set
    148145);
    149146
    … …  
    152149 *  A negative value for the x or y positions means index from the end.
    153150 *
    154  *  @return complex: The value at the specified x,y position.
    155  */
    156 double complex psImageGet(
     151 *  @return double: The value at the specified x,y position.
     152 */
     153double psImageGet(
    157154    const psImage *image,              ///< the image from which to get
    158155    int x,                             ///< x-position
    … …  
    230227/** Interpolate image pixel value given floating point coordinates.
    231228 *
    232  *  @return complex    Pixel value interpolated from image or unexposedValue if
     229 *  @return double    Pixel value interpolated from image or unexposedValue if
    233230 *                   given x,y doesn't coorespond to a valid image location
    234231 */
    235 double complex psImagePixelInterpolate(
     232double psImagePixelInterpolate(
    236233    const psImage* input,              ///< input image for interpolation
    237234    float x,                           ///< column location to derive value of
    … …  
    239236    const psImage* mask,               ///< if not NULL, the mask of the input image
    240237    psMaskType maskVal,                ///< the mask value
    241     double complex unexposedValue,            ///< return value if x,y location is not in image.
     238    double unexposedValue,             ///< return value if x,y location is not in image.
    242239    psImageInterpolateMode mode        ///< interpolation mode
    243240);
    … …  
    250247        float y,                       /**< row location ot derive value of */ \
    251248        const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    252         psU32 maskVal,                 /**< the mask value */ \
     249        psMaskType maskVal,            /**< the mask value */ \
    253250        RETURNTYPE unexposedValue      /**< return value if x,y location is not in image. */ \
    254251                                                   );
    … …  
    264261PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S64,psF64) \
    265262PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F32,psF64) \
    266 PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64) \
    267 PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C32,psC64) \
    268 PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C64,psC64)
     263PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64)
    269264
    270265#ifndef SWIG

  • trunk/psLib/src/mathtypes/psScalar.c

    r11697 r12431  
    88 *  @author Ross Harman, MHPCC
    99 *
    10  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2007-02-08 02:42:46 $
     10 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2007-03-14 00:39:51 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3434                          unsigned int lineno,
    3535                          const char *func,
    36                           double complex value,
     36                          double value,
    3737                          psElemType type)
    3838{
    … …  
    7575    case PS_TYPE_F64:
    7676        scalar->data.F64 = (psF64) value;
    77         break;
    78     case PS_TYPE_C32:
    79         scalar->data.C32 = (psC32) value;
    80         break;
    81     case PS_TYPE_C64:
    82         scalar->data.C64 = (psC64) value;
    8377        break;
    8478    default:
    … …  
    148142        newScalar =  p_psScalarAlloc(file, lineno, func, value->data.F64, dataType);
    149143        break;
    150     case PS_TYPE_C32:
    151         newScalar =  p_psScalarAlloc(file, lineno, func, value->data.C32, dataType);
    152         break;
    153     case PS_TYPE_C64:
    154         newScalar =  p_psScalarAlloc(file, lineno, func, value->data.C64, dataType);
    155         break;
    156144    default:
    157145        psError(PS_ERR_BAD_PARAMETER_TYPE, true,

  • trunk/psLib/src/mathtypes/psScalar.h

    r11697 r12431  
    88 * @author Joshua Hoblitt, University of Hawaii
    99 *
    10  * @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
    11  * @date $Date: 2007-02-08 02:42:46 $
     10 * @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
     11 * @date $Date: 2007-03-14 00:39:51 $
    1212 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1313 */
    … …  
    4141        psF32 F32;              ///< Single-precision float data.
    4242        psF64 F64;              ///< Double-precision float data.
    43         psC32 C32;              ///< Single-precision complex data.
    44         psC64 C64;              ///< Double-precision complex data.
    4543    } data;                     ///< Union for data types.
    4644}
    … …  
    5654 *
    5755 * Uses psLib memory allocation functions to create scalar data as defined by the psType type.
    58  * Accepts a complex 64 bit float for input value, as max size, but resizes according to
    59  * correct type.
     56 * Accepts a double for input value, as max size, but resizes according to correct type.
    6057 *
    6158 * @return psScalar*   Pointer to a new psScalar.
    … …  
    6360#ifdef DOXYGEN
    6461psScalar* psScalarAlloc(
    65     double complex value,               ///< Data to be put into psScalar
     62    double value,                       ///< Data to be put into psScalar
    6663    psElemType type                     ///< Type of data to be held by psScalar
    6764);
    … …  
    7168    unsigned int lineno,                ///< Line number of caller
    7269    const char *func,                   ///< Function name of caller
    73     double complex value,               ///< Data to be put into psScalar
     70    double value,                       ///< Data to be put into psScalar
    7471    psElemType type                     ///< Type of data to be held by psScalar
    7572);

  • trunk/psLib/src/mathtypes/psVector.c

    r12381 r12431  
    1010*  @author Joshua Hoblitt, University of Hawaii
    1111*
    12 *  @version $Revision: 1.95 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2007-03-09 20:16:40 $
     12*  @version $Revision: 1.96 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2007-03-14 00:39:51 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3333#include "psAssert.h"
    3434#include "psString.h"
    35 
    36 typedef struct
    37 {
    38     union {
    39         psU8* U8;                      ///< Unsigned 8-bit integer data.
    40         psU16* U16;                    ///< Unsigned 16-bit integer data.
    41         psU32* U32;                    ///< Unsigned 32-bit integer data.
    42         psU64* U64;                    ///< Unsigned 64-bit integer data.
    43         psS8* S8;                      ///< Signed 8-bit integer data.
    44         psS16* S16;                    ///< Signed 16-bit integer data.
    45         psS32* S32;                    ///< Signed 32-bit integer data.
    46         psS64* S64;                    ///< Signed 64-bit integer data.
    47         psF32* F32;                    ///< Single-precision float data.
    48         psF64* F64;                    ///< Double-precision float data.
    49         psC32* C32;                    ///< Single-precision complex data.
    50         psC64* C64;                    ///< Double-precision complex data.
    51     } data;
    52     psU32 index;
    53 }
    54 indexedVector;
    55 
    56 static void vectorFree(psVector* psVec);
    5735
    5836static void vectorFree(psVector* psVec)
    … …  
    270248            PSVECTOR_COPY_SAME_CASE(F32);
    271249            PSVECTOR_COPY_SAME_CASE(F64);
    272             PSVECTOR_COPY_SAME_CASE(C32);
    273             PSVECTOR_COPY_SAME_CASE(C64);
    274250        default: {
    275251                char* typeStr;
    … …  
    326302            PSVECTOR_COPY(F64,OUTTYPE); \
    327303            break; \
    328         case PS_TYPE_C32: \
    329             PSVECTOR_COPY(C32,OUTTYPE); \
    330             break; \
    331         case PS_TYPE_C64: \
    332             PSVECTOR_COPY(C64,OUTTYPE); \
    333             break; \
    334304        default: { \
    335305                char* typeStr; \
    … …  
    355325        PSVECTOR_COPY_CASE(F32);
    356326        PSVECTOR_COPY_CASE(F64);
    357         PSVECTOR_COPY_CASE(C32);
    358         PSVECTOR_COPY_CASE(C64);
    359327    default: {
    360328            char* typeStr;
    … …  
    560528    break;
    561529
    562     #define APPEND_ELEMENTS_CASE_COMPLEX(TYPE,CREAL,CIMAG) \
    563 case PS_TYPE_##TYPE: \
    564     for (lcv=0; lcv < size && ! full; lcv++) { \
    565         snprintf(tempStr, maxLength, "%s%g%+gi", prefix, \
    566                  CREAL(vector->data.TYPE[lcv]), \
    567                  CIMAG(vector->data.TYPE[lcv])); \
    568         strncat(str,tempStr,maxLength); \
    569         full = (strlen(str) > maxLength-2); \
    570         prefix = ","; \
    571     } \
    572     break;
    573 
    574530    int lcv;
    575531    char* prefix = "[";
    … …  
    585541        APPEND_ELEMENTS_CASE(F32,double,"%g")
    586542        APPEND_ELEMENTS_CASE(F64,double,"%g")
    587         APPEND_ELEMENTS_CASE_COMPLEX(C32,crealf,cimagf)
    588         APPEND_ELEMENTS_CASE_COMPLEX(C64,creal,cimag)
    589543    default:
    590544        snprintf(str,maxLength,"[...]");
    … …  
    822776bool psVectorSet(psVector *input,
    823777                 long position,
    824                  double complex value)
     778                 double value)
    825779{
    826780    if (input == NULL) {
    … …  
    880834        input->data.F64[position] = (psF64)value;
    881835        break;
    882     case PS_TYPE_C32:
    883         input->data.C32[position] = (psC32)value;
    884         break;
    885     case PS_TYPE_C64:
    886         input->data.C64[position] = (psC64)value;
    887         break;
    888836    default:
    889837        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psVector Data Type\n");
    … …  
    894842}
    895843
    896 double complex psVectorGet(const psVector *input,
     844double psVectorGet(const psVector *input,
    897845                           long position)
    898846{
    … …  
    941889    case PS_TYPE_F64:
    942890        return input->data.F64[position];
    943         break;
    944     case PS_TYPE_C32:
    945         return input->data.C32[position];
    946         break;
    947     case PS_TYPE_C64:
    948         return input->data.C64[position];
    949891        break;
    950892    default:
    … …  
    992934    case PS_TYPE_F32:
    993935    case PS_TYPE_F64:
    994     case PS_TYPE_C32:
    995     case PS_TYPE_C64:
    996936    default:
    997937        psError(PS_ERR_BAD_PARAMETER_TYPE, true,

  • trunk/psLib/src/mathtypes/psVector.h

    r12381 r12431  
    1010 * @author Joshua Hoblitt, University of Hawaii
    1111 *
    12  * @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
    13  * @date $Date: 2007-03-09 20:16:40 $
     12 * @version $Revision: 1.67 $ $Name: not supported by cvs2svn $
     13 * @date $Date: 2007-03-14 00:39:51 $
    1414 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1515 */
    … …  
    4545        psF32* F32;                    ///< Single-precision float data.
    4646        psF64* F64;                    ///< Double-precision float data.
    47         psC32* C32;                    ///< Single-precision complex data.
    48         psC64* C64;                    ///< Double-precision complex data.
    4947    } data;
    5048    void *lock;                        ///< Optional lock for thread safety.
    … …  
    227225/** Sort an array of floats.
    228226 *
    229  *  Sorts an array of floats in ascending order.  This function is valid for
    230  *  all non-complex data types.
     227 *  Sorts an array of floats in ascending order.
    231228 *
    232229 *  @return  psVector*     Pointer to sorted psVector.
    … …  
    334331 */
    335332bool psVectorSet(
    336     psVector *input,                   ///< Input vector to set
    337     long position,                     ///< vector position
    338     double complex value               ///< value to set
     333    psVector *input,                    ///< Input vector to set
     334    long position,                      ///< vector position
     335    double value                        ///< value to set
    339336);
    340337
    … …  
    344341 *  A negative position means index from the end.
    345342 *
    346  *  @return complex:        Value of the input vector at the specified position.
    347  */
    348 double complex psVectorGet(
     343 *  @return double:        Value of the input vector at the specified position.
     344 */
     345double psVectorGet(
    349346    const psVector *input,             ///< Input vector from which to get value
    350347    long position                      ///< vector position
Note: See TracChangeset for help on using the changeset viewer.