IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 12, 2006, 11:03:44 AM (20 years ago)
Author:
drobbin
Message:

Reset error outputs. (just a psWarning was removed at some point from p_psVectorSampleMedian).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/math/verified/tst_psPolyFit4D.stdout

    r6100 r7109  
    1111\**********************************************************************************/
    1212
    13         performing a non clip-fit
    14         using ordinary polynomials
    15         using a psF32 x vector
    16         using a psF32 y vector
    17         using a psF32 z vector
    18         using a psF32 t vector
    19         using a psF32 f vector
    20         using a psF32 fErr vector
    21         using a psU8 mask vector
    22 
    23 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    24 
    25 /***************************** TESTPOINT ******************************************\
    26 *             TestFile: tst_psPolyFit4D.c                                          *
    27 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    28 *             TestType: Positive                                                   *
    29 \**********************************************************************************/
    30 
    31         performing a non clip-fit
    32         using ordinary polynomials
    33         using a psF32 x vector
    34         using a psF32 y vector
    35         using a psF32 z vector
    36         using a psF32 t vector
    37         using a psF32 f vector
    38         using a NULL fErr vector
    39         using a psU8 mask vector
    40 
    41 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    42 
    43 /***************************** TESTPOINT ******************************************\
    44 *             TestFile: tst_psPolyFit4D.c                                          *
    45 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    46 *             TestType: Positive                                                   *
    47 \**********************************************************************************/
    48 
    49 This test should generate an error message, and return NULL.
    50         performing a non clip-fit
    51         using ordinary polynomials
    52         using a NULL x vector
    53         using a psF32 y vector
    54         using a psF32 z vector
    55         using a psF32 t vector
    56         using a psF32 f vector
    57         using a psF32 fErr vector
    58         using a psU8 mask vector
    59 
    60 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    61 
    62 /***************************** TESTPOINT ******************************************\
    63 *             TestFile: tst_psPolyFit4D.c                                          *
    64 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    65 *             TestType: Positive                                                   *
    66 \**********************************************************************************/
    67 
    68 This test should generate an error message, and return NULL.
    69         performing a non clip-fit
    70         using ordinary polynomials
    71         using a psF32 x vector
    72         using a NULL y vector
    73         using a psF32 z vector
    74         using a psF32 t vector
    75         using a psF32 f vector
    76         using a psF32 fErr vector
    77         using a psU8 mask vector
    78 
    79 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    80 
    81 /***************************** TESTPOINT ******************************************\
    82 *             TestFile: tst_psPolyFit4D.c                                          *
    83 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    84 *             TestType: Positive                                                   *
    85 \**********************************************************************************/
    86 
    87 This test should generate an error message, and return NULL.
    88         performing a non clip-fit
    89         using ordinary polynomials
    90         using a psF32 x vector
    91         using a psF32 y vector
    92         using a NULL z vector
    93         using a psF32 t vector
    94         using a psF32 f vector
    95         using a psF32 fErr vector
    96         using a psU8 mask vector
    97 
    98 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    99 
    100 /***************************** TESTPOINT ******************************************\
    101 *             TestFile: tst_psPolyFit4D.c                                          *
    102 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    103 *             TestType: Positive                                                   *
    104 \**********************************************************************************/
    105 
    106 This test should generate an error message, and return NULL.
    107         performing a non clip-fit
    108         using ordinary polynomials
    109         using a psF32 x vector
    110         using a psF32 y vector
    111         using a psF32 z vector
    112         using a NULL t vector
    113         using a psF32 f vector
    114         using a psF32 fErr vector
    115         using a psU8 mask vector
    116 
    117 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    118 
    119 /***************************** TESTPOINT ******************************************\
    120 *             TestFile: tst_psPolyFit4D.c                                          *
    121 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    122 *             TestType: Positive                                                   *
    123 \**********************************************************************************/
    124 
    125         performing a non clip-fit
    126         using ordinary polynomials
    127         using a psF32 x vector
    128         using a psF32 y vector
    129         using a psF32 z vector
    130         using a psF32 t vector
    131         using a psF32 f vector
    132         using a psF32 fErr vector
    133         using a NULL mask vector
    134 
    135 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    136 
    137 /***************************** TESTPOINT ******************************************\
    138 *             TestFile: tst_psPolyFit4D.c                                          *
    139 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    140 *             TestType: Positive                                                   *
    141 \**********************************************************************************/
    142 
    143 This test should generate an error message, and return NULL.
    144         performing a non clip-fit
    145         using ordinary polynomials
    146         using a psF32 x vector
    147         using a psF32 y vector
    148         using a psF32 z vector
    149         using a psF32 t vector
    150         using a NULL f vector
    151         using a psF32 fErr vector
    152         using a psU8 mask vector
    153 
    154 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    155 
    156 /***************************** TESTPOINT ******************************************\
    157 *             TestFile: tst_psPolyFit4D.c                                          *
    158 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    159 *             TestType: Positive                                                   *
    160 \**********************************************************************************/
    161 
    162         performing a non clip-fit
    163         using ordinary polynomials
    164         using a psF32 x vector
    165         using a psF32 y vector
    166         using a psF32 z vector
    167         using a psF32 t vector
    168         using a psF32 f vector
    169         using a psF32 fErr vector
    170         using a NULL mask vector
    171 
    172 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    173 
    174 /***************************** TESTPOINT ******************************************\
    175 *             TestFile: tst_psPolyFit4D.c                                          *
    176 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    177 *             TestType: Positive                                                   *
    178 \**********************************************************************************/
    179 
    180         performing a non clip-fit
    181         using ordinary polynomials
    182         using a psF32 x vector
    183         using a psF32 y vector
    184         using a psF32 z vector
    185         using a psF32 t vector
    186         using a psF32 f vector
    187         using a psF64 fErr vector
    188         using a psU8 mask vector
    189 
    190 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    191 
    192 /***************************** TESTPOINT ******************************************\
    193 *             TestFile: tst_psPolyFit4D.c                                          *
    194 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    195 *             TestType: Positive                                                   *
    196 \**********************************************************************************/
    197 
    198         performing a non clip-fit
    199         using ordinary polynomials
    200         using a psF64 x vector
    201         using a psF32 y vector
    202         using a psF32 z vector
    203         using a psF32 t vector
    204         using a psF32 f vector
    205         using a psF32 fErr vector
    206         using a psU8 mask vector
    207 
    208 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    209 
    210 /***************************** TESTPOINT ******************************************\
    211 *             TestFile: tst_psPolyFit4D.c                                          *
    212 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    213 *             TestType: Positive                                                   *
    214 \**********************************************************************************/
    215 
    216         performing a non clip-fit
    217         using ordinary polynomials
    218         using a psF32 x vector
    219         using a psF64 y vector
    220         using a psF32 z vector
    221         using a psF32 t vector
    222         using a psF32 f vector
    223         using a psF32 fErr vector
    224         using a psU8 mask vector
    225 
    226 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    227 
    228 /***************************** TESTPOINT ******************************************\
    229 *             TestFile: tst_psPolyFit4D.c                                          *
    230 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    231 *             TestType: Positive                                                   *
    232 \**********************************************************************************/
    233 
    234         performing a non clip-fit
    235         using ordinary polynomials
    236         using a psF32 x vector
    237         using a psF32 y vector
    238         using a psF64 z vector
    239         using a psF32 t vector
    240         using a psF32 f vector
    241         using a psF32 fErr vector
    242         using a psU8 mask vector
    243 
    244 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    245 
    246 /***************************** TESTPOINT ******************************************\
    247 *             TestFile: tst_psPolyFit4D.c                                          *
    248 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    249 *             TestType: Positive                                                   *
    250 \**********************************************************************************/
    251 
    252         performing a non clip-fit
    253         using ordinary polynomials
    254         using a psF32 x vector
    255         using a psF32 y vector
    256         using a psF32 z vector
    257         using a psF64 t vector
    258         using a psF32 f vector
    259         using a psF32 fErr vector
    260         using a psU8 mask vector
    261 
    262 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    263 
    264 /***************************** TESTPOINT ******************************************\
    265 *             TestFile: tst_psPolyFit4D.c                                          *
    266 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    267 *             TestType: Positive                                                   *
    268 \**********************************************************************************/
    269 
    270         performing a non clip-fit
    271         using ordinary polynomials
    272         using a psF32 x vector
    273         using a psF32 y vector
    274         using a psF32 z vector
    275         using a psF32 t vector
    276         using a psF64 f vector
    277         using a psF32 fErr vector
    278         using a psU8 mask vector
    279 
    280 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    281 
    282 /***************************** TESTPOINT ******************************************\
    283 *             TestFile: tst_psPolyFit4D.c                                          *
    284 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    285 *             TestType: Positive                                                   *
    286 \**********************************************************************************/
    287 
    288 This test should generate an error message, and return NULL.
    289         performing a non clip-fit
    290         using ordinary polynomials
    291         using a psF32 x vector
    292         using a psF32 y vector
    293         using a psF32 z vector
    294         using a psF32 t vector
    295         using a psF32 f vector
    296         using a psF32 fErr vector
    297         using a psS32 mask vector
    298 
    299 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    300 
    301 /***************************** TESTPOINT ******************************************\
    302 *             TestFile: tst_psPolyFit4D.c                                          *
    303 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    304 *             TestType: Positive                                                   *
    305 \**********************************************************************************/
    306 
    307         performing a non clip-fit
    308         using ordinary polynomials
    309         using a psF64 x vector
    310         using a psF64 y vector
    311         using a psF64 z vector
    312         using a psF64 t vector
    313         using a psF64 f vector
    314         using a psF64 fErr vector
    315         using a psU8 mask vector
    316 
    317 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    318 
    319 /***************************** TESTPOINT ******************************************\
    320 *             TestFile: tst_psPolyFit4D.c                                          *
    321 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    322 *             TestType: Positive                                                   *
    323 \**********************************************************************************/
    324 
    325         performing a non clip-fit
    326         using ordinary polynomials
    327         using a psF64 x vector
    328         using a psF64 y vector
    329         using a psF64 z vector
    330         using a psF64 t vector
    331         using a psF64 f vector
    332         using a NULL fErr vector
    333         using a psU8 mask vector
    334 
    335 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    336 
    337 /***************************** TESTPOINT ******************************************\
    338 *             TestFile: tst_psPolyFit4D.c                                          *
    339 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    340 *             TestType: Positive                                                   *
    341 \**********************************************************************************/
    342 
    343 This test should generate an error message, and return NULL.
    344         performing a non clip-fit
    345         using ordinary polynomials
    346         using a NULL x vector
    347         using a psF64 y vector
    348         using a psF64 z vector
    349         using a psF64 t vector
    350         using a psF64 f vector
    351         using a psF64 fErr vector
    352         using a psU8 mask vector
    353 
    354 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    355 
    356 /***************************** TESTPOINT ******************************************\
    357 *             TestFile: tst_psPolyFit4D.c                                          *
    358 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    359 *             TestType: Positive                                                   *
    360 \**********************************************************************************/
    361 
    362 This test should generate an error message, and return NULL.
    363         performing a non clip-fit
    364         using ordinary polynomials
    365         using a psF64 x vector
    366         using a NULL y vector
    367         using a psF64 z vector
    368         using a psF64 t vector
    369         using a psF64 f vector
    370         using a psF64 fErr vector
    371         using a psU8 mask vector
    372 
    373 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    374 
    375 /***************************** TESTPOINT ******************************************\
    376 *             TestFile: tst_psPolyFit4D.c                                          *
    377 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    378 *             TestType: Positive                                                   *
    379 \**********************************************************************************/
    380 
    381 This test should generate an error message, and return NULL.
    382         performing a non clip-fit
    383         using ordinary polynomials
    384         using a psF64 x vector
    385         using a psF64 y vector
    386         using a NULL z vector
    387         using a psF64 t vector
    388         using a psF64 f vector
    389         using a psF64 fErr vector
    390         using a psU8 mask vector
    391 
    392 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    393 
    394 /***************************** TESTPOINT ******************************************\
    395 *             TestFile: tst_psPolyFit4D.c                                          *
    396 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    397 *             TestType: Positive                                                   *
    398 \**********************************************************************************/
    399 
    400 This test should generate an error message, and return NULL.
    401         performing a non clip-fit
    402         using ordinary polynomials
    403         using a psF64 x vector
    404         using a psF64 y vector
    405         using a psF64 z vector
    406         using a NULL t vector
    407         using a psF64 f vector
    408         using a psF64 fErr vector
    409         using a psU8 mask vector
    410 
    411 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    412 
    413 /***************************** TESTPOINT ******************************************\
    414 *             TestFile: tst_psPolyFit4D.c                                          *
    415 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    416 *             TestType: Positive                                                   *
    417 \**********************************************************************************/
    418 
    419         performing a non clip-fit
    420         using ordinary polynomials
    421         using a psF64 x vector
    422         using a psF64 y vector
    423         using a psF64 z vector
    424         using a psF64 t vector
    425         using a psF64 f vector
    426         using a psF64 fErr vector
    427         using a NULL mask vector
    428 
    429 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    430 
    431 /***************************** TESTPOINT ******************************************\
    432 *             TestFile: tst_psPolyFit4D.c                                          *
    433 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    434 *             TestType: Positive                                                   *
    435 \**********************************************************************************/
    436 
    437 This test should generate an error message, and return NULL.
    438         performing a non clip-fit
    439         using ordinary polynomials
    440         using a psF64 x vector
    441         using a psF64 y vector
    442         using a psF64 z vector
    443         using a psF64 t vector
    444         using a NULL f vector
    445         using a psF64 fErr vector
    446         using a psU8 mask vector
    447 
    448 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    449 
    450 /***************************** TESTPOINT ******************************************\
    451 *             TestFile: tst_psPolyFit4D.c                                          *
    452 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    453 *             TestType: Positive                                                   *
    454 \**********************************************************************************/
    455 
    456         performing a non clip-fit
    457         using ordinary polynomials
    458         using a psF64 x vector
    459         using a psF64 y vector
    460         using a psF64 z vector
    461         using a psF64 t vector
    462         using a psF64 f vector
    463         using a psF64 fErr vector
    464         using a NULL mask vector
    465 
    466 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    467 
    468 /***************************** TESTPOINT ******************************************\
    469 *             TestFile: tst_psPolyFit4D.c                                          *
    470 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    471 *             TestType: Positive                                                   *
    472 \**********************************************************************************/
    473 
    474         performing a non clip-fit
    475         using ordinary polynomials
    476         using a psF64 x vector
    477         using a psF64 y vector
    478         using a psF64 z vector
    479         using a psF64 t vector
    480         using a psF64 f vector
    481         using a psF32 fErr vector
    482         using a psU8 mask vector
    483 
    484 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    485 
    486 /***************************** TESTPOINT ******************************************\
    487 *             TestFile: tst_psPolyFit4D.c                                          *
    488 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    489 *             TestType: Positive                                                   *
    490 \**********************************************************************************/
    491 
    492         performing a non clip-fit
    493         using ordinary polynomials
    494         using a psF32 x vector
    495         using a psF64 y vector
    496         using a psF64 z vector
    497         using a psF64 t vector
    498         using a psF64 f vector
    499         using a psF64 fErr vector
    500         using a psU8 mask vector
    501 
    502 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    503 
    504 /***************************** TESTPOINT ******************************************\
    505 *             TestFile: tst_psPolyFit4D.c                                          *
    506 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    507 *             TestType: Positive                                                   *
    508 \**********************************************************************************/
    509 
    510         performing a non clip-fit
    511         using ordinary polynomials
    512         using a psF64 x vector
    513         using a psF32 y vector
    514         using a psF64 z vector
    515         using a psF64 t vector
    516         using a psF64 f vector
    517         using a psF64 fErr vector
    518         using a psU8 mask vector
    519 
    520 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    521 
    522 /***************************** TESTPOINT ******************************************\
    523 *             TestFile: tst_psPolyFit4D.c                                          *
    524 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    525 *             TestType: Positive                                                   *
    526 \**********************************************************************************/
    527 
    528         performing a non clip-fit
    529         using ordinary polynomials
    530         using a psF64 x vector
    531         using a psF64 y vector
    532         using a psF32 z vector
    533         using a psF64 t vector
    534         using a psF64 f vector
    535         using a psF64 fErr vector
    536         using a psU8 mask vector
    537 
    538 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    539 
    540 /***************************** TESTPOINT ******************************************\
    541 *             TestFile: tst_psPolyFit4D.c                                          *
    542 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    543 *             TestType: Positive                                                   *
    544 \**********************************************************************************/
    545 
    546         performing a non clip-fit
    547         using ordinary polynomials
    548         using a psF64 x vector
    549         using a psF64 y vector
    550         using a psF64 z vector
    551         using a psF32 t vector
    552         using a psF64 f vector
    553         using a psF64 fErr vector
    554         using a psU8 mask vector
    555 
    556 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    557 
    558 /***************************** TESTPOINT ******************************************\
    559 *             TestFile: tst_psPolyFit4D.c                                          *
    560 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    561 *             TestType: Positive                                                   *
    562 \**********************************************************************************/
    563 
    564         performing a non clip-fit
    565         using ordinary polynomials
    566         using a psF64 x vector
    567         using a psF64 y vector
    568         using a psF64 z vector
    569         using a psF64 t vector
    570         using a psF32 f vector
    571         using a psF64 fErr vector
    572         using a psU8 mask vector
    573 
    574 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    575 
    576 /***************************** TESTPOINT ******************************************\
    577 *             TestFile: tst_psPolyFit4D.c                                          *
    578 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    579 *             TestType: Positive                                                   *
    580 \**********************************************************************************/
    581 
    582 This test should generate an error message, and return NULL.
    583         performing a non clip-fit
    584         using ordinary polynomials
    585         using a psF64 x vector
    586         using a psF64 y vector
    587         using a psF64 z vector
    588         using a psF64 t vector
    589         using a psF64 f vector
    590         using a psF64 fErr vector
    591         using a psS32 mask vector
    592 
    593 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    594 
    595 /***************************** TESTPOINT ******************************************\
    596 *             TestFile: tst_psPolyFit4D.c                                          *
    597 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    598 *             TestType: Positive                                                   *
    599 \**********************************************************************************/
    600 
    601         performing a clip-fit
    602         using ordinary polynomials
    603         using a psF32 x vector
    604         using a psF32 y vector
    605         using a psF32 z vector
    606         using a psF32 t vector
    607         using a psF32 f vector
    608         using a psF32 fErr vector
    609         using a psU8 mask vector
    610 
    611 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    612 
    613 /***************************** TESTPOINT ******************************************\
    614 *             TestFile: tst_psPolyFit4D.c                                          *
    615 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    616 *             TestType: Positive                                                   *
    617 \**********************************************************************************/
    618 
    619         performing a clip-fit
    620         using ordinary polynomials
    621         using a psF32 x vector
    622         using a psF32 y vector
    623         using a psF32 z vector
    624         using a psF32 t vector
    625         using a psF32 f vector
    626         using a NULL fErr vector
    627         using a psU8 mask vector
    628 
    629 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    630 
    631 /***************************** TESTPOINT ******************************************\
    632 *             TestFile: tst_psPolyFit4D.c                                          *
    633 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    634 *             TestType: Positive                                                   *
    635 \**********************************************************************************/
    636 
    637 This test should generate an error message, and return NULL.
    638         performing a clip-fit
    639         using ordinary polynomials
    640         using a NULL x vector
    641         using a psF32 y vector
    642         using a psF32 z vector
    643         using a psF32 t vector
    644         using a psF32 f vector
    645         using a psF32 fErr vector
    646         using a psU8 mask vector
    647 
    648 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    649 
    650 /***************************** TESTPOINT ******************************************\
    651 *             TestFile: tst_psPolyFit4D.c                                          *
    652 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    653 *             TestType: Positive                                                   *
    654 \**********************************************************************************/
    655 
    656 This test should generate an error message, and return NULL.
    657         performing a clip-fit
    658         using ordinary polynomials
    659         using a psF32 x vector
    660         using a NULL y vector
    661         using a psF32 z vector
    662         using a psF32 t vector
    663         using a psF32 f vector
    664         using a psF32 fErr vector
    665         using a psU8 mask vector
    666 
    667 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    668 
    669 /***************************** TESTPOINT ******************************************\
    670 *             TestFile: tst_psPolyFit4D.c                                          *
    671 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    672 *             TestType: Positive                                                   *
    673 \**********************************************************************************/
    674 
    675 This test should generate an error message, and return NULL.
    676         performing a clip-fit
    677         using ordinary polynomials
    678         using a psF32 x vector
    679         using a psF32 y vector
    680         using a NULL z vector
    681         using a psF32 t vector
    682         using a psF32 f vector
    683         using a psF32 fErr vector
    684         using a psU8 mask vector
    685 
    686 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    687 
    688 /***************************** TESTPOINT ******************************************\
    689 *             TestFile: tst_psPolyFit4D.c                                          *
    690 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    691 *             TestType: Positive                                                   *
    692 \**********************************************************************************/
    693 
    694 This test should generate an error message, and return NULL.
    695         performing a clip-fit
    696         using ordinary polynomials
    697         using a psF32 x vector
    698         using a psF32 y vector
    699         using a psF32 z vector
    700         using a NULL t vector
    701         using a psF32 f vector
    702         using a psF32 fErr vector
    703         using a psU8 mask vector
    704 
    705 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    706 
    707 /***************************** TESTPOINT ******************************************\
    708 *             TestFile: tst_psPolyFit4D.c                                          *
    709 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    710 *             TestType: Positive                                                   *
    711 \**********************************************************************************/
    712 
    713 This test should generate an error message, and return NULL.
    714         performing a clip-fit
    715         using ordinary polynomials
    716         using a psF32 x vector
    717         using a psF32 y vector
    718         using a psF32 z vector
    719         using a psF32 t vector
    720         using a NULL f vector
    721         using a psF32 fErr vector
    722         using a psU8 mask vector
    723 
    724 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    725 
    726 /***************************** TESTPOINT ******************************************\
    727 *             TestFile: tst_psPolyFit4D.c                                          *
    728 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    729 *             TestType: Positive                                                   *
    730 \**********************************************************************************/
    731 
    732 This test should generate an error message, and return NULL.
    733         performing a clip-fit
    734         using ordinary polynomials
    735         using a psF32 x vector
    736         using a psF32 y vector
    737         using a psF32 z vector
    738         using a psF32 t vector
    739         using a psF32 f vector
    740         using a psF32 fErr vector
    741         using a NULL mask vector
    742 
    743 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    744 
    745 /***************************** TESTPOINT ******************************************\
    746 *             TestFile: tst_psPolyFit4D.c                                          *
    747 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    748 *             TestType: Positive                                                   *
    749 \**********************************************************************************/
    750 
    751 This test should generate an error message, and return NULL.
    752         performing a clip-fit
    753         using ordinary polynomials
    754         using a psF32 x vector
    755         using a psF32 y vector
    756         using a psF32 z vector
    757         using a psF32 t vector
    758         using a psF32 f vector
    759         using a psF64 fErr vector
    760         using a psU8 mask vector
    761 
    762 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    763 
    764 /***************************** TESTPOINT ******************************************\
    765 *             TestFile: tst_psPolyFit4D.c                                          *
    766 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    767 *             TestType: Positive                                                   *
    768 \**********************************************************************************/
    769 
    770 This test should generate an error message, and return NULL.
    771         performing a clip-fit
    772         using ordinary polynomials
    773         using a psF64 x vector
    774         using a psF32 y vector
    775         using a psF32 z vector
    776         using a psF32 t vector
    777         using a psF32 f vector
    778         using a psF32 fErr vector
    779         using a psU8 mask vector
    780 
    781 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    782 
    783 /***************************** TESTPOINT ******************************************\
    784 *             TestFile: tst_psPolyFit4D.c                                          *
    785 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    786 *             TestType: Positive                                                   *
    787 \**********************************************************************************/
    788 
    789 This test should generate an error message, and return NULL.
    790         performing a clip-fit
    791         using ordinary polynomials
    792         using a psF32 x vector
    793         using a psF64 y vector
    794         using a psF32 z vector
    795         using a psF32 t vector
    796         using a psF32 f vector
    797         using a psF32 fErr vector
    798         using a psU8 mask vector
    799 
    800 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    801 
    802 /***************************** TESTPOINT ******************************************\
    803 *             TestFile: tst_psPolyFit4D.c                                          *
    804 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    805 *             TestType: Positive                                                   *
    806 \**********************************************************************************/
    807 
    808 This test should generate an error message, and return NULL.
    809         performing a clip-fit
    810         using ordinary polynomials
    811         using a psF32 x vector
    812         using a psF32 y vector
    813         using a psF64 z vector
    814         using a psF32 t vector
    815         using a psF32 f vector
    816         using a psF32 fErr vector
    817         using a psU8 mask vector
    818 
    819 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    820 
    821 /***************************** TESTPOINT ******************************************\
    822 *             TestFile: tst_psPolyFit4D.c                                          *
    823 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    824 *             TestType: Positive                                                   *
    825 \**********************************************************************************/
    826 
    827 This test should generate an error message, and return NULL.
    828         performing a clip-fit
    829         using ordinary polynomials
    830         using a psF32 x vector
    831         using a psF32 y vector
    832         using a psF32 z vector
    833         using a psF64 t vector
    834         using a psF32 f vector
    835         using a psF32 fErr vector
    836         using a psU8 mask vector
    837 
    838 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    839 
    840 /***************************** TESTPOINT ******************************************\
    841 *             TestFile: tst_psPolyFit4D.c                                          *
    842 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    843 *             TestType: Positive                                                   *
    844 \**********************************************************************************/
    845 
    846 This test should generate an error message, and return NULL.
    847         performing a clip-fit
    848         using ordinary polynomials
    849         using a psF32 x vector
    850         using a psF32 y vector
    851         using a psF32 z vector
    852         using a psF32 t vector
    853         using a psF64 f vector
    854         using a psF32 fErr vector
    855         using a psU8 mask vector
    856 
    857 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    858 
    859 /***************************** TESTPOINT ******************************************\
    860 *             TestFile: tst_psPolyFit4D.c                                          *
    861 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    862 *             TestType: Positive                                                   *
    863 \**********************************************************************************/
    864 
    865 This test should generate an error message, and return NULL.
    866         performing a clip-fit
    867         using ordinary polynomials
    868         using a psF32 x vector
    869         using a psF32 y vector
    870         using a psF32 z vector
    871         using a psF32 t vector
    872         using a psF32 f vector
    873         using a psF32 fErr vector
    874         using a psS32 mask vector
    875 
    876 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    877 
    878 /***************************** TESTPOINT ******************************************\
    879 *             TestFile: tst_psPolyFit4D.c                                          *
    880 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    881 *             TestType: Positive                                                   *
    882 \**********************************************************************************/
    883 
    884         performing a clip-fit
    885         using ordinary polynomials
    886         using a psF64 x vector
    887         using a psF64 y vector
    888         using a psF64 z vector
    889         using a psF64 t vector
    890         using a psF64 f vector
    891         using a psF64 fErr vector
    892         using a psU8 mask vector
    893 
    894 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    895 
    896 /***************************** TESTPOINT ******************************************\
    897 *             TestFile: tst_psPolyFit4D.c                                          *
    898 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    899 *             TestType: Positive                                                   *
    900 \**********************************************************************************/
    901 
    902         performing a clip-fit
    903         using ordinary polynomials
    904         using a psF64 x vector
    905         using a psF64 y vector
    906         using a psF64 z vector
    907         using a psF64 t vector
    908         using a psF64 f vector
    909         using a NULL fErr vector
    910         using a psU8 mask vector
    911 
    912 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    913 
    914 /***************************** TESTPOINT ******************************************\
    915 *             TestFile: tst_psPolyFit4D.c                                          *
    916 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    917 *             TestType: Positive                                                   *
    918 \**********************************************************************************/
    919 
    920 This test should generate an error message, and return NULL.
    921         performing a clip-fit
    922         using ordinary polynomials
    923         using a NULL x vector
    924         using a psF64 y vector
    925         using a psF64 z vector
    926         using a psF64 t vector
    927         using a psF64 f vector
    928         using a psF64 fErr vector
    929         using a psU8 mask vector
    930 
    931 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    932 
    933 /***************************** TESTPOINT ******************************************\
    934 *             TestFile: tst_psPolyFit4D.c                                          *
    935 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    936 *             TestType: Positive                                                   *
    937 \**********************************************************************************/
    938 
    939 This test should generate an error message, and return NULL.
    940         performing a clip-fit
    941         using ordinary polynomials
    942         using a psF64 x vector
    943         using a NULL y vector
    944         using a psF64 z vector
    945         using a psF64 t vector
    946         using a psF64 f vector
    947         using a psF64 fErr vector
    948         using a psU8 mask vector
    949 
    950 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    951 
    952 /***************************** TESTPOINT ******************************************\
    953 *             TestFile: tst_psPolyFit4D.c                                          *
    954 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    955 *             TestType: Positive                                                   *
    956 \**********************************************************************************/
    957 
    958 This test should generate an error message, and return NULL.
    959         performing a clip-fit
    960         using ordinary polynomials
    961         using a psF64 x vector
    962         using a psF64 y vector
    963         using a NULL z vector
    964         using a psF64 t vector
    965         using a psF64 f vector
    966         using a psF64 fErr vector
    967         using a psU8 mask vector
    968 
    969 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    970 
    971 /***************************** TESTPOINT ******************************************\
    972 *             TestFile: tst_psPolyFit4D.c                                          *
    973 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    974 *             TestType: Positive                                                   *
    975 \**********************************************************************************/
    976 
    977 This test should generate an error message, and return NULL.
    978         performing a clip-fit
    979         using ordinary polynomials
    980         using a psF64 x vector
    981         using a psF64 y vector
    982         using a psF64 z vector
    983         using a NULL t vector
    984         using a psF64 f vector
    985         using a psF64 fErr vector
    986         using a psU8 mask vector
    987 
    988 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    989 
    990 /***************************** TESTPOINT ******************************************\
    991 *             TestFile: tst_psPolyFit4D.c                                          *
    992 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    993 *             TestType: Positive                                                   *
    994 \**********************************************************************************/
    995 
    996 This test should generate an error message, and return NULL.
    997         performing a clip-fit
    998         using ordinary polynomials
    999         using a psF64 x vector
    1000         using a psF64 y vector
    1001         using a psF64 z vector
    1002         using a psF64 t vector
    1003         using a NULL f vector
    1004         using a psF64 fErr vector
    1005         using a psU8 mask vector
    1006 
    1007 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1008 
    1009 /***************************** TESTPOINT ******************************************\
    1010 *             TestFile: tst_psPolyFit4D.c                                          *
    1011 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1012 *             TestType: Positive                                                   *
    1013 \**********************************************************************************/
    1014 
    1015 This test should generate an error message, and return NULL.
    1016         performing a clip-fit
    1017         using ordinary polynomials
    1018         using a psF64 x vector
    1019         using a psF64 y vector
    1020         using a psF64 z vector
    1021         using a psF64 t vector
    1022         using a psF64 f vector
    1023         using a psF64 fErr vector
    1024         using a NULL mask vector
    1025 
    1026 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1027 
    1028 /***************************** TESTPOINT ******************************************\
    1029 *             TestFile: tst_psPolyFit4D.c                                          *
    1030 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1031 *             TestType: Positive                                                   *
    1032 \**********************************************************************************/
    1033 
    1034 This test should generate an error message, and return NULL.
    1035         performing a clip-fit
    1036         using ordinary polynomials
    1037         using a psF64 x vector
    1038         using a psF64 y vector
    1039         using a psF64 z vector
    1040         using a psF64 t vector
    1041         using a psF64 f vector
    1042         using a psF32 fErr vector
    1043         using a psU8 mask vector
    1044 
    1045 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1046 
    1047 /***************************** TESTPOINT ******************************************\
    1048 *             TestFile: tst_psPolyFit4D.c                                          *
    1049 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1050 *             TestType: Positive                                                   *
    1051 \**********************************************************************************/
    1052 
    1053 This test should generate an error message, and return NULL.
    1054         performing a clip-fit
    1055         using ordinary polynomials
    1056         using a psF32 x vector
    1057         using a psF64 y vector
    1058         using a psF64 z vector
    1059         using a psF64 t vector
    1060         using a psF64 f vector
    1061         using a psF64 fErr vector
    1062         using a psU8 mask vector
    1063 
    1064 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1065 
    1066 /***************************** TESTPOINT ******************************************\
    1067 *             TestFile: tst_psPolyFit4D.c                                          *
    1068 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1069 *             TestType: Positive                                                   *
    1070 \**********************************************************************************/
    1071 
    1072 This test should generate an error message, and return NULL.
    1073         performing a clip-fit
    1074         using ordinary polynomials
    1075         using a psF64 x vector
    1076         using a psF32 y vector
    1077         using a psF64 z vector
    1078         using a psF64 t vector
    1079         using a psF64 f vector
    1080         using a psF64 fErr vector
    1081         using a psU8 mask vector
    1082 
    1083 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1084 
    1085 /***************************** TESTPOINT ******************************************\
    1086 *             TestFile: tst_psPolyFit4D.c                                          *
    1087 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1088 *             TestType: Positive                                                   *
    1089 \**********************************************************************************/
    1090 
    1091 This test should generate an error message, and return NULL.
    1092         performing a clip-fit
    1093         using ordinary polynomials
    1094         using a psF64 x vector
    1095         using a psF64 y vector
    1096         using a psF32 z vector
    1097         using a psF64 t vector
    1098         using a psF64 f vector
    1099         using a psF64 fErr vector
    1100         using a psU8 mask vector
    1101 
    1102 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1103 
    1104 /***************************** TESTPOINT ******************************************\
    1105 *             TestFile: tst_psPolyFit4D.c                                          *
    1106 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1107 *             TestType: Positive                                                   *
    1108 \**********************************************************************************/
    1109 
    1110 This test should generate an error message, and return NULL.
    1111         performing a clip-fit
    1112         using ordinary polynomials
    1113         using a psF64 x vector
    1114         using a psF64 y vector
    1115         using a psF64 z vector
    1116         using a psF32 t vector
    1117         using a psF64 f vector
    1118         using a psF64 fErr vector
    1119         using a psU8 mask vector
    1120 
    1121 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1122 
    1123 /***************************** TESTPOINT ******************************************\
    1124 *             TestFile: tst_psPolyFit4D.c                                          *
    1125 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1126 *             TestType: Positive                                                   *
    1127 \**********************************************************************************/
    1128 
    1129 This test should generate an error message, and return NULL.
    1130         performing a clip-fit
    1131         using ordinary polynomials
    1132         using a psF64 x vector
    1133         using a psF64 y vector
    1134         using a psF64 z vector
    1135         using a psF64 t vector
    1136         using a psF32 f vector
    1137         using a psF64 fErr vector
    1138         using a psU8 mask vector
    1139 
    1140 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1141 
    1142 /***************************** TESTPOINT ******************************************\
    1143 *             TestFile: tst_psPolyFit4D.c                                          *
    1144 *            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
    1145 *             TestType: Positive                                                   *
    1146 \**********************************************************************************/
    1147 
    1148 This test should generate an error message, and return NULL.
    1149         performing a clip-fit
    1150         using ordinary polynomials
    1151         using a psF64 x vector
    1152         using a psF64 y vector
    1153         using a psF64 z vector
    1154         using a psF64 t vector
    1155         using a psF64 f vector
    1156         using a psF64 fErr vector
    1157         using a psS32 mask vector
    1158 
    1159 ---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
    1160 
     13 performing a non clip-fit
     14 using ordinary polynomials
     15 using a psF32 x vector
     16 using a psF32 y vector
     17 using a psF32 z vector
     18 using a psF32 t vector
     19 using a psF32 f vector
     20 using a psF32 fErr vector
     21 using a psU8 mask vector
     22
     23---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     24
     25/***************************** TESTPOINT ******************************************\
     26*             TestFile: tst_psPolyFit4D.c                                          *
     27*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     28*             TestType: Positive                                                   *
     29\**********************************************************************************/
     30
     31 performing a non clip-fit
     32 using ordinary polynomials
     33 using a psF32 x vector
     34 using a psF32 y vector
     35 using a psF32 z vector
     36 using a psF32 t vector
     37 using a psF32 f vector
     38 using a NULL fErr vector
     39 using a psU8 mask vector
     40
     41---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     42
     43/***************************** TESTPOINT ******************************************\
     44*             TestFile: tst_psPolyFit4D.c                                          *
     45*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     46*             TestType: Positive                                                   *
     47\**********************************************************************************/
     48
     49This test should generate an error message, and return NULL.
     50 performing a non clip-fit
     51 using ordinary polynomials
     52 using a NULL x vector
     53 using a psF32 y vector
     54 using a psF32 z vector
     55 using a psF32 t vector
     56 using a psF32 f vector
     57 using a psF32 fErr vector
     58 using a psU8 mask vector
     59
     60---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     61
     62/***************************** TESTPOINT ******************************************\
     63*             TestFile: tst_psPolyFit4D.c                                          *
     64*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     65*             TestType: Positive                                                   *
     66\**********************************************************************************/
     67
     68This test should generate an error message, and return NULL.
     69 performing a non clip-fit
     70 using ordinary polynomials
     71 using a psF32 x vector
     72 using a NULL y vector
     73 using a psF32 z vector
     74 using a psF32 t vector
     75 using a psF32 f vector
     76 using a psF32 fErr vector
     77 using a psU8 mask vector
     78
     79---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     80
     81/***************************** TESTPOINT ******************************************\
     82*             TestFile: tst_psPolyFit4D.c                                          *
     83*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     84*             TestType: Positive                                                   *
     85\**********************************************************************************/
     86
     87This test should generate an error message, and return NULL.
     88 performing a non clip-fit
     89 using ordinary polynomials
     90 using a psF32 x vector
     91 using a psF32 y vector
     92 using a NULL z vector
     93 using a psF32 t vector
     94 using a psF32 f vector
     95 using a psF32 fErr vector
     96 using a psU8 mask vector
     97
     98---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     99
     100/***************************** TESTPOINT ******************************************\
     101*             TestFile: tst_psPolyFit4D.c                                          *
     102*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     103*             TestType: Positive                                                   *
     104\**********************************************************************************/
     105
     106This test should generate an error message, and return NULL.
     107 performing a non clip-fit
     108 using ordinary polynomials
     109 using a psF32 x vector
     110 using a psF32 y vector
     111 using a psF32 z vector
     112 using a NULL t vector
     113 using a psF32 f vector
     114 using a psF32 fErr vector
     115 using a psU8 mask vector
     116
     117---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     118
     119/***************************** TESTPOINT ******************************************\
     120*             TestFile: tst_psPolyFit4D.c                                          *
     121*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     122*             TestType: Positive                                                   *
     123\**********************************************************************************/
     124
     125 performing a non clip-fit
     126 using ordinary polynomials
     127 using a psF32 x vector
     128 using a psF32 y vector
     129 using a psF32 z vector
     130 using a psF32 t vector
     131 using a psF32 f vector
     132 using a psF32 fErr vector
     133 using a NULL mask vector
     134
     135---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     136
     137/***************************** TESTPOINT ******************************************\
     138*             TestFile: tst_psPolyFit4D.c                                          *
     139*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     140*             TestType: Positive                                                   *
     141\**********************************************************************************/
     142
     143This test should generate an error message, and return NULL.
     144 performing a non clip-fit
     145 using ordinary polynomials
     146 using a psF32 x vector
     147 using a psF32 y vector
     148 using a psF32 z vector
     149 using a psF32 t vector
     150 using a NULL f vector
     151 using a psF32 fErr vector
     152 using a psU8 mask vector
     153
     154---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     155
     156/***************************** TESTPOINT ******************************************\
     157*             TestFile: tst_psPolyFit4D.c                                          *
     158*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     159*             TestType: Positive                                                   *
     160\**********************************************************************************/
     161
     162 performing a non clip-fit
     163 using ordinary polynomials
     164 using a psF32 x vector
     165 using a psF32 y vector
     166 using a psF32 z vector
     167 using a psF32 t vector
     168 using a psF32 f vector
     169 using a psF32 fErr vector
     170 using a NULL mask vector
     171
     172---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     173
     174/***************************** TESTPOINT ******************************************\
     175*             TestFile: tst_psPolyFit4D.c                                          *
     176*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     177*             TestType: Positive                                                   *
     178\**********************************************************************************/
     179
     180 performing a non clip-fit
     181 using ordinary polynomials
     182 using a psF32 x vector
     183 using a psF32 y vector
     184 using a psF32 z vector
     185 using a psF32 t vector
     186 using a psF32 f vector
     187 using a psF64 fErr vector
     188 using a psU8 mask vector
     189
     190---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     191
     192/***************************** TESTPOINT ******************************************\
     193*             TestFile: tst_psPolyFit4D.c                                          *
     194*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     195*             TestType: Positive                                                   *
     196\**********************************************************************************/
     197
     198 performing a non clip-fit
     199 using ordinary polynomials
     200 using a psF64 x vector
     201 using a psF32 y vector
     202 using a psF32 z vector
     203 using a psF32 t vector
     204 using a psF32 f vector
     205 using a psF32 fErr vector
     206 using a psU8 mask vector
     207
     208---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     209
     210/***************************** TESTPOINT ******************************************\
     211*             TestFile: tst_psPolyFit4D.c                                          *
     212*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     213*             TestType: Positive                                                   *
     214\**********************************************************************************/
     215
     216 performing a non clip-fit
     217 using ordinary polynomials
     218 using a psF32 x vector
     219 using a psF64 y vector
     220 using a psF32 z vector
     221 using a psF32 t vector
     222 using a psF32 f vector
     223 using a psF32 fErr vector
     224 using a psU8 mask vector
     225
     226---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     227
     228/***************************** TESTPOINT ******************************************\
     229*             TestFile: tst_psPolyFit4D.c                                          *
     230*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     231*             TestType: Positive                                                   *
     232\**********************************************************************************/
     233
     234 performing a non clip-fit
     235 using ordinary polynomials
     236 using a psF32 x vector
     237 using a psF32 y vector
     238 using a psF64 z vector
     239 using a psF32 t vector
     240 using a psF32 f vector
     241 using a psF32 fErr vector
     242 using a psU8 mask vector
     243
     244---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     245
     246/***************************** TESTPOINT ******************************************\
     247*             TestFile: tst_psPolyFit4D.c                                          *
     248*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     249*             TestType: Positive                                                   *
     250\**********************************************************************************/
     251
     252 performing a non clip-fit
     253 using ordinary polynomials
     254 using a psF32 x vector
     255 using a psF32 y vector
     256 using a psF32 z vector
     257 using a psF64 t vector
     258 using a psF32 f vector
     259 using a psF32 fErr vector
     260 using a psU8 mask vector
     261
     262---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     263
     264/***************************** TESTPOINT ******************************************\
     265*             TestFile: tst_psPolyFit4D.c                                          *
     266*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     267*             TestType: Positive                                                   *
     268\**********************************************************************************/
     269
     270 performing a non clip-fit
     271 using ordinary polynomials
     272 using a psF32 x vector
     273 using a psF32 y vector
     274 using a psF32 z vector
     275 using a psF32 t vector
     276 using a psF64 f vector
     277 using a psF32 fErr vector
     278 using a psU8 mask vector
     279
     280---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     281
     282/***************************** TESTPOINT ******************************************\
     283*             TestFile: tst_psPolyFit4D.c                                          *
     284*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     285*             TestType: Positive                                                   *
     286\**********************************************************************************/
     287
     288This test should generate an error message, and return NULL.
     289 performing a non clip-fit
     290 using ordinary polynomials
     291 using a psF32 x vector
     292 using a psF32 y vector
     293 using a psF32 z vector
     294 using a psF32 t vector
     295 using a psF32 f vector
     296 using a psF32 fErr vector
     297 using a psS32 mask vector
     298
     299---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     300
     301/***************************** TESTPOINT ******************************************\
     302*             TestFile: tst_psPolyFit4D.c                                          *
     303*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     304*             TestType: Positive                                                   *
     305\**********************************************************************************/
     306
     307 performing a non clip-fit
     308 using ordinary polynomials
     309 using a psF64 x vector
     310 using a psF64 y vector
     311 using a psF64 z vector
     312 using a psF64 t vector
     313 using a psF64 f vector
     314 using a psF64 fErr vector
     315 using a psU8 mask vector
     316
     317---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     318
     319/***************************** TESTPOINT ******************************************\
     320*             TestFile: tst_psPolyFit4D.c                                          *
     321*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     322*             TestType: Positive                                                   *
     323\**********************************************************************************/
     324
     325 performing a non clip-fit
     326 using ordinary polynomials
     327 using a psF64 x vector
     328 using a psF64 y vector
     329 using a psF64 z vector
     330 using a psF64 t vector
     331 using a psF64 f vector
     332 using a NULL fErr vector
     333 using a psU8 mask vector
     334
     335---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     336
     337/***************************** TESTPOINT ******************************************\
     338*             TestFile: tst_psPolyFit4D.c                                          *
     339*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     340*             TestType: Positive                                                   *
     341\**********************************************************************************/
     342
     343This test should generate an error message, and return NULL.
     344 performing a non clip-fit
     345 using ordinary polynomials
     346 using a NULL x vector
     347 using a psF64 y vector
     348 using a psF64 z vector
     349 using a psF64 t vector
     350 using a psF64 f vector
     351 using a psF64 fErr vector
     352 using a psU8 mask vector
     353
     354---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     355
     356/***************************** TESTPOINT ******************************************\
     357*             TestFile: tst_psPolyFit4D.c                                          *
     358*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     359*             TestType: Positive                                                   *
     360\**********************************************************************************/
     361
     362This test should generate an error message, and return NULL.
     363 performing a non clip-fit
     364 using ordinary polynomials
     365 using a psF64 x vector
     366 using a NULL y vector
     367 using a psF64 z vector
     368 using a psF64 t vector
     369 using a psF64 f vector
     370 using a psF64 fErr vector
     371 using a psU8 mask vector
     372
     373---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     374
     375/***************************** TESTPOINT ******************************************\
     376*             TestFile: tst_psPolyFit4D.c                                          *
     377*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     378*             TestType: Positive                                                   *
     379\**********************************************************************************/
     380
     381This test should generate an error message, and return NULL.
     382 performing a non clip-fit
     383 using ordinary polynomials
     384 using a psF64 x vector
     385 using a psF64 y vector
     386 using a NULL z vector
     387 using a psF64 t vector
     388 using a psF64 f vector
     389 using a psF64 fErr vector
     390 using a psU8 mask vector
     391
     392---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     393
     394/***************************** TESTPOINT ******************************************\
     395*             TestFile: tst_psPolyFit4D.c                                          *
     396*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     397*             TestType: Positive                                                   *
     398\**********************************************************************************/
     399
     400This test should generate an error message, and return NULL.
     401 performing a non clip-fit
     402 using ordinary polynomials
     403 using a psF64 x vector
     404 using a psF64 y vector
     405 using a psF64 z vector
     406 using a NULL t vector
     407 using a psF64 f vector
     408 using a psF64 fErr vector
     409 using a psU8 mask vector
     410
     411---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     412
     413/***************************** TESTPOINT ******************************************\
     414*             TestFile: tst_psPolyFit4D.c                                          *
     415*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     416*             TestType: Positive                                                   *
     417\**********************************************************************************/
     418
     419 performing a non clip-fit
     420 using ordinary polynomials
     421 using a psF64 x vector
     422 using a psF64 y vector
     423 using a psF64 z vector
     424 using a psF64 t vector
     425 using a psF64 f vector
     426 using a psF64 fErr vector
     427 using a NULL mask vector
     428
     429---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     430
     431/***************************** TESTPOINT ******************************************\
     432*             TestFile: tst_psPolyFit4D.c                                          *
     433*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     434*             TestType: Positive                                                   *
     435\**********************************************************************************/
     436
     437This test should generate an error message, and return NULL.
     438 performing a non clip-fit
     439 using ordinary polynomials
     440 using a psF64 x vector
     441 using a psF64 y vector
     442 using a psF64 z vector
     443 using a psF64 t vector
     444 using a NULL f vector
     445 using a psF64 fErr vector
     446 using a psU8 mask vector
     447
     448---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     449
     450/***************************** TESTPOINT ******************************************\
     451*             TestFile: tst_psPolyFit4D.c                                          *
     452*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     453*             TestType: Positive                                                   *
     454\**********************************************************************************/
     455
     456 performing a non clip-fit
     457 using ordinary polynomials
     458 using a psF64 x vector
     459 using a psF64 y vector
     460 using a psF64 z vector
     461 using a psF64 t vector
     462 using a psF64 f vector
     463 using a psF64 fErr vector
     464 using a NULL mask vector
     465
     466---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     467
     468/***************************** TESTPOINT ******************************************\
     469*             TestFile: tst_psPolyFit4D.c                                          *
     470*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     471*             TestType: Positive                                                   *
     472\**********************************************************************************/
     473
     474 performing a non clip-fit
     475 using ordinary polynomials
     476 using a psF64 x vector
     477 using a psF64 y vector
     478 using a psF64 z vector
     479 using a psF64 t vector
     480 using a psF64 f vector
     481 using a psF32 fErr vector
     482 using a psU8 mask vector
     483
     484---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     485
     486/***************************** TESTPOINT ******************************************\
     487*             TestFile: tst_psPolyFit4D.c                                          *
     488*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     489*             TestType: Positive                                                   *
     490\**********************************************************************************/
     491
     492 performing a non clip-fit
     493 using ordinary polynomials
     494 using a psF32 x vector
     495 using a psF64 y vector
     496 using a psF64 z vector
     497 using a psF64 t vector
     498 using a psF64 f vector
     499 using a psF64 fErr vector
     500 using a psU8 mask vector
     501
     502---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     503
     504/***************************** TESTPOINT ******************************************\
     505*             TestFile: tst_psPolyFit4D.c                                          *
     506*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     507*             TestType: Positive                                                   *
     508\**********************************************************************************/
     509
     510 performing a non clip-fit
     511 using ordinary polynomials
     512 using a psF64 x vector
     513 using a psF32 y vector
     514 using a psF64 z vector
     515 using a psF64 t vector
     516 using a psF64 f vector
     517 using a psF64 fErr vector
     518 using a psU8 mask vector
     519
     520---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     521
     522/***************************** TESTPOINT ******************************************\
     523*             TestFile: tst_psPolyFit4D.c                                          *
     524*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     525*             TestType: Positive                                                   *
     526\**********************************************************************************/
     527
     528 performing a non clip-fit
     529 using ordinary polynomials
     530 using a psF64 x vector
     531 using a psF64 y vector
     532 using a psF32 z vector
     533 using a psF64 t vector
     534 using a psF64 f vector
     535 using a psF64 fErr vector
     536 using a psU8 mask vector
     537
     538---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     539
     540/***************************** TESTPOINT ******************************************\
     541*             TestFile: tst_psPolyFit4D.c                                          *
     542*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     543*             TestType: Positive                                                   *
     544\**********************************************************************************/
     545
     546 performing a non clip-fit
     547 using ordinary polynomials
     548 using a psF64 x vector
     549 using a psF64 y vector
     550 using a psF64 z vector
     551 using a psF32 t vector
     552 using a psF64 f vector
     553 using a psF64 fErr vector
     554 using a psU8 mask vector
     555
     556---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     557
     558/***************************** TESTPOINT ******************************************\
     559*             TestFile: tst_psPolyFit4D.c                                          *
     560*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     561*             TestType: Positive                                                   *
     562\**********************************************************************************/
     563
     564 performing a non clip-fit
     565 using ordinary polynomials
     566 using a psF64 x vector
     567 using a psF64 y vector
     568 using a psF64 z vector
     569 using a psF64 t vector
     570 using a psF32 f vector
     571 using a psF64 fErr vector
     572 using a psU8 mask vector
     573
     574---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     575
     576/***************************** TESTPOINT ******************************************\
     577*             TestFile: tst_psPolyFit4D.c                                          *
     578*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     579*             TestType: Positive                                                   *
     580\**********************************************************************************/
     581
     582This test should generate an error message, and return NULL.
     583 performing a non clip-fit
     584 using ordinary polynomials
     585 using a psF64 x vector
     586 using a psF64 y vector
     587 using a psF64 z vector
     588 using a psF64 t vector
     589 using a psF64 f vector
     590 using a psF64 fErr vector
     591 using a psS32 mask vector
     592
     593---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     594
     595/***************************** TESTPOINT ******************************************\
     596*             TestFile: tst_psPolyFit4D.c                                          *
     597*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     598*             TestType: Positive                                                   *
     599\**********************************************************************************/
     600
     601 performing a clip-fit
     602 using ordinary polynomials
     603 using a psF32 x vector
     604 using a psF32 y vector
     605 using a psF32 z vector
     606 using a psF32 t vector
     607 using a psF32 f vector
     608 using a psF32 fErr vector
     609 using a psU8 mask vector
     610
     611---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     612
     613/***************************** TESTPOINT ******************************************\
     614*             TestFile: tst_psPolyFit4D.c                                          *
     615*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     616*             TestType: Positive                                                   *
     617\**********************************************************************************/
     618
     619 performing a clip-fit
     620 using ordinary polynomials
     621 using a psF32 x vector
     622 using a psF32 y vector
     623 using a psF32 z vector
     624 using a psF32 t vector
     625 using a psF32 f vector
     626 using a NULL fErr vector
     627 using a psU8 mask vector
     628
     629---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     630
     631/***************************** TESTPOINT ******************************************\
     632*             TestFile: tst_psPolyFit4D.c                                          *
     633*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     634*             TestType: Positive                                                   *
     635\**********************************************************************************/
     636
     637This test should generate an error message, and return NULL.
     638 performing a clip-fit
     639 using ordinary polynomials
     640 using a NULL x vector
     641 using a psF32 y vector
     642 using a psF32 z vector
     643 using a psF32 t vector
     644 using a psF32 f vector
     645 using a psF32 fErr vector
     646 using a psU8 mask vector
     647
     648---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     649
     650/***************************** TESTPOINT ******************************************\
     651*             TestFile: tst_psPolyFit4D.c                                          *
     652*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     653*             TestType: Positive                                                   *
     654\**********************************************************************************/
     655
     656This test should generate an error message, and return NULL.
     657 performing a clip-fit
     658 using ordinary polynomials
     659 using a psF32 x vector
     660 using a NULL y vector
     661 using a psF32 z vector
     662 using a psF32 t vector
     663 using a psF32 f vector
     664 using a psF32 fErr vector
     665 using a psU8 mask vector
     666
     667---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     668
     669/***************************** TESTPOINT ******************************************\
     670*             TestFile: tst_psPolyFit4D.c                                          *
     671*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     672*             TestType: Positive                                                   *
     673\**********************************************************************************/
     674
     675This test should generate an error message, and return NULL.
     676 performing a clip-fit
     677 using ordinary polynomials
     678 using a psF32 x vector
     679 using a psF32 y vector
     680 using a NULL z vector
     681 using a psF32 t vector
     682 using a psF32 f vector
     683 using a psF32 fErr vector
     684 using a psU8 mask vector
     685
     686---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     687
     688/***************************** TESTPOINT ******************************************\
     689*             TestFile: tst_psPolyFit4D.c                                          *
     690*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     691*             TestType: Positive                                                   *
     692\**********************************************************************************/
     693
     694This test should generate an error message, and return NULL.
     695 performing a clip-fit
     696 using ordinary polynomials
     697 using a psF32 x vector
     698 using a psF32 y vector
     699 using a psF32 z vector
     700 using a NULL t vector
     701 using a psF32 f vector
     702 using a psF32 fErr vector
     703 using a psU8 mask vector
     704
     705---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     706
     707/***************************** TESTPOINT ******************************************\
     708*             TestFile: tst_psPolyFit4D.c                                          *
     709*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     710*             TestType: Positive                                                   *
     711\**********************************************************************************/
     712
     713This test should generate an error message, and return NULL.
     714 performing a clip-fit
     715 using ordinary polynomials
     716 using a psF32 x vector
     717 using a psF32 y vector
     718 using a psF32 z vector
     719 using a psF32 t vector
     720 using a NULL f vector
     721 using a psF32 fErr vector
     722 using a psU8 mask vector
     723
     724---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     725
     726/***************************** TESTPOINT ******************************************\
     727*             TestFile: tst_psPolyFit4D.c                                          *
     728*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     729*             TestType: Positive                                                   *
     730\**********************************************************************************/
     731
     732This test should generate an error message, and return NULL.
     733 performing a clip-fit
     734 using ordinary polynomials
     735 using a psF32 x vector
     736 using a psF32 y vector
     737 using a psF32 z vector
     738 using a psF32 t vector
     739 using a psF32 f vector
     740 using a psF32 fErr vector
     741 using a NULL mask vector
     742
     743---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     744
     745/***************************** TESTPOINT ******************************************\
     746*             TestFile: tst_psPolyFit4D.c                                          *
     747*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     748*             TestType: Positive                                                   *
     749\**********************************************************************************/
     750
     751This test should generate an error message, and return NULL.
     752 performing a clip-fit
     753 using ordinary polynomials
     754 using a psF32 x vector
     755 using a psF32 y vector
     756 using a psF32 z vector
     757 using a psF32 t vector
     758 using a psF32 f vector
     759 using a psF64 fErr vector
     760 using a psU8 mask vector
     761
     762---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     763
     764/***************************** TESTPOINT ******************************************\
     765*             TestFile: tst_psPolyFit4D.c                                          *
     766*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     767*             TestType: Positive                                                   *
     768\**********************************************************************************/
     769
     770This test should generate an error message, and return NULL.
     771 performing a clip-fit
     772 using ordinary polynomials
     773 using a psF64 x vector
     774 using a psF32 y vector
     775 using a psF32 z vector
     776 using a psF32 t vector
     777 using a psF32 f vector
     778 using a psF32 fErr vector
     779 using a psU8 mask vector
     780
     781---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     782
     783/***************************** TESTPOINT ******************************************\
     784*             TestFile: tst_psPolyFit4D.c                                          *
     785*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     786*             TestType: Positive                                                   *
     787\**********************************************************************************/
     788
     789This test should generate an error message, and return NULL.
     790 performing a clip-fit
     791 using ordinary polynomials
     792 using a psF32 x vector
     793 using a psF64 y vector
     794 using a psF32 z vector
     795 using a psF32 t vector
     796 using a psF32 f vector
     797 using a psF32 fErr vector
     798 using a psU8 mask vector
     799
     800---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     801
     802/***************************** TESTPOINT ******************************************\
     803*             TestFile: tst_psPolyFit4D.c                                          *
     804*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     805*             TestType: Positive                                                   *
     806\**********************************************************************************/
     807
     808This test should generate an error message, and return NULL.
     809 performing a clip-fit
     810 using ordinary polynomials
     811 using a psF32 x vector
     812 using a psF32 y vector
     813 using a psF64 z vector
     814 using a psF32 t vector
     815 using a psF32 f vector
     816 using a psF32 fErr vector
     817 using a psU8 mask vector
     818
     819---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     820
     821/***************************** TESTPOINT ******************************************\
     822*             TestFile: tst_psPolyFit4D.c                                          *
     823*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     824*             TestType: Positive                                                   *
     825\**********************************************************************************/
     826
     827This test should generate an error message, and return NULL.
     828 performing a clip-fit
     829 using ordinary polynomials
     830 using a psF32 x vector
     831 using a psF32 y vector
     832 using a psF32 z vector
     833 using a psF64 t vector
     834 using a psF32 f vector
     835 using a psF32 fErr vector
     836 using a psU8 mask vector
     837
     838---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     839
     840/***************************** TESTPOINT ******************************************\
     841*             TestFile: tst_psPolyFit4D.c                                          *
     842*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     843*             TestType: Positive                                                   *
     844\**********************************************************************************/
     845
     846This test should generate an error message, and return NULL.
     847 performing a clip-fit
     848 using ordinary polynomials
     849 using a psF32 x vector
     850 using a psF32 y vector
     851 using a psF32 z vector
     852 using a psF32 t vector
     853 using a psF64 f vector
     854 using a psF32 fErr vector
     855 using a psU8 mask vector
     856
     857---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     858
     859/***************************** TESTPOINT ******************************************\
     860*             TestFile: tst_psPolyFit4D.c                                          *
     861*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     862*             TestType: Positive                                                   *
     863\**********************************************************************************/
     864
     865This test should generate an error message, and return NULL.
     866 performing a clip-fit
     867 using ordinary polynomials
     868 using a psF32 x vector
     869 using a psF32 y vector
     870 using a psF32 z vector
     871 using a psF32 t vector
     872 using a psF32 f vector
     873 using a psF32 fErr vector
     874 using a psS32 mask vector
     875
     876---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     877
     878/***************************** TESTPOINT ******************************************\
     879*             TestFile: tst_psPolyFit4D.c                                          *
     880*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     881*             TestType: Positive                                                   *
     882\**********************************************************************************/
     883
     884 performing a clip-fit
     885 using ordinary polynomials
     886 using a psF64 x vector
     887 using a psF64 y vector
     888 using a psF64 z vector
     889 using a psF64 t vector
     890 using a psF64 f vector
     891 using a psF64 fErr vector
     892 using a psU8 mask vector
     893
     894---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     895
     896/***************************** TESTPOINT ******************************************\
     897*             TestFile: tst_psPolyFit4D.c                                          *
     898*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     899*             TestType: Positive                                                   *
     900\**********************************************************************************/
     901
     902 performing a clip-fit
     903 using ordinary polynomials
     904 using a psF64 x vector
     905 using a psF64 y vector
     906 using a psF64 z vector
     907 using a psF64 t vector
     908 using a psF64 f vector
     909 using a NULL fErr vector
     910 using a psU8 mask vector
     911
     912---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     913
     914/***************************** TESTPOINT ******************************************\
     915*             TestFile: tst_psPolyFit4D.c                                          *
     916*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     917*             TestType: Positive                                                   *
     918\**********************************************************************************/
     919
     920This test should generate an error message, and return NULL.
     921 performing a clip-fit
     922 using ordinary polynomials
     923 using a NULL x vector
     924 using a psF64 y vector
     925 using a psF64 z vector
     926 using a psF64 t vector
     927 using a psF64 f vector
     928 using a psF64 fErr vector
     929 using a psU8 mask vector
     930
     931---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     932
     933/***************************** TESTPOINT ******************************************\
     934*             TestFile: tst_psPolyFit4D.c                                          *
     935*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     936*             TestType: Positive                                                   *
     937\**********************************************************************************/
     938
     939This test should generate an error message, and return NULL.
     940 performing a clip-fit
     941 using ordinary polynomials
     942 using a psF64 x vector
     943 using a NULL y vector
     944 using a psF64 z vector
     945 using a psF64 t vector
     946 using a psF64 f vector
     947 using a psF64 fErr vector
     948 using a psU8 mask vector
     949
     950---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     951
     952/***************************** TESTPOINT ******************************************\
     953*             TestFile: tst_psPolyFit4D.c                                          *
     954*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     955*             TestType: Positive                                                   *
     956\**********************************************************************************/
     957
     958This test should generate an error message, and return NULL.
     959 performing a clip-fit
     960 using ordinary polynomials
     961 using a psF64 x vector
     962 using a psF64 y vector
     963 using a NULL z vector
     964 using a psF64 t vector
     965 using a psF64 f vector
     966 using a psF64 fErr vector
     967 using a psU8 mask vector
     968
     969---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     970
     971/***************************** TESTPOINT ******************************************\
     972*             TestFile: tst_psPolyFit4D.c                                          *
     973*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     974*             TestType: Positive                                                   *
     975\**********************************************************************************/
     976
     977This test should generate an error message, and return NULL.
     978 performing a clip-fit
     979 using ordinary polynomials
     980 using a psF64 x vector
     981 using a psF64 y vector
     982 using a psF64 z vector
     983 using a NULL t vector
     984 using a psF64 f vector
     985 using a psF64 fErr vector
     986 using a psU8 mask vector
     987
     988---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     989
     990/***************************** TESTPOINT ******************************************\
     991*             TestFile: tst_psPolyFit4D.c                                          *
     992*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     993*             TestType: Positive                                                   *
     994\**********************************************************************************/
     995
     996This test should generate an error message, and return NULL.
     997 performing a clip-fit
     998 using ordinary polynomials
     999 using a psF64 x vector
     1000 using a psF64 y vector
     1001 using a psF64 z vector
     1002 using a psF64 t vector
     1003 using a NULL f vector
     1004 using a psF64 fErr vector
     1005 using a psU8 mask vector
     1006
     1007---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1008
     1009/***************************** TESTPOINT ******************************************\
     1010*             TestFile: tst_psPolyFit4D.c                                          *
     1011*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1012*             TestType: Positive                                                   *
     1013\**********************************************************************************/
     1014
     1015This test should generate an error message, and return NULL.
     1016 performing a clip-fit
     1017 using ordinary polynomials
     1018 using a psF64 x vector
     1019 using a psF64 y vector
     1020 using a psF64 z vector
     1021 using a psF64 t vector
     1022 using a psF64 f vector
     1023 using a psF64 fErr vector
     1024 using a NULL mask vector
     1025
     1026---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1027
     1028/***************************** TESTPOINT ******************************************\
     1029*             TestFile: tst_psPolyFit4D.c                                          *
     1030*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1031*             TestType: Positive                                                   *
     1032\**********************************************************************************/
     1033
     1034This test should generate an error message, and return NULL.
     1035 performing a clip-fit
     1036 using ordinary polynomials
     1037 using a psF64 x vector
     1038 using a psF64 y vector
     1039 using a psF64 z vector
     1040 using a psF64 t vector
     1041 using a psF64 f vector
     1042 using a psF32 fErr vector
     1043 using a psU8 mask vector
     1044
     1045---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1046
     1047/***************************** TESTPOINT ******************************************\
     1048*             TestFile: tst_psPolyFit4D.c                                          *
     1049*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1050*             TestType: Positive                                                   *
     1051\**********************************************************************************/
     1052
     1053This test should generate an error message, and return NULL.
     1054 performing a clip-fit
     1055 using ordinary polynomials
     1056 using a psF32 x vector
     1057 using a psF64 y vector
     1058 using a psF64 z vector
     1059 using a psF64 t vector
     1060 using a psF64 f vector
     1061 using a psF64 fErr vector
     1062 using a psU8 mask vector
     1063
     1064---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1065
     1066/***************************** TESTPOINT ******************************************\
     1067*             TestFile: tst_psPolyFit4D.c                                          *
     1068*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1069*             TestType: Positive                                                   *
     1070\**********************************************************************************/
     1071
     1072This test should generate an error message, and return NULL.
     1073 performing a clip-fit
     1074 using ordinary polynomials
     1075 using a psF64 x vector
     1076 using a psF32 y vector
     1077 using a psF64 z vector
     1078 using a psF64 t vector
     1079 using a psF64 f vector
     1080 using a psF64 fErr vector
     1081 using a psU8 mask vector
     1082
     1083---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1084
     1085/***************************** TESTPOINT ******************************************\
     1086*             TestFile: tst_psPolyFit4D.c                                          *
     1087*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1088*             TestType: Positive                                                   *
     1089\**********************************************************************************/
     1090
     1091This test should generate an error message, and return NULL.
     1092 performing a clip-fit
     1093 using ordinary polynomials
     1094 using a psF64 x vector
     1095 using a psF64 y vector
     1096 using a psF32 z vector
     1097 using a psF64 t vector
     1098 using a psF64 f vector
     1099 using a psF64 fErr vector
     1100 using a psU8 mask vector
     1101
     1102---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1103
     1104/***************************** TESTPOINT ******************************************\
     1105*             TestFile: tst_psPolyFit4D.c                                          *
     1106*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1107*             TestType: Positive                                                   *
     1108\**********************************************************************************/
     1109
     1110This test should generate an error message, and return NULL.
     1111 performing a clip-fit
     1112 using ordinary polynomials
     1113 using a psF64 x vector
     1114 using a psF64 y vector
     1115 using a psF64 z vector
     1116 using a psF32 t vector
     1117 using a psF64 f vector
     1118 using a psF64 fErr vector
     1119 using a psU8 mask vector
     1120
     1121---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1122
     1123/***************************** TESTPOINT ******************************************\
     1124*             TestFile: tst_psPolyFit4D.c                                          *
     1125*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1126*             TestType: Positive                                                   *
     1127\**********************************************************************************/
     1128
     1129This test should generate an error message, and return NULL.
     1130 performing a clip-fit
     1131 using ordinary polynomials
     1132 using a psF64 x vector
     1133 using a psF64 y vector
     1134 using a psF64 z vector
     1135 using a psF64 t vector
     1136 using a psF32 f vector
     1137 using a psF64 fErr vector
     1138 using a psU8 mask vector
     1139
     1140---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1141
     1142/***************************** TESTPOINT ******************************************\
     1143*             TestFile: tst_psPolyFit4D.c                                          *
     1144*            TestPoint: psMinimize functions{4D Polynomial Fitting Functions}      *
     1145*             TestType: Positive                                                   *
     1146\**********************************************************************************/
     1147
     1148This test should generate an error message, and return NULL.
     1149 performing a clip-fit
     1150 using ordinary polynomials
     1151 using a psF64 x vector
     1152 using a psF64 y vector
     1153 using a psF64 z vector
     1154 using a psF64 t vector
     1155 using a psF64 f vector
     1156 using a psF64 fErr vector
     1157 using a psS32 mask vector
     1158
     1159---> TESTPOINT PASSED (psMinimize functions{4D Polynomial Fitting Functions} | tst_psPolyFit4D.c)
     1160
     1161Status: 1
    11611162
    11621163---> TESTPOINT PASSED (psMinimize functions: 4D Polynomial Fitting Functions{} | tst_psPolyFit4D.c)
Note: See TracChangeset for help on using the changeset viewer.