IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 1592


Ignore:
Timestamp:
Aug 18, 2004, 6:32:24 PM (22 years ago)
Author:
Paul Price
Message:

Removed "restrict"s and "const"s, among other things.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/pslib/psLibSDRS.tex

    r1571 r1592  
    1 %%% $Id: psLibSDRS.tex,v 1.81 2004-08-19 01:30:33 price Exp $
     1%%% $Id: psLibSDRS.tex,v 1.82 2004-08-19 04:32:24 price Exp $
    22\documentclass[panstarrs,spec]{panstarrs}
    33
    … …  
    11371137determine the type of the data on the basis of the data. 
    11381138Supported data types must be defined by a structure in which
    1139 the first element is always of type \code{psType}: 
     1139the first element is always of type \code{psType}:
    11401140\begin{verbatim}
    11411141typedef struct {
    … …  
    11711171    PS_TYPE_C32,                        ///< Complex numbers consisting of floats
    11721172    PS_TYPE_C64,                        ///< Complex numbers consisting of doubles
    1173     PS_TYPE_OTHER,                      ///< Not supported for arithmetic
     1173    PS_TYPE_OTHER                       ///< Not supported for arithmetic
    11741174} psElemType;
    11751175\end{verbatim}
    … …  
    12481248to use automatic construction mechanisms effectively.  The data type
    12491249is defined by the first element, \code{psType}.  The structure is
    1250 associated with a constructor and a destructor:
     1250associated with a constructor and reallocator:
    12511251%
    12521252\begin{verbatim}
    12531253psVector *psVectorAlloc(int nalloc, psElemType type);
    12541254psVector *psVectorRealloc(const psVector *vector, int nalloc);
    1255 void p_psVectorFree(psVector *restrict vector);
    12561255\end{verbatim}
    12571256%
    … …  
    13271326dimensionality must be 2. 
    13281327
    1329 \begin{verbatim}
    1330 void p_psImageFree(psImage *restrict image);
    1331 \end{verbatim}
    1332 Free the memory associated with a specific image, including the pixel
    1333 data. Free the children of the image if they exist.
    1334 
    13351328\subsection{Simple Arrays}
    13361329
    … …  
    13551348%
    13561349\begin{verbatim}
    1357 psArray *psArrayAlloc(int nalloc, psElemType type);
     1350psArray *psArrayAlloc(int nalloc);
    13581351psArray *psArrayRealloc(const psArray *array, int nalloc);
    1359 void p_psArrayFree(psArray *restrict array);
    13601352\end{verbatim}
    13611353%
    … …  
    14091401   struct psListElem *prev;            ///< previous link in list
    14101402   struct psListElem *next;            ///< next link in list
    1411    void *data;                          ///< real data item
     1403   void *data;                         ///< real data item
    14121404} psListElem;
    14131405\end{verbatim}
    … …  
    14271419\code{NULL}, then an empty list, with both pointers are set to
    14281420\code{NULL} should be created.
     1421
     1422The destructor function for \code{psList} must free the data
     1423associated with the entire list.
    14291424
    14301425\begin{verbatim}
    … …  
    14691464data from a list (with \code{psListGet}) also increments the reference
    14701465counter.
    1471 
    1472 \begin{verbatim}
    1473 void p_psListFree(psList *list);
    1474 \end{verbatim}
    1475 This function frees the data associated with the entire list.  This
    1476 function is used by psFree to free a list with its associated data.
    14771466
    14781467\begin{verbatim}
    … …  
    15341523\begin{verbatim}
    15351524typedef struct {
    1536     int nbucket;                        // number of buckets
    1537     psHashBucket **buckets;             // the buckets themselves
     1525    int nbucket;                        ///< number of buckets
     1526    psHashBucket **buckets;             ///< the buckets themselves
    15381527} psHash;
    15391528\end{verbatim}
    … …  
    15451534\begin{verbatim}
    15461535typedef struct psHashBucket {
    1547     char *key;                          // key for this item of data
    1548     void *data;                         // the data itself
    1549     struct psHashBucket *next;          // list of other possible keys
     1536    char *key;                          ///< key for this item of data
     1537    void *data;                         ///< the data itself
     1538    struct psHashBucket *next;          ///< list of other possible keys
    15501539} psHashBucket;
    15511540\end{verbatim}
    … …  
    15611550the buckets.
    15621551
     1552The destructor for \code{psHash} must free all data associated with a complete hash table.
     1553
    15631554A data item may be added to the hash table with the function:
    15641555\begin{verbatim}
    1565 bool psHashAdd(psHash *table, char *key, void *data);
     1556bool psHashAdd(psHash *table, const char *key, void *data);
    15661557\end{verbatim}
    15671558In this function, the value of the string \code{key} is used to
    … …  
    15741565The data associated with a given key may be found with the function:
    15751566\begin{verbatim}
    1576 void *psHashLookup(psHash *table, char *key);
     1567void *psHashLookup(psHash *table, const char *key);
    15771568\end{verbatim}
    15781569which returns the data value pointed to by the element associated with
    … …  
    15801571a specific key may be removed (deleted) with the function:
    15811572\begin{verbatim}
    1582 bool psHashRemove(psHash *table, char *key);
     1573bool psHashRemove(psHash *table, const char *key);
    15831574\end{verbatim}
    15841575The function returns a value of \code{true} if the operation was
    15851576successfull, and \code{false} otherwise.
    1586 
    1587 The data associated with a complete hash table may be freed by calling:
    1588 \begin{verbatim}
    1589 void p_psHashFree(psHash *table);
    1590 \end{verbatim}
    15911577
    15921578The function
    … …  
    16361622\begin{verbatim}
    16371623psBitSet *psBitSetAlloc(int n);
    1638 void p_psBitSetFree(psBitSet *restrict myBits);
    16391624\end{verbatim}
    16401625where \code{n} is the requested number of bits.
    … …  
    16501635
    16511636\begin{verbatim}
    1652 psBitSet *psBitSetSet(psBitSet *restrict myBits, int bit);
     1637psBitSet *psBitSetSet(psBitSet *myBits, int bit);
    16531638psBitSet *psBitSetOp(psBitSet *outBits,
    1654                      const psBitSet *restrict inBits1,
     1639                     const psBitSet *inBits1,
    16551640                     char *operator,
    1656                      const psBitSet *restrict inBits2);
     1641                     const psBitSet *inBits2);
    16571642psBitSet *psBitSetNot(psBitSet *out, psBitSet *in);
    1658 bool psBitSetTest(const psBitSet *restrict checkBits, int bit);
     1643bool psBitSetTest(const psBitSet *checkBits, int bit);
    16591644\end{verbatim}
    16601645
    … …  
    16891674
    16901675\begin{verbatim}
    1691 psVector *psVectorSort(psVector *out, const psVector *restrict in);
     1676psVector *psVectorSort(psVector *out, const psVector *in);
    16921677\end{verbatim}
    16931678
    … …  
    17031688
    17041689\begin{verbatim}
    1705 psVector *psVectorSortIndex(psVector *restrict out; const psVector *restrict in);
     1690psVector *psVectorSortIndex(psVector *out; const psVector *in);
    17061691\end{verbatim}
    17071692
    … …  
    17481733\begin{verbatim}
    17491734psStats *psVectorStats(psStats *stats,
    1750                        const psVector *restrict in,
    1751                        const psVector *restrict mask,
     1735                       const psVector *in,
     1736                       const psVector *mask,
    17521737                       unsigned int maskVal);
    17531738\end{verbatim}
    … …  
    17831768    double sampleUQ;                    ///< upper quartile of sample
    17841769    double sampleLQ;                    ///< lower quartile of sample
    1785     double sampleLimit;                 ///< Number of datapoints to
    17861770    double robustMean;                  ///< robust mean of data
    17871771    double robustMedian;                ///< robust median of data
    … …  
    18271811\end{verbatim}
    18281812
    1829 Associated constructors and destructors are also required:
    1830 
     1813A constructor is also required:
     1814%
    18311815\begin{verbatim}
    18321816psStats *psStatsAlloc(psStatsOptions options);
    1833 void p_psStatsFree(psStats *restrict stats);
    18341817\end{verbatim}
    18351818
    … …  
    18421825\begin{verbatim}
    18431826typedef struct {
    1844     const psVector *restrict bounds;    ///< Bounds for the bins
     1827    const psVector *bounds;             ///< Bounds for the bins
    18451828    psVector *nums;                     ///< Number in each of the bins
    18461829    int minNum, maxNum;                 ///< Number below minimum / above maximum
    1847     bool uniform;                        ///< Is it a uniform distribution?
     1830    bool uniform;                       ///< Is it a uniform distribution?
    18481831} psHistogram;
    18491832\end{verbatim}
    … …  
    18721855following constructor:
    18731856\begin{verbatim}
    1874 psHistogram *psHistogramAllocGeneric(const psVector *restrict bounds);
     1857psHistogram *psHistogramAllocGeneric(const psVector *bounds);
    18751858\end{verbatim}
    18761859where the \code{psVector *bounds} (of type \code{psF32}) is defined by
    … …  
    18781861constructor sets the value of \code{uniform} to be false.
    18791862
    1880 A histogram is free with the destructor:
    1881 \begin{verbatim}
    1882 void p_psHistogramFree(psHistogram *restrict myHist);
    1883 \end{verbatim}
    1884 
    18851863The following function populates the histogram bins from the specified
    18861864vector (\code{in}).  It alters and returns the histogram \code{out}
    … …  
    18881866\begin{verbatim}
    18891867psHistogram *psVectorHistogram(psHistogram *out,
    1890                                const psVector *restrict in,
    1891                                const psVector *restrict mask,
     1868                               const psVector *in,
     1869                               const psVector *mask,
    18921870                               unsigned int maskVal);
    18931871\end{verbatim}
    … …  
    19421920
    19431921\begin{verbatim}
    1944 /** Type of polynomial */
    19451922typedef enum {
    19461923    PS_POLYNOMIAL_ORD,                  ///< Ordinary polynomial
    … …  
    19771954naming convention exampled above.
    19781955
    1979 The constructor and destructor are:
     1956The constructor is:
    19801957\begin{verbatim}
    19811958psDPolynomial2D *psDPolynomial2DAlloc(int nX, int nY, psPolynomialType type);
    1982 void p_psDPolynomial2DFree(psDPolynomial2D *restrict myPoly);
    19831959\end{verbatim}
    19841960where \code{nX} and \code{nY} are the number of terms in x and y
    … …  
    19921968In the event that several evaluations are required, we also define:
    19931969\begin{verbatim}
    1994 psVector *psDPolynomial2DEvalVector(psVector *x, psVector *y, const psDPolynomial2D *restrict myPoly);
     1970psVector *psDPolynomial2DEvalVector(const psVector *x, const psVector *y,
     1971                                    const psDPolynomial2D *myPoly);
    19951972\end{verbatim}
    19961973If the \code{x} and \code{y} vectors do not match the precision of the
    … …  
    20101987
    20111988\begin{verbatim}
    2012 /** A 1D cubic-spline */
    20131989typedef struct {
    20141990    int n;                              ///< Number of spline pieces
    2015     psPolynomial1D *spline;             ///< Array of n splines
     1991    psPolynomial1D **spline;            ///< Array of n pointers to splines
    20161992    float *domains;                     ///< The boundaries between each spline piece.  Size is n+1.
    20171993} psSpline1D;
    … …  
    20552031\begin{verbatim}
    20562032float psSpline1DEval(const psSpline1D *spline, float x);
    2057 psVector *psSpline1DEvalVector(psVector *x, const psSpline1D *spline);
     2033psVector *psSpline1DEvalVector(const psVector *x, const psSpline1D *spline);
    20582034\end{verbatim}
    20592035
    … …  
    22742250
    22752251\begin{verbatim}
    2276 psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *myPoly, 
    2277                                         const psVector *restrict x,
    2278                                         const psVector *restrict y,
    2279                                         const psVector *restrict yErr);
     2252psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *myPoly,
     2253                                        const psVector *x,
     2254                                        const psVector *y,
     2255                                        const psVector *yErr);
    22802256\end{verbatim}
    22812257\code{psVectorFitPolynomial1d} returns the polynomial that best fits the
    … …  
    23292305
    23302306\begin{verbatim}
    2331 psImage *psImageSubsection(const psImage *image, const *section);
     2307psImage *psImageSubsection(const psImage *image, const char *section);
    23322308\end{verbatim}
    23332309Similar to \code{psImageSubset}, but uses an image \code{section}, of
    … …  
    23652341\begin{verbatim}
    23662342typedef enum {
    2367     PS_CUT_X_POS;
    2368     PS_CUT_X_NEG;
    2369     PS_CUT_Y_POS;
    2370     PS_CUT_Y_NEG;
     2343    PS_CUT_X_POS,
     2344    PS_CUT_X_NEG,
     2345    PS_CUT_Y_POS,
     2346    PS_CUT_Y_NEG
    23712347} psImageCutDirection;
    23722348
    23732349psVector *psImageSlice(psVector *out,
    23742350                       psVector *coords,
    2375                        const psImage *restrict input,
    2376                        const psImage *restrict mask,
     2351                       const psImage *input,
     2352                       const psImage *mask,
    23772353                       unsigned int maskVal,
    23782354                       unsigned int x,
    … …  
    23992375\begin{verbatim}
    24002376psVector *psImageCut(psVector *out, const psImage *input,
    2401                      const psImage *restrict mask,
     2377                     const psImage *mask,
    24022378                     unsigned int maskVal,
    24032379                     float xs, float ys, float xe, float ye,
    … …  
    24202396\begin{verbatim}
    24212397psVector *psImageRadialCut(psVector *out, const psImage *input,
    2422                            const psImage *restrict mask,
     2398                           const psImage *mask,
    24232399                           unsigned int maskVal,
    24242400                           float x, float y,
    … …  
    24852461
    24862462\begin{verbatim}
    2487 psImage *psImageRotate(psImage *out, const psImage *input, float angle, psC64 exposed, psImageInterpolateMode mode);
     2463psImage *psImageRotate(psImage *out, const psImage *input, float angle,
     2464                       psC64 exposed, psImageInterpolateMode mode);
    24882465\end{verbatim}
    24892466Rotate the input image by given angle, specified in degrees.  The
    … …  
    25252502\begin{verbatim}
    25262503psStats *psImageStats(psStats *stats,
    2527                       const psImage *restrict in,
    2528                       const psImage *restrict mask,
     2504                      const psImage *in,
     2505                      const psImage *mask,
    25292506                      unsigned int maskVal);
    25302507\end{verbatim}
    … …  
    25382515\begin{verbatim}
    25392516psHistogram *psImageHistogram(psHistogram *out,
    2540                               const psImage *restrict in,
    2541                               const psImage *restrict mask,
     2517                              const psImage *in,
     2518                              const psImage *mask,
    25422519                              unsigned int maskVal);
    25432520\end{verbatim}
    … …  
    25662543
    25672544\begin{verbatim}
    2568 psF64 psImagePixelInterpolate (const psImage *input, float x, float y, psC64 unexposedValue, psImageInterpolateMode mode);
     2545psF64 psImagePixelInterpolate (const psImage *input, float x, float y,
     2546                               psC64 unexposedValue, psImageInterpolateMode mode);
    25692547\end{verbatim}
    25702548Perform interpolation of image pixel values to the given fractional
    … …  
    26492627
    26502628\begin{verbatim}
    2651 int psImageClipComplexRegion(psImage *input, complex double min, complex double vmin, complex double max, complex double vmax);
     2629int psImageClipComplexRegion(psImage *input, complex double min, complex double vmin,
     2630                             complex double max, complex double vmax);
    26522631\end{verbatim}
    26532632Clip image values outside of range to given values.  All pixels with
    … …  
    27912770
    27922771\begin{verbatim}
    2793 psImage *psMatrixInvert(psImage *out, const psImage *in, float *restrict determinant);
     2772psImage *psMatrixInvert(psImage *out, const psImage *in, float *determinant);
    27942773\end{verbatim}
    27952774\code{psMatrixInvert} returns the inverse of the specified matrix
    … …  
    28032782types \code{psF32, psF64}.
    28042783\begin{verbatim}
    2805 float psMatrixDeterminant(const psImage *restrict in);
     2784float psMatrixDeterminant(const psImage *in);
    28062785\end{verbatim}
    28072786
    … …  
    28332812should match.
    28342813\begin{verbatim}
    2835 psVector *psMatrixToVector(psVector *out, psImage *in);
    2836 psImage *psVectorToMatrix(psImage *out, psVector *in);
     2814psVector *psMatrixToVector(psVector *out, const psImage *in);
     2815psImage *psVectorToMatrix(psImage *out, const psVector *in);
    28372816\end{verbatim}
    28382817
    … …  
    30793058
    30803059\begin{verbatim}
    3081 psTime *psTimeGetTime(psTimeType);
     3060psTime *psTimeGetTime(psTimeType type);
    30823061\end{verbatim}
    30833062
    … …  
    30893068\end{verbatim}
    30903069This function may be used to convert between \code{PS_TIME_TAI} and
    3091 \code{PS_TIME_UTC} time representations. 
     3070\code{PS_TIME_UTC} time representations.  The \code{time} is modified
     3071and returned.
    30923072
    30933073To convert to or from Local Mean Sidereal Time, it is necessary to
    … …  
    30963076\begin{verbatim}
    30973077psTime *psTimeToLST(psTime *time, double longitude);
    3098 psTime *psLSTToTime(psTime *time, double longitude);
    3099 \end{verbatim}
    3100 %
    3101 The functions may accept either \code{psTimeType}.  Note that this
    3102 function must supply the value UT1-UTC, which is available externally
    3103 The value UT1-UTC is necessary for this an various other SLALIB
    3104 functions.  The following utility function encapsulates the PSLib
    3105 mechanism to extract the value of UT1-UTC:
    3106 \begin{verbatim}
    3107 double psGetUT1Delta(psTime *time);
    3108 psSphere *psGetPoleCoords(psTime *time);
     3078psTime *psTimeFromLST(psTime *time, double longitude);
     3079\end{verbatim}
     3080%
     3081The functions may accept either \code{psTimeType}.  The \code{time} is
     3082modified and returned.  Note that this function must supply the value
     3083UT1-UTC, which is available externally.  The value UT1-UTC is
     3084necessary for this an various other SLALIB functions.  The following
     3085utility function encapsulates the PSLib mechanism to extract the value
     3086of UT1-UTC:
     3087\begin{verbatim}
     3088double psTimeGetUT1Delta(const psTime *time);
     3089psSphere *psTimeGetPoleCoords(const psTime *time);
    31093090\end{verbatim}
    31103091
    … …  
    31153096
    31163097\begin{verbatim}
    3117 psF64 psTimeToJD(psTime *time);
    3118 psF64 psTimeToMJD(psTime *time);
    3119 char *psTimeToISOTime(psTime *time);
    3120 struct timeval *psTimeToTimeval(psTime *time);
     3098psF64 psTimeToJD(const psTime *time);
     3099psF64 psTimeToMJD(const psTime *time);
     3100char *psTimeToISOTime(const psTime *time);
     3101timeval *psTimeToTimeval(const psTime *time);
    31213102\end{verbatim}
    31223103
    … …  
    31273108
    31283109\begin{verbatim}
    3129 psTime *psJDToTime(psF64 input);
    3130 psTime *psMJDToTime(psF64 input);
    3131 psTime *psISOTimeToTime(char *input);
    3132 psTime *psTimevalToTime(struct timeval *input);
     3110psTime *psTimeFromJD(psF64 input);
     3111psTime *psTimeFromMJD(psF64 input);
     3112psTime *psTimeFromISO(const char *input);
     3113psTime *psTimeFromTimeval(const timeval *input);
    31333114\end{verbatim}
    31343115
    31353116\subsubsection{Date and Time Math}
    31363117
     3118\begin{verbatim}
     3119psTime *psTimeAdd(const psTime *tai1, psF64 delta);
     3120psF64 psTimeSubtract(const psTime *time1, const psTime *time2);
     3121psF64 psTimeDelta(const psTime *time1, const psTime *time2);
     3122\end{verbatim}
     3123\code{psTimeAdd} adds some time to a \code{psTime}.
     3124\code{psTimeSubtract} subtracts two times.  \code{psTimeDelta} gives
     3125the absolute time difference between two times.
     3126
    31373127Time math is only done on the \code{psTime} TAI type.
    3138 
    3139 \begin{verbatim}
    3140 psTime *psTAIAdd(psTime *tai1, psTime *tai2);
    3141 psTime *psTAISub(psTime *tai1, psTime *tai2);
    3142 psTime *psTAIDelta(psTime *tai1, psTime *tai2);
    3143 \end{verbatim}
    31443128
    31453129%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    … …  
    32603244typedef struct {
    32613245    const int id;                       ///< unique ID for this item
    3262     char *restrict name;                ///< Name of item
     3246    const char *name;                   ///< Name of item
    32633247    psMetadataType type;                ///< type of this item
    32643248    const union {
    … …  
    32693253    } data;                             ///< value of metadata
    32703254    char *comment;                      ///< optional comment ("", not NULL)
    3271     psList *restrict items;            ///< list of psMetadataItems with the same name
     3255    psList *items;                      ///< list of psMetadataItems with the same name
    32723256} psMetadataItem;
    32733257\end{verbatim}
    … …  
    33013285\begin{verbatim}
    33023286typedef struct {
    3303     psList *restrict list;             ///< list of psMetadataItem
    3304     psHash *restrict table;             ///< hash table of the same metadata
     3287    psList *list;                       ///< list of psMetadataItem
     3288    psHash *table;                      ///< hash table of the same metadata
    33053289} psMetadata;
    33063290\end{verbatim}
    … …  
    33563340\end{verbatim}
    33573341
    3358 The \code{psMetadataItem} destructor is specified below.  Note that
    3359 the destructor for \code{psMetadataItem} must call the appropriate
    3360 destructor for the \code{data.item} (recall that it is the duty of the
    3361 \code{psMyTypeFree}s to decrement the \code{refCounter} and free the
    3362 memory if and only if the \code{refCounter == 1} --- see
    3363 \S\ref{sec:free}).
    3364 \begin{verbatim}
    3365 void p_psMetadataItemFree(psMetadataItem *item);
    3366 \end{verbatim}
    3367 
    33683342The constructor for the collection of metadata, \code{psMetadata},
    33693343simply returns an empty metadata container (employing the constructors
    … …  
    33723346\begin{verbatim}
    33733347psMetadata *psMetadataAlloc(void);
    3374 void p_psMetadataFree(psMetadata *md);
    33753348\end{verbatim}
    33763349
    … …  
    33893362%
    33903363\begin{verbatim}
    3391 bool psMetadataAddItem(psMetadata *restrict md, int where,
    3392                        psMetadataItem *restrict item);
    3393 bool psMetadataAdd(psMetadata *restrict md, int where,
    3394                    const char *name, int format, const char *comment, ...);
     3364bool psMetadataAddItem(psMetadata *md, int where, psMetadataItem *item);
     3365bool psMetadataAdd(psMetadata *md, int where, const char *name, int format, const char *comment, ...);
    33953366\end{verbatim}
    33963367
    … …  
    34053376%
    34063377\begin{verbatim}
    3407 bool psMetadataRemove(psMetadata *restrict md, int where, const char *restrict key);
     3378bool psMetadataRemove(psMetadata *md, int where, const char *key);
    34083379\end{verbatim}
    34093380
    … …  
    34113382event that the key is non-unique, the first item is returned.
    34123383\begin{verbatim}
    3413 psMetadataItem *psMetadataLookup(const psMetadata *restrict md,
    3414                                  const char *restrict key);
     3384psMetadataItem *psMetadataLookup(const psMetadata *md, const char *key);
    34153385\end{verbatim}
    34163386
    … …  
    34193389\code{psList}.
    34203390\begin{verbatim}
    3421 psMetadataItem *psMetadataGet(const psMetadata *restrict md, int which);
     3391psMetadataItem *psMetadataGet(const psMetadata *md, int which);
    34223392\end{verbatim}
    34233393
    … …  
    34343404\begin{verbatim}
    34353405void psMetadataSetIterator(psMetadata *md, int where);
    3436 psMetadataItem *psMetadataGetNext(psMetadata *restrict md, const char *restrict match, int which);
    3437 psMetadataItem *psMetadataGetPrevious(psMetadata *restrict md, const char *restrict match, int which);
     3406psMetadataItem *psMetadataGetNext(psMetadata *md, const char *match, int which);
     3407psMetadataItem *psMetadataGetPrevious(psMetadata *md, const char *match, int which);
    34383408\end{verbatim}
    34393409
    … …  
    34473417data type, printing is not allowed.
    34483418\begin{verbatim}
    3449 void psMetadataItemPrint(FILE *fd, const char *format, const psMetadataItem *restrict md);
     3419void psMetadataItemPrint(FILE *fd, const char *format, const psMetadataItem *md);
    34503420\end{verbatim}
    34513421
    34523422\begin{verbatim}
    34533423psMetadata *psMetadataReadHeader(psMetadata *output, const char *extname,
    3454                               int extnum, const char *filename);
     3424                                 int extnum, const char *filename);
    34553425\end{verbatim}
    34563426Read header data from a FITS image file into a \code{psMetadata}
    … …  
    34623432\begin{verbatim}
    34633433psMetadata *psMetadataFReadHeader(psMetadata *output, const char *extname,
    3464                                int extnum, FILE *f);
     3434                                  int extnum, FILE *f);
    34653435\end{verbatim}
    34663436Read header data from a FITS image file descriptor into a
    … …  
    35873557%
    35883558\begin{verbatim}
    3589 psPlane *psPlaneTransformApply (psPlane *out,
    3590                                 const psPlaneTransform *transform,
    3591                                 const psPlane *coords);
    3592 psPlane *psPlaneDistortApply (psPlane *out,
    3593                               const psPlaneDistort *distort,
    3594                               const psPlane *coords,
    3595                               float term3, float term4);
     3559psPlane *psPlaneTransformApply(psPlane *out,
     3560                               const psPlaneTransform *transform,
     3561                               const psPlane *coords);
     3562psPlane *psPlaneDistortApply(psPlane *out,
     3563                             const psPlaneDistort *distort,
     3564                             const psPlane *coords,
     3565                             float mag, float color);
    35963566\end{verbatim}
    35973567
    … …  
    36243594\end{verbatim}
    36253595
    3626 The constructor and destructor are defined as follows:
     3596The constructor is defined as follows:
    36273597\begin{verbatim}
    36283598psSphereTransform *psSphereTransformAlloc(double NPlon, double NPlat, double ZP);
    3629 void p_psSphereTransformFree(psSphereTransform *trans);
    36303599\end{verbatim}
    36313600where \code{NPlon} and \code{NPlat} define the coordinates in the
    … …  
    36663635\item AIT
    36673636\item PAR
    3668 \item GLS
    36693637\end{itemize}
    36703638
    … …  
    37123680
    37133681\begin{verbatim}
    3714 psSphere *psSphereGetOffset(const psSphere *restrict position1,
    3715                             const psSphere *restrict position2,
     3682psSphere *psSphereGetOffset(const psSphere *position1,
     3683                            const psSphere *position2,
    37163684                            psSphereOffsetMode mode,
    37173685                            psSphereOffsetUnit unit);
    37183686
    3719 psSphere *psSphereSetOffset(const psSphere *restrict position,
    3720                             const psSphere *restrict offset,
     3687psSphere *psSphereSetOffset(const psSphere *position,
     3688                            const psSphere *offset,
    37213689                            psSphereOffsetMode mode,
    37223690                            psSphereOffsetUnit unit);
    37233691
    37243692typedef enum {
    3725  PS_SPHERICAL;
    3726  PS_LINEAR;
     3693    PS_SPHERICAL;                       ///< Offset on a sphere
     3694    PS_LINEAR;                          ///< Linear offset
    37273695} psSphereOffsetMode;
    37283696
    37293697typedef enum {
    3730  PS_ARCSEC;
    3731  PS_ARCMIN;
    3732  PS_DEGREE;
    3733  PS_RADIAN;
     3698    PS_ARCSEC;                          ///< Arcseconds
     3699    PS_ARCMIN;                          ///< Arcminutes
     3700    PS_DEGREE;                          ///< Degrees
     3701    PS_RADIAN;                          ///< Radians
    37343702} psSphereOffsetUnit;
    37353703\end{verbatim}
    … …  
    38143782\subsubsection{Positions of Major SS Objects}
    38153783
    3816 We require the ability to calculate the position of major Solar System
    3817 objects, as well as Lunar phase.  These functions all take the
    3818 specified modified julian date, \code{mjd}, and the latitude/longitude
    3819 of the observer.
    3820 
    3821 \begin{verbatim}
    3822 psSphere *psSunGetPos(psTime time);
    3823 psTime *psSunGetRise (psTime *twi15, psTime *twi18, psTime time);
    3824 psTime *psSunGetSet (psTime *twi15, psTime *twi18, psTime time);
     3784\tbd{We require the ability to calculate the position of major Solar System
     3785objects, as well as Lunar phase.}
     3786
     3787\begin{verbatim}
     3788psSphere *psSunGetPos(psTime *time);
     3789psTime *psSunGetRise (psTime *twi15, psTime *twi18, const psTime *time);
     3790psTime *psSunGetSet (psTime *twi15, psTime *twi18, const psTime *time);
    38253791
    38263792psSphere *psMoonGetPos(psTime time, psSphere location);
    3827 psTime *psMoonGetRise (psTime *twi15, psTime *twi18, psTime time);
    3828 psTime *psMoonGetSet (psTime *twi15, psTime *twi18, psTime time);
     3793psTime *psMoonGetRise (psTime *twi15, psTime *twi18, psTime *time);
     3794psTime *psMoonGetSet (psTime *twi15, psTime *twi18, psTime *time);
    38293795float psGetMoonPhase(psTime time);
    38303796
    38313797psSphere *psPlanetGetPos(psTime time, psSphere location);
    3832 psTime *psPlanetGetRise (psTime *twi15, psTime *twi18, psTime time);
    3833 psTime *psPlanetGetSet (psTime *twi15, psTime *twi18, psTime time);
    3834 
     3798psTime *psPlanetGetRise (psTime *twi15, psTime *twi18, psTime *time);
     3799psTime *psPlanetGetSet (psTime *twi15, psTime *twi18, psTime *time);
    38353800\end{verbatim}
    38363801
Note: See TracChangeset for help on using the changeset viewer.