IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 25, 2005, 10:26:55 AM (21 years ago)
Author:
gusciora
Message:

I renamed many of the PS_CHECK macros to PS_ASSERT...

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3990 r4029  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.103 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-05-19 23:57:37 $
     9 *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-05-25 20:26:55 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    246246static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
    247247{
    248     PS_INT_CHECK_NON_NEGATIVE(maxChebyPoly, NULL);
     248    PS_ASSERT_INT_NONNEGATIVE(maxChebyPoly, NULL);
    249249
    250250    psPolynomial1D **chebPolys = NULL;
    … …  
    314314static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
    315315{
    316     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     316    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    317317    // XXX: Create a macro for this in psConstants.h
    318318    if (myPoly->n < 1) {
    … …  
    398398                                 const psPolynomial2D* myPoly)
    399399{
    400     PS_POLY_CHECK_NULL(myPoly, NAN);
     400    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    401401
    402402    psS32 loop_x = 0;
    … …  
    422422static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
    423423{
    424     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    425     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    426     PS_POLY_CHECK_NULL(myPoly, NAN);
     424    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     425    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     426    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    427427
    428428    psS32 loop_x = 0;
    … …  
    487487static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
    488488{
    489     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    490     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    491     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     489    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     490    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     491    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    492492    psS32 loop_x = 0;
    493493    psS32 loop_y = 0;
    … …  
    565565static psF32 chebPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
    566566{
    567     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    568     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    569     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    570     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     567    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     568    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     569    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     570    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    571571    psS32 loop_w = 0;
    572572    psS32 loop_x = 0;
    … …  
    638638static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
    639639{
    640     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
     640    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    641641    psVector *d;
    642642    psS32 n;
    … …  
    697697static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
    698698{
    699     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    700     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
     699    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     700    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
    701701    psS32 loop_x = 0;
    702702    psS32 loop_y = 0;
    … …  
    761761static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
    762762{
    763     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    764     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    765     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     763    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     764    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     765    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    766766    psS32 loop_x = 0;
    767767    psS32 loop_y = 0;
    … …  
    839839static psF64 dChebPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
    840840{
    841     PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
    842     PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    843     PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
    844     PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
     841    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
     842    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     843    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     844    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
    845845    psS32 loop_w = 0;
    846846    psS32 loop_x = 0;
    … …  
    973973                              psF32 x)
    974974{
    975     PS_PTR_CHECK_NULL(domain, NAN)
    976     PS_PTR_CHECK_NULL(range, NAN)
     975    PS_ASSERT_PTR_NON_NULL(domain, NAN)
     976    PS_ASSERT_PTR_NON_NULL(range, NAN)
    977977    // XXX: Check valid values for n, order, and x?
    978978
    … …  
    10441044psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
    10451045{
    1046     PS_INT_CHECK_NON_NEGATIVE(Npts, NULL);
     1046    PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
    10471047
    10481048    psVector* gauss = NULL;
    … …  
    10721072                                    psPolynomialType type)
    10731073{
    1074     PS_INT_CHECK_POSITIVE(n, NULL);
     1074    PS_ASSERT_INT_POSITIVE(n, NULL);
    10751075
    10761076    psS32 i = 0;
    … …  
    10971097                                    psPolynomialType type)
    10981098{
    1099     PS_INT_CHECK_POSITIVE(nX, NULL);
    1100     PS_INT_CHECK_POSITIVE(nY, NULL);
     1099    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1100    PS_ASSERT_INT_POSITIVE(nY, NULL);
    11011101
    11021102    psS32 x = 0;
    … …  
    11331133                                    psPolynomialType type)
    11341134{
    1135     PS_INT_CHECK_POSITIVE(nX, NULL);
    1136     PS_INT_CHECK_POSITIVE(nY, NULL);
    1137     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1135    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1136    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1137    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11381138
    11391139    psS32 x = 0;
    … …  
    11791179                                    psPolynomialType type)
    11801180{
    1181     PS_INT_CHECK_POSITIVE(nW, NULL);
    1182     PS_INT_CHECK_POSITIVE(nX, NULL);
    1183     PS_INT_CHECK_POSITIVE(nY, NULL);
    1184     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1181    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1182    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1183    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1184    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    11851185
    11861186    psS32 w = 0;
    … …  
    12341234psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
    12351235{
    1236     PS_POLY_CHECK_NULL(myPoly, NAN);
     1236    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12371237
    12381238    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12511251                                   const psVector *x)
    12521252{
    1253     PS_POLY_CHECK_NULL(myPoly, NULL);
    1254     PS_VECTOR_CHECK_NULL(x, NULL);
    1255     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
     1253    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1254    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1255    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
    12561256
    12571257    psVector *tmp;
    … …  
    12671267psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
    12681268{
    1269     PS_POLY_CHECK_NULL(myPoly, NAN);
     1269    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    12701270
    12711271    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    12861286
    12871287{
    1288     PS_POLY_CHECK_NULL(myPoly, NULL);
    1289     PS_VECTOR_CHECK_NULL(x, NULL);
    1290     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1291     PS_VECTOR_CHECK_NULL(y, NULL);
    1292     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
     1288    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1289    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1290    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1291    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1292    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
    12931293
    12941294    psVector *tmp;
    … …  
    13141314psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
    13151315{
    1316     PS_POLY_CHECK_NULL(myPoly, NAN);
     1316    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13171317
    13181318    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13341334
    13351335{
    1336     PS_POLY_CHECK_NULL(myPoly, NULL);
    1337     PS_VECTOR_CHECK_NULL(x, NULL);
    1338     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1339     PS_VECTOR_CHECK_NULL(y, NULL);
    1340     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1341     PS_VECTOR_CHECK_NULL(z, NULL);
    1342     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1336    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1337    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1338    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1339    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1340    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1341    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1342    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    13431343
    13441344    psVector *tmp;
    … …  
    13701370psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
    13711371{
    1372     PS_POLY_CHECK_NULL(myPoly, NAN);
     1372    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    13731373
    13741374    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    13901390                                   const psVector *z)
    13911391{
    1392     PS_POLY_CHECK_NULL(myPoly, NULL);
    1393     PS_VECTOR_CHECK_NULL(w, NULL);
    1394     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F32, NULL);
    1395     PS_VECTOR_CHECK_NULL(x, NULL);
    1396     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
    1397     PS_VECTOR_CHECK_NULL(y, NULL);
    1398     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
    1399     PS_VECTOR_CHECK_NULL(z, NULL);
    1400     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
     1392    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1393    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1394    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
     1395    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1396    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
     1397    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1398    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
     1399    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1400    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
    14011401
    14021402    psVector *tmp;
    … …  
    14341434                                      psPolynomialType type)
    14351435{
    1436     PS_INT_CHECK_POSITIVE(n, NULL);
     1436    PS_ASSERT_INT_POSITIVE(n, NULL);
    14371437
    14381438    psS32 i = 0;
    … …  
    14591459                                      psPolynomialType type)
    14601460{
    1461     PS_INT_CHECK_POSITIVE(nX, NULL);
    1462     PS_INT_CHECK_POSITIVE(nY, NULL);
     1461    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1462    PS_ASSERT_INT_POSITIVE(nY, NULL);
    14631463
    14641464    psS32 x = 0;
    … …  
    14951495                                      psPolynomialType type)
    14961496{
    1497     PS_INT_CHECK_POSITIVE(nX, NULL);
    1498     PS_INT_CHECK_POSITIVE(nY, NULL);
    1499     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1497    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1498    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1499    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15001500
    15011501    psS32 x = 0;
    … …  
    15411541                                      psPolynomialType type)
    15421542{
    1543     PS_INT_CHECK_POSITIVE(nW, NULL);
    1544     PS_INT_CHECK_POSITIVE(nX, NULL);
    1545     PS_INT_CHECK_POSITIVE(nY, NULL);
    1546     PS_INT_CHECK_POSITIVE(nZ, NULL);
     1543    PS_ASSERT_INT_POSITIVE(nW, NULL);
     1544    PS_ASSERT_INT_POSITIVE(nX, NULL);
     1545    PS_ASSERT_INT_POSITIVE(nY, NULL);
     1546    PS_ASSERT_INT_POSITIVE(nZ, NULL);
    15471547
    15481548    psS32 w = 0;
    … …  
    15971597psF64 psDPolynomial1DEval(const psDPolynomial1D* myPoly, psF64 x)
    15981598{
    1599     PS_POLY_CHECK_NULL(myPoly, NAN);
     1599    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16001600
    16011601    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16151615
    16161616{
    1617     PS_POLY_CHECK_NULL(myPoly, NULL);
    1618     PS_VECTOR_CHECK_NULL(x, NULL);
    1619     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
     1617    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1618    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1619    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
    16201620
    16211621    psVector *tmp;
    … …  
    16351635                          psF64 y)
    16361636{
    1637     PS_POLY_CHECK_NULL(myPoly, NAN);
     1637    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16381638
    16391639    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    16531653                                    const psVector *y)
    16541654{
    1655     PS_POLY_CHECK_NULL(myPoly, NULL);
    1656     PS_VECTOR_CHECK_NULL(x, NULL);
    1657     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1658     PS_VECTOR_CHECK_NULL(y, NULL);
    1659     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
     1655    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1656    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1657    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1658    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1659    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
    16601660
    16611661    psVector *tmp;
    … …  
    16851685                          psF64 z)
    16861686{
    1687     PS_POLY_CHECK_NULL(myPoly, NAN);
     1687    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    16881688
    16891689    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17051705
    17061706{
    1707     PS_POLY_CHECK_NULL(myPoly, NULL);
    1708     PS_VECTOR_CHECK_NULL(x, NULL);
    1709     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1710     PS_VECTOR_CHECK_NULL(y, NULL);
    1711     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1712     PS_VECTOR_CHECK_NULL(z, NULL);
    1713     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1707    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1708    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1709    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1710    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1711    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1712    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1713    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17141714
    17151715    psVector *tmp;
    … …  
    17451745                          psF64 z)
    17461746{
    1747     PS_POLY_CHECK_NULL(myPoly, NAN);
     1747    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
    17481748
    17491749    if (myPoly->type == PS_POLYNOMIAL_ORD) {
    … …  
    17651765                                    const psVector *z)
    17661766{
    1767     PS_POLY_CHECK_NULL(myPoly, NULL);
    1768     PS_VECTOR_CHECK_NULL(w, NULL);
    1769     PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F64, NULL);
    1770     PS_VECTOR_CHECK_NULL(x, NULL);
    1771     PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
    1772     PS_VECTOR_CHECK_NULL(y, NULL);
    1773     PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
    1774     PS_VECTOR_CHECK_NULL(z, NULL);
    1775     PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
     1767    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
     1768    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
     1769    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F64, NULL);
     1770    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     1771    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     1772    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     1773    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     1774    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     1775    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
    17761776
    17771777    psVector *tmp;
    … …  
    18281828                            psF32 max)
    18291829{
    1830     PS_INT_CHECK_NON_NEGATIVE(numSplines, NULL);
    1831     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    1832     PS_FLOAT_CHECK_NON_EQUAL(max, min, NULL);
     1830    PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL);
     1831    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     1832    PS_ASSERT_FLOAT_NON_EQUAL(max, min, NULL);
    18331833
    18341834    psSpline1D *tmp = NULL;
    … …  
    18701870                                   psS32 order)
    18711871{
    1872     PS_VECTOR_CHECK_NULL(bounds, NULL);
    1873     PS_VECTOR_CHECK_EMPTY(bounds, NULL);
    1874     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
     1872    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
     1873    PS_ASSERT_VECTOR_NON_EMPTY(bounds, NULL);
     1874    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
    18751875
    18761876    psSpline1D *tmp = NULL;
    … …  
    19831983                          psScalar *x)
    19841984{
    1985     PS_VECTOR_CHECK_NULL(bins, -4);
    1986     PS_VECTOR_CHECK_EMPTY(bins, -4);
    1987     PS_PTR_CHECK_NULL(x, -6);
    1988     PS_PTR_CHECK_TYPE_EQUAL(x, bins, -3);
     1985    PS_ASSERT_VECTOR_NON_NULL(bins, -4);
     1986    PS_ASSERT_VECTOR_NON_EMPTY(bins, -4);
     1987    PS_ASSERT_PTR_NON_NULL(x, -6);
     1988    PS_ASSERT_PTR_TYPE_EQUAL(x, bins, -3);
    19891989    char* strType;
    19901990
    … …  
    20492049                                psScalar *x)
    20502050{
    2051     PS_VECTOR_CHECK_NULL(domain, NULL);
    2052     PS_VECTOR_CHECK_NULL(range, NULL);
    2053     PS_PTR_CHECK_NULL(x, NULL);
    2054     PS_INT_CHECK_NON_NEGATIVE(order, NULL);
    2055     PS_VECTOR_CHECK_SIZE_EQUAL(domain, range, NULL);
    2056     PS_PTR_CHECK_TYPE_EQUAL(domain, range, NULL);
    2057     PS_PTR_CHECK_TYPE_EQUAL(domain, x, NULL);
     2051    PS_ASSERT_VECTOR_NON_NULL(domain, NULL);
     2052    PS_ASSERT_VECTOR_NON_NULL(range, NULL);
     2053    PS_ASSERT_PTR_NON_NULL(x, NULL);
     2054    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
     2055    PS_ASSERT_VECTORS_SIZE_EQUAL(domain, range, NULL);
     2056    PS_ASSERT_PTR_TYPE_EQUAL(domain, range, NULL);
     2057    PS_ASSERT_PTR_TYPE_EQUAL(domain, x, NULL);
    20582058
    20592059    psVector *range32 = NULL;
    … …  
    21312131)
    21322132{
    2133     PS_PTR_CHECK_NULL(spline, NAN);
    2134     PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
    2135     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NAN);
     2133    PS_ASSERT_PTR_NON_NULL(spline, NAN);
     2134    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
     2135    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NAN);
    21362136
    21372137    psS32 binNum;
    … …  
    21672167)
    21682168{
    2169     PS_PTR_CHECK_NULL(spline, NULL);
    2170     PS_VECTOR_CHECK_NULL(x, NULL);
    2171     PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
    2172     PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
     2169    PS_ASSERT_PTR_NON_NULL(spline, NULL);
     2170    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     2171    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
     2172    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    21732173
    21742174    psS32 i;
Note: See TracChangeset for help on using the changeset viewer.