Index: /trunk/doc/pslib/psLibSDRS.tex =================================================================== --- /trunk/doc/pslib/psLibSDRS.tex (revision 7553) +++ /trunk/doc/pslib/psLibSDRS.tex (revision 7554) @@ -1,3 +1,3 @@ -%%% $Id: psLibSDRS.tex,v 1.401 2006-06-13 21:58:17 price Exp $ +%%% $Id: psLibSDRS.tex,v 1.402 2006-06-14 01:33:49 price Exp $ \documentclass[panstarrs,spec]{panstarrs} @@ -925,5 +925,5 @@ \begin{prototype} -psList *psStringSplit(const char *string, const char *splitters); +psList *psStringSplit(const char *string, const char *splitters, bool multipleAreSignificant); \end{prototype} @@ -931,9 +931,10 @@ \code{psList} of \code{psStrings}. The \code{string} is split at any one of the characters in \code{splitters}. Split strings of zero -length should not be included in the output list. +length should not be included in the output list if +\code{multipleAreSignificant} is \code{true}. String whitespace from head and tail of string: \begin{prototype} -int psStringStrip (char *string); +size_t psStringStrip(char *string); \end{prototype} @@ -1010,7 +1011,9 @@ PS_DATA_S16 = PS_TYPE_S16, ///< psS16 PS_DATA_S32 = PS_TYPE_S32, ///< psS32 + PS_DATA_S64 = PS_TYPE_S64, ///< psS64 PS_DATA_U8 = PS_TYPE_U8, ///< psU8 PS_DATA_U16 = PS_TYPE_U16, ///< psU16 PS_DATA_U32 = PS_TYPE_U32, ///< psU32 + PS_DATA_U64 = PS_TYPE_U64, ///< psU64 PS_DATA_F32 = PS_TYPE_F32, ///< psF32 PS_DATA_F64 = PS_TYPE_F64, ///< psF64 @@ -2654,7 +2657,9 @@ psS16 S16; ///< integer data psS32 S32; ///< integer data + psS64 S64; ///< integer data psU8 U8; ///< integer data psU16 U16; ///< integer data psU32 U32; ///< integer data + psU64 U64; ///< integer data psF32 F32; ///< floating-point data psF64 F64; ///< double-precision data @@ -2936,13 +2941,13 @@ \begin{prototype} psBool psMetadataItemParseBool(const psMetadataItem *item); -psF32 psMetadataItemParseF32(psMetadataItem *item); -psF64 psMetadataItemParseF64(psMetadataItem *item); +psF32 psMetadataItemParseF32(const psMetadataItem *item); +psF64 psMetadataItemParseF64(const psMetadataItem *item); psS8 psMetadataItemParseS8(const psMetadataItem *item); psS16 psMetadataItemParseS16(const psMetadataItem *item); -psS32 psMetadataItemParseS32(psMetadataItem *item); +psS32 psMetadataItemParseS32(const psMetadataItem *item); psU8 psMetadataItemParseU8(const psMetadataItem *item); psU16 psMetadataItemParseU16(const psMetadataItem *item); psU32 psMetadataItemParseU32(const psMetadataItem *item); -psString psMetadataItemParseString(psMetadataItem *item); +psString psMetadataItemParseString(const psMetadataItem *item); \end{prototype} @@ -4109,5 +4114,5 @@ \begin{datatype} typedef struct { - fitsfile fd; // cfitsio structure + fitsfile *fd; // cfitsio structure bool writable; // Is the file writable? } psFits; @@ -4327,5 +4332,5 @@ \begin{prototype} -bool psFitsWriteImage(psFits *fits, psMetadata *header, const psImage *input, int depth, +bool psFitsWriteImage(psFits *fits, const psMetadata *header, const psImage *input, int depth, const char *extname); \end{prototype} @@ -4340,5 +4345,5 @@ \begin{prototype} -bool psFitsInsertImage(psFits *fits, psMetadata *header, const psImage *input, int depth, +bool psFitsInsertImage(psFits *fits, const psMetadata *header, const psImage *input, int depth, const char *extname, bool after); \end{prototype} @@ -5250,14 +5255,11 @@ \begin{prototype} - bool psVectorFitSpline1D(psSpline1D *spline, const psVector *x, const psVector *y, - const psVector * yErr); -\end{prototype} -\code{psVectorFitSpline1D} shall fit the code{spline} that best fits -the given combination of ordinates (\code{x}) and coordinates -(\code{y}) with the known errors (\code{yErr}, which may be -\code{NULL}). As is the case for \code{psVectorFitPolynomial1D}, if -\code{x} is \code{NULL}, then the index of \code{y} shall be used as -the ordinate. This function must be valid only for types -\code{psF32}, \code{psF64}. +psSpline1D *psVectorFitSpline1D(const psVector *x, const psVector *y); +\end{prototype} +\code{psVectorFitSpline1D} shall return the spline that best fits the +given combination of ordinates (\code{x}) and coordinates (\code{y}). +As is the case for \code{psVectorFitPolynomial1D}, if \code{x} is +\code{NULL}, then the index of \code{y} shall be used as the ordinate. +This function must be valid only for types \code{psF32}, \code{psF64}. \subsubsection{Additional polynomial functions} @@ -5367,5 +5369,5 @@ identical to a 180\degree\ rotation. \begin{prototype} -psImage *psImageFlip(psImage *output, const psImage *image, +psImage *psImageFlip(psImage *output, const psImage *input, bool xFlip, bool yFlip); \end{prototype} @@ -5629,5 +5631,5 @@ \tbd{Description required for psImageUnbin} \begin{prototype} -psImage *psImageUnbin(psImage *out, psImage *in, int DX, int DY, int dx, int dy); +psImage *psImageUnbin(psImage *out, const psImage *in, int DX, int DY, int dx, int dy); \end{prototype} \tbd{Can ``out'' be NULL? I'm not sure this is the best way to specify this function for a library.} @@ -5833,5 +5835,5 @@ The following function allocates, but does not specify, a JPEG colormap: \begin{prototype} -psImageJpegColormap *psImageJpegColormapAlloc (); +psImageJpegColormap *psImageJpegColormapAlloc(); \end{prototype} @@ -5841,5 +5843,5 @@ \code{rainbow}, \code{heat}. \begin{prototype} -psImageJpegColormap *psImageJpegColormapSet (psImageJpegColormap *map, char *name); +psImageJpegColormap *psImageJpegColormapSet(psImageJpegColormap *map, const char *name); \end{prototype} @@ -5849,5 +5851,6 @@ (the values of the single image determine the colors). \begin{prototype} -bool psImageJpeg (psImageJpegColormap *map, psImage *image, char *filename, float min, float max); +bool psImageJpeg(const psImageJpegColormap *map, const psImage *image, + const char *filename, float min, float max); \end{prototype} @@ -6164,10 +6167,10 @@ only add elements above the diagonal. \begin{prototype} -void psSparseMatrixElement (psSparse *sparse, int i, int j, float value); +void psSparseMatrixElement(psSparse *sparse, int i, int j, float value); \end{prototype} The following function define a new sparse matrix equation vector element: \begin{prototype} -void psSparseVectorElement (psSparse *sparse, int i, float value); +void psSparseVectorElement(psSparse *sparse, int i, float value); \end{prototype} @@ -6175,5 +6178,6 @@ on a sparse matrix and a vector: \begin{prototype} -psVector *psSparseMatrixTimesVector (psVector *output, psSparse *matrix, psVector *vector); +psVector *psSparseMatrixTimesVector(psVector *output, const psSparse *matrix, + const psVector *vector); \end{prototype} @@ -6182,5 +6186,5 @@ function before attempting to solve, but after populating, the matrix and vector: \begin{prototype} -void psSparseResort (psSparse *sparse); +void psSparseResort(psSparse *sparse); \end{prototype} @@ -6188,5 +6192,6 @@ \bar{Bf}$. For the value of $\bar{x}$, a good starting guess is the vector $\bar{Bf}$ \begin{prototype} -psVector *psSparseSolve (psVector *guess, psSparseConstraint constraint, psSparse *sparse, int Niter); +psVector *psSparseSolve(psVector *guess, psSparseConstraint constraint, + const psSparse *sparse, int Niter); \end{prototype}