IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 2, 2004, 1:29:39 PM (22 years ago)
Author:
harman
Message:

Changed psVector to be consistent with psImage

Location:
trunk/psLib/src/dataManip
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/dataManip/psFFT.c

    r827 r831  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-06-02 03:02:48 $
     7 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-06-02 23:29:21 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    448448    numElements = in->n;
    449449
    450     out = psVectorRecycle(out,PS_TYPE_C32,numElements);
     450    out = psVectorRecycle(out, numElements, PS_TYPE_C32);
    451451
    452452    if (type == PS_TYPE_F32) {
    453453        // need to convert to complex
    454         psC32* outVec = out->vec.cf;
    455         psF32* inVec = in->vec.f;
     454        psC32* outVec = out->data.C32;
     455        psF32* inVec = in->data.F32;
    456456        for (unsigned int i=0;i<numElements;i++) {
    457457            outVec[i] = inVec[i];
    458458        }
    459459    } else {
    460         psC32* outVec = out->vec.cf;
    461         psC32* inVec = in->vec.cf;
     460        psC32* outVec = out->data.C32;
     461        psC32* inVec = in->data.C32;
    462462        for (unsigned int i=0;i<numElements;i++) {
    463463            outVec[i] = inVec[i];
    … …  
    466466
    467467    plan = fftwf_plan_dft_1d(numElements,
    468                              (fftwf_complex*)out->vec.cf,
    469                              (fftwf_complex*)out->vec.cf,
     468                             (fftwf_complex*)out->data.C32,
     469                             (fftwf_complex*)out->data.C32,
    470470                             direction,
    471471                             P_FFTW_PLAN_RIGOR);
    … …  
    504504        psLogMsg(__func__,PS_LOG_WARN,"Real portion of a non-Complex type called called for. "
    505505                 "Just a vector copy was performed.");
    506         out = psVectorRecycle(out,type,numElements);
    507         memcpy(out->vec.v,in->vec.v,numElements*PSELEMTYPE_SIZEOF(type));
     506        out = psVectorRecycle(out,numElements,type);
     507        memcpy(out->data.V,in->data.V,numElements*PSELEMTYPE_SIZEOF(type));
    508508        return out;
    509509    }
    … …  
    511511    if (type == PS_TYPE_C32) {
    512512        psF32* outVec;
    513         psC32* inVec = in->vec.cf;
    514 
    515         out = psVectorRecycle(out,PS_TYPE_F32,numElements);
    516         outVec = out->vec.f;
     513        psC32* inVec = in->data.C32;
     514
     515        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
     516        outVec = out->data.F32;
    517517
    518518        for (unsigned int i=0;i<numElements;i++) {
    … …  
    548548                 "A zeroed vector was returned.");
    549549        out = psVectorRecycle(out,numElements,type);
    550         memset(out->vec.v,0,PSELEMTYPE_SIZEOF(type)*numElements);
     550        memset(out->data.V,0,PSELEMTYPE_SIZEOF(type)*numElements);
    551551        return out;
    552552    }
    … …  
    554554    if (type == PS_TYPE_C32) {
    555555        psF32* outVec;
    556         psC32* inVec = in->vec.cf;
    557 
    558         out = psVectorRecycle(out,PS_TYPE_F32,numElements);
    559         outVec = out->vec.f;
     556        psC32* inVec = in->data.C32;
     557
     558        out = psVectorRecycle(out,numElements, PS_TYPE_F32);
     559        outVec = out->data.F32;
    560560
    561561        for (unsigned int i=0;i<numElements;i++) {
    … …  
    601601    if (type == PS_TYPE_F32) {
    602602        psC32* outVec;
    603         psF32* realVec = real->vec.f;
    604         psF32* imagVec = imag->vec.f;
    605 
    606         out = psVectorRecycle(out,PS_TYPE_C32,numElements);
    607         outVec = out->vec.cf;
     603        psF32* realVec = real->data.F32;
     604        psF32* imagVec = imag->data.F32;
     605
     606        out = psVectorRecycle(out,numElements, PS_TYPE_C32);
     607        outVec = out->data.C32;
    608608
    609609        for (unsigned int i=0;i<numElements;i++) {
    … …  
    639639                 "Vector copy was performed instead.");
    640640
    641         out = psVectorRecycle(out,type,numElements);
    642         memcpy(out->vec.v,in->vec.v,PSELEMTYPE_SIZEOF(type)*numElements);
     641        out = psVectorRecycle(out,numElements,type);
     642        memcpy(out->data.V,in->data.V,PSELEMTYPE_SIZEOF(type)*numElements);
    643643        return out;
    644644    }
    … …  
    646646    if (type == PS_TYPE_C32) {
    647647        psC32* outVec;
    648         psC32* inVec = in->vec.cf;
    649 
    650         out = psVectorRecycle(out,PS_TYPE_C32,numElements);
    651         outVec = out->vec.cf;
     648        psC32* inVec = in->data.C32;
     649
     650        out = psVectorRecycle(out,numElements,PS_TYPE_C32);
     651        outVec = out->data.C32;
    652652
    653653        for (unsigned int i=0;i<numElements;i++) {
    … …  
    686686    if (type == PS_TYPE_C32) {
    687687        psF32* outVec;
    688         psC32* inVec = in->vec.cf;
     688        psC32* inVec = in->data.C32;
    689689        psF32 real;
    690690        psF32 imag;
    691691
    692692
    693         out = psVectorRecycle(out,PS_TYPE_F32,numElements);
    694         outVec = out->vec.f;
     693        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
     694        outVec = out->data.F32;
    695695
    696696        for (unsigned int i=0;i<numElements;i++) {

  • trunk/psLib/src/dataManip/psFunctions.c

    r822 r831  
    66 *  @author George Gusciora, MHPCC
    77 *
    8  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2004-06-01 22:24:55 $
     8 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2004-06-02 23:29:21 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    7575    int i = 0;
    7676
    77     gauss = psVectorAlloc(Npts, PS_TYPE_FLOAT);
     77    gauss = psVectorAlloc(Npts, PS_TYPE_F32);
    7878    gsl_rng_env_setup();
    7979    T = gsl_rng_default;
    … …  
    8181
    8282    for (i = 0; i < Npts; i++) {
    83         gauss->vec.f[i] = mean + gsl_ran_gaussian(r, sigma);
     83        gauss->data.F32[i] = mean + gsl_ran_gaussian(r, sigma);
    8484    }
    8585

  • trunk/psLib/src/dataManip/psMatrix.c

    r824 r831  
    2020 *  @author Ross Harman, MHPCC
    2121 *   
    22  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    23  *  @date $Date: 2004-06-01 22:42:57 $
     22 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     23 *  @date $Date: 2004-06-02 23:29:21 $
    2424 *
    2525 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    7070/** Preprocessor macro to generate error a NULL image */
    7171#define PS_CHECK_NULL_VECTOR(NAME, RETURN)                                                          \
    72 if (NAME == NULL || NAME->vec.v == NULL) {                                                          \
     72if (NAME == NULL || NAME->data.V == NULL) {                                                          \
    7373    psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME);                          \
    7474    return RETURN;                                                                                  \
    … …  
    7878#define PS_CHECK_ALLOC_VECTOR(NAME, SIZE, PS_TYPE)                                                  \
    7979if(NAME == NULL) {                                                                                  \
    80     NAME = psVectorAlloc(PS_TYPE, SIZE);                                                            \
     80    NAME = psVectorAlloc(SIZE, PS_TYPE);                                                            \
    8181}
    8282
    … …  
    173173    perm.size = numCols;
    174174    outPerm->n = numCols;
    175     perm.data = outPerm->vec.v;
     175    perm.data = outPerm->data.V;
    176176    PS_GSL_MATRIX_INITIALIZE(lu, outImage->data.V[0]);
    177177
    … …  
    226226
    227227    perm.size = inPerm->n;
    228     perm.data = inPerm->vec.v;
     228    perm.data = inPerm->data.V;
    229229
    230230    b.size = inVector->n;
    231231    b.stride = 1;
    232     b.data = inVector->vec.v;
     232    b.data = inVector->data.V;
    233233
    234234    x.size = numCols;
    235235    x.stride = 1;
    236     x.data = outVector->vec.v;
     236    x.data = outVector->data.V;
    237237
    238238    // Solve for {x} in equation: {b} = [A]{x}
    … …  
    483483
    484484    colSize = PSELEMTYPE_SIZEOF(inImage->type.type)*inImage->numRows;
    485     memcpy(outVector->vec.v, inImage->data.V[0], colSize);
     485    memcpy(outVector->data.V, inImage->data.V[0], colSize);
    486486
    487487    return outVector;
    … …  
    510510
    511511    colSize = PSELEMTYPE_SIZEOF(outImage->type.type)*outImage->numRows;
    512     memcpy(outImage->data.V[0], inVector->vec.v, colSize);
     512    memcpy(outImage->data.V[0], inVector->data.V, colSize);
    513513
    514514    return outImage;

  • trunk/psLib/src/dataManip/psStats.c

    r797 r831  
    8686
    8787    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    88     newHist->bounds = psVectorAlloc(PS_TYPE_FLOAT, n+1);
     88    newHist->bounds = psVectorAlloc(n+1, PS_TYPE_F32);
    8989    binSize = (upper - lower) / (float) n;
    9090    for (i=0;i<n+1;i++) {
    91         newHist->bounds->vec.f[i] = lower + (binSize * (float) i);
    92     }
    93     newHist->nums =  psVectorAlloc(PS_TYPE_INT32, n);
     91        newHist->bounds->data.F32[i] = lower + (binSize * (float) i);
     92    }
     93    newHist->nums =  psVectorAlloc(n, PS_TYPE_S32);
    9494    newHist->minNum = 0;
    9595    newHist->maxNum = 0;
    … …  
    106106
    107107    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    108     newHist->bounds = psVectorAlloc(PS_TYPE_FLOAT, bounds->n);
     108    newHist->bounds = psVectorAlloc(bounds->n, PS_TYPE_F32);
    109109    for (i=0;i<bounds->n;i++) {
    110         newHist->bounds->vec.f[i] = bounds->vec.f[i];
    111     }
    112     newHist->nums = psVectorAlloc(PS_TYPE_INT32, (bounds->n)-1);
     110        newHist->bounds->data.F32[i] = bounds->data.F32[i];
     111    }
     112    newHist->nums = psVectorAlloc((bounds->n)-1, PS_TYPE_S32);
    113113
    114114    newHist->minNum = 0;
    … …  
    152152    for (i=0;i<in->n;i++) {
    153153        // Check if this pixel is masked, and if so, skip it.
    154         if (!(mask->vec.i32[i] & maskVal)) {
     154        if (!(mask->data.S32[i] & maskVal)) {
    155155            // Check if this pixel is below the minimum value, and if so
    156156            // count it, then skip it.
    157             if (in->vec.f[i] < out->bounds->vec.f[0]) {
     157            if (in->data.F32[i] < out->bounds->data.F32[0]) {
    158158                out->minNum++;
    159159
    160160                // Check if this pixel is above the maximum value, and if so
    161161                // count it, then skip it.
    162             } else if (in->vec.f[i] > out->bounds->vec.f[numBins]) {
     162            } else if (in->data.F32[i] > out->bounds->data.F32[numBins]) {
    163163                out->maxNum++;
    164164            } else {
    … …  
    166166                // number is trivial.
    167167                if (out->uniform == true) {
    168                     binSize = out->bounds->vec.f[1] - out->bounds->vec.f[0];
    169 
    170                     binNum = (int) ((in->vec.f[i] - out->bounds->vec.f[0]) /
     168                    binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0];
     169
     170                    binNum = (int) ((in->data.F32[i] - out->bounds->data.F32[0]) /
    171171                                    binSize);
    172                     (out->nums->vec.i32[binNum])++;
     172                    (out->nums->data.S32[binNum])++;
    173173                    // If this is a non-uniform histogram, determining the correct
    174174                    // bin number requires a bit more work.
    … …  
    177177                    // find the correct bin number (bin search, probably)
    178178                    for (j=0;j<(out->bounds->n)-1;j++) {
    179                         if ((out->bounds->vec.i32[j] <= in->vec.f[i]) &&
    180                                 (in->vec.f[i] <= out->bounds->vec.i32[j+1])) {
    181                             (out->nums->vec.i32[j])++;
     179                        if ((out->bounds->data.S32[j] <= in->data.F32[i]) &&
     180                                (in->data.F32[i] <= out->bounds->data.S32[j+1])) {
     181                            (out->nums->data.S32[j])++;
    182182                        }
    183183                    }
    … …  
    198198    for (i=0;i<myVector->n;i++) {
    199199        if (maskVector != NULL)
    200             printf("Element %d is %f (mask is %d)\n", i, myVector->vec.f[i], maskVector->vec.ui8[i]);
     200            printf("Element %d is %f (mask is %d)\n", i, myVector->data.F32[i], maskVector->data.U8[i]);
    201201        else
    202             printf("Element %d is %f\n", i, myVector->vec.f[i]);
     202            printf("Element %d is %f\n", i, myVector->data.F32[i]);
    203203    }
    204204}
    … …  
    234234        if (maskVector != NULL) {
    235235            for (i=0;i<myVector->n;i++) {
    236                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    237                         (rangeMin <= myVector->vec.f[i]) &&
    238                         (myVector->vec.f[i] <= rangeMax)) {
    239                     mean+= myVector->vec.f[i];
     236                if (!(maskVal & maskVector->data.U8[i]) &&
     237                        (rangeMin <= myVector->data.F32[i]) &&
     238                        (myVector->data.F32[i] <= rangeMax)) {
     239                    mean+= myVector->data.F32[i];
    240240                    count++;
    241241                }
    … …  
    244244        } else {
    245245            for (i=0;i<myVector->n;i++) {
    246                 if ((rangeMin <= myVector->vec.f[i]) &&
    247                         (myVector->vec.f[i] <= rangeMax)) {
    248                     mean+= myVector->vec.f[i];
     246                if ((rangeMin <= myVector->data.F32[i]) &&
     247                        (myVector->data.F32[i] <= rangeMax)) {
     248                    mean+= myVector->data.F32[i];
    249249                    count++;
    250250                }
    … …  
    255255        if (maskVector != NULL) {
    256256            for (i=0;i<myVector->n;i++) {
    257                 if (!(maskVal & maskVector->vec.ui8[i])) {
    258                     mean+= myVector->vec.f[i];
     257                if (!(maskVal & maskVector->data.U8[i])) {
     258                    mean+= myVector->data.F32[i];
    259259                    count++;
    260260                }
    … …  
    263263        } else {
    264264            for (i=0;i<myVector->n;i++) {
    265                 mean+= myVector->vec.f[i];
     265                mean+= myVector->data.F32[i];
    266266            }
    267267            mean/= (float) myVector->n;
    … …  
    287287        if (maskVector != NULL) {
    288288            for (i=0;i<myVector->n;i++) {
    289                 if (!(maskVal & maskVector->vec.ui8[i])) {
    290                     if ((myVector->vec.f[i] > max) &&
    291                             (rangeMin <= myVector->vec.f[i]) &&
    292                             (myVector->vec.f[i] <= rangeMax)) {
    293                         max = myVector->vec.f[i];
     289                if (!(maskVal & maskVector->data.U8[i])) {
     290                    if ((myVector->data.F32[i] > max) &&
     291                            (rangeMin <= myVector->data.F32[i]) &&
     292                            (myVector->data.F32[i] <= rangeMax)) {
     293                        max = myVector->data.F32[i];
    294294                    }
    295295                }
    … …  
    297297        } else {
    298298            for (i=0;i<myVector->n;i++) {
    299                 if ((myVector->vec.f[i] > max) &&
    300                         (rangeMin <= myVector->vec.f[i]) &&
    301                         (myVector->vec.f[i] <= rangeMax)) {
    302                     max = myVector->vec.f[i];
     299                if ((myVector->data.F32[i] > max) &&
     300                        (rangeMin <= myVector->data.F32[i]) &&
     301                        (myVector->data.F32[i] <= rangeMax)) {
     302                    max = myVector->data.F32[i];
    303303                }
    304304            }
    … …  
    307307        if (maskVector != NULL) {
    308308            for (i=0;i<myVector->n;i++) {
    309                 if (!(maskVal & maskVector->vec.ui8[i])) {
    310                     if (myVector->vec.f[i] > max) {
    311                         max = myVector->vec.f[i];
     309                if (!(maskVal & maskVector->data.U8[i])) {
     310                    if (myVector->data.F32[i] > max) {
     311                        max = myVector->data.F32[i];
    312312                    }
    313313                }
    … …  
    315315        } else {
    316316            for (i=0;i<myVector->n;i++) {
    317                 if (myVector->vec.f[i] > max) {
    318                     max = myVector->vec.f[i];
     317                if (myVector->data.F32[i] > max) {
     318                    max = myVector->data.F32[i];
    319319                }
    320320            }
    … …  
    340340        if (maskVector != NULL) {
    341341            for (i=0;i<myVector->n;i++) {
    342                 if (!(maskVal & maskVector->vec.ui8[i])) {
    343                     if ((myVector->vec.f[i] < min) &&
    344                             (rangeMin <= myVector->vec.f[i]) &&
    345                             (myVector->vec.f[i] <= rangeMax)) {
    346                         min = myVector->vec.f[i];
     342                if (!(maskVal & maskVector->data.U8[i])) {
     343                    if ((myVector->data.F32[i] < min) &&
     344                            (rangeMin <= myVector->data.F32[i]) &&
     345                            (myVector->data.F32[i] <= rangeMax)) {
     346                        min = myVector->data.F32[i];
    347347                    }
    348348                }
    … …  
    350350        } else {
    351351            for (i=0;i<myVector->n;i++) {
    352                 if ((myVector->vec.f[i] < min) &&
    353                         (rangeMin <= myVector->vec.f[i]) &&
    354                         (myVector->vec.f[i] <= rangeMax)) {
    355                     min = myVector->vec.f[i];
     352                if ((myVector->data.F32[i] < min) &&
     353                        (rangeMin <= myVector->data.F32[i]) &&
     354                        (myVector->data.F32[i] <= rangeMax)) {
     355                    min = myVector->data.F32[i];
    356356                }
    357357            }
    … …  
    360360        if (maskVector != NULL) {
    361361            for (i=0;i<myVector->n;i++) {
    362                 if (!(maskVal & maskVector->vec.ui8[i])) {
    363                     if (myVector->vec.f[i] < min) {
    364                         min = myVector->vec.f[i];
     362                if (!(maskVal & maskVector->data.U8[i])) {
     363                    if (myVector->data.F32[i] < min) {
     364                        min = myVector->data.F32[i];
    365365                    }
    366366                }
    … …  
    368368        } else {
    369369            for (i=0;i<myVector->n;i++) {
    370                 if (myVector->vec.f[i] < min) {
    371                     min = myVector->vec.f[i];
     370                if (myVector->data.F32[i] < min) {
     371                    min = myVector->data.F32[i];
    372372                }
    373373            }
    … …  
    397397        if (maskVector != NULL) {
    398398            for (i=0;i<myVector->n;i++) {
    399                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    400                         (rangeMin <= myVector->vec.f[i]) &&
    401                         (myVector->vec.f[i] <= rangeMax)) {
     399                if (!(maskVal & maskVector->data.U8[i]) &&
     400                        (rangeMin <= myVector->data.F32[i]) &&
     401                        (myVector->data.F32[i] <= rangeMax)) {
    402402                    numData++;
    403403                }
    … …  
    405405        } else {
    406406            for (i=0;i<myVector->n;i++) {
    407                 if ((rangeMin <= myVector->vec.f[i]) &&
    408                         (myVector->vec.f[i] <= rangeMax)) {
     407                if ((rangeMin <= myVector->data.F32[i]) &&
     408                        (myVector->data.F32[i] <= rangeMax)) {
    409409                    numData++;
    410410                }
    … …  
    416416        if (maskVector != NULL) {
    417417            for (i=0;i<myVector->n;i++) {
    418                 if (!(maskVal & maskVector->vec.ui8[i])) {
     418                if (!(maskVal & maskVector->data.U8[i])) {
    419419                    numData++;
    420420                }
    … …  
    469469
    470470    // Allocate temporary vectors for the data.
    471     unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     471    unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
    472472    unsortedVector->n = unsortedVector->nalloc;
    473     sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     473    sortedVector   = psVectorAlloc(nValues, PS_TYPE_F32);
    474474    sortedVector->n = sortedVector->nalloc;
    475475
    … …  
    484484        if (maskVector != NULL) {
    485485            for (i=0;i<myVector->n;i++) {
    486                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    487                         (rangeMin <= myVector->vec.f[i]) &&
    488                         (myVector->vec.f[i] <= rangeMax)) {
    489                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    490                 }
    491             }
    492         } else {
    493             for (i=0;i<myVector->n;i++) {
    494                 if ((rangeMin <= myVector->vec.f[i]) &&
    495                         (myVector->vec.f[i] <= rangeMax)) {
    496                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
     486                if (!(maskVal & maskVector->data.U8[i]) &&
     487                        (rangeMin <= myVector->data.F32[i]) &&
     488                        (myVector->data.F32[i] <= rangeMax)) {
     489                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     490                }
     491            }
     492        } else {
     493            for (i=0;i<myVector->n;i++) {
     494                if ((rangeMin <= myVector->data.F32[i]) &&
     495                        (myVector->data.F32[i] <= rangeMax)) {
     496                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
    497497                }
    498498            }
    … …  
    503503        if (maskVector != NULL) {
    504504            for (i=0;i<myVector->n;i++) {
    505                 if (!(maskVal & maskVector->vec.ui8[i])) {
    506                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    507                 }
    508             }
    509         } else {
    510             for (i=0;i<myVector->n;i++) {
    511                 unsortedVector->vec.f[i] = maskVector->vec.f[i];
     505                if (!(maskVal & maskVector->data.U8[i])) {
     506                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     507                }
     508            }
     509        } else {
     510            for (i=0;i<myVector->n;i++) {
     511                unsortedVector->data.F32[i] = maskVector->data.F32[i];
    512512            }
    513513        }
    … …  
    518518    // Calculate the median exactly.
    519519    if (0 == (nValues % 2)) {
    520         stats->sampleMedian = 0.5 * (sortedVector->vec.f[(nValues/2)-1] +
    521                                      sortedVector->vec.f[nValues/2]);
     520        stats->sampleMedian = 0.5 * (sortedVector->data.F32[(nValues/2)-1] +
     521                                     sortedVector->data.F32[nValues/2]);
    522522    } else {
    523         stats->sampleMedian = sortedVector->vec.f[nValues/2];
     523        stats->sampleMedian = sortedVector->data.F32[nValues/2];
    524524    }
    525525
    … …  
    569569        for (j=-GAUSS_WIDTH;j<=+GAUSS_WIDTH;j++) {
    570570            if (((j+i) >= 0) && ((j+i) < robustHistogram->nums->n)) {
    571                 robustHistogram->nums->vec.i32[j+i]+=
     571                robustHistogram->nums->data.S32[j+i]+=
    572572                    (gaussianCoefs[j+GAUSS_WIDTH] *
    573                      (float) robustHistogram->nums->vec.i32[j+i]);
     573                     (float) robustHistogram->nums->data.S32[j+i]);
    574574            }
    575575        }
    … …  
    623623
    624624    // Allocate temporary vectors for the data.
    625     unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     625    unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
    626626    unsortedVector->n = unsortedVector->nalloc;
    627     sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, nValues);
     627    sortedVector   = psVectorAlloc(nValues, PS_TYPE_F32);
    628628    sortedVector->n = sortedVector->nalloc;
    629629
    … …  
    637637        if (maskVector != NULL) {
    638638            for (i=0;i<myVector->n;i++) {
    639                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    640                         (rangeMin <= myVector->vec.f[i]) &&
    641                         (myVector->vec.f[i] <= rangeMax)) {
    642                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    643                 }
    644             }
    645         } else {
    646             for (i=0;i<myVector->n;i++) {
    647                 if ((rangeMin <= myVector->vec.f[i]) &&
    648                         (myVector->vec.f[i] <= rangeMax)) {
    649                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
     639                if (!(maskVal & maskVector->data.U8[i]) &&
     640                        (rangeMin <= myVector->data.F32[i]) &&
     641                        (myVector->data.F32[i] <= rangeMax)) {
     642                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     643                }
     644            }
     645        } else {
     646            for (i=0;i<myVector->n;i++) {
     647                if ((rangeMin <= myVector->data.F32[i]) &&
     648                        (myVector->data.F32[i] <= rangeMax)) {
     649                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
    650650                }
    651651            }
    … …  
    656656        if (maskVector != NULL) {
    657657            for (i=0;i<myVector->n;i++) {
    658                 if (!(maskVal & maskVector->vec.ui8[i])) {
    659                     unsortedVector->vec.f[count++] = maskVector->vec.f[i];
    660                 }
    661             }
    662         } else {
    663             for (i=0;i<myVector->n;i++) {
    664                 unsortedVector->vec.f[i] = maskVector->vec.f[i];
     658                if (!(maskVal & maskVector->data.U8[i])) {
     659                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
     660                }
     661            }
     662        } else {
     663            for (i=0;i<myVector->n;i++) {
     664                unsortedVector->data.F32[i] = maskVector->data.F32[i];
    665665            }
    666666        }
    … …  
    672672    // Calculate the quartile points exactly.
    673673    ind = 3 * (nValues / 4);
    674     stats->sampleUQ = sortedVector->vec.f[ind];
     674    stats->sampleUQ = sortedVector->data.F32[ind];
    675675    ind = (nValues / 4);
    676     stats->sampleLQ = sortedVector->vec.f[ind];
     676    stats->sampleLQ = sortedVector->data.F32[ind];
    677677
    678678    // Free the temporary data structures.
    … …  
    765765    UQBinNum = -1;
    766766    for (i=0;i<robustHistogram->nums->n;i++) {
    767         if ((robustHistogram->nums->vec.i32[i] <= stats->sampleLQ) &&
    768                 (stats->sampleLQ <= robustHistogram->nums->vec.i32[i])) {
     767        if ((robustHistogram->nums->data.S32[i] <= stats->sampleLQ) &&
     768                (stats->sampleLQ <= robustHistogram->nums->data.S32[i])) {
    769769            LQBinNum = i;
    770770        }
    771771
    772         if ((robustHistogram->nums->vec.i32[i] <= stats->sampleUQ) &&
    773                 (stats->sampleUQ <= robustHistogram->nums->vec.i32[i])) {
     772        if ((robustHistogram->nums->data.S32[i] <= stats->sampleUQ) &&
     773                (stats->sampleUQ <= robustHistogram->nums->data.S32[i])) {
    774774            UQBinNum = i;
    775775        }
    … …  
    778778    // Determine the bin with the peak value in the range LQ to UQ.
    779779    maxBinNum = LQBinNum;
    780     maxBinCount = robustHistogram->nums->vec.i32[maxBinNum];
     780    maxBinCount = robustHistogram->nums->data.S32[maxBinNum];
    781781    for (i=LQBinNum;i<=UQBinNum;i++) {
    782         if (robustHistogram->nums->vec.i32[i] > maxBinCount) {
     782        if (robustHistogram->nums->data.S32[i] > maxBinCount) {
    783783            maxBinNum = i;
    784             maxBinCount = robustHistogram->nums->vec.i32[i];
     784            maxBinCount = robustHistogram->nums->data.S32[i];
    785785        }
    786786    }
    … …  
    843843        if (maskVector != NULL) {
    844844            for (i=0;i<myVector->n;i++) {
    845                 if (!(maskVal & maskVector->vec.ui8[i]) &&
    846                         (rangeMin <= myVector->vec.f[i]) &&
    847                         (myVector->vec.f[i] <= rangeMax)) {
    848                     diff = myVector->vec.f[i] - mean;
     845                if (!(maskVal & maskVector->data.U8[i]) &&
     846                        (rangeMin <= myVector->data.F32[i]) &&
     847                        (myVector->data.F32[i] <= rangeMax)) {
     848                    diff = myVector->data.F32[i] - mean;
    849849                    sumSquares+= (diff * diff);
    850850                    sumDiffs+= diff;
    … …  
    854854        } else {
    855855            for (i=0;i<myVector->n;i++) {
    856                 if ((rangeMin <= myVector->vec.f[i]) &&
    857                         (myVector->vec.f[i] <= rangeMax)) {
    858                     diff = myVector->vec.f[i] - mean;
     856                if ((rangeMin <= myVector->data.F32[i]) &&
     857                        (myVector->data.F32[i] <= rangeMax)) {
     858                    diff = myVector->data.F32[i] - mean;
    859859                    sumSquares+= (diff * diff);
    860860                    sumDiffs+= diff;
    … …  
    867867        if (maskVector != NULL) {
    868868            for (i=0;i<myVector->n;i++) {
    869                 if (!(maskVal & maskVector->vec.ui8[i])) {
    870                     diff = myVector->vec.f[i] - mean;
     869                if (!(maskVal & maskVector->data.U8[i])) {
     870                    diff = myVector->data.F32[i] - mean;
    871871                    sumSquares+= (diff * diff);
    872872                    sumDiffs+= diff;
    … …  
    876876        } else {
    877877            for (i=0;i<myVector->n;i++) {
    878                 diff = myVector->vec.f[i] - mean;
     878                diff = myVector->data.F32[i] - mean;
    879879                sumSquares+= (diff * diff);
    880880                sumDiffs+= diff;
    … …  
    920920    }
    921921
    922     tmpMask = psVectorAlloc(maskVector->type.type, myVector->nalloc);
     922    tmpMask = psVectorAlloc(myVector->nalloc, maskVector->type.type);
    923923
    924924    tmpMask->n = maskVector->n;
    925925    for (i=0;i<tmpMask->n;i++) {
    926         tmpMask->vec.ui8[i] = maskVector->vec.ui8[i];
     926        tmpMask->data.U8[i] = maskVector->data.U8[i];
    927927    }
    928928
    … …  
    944944        for (j=0;j<myVector->n;j++) {
    945945            // a) Exclude all values x_i for which |x_i - x| > K * stdev
    946             if ( fabs(myVector->vec.f[j] - clippedMean) >
     946            if ( fabs(myVector->data.F32[j] - clippedMean) >
    947947                    (stats->clipSigma * clippedStdev)) {
    948                 tmpMask->vec.ui8[i] = 0xff;
     948                tmpMask->data.U8[i] = 0xff;
    949949            }
    950950            // b) compute new mean and stdev
    … …  
    979979 
    980980    NOTE: The current strategy is to implement everything assuming that all
    981     input data is of type PS_TYPE_FLOAT.  Once the basic code is in place,
    982     we will macro-ize everything and add PS_TYPE_UINT16 and PS_TYPE_DOUBLE.
     981    input data is of type PS_TYPE_F32.  Once the basic code is in place,
     982    we will macro-ize everything and add PS_TYPE_U16 and PS_TYPE_F64.
    983983 
    984984 *****************************************************************************/
    … …  
    992992    }
    993993
    994     if (in->type.type != PS_TYPE_FLOAT) {
     994    if (in->type.type != PS_TYPE_F32) {
    995995        psAbort(__func__,
    996                 "Only data type PS_TYPE_FLOAT is currently supported.");
     996                "Only data type PS_TYPE_F32 is currently supported.");
    997997    }
    998998    if (mask != NULL) {
    … …  
    10011001                    "Vector data and vector mask are of different sizes.");
    10021002        }
    1003         if (mask->type.type != PS_TYPE_UINT8) {
     1003        if (mask->type.type != PS_TYPE_U8) {
    10041004            psAbort(__func__,
    1005                     "Vector mask must be type PS_TYPE_UINT8");
     1005                    "Vector mask must be type PS_TYPE_U8");
    10061006        }
    10071007    }

  • trunk/psLib/src/dataManip/psVectorFFT.c

    r827 r831  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2004-06-02 03:02:48 $
     7 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2004-06-02 23:29:21 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    448448    numElements = in->n;
    449449
    450     out = psVectorRecycle(out,PS_TYPE_C32,numElements);
     450    out = psVectorRecycle(out, numElements, PS_TYPE_C32);
    451451
    452452    if (type == PS_TYPE_F32) {
    453453        // need to convert to complex
    454         psC32* outVec = out->vec.cf;
    455         psF32* inVec = in->vec.f;
     454        psC32* outVec = out->data.C32;
     455        psF32* inVec = in->data.F32;
    456456        for (unsigned int i=0;i<numElements;i++) {
    457457            outVec[i] = inVec[i];
    458458        }
    459459    } else {
    460         psC32* outVec = out->vec.cf;
    461         psC32* inVec = in->vec.cf;
     460        psC32* outVec = out->data.C32;
     461        psC32* inVec = in->data.C32;
    462462        for (unsigned int i=0;i<numElements;i++) {
    463463            outVec[i] = inVec[i];
    … …  
    466466
    467467    plan = fftwf_plan_dft_1d(numElements,
    468                              (fftwf_complex*)out->vec.cf,
    469                              (fftwf_complex*)out->vec.cf,
     468                             (fftwf_complex*)out->data.C32,
     469                             (fftwf_complex*)out->data.C32,
    470470                             direction,
    471471                             P_FFTW_PLAN_RIGOR);
    … …  
    504504        psLogMsg(__func__,PS_LOG_WARN,"Real portion of a non-Complex type called called for. "
    505505                 "Just a vector copy was performed.");
    506         out = psVectorRecycle(out,type,numElements);
    507         memcpy(out->vec.v,in->vec.v,numElements*PSELEMTYPE_SIZEOF(type));
     506        out = psVectorRecycle(out,numElements,type);
     507        memcpy(out->data.V,in->data.V,numElements*PSELEMTYPE_SIZEOF(type));
    508508        return out;
    509509    }
    … …  
    511511    if (type == PS_TYPE_C32) {
    512512        psF32* outVec;
    513         psC32* inVec = in->vec.cf;
    514 
    515         out = psVectorRecycle(out,PS_TYPE_F32,numElements);
    516         outVec = out->vec.f;
     513        psC32* inVec = in->data.C32;
     514
     515        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
     516        outVec = out->data.F32;
    517517
    518518        for (unsigned int i=0;i<numElements;i++) {
    … …  
    548548                 "A zeroed vector was returned.");
    549549        out = psVectorRecycle(out,numElements,type);
    550         memset(out->vec.v,0,PSELEMTYPE_SIZEOF(type)*numElements);
     550        memset(out->data.V,0,PSELEMTYPE_SIZEOF(type)*numElements);
    551551        return out;
    552552    }
    … …  
    554554    if (type == PS_TYPE_C32) {
    555555        psF32* outVec;
    556         psC32* inVec = in->vec.cf;
    557 
    558         out = psVectorRecycle(out,PS_TYPE_F32,numElements);
    559         outVec = out->vec.f;
     556        psC32* inVec = in->data.C32;
     557
     558        out = psVectorRecycle(out,numElements, PS_TYPE_F32);
     559        outVec = out->data.F32;
    560560
    561561        for (unsigned int i=0;i<numElements;i++) {
    … …  
    601601    if (type == PS_TYPE_F32) {
    602602        psC32* outVec;
    603         psF32* realVec = real->vec.f;
    604         psF32* imagVec = imag->vec.f;
    605 
    606         out = psVectorRecycle(out,PS_TYPE_C32,numElements);
    607         outVec = out->vec.cf;
     603        psF32* realVec = real->data.F32;
     604        psF32* imagVec = imag->data.F32;
     605
     606        out = psVectorRecycle(out,numElements, PS_TYPE_C32);
     607        outVec = out->data.C32;
    608608
    609609        for (unsigned int i=0;i<numElements;i++) {
    … …  
    639639                 "Vector copy was performed instead.");
    640640
    641         out = psVectorRecycle(out,type,numElements);
    642         memcpy(out->vec.v,in->vec.v,PSELEMTYPE_SIZEOF(type)*numElements);
     641        out = psVectorRecycle(out,numElements,type);
     642        memcpy(out->data.V,in->data.V,PSELEMTYPE_SIZEOF(type)*numElements);
    643643        return out;
    644644    }
    … …  
    646646    if (type == PS_TYPE_C32) {
    647647        psC32* outVec;
    648         psC32* inVec = in->vec.cf;
    649 
    650         out = psVectorRecycle(out,PS_TYPE_C32,numElements);
    651         outVec = out->vec.cf;
     648        psC32* inVec = in->data.C32;
     649
     650        out = psVectorRecycle(out,numElements,PS_TYPE_C32);
     651        outVec = out->data.C32;
    652652
    653653        for (unsigned int i=0;i<numElements;i++) {
    … …  
    686686    if (type == PS_TYPE_C32) {
    687687        psF32* outVec;
    688         psC32* inVec = in->vec.cf;
     688        psC32* inVec = in->data.C32;
    689689        psF32 real;
    690690        psF32 imag;
    691691
    692692
    693         out = psVectorRecycle(out,PS_TYPE_F32,numElements);
    694         outVec = out->vec.f;
     693        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
     694        outVec = out->data.F32;
    695695
    696696        for (unsigned int i=0;i<numElements;i++) {
Note: See TracChangeset for help on using the changeset viewer.