Changeset 4995 for trunk/psLib/test/math/tst_psMinimize04.c

Timestamp:

Sep 12, 2005, 10:31:24 AM (21 years ago)

Author:

gusciora

Message:

....

File:

• trunk/psLib/test/math/tst_psMinimize04.c (modified) (6 diffs)

trunk/psLib/test/math/tst_psMinimize04.c

@@ -1 +1 @@
 /*****************************************************************************
-This routine must ensure that the psVectorFitPolynomial1D works correctly.
+This routine must ensure that the psVectorFitPolynomial2D works correctly.
 We create a vectors of data points (x and y), and populate them with the
 values from an arbitrary function setData().  We then call
-psVectorFitPolynomial1D() with a regular polynomial data structure.  We then
+psVectorFitPolynomial2D() with a regular polynomial data structure.  We then
 evaluate the polynomial with the coefficients generated above and determine
 if they are within an error tolerance of the expected values.
@@ -25 +25 @@
 #define B 2.0
 #define C 3.0
+#define D 3.0
+#define E 3.0
+#define F 3.0
 #define ERROR_TOLERANCE 0.10
-#define YERR 1.0
-double setData(double x)
+#define FERR 1.0
+#define PRINT_RESULTS 0
+
+double setData(double x, double y)
 {
-    return(A + (B * x) + (C * x * x));
+    return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (E * x * y));
 }
 
 psS32 t00()
 {
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psVector *yErr = NULL;
-    psS32 i = 0;
     psS32 currentId = psMemGetId();
     psS32 testStatus = true;
@@ -45 +45 @@
     double actualData;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *f = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *fErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
 
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F64[i] = (double) i;
-        y->data.F64[i] = setData(x->data.F64[i]);
-        yErr->data.F64[i] = YERR;
-        //        printf("Original data %d: (%.1f %.1f)\n", i, x->data.F64[i], y->data.F64[i]);
+    for (psS32 i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (double) i;
+        y->data.F32[i] = (double) i;
+        f->data.F32[i] = setData(x->data.F32[i], y->data.F32[i]);
+        fErr->data.F32[i] = FERR;
     }
 
     printPositiveTestHeader(stdout,
                             "psMinimize functions",
-                            "psVectorFitPolynomial1D(): equal difference in variable yErr");
+                            "psVectorFitPolynomial2D(): equal difference in variable fErr");
 
-    psVectorFitPolynomial1D(myPoly, x, y, yErr);
+    printf("TEST: calling psVectorFitPolynomial2D() with f, fErr, y, x as F32 vectors.\n");
+    psVectorFitPolynomial2D(myPoly, NULL, 0, f, fErr, x, y);
 
     //    for (i=0;i<POLY_ORDER+1;i++) {
@@ -67 +69 @@
     //    }
 
-    for (i=0;i<NUM_DATA;i++) {
-        expectData = setData(x->data.F64[i]);
-        actualData = psPolynomial1DEval(
-                         myPoly,
-                         x->data.F64[i]
-                     );
+    for (psS32 i=0;i<NUM_DATA;i++) {
+        expectData = setData(x->data.F32[i],  y->data.F32[i]);
+        actualData = psPolynomial2DEval(myPoly, x->data.F32[i], y->data.F32[i]);
         if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F64[i], actualData, expectData);
+            printf("ERROR: Fitted data %d: (%.1f %.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], y->data.F32[i], actualData, expectData);
             testStatus = false;
         }
-        //        } else {
-        //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-        //                   i, x->data.F64[i], actualData, expectData);
-        //        }
+        if (PRINT_RESULTS) {
+            printf("Data point [%d] is %f, should be %f.\n", i, actualData, expectData);
+        }
+    }
+
+
+    printf("Running test with fErr set to NULL.\n");
+    psVectorFitPolynomial2D(myPoly, NULL, 0, f, NULL, x, y);
+    for (psS32 i=0;i<NUM_DATA;i++) {
+        expectData = setData(x->data.F32[i],  y->data.F32[i]);
+        actualData = psPolynomial2DEval(myPoly, x->data.F32[i], y->data.F32[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("ERROR: Fitted data %d: (%.1f %.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], y->data.F32[i], actualData, expectData);
+            testStatus = false;
+        }
+        if (PRINT_RESULTS) {
+            printf("Data point [%d] is %f, should be %f.\n", i, actualData, expectData);
+        }
+    }
+    psFree(myPoly);
+
+    printf("Running test with x, y set to NULL.  Should generate error.\n");
+    myPoly = psVectorFitPolynomial2D(NULL, NULL, 0, f, fErr, NULL, NULL);
+    if (myPoly != NULL) {
+        printf("TEST ERROR: psVectorFitPolynomial2D() returned non-NULL.\n");
+        testStatus = false;
     }
 
     psMemCheckCorruption(1);
-    psFree(myPoly);
     psFree(x);
     psFree(y);
-    psFree(yErr);
+    psFree(f);
+    psFree(fErr);
     psMemCheckCorruption(1);
     memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
@@ -97 +119 @@
     printFooter(stdout,
                 "psMinimize functions",
-                "psVectorFitPolynomial1D(): equal differences in variable yErr",
+                "psVectorFitPolynomial2D(): equal differences in variable fErr",
                 testStatus);
 
@@ -103 +125 @@
 }
 
-psS32 t01()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    double expectData;
-    double actualData;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F64[i] = (double) i;
-        y->data.F64[i] = setData(x->data.F64[i]);
-        //        printf("Original data %d: (%.1f %.1f)\n", i, x->data.F64[i], y->data.F64[i]);
-    }
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, x, y, NULL);
-
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    for (i=0;i<NUM_DATA;i++) {
-        expectData = setData(x->data.F64[i]);
-        actualData = psPolynomial1DEval(
-                         myPoly,
-                         x->data.F64[i]
-                     );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F64[i], actualData, expectData);
-            testStatus = false;
-            //        } else {
-            //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-            //                   i, x->data.F64[i], actualData, expectData);
-        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): yErr is NULL",
-                testStatus);
-
-    return (!testStatus);
-}
-
-psS32 t02()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    double expectData;
-    double actualData;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-
-    for (i=0;i<NUM_DATA;i++) {
-        y->data.F64[i] = setData((double) i);
-        //        printf("Original data %d: (%.1f)\n", i, y->data.F64[i]);
-    }
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): x, yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, y, NULL);
-
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    for (i=0;i<NUM_DATA;i++) {
-        expectData = setData((double) i);
-        actualData = psPolynomial1DEval(
-                         myPoly,
-                         (double) i
-                     );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, (double) i, actualData, expectData);
-            testStatus = false;
-            //        } else {
-            //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-            //                   i, (double) i, actualData, expectData);
-        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): x, yErr is NULL",
-                testStatus);
-
-    return (!testStatus);
-}
-
-psS32 t03()
-{
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    psPolynomial1D *myPoly = NULL;
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): all inputs are NULL");
-
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for null input polynomial.");
-    myPoly = psVectorFitPolynomial1D(NULL, NULL, NULL, NULL);
-    if ( myPoly != NULL ) {
-        psError(PS_ERR_UNKNOWN, true,"A null polynomial should have returned a null pointer.");
-        testStatus = false;
-    }
-
-
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): all inputs are NULL",
-                testStatus);
-
-    return (!testStatus);
-}
-
-
 psS32 main()
 {
     psLogSetFormat("HLNM");
     t00();
-    t01();
-    t02();
-    t03();
 }