Index: trunk/psLib/src/astro/psCoord.c
===================================================================
--- trunk/psLib/src/astro/psCoord.c	(revision 4541)
+++ trunk/psLib/src/astro/psCoord.c	(revision 4581)
@@ -10,6 +10,6 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-07-12 19:12:00 $
+*  @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -226,6 +226,6 @@
 
     psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
-    pt->x = psDPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
-    pt->y = psDPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
+    pt->x = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
+    pt->y = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
 
     psMemSetDeallocator(pt, (psFreeFunc) planeTransformFree);
@@ -246,5 +246,5 @@
     }
 
-    out->x = psDPolynomial2DEval(
+    out->x = psPolynomial2DEval(
                  transform->x,
                  coords->x,
@@ -252,5 +252,5 @@
              );
 
-    out->y = psDPolynomial2DEval(
+    out->y = psPolynomial2DEval(
                  transform->y,
                  coords->x,
@@ -275,6 +275,6 @@
 
     psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
-    pt->x = psDPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
-    pt->y = psDPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
+    pt->x = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
+    pt->y = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
 
     psMemSetDeallocator(pt, (psFreeFunc) planeDistortFree);
@@ -300,5 +300,5 @@
         out = (psPlane* ) psAlloc(sizeof(psPlane));
     }
-    out->x = psDPolynomial4DEval(
+    out->x = psPolynomial4DEval(
                  distort->x,
                  coords->x,
@@ -307,5 +307,5 @@
                  color
              );
-    out->y = psDPolynomial4DEval(
+    out->y = psPolynomial4DEval(
                  distort->y,
                  coords->x,
@@ -854,6 +854,6 @@
  *****************************************************************************/
 
-static psDPolynomial2D *multiplyDPoly2D(psDPolynomial2D *trans1,
-                                        psDPolynomial2D *trans2)
+static psPolynomial2D *multiplyDPoly2D(psPolynomial2D *trans1,
+                                       psPolynomial2D *trans2)
 {
     //TRACE: printf("multiplyDPoly2D(%d %d: %d %d)\n", trans1->nX, trans1->nY, trans2->nX, trans2->nY);
@@ -861,5 +861,5 @@
     psS32 orderY = (trans1->nY + trans2->nY) - 1;
 
-    psDPolynomial2D *out = psDPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *out = psPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
     //TRACE: printf("Creating poly (%d, %d)\n", orderX, orderY);
     for (psS32 i = 0 ; i < out->nX; i++) {
@@ -966,9 +966,9 @@
     for (psS32 t2x = 0 ; t2x < trans2->x->nX ; t2x++) {
         for (psS32 t2y = 0 ; t2y < trans2->x->nY ; t2y++) {
-            psDPolynomial2D *currPoly = psDPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
+            psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
 
             currPoly->coeff[0][0] = 1.0;
             currPoly->mask[0][0] = 0;
-            psDPolynomial2D *newPoly = NULL;
+            psPolynomial2D *newPoly = NULL;
 
             if (trans2->x->mask[t2x][t2y] == 0) {
@@ -1001,8 +1001,8 @@
     for (psS32 t2x = 0 ; t2x < trans2->y->nX ; t2x++) {
         for (psS32 t2y = 0 ; t2y < trans2->y->nY ; t2y++) {
-            psDPolynomial2D *currPoly = psDPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
+            psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
             currPoly->coeff[0][0] = 1.0;
             currPoly->mask[0][0] = 0;
-            psDPolynomial2D *newPoly = NULL;
+            psPolynomial2D *newPoly = NULL;
 
             if (trans2->y->mask[t2x][t2y] == 0) {
@@ -1062,5 +1062,5 @@
     // Create fake polynomial to use in evaluation
     //
-    psDPolynomial2D *fakePoly = psDPolynomial2DAlloc(order, order, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *fakePoly = psPolynomial2DAlloc(order, order, PS_POLYNOMIAL_ORD);
     for (int i = 0; i < order; i++) {
         for (int j = 0; j < order; j++) {
@@ -1098,5 +1098,5 @@
                 psF64 xOut = ((psPlane *) dest->data[g])->x;
                 psF64 yOut = ((psPlane *) dest->data[g])->y;
-                psF64 ijPoly = psDPolynomial2DEval(fakePoly, xIn, yIn);
+                psF64 ijPoly = psPolynomial2DEval(fakePoly, xIn, yIn);
                 fakePoly->mask[i][j] = 1;
 
@@ -1104,5 +1104,5 @@
                     for (psS32 n = 0; n < order - m; n++, mnIndex++) {
                         fakePoly->mask[m][n] = 0;
-                        psF64 mnPoly = psDPolynomial2DEval(fakePoly, xIn, yIn);
+                        psF64 mnPoly = psPolynomial2DEval(fakePoly, xIn, yIn);
                         fakePoly->mask[m][n] = 1;
 
Index: trunk/psLib/src/astro/psCoord.h
===================================================================
--- trunk/psLib/src/astro/psCoord.h	(revision 4541)
+++ trunk/psLib/src/astro/psCoord.h	(revision 4581)
@@ -10,6 +10,6 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-06-27 20:38:11 $
+*  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -71,6 +71,6 @@
 typedef struct
 {
-    psDPolynomial2D* x;         ///< 2D polynomial transform of X coordinates
-    psDPolynomial2D* y;         ///< 2D polynomial transform of Y coordinates
+    psPolynomial2D* x;         ///< 2D polynomial transform of X coordinates
+    psPolynomial2D* y;         ///< 2D polynomial transform of Y coordinates
 }
 psPlaneTransform;
@@ -90,6 +90,6 @@
 typedef struct
 {
-    psDPolynomial4D* x;         ///< 4D polynomial transform of X coordinates
-    psDPolynomial4D* y;         ///< 4D polynomial transform of Y coordinates
+    psPolynomial4D* x;         ///< 4D polynomial transform of X coordinates
+    psPolynomial4D* y;         ///< 4D polynomial transform of Y coordinates
 }
 psPlaneDistort;