Index: trunk/psLib/src/math/psSpline.c
===================================================================
--- trunk/psLib/src/math/psSpline.c	(revision 3990)
+++ trunk/psLib/src/math/psSpline.c	(revision 4029)
@@ -7,6 +7,6 @@
  *  polynomials.  It also contains a Gaussian functions.
  *
- *  @version $Revision: 1.103 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-05-19 23:57:37 $
+ *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-05-25 20:26:55 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -246,5 +246,5 @@
 static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
 {
-    PS_INT_CHECK_NON_NEGATIVE(maxChebyPoly, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(maxChebyPoly, NULL);
 
     psPolynomial1D **chebPolys = NULL;
@@ -314,5 +314,5 @@
 static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     // XXX: Create a macro for this in psConstants.h
     if (myPoly->n < 1) {
@@ -398,5 +398,5 @@
                                  const psPolynomial2D* myPoly)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     psS32 loop_x = 0;
@@ -422,7 +422,7 @@
 static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     psS32 loop_x = 0;
@@ -487,7 +487,7 @@
 static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
     psS32 loop_x = 0;
     psS32 loop_y = 0;
@@ -565,8 +565,8 @@
 static psF32 chebPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
     psS32 loop_w = 0;
     psS32 loop_x = 0;
@@ -638,5 +638,5 @@
 static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     psVector *d;
     psS32 n;
@@ -697,6 +697,6 @@
 static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     psS32 loop_x = 0;
     psS32 loop_y = 0;
@@ -761,7 +761,7 @@
 static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
     psS32 loop_x = 0;
     psS32 loop_y = 0;
@@ -839,8 +839,8 @@
 static psF64 dChebPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
 {
-    PS_FLOAT_CHECK_RANGE(w, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(y, -1.0, 1.0, 0.0);
-    PS_FLOAT_CHECK_RANGE(z, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(w, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
     psS32 loop_w = 0;
     psS32 loop_x = 0;
@@ -973,6 +973,6 @@
                               psF32 x)
 {
-    PS_PTR_CHECK_NULL(domain, NAN)
-    PS_PTR_CHECK_NULL(range, NAN)
+    PS_ASSERT_PTR_NON_NULL(domain, NAN)
+    PS_ASSERT_PTR_NON_NULL(range, NAN)
     // XXX: Check valid values for n, order, and x?
 
@@ -1044,5 +1044,5 @@
 psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
 {
-    PS_INT_CHECK_NON_NEGATIVE(Npts, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
 
     psVector* gauss = NULL;
@@ -1072,5 +1072,5 @@
                                     psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(n, NULL);
+    PS_ASSERT_INT_POSITIVE(n, NULL);
 
     psS32 i = 0;
@@ -1097,6 +1097,6 @@
                                     psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(nX, NULL);
-    PS_INT_CHECK_POSITIVE(nY, NULL);
+    PS_ASSERT_INT_POSITIVE(nX, NULL);
+    PS_ASSERT_INT_POSITIVE(nY, NULL);
 
     psS32 x = 0;
@@ -1133,7 +1133,7 @@
                                     psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(nX, NULL);
-    PS_INT_CHECK_POSITIVE(nY, NULL);
-    PS_INT_CHECK_POSITIVE(nZ, NULL);
+    PS_ASSERT_INT_POSITIVE(nX, NULL);
+    PS_ASSERT_INT_POSITIVE(nY, NULL);
+    PS_ASSERT_INT_POSITIVE(nZ, NULL);
 
     psS32 x = 0;
@@ -1179,8 +1179,8 @@
                                     psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(nW, NULL);
-    PS_INT_CHECK_POSITIVE(nX, NULL);
-    PS_INT_CHECK_POSITIVE(nY, NULL);
-    PS_INT_CHECK_POSITIVE(nZ, NULL);
+    PS_ASSERT_INT_POSITIVE(nW, NULL);
+    PS_ASSERT_INT_POSITIVE(nX, NULL);
+    PS_ASSERT_INT_POSITIVE(nY, NULL);
+    PS_ASSERT_INT_POSITIVE(nZ, NULL);
 
     psS32 w = 0;
@@ -1234,5 +1234,5 @@
 psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1251,7 +1251,7 @@
                                    const psVector *x)
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
 
     psVector *tmp;
@@ -1267,5 +1267,5 @@
 psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1286,9 +1286,9 @@
 
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
-    PS_VECTOR_CHECK_NULL(y, NULL);
-    PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
 
     psVector *tmp;
@@ -1314,5 +1314,5 @@
 psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1334,11 +1334,11 @@
 
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
-    PS_VECTOR_CHECK_NULL(y, NULL);
-    PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
-    PS_VECTOR_CHECK_NULL(z, NULL);
-    PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
+    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
 
     psVector *tmp;
@@ -1370,5 +1370,5 @@
 psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1390,13 +1390,13 @@
                                    const psVector *z)
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(w, NULL);
-    PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F32, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F32, NULL);
-    PS_VECTOR_CHECK_NULL(y, NULL);
-    PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F32, NULL);
-    PS_VECTOR_CHECK_NULL(z, NULL);
-    PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F32, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
+    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
+    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
 
     psVector *tmp;
@@ -1434,5 +1434,5 @@
                                       psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(n, NULL);
+    PS_ASSERT_INT_POSITIVE(n, NULL);
 
     psS32 i = 0;
@@ -1459,6 +1459,6 @@
                                       psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(nX, NULL);
-    PS_INT_CHECK_POSITIVE(nY, NULL);
+    PS_ASSERT_INT_POSITIVE(nX, NULL);
+    PS_ASSERT_INT_POSITIVE(nY, NULL);
 
     psS32 x = 0;
@@ -1495,7 +1495,7 @@
                                       psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(nX, NULL);
-    PS_INT_CHECK_POSITIVE(nY, NULL);
-    PS_INT_CHECK_POSITIVE(nZ, NULL);
+    PS_ASSERT_INT_POSITIVE(nX, NULL);
+    PS_ASSERT_INT_POSITIVE(nY, NULL);
+    PS_ASSERT_INT_POSITIVE(nZ, NULL);
 
     psS32 x = 0;
@@ -1541,8 +1541,8 @@
                                       psPolynomialType type)
 {
-    PS_INT_CHECK_POSITIVE(nW, NULL);
-    PS_INT_CHECK_POSITIVE(nX, NULL);
-    PS_INT_CHECK_POSITIVE(nY, NULL);
-    PS_INT_CHECK_POSITIVE(nZ, NULL);
+    PS_ASSERT_INT_POSITIVE(nW, NULL);
+    PS_ASSERT_INT_POSITIVE(nX, NULL);
+    PS_ASSERT_INT_POSITIVE(nY, NULL);
+    PS_ASSERT_INT_POSITIVE(nZ, NULL);
 
     psS32 w = 0;
@@ -1597,5 +1597,5 @@
 psF64 psDPolynomial1DEval(const psDPolynomial1D* myPoly, psF64 x)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1615,7 +1615,7 @@
 
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
 
     psVector *tmp;
@@ -1635,5 +1635,5 @@
                           psF64 y)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1653,9 +1653,9 @@
                                     const psVector *y)
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
-    PS_VECTOR_CHECK_NULL(y, NULL);
-    PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
 
     psVector *tmp;
@@ -1685,5 +1685,5 @@
                           psF64 z)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1705,11 +1705,11 @@
 
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
-    PS_VECTOR_CHECK_NULL(y, NULL);
-    PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
-    PS_VECTOR_CHECK_NULL(z, NULL);
-    PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
+    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
 
     psVector *tmp;
@@ -1745,5 +1745,5 @@
                           psF64 z)
 {
-    PS_POLY_CHECK_NULL(myPoly, NAN);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
@@ -1765,13 +1765,13 @@
                                     const psVector *z)
 {
-    PS_POLY_CHECK_NULL(myPoly, NULL);
-    PS_VECTOR_CHECK_NULL(w, NULL);
-    PS_VECTOR_CHECK_TYPE(w, PS_TYPE_F64, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE(x, PS_TYPE_F64, NULL);
-    PS_VECTOR_CHECK_NULL(y, NULL);
-    PS_VECTOR_CHECK_TYPE(y, PS_TYPE_F64, NULL);
-    PS_VECTOR_CHECK_NULL(z, NULL);
-    PS_VECTOR_CHECK_TYPE(z, PS_TYPE_F64, NULL);
+    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
+    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
+    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
 
     psVector *tmp;
@@ -1828,7 +1828,7 @@
                             psF32 max)
 {
-    PS_INT_CHECK_NON_NEGATIVE(numSplines, NULL);
-    PS_INT_CHECK_NON_NEGATIVE(order, NULL);
-    PS_FLOAT_CHECK_NON_EQUAL(max, min, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
+    PS_ASSERT_FLOAT_NON_EQUAL(max, min, NULL);
 
     psSpline1D *tmp = NULL;
@@ -1870,7 +1870,7 @@
                                    psS32 order)
 {
-    PS_VECTOR_CHECK_NULL(bounds, NULL);
-    PS_VECTOR_CHECK_EMPTY(bounds, NULL);
-    PS_INT_CHECK_NON_NEGATIVE(order, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
+    PS_ASSERT_VECTOR_NON_EMPTY(bounds, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
 
     psSpline1D *tmp = NULL;
@@ -1983,8 +1983,8 @@
                           psScalar *x)
 {
-    PS_VECTOR_CHECK_NULL(bins, -4);
-    PS_VECTOR_CHECK_EMPTY(bins, -4);
-    PS_PTR_CHECK_NULL(x, -6);
-    PS_PTR_CHECK_TYPE_EQUAL(x, bins, -3);
+    PS_ASSERT_VECTOR_NON_NULL(bins, -4);
+    PS_ASSERT_VECTOR_NON_EMPTY(bins, -4);
+    PS_ASSERT_PTR_NON_NULL(x, -6);
+    PS_ASSERT_PTR_TYPE_EQUAL(x, bins, -3);
     char* strType;
 
@@ -2049,11 +2049,11 @@
                                 psScalar *x)
 {
-    PS_VECTOR_CHECK_NULL(domain, NULL);
-    PS_VECTOR_CHECK_NULL(range, NULL);
-    PS_PTR_CHECK_NULL(x, NULL);
-    PS_INT_CHECK_NON_NEGATIVE(order, NULL);
-    PS_VECTOR_CHECK_SIZE_EQUAL(domain, range, NULL);
-    PS_PTR_CHECK_TYPE_EQUAL(domain, range, NULL);
-    PS_PTR_CHECK_TYPE_EQUAL(domain, x, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(domain, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(range, NULL);
+    PS_ASSERT_PTR_NON_NULL(x, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(order, NULL);
+    PS_ASSERT_VECTORS_SIZE_EQUAL(domain, range, NULL);
+    PS_ASSERT_PTR_TYPE_EQUAL(domain, range, NULL);
+    PS_ASSERT_PTR_TYPE_EQUAL(domain, x, NULL);
 
     psVector *range32 = NULL;
@@ -2131,7 +2131,7 @@
 )
 {
-    PS_PTR_CHECK_NULL(spline, NAN);
-    PS_INT_CHECK_NON_NEGATIVE(spline->n, NAN);
-    PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NAN);
+    PS_ASSERT_PTR_NON_NULL(spline, NAN);
+    PS_ASSERT_INT_NONNEGATIVE(spline->n, NAN);
+    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NAN);
 
     psS32 binNum;
@@ -2167,8 +2167,8 @@
 )
 {
-    PS_PTR_CHECK_NULL(spline, NULL);
-    PS_VECTOR_CHECK_NULL(x, NULL);
-    PS_VECTOR_CHECK_TYPE_F32_OR_F64(x, NULL);
-    PS_VECTOR_CHECK_TYPE(spline->knots, PS_TYPE_F32, NULL);
+    PS_ASSERT_PTR_NON_NULL(spline, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
+    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
 
     psS32 i;