Index: trunk/doc/pslib/psLibSDRS.tex
===================================================================
--- trunk/doc/pslib/psLibSDRS.tex	(revision 4110)
+++ trunk/doc/pslib/psLibSDRS.tex	(revision 4122)
@@ -1,3 +1,3 @@
-%%% $Id: psLibSDRS.tex,v 1.263 2005-06-04 02:37:24 jhoblitt Exp $
+%%% $Id: psLibSDRS.tex,v 1.264 2005-06-06 23:40:53 jhoblitt Exp $
 \documentclass[panstarrs,spec]{panstarrs}
 
@@ -1420,6 +1420,6 @@
 typedef struct {
     psType type;                        ///< vector data type and dimension
-    long int n;                         ///< size of vector
-    const long int nalloc;              ///< allocated data block
+    long n;                             ///< size of vector
+    const long nalloc;                  ///< allocated data block
     union {
         psS8  *S8;                      ///< Pointers to byte data
@@ -1450,7 +1450,7 @@
 %
 \begin{prototype}
-psVector *psVectorAlloc(long int nalloc, psElemType type);
-psVector *psVectorRealloc(psVector *vector, long int nalloc);
-psVector *psVectorRecycle(psVector *vector, long int nalloc, psElemType type);
+psVector *psVectorAlloc(long nalloc, psElemType type);
+psVector *psVectorRealloc(psVector *vector, long nalloc);
+psVector *psVectorRecycle(psVector *vector, long nalloc, psElemType type);
 \end{prototype}
 %
@@ -1474,5 +1474,5 @@
 
 \begin{prototype}
-psVector *psVectorExtend(psVector *vector, long int delta, long int nExtend);
+psVector *psVectorExtend(psVector *vector, long delta, long nExtend);
 \end{prototype}
 
@@ -1606,6 +1606,6 @@
 \begin{datatype}
 typedef struct {
-    const long int n;                   ///< size of array 
-    const long int nalloc;              ///< allocated data block
+    const long n;                       ///< size of array 
+    const long nalloc;                  ///< allocated data block
     void **data;                        ///< pointer to data block
 } psArray;
@@ -1619,6 +1619,6 @@
 %
 \begin{prototype}
-psArray *psArrayAlloc(long int nalloc);
-psArray *psArrayRealloc(psArray *array, long int nalloc);
+psArray *psArrayAlloc(long nalloc);
+psArray *psArrayRealloc(psArray *array, long nalloc);
 \end{prototype}
 %
@@ -1637,5 +1637,5 @@
 
 \begin{prototype}
-psArray *psArrayAdd(psArray *array, long int delta, psPtr data);
+psArray *psArrayAdd(psArray *array, long delta, psPtr data);
 \end{prototype}
 
@@ -1657,6 +1657,6 @@
 
 \begin{prototype}
-bool psArraySet(psArray *array, long int position, psPtr data);
-psPtr psArrayGet(const psArray *array, long int position);
+bool psArraySet(psArray *array, long position, psPtr data);
+psPtr psArrayGet(const psArray *array, long position);
 \end{prototype}
 
@@ -1690,8 +1690,8 @@
 \begin{datatype}
 typedef struct {
-   long int n;                         ///< number of elements on list
-   psListElem *head;                   ///< first element on list (may be NULL)
-   psListElem *tail;                   ///< last element on list (may be NULL)
-   psArray *iterators;                 ///< array of psListIterator: iteration cursors
+   long n;                              ///< number of elements on list
+   psListElem *head;                    ///< first element on list (may be NULL)
+   psListElem *tail;                    ///< last element on list (may be NULL)
+   psArray *iterators;                  ///< array of psListIterator: iteration cursors
 } psList;
 \end{datatype}
@@ -1742,9 +1742,9 @@
 \begin{datatype}
 typedef struct {
-    psList *list;                      ///< List iterator works on
-    psListElem *cursor;                ///< The current iterator cursor
-    bool offEnd;                       ///< Is the iterator off the end?
-    long int index;                    ///< Index of iterator, to assist performance
-    bool mutable;                      ///< Is it permissible to modify the list?
+    psList *list;                       ///< List iterator works on
+    psListElem *cursor;                 ///< The current iterator cursor
+    bool offEnd;                        ///< Is the iterator off the end?
+    long index;                         ///< Index of iterator, to assist performance
+    bool mutable;                       ///< Is it permissible to modify the list?
 } psListIterator;
 \end{datatype}
@@ -1763,5 +1763,5 @@
 The corresponding constructor shall be:
 \begin{prototype}
-psListIterator *psListIteratorAlloc(const psList *list, long int location, bool mutable);
+psListIterator *psListIteratorAlloc(const psList *list, long location, bool mutable);
 \end{prototype}
 Here, \code{list} is the \code{psList} on which the iterator will
@@ -1791,5 +1791,5 @@
 
 \begin{prototype}
-bool psListAdd(psList *list, long int location, psPtr data);
+bool psListAdd(psList *list, long location, psPtr data);
 bool psListAddAfter(psListIterator *iterator, psPtr data);
 bool psListAddBefore(psListIterator *iterator, psPtr data);
@@ -1809,5 +1809,5 @@
 
 \begin{prototype}
-psPtr psListGet(psList *list, long int location);
+psPtr psListGet(psList *list, long location);
 psPtr psListGetAndIncrement(psListIterator *iterator);
 psPtr psListGetAndDecrement(psListIterator *iterator);
@@ -1839,5 +1839,5 @@
 
 \begin{prototype}
-bool psListRemove(psList *list, long int location)
+bool psListRemove(psList *list, long location)
 bool psListRemoveData(psList *list, psPtr data);
 \end{prototype}
@@ -1900,5 +1900,5 @@
 \begin{datatype}
 typedef struct {
-    long int n;                         ///< number of buckets
+    long n;                             ///< number of buckets
     psHashBucket **buckets;             ///< the buckets themselves
 } psHash;
@@ -1922,5 +1922,5 @@
 A hash table is created with the following function:
 \begin{prototype}
-psHash *psHashAlloc(long int nalloc);
+psHash *psHashAlloc(long nalloc);
 \end{prototype}
 which allocates the space for the hash table, creating and
@@ -1999,5 +1999,5 @@
     const char *filename;               ///< File from which data is to be read
     const char *format;                 ///< scanf-like format string for file
-    long int indexCol;                  ///< Column of the index vector (starting at zero)
+    long indexCol;                      ///< Column of the index vector (starting at zero)
     psVector *index;                    ///< Index values
     psArray *values;                    ///< Corresponding values: an array of vectors
@@ -2023,6 +2023,6 @@
 \begin{prototype}
 psLookupTable *psLookupTableAlloc(const char *filename, ///< File from which to read
-                                  const char *format, ///< scanf-like format string
-                                  long int indexCol ///< Column of the index vector (starting at zero)
+                                  const char *format,   ///< scanf-like format string
+                                  long indexCol         ///< Column of the index vector (starting at zero)
                                   );
 \end{prototype}
@@ -2035,7 +2035,7 @@
 
 \begin{prototype}
-psLookupTable *psLookupTableImport(psLookupTable *table, ///< Lookup table into which to import
-                                   const psArray *vectors, ///< Array of vectors
-                                   long int indexCol ///< Index of the index vector in the array of vectors
+psLookupTable *psLookupTableImport(psLookupTable *table,    ///< Lookup table into which to import
+                                   const psArray *vectors,  ///< Array of vectors
+                                   long indexCol            ///< Index of the index vector in the array of vectors
                                    );
 \end{prototype}
@@ -2055,5 +2055,5 @@
 
 \begin{prototype}
-long int psLookupTableRead(psLookupTable *table);
+long psLookupTableRead(psLookupTable *table);
 \end{prototype}
 \code{psLookupTableRead} combines \code{psVectorsReadFromFile} and
@@ -2067,5 +2067,5 @@
 functions:
 \begin{prototype}
-double psLookupTableInterpolate(const psLookupTable *table, double index, long int column, psLookupStatusType *status);
+double psLookupTableInterpolate(const psLookupTable *table, double index, long column, psLookupStatusType *status);
 psVector *psLookupTableInterpolateAll(const psLookupTable *table, double index, psVector *stats);
 \end{prototype}
@@ -2114,5 +2114,5 @@
 \begin{datatype}
 typedef struct {
-    long int n;                         ///< Number of chars that form the bitset
+    long n;                             ///< Number of chars that form the bitset
     char *bits;                         ///< The bits
 } psBitSet;
@@ -2121,5 +2121,5 @@
 We also require the corresponding constructor and destructor:
 \begin{prototype}
-psBitSet *psBitSetAlloc(long int nalloc);
+psBitSet *psBitSetAlloc(long nalloc);
 \end{prototype}
 where \code{n} is the requested number of bits.
@@ -2135,9 +2135,9 @@
 
 \begin{prototype}
-psBitSet *psBitSetSet(psBitSet *bitSet, long int bit);
-psBitSet* psBitSetClear(psBitSet *bitSet, long int bit);
+psBitSet *psBitSetSet(psBitSet *bitSet, long bit);
+psBitSet* psBitSetClear(psBitSet *bitSet, long bit);
 psBitSet *psBitSetOp(psBitSet *outBitSet, const psBitSet *inBitSet1, const char *operator, const psBitSet *inBitSet2);
 psBitSet *psBitSetNot(psBitSet *outBitSet, const psBitSet *inBitSet);
-bool psBitSetTest(const psBitSet *bitSet, long int bit);
+bool psBitSetTest(const psBitSet *bitSet, long bit);
 char *psBitSetToString(const psBitSet* bitSet);
 \end{prototype}
@@ -4726,6 +4726,6 @@
 
 \begin{prototype}
-    psArray *psDBSelectColumn(psDB *dbh, const char *tableName, const char *col, unsigned long int limit);
-    psVector *psDBSelectColumnNum(psDB *dbh, const char *tableName, const char *col, psElemType type, unsigned long int limit);
+    psArray *psDBSelectColumn(psDB *dbh, const char *tableName, const char *col, unsigned long limit);
+    psVector *psDBSelectColumnNum(psDB *dbh, const char *tableName, const char *col, psElemType type, unsigned long limit);
 \end{prototype}
 
@@ -4738,5 +4738,5 @@
 
 \begin{prototype}
-    psArray *psDBSelectRows(psDB *dbh, const char *tableName, psMetadata *where, unsigned long int limit);
+    psArray *psDBSelectRows(psDB *dbh, const char *tableName, psMetadata *where, unsigned long limit);
 \end{prototype}