Index: trunk/doc/pslib/psLibSDRS.tex
===================================================================
--- trunk/doc/pslib/psLibSDRS.tex	(revision 5877)
+++ trunk/doc/pslib/psLibSDRS.tex	(revision 5904)
@@ -1,3 +1,3 @@
-%%% $Id: psLibSDRS.tex,v 1.369 2006-01-04 04:26:21 jhoblitt Exp $
+%%% $Id: psLibSDRS.tex,v 1.370 2006-01-05 23:49:44 jhoblitt Exp $
 \documentclass[panstarrs,spec]{panstarrs}
 
@@ -926,6 +926,6 @@
     PS_TYPE_F32,                       ///< Floating point
     PS_TYPE_F64,                       ///< Double-precision floating point
-    PS_TYPE_C32,                       ///< Complex numbers consisting of floats
-    PS_TYPE_C64,                       ///< Complex numbers consisting of doubles
+    PS_TYPE_C32,                       ///< Float complex
+    PS_TYPE_C64,                       ///< Double complex
     PS_TYPE_BOOL                       ///< Boolean value
 } psElemType;
@@ -3306,13 +3306,13 @@
         psS8   S8;                      ///< bye value entry
         psS16 S16;                      ///< short int value entry
-	psS32 S32;                      ///< int value entry
-	psS64 S64;                      ///< long int value entry
+        psS32 S32;                      ///< int value entry
+        psS64 S64;                      ///< long int value entry
         psU8   U8;                      ///< unsigned byte value entry
         psU16 U16;                      ///< unsigned short int value entry
-	psU32 U32;                      ///< unsigned int value entry
-	psU64 U64;                      ///< unsigned long int value entry
+        psU32 U32;                      ///< unsigned int value entry
+        psU64 U64;                      ///< unsigned long int value entry
         psF32 F32;                      ///< float value entry
         psF64 F64;                      ///< double value entry
-        psC32 C32;                      ///< complex value entry
+        psC32 C32;                      ///< float complex value entry
         psC64 C64;                      ///< double complex value entry
     } data;
@@ -3322,5 +3322,5 @@
 In addition, we specify two functions for working with \code{psScalar} data:
 \begin{prototype}
-psScalar *psScalarAlloc(complex value, psElemType type);
+psScalar *psScalarAlloc(double complex value, psElemType type);
 psScalar *psScalarCopy(const psScalar *value);
 \end{prototype}
@@ -3338,5 +3338,5 @@
 We require several related types of basic one-dimensional arrays:
 arrays of values of type \code{int}, \code{float}, \code{double},
-\code{complex float}, and \code{complex}.  We have defined a
+\code{float complex}, and \code{double complex}.  We have defined a
 single structure, \code{psVector} to represent these concepts:
 %
@@ -3358,5 +3358,5 @@
         psF64 *F64;                     ///< Pointers to double-precision data
         psC32 *C32;                     ///< Pointers to complex floating-point data
-        psC64 *C64;                     ///< Pointers to complex floating-point data
+        psC64 *C64;                     ///< Pointers to complex double-precision data
     } data;
     void *lock;                         ///< Lock for thread safety
@@ -3448,6 +3448,6 @@
 
 \begin{prototype}
-bool psVectorSet(const psVector *input, long position, complex value);
-complex psVectorGet(const psVector *input, long position);
+bool psVectorSet(const psVector *input, long position, double complex value);
+double complex psVectorGet(const psVector *input, long position);
 \end{prototype}
 
@@ -3497,5 +3497,5 @@
         psF64 **F64;                    ///< Pointers to double-precision data
         psC32 **C32;                    ///< Pointers to complex floating-point data
-        psC64 **C64;                    ///< Pointers to complex floating-point data
+        psC64 **C64;                    ///< Pointers to complex double-precision data
         psPtr *V;                       ///< Pointers to untyped data
     } data;
@@ -3570,6 +3570,6 @@
 
 \begin{prototype}
-bool psImageSet(const psImage *image, int x, int y, complex value);
-complex psImageGet(const psImage *image, int x, int y);
+bool psImageSet(const psImage *image, int x, int y, double complex value);
+double complex psImageGet(const psImage *image, int x, int y);
 \end{prototype}
 
@@ -5263,5 +5263,5 @@
 \begin{prototype}
 psImage *psImageRotate(psImage *out, const psImage *input, float angle,
-                       complex exposed, psImageInterpolateMode mode);
+                       double complex exposed, psImageInterpolateMode mode);
 \end{prototype}
 Rotate the input image by given angle, specified in radians.  The
@@ -5277,5 +5277,5 @@
 \begin{prototype}
 psImage *psImageShift(psImage *out, const psImage *input, 
-                      float dx, float dy, complex exposed, psImageInterpolateMode mode);
+                      float dx, float dy, double complex exposed, psImageInterpolateMode mode);
 \end{prototype}
 Shift image by an arbitrary number of pixels (\code{dx,dy}) in either
@@ -5396,7 +5396,7 @@
 
 \begin{prototype}
-complex psImagePixelInterpolate(const psImage *input, float x, float y,
+double complex psImagePixelInterpolate(const psImage *input, float x, float y,
                               const psImage *mask, psMaskType maskVal,
-                              complex unexposedValue, psImageInterpolateMode mode);
+                              double complex unexposedValue, psImageInterpolateMode mode);
 \end{prototype}
 Perform interpolation of image pixel values to the given fractional
@@ -5432,6 +5432,7 @@
 
 \begin{prototype}
-int psImageClipComplexRegion(psImage *input, complex min, complex vmin,
-                             complex max, complex vmax);
+int psImageClipComplexRegion(psImage *input, double complex min,
+                             double complex vmin, double complex max,
+                             double complex vmax);
 \end{prototype}
 Clip image values outside of range to given values.  All pixels with