IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 10, 2006, 3:19:57 AM (20 years ago)
Author:
Paul Price
Message:

Fixing tests: standardised inputs, distributed inputs around [-1,1] so as to avoid numerical effects. tst_psPolyFit1D required special treatment for chebyshev polynomial fitting when x==NULL (indices used as the ordinate)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6484 r7105  
    1111#include "pslib.h"
    1212#include "psTest.h"
    13 #define NUM_DATA 35
     13#define NUM_DATA 30
    1414#define POLY_ORDER_X 2
    1515#define POLY_ORDER_Y 3
    … …  
    2727#define ERROR_TOLERANCE 0.10
    2828#define YERR 10.0
    29 #define VERBOSE 0
     29#define VERBOSE 1
    3030#define NUM_ITERATIONS 5
    3131#define CLIP_SIGMA 4.0
    … …  
    9595    printPositiveTestHeader(stdout, "psMinimize functions", "3D Polynomial Fitting Functions");
    9696
     97    psVector *xTruth = psVectorAlloc(numData, PS_TYPE_F64);
     98    psVector *yTruth = psVectorAlloc(numData, PS_TYPE_F64);
     99    psVector *zTruth = psVectorAlloc(numData, PS_TYPE_F64);
     100    psVector *fTruth = psVectorAlloc(numData, PS_TYPE_F64);
     101    xTruth->n = numData;
     102    yTruth->n = numData;
     103    zTruth->n = numData;
     104    fTruth->n = numData;
     105    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
     106    for (int i = 0; i < numData; i++) {
     107        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
     108        yTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
     109        zTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
     110        fTruth->data.F64[i] = setData(xTruth->data.F64[i], yTruth->data.F64[i], zTruth->data.F64[i]);
     111    }
     112    psFree(rng);
     113
    97114    if (expectedRC == false) {
    98115        printf("This test should generate an error message, and return NULL.\n");
    … …  
    116133    if (flags & TS00_X_F32) {
    117134        printf(" using a psF32 x vector\n");
    118         x = psVectorAlloc(numData, PS_TYPE_F32);
    119         x->n = numData;
    120         for (psS32 i=0;i<numData;i++) {
    121             x->data.F32[i] = (psF32) i;
    122         }
     135        x = psVectorCopy(NULL, xTruth, PS_TYPE_F32);
    123136    }
    124137
    125138    if (flags & TS00_X_S32) {
    126139        printf(" using a psS32 x vector\n");
    127         x = psVectorAlloc(numData, PS_TYPE_S32);
    128         x->n = numData;
    129         for (psS32 i=0;i<numData;i++) {
    130             x->data.S32[i] = (psS32) i;
    131         }
     140        x = psVectorCopy(NULL, xTruth, PS_TYPE_S32);
    132141    }
    133142
    134143    if (flags & TS00_X_F64) {
    135144        printf(" using a psF64 x vector\n");
    136         x = psVectorAlloc(numData, PS_TYPE_F64);
    137         x->n = numData;
    138         for (psS32 i=0;i<numData;i++) {
    139             x->data.F64[i] = (psF64) i;
    140         }
     145        x = psVectorCopy(NULL, xTruth, PS_TYPE_F64);
    141146    }
    142147
    … …  
    148153    if (flags & TS00_Y_F32) {
    149154        printf(" using a psF32 y vector\n");
    150         y = psVectorAlloc(numData, PS_TYPE_F32);
    151         y->n = numData;
    152         for (psS32 i=0;i<numData;i++) {
    153             y->data.F32[i] = (psF32) i;
    154         }
     155        y = psVectorCopy(NULL, yTruth, PS_TYPE_F32);
    155156    }
    156157
    157158    if (flags & TS00_Y_S32) {
    158159        printf(" using a psS32 y vector\n");
    159         y = psVectorAlloc(numData, PS_TYPE_S32);
    160         y->n = numData;
    161         for (psS32 i=0;i<numData;i++) {
    162             y->data.S32[i] = (psS32) i;
    163         }
     160        y = psVectorCopy(NULL, yTruth, PS_TYPE_S32);
    164161    }
    165162
    166163    if (flags & TS00_Y_F64) {
    167164        printf(" using a psF64 y vector\n");
    168         y = psVectorAlloc(numData, PS_TYPE_F64);
    169         y->n = numData;
    170         for (psS32 i=0;i<numData;i++) {
    171             y->data.F64[i] = (psF64) i;
    172         }
     165        y = psVectorCopy(NULL, yTruth, PS_TYPE_F64);
    173166    }
    174167
    … …  
    179172    if (flags & TS00_Z_F32) {
    180173        printf(" using a psF32 z vector\n");
    181         z = psVectorAlloc(numData, PS_TYPE_F32);
    182         z->n = numData;
    183         for (psS32 i=0;i<numData;i++) {
    184             z->data.F32[i] = (psF32) i;
    185         }
     174        z = psVectorCopy(NULL, zTruth, PS_TYPE_F32);
    186175    }
    187176
    188177    if (flags & TS00_Z_S32) {
    189178        printf(" using a psS32 z vector\n");
    190         z = psVectorAlloc(numData, PS_TYPE_S32);
    191         z->n = numData;
    192         for (psS32 i=0;i<numData;i++) {
    193             z->data.S32[i] = (psS32) i;
    194         }
     179        z = psVectorCopy(NULL, zTruth, PS_TYPE_S32);
    195180    }
    196181
    197182    if (flags & TS00_Z_F64) {
    198183        printf(" using a psF64 z vector\n");
    199         z = psVectorAlloc(numData, PS_TYPE_F64);
    200         z->n = numData;
    201         for (psS32 i=0;i<numData;i++) {
    202             z->data.F64[i] = (psF64) i;
    203         }
     184        z = psVectorCopy(NULL, zTruth, PS_TYPE_F64);
    204185    }
    205186
    … …  
    211192    if (flags & TS00_F_F32) {
    212193        printf(" using a psF32 f vector\n");
    213         f = psVectorAlloc(numData, PS_TYPE_F32);
    214         f->n = numData;
    215         for (psS32 i=0;i<numData;i++) {
    216             f->data.F32[i] = setData((psF32) i, (psF32) i, (psF32) i);
    217         }
     194        f = psVectorCopy(NULL, fTruth, PS_TYPE_F32);
    218195        // Set a few outliers in the data.
    219196        if (OUTLIERS && (flags & TS00_CLIP_FIT)) {
    … …  
    225202        if (VERBOSE) {
    226203            for (psS32 i=0;i<numData;i++) {
    227                 printf("Original data %d: (%.1f %.1f)\n", i, (psF32) i, f->data.F32[i]);
     204                printf("Original data %d: (%.1f)\n", i, f->data.F32[i]);
    228205            }
    229206        }
    … …  
    232209    if (flags & TS00_F_S32) {
    233210        printf(" using a psS32 f vector\n");
    234         f = psVectorAlloc(numData, PS_TYPE_S32);
    235         f->n = numData;
    236         for (psS32 i=0;i<numData;i++) {
    237             f->data.S32[i] = (psS32) setData((psF32) i, (psF32) i, (psF32) i);
    238         }
     211        f = psVectorCopy(NULL, fTruth, PS_TYPE_S32);
    239212        // Set a few outliers in the data.
    240213        if (OUTLIERS && (flags & TS00_CLIP_FIT)) {
    … …  
    246219        if (VERBOSE) {
    247220            for (psS32 i=0;i<numData;i++) {
    248                 printf("Original data %d: (%.1f %d)\n", i, (psF32) i, f->data.S32[i]);
     221                printf("Original data %d: (%d)\n", i, f->data.S32[i]);
    249222            }
    250223        }
    … …  
    253226    if (flags & TS00_F_F64) {
    254227        printf(" using a psF64 f vector\n");
    255         f = psVectorAlloc(numData, PS_TYPE_F64);
    256         f->n = numData;
    257         for (psS32 i=0;i<numData;i++) {
    258             f->data.F64[i] = (psF64) setData((psF32) i, (psF32) i, (psF32) i);
    259         }
     228        f = psVectorCopy(NULL, fTruth, PS_TYPE_F64);
    260229        // Set a few outliers in the data.
    261230        if (OUTLIERS && (flags & TS00_CLIP_FIT)) {
    … …  
    267236        if (VERBOSE) {
    268237            for (psS32 i=0;i<numData;i++) {
    269                 printf("Original data %d: (%.1f %.1f)\n", i, (psF32) i, f->data.F64[i]);
     238                printf("Original data %d: (%.1f)\n", i, f->data.F64[i]);
    270239            }
    271240        }
    … …  
    353322        }
    354323
     324        psVector *result = psPolynomial3DEvalVector(myPoly, xTruth, yTruth, zTruth);
    355325        for (psS32 i=0 ;i<numData; i++) {
    356326            // Skip the outliers.
    … …  
    358328                continue;
    359329            }
    360             psF32 expectData;
    361             psF32 xData;
    362             psF32 yData;
    363             psF32 zData;
    364             if (flags & TS00_F_F32) {
    365                 expectData = f->data.F32[i];
    366             } else if (flags & TS00_F_F64) {
    367                 expectData = (psF32) f->data.F64[i];
    368             } else if (flags & TS00_F_S32) {
    369                 expectData = (psF32) f->data.S32[i];
    370             }
    371 
    372             if (flags & TS00_X_F32) {
    373                 xData = x->data.F32[i];
    374             } else if (flags & TS00_X_F64) {
    375                 xData = (psF32) x->data.F64[i];
    376             } else if (flags & TS00_X_S32) {
    377                 xData = (psF32) x->data.S32[i];
    378             } else if (flags & TS00_X_NULL) {
    379                 xData = (psF32) i;
    380             }
    381 
    382             if (flags & TS00_Y_F32) {
    383                 yData = y->data.F32[i];
    384             } else if (flags & TS00_Y_F64) {
    385                 yData = (psF32) y->data.F64[i];
    386             } else if (flags & TS00_Y_S32) {
    387                 yData = (psF32) y->data.S32[i];
    388             } else if (flags & TS00_Y_NULL) {
    389                 yData = (psF32) i;
    390             }
    391 
    392             if (flags & TS00_Z_F32) {
    393                 zData = z->data.F32[i];
    394             } else if (flags & TS00_Z_F64) {
    395                 zData = (psF32) z->data.F64[i];
    396             } else if (flags & TS00_Z_S32) {
    397                 zData = (psF32) z->data.S32[i];
    398             } else if (flags & TS00_Z_NULL) {
    399                 zData = (psF32) i;
    400             }
    401 
    402             psF32 actualData = psPolynomial3DEval(myPoly, xData, yData, zData);
     330            psF32 expectData = fTruth->data.F64[i];
     331            psF32 actualData = result->data.F64[i];
    403332
    404333            if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
    405                 printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
    406                        i, xData, actualData, expectData);
     334                printf("TEST ERROR: Fitted data %d: (%.1f), expected was (%.1f)\n",
     335                       i, actualData, expectData);
    407336                testStatus = false;
    408337            } else {
    409338                if (VERBOSE) {
    410                     printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
    411                            i, xData, actualData, expectData);
     339                    printf("GOOD: Fitted data %d: (%.1f), expected was (%.1f)\n",
     340                           i, actualData, expectData);
    412341                }
    413342            }
    414343        }
     344        psFree(result);
    415345    }
    416346
    … …  
    422352    psFree(z);
    423353    psFree(f);
     354    psFree(xTruth);
     355    psFree(yTruth);
     356    psFree(zTruth);
     357    psFree(fTruth);
    424358    psFree(fErr);
    425359    psFree(stats);
Note: See TracChangeset for help on using the changeset viewer.