IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 6484 for trunk/psLib/test/math


Ignore:
Timestamp:
Feb 24, 2006, 1:43:16 PM (20 years ago)
Author:
drobbin
Message:

Changed psArray & psVector to zero 'n' upon allocation. Used to set vector->n = nalloc.

Location:
trunk/psLib/test/math
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/math/tst_psMinimizeLMM.c

    r6449 r6484  
    6161    myCoords->n = NUM_DATA_POINTS;
    6262    psVector *y = psVectorAlloc(NUM_DATA_POINTS, PS_TYPE_F32);
     63    myParams->n = NUM_PARAMS;
     64    myDerivs->n = NUM_PARAMS;
     65    y->n = NUM_DATA_POINTS;
    6366
    6467    for (psS32 i=0;i<NUM_DATA_POINTS;i++) {
    … …  
    6669        ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10);
    6770        ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3);
     71        ((psVector *) (myCoords->data[i]))->n = 2;
    6872        psTrace(__func__, 5, "x[%d] is vector (%f, %f)\n", i, ((psVector *) (myCoords->data[i]))->data.F32[0],
    6973                ((psVector *) (myCoords->data[i]))->data.F32[1]);

  • trunk/psLib/test/math/tst_psMinimizePowell.c

    r6449 r6484  
    8181    myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32);
    8282    myParamMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_U8);
     83    myParams->n = NUM_PARAMS;
     84    myParamMask->n = NUM_PARAMS;
    8385    min = psMinimizationAlloc(100, 0.01);
    8486
    … …  
    164166        ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10);
    165167        ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3);
     168        ((psVector *) (myCoords->data[i]))->n = 2;
    166169    }
    167170    for (i=0;i<NUM_PARAMS;i++) {
    … …  
    169172        myParams->data.F32[i] = 0.0;
    170173        myParams->data.F32[i] = (float) i;
     174        myParams->n++;
    171175    }
    172176
    … …  
    239243        ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10);
    240244        ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3);
     245        ((psVector *) (myCoords->data[i]))->n++;
    241246    }
    242247    for (i=0;i<NUM_PARAMS;i++) {
    … …  
    245250        myParams->data.F32[i] = (float) i;
    246251        myParamMask->data.U8[i] = 0;
     252        myParams->n++;
     253        myParamMask->n++;
    247254    }
    248255

  • trunk/psLib/test/math/tst_psPolyFit1D.c

    r6304 r6484  
    9999        printf(" using a psF32 x vector\n");
    100100        x = psVectorAlloc(numData, PS_TYPE_F32);
     101        x->n = numData;
    101102        for (psS32 i=0;i<numData;i++) {
    102103            x->data.F32[i] = (psF32) i;
    … …  
    111112        printf(" using a psS32 x vector\n");
    112113        x = psVectorAlloc(numData, PS_TYPE_S32);
     114        x->n = numData;
    113115        for (psS32 i=0;i<numData;i++) {
    114116            x->data.S32[i] = (psS32) i;
    … …  
    123125        printf(" using a psF64 x vector\n");
    124126        x = psVectorAlloc(numData, PS_TYPE_F64);
     127        x->n = numData;
    125128        for (psS32 i=0;i<numData;i++) {
    126129            x->data.F64[i] = (psF64) i;
    … …  
    139142        printf(" using a psF32 f vector\n");
    140143        f = psVectorAlloc(numData, PS_TYPE_F32);
     144        f->n = numData;
    141145        for (psS32 i=0;i<numData;i++) {
    142146            f->data.F32[i] = setData((psF32) i);
    … …  
    159163        printf(" using a psS32 f vector\n");
    160164        f = psVectorAlloc(numData, PS_TYPE_S32);
     165        f->n = numData;
    161166        for (psS32 i=0;i<numData;i++) {
    162167            f->data.S32[i] = (psS32) setData((psF32) i);
    … …  
    179184        printf(" using a psF64 f vector\n");
    180185        f = psVectorAlloc(numData, PS_TYPE_F64);
     186        f->n = numData;
    181187        for (psS32 i=0;i<numData;i++) {
    182188            f->data.F64[i] = (psF64) setData((psF32) i);
    … …  
    203209        printf(" using a psF32 fErr vector\n");
    204210        fErr = psVectorAlloc(numData, PS_TYPE_F32);
     211        fErr->n = numData;
    205212        for (psS32 i=0;i<numData;i++) {
    206213            fErr->data.F32[i] = YERR;
    … …  
    211218        printf(" using a psS32 fErr vector\n");
    212219        fErr = psVectorAlloc(numData, PS_TYPE_S32);
     220        fErr->n = numData;
    213221        for (psS32 i=0;i<numData;i++) {
    214222            fErr->data.S32[i] = (psS32) YERR;
    … …  
    219227        printf(" using a psF64 fErr vector\n");
    220228        fErr = psVectorAlloc(numData, PS_TYPE_F64);
     229        fErr->n = numData;
    221230        for (psS32 i=0;i<numData;i++) {
    222231            fErr->data.F64[i] = YERR;
    … …  
    231240        printf(" using a psU8 mask vector\n");
    232241        mask = psVectorAlloc(numData, PS_TYPE_U8);
     242        mask->n = numData;
    233243        for (psS32 i=0;i<numData;i++) {
    234244            mask->data.U8[i] = 0;
    … …  
    239249        printf(" using a psS32 mask vector\n");
    240250        mask = psVectorAlloc(numData, PS_TYPE_S32);
     251        mask->n = numData;
    241252        for (psS32 i=0;i<numData;i++) {
    242253            mask->data.S32[i] = 0;

  • trunk/psLib/test/math/tst_psPolyFit2D.c

    r6226 r6484  
    100100        printf(" using a psF32 x vector\n");
    101101        x = psVectorAlloc(numData, PS_TYPE_F32);
     102        x->n = numData;
    102103        for (psS32 i=0;i<numData;i++) {
    103104            x->data.F32[i] = (psF32) i;
    … …  
    108109        printf(" using a psS32 x vector\n");
    109110        x = psVectorAlloc(numData, PS_TYPE_S32);
     111        x->n = numData;
    110112        for (psS32 i=0;i<numData;i++) {
    111113            x->data.S32[i] = (psS32) i;
    … …  
    116118        printf(" using a psF64 x vector\n");
    117119        x = psVectorAlloc(numData, PS_TYPE_F64);
     120        x->n = numData;
    118121        for (psS32 i=0;i<numData;i++) {
    119122            x->data.F64[i] = (psF64) i;
    … …  
    129132        printf(" using a psF32 y vector\n");
    130133        y = psVectorAlloc(numData, PS_TYPE_F32);
     134        y->n = numData;
    131135        for (psS32 i=0;i<numData;i++) {
    132136            y->data.F32[i] = (psF32) i;
    … …  
    137141        printf(" using a psS32 y vector\n");
    138142        y = psVectorAlloc(numData, PS_TYPE_S32);
     143        y->n = numData;
    139144        for (psS32 i=0;i<numData;i++) {
    140145            y->data.S32[i] = (psS32) i;
    … …  
    145150        printf(" using a psF64 y vector\n");
    146151        y = psVectorAlloc(numData, PS_TYPE_F64);
     152        y->n = numData;
    147153        for (psS32 i=0;i<numData;i++) {
    148154            y->data.F64[i] = (psF64) i;
    … …  
    157163        printf(" using a psF32 f vector\n");
    158164        f = psVectorAlloc(numData, PS_TYPE_F32);
     165        f->n = numData;
    159166        for (psS32 i=0;i<numData;i++) {
    160167            f->data.F32[i] = setData((psF32) i, (psF32) i);
    … …  
    177184        printf(" using a psS32 f vector\n");
    178185        f = psVectorAlloc(numData, PS_TYPE_S32);
     186        f->n = numData;
    179187        for (psS32 i=0;i<numData;i++) {
    180188            f->data.S32[i] = (psS32) setData((psF32) i, (psF32) i);
    … …  
    197205        printf(" using a psF64 f vector\n");
    198206        f = psVectorAlloc(numData, PS_TYPE_F64);
     207        f->n = numData;
    199208        for (psS32 i=0;i<numData;i++) {
    200209            f->data.F64[i] = (psF64) setData((psF32) i, (psF32) i);
    … …  
    221230        printf(" using a psF32 fErr vector\n");
    222231        fErr = psVectorAlloc(numData, PS_TYPE_F32);
     232        fErr->n = numData;
    223233        for (psS32 i=0;i<numData;i++) {
    224234            fErr->data.F32[i] = YERR;
    … …  
    237247        printf(" using a psF64 fErr vector\n");
    238248        fErr = psVectorAlloc(numData, PS_TYPE_F64);
     249        fErr->n = numData;
    239250        for (psS32 i=0;i<numData;i++) {
    240251            fErr->data.F64[i] = YERR;
    … …  
    249260        printf(" using a psU8 mask vector\n");
    250261        mask = psVectorAlloc(numData, PS_TYPE_U8);
     262        mask->n = numData;
    251263        for (psS32 i=0;i<numData;i++) {
    252264            mask->data.U8[i] = 0;
    … …  
    257269        printf(" using a psS32 mask vector\n");
    258270        mask = psVectorAlloc(numData, PS_TYPE_S32);
     271        mask->n = numData;
    259272        for (psS32 i=0;i<numData;i++) {
    260273            mask->data.S32[i] = 0;

  • trunk/psLib/test/math/tst_psPolyFit3D.c

    r6226 r6484  
    117117        printf(" using a psF32 x vector\n");
    118118        x = psVectorAlloc(numData, PS_TYPE_F32);
     119        x->n = numData;
    119120        for (psS32 i=0;i<numData;i++) {
    120121            x->data.F32[i] = (psF32) i;
    … …  
    125126        printf(" using a psS32 x vector\n");
    126127        x = psVectorAlloc(numData, PS_TYPE_S32);
     128        x->n = numData;
    127129        for (psS32 i=0;i<numData;i++) {
    128130            x->data.S32[i] = (psS32) i;
    … …  
    133135        printf(" using a psF64 x vector\n");
    134136        x = psVectorAlloc(numData, PS_TYPE_F64);
     137        x->n = numData;
    135138        for (psS32 i=0;i<numData;i++) {
    136139            x->data.F64[i] = (psF64) i;
    … …  
    146149        printf(" using a psF32 y vector\n");
    147150        y = psVectorAlloc(numData, PS_TYPE_F32);
     151        y->n = numData;
    148152        for (psS32 i=0;i<numData;i++) {
    149153            y->data.F32[i] = (psF32) i;
    … …  
    154158        printf(" using a psS32 y vector\n");
    155159        y = psVectorAlloc(numData, PS_TYPE_S32);
     160        y->n = numData;
    156161        for (psS32 i=0;i<numData;i++) {
    157162            y->data.S32[i] = (psS32) i;
    … …  
    162167        printf(" using a psF64 y vector\n");
    163168        y = psVectorAlloc(numData, PS_TYPE_F64);
     169        y->n = numData;
    164170        for (psS32 i=0;i<numData;i++) {
    165171            y->data.F64[i] = (psF64) i;
    … …  
    174180        printf(" using a psF32 z vector\n");
    175181        z = psVectorAlloc(numData, PS_TYPE_F32);
     182        z->n = numData;
    176183        for (psS32 i=0;i<numData;i++) {
    177184            z->data.F32[i] = (psF32) i;
    … …  
    182189        printf(" using a psS32 z vector\n");
    183190        z = psVectorAlloc(numData, PS_TYPE_S32);
     191        z->n = numData;
    184192        for (psS32 i=0;i<numData;i++) {
    185193            z->data.S32[i] = (psS32) i;
    … …  
    190198        printf(" using a psF64 z vector\n");
    191199        z = psVectorAlloc(numData, PS_TYPE_F64);
     200        z->n = numData;
    192201        for (psS32 i=0;i<numData;i++) {
    193202            z->data.F64[i] = (psF64) i;
    … …  
    203212        printf(" using a psF32 f vector\n");
    204213        f = psVectorAlloc(numData, PS_TYPE_F32);
     214        f->n = numData;
    205215        for (psS32 i=0;i<numData;i++) {
    206216            f->data.F32[i] = setData((psF32) i, (psF32) i, (psF32) i);
    … …  
    223233        printf(" using a psS32 f vector\n");
    224234        f = psVectorAlloc(numData, PS_TYPE_S32);
     235        f->n = numData;
    225236        for (psS32 i=0;i<numData;i++) {
    226237            f->data.S32[i] = (psS32) setData((psF32) i, (psF32) i, (psF32) i);
    … …  
    243254        printf(" using a psF64 f vector\n");
    244255        f = psVectorAlloc(numData, PS_TYPE_F64);
     256        f->n = numData;
    245257        for (psS32 i=0;i<numData;i++) {
    246258            f->data.F64[i] = (psF64) setData((psF32) i, (psF32) i, (psF32) i);
    … …  
    267279        printf(" using a psF32 fErr vector\n");
    268280        fErr = psVectorAlloc(numData, PS_TYPE_F32);
     281        fErr->n = numData;
    269282        for (psS32 i=0;i<numData;i++) {
    270283            fErr->data.F32[i] = YERR;
    … …  
    275288        printf(" using a psS32 fErr vector\n");
    276289        fErr = psVectorAlloc(numData, PS_TYPE_S32);
     290        fErr->n = numData;
    277291        for (psS32 i=0;i<numData;i++) {
    278292            fErr->data.S32[i] = (psS32) YERR;
    … …  
    283297        printf(" using a psF64 fErr vector\n");
    284298        fErr = psVectorAlloc(numData, PS_TYPE_F64);
     299        fErr->n = numData;
    285300        for (psS32 i=0;i<numData;i++) {
    286301            fErr->data.F64[i] = YERR;
    … …  
    295310        printf(" using a psU8 mask vector\n");
    296311        mask = psVectorAlloc(numData, PS_TYPE_U8);
     312        mask->n = numData;
    297313        for (psS32 i=0;i<numData;i++) {
    298314            mask->data.U8[i] = 0;
    … …  
    303319        printf(" using a psS32 mask vector\n");
    304320        mask = psVectorAlloc(numData, PS_TYPE_S32);
     321        mask->n = numData;
    305322        for (psS32 i=0;i<numData;i++) {
    306323            mask->data.S32[i] = 0;

  • trunk/psLib/test/math/tst_psPolyFit4D.c

    r6226 r6484  
    130130        printf(" using a psF32 x vector\n");
    131131        x = psVectorAlloc(numData, PS_TYPE_F32);
     132        x->n = numData;
    132133        for (psS32 i=0;i<numData;i++) {
    133134            x->data.F32[i] = (psF32) i;
    … …  
    138139        printf(" using a psS32 x vector\n");
    139140        x = psVectorAlloc(numData, PS_TYPE_S32);
     141        x->n = numData;
    140142        for (psS32 i=0;i<numData;i++) {
    141143            x->data.S32[i] = (psS32) i;
    … …  
    146148        printf(" using a psF64 x vector\n");
    147149        x = psVectorAlloc(numData, PS_TYPE_F64);
     150        x->n = numData;
    148151        for (psS32 i=0;i<numData;i++) {
    149152            x->data.F64[i] = (psF64) i;
    … …  
    159162        printf(" using a psF32 y vector\n");
    160163        y = psVectorAlloc(numData, PS_TYPE_F32);
     164        y->n = numData;
    161165        for (psS32 i=0;i<numData;i++) {
    162166            y->data.F32[i] = (psF32) i;
    … …  
    167171        printf(" using a psS32 y vector\n");
    168172        y = psVectorAlloc(numData, PS_TYPE_S32);
     173        y->n = numData;
    169174        for (psS32 i=0;i<numData;i++) {
    170175            y->data.S32[i] = (psS32) i;
    … …  
    175180        printf(" using a psF64 y vector\n");
    176181        y = psVectorAlloc(numData, PS_TYPE_F64);
     182        y->n = numData;
    177183        for (psS32 i=0;i<numData;i++) {
    178184            y->data.F64[i] = (psF64) i;
    … …  
    187193        printf(" using a psF32 z vector\n");
    188194        z = psVectorAlloc(numData, PS_TYPE_F32);
     195        z->n = numData;
    189196        for (psS32 i=0;i<numData;i++) {
    190197            z->data.F32[i] = (psF32) i;
    … …  
    195202        printf(" using a psS32 z vector\n");
    196203        z = psVectorAlloc(numData, PS_TYPE_S32);
     204        z->n = numData;
    197205        for (psS32 i=0;i<numData;i++) {
    198206            z->data.S32[i] = (psS32) i;
    … …  
    203211        printf(" using a psF64 z vector\n");
    204212        z = psVectorAlloc(numData, PS_TYPE_F64);
     213        z->n = numData;
    205214        for (psS32 i=0;i<numData;i++) {
    206215            z->data.F64[i] = (psF64) i;
    … …  
    215224        printf(" using a psF32 t vector\n");
    216225        t = psVectorAlloc(numData, PS_TYPE_F32);
     226        t->n = numData;
    217227        for (psS32 i=0;i<numData;i++) {
    218228            t->data.F32[i] = (psF32) i;
    … …  
    223233        printf(" using a psS32 t vector\n");
    224234        t = psVectorAlloc(numData, PS_TYPE_S32);
     235        t->n = numData;
    225236        for (psS32 i=0;i<numData;i++) {
    226237            t->data.S32[i] = (psS32) i;
    … …  
    231242        printf(" using a psF64 t vector\n");
    232243        t = psVectorAlloc(numData, PS_TYPE_F64);
     244        t->n = numData;
    233245        for (psS32 i=0;i<numData;i++) {
    234246            t->data.F64[i] = (psF64) i;
    … …  
    244256        printf(" using a psF32 f vector\n");
    245257        f = psVectorAlloc(numData, PS_TYPE_F32);
     258        f->n = numData;
    246259        for (psS32 i=0;i<numData;i++) {
    247260            f->data.F32[i] = setData((psF32) i, (psF32) i, (psF32) i, (psF32) i);
    … …  
    264277        printf(" using a psS32 f vector\n");
    265278        f = psVectorAlloc(numData, PS_TYPE_S32);
     279        f->n = numData;
    266280        for (psS32 i=0;i<numData;i++) {
    267281            f->data.S32[i] = (psS32) setData((psF32) i, (psF32) i, (psF32) i, (psF32) i);
    … …  
    284298        printf(" using a psF64 f vector\n");
    285299        f = psVectorAlloc(numData, PS_TYPE_F64);
     300        f->n = numData;
    286301        for (psS32 i=0;i<numData;i++) {
    287302            f->data.F64[i] = (psF64) setData((psF32) i, (psF32) i, (psF32) i, (psF32) i);
    … …  
    308323        printf(" using a psF32 fErr vector\n");
    309324        fErr = psVectorAlloc(numData, PS_TYPE_F32);
     325        fErr->n = numData;
    310326        for (psS32 i=0;i<numData;i++) {
    311327            fErr->data.F32[i] = YERR;
    … …  
    316332        printf(" using a psS32 fErr vector\n");
    317333        fErr = psVectorAlloc(numData, PS_TYPE_S32);
     334        fErr->n = numData;
    318335        for (psS32 i=0;i<numData;i++) {
    319336            fErr->data.S32[i] = (psS32) YERR;
    … …  
    324341        printf(" using a psF64 fErr vector\n");
    325342        fErr = psVectorAlloc(numData, PS_TYPE_F64);
     343        fErr->n = numData;
    326344        for (psS32 i=0;i<numData;i++) {
    327345            fErr->data.F64[i] = YERR;
    … …  
    336354        printf(" using a psU8 mask vector\n");
    337355        mask = psVectorAlloc(numData, PS_TYPE_U8);
     356        mask->n = numData;
    338357        for (psS32 i=0;i<numData;i++) {
    339358            mask->data.U8[i] = 0;
    … …  
    344363        printf(" using a psS32 mask vector\n");
    345364        mask = psVectorAlloc(numData, PS_TYPE_S32);
     365        mask->n = numData;
    346366        for (psS32 i=0;i<numData;i++) {
    347367            mask->data.S32[i] = 0;

  • trunk/psLib/test/math/tst_psPolynomialEval1D.c

    r6304 r6484  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-02-02 21:05:51 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-02-24 23:43:15 $
    88*
    99*  XXX: Probably should test single- and multi-dimensional polynomials in
    … …  
    1111*
    1212*  XXX: define ORDERS, not TERMS
    13 * 
     13*
    1414*
    1515* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    124124        inputOrd->data.F64[i] = poly1DXValue[i];
    125125        inputCheb->data.F64[i] = poly1DXChebValue[i];
     126        inputOrd->n++;
     127        inputCheb->n++;
    126128    }
    127129

  • trunk/psLib/test/math/tst_psPolynomialEval2D.c

    r6304 r6484  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-02-02 21:05:51 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-02-24 23:43:15 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    157157        inputChebX->data.F64[i] = poly2DXYChebValue[i][0];
    158158        inputChebY->data.F64[i] = poly2DXYChebValue[i][1];
     159        inputOrdX->n++;
     160        inputOrdY->n++;
     161        inputChebX->n++;
     162        inputChebY->n++;
    159163    }
    160164

  • trunk/psLib/test/math/tst_psPolynomialEval3D.c

    r6304 r6484  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-02-02 21:05:51 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-02-24 23:43:15 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    220220        inputChebY->data.F64[i] = Dpoly3DXYZChebValue[i][1];
    221221        inputChebZ->data.F64[i] = Dpoly3DXYZChebValue[i][2];
     222        inputOrdX->n++;
     223        inputOrdY->n++;
     224        inputOrdZ->n++;
     225        inputChebX->n++;
     226        inputChebY->n++;
     227        inputChebZ->n++;
    222228    }
    223229

  • trunk/psLib/test/math/tst_psPolynomialEval4D.c

    r6304 r6484  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-02-02 21:05:51 $
     6*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-02-24 23:43:15 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    470470        inputChebY->data.F64[i] = Dpoly4DWXYZChebValue[i][2];
    471471        inputChebZ->data.F64[i] = Dpoly4DWXYZChebValue[i][3];
     472        inputOrdW->n++;
     473        inputOrdX->n++;
     474        inputOrdY->n++;
     475        inputOrdZ->n++;
     476        inputChebW->n++;
     477        inputChebX->n++;
     478        inputChebY->n++;
     479        inputChebZ->n++;
    472480    }
    473481

  • trunk/psLib/test/math/tst_psRandom.c

    r4951 r6484  
    122122    psRandom *myRNG = NULL;
    123123    psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     124    rans->n = rans->nalloc;
    124125    psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    125126
    … …  
    167168    psRandom *myRNG = NULL;
    168169    psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     170    rans->n = rans->nalloc;
    169171    psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    170172
    … …  
    214216    psRandom *myRNG = NULL;
    215217    psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     218    rans->n = rans->nalloc;
    216219    psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
    217220
    … …  
    259262    psRandom *myRNG = NULL;
    260263    psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     264    rans00->n = rans00->nalloc;
    261265    psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     266    rans01->n = rans01->nalloc;
    262267    psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     268    rans02->n = rans02->nalloc;
    263269
    264270    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    … …  
    314320    psRandom *myRNG = NULL;
    315321    psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     322    rans00->n = rans00->nalloc;
    316323    psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     324    rans01->n = rans01->nalloc;
    317325    psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     326    rans02->n = rans02->nalloc;
    318327
    319328    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
    … …  
    357366    psRandom *myRNG = NULL;
    358367    psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     368    rans00->n = rans00->nalloc;
    359369    psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     370    rans01->n = rans01->nalloc;
    360371    psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     372    rans02->n = rans02->nalloc;
    361373
    362374    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);

  • trunk/psLib/test/math/tst_psSpline1D.c

    r6226 r6484  
    1313*  @author GLG, MHPCC
    1414*
    15 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    16 *  @date $Date: 2006-01-27 20:08:58 $
     15*  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     16*  @date $Date: 2006-02-24 23:43:15 $
    1717*
    1818*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828// {testFunction, testpointNumber, description, expected rc, boolean-ignore this test}
    2929testDescription tests[] = {
    30                               {psSplineAllocTest,      0000, "(TEST A) psSplineAllocTest",      true, false},
    31                               {psSplineEvalTest,       0000, "(TEST B) psSplineEvalTest",       true, false},
    32                               {psSplineEvalVectorTest, 0000, "(TEST C) psSplineEvalVectorTest", true, false},
     30                              {psSplineAllocTest, 665, "(TEST A) psSplineAllocTest",true, false},
     31                              {psSplineEvalTest, 666, "(TEST B) psSplineEvalTest",true, false},
     32                              {psSplineEvalVectorTest,667,"(TEST C) psSplineEvalVectorTest",true,false},
    3333                              {NULL}
    3434                          };
    … …  
    199199    yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32);
    200200    yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64);
     201    xF32->n = NumSplines+1;
     202    xF64->n = NumSplines+1;
     203    yF32->n = NumSplines+1;
     204    yF64->n = NumSplines+1;
    201205
    202206    for (psS32 i=0;i<NumSplines+1;i++) {
    … …  
    274278    yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32);
    275279    yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64);
     280    xF32->n = NumSplines+1;
     281    xF64->n = NumSplines+1;
     282    yF32->n = NumSplines+1;
     283    yF64->n = NumSplines+1;
    276284
    277285    for (psS32 i=0;i<NumSplines+1;i++) {
    … …  
    384392    yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32);
    385393    yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64);
     394    xF32->n = NumSplines+1;
     395    xF64->n = NumSplines+1;
     396    yF32->n = NumSplines+1;
     397    yF64->n = NumSplines+1;
    386398
    387399    for (psS32 i=0;i<NumSplines+1;i++) {
    … …  
    459471    yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32);
    460472    yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64);
     473    xF32->n = NumSplines+1;
     474    xF64->n = NumSplines+1;
     475    yF32->n = NumSplines+1;
     476    yF64->n = NumSplines+1;
    461477
    462478    for (psS32 i=0;i<NumSplines+1;i++) {
    … …  
    559575    yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32);
    560576    yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64);
     577    xF32->n = NumSplines+1;
     578    xF64->n = NumSplines+1;
     579    yF32->n = NumSplines+1;
     580    yF64->n = NumSplines+1;
    561581
    562582    for (psS32 i=0;i<NumSplines+1;i++) {
    … …  
    634654    yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32);
    635655    yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64);
     656    xF32->n = NumSplines+1;
     657    xF64->n = NumSplines+1;
     658    yF32->n = NumSplines+1;
     659    yF64->n = NumSplines+1;
    636660
    637661    for (psS32 i=0;i<NumSplines+1;i++) {
    … …  
    757781    psVector *yF32Test = NULL;
    758782    psVector *xF64Test = psVectorAlloc(NumSplines, PS_TYPE_F64);
     783    xF32->n = NumSplines+1;
     784    yF32->n = NumSplines+1;
     785    xF32Test->n = NumSplines;
     786    xF64Test->n = NumSplines;
     787
    759788
    760789    for (psS32 i=0;i<NumSplines+1;i++) {

  • trunk/psLib/test/math/tst_psStats07.c

    r6326 r6484  
    7272        for (psS32 i=0;i<numData;i++) {
    7373            in->data.F32[i] = gaussVector->data.F32[i];
     74            in->n++;
    7475        }
    7576
    … …  
    8687        for (psS32 i=0;i<numData;i++) {
    8788            in->data.F64[i] = (psF64) gaussVector->data.F32[i];
     89            in->n++;
    8890        }
    8991
    … …  
    100102        for (psS32 i=0;i<numData;i++) {
    101103            in->data.S8[i] = (psS8) gaussVector->data.F32[i];
     104            in->n++;
    102105        }
    103106
    … …  
    114117        for (psS32 i=0;i<numData;i++) {
    115118            in->data.U16[i] = (psU16) gaussVector->data.F32[i];
     119            in->n++;
    116120        }
    117121
    … …  
    128132        for (psS32 i=0;i<numData;i++) {
    129133            in->data.S32[i] = (psS32) gaussVector->data.F32[i];
     134            in->n++;
    130135        }
    131136
    … …  
    138143    psFree(gaussVector);
    139144
     145    //    in->n = in->nalloc;
    140146    if (flags & TST_ERRORS_NULL) {
    141147        printf("        using a NULL errors vector\n");
    … …  
    147153        for (psS32 i=0;i<numData;i++) {
    148154            errors->data.F32[i] = ERRORS;
     155            errors->n++;
    149156        }
    150157
    … …  
    161168        for (psS32 i=0;i<numData;i++) {
    162169            errors->data.F64[i] = ERRORS;
     170            errors->n++;
    163171        }
    164172
    … …  
    175183        for (psS32 i=0;i<numData;i++) {
    176184            errors->data.S8[i] = (psS8) ERRORS;
     185            errors->n++;
    177186        }
    178187
    … …  
    189198        for (psS32 i=0;i<numData;i++) {
    190199            errors->data.U16[i] = (psU16) ERRORS;
     200            errors->n++;
    191201        }
    192202
    … …  
    203213        for (psS32 i=0;i<numData;i++) {
    204214            errors->data.S32[i] = (psS32) ERRORS;
     215            errors->n++;
    205216        }
    206217
    … …  
    222233        for (psS32 i=0;i<numData;i++) {
    223234            mask->data.U8[i] = (psU8) 0;
     235            mask->n++;
    224236        }
    225237
    … …  
    236248        for (psS32 i=0;i<numData;i++) {
    237249            mask->data.S32[i] = (psS32) 0;
     250            mask->n++;
    238251        }
    239252

  • trunk/psLib/test/math/tst_psStats09.c

    r6307 r6484  
    6868        for (psS32 i=0;i<numData;i++) {
    6969            in->data.F32[i] = (psF32) i;
     70            in->n++;
    7071        }
    7172
    … …  
    8283        for (psS32 i=0;i<numData;i++) {
    8384            in->data.F64[i] = (psF64) i;
     85            in->n++;
    8486        }
    8587
    … …  
    9698        for (psS32 i=0;i<numData;i++) {
    9799            in->data.S8[i] = (psS8) i;
     100            in->n++;
    98101        }
    99102
    … …  
    110113        for (psS32 i=0;i<numData;i++) {
    111114            in->data.U16[i] = (psU16) i;
     115            in->n++;
    112116        }
    113117
    … …  
    124128        for (psS32 i=0;i<numData;i++) {
    125129            in->data.S32[i] = (psS32) i;
     130            in->n++;
    126131        }
    127132
    … …  
    142147        for (psS32 i=0;i<numData;i++) {
    143148            errors->data.F32[i] = ERRORS;
     149            errors->n++;
    144150        }
    145151
    … …  
    156162        for (psS32 i=0;i<numData;i++) {
    157163            errors->data.F64[i] = ERRORS;
     164            errors->n++;
    158165        }
    159166
    … …  
    170177        for (psS32 i=0;i<numData;i++) {
    171178            errors->data.S8[i] = (psS8) ERRORS;
     179            errors->n++;
    172180        }
    173181
    … …  
    184192        for (psS32 i=0;i<numData;i++) {
    185193            errors->data.U16[i] = (psU16) ERRORS;
     194            errors->n++;
    186195        }
    187196
    … …  
    198207        for (psS32 i=0;i<numData;i++) {
    199208            errors->data.S32[i] = (psS32) ERRORS;
     209            errors->n++;
    200210        }
    201211
    … …  
    217227        for (psS32 i=0;i<numData;i++) {
    218228            mask->data.U8[i] = (psU8) 0;
     229            mask->n++;
    219230        }
    220231
    … …  
    231242        for (psS32 i=0;i<numData;i++) {
    232243            mask->data.S32[i] = (psS32) 0;
     244            mask->n++;
    233245        }
    234246
Note: See TracChangeset for help on using the changeset viewer.