IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2782


Ignore:
Timestamp:
Dec 21, 2004, 2:54:28 PM (22 years ago)
Author:
gusciora
Message:

Modified histogram->nums to be of type F32, not U32.

Location:
trunk/psLib
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r2780 r2782  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.106 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-12-21 23:25:14 $
     11 *  @version $Revision: 1.107 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-12-22 00:54:28 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    682682                    robustHistogram->bounds->data.F32[j+1]) / 2.0;
    683683            smooth->data.F32[i] +=
    684                 ((float) robustHistogram->nums->data.U32[j]) *
     684                robustHistogram->nums->data.F32[j] *
    685685                psGaussian(jMid, iMid, sigma, true);
    686686        }
    … …  
    15631563    modeBinNum = LQBinNum;
    15641564    modeBinCount = robustHistogramVector->data.F32[LQBinNum];
    1565     sumN50 = (float)robustHistogram->nums->data.U32[LQBinNum];
     1565    sumN50 = robustHistogram->nums->data.F32[LQBinNum];
    15661566    for (i = LQBinNum + 1; i <= UQBinNum; i++) {
    15671567        if (robustHistogramVector->data.F32[i] > modeBinCount) {
    … …  
    15691569            modeBinCount = robustHistogramVector->data.F32[i];
    15701570        }
    1571         sumN50 += (float)robustHistogram->nums->data.U32[i];
     1571        sumN50 += robustHistogram->nums->data.F32[i];
    15721572    }
    15731573
    … …  
    15871587        }
    15881588
    1589         sumNfit += (float)robustHistogram->nums->data.U32[i];
     1589        sumNfit += robustHistogram->nums->data.F32[i];
    15901590    }
    15911591    // XXX: divide by zero?
    … …  
    17961796
    17971797    // Allocate the bins, and initialize them to zero.
    1798     newHist->nums = psVectorAlloc(n, PS_TYPE_U32);
    1799     newHist->nums->n = newHist->nums->nalloc;
     1798    newHist->nums = psVectorAlloc(n, PS_TYPE_F32);
    18001799    for (i = 0; i < newHist->nums->n; i++) {
    1801         newHist->nums->data.U32[i] = 0;
     1800        newHist->nums->data.F32[i] = 0.0;
    18021801    }
    18031802
    … …  
    18391838    // Allocate the bins, and initialize them to zero.  If there are N bounds,
    18401839    // then there are N-1 bins.
    1841     newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_U32);
    1842     newHist->nums->n = newHist->nums->nalloc;
     1840    newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_F32);
    18431841    for (i = 0; i < newHist->nums->n; i++) {
    1844         newHist->nums->data.U32[i] = 0;
     1842        newHist->nums->data.F32[i] = 0.0;
    18451843    }
    18461844
    … …  
    18581856    psFree(myHist->nums);
    18591857}
     1858
     1859psS32 UpdateHistogramBins(psS32 binNum,
     1860                          psHistogram* out,
     1861                          psF32 data,
     1862                          psF32 error)
     1863{
     1864    PS_PTR_CHECK_NULL(out, -1);
     1865    PS_INT_CHECK_RANGE(binNum, 0, out->nums->n-1, -2);
     1866    /*
     1867        psF32 width = 2.35 * error;
     1868        psF32 centerBinWidth = out->bounds->data.F32[binNum+1] - out->bounds->data.F32[binNum]
     1869        psF32 boxcarCenter = (out->bounds->data.F32[binNum] + out->bounds->data.F32[binNum+1]) / 2.0;
     1870     
     1871        if (width <= centerBinWidth) {
     1872            out->nums->data.F32[binNum]+= 1.0;
     1873        } else {
     1874            out->nums->data.F32[binNum]+= centerBinWidth / width;
     1875            // XXX: walk to the left, adding fractional values.
     1876            // XXX: walk to the right, adding fractional values.
     1877     
     1878     
     1879        }
     1880    */
     1881    return(0);
     1882}
     1883
    18601884
    18611885/*****************************************************************************
    … …  
    18831907    PS_PTR_CHECK_NULL(out, NULL);
    18841908    PS_VECTOR_CHECK_TYPE(out->bounds, PS_TYPE_F32, NULL);
    1885     PS_VECTOR_CHECK_TYPE(out->nums, PS_TYPE_U32, NULL);
     1909    PS_VECTOR_CHECK_TYPE(out->nums, PS_TYPE_F32, NULL);
    18861910    PS_INT_CHECK_NON_NEGATIVE(out->nums->n, NULL);
    18871911    PS_VECTOR_CHECK_NULL(in, out);
    … …  
    19131937    for (i = 0; i < inF32->n; i++) {
    19141938        // Check if this pixel is masked, and if so, skip it.
    1915         if ((mask == NULL) ||
    1916                 ((mask != NULL) && (!(mask->data.U8[i] & maskVal)))) {
     1939        if ((mask == NULL) || ((mask != NULL) && (!(mask->data.U8[i] & maskVal)))) {
    19171940            if (inF32->data.F32[i] < out->bounds->data.F32[0]) {
    19181941                // If this pixel is below minimum value, count it, then skip.
    … …  
    19271950                    binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0];
    19281951                    binNum = (psS32)((inF32->data.F32[i] - out->bounds->data.F32[0]) / binSize);
    1929 
    1930                     // XXX: This if-statement really shouldn't be necessary.
    1931                     // However, due to numerical lack of precision, we
    1932                     // occasionally produce a binNum outside the range.
    1933                     if (binNum >= out->nums->n) {
    1934                         binNum = out->nums->n - 1;
     1952                    if (errors != NULL) {
     1953                        // XXX: Check return codes.
     1954                        UpdateHistogramBins(binNum, out,
     1955                                            inF32->data.F32[i],
     1956                                            errors->data.F32[i]);
     1957                    } else {
     1958                        // XXX: This if-statement really shouldn't be necessary.
     1959                        // However, due to numerical lack of precision, we
     1960                        // occasionally produce a binNum outside the range.
     1961                        if (binNum >= out->nums->n) {
     1962                            binNum = out->nums->n - 1;
     1963                        }
     1964                        (out->nums->data.F32[binNum])+= 1.0;
    19351965                    }
    1936 
    1937                     (out->nums->data.U32[binNum])++;
    19381966
    19391967                } else {
    … …  
    19461974                                 "WARNING: psVectorHistogram(): element outside histogram bounds.\n");
    19471975                    } else {
    1948                         (out->nums->data.U32[tmp])++;
     1976                        if (errors != NULL) {
     1977                            // XXX: Check return codes.
     1978                            UpdateHistogramBins(tmp, out,
     1979                                                inF32->data.F32[i],
     1980                                                errors->data.F32[i]);
     1981                        } else {
     1982                            (out->nums->data.F32[tmp])+= 1.0;
     1983                        }
    19491984                    }
    19501985                }

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

    r2780 r2782  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.106 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-12-21 23:25:14 $
     11 *  @version $Revision: 1.107 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-12-22 00:54:28 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    682682                    robustHistogram->bounds->data.F32[j+1]) / 2.0;
    683683            smooth->data.F32[i] +=
    684                 ((float) robustHistogram->nums->data.U32[j]) *
     684                robustHistogram->nums->data.F32[j] *
    685685                psGaussian(jMid, iMid, sigma, true);
    686686        }
    … …  
    15631563    modeBinNum = LQBinNum;
    15641564    modeBinCount = robustHistogramVector->data.F32[LQBinNum];
    1565     sumN50 = (float)robustHistogram->nums->data.U32[LQBinNum];
     1565    sumN50 = robustHistogram->nums->data.F32[LQBinNum];
    15661566    for (i = LQBinNum + 1; i <= UQBinNum; i++) {
    15671567        if (robustHistogramVector->data.F32[i] > modeBinCount) {
    … …  
    15691569            modeBinCount = robustHistogramVector->data.F32[i];
    15701570        }
    1571         sumN50 += (float)robustHistogram->nums->data.U32[i];
     1571        sumN50 += robustHistogram->nums->data.F32[i];
    15721572    }
    15731573
    … …  
    15871587        }
    15881588
    1589         sumNfit += (float)robustHistogram->nums->data.U32[i];
     1589        sumNfit += robustHistogram->nums->data.F32[i];
    15901590    }
    15911591    // XXX: divide by zero?
    … …  
    17961796
    17971797    // Allocate the bins, and initialize them to zero.
    1798     newHist->nums = psVectorAlloc(n, PS_TYPE_U32);
    1799     newHist->nums->n = newHist->nums->nalloc;
     1798    newHist->nums = psVectorAlloc(n, PS_TYPE_F32);
    18001799    for (i = 0; i < newHist->nums->n; i++) {
    1801         newHist->nums->data.U32[i] = 0;
     1800        newHist->nums->data.F32[i] = 0.0;
    18021801    }
    18031802
    … …  
    18391838    // Allocate the bins, and initialize them to zero.  If there are N bounds,
    18401839    // then there are N-1 bins.
    1841     newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_U32);
    1842     newHist->nums->n = newHist->nums->nalloc;
     1840    newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_F32);
    18431841    for (i = 0; i < newHist->nums->n; i++) {
    1844         newHist->nums->data.U32[i] = 0;
     1842        newHist->nums->data.F32[i] = 0.0;
    18451843    }
    18461844
    … …  
    18581856    psFree(myHist->nums);
    18591857}
     1858
     1859psS32 UpdateHistogramBins(psS32 binNum,
     1860                          psHistogram* out,
     1861                          psF32 data,
     1862                          psF32 error)
     1863{
     1864    PS_PTR_CHECK_NULL(out, -1);
     1865    PS_INT_CHECK_RANGE(binNum, 0, out->nums->n-1, -2);
     1866    /*
     1867        psF32 width = 2.35 * error;
     1868        psF32 centerBinWidth = out->bounds->data.F32[binNum+1] - out->bounds->data.F32[binNum]
     1869        psF32 boxcarCenter = (out->bounds->data.F32[binNum] + out->bounds->data.F32[binNum+1]) / 2.0;
     1870     
     1871        if (width <= centerBinWidth) {
     1872            out->nums->data.F32[binNum]+= 1.0;
     1873        } else {
     1874            out->nums->data.F32[binNum]+= centerBinWidth / width;
     1875            // XXX: walk to the left, adding fractional values.
     1876            // XXX: walk to the right, adding fractional values.
     1877     
     1878     
     1879        }
     1880    */
     1881    return(0);
     1882}
     1883
    18601884
    18611885/*****************************************************************************
    … …  
    18831907    PS_PTR_CHECK_NULL(out, NULL);
    18841908    PS_VECTOR_CHECK_TYPE(out->bounds, PS_TYPE_F32, NULL);
    1885     PS_VECTOR_CHECK_TYPE(out->nums, PS_TYPE_U32, NULL);
     1909    PS_VECTOR_CHECK_TYPE(out->nums, PS_TYPE_F32, NULL);
    18861910    PS_INT_CHECK_NON_NEGATIVE(out->nums->n, NULL);
    18871911    PS_VECTOR_CHECK_NULL(in, out);
    … …  
    19131937    for (i = 0; i < inF32->n; i++) {
    19141938        // Check if this pixel is masked, and if so, skip it.
    1915         if ((mask == NULL) ||
    1916                 ((mask != NULL) && (!(mask->data.U8[i] & maskVal)))) {
     1939        if ((mask == NULL) || ((mask != NULL) && (!(mask->data.U8[i] & maskVal)))) {
    19171940            if (inF32->data.F32[i] < out->bounds->data.F32[0]) {
    19181941                // If this pixel is below minimum value, count it, then skip.
    … …  
    19271950                    binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0];
    19281951                    binNum = (psS32)((inF32->data.F32[i] - out->bounds->data.F32[0]) / binSize);
    1929 
    1930                     // XXX: This if-statement really shouldn't be necessary.
    1931                     // However, due to numerical lack of precision, we
    1932                     // occasionally produce a binNum outside the range.
    1933                     if (binNum >= out->nums->n) {
    1934                         binNum = out->nums->n - 1;
     1952                    if (errors != NULL) {
     1953                        // XXX: Check return codes.
     1954                        UpdateHistogramBins(binNum, out,
     1955                                            inF32->data.F32[i],
     1956                                            errors->data.F32[i]);
     1957                    } else {
     1958                        // XXX: This if-statement really shouldn't be necessary.
     1959                        // However, due to numerical lack of precision, we
     1960                        // occasionally produce a binNum outside the range.
     1961                        if (binNum >= out->nums->n) {
     1962                            binNum = out->nums->n - 1;
     1963                        }
     1964                        (out->nums->data.F32[binNum])+= 1.0;
    19351965                    }
    1936 
    1937                     (out->nums->data.U32[binNum])++;
    19381966
    19391967                } else {
    … …  
    19461974                                 "WARNING: psVectorHistogram(): element outside histogram bounds.\n");
    19471975                    } else {
    1948                         (out->nums->data.U32[tmp])++;
     1976                        if (errors != NULL) {
     1977                            // XXX: Check return codes.
     1978                            UpdateHistogramBins(tmp, out,
     1979                                                inF32->data.F32[i],
     1980                                                errors->data.F32[i]);
     1981                        } else {
     1982                            (out->nums->data.F32[tmp])+= 1.0;
     1983                        }
    19491984                    }
    19501985                }

  • trunk/psLib/test/dataManip/tst_psHist00.c

    r2718 r2782  
    5050
    5151        for (i=0;i<numBins;i++) {
    52             if (myHist->nums->data.U32[i] != 0) {
     52            if (myHist->nums->data.F32[i] != 0.0) {
    5353                printf("ERROR: myHist->nums->data.U32[%d] not initialized to 0.\n", i);
    5454                testStatus = false;
    5555            }
    56             myHist->nums->data.U32[i] = 0;
     56            myHist->nums->data.F32[i] = 0.0;
    5757        }
    5858

  • trunk/psLib/test/dataManip/tst_psHist01.c

    r2392 r2782  
    5656
    5757        for (i=0;i<numBins;i++) {
    58             if (myHist->nums->data.U32[i] != 0) {
    59                 printf("ERROR: myHist->nums->data.U32[%d] not initialized to 0.\n", i);
     58            if (myHist->nums->data.F32[i] != 0.0) {
     59                printf("ERROR: myHist->nums->data.F32[%d] not initialized to 0.\n", i);
    6060                testStatus = false;
    6161            }
    62             myHist->nums->data.U32[i] = 0;
     62            myHist->nums->data.F32[i] = 0.0;
    6363        }
    6464

  • trunk/psLib/test/dataManip/tst_psHist02.c

    r2780 r2782  
    6969
    7070        for ( i = 0;i < numBins;i++ ) {
    71             printf( "Bin number %d bounds: (%.2f - %.2f) data (%d)\n", i,
     71            printf( "Bin number %d bounds: (%.2f - %.2f) data (%f)\n", i,
    7272                    myHist->bounds->data.F32[ i ],
    7373                    myHist->bounds->data.F32[ i + 1 ],
    74                     myHist->nums->data.U32[ i ] );
     74                    myHist->nums->data.F32[ i ] );
    7575        }
    7676        psMemCheckCorruption( 1 );
    … …  
    9494
    9595        for ( i = 0;i < numBins;i++ ) {
    96             printf( "Bin number %d bounds: (%6.3f - %6.3f) data (%d)\n", i,
     96            printf( "Bin number %d bounds: (%6.3f - %6.3f) data (%f)\n", i,
    9797                    myHist->bounds->data.F32[ i ],
    9898                    myHist->bounds->data.F32[ i + 1 ],
    99                     myHist->nums->data.U32[ i ] );
     99                    myHist->nums->data.F32[ i ] );
    100100        }
    101101        psMemCheckCorruption( 1 );

  • trunk/psLib/test/dataManip/tst_psHist03.c

    r2780 r2782  
    6767
    6868        for (i=0;i<numBins;i++) {
    69             if (myHist->nums->data.U32[i] != 0) {
    70                 printf("ERROR: myHist->nums->data.U32[%d] not initialized to 0.\n", i);
     69            if (myHist->nums->data.F32[i] != 0.0) {
     70                printf("ERROR: myHist->nums->data.F32[%d] not initialized to 0.\n", i);
    7171                testStatus = false;
    7272            }
    73             myHist->nums->data.U32[i] = 0;
     73            myHist->nums->data.F32[i] = 0.0;
    7474        }
    7575
    … …  
    9191        myHist = psVectorHistogram( myHist, myData, NULL, NULL, 0 );
    9292        for (i=0;i<numBins;i++) {
    93             printf("Bin number %d bounds: (%6.3f - %6.3f): data: (%d)\n", i,
     93            printf("Bin number %d bounds: (%6.3f - %6.3f): data: (%f)\n", i,
    9494                   myHist->bounds->data.F32[i],
    9595                   myHist->bounds->data.F32[i+1],
    96                    myHist->nums->data.S32[i]);
     96                   myHist->nums->data.F32[i]);
    9797        }
    9898

  • trunk/psLib/test/dataManip/verified/tst_psHist02.stdout

    r2721 r2782  
    55\**********************************************************************************/
    66
    7 Bin number 0 bounds: (20.00 - 30.00) data (10000)
     7Bin number 0 bounds: (20.00 - 30.00) data (10000.000000)
    88
    99---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
    … …  
    1515\**********************************************************************************/
    1616
    17 Bin number 0 bounds: (20.000 - 30.000) data (5000)
     17Bin number 0 bounds: (20.000 - 30.000) data (5000.000000)
    1818
    1919---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
    … …  
    2525\**********************************************************************************/
    2626
    27 Bin number 0 bounds: (20.00 - 25.00) data (5000)
    28 Bin number 1 bounds: (25.00 - 30.00) data (5000)
     27Bin number 0 bounds: (20.00 - 25.00) data (5000.000000)
     28Bin number 1 bounds: (25.00 - 30.00) data (5000.000000)
    2929
    3030---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
    … …  
    3636\**********************************************************************************/
    3737
    38 Bin number 0 bounds: (20.000 - 25.000) data (5000)
    39 Bin number 1 bounds: (25.000 - 30.000) data (0)
     38Bin number 0 bounds: (20.000 - 25.000) data (5000.000000)
     39Bin number 1 bounds: (25.000 - 30.000) data (0.000000)
    4040
    4141---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
    … …  
    4747\**********************************************************************************/
    4848
    49 Bin number 0 bounds: (20.00 - 21.00) data (1000)
    50 Bin number 1 bounds: (21.00 - 22.00) data (1000)
    51 Bin number 2 bounds: (22.00 - 23.00) data (1000)
    52 Bin number 3 bounds: (23.00 - 24.00) data (1000)
    53 Bin number 4 bounds: (24.00 - 25.00) data (1000)
    54 Bin number 5 bounds: (25.00 - 26.00) data (1000)
    55 Bin number 6 bounds: (26.00 - 27.00) data (1000)
    56 Bin number 7 bounds: (27.00 - 28.00) data (1000)
    57 Bin number 8 bounds: (28.00 - 29.00) data (1000)
    58 Bin number 9 bounds: (29.00 - 30.00) data (1000)
     49Bin number 0 bounds: (20.00 - 21.00) data (1000.000000)
     50Bin number 1 bounds: (21.00 - 22.00) data (1000.000000)
     51Bin number 2 bounds: (22.00 - 23.00) data (1000.000000)
     52Bin number 3 bounds: (23.00 - 24.00) data (1000.000000)
     53Bin number 4 bounds: (24.00 - 25.00) data (1000.000000)
     54Bin number 5 bounds: (25.00 - 26.00) data (1000.000000)
     55Bin number 6 bounds: (26.00 - 27.00) data (1000.000000)
     56Bin number 7 bounds: (27.00 - 28.00) data (1000.000000)
     57Bin number 8 bounds: (28.00 - 29.00) data (1000.000000)
     58Bin number 9 bounds: (29.00 - 30.00) data (1000.000000)
    5959
    6060---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
    … …  
    6666\**********************************************************************************/
    6767
    68 Bin number 0 bounds: (20.000 - 21.000) data (1000)
    69 Bin number 1 bounds: (21.000 - 22.000) data (1000)
    70 Bin number 2 bounds: (22.000 - 23.000) data (1000)
    71 Bin number 3 bounds: (23.000 - 24.000) data (1000)
    72 Bin number 4 bounds: (24.000 - 25.000) data (1000)
    73 Bin number 5 bounds: (25.000 - 26.000) data (0)
    74 Bin number 6 bounds: (26.000 - 27.000) data (0)
    75 Bin number 7 bounds: (27.000 - 28.000) data (0)
    76 Bin number 8 bounds: (28.000 - 29.000) data (0)
    77 Bin number 9 bounds: (29.000 - 30.000) data (0)
     68Bin number 0 bounds: (20.000 - 21.000) data (1000.000000)
     69Bin number 1 bounds: (21.000 - 22.000) data (1000.000000)
     70Bin number 2 bounds: (22.000 - 23.000) data (1000.000000)
     71Bin number 3 bounds: (23.000 - 24.000) data (1000.000000)
     72Bin number 4 bounds: (24.000 - 25.000) data (1000.000000)
     73Bin number 5 bounds: (25.000 - 26.000) data (0.000000)
     74Bin number 6 bounds: (26.000 - 27.000) data (0.000000)
     75Bin number 7 bounds: (27.000 - 28.000) data (0.000000)
     76Bin number 8 bounds: (28.000 - 29.000) data (0.000000)
     77Bin number 9 bounds: (29.000 - 30.000) data (0.000000)
    7878
    7979---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
    … …  
    8585\**********************************************************************************/
    8686
    87 Bin number 0 bounds: (20.00 - 20.50) data (500)
    88 Bin number 1 bounds: (20.50 - 21.00) data (500)
    89 Bin number 2 bounds: (21.00 - 21.50) data (500)
    90 Bin number 3 bounds: (21.50 - 22.00) data (500)
    91 Bin number 4 bounds: (22.00 - 22.50) data (500)
    92 Bin number 5 bounds: (22.50 - 23.00) data (500)
    93 Bin number 6 bounds: (23.00 - 23.50) data (500)
    94 Bin number 7 bounds: (23.50 - 24.00) data (500)
    95 Bin number 8 bounds: (24.00 - 24.50) data (500)
    96 Bin number 9 bounds: (24.50 - 25.00) data (500)
    97 Bin number 10 bounds: (25.00 - 25.50) data (500)
    98 Bin number 11 bounds: (25.50 - 26.00) data (500)
    99 Bin number 12 bounds: (26.00 - 26.50) data (500)
    100 Bin number 13 bounds: (26.50 - 27.00) data (500)
    101 Bin number 14 bounds: (27.00 - 27.50) data (500)
    102 Bin number 15 bounds: (27.50 - 28.00) data (500)
    103 Bin number 16 bounds: (28.00 - 28.50) data (500)
    104 Bin number 17 bounds: (28.50 - 29.00) data (500)
    105 Bin number 18 bounds: (29.00 - 29.50) data (500)
    106 Bin number 19 bounds: (29.50 - 30.00) data (500)
     87Bin number 0 bounds: (20.00 - 20.50) data (500.000000)
     88Bin number 1 bounds: (20.50 - 21.00) data (500.000000)
     89Bin number 2 bounds: (21.00 - 21.50) data (500.000000)
     90Bin number 3 bounds: (21.50 - 22.00) data (500.000000)
     91Bin number 4 bounds: (22.00 - 22.50) data (500.000000)
     92Bin number 5 bounds: (22.50 - 23.00) data (500.000000)
     93Bin number 6 bounds: (23.00 - 23.50) data (500.000000)
     94Bin number 7 bounds: (23.50 - 24.00) data (500.000000)
     95Bin number 8 bounds: (24.00 - 24.50) data (500.000000)
     96Bin number 9 bounds: (24.50 - 25.00) data (500.000000)
     97Bin number 10 bounds: (25.00 - 25.50) data (500.000000)
     98Bin number 11 bounds: (25.50 - 26.00) data (500.000000)
     99Bin number 12 bounds: (26.00 - 26.50) data (500.000000)
     100Bin number 13 bounds: (26.50 - 27.00) data (500.000000)
     101Bin number 14 bounds: (27.00 - 27.50) data (500.000000)
     102Bin number 15 bounds: (27.50 - 28.00) data (500.000000)
     103Bin number 16 bounds: (28.00 - 28.50) data (500.000000)
     104Bin number 17 bounds: (28.50 - 29.00) data (500.000000)
     105Bin number 18 bounds: (29.00 - 29.50) data (500.000000)
     106Bin number 19 bounds: (29.50 - 30.00) data (500.000000)
    107107
    108108---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
    … …  
    114114\**********************************************************************************/
    115115
    116 Bin number 0 bounds: (20.000 - 20.500) data (500)
    117 Bin number 1 bounds: (20.500 - 21.000) data (500)
    118 Bin number 2 bounds: (21.000 - 21.500) data (500)
    119 Bin number 3 bounds: (21.500 - 22.000) data (500)
    120 Bin number 4 bounds: (22.000 - 22.500) data (500)
    121 Bin number 5 bounds: (22.500 - 23.000) data (500)
    122 Bin number 6 bounds: (23.000 - 23.500) data (500)
    123 Bin number 7 bounds: (23.500 - 24.000) data (500)
    124 Bin number 8 bounds: (24.000 - 24.500) data (500)
    125 Bin number 9 bounds: (24.500 - 25.000) data (500)
    126 Bin number 10 bounds: (25.000 - 25.500) data (0)
    127 Bin number 11 bounds: (25.500 - 26.000) data (0)
    128 Bin number 12 bounds: (26.000 - 26.500) data (0)
    129 Bin number 13 bounds: (26.500 - 27.000) data (0)
    130 Bin number 14 bounds: (27.000 - 27.500) data (0)
    131 Bin number 15 bounds: (27.500 - 28.000) data (0)
    132 Bin number 16 bounds: (28.000 - 28.500) data (0)
    133 Bin number 17 bounds: (28.500 - 29.000) data (0)
    134 Bin number 18 bounds: (29.000 - 29.500) data (0)
    135 Bin number 19 bounds: (29.500 - 30.000) data (0)
     116Bin number 0 bounds: (20.000 - 20.500) data (500.000000)
     117Bin number 1 bounds: (20.500 - 21.000) data (500.000000)
     118Bin number 2 bounds: (21.000 - 21.500) data (500.000000)
     119Bin number 3 bounds: (21.500 - 22.000) data (500.000000)
     120Bin number 4 bounds: (22.000 - 22.500) data (500.000000)
     121Bin number 5 bounds: (22.500 - 23.000) data (500.000000)
     122Bin number 6 bounds: (23.000 - 23.500) data (500.000000)
     123Bin number 7 bounds: (23.500 - 24.000) data (500.000000)
     124Bin number 8 bounds: (24.000 - 24.500) data (500.000000)
     125Bin number 9 bounds: (24.500 - 25.000) data (500.000000)
     126Bin number 10 bounds: (25.000 - 25.500) data (0.000000)
     127Bin number 11 bounds: (25.500 - 26.000) data (0.000000)
     128Bin number 12 bounds: (26.000 - 26.500) data (0.000000)
     129Bin number 13 bounds: (26.500 - 27.000) data (0.000000)
     130Bin number 14 bounds: (27.000 - 27.500) data (0.000000)
     131Bin number 15 bounds: (27.500 - 28.000) data (0.000000)
     132Bin number 16 bounds: (28.000 - 28.500) data (0.000000)
     133Bin number 17 bounds: (28.500 - 29.000) data (0.000000)
     134Bin number 18 bounds: (29.000 - 29.500) data (0.000000)
     135Bin number 19 bounds: (29.500 - 30.000) data (0.000000)
    136136
    137137---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
Note: See TracChangeset for help on using the changeset viewer.