Changeset 5904 for trunk/doc/pslib/psLibSDRS.tex

Timestamp:

Jan 5, 2006, 1:49:44 PM (21 years ago)

Author:

jhoblitt

Message:

convert complex declarations to be explicitly double complex

File:

• trunk/doc/pslib/psLibSDRS.tex (modified) (13 diffs)

trunk/doc/pslib/psLibSDRS.tex

@@ -1 @@
-%%% $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 +926 @@
     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 +3306 @@
         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 +3322 @@
 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 +3338 @@
 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 +3358 @@
         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 +3448 @@
 
 \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 +3497 @@
         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 +3570 @@
 
 \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 +5263 @@
 \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 +5277 @@
 \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 +5396 @@
 
 \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 +5432 @@
 
 \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