IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 257


Ignore:
Timestamp:
Mar 18, 2004, 9:37:58 PM (22 years ago)
Author:
eugene
Message:

code cleanup for Doxygen support & readability

Location:
trunk/archive/pslib/include
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/archive/pslib/include/Doxyfile

    r223 r257  
    564564# Windows users are probably better off using the HTML help feature.
    565565
    566 GENERATE_TREEVIEW      = NO
     566GENERATE_TREEVIEW      = YES
    567567
    568568# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be

  • trunk/archive/pslib/include/psAstrom.h

    r254 r257  
    127127   
    128128
    129 /*** Functions ***********************************************************************/
    130 
    131 /***********************************************************************************************************/
    132 
    133 /* Calculating and applying astrometric solutions */
     129/** Functions **************************************************************/
     130/** \addtogroup AstroGroup Astronomy-Specific Utilities
     131 *  \{
     132 */
     133
     134/*** Calculating and applying astrometric solutions ***/
    134135
    135136/** returns Chip in FPA which contains the given FPA coordinate */
    … …  
    236237psExposureFree(psExposure *restrict myExp //!< Object to destroy
    237238               );
     239/* \} */ // End of AstroGroup Functions
     240
    238241#endif
    239242

  • trunk/archive/pslib/include/psBitMask.h

    r247 r257  
    1212    char *bits;                         //!< The bits
    1313} psBitMask;
     14
     15/** Functions **************************************************************/
     16/** \addtogroup MathGroup Math Utilities
     17 *  \{
     18 */
    1419
    1520/** Constructor */
    … …  
    4449    );
    4550
     51/* \} */ // End of MathGroup Functions
     52
    4653#endif

  • trunk/archive/pslib/include/psDateTime.h

    r256 r257  
    1111 */
    1212
    13 /** Get current MJD, for a timestamp */
     13/** \addtogroup AstroGroup Astronomy-Specific Utilities
     14 *  \{
     15 */
     16
     17/** Get current MJD, for a timestamp \ingroup AstroGroup */
    1418double
    1519psGetMJD(void);
    1620
    17 /** Get current sidereal time at longitude */
     21/** Get current sidereal time at longitude \ingroup AstroGroup */
    1822double
    1923psGetSidereal(float mjd,                //!< MJD
    … …  
    5357
    5458/***** convert to psTime *****/
    55 /** Convert ISOTime (Human-readable date/time string YYYY/MM/DD,HH:MM:SS.SSS) to psTime */
     59/** Convert ISOTime (Human-readable date/time string YYYY/MM/DD,HH:MM:SS.SSS) to psTime \ingroup AstroGroup */
    5660psTime *
    5761psISOTimeToTime (char *input)           //!< Input ISOTime time
    … …  
    8387;
    8488
     89/* \} end of AstroGroup */
     90
    8591#endif
    8692

  • trunk/archive/pslib/include/psDlist.h

    r247 r257  
    3131};
    3232
    33 /*****************************************************************************/
     33/** Functions **************************************************************/
     34/** \addtogroup DataGroup General Data Container Utilities 
     35 *  \{
     36 */
     37
    3438/** Constructor */
    35 psDlist *psDlistAlloc(void *data        //!< initial data item; may be NULL
    36     );
     39psDlist *psDlistAlloc(void *data)       //!< initial data item; may be NULL
     40;
    3741
    3842/** Destructor */
    3943void psDlistFree(psDlist *list,         //!< list to destroy
    40                 void (*elemFree)(void *) //!< destructor for data on list
    41     );
     44                void (*elemFree)(void *)) //!< destructor for data on list
     45;
    4246
    43 /*
    44  * List maintainence functions
    45  */
     47/**** List maintainence functions ****/
    4648
    4749/** Add to list */
    4850psDlist *psDlistAdd(psDlist *list,      //!< list to add to (may be NULL)
    4951                    void *data,         //!< data item to add
    50                     int where           //!< index, PS_DLIST_HEAD, or PS_DLIST_TAIL
    51     );
     52                    int where)          //!< index, PS_DLIST_HEAD, or PS_DLIST_TAIL
     53;
    5254
    5355/** Append to a list */
    5456psDlist *psDlistAppend(psDlist *list,   //!< list to append to (may be NULL)
    55                        void *data       //!< data item to add
    56     );
     57                       void *data)      //!< data item to add
     58;
    5759
    5860/** Remove from a list */
    5961void *psDlistRemove(psDlist *list,      //!< list to remove element from
    6062                    void *data,         //!< data item to remove
    61                     int which           //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
    62                                         //!< PS_DLIST_PREV
    63     );
     63                    int which)          //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
     64;                                       //!< PS_DLIST_PREV
    6465
    6566/** Retrieve from a list */
    6667void *psDlistGet(const psDlist *list,   //!< list to retrieve element from
    67                  int which              //!< index of item, or PS_DLIST_NEXT, or PS_DLIST_PREV
    68     );
     68                 int which)             //!< index of item, or PS_DLIST_NEXT, or PS_DLIST_PREV
     69;
    6970
    70 /*
    71  * convenience functions to use psDlistGet as an iterator
    72  */
     71/**** convenience functions to use psDlistGet as an iterator ******/
    7372
    7473/** Set the iterator */
    7574void psDlistSetIterator(psDlist *list,  //!< list to retrieve element from
    7675                        int where,      //!< index, PS_DLIST_HEAD, or PS_DLIST_TAIL
    77                         int which       //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
    78                                         //!< PS_DLIST_PREV
    79     );
     76                        int which)      //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
     77;                                       //!< PS_DLIST_PREV
    8078
    8179/** Get next element */
    8280void *psDlistGetNext(psDlist *list,     //!< list to retrieve element from
    83                      int which          //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
    84                                         //!< PS_DLIST_PREV
    85     );
     81                     int which)         //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
     82;                                       //!< PS_DLIST_PREV
    8683
    8784/** Get previous element */
    8885void *psDlistGetPrev(psDlist *list,     //!< list to retrieve element from
    89                      int which          //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
    90                                         //!< PS_DLIST_PREV
    91     );
    92 
     86                     int which)         //!< index of item, or PS_DLIST_UNKNOWN, or PS_DLIST_NEXT, or
     87;                                       //!< PS_DLIST_PREV
    9388
    9489/** Convert doubly-linked list to an array */
    95 psVoidPtrArray *psDlistToArray(psDlist *dlist //!< List to convert
    96     );
     90psVoidPtrArray *psDlistToArray(psDlist *dlist) //!< List to convert
     91;
    9792
    9893/** Convert array to a doubly-linked list */
    99 psDlist *psArrayToDlist(psVoidPtrArray *arr //!< Array to convert
    100     );
     94psDlist *psArrayToDlist(psVoidPtrArray *arr) //!< Array to convert
     95;
    10196
     97/* \} */ // End of DataGroup Functions
    10298
    10399#endif

  • trunk/archive/pslib/include/psFFT.h

    r247 r257  
    55 *  \brief Fourier Transform functions
    66 *  \ingroup MathGroup
     7 */
     8
     9/** Functions **************************************************************/
     10/** \addtogroup MathGroup Math Utilities
     11 *  \{
    712 */
    813
    … …  
    2631            );
    2732
     33/* \} */ // End of MathGroup Functions
    2834
    2935#endif

  • trunk/archive/pslib/include/psFunctions.h

    r247 r257  
    5050
    5151
     52/** Functions **************************************************************/
     53/** \addtogroup MathGroup Math Utilities
     54 *  \{
     55 */
     56
    5257/** Constructors */
    5358psPolynomial1D *psPolynomial1DAlloc(int n //!< Number of terms
    … …  
    101106                   );
    102107
     108/* \} */ // End of MathGroup Functions
     109
    103110/************************************************************************************************************/
    104111
    … …  
    137144} psDPolynomial4D;
    138145
     146/** Functions **************************************************************/
     147/** \addtogroup MathGroup Math Utilities
     148 *  \{
     149 */
     150
    139151/** Constructors */
    140152psDPolynomial1D *psDPolynomial1DAlloc(int n //!< Number of terms
    … …  
    189201                    );
    190202
     203/* \} */ // End of MathGroup Functions
    191204
    192205#endif

  • trunk/archive/pslib/include/psHash.h

    r247 r257  
    88
    99/** DO WE NEED TO DEFINE HashTable? */
    10 typedef struct HashTable psHash;        //!< Opaque type for a hash table
     10typedef struct HashTable psHash;        ///< Opaque type for a hash table
    1111
    12 psHash *psHashAlloc(int nbucket         //!< initial number of buckets
    13     );
    14 void psHashFree(psHash *table,          //!< hash table to be freed
    15                 void (*itemFree)(void *item) //!< how to free hashed data; or NULL
    16     );
     12/** Functions **************************************************************/
     13/** \addtogroup DataGroup General Data Container Utilities 
     14 *  \{
     15 */
    1716
    18 void *psHashInsert(psHash *table,       //!< table to insert in
    19                    const char *key,     //!< key to use
    20                    void *data,          //!< data to insert
    21                    void (*itemFree)(void *item) //!< how to free hashed data; or NULL
    22     );
    23 void *psHashLookup(psHash *table,       //!< table to lookup key in
    24                    const char *key      //!< key to lookup
    25     );
     17/// Allocate hash buckets in table.
     18psHash *psHashAlloc(int nbucket)        ///< initial number of buckets
     19;
    2620
    27 void *psHashRemove(psHash *table,       //!< table to lookup key in
    28                    const char *key      //!< key to lookup
    29     );
     21/// Free hash buckets from table.
     22void psHashFree(psHash *table,          ///< hash table to be freed
     23                void (*itemFree)(void *item)) ///< how to free hashed data; or NULL
     24;
    3025
     26/// Insert entry into table.
     27void *psHashInsert(psHash *table,       ///< table to insert in
     28                   const char *key,     ///< key to use
     29                   void *data,          ///< data to insert
     30                   void (*itemFree)(void *item)) ///< how to free hashed data; or NULL
     31;
     32
     33/// Lookup key in table.
     34void *psHashLookup(psHash *table,       ///< table to lookup key in
     35                   const char *key)     ///< key to lookup
     36;
     37
     38/// Remove key from table.
     39void *psHashRemove(psHash *table,       ///< table to lookup key in
     40                   const char *key)     ///< key to lookup
     41;
     42
     43/* \} */ // End of DataGroup Functions
    3144
    3245#endif

  • trunk/archive/pslib/include/psImage.h

    r253 r257  
    55 *  \brief Basic image definitions and operations.
    66 *  \ingroup AstroGroup
    7  */
    8 
    9 /** General image manipulation functions.
    10  *  These functions operate on individual 2D images
    117 */
    128
    … …  
    3228} psImage;
    3329
     30/** Functions **************************************************************/
     31/** \addtogroup AstroGroup Astronomy-Specific Utilities
     32 *  \{
     33 */
     34
    3435/*** Image structure manipulation ***/
     36
    3537/// Create an image of the specified size and type.
    36 typedef int PS_IMAGE_DEPTH;             // RHL Added this to make the psImage compile XXX
    37 
    3838psImage *
    3939psImageAlloc (int nx,                   ///< image width
    4040              int ny,                   ///< image height
    41               PS_IMAGE_DEPTH depth      ///< image depth
    42     );
     41              psType type)              ///< image data type
     42;
    4343
    4444/// Create a subimage of the specified area.
    … …  
    6868
    6969/*** various image pixel extractions ***/
    70 
    71 typedef enum { PS_STAT_MODE_MEDIAN } psStatMode;
    7270
    7371/// Extract pixels from rectlinear region to a vector.
    … …  
    271269);
    272270
     271/* \} */ // End of AstroGroup Functions
     272
    273273# endif
    274274/* image overlay operations

  • trunk/archive/pslib/include/psLogMsg.h

    r247 r257  
    77 */
    88
     9/** Functions **************************************************************/
     10/** \addtogroup SystemGroup System Utilities
     11 *  \{
     12 */
     13
     14/// Sets the log destination
     15int psSetLogDestination(int dest);     
     16
     17/// Sets the log level
     18int psSetLogLevel(int level);           
     19
     20/// sets the log format
     21void psSetLogFormat(const char *fmt);   
     22
     23/// Logs a message
     24void psLogMsg(const char *name, int level, const char *fmt, ...);
     25
     26/// Logs a message from varargs
     27void p_psVLogMsg(const char *name, int level, const char *fmt, va_list ap);
     28
     29/* \} */ // End of SystemGroup Functions
     30
    931enum { PS_LOG_ABORT = 0, PS_LOG_ERROR, PS_LOG_WARN, PS_LOG_INFO }; //!< Status codes for log messages
    1032
    1133enum { PS_LOG_TO_STDERR, PS_LOG_TO_STDOUT }; //!< Destinations for log messages
    1234
    13 int psSetLogDestination(int dest);      //!< Sets the log destination
    14 int psSetLogLevel(int level);           //!< Sets the log level
    15 void psSetLogFormat(const char *fmt);   //!< sets the log format
    16 
    17 void psLogMsg(const char *name, int level, const char *fmt, ...); //!< Logs a message
    18 void p_psVLogMsg(const char *name, int level, const char *fmt, va_list ap); //!< Logs a message from varargs
    19 
    2035#endif

  • trunk/archive/pslib/include/psMath.h

    r253 r257  
    1717    } val;
    1818} p_psScalar;
     19
     20/** Functions **************************************************************/
     21/** \addtogroup MathGroup Math Utilities
     22 *  \{
     23 */
    1924
    2025/** Perform a binary operation on two data items (psImage, psVector, psScalar). */
    … …  
    4247              ...                       ///< value (or values) of specified types
    4348);
     49
     50/* \} */ // End of MathGroup Functions
    4451
    4552/** the functions defined here can operate on the basic PSLib data types: psImage, psVector, XXX.  These data

  • trunk/archive/pslib/include/psMatrix.h

    r250 r257  
    1212    float *restrict *restrict value;    //!< Values in matrix
    1313} psMatrix;
     14
     15/** Functions **************************************************************/
     16/** \addtogroup MathGroup Math Utilities
     17 *  \{
     18 */
    1419
    1520/** Constructor */
    … …  
    5964    );
    6065
     66/* \} */ // End of MathGroup Functions
     67
    6168#endif

  • trunk/archive/pslib/include/psMemory.h

    r247 r257  
    66 *  \ingroup SystemGroup
    77 */
     8
     9// Structures ***********************************************************
    810
    911/** Book-keeping data for storage allocator.
    … …  
    2123} psMemBlock;
    2224
    23 /** prototype of a basic callback used by memory functions */
     25/// prototype of a basic callback used by memory functions
    2426typedef int (*psMemCallback)(const psMemBlock *ptr);
    2527
    26 /** prototype of a callback used in error conditions */
     28/// prototype of a callback used in error conditions
    2729typedef void (*psMemProblemCallback)(const psMemBlock *ptr, const char *file, int lineno);
    2830
    29 /** prototype of a callback used when memory runs out */
     31/// prototype of a callback used when memory runs out
    3032typedef void *(*psMemExhaustedCallback)(size_t size);
    3133
    32 /*****************************************************************************/
     34/** Functions **************************************************************/
     35/** \addtogroup SystemGroup System Utilities
     36 *  \{
     37 */
    3338
    34 /** Memory allocation. Underlying private function called by macro psAlloc. */
     39/// Memory allocation. Underlying private function called by macro psAlloc.
    3540void *p_psAlloc(size_t size,            //!< Size required
    3641                const char *file,       //!< File of call
    37                 int lineno              //!< Line number of call
    38     );
     42                int lineno)             //!< Line number of call
     43;
    3944
    40 /** Memory re-allocation.  Underlying private function called by macro psRealloc. */
     45/// Memory re-allocation.  Underlying private function called by macro psRealloc.
    4146void *p_psRealloc(void *ptr,            //!< Pointer to re-allocate
    4247                  size_t size,          //!< Size required
    4348                  const char *file,     //!< File of call
    44                   int lineno            //!< Line number of call
    45     );
     49                  int lineno)           //!< Line number of call
     50;
    4651
    47 /** Free memory.  Underlying private function called by macro psFree. */
     52/// Free memory.  Underlying private function called by macro psFree.
    4853void p_psFree(void *ptr,                //!< Pointer to free
    4954              const char *file,         //!< File of call
    50               int lineno                //!< Line number of call
    51     );
     55              int lineno)               //!< Line number of call
     56;
    5257
    53 /** Memory allocation. psAlloc sends file and line number to p_psAlloc. */
     58/// Check for memory leaks
     59int psMemCheckLeaks(int id0,            //!< don't list blocks with id < id0
     60                    psMemBlock ***arr,  //!< pointer to array of pointers to leaked blocks, or NULL
     61                    FILE *fd)           //!< print list of leaks to fd (or NULL)
     62;
     63
     64/// Check for memory corruption
     65int psMemCheckCorruption(int abort_on_error) //!< Abort on detecting corruption?
     66;
     67
     68/// Return reference counter
     69int psMemGetRefCounter(void *vptr)      //!< Pointer to get refCounter for
     70;
     71
     72/// Increment reference counter and return the pointer
     73void *psMemIncrRefCounter(void *vptr)   //!< Pointer to increment refCounter, and return
     74;
     75
     76/// Decrement reference counter and return the pointer
     77void *psMemDecrRefCounter(void *vptr)   //!< Pointer to decrement refCounter, and return
     78;
     79
     80/// Set callback for problems
     81psMemProblemCallback psMemProblemSetCB(psMemProblemCallback func) //!< Function to run
     82;
     83
     84/// Set callback for out-of-memory
     85psMemExhaustedCallback psMemExhaustedSetCB(psMemExhaustedCallback func) //!< Function to run
     86;                                                                       
     87
     88/// Set call back for when a particular memory block is allocated
     89psMemCallback psMemAllocateSetCB(psMemCallback func)
     90;
     91
     92/// Set call back for when a particular memory block is freed
     93psMemCallback psMemFreeSetCB(psMemCallback func)
     94;
     95
     96/// get next memory ID
     97int psMemGetId(void)
     98;
     99
     100/// set p_psMemAllocateID to id
     101long psMemSetAllocateID(long id)
     102;
     103
     104/// set p_psMemFreeID to id
     105long psMemSetFreeID(long id)
     106;
     107
     108/* \} */ // End of SystemGroup Functions
     109
     110/// Memory allocation. psAlloc sends file and line number to p_psAlloc.
    54111#define psAlloc(size) p_psAlloc(size, __FILE__, __LINE__)
    55112
    56 /** Memory re-allocation.  psRealloc sends file and line number to p_psRealloc. */
     113/// Memory re-allocation.  psRealloc sends file and line number to p_psRealloc.
    57114#define psRealloc(ptr, size) p_psRealloc(ptr, size, __FILE__, __LINE__)
    58115
    59 /** Free memory.  psFree sends file and line number to p_psFree. */
     116/// Free memory.  psFree sends file and line number to p_psFree.
    60117#define psFree(size) p_psFree(size, __FILE__, __LINE__)
    61118
    62 /** prevent the use of 'malloc'. malloc is re-defined to throw an error in the C preprocessor */
     119/// prevent the use of 'malloc'. malloc is re-defined to throw an error in the C preprocessor
    63120#define malloc(S) for
    64121
    65 /** prevent the use of 'realloc'. realloc is re-defined to throw an error in the C preprocessor */
     122/// prevent the use of 'realloc'. realloc is re-defined to throw an error in the C preprocessor
    66123#define realloc(P,S) for
    67124
    68 /** prevent the use of 'free'. free is re-defined to throw an error in the C preprocessor */
     125/// prevent the use of 'free'. free is re-defined to throw an error in the C preprocessor
    69126#define free(P) for
    70127
    71 /*****************************************************************************/
    72 /** Check for memory leaks */
    73 int psMemCheckLeaks(int id0,            //!< don't list blocks with id < id0
    74                     psMemBlock ***arr,  //!< pointer to array of pointers to leaked blocks, or NULL
    75                     FILE *fd            //!< print list of leaks to fd (or NULL)
    76     );
    77 
    78 /** Check for memory corruption */
    79 int psMemCheckCorruption(int abort_on_error //!< Abort on detecting corruption?
    80     );
    81 
    82 /*****************************************************************************/
    83 
    84 /** Return reference counter */
    85 int psMemGetRefCounter(void *vptr       //!< Pointer to get refCounter for
    86     );
    87 /** Increment reference counter and return the pointer */
    88 void *psMemIncrRefCounter(void *vptr    //!< Pointer to increment refCounter, and return
    89     );
    90 /** Decrement reference counter and return the pointer */
    91 void *psMemDecrRefCounter(void *vptr    //!< Pointer to decrement refCounter, and return
    92     );
    93 
    94 /*****************************************************************************/
    95 /*
    96  * Functions to set and control callbacks
    97  */
    98 
    99 /** Set callback for problems */
    100 psMemProblemCallback psMemProblemSetCB(psMemProblemCallback func //!< Function to run
    101     );
    102 psMemExhaustedCallback psMemExhaustedSetCB(psMemExhaustedCallback func); //!< set call back for exhausted
    103                                                                          //!< memory
    104 
    105 psMemCallback psMemAllocateSetCB(psMemCallback func); //!< Set call back for when a particular memory block is
    106                                                       //!< allocated
    107 psMemCallback psMemFreeSetCB(psMemCallback func); //!< set call back for when a particular memory block is
    108                                                   //!< freed
    109 
    110 int psMemGetId(void);                   //!< get next memory ID
    111 long psMemSetAllocateID(long id);       //!< set p_psMemAllocateID to id
    112 long psMemSetFreeID(long id);           //!< set p_psMemFreeID to id
    113 
    114128#endif

  • trunk/archive/pslib/include/psMetaData.h

    r247 r257  
    4949} psMetaDataSet;
    5050
     51/** Functions **************************************************************/
     52/** \addtogroup AstroGroup Astronomy-Specific Utilities
     53 *  \{
     54 */
     55
    5156/** Constructor */
    5257psMetaDataItem *psMetaDataItemAlloc(
    … …  
    8085                         const psMetaDataItem *restrict ms, // item of metadata to print
    8186                         const char *prefix);      // print this at the beginning of each line
     87/* \} */ // End of AstroGroup Functions
    8288#endif

  • trunk/archive/pslib/include/psMinimize.h

    r247 r257  
    55 *  \brief minimization operations
    66 *  \ingroup MathGroup
     7 */
     8
     9/** Functions **************************************************************/
     10/** \addtogroup MathGroup Math Utilities
     11 *  \{
    712 */
    813
    … …  
    3237    );
    3338
     39/* \} */ // End of MathGroup Functions
     40
    3441#endif

  • trunk/archive/pslib/include/psMisc.h

    r247 r257  
    77 */
    88
    9 #define PS_STRING(S) #S                 //!< converts argument to string
     9/** Functions **************************************************************/
     10/** \addtogroup SystemGroup System Utilities
     11 *  \{
     12 */
    1013
    11 /** Prints an error message and aborts */
    12 void psAbort(const char *name,          //!< Category of code that caused the abort
    13              const char *fmt,           //!< Format
    14              ...                        //!< Extra arguments to use format
    15     );
    16 /** Prints an error message and doesn't abort */
    17 void psError(const char *name,          //!< Category of code that caused the abort
    18              const char *fmt,           //!< Format
    19              ...                        //!< Extra arguments to use format
    20     );
     14/// Prints an error message and aborts
     15void psAbort(const char *name,          ///< Category of code that caused the abort
     16             const char *fmt,           ///< Format
     17             ...)                       ///< Extra arguments to use format
     18;
    2119
    22 /** Allocates and returns a copy of a string */
    23 char *psStringCopy(const char *str      //!< string to copy
    24     );
     20/// Prints an error message and doesn't abort
     21void psError(const char *name,          ///< Category of code that caused the abort
     22             const char *fmt,           ///< Format
     23             ...)                       ///< Extra arguments to use format
     24;
    2525
    26 /** Magic values for errors */
     26/// Allocates and returns a copy of a string
     27char *psStringCopy(const char *str)     ///< string to copy
     28;
     29
     30/* \} */ // End of SystemGroup Functions
     31
     32#define PS_STRING(S) #S                 ///< converts argument to string
     33
     34/// Magic values for errors
    2735enum {
    28     PS_NO_VALUE = -111,                 //!< Corresponding value not yet measured
    29     PS_NO_ERROR = -222                  //!< Corresponding value has no error
     36    PS_NO_VALUE = -111,                 ///< Corresponding value not yet measured
     37    PS_NO_ERROR = -222                  ///< Corresponding value has no error
    3038};
    3139

  • trunk/archive/pslib/include/psPosition.h

    r253 r257  
    66 *  \ingroup AstroGroup
    77 */
     8
     9/** Structures *********************/
    810
    911/** A point in 2-D space, with errors.
    … …  
    2931
    3032/** A polynomial transformation between coordinate frames.  This may be a linear relationship, or may
    31  * represent a higher-order transformation.
     33 *  represent a higher-order transformation.
    3234 */
    3335typedef struct {
    … …  
    3739
    3840/** The optical distortion terms.  The lowest two terms are the x and y axis of the target system.  The higher
    39  * two terms represent magnitude and color terms.
     41 *  two terms represent magnitude and color terms.
    4042 */
    4143typedef struct {
    … …  
    4446} psDistortion;
    4547
    46 psCoord *psCoordXformApply (psCoordXform *frame, psCoord *coords);
     48/** Functions **************************************************************/
     49/** \addtogroup AstroGroup Astronomy-Specific Utilities
     50 *  \{
     51 */
    4752
    48 psCoord *psDistortionApply (psCoordXform *frame, psCoord *coords);
     53/** apply the coordinate transformation to the given coordinate */
     54psCoord *psCoordXformApply (psCoordXform *frame, ///< coordinate transformation
     55                            psCoord *coords) ///< input coordiate
     56;
    4957
    50 /***********************************************************************************************************/
    51 
    52 /* Offsets */
     58/** apply the optical distortion to the given coordinate, magnitude, color */
     59psCoord *psDistortionApply (psDistortion *pattern, ///< optical distortion pattern
     60psCoord *coords,                        ///< input coordinate
     61float mag,                              ///< magnitude of object
     62float color)                            ///< color of object
     63;
    5364
    5465/** Get offset (RA,Dec) on the sky between two positions position1 and position2 may not be identical */
    … …  
    5667psGetOffset(const psCoord *restrict position1, //!< Position 1
    5768            const psCoord *restrict position2, //!< Position 2
    58             char *system
    59             );
     69            char *system)
     70;
    6071
    6172/** Apply an offset to a position */
    … …  
    6374psApplyOffset(const psCoord *restrict position, //!< Position
    6475              const psCoord *restrict offset, //!< Offset
    65               char *system
    66     );
    67 
    68 /***********************************************************************************************************/
     76              char *system)
     77;
    6978
    7079/* Positions of well-known objects */
    … …  
    7281/** Get Sun Position */
    7382psCoord *
    74 psGetSunPos(float mjd                   //!< MJD to get position for
    75             );
     83psGetSunPos(float mjd)                  //!< MJD to get position for
     84;
    7685
    7786/** Get Moon position */
    … …  
    7988psGetMoonPos(float mjd,                 //!< MJD to get position for
    8089             double latitude,           //!< Latitude for apparent position
    81              double longitude           //!< Longitude for apparent position
    82              );
     90             double longitude)          //!< Longitude for apparent position
     91;
    8392
    8493/** Get Moon phase */
    8594float
    86 psGetMoonPhase(float mjd                //!< MJD to get phase for
    87                );
     95psGetMoonPhase(float mjd)               //!< MJD to get phase for
     96;
    8897
    8998/** Get Planet positions */
    9099psCoord *
    91100psGetSolarSystemPos(char *solarSystemObject, //!< Named S.S. object
    92                     float mjd           //!< MJD to get position for
    93     );
     101                    float mjd)          //!< MJD to get position for
     102;
    94103
    95104/***********************************************************************************************************/
    … …  
    99108/** Convert ICRS to Ecliptic */
    100109psCoord *
    101 psCoordinatesItoE(const psCoord *restrict coordinates //!< ICRS coordinates to convert
    102                   );
     110psCoordinatesItoE(const psCoord *restrict coordinates) //!< ICRS coordinates to convert
     111;
    103112
    104113/** Convert Ecliptic to ICRS */
    105114psCoord *
    106 psCoordinatesEtoI(const psCoord *restrict coordinates //!< Ecliptic coordinates to convert
    107                   );
     115psCoordinatesEtoI(const psCoord *restrict coordinates) //!< Ecliptic coordinates to convert
     116;
    108117
    109118/** Convert ICRS to Galactic */
    110119psCoord *
    111 psCoordinatesItoG(const psCoord *restrict coordinates //!< ICRS coordinates to convert
    112                   );
     120psCoordinatesItoG(const psCoord *restrict coordinates) //!< ICRS coordinates to convert
     121;
    113122
    114123/** Convert Galactic to ICRS */
    115124psCoord *
    116 psCoordinatesGtoI(const psCoord *restrict coordinates //!< Galactic coordinates to convert
    117                   );
     125psCoordinatesGtoI(const psCoord *restrict coordinates) //!< Galactic coordinates to convert
     126;
    118127
    119128/***********************************************************************************************************/
     129
     130/* \} */ // End of AstroGroup Functions
     131
    120132#endif

  • trunk/archive/pslib/include/psSort.h

    r253 r257  
    55 *  \brief general sorting operations
    66 *  \ingroup MathGroup
     7 */
     8
     9/** Functions **************************************************************/
     10/** \addtogroup MathGroup Math Utilities
     11 *  \{
    712 */
    813
    … …  
    1924    );
    2025
     26/* \} */ // End of MathGroup Functions
     27
    2128#endif

  • trunk/archive/pslib/include/psStats.h

    r249 r257  
    7070
    7171
    72 /** Do Statistics on an array.  Returns a status value. */
     72/** Do Statistics on an array.  Returns a status value. \ingroup MathGroup */
    7373psStats *
    7474psArrayStats(const psFloatArray *restrict myArray, //!< Array to be analysed
    … …  
    8181/***********************************************************************************************************/
    8282
    83 /** Histograms */
     83/** Histograms  */
    8484typedef struct {
    8585    const psFloatArray *restrict lower; //!< Lower bounds for the bins
    … …  
    9090} psHistogram;
    9191
    92 /** Constructor */
     92/** Constructor \ingroup MathGroup */
    9393psHistogram *
    9494psHistogramAlloc(float lower,           //!< Lower limit for the bins
    … …  
    9797    );
    9898
    99 /** Generic constructor */
     99/** Generic constructor \ingroup MathGroup */
    100100psHistogram *
    101101psHistogramAllocGeneric(const psFloatArray *restrict lower, //!< Lower bounds for the bins
    … …  
    105105    );
    106106
    107 /** Destructor */
     107/** Destructor \ingroup MathGroup **/
    108108void
    109109psHistogramFree(psHistogram *restrict myHist //!< Histogram to destroy
    … …  
    111111
    112112
    113 /** Calculate a histogram */
     113/** Calculate a histogram \ingroup MathGroup **/
    114114psHistogram *
    115115psGetArrayHistogram(psHistogram *restrict myHist, //!< Histogram data

  • trunk/archive/pslib/include/psStdArrays.h

    r247 r257  
    7979} psFloatArray;
    8080
    81 /** Constructor */
     81/** Constructor \ingroup DataGroup */
    8282psFloatArray *psFloatArrayAlloc(int s,  ///< Total number of elements to make available
    8383                                int n   ///< Number of elements that will be used
    8484    );
    85 /** Reallocator */
     85/** Reallocator \ingroup DataGroup */
    8686psFloatArray *psFloatArrayRealloc(psFloatArray *myArray, ///< Array to reallocate
    8787                                  int s ///< Total number of elements to make available
    8888    );
    89 /** Destructor */
     89/** Destructor \ingroup DataGroup */
    9090void psFloatArrayFree(psFloatArray *restrict myArray ///< Array to free
    9191    );
    … …  
    109109} psComplexArray;
    110110
    111 /** Constructor */
     111/** Constructor \ingroup DataGroup */
    112112psComplexArray *psComplexArrayAlloc(int s, ///< Total number of elements to make available
    113113                                    int n       ///< Number of elements that will be used
    114114    );
    115 /** Reallocator */
     115/** Reallocator \ingroup DataGroup */
    116116psComplexArray *psComplexArrayRealloc(psComplexArray *myArray, ///< Array to reallocate
    117117                                      int s     ///< Total number of elements to make available
    118118    );
    119 /** Destructor */
     119/** Destructor \ingroup DataGroup */
    120120void psComplexArrayFree(psComplexArray *restrict myArray ///< Array to free
    121121    );
    … …  
    131131} psIntArray;
    132132
    133 /** Constructor */
     133/** Constructor \ingroup DataGroup */
    134134psIntArray *psIntArrayAlloc(int s,      ///< Total number of elements to make available
    135135                            int n       ///< Number of elements that will be used
    136136    );
    137 /** Reallocator */
     137/** Reallocator \ingroup DataGroup */
    138138psIntArray *psIntArrayRealloc(psIntArray *myArray, ///< Array to reallocate
    139139                              int s     ///< Total number of elements to make available
    140140    );
    141 /** Destructor */
     141/** Destructor \ingroup DataGroup */
    142142void psIntArrayFree(psIntArray *restrict myArray ///< Array to free
    143143    );
    … …  
    153153} psDoubleArray;
    154154
    155 /** Constructor */
     155/** Constructor \ingroup DataGroup */
    156156psDoubleArray *psDoubleArrayAlloc(int s, ///< Total number of elements to make available
    157157                                  int n ///< Number of elements that will be used
    158158    );
    159 /** Reallocator */
     159/** Reallocator \ingroup DataGroup */
    160160psDoubleArray *psDoubleArrayRealloc(psDoubleArray *myArray, ///< Array to reallocate
    161161                                    int s       ///< Total number of elements to make available
    162162    );
    163 /** Destructor */
     163/** Destructor \ingroup DataGroup */
    164164void psDoubleArrayFree(psDoubleArray *restrict myArray ///< Array to free
    165165    );
    … …  
    175175} psVectorArray;
    176176
    177 /** Constructor */
     177/** Constructor \ingroup DataGroup */
    178178psVectorArray *psVectorArrayAlloc(int s, ///< Total number of elements to make available
    179179                                  int n ///< Number of elements that will be used
    180180    );
    181 /** Reallocator */
     181/** Reallocator \ingroup DataGroup */
    182182psVectorArray *psVectorArrayRealloc(psVectorArray *myArray, ///< Array to reallocate
    183183                                    int s       ///< Total number of elements to make available
    184184    );
    185 /** Destructor */
     185/** Destructor \ingroup DataGroup */
    186186void psVectorArrayFree(psVectorArray *restrict myArray ///< Array to free
    187187    );
    … …  
    200200} psVoidPtrArray;
    201201
    202 /** Constructor */
     202/** Constructor \ingroup DataGroup */
    203203psVoidPtrArray *psVoidPtrArrayAlloc(int n, //!< Number of elements to use
    204204                                    int s //!< Total number of elements
    205205                                    );
    206 /** Reallocate */
     206/** Reallocate \ingroup DataGroup */
    207207psVoidPtrArray *psVoidPtrArrayRealloc(psVoidPtrArray *arr, //!< Array to reallocate
    208208                                      int n //!< Number of elements
    209209                                      );
    210 /** Destructor */
     210/** Destructor \ingroup DataGroup */
    211211void psVoidPtrArrayFree(psVoidPtrArray *arr, //!< array to destroy
    212212                        void (*elemFree)(void *) //!< destructor for array data

  • trunk/archive/pslib/include/psTrace.h

    r247 r257  
    77 */
    88
    9 //#define PS_NTRACE 1                   //!< to turn off all tracing
     9/** Functions **************************************************************/
     10/** \addtogroup SystemGroup System Utilities
     11 *  \{
     12 */
     13
     14/// Send a trace message
     15void p_psTrace(const char *facil,       ///< facilty of interest
     16               int level,               ///< desired trace level
     17               ...)                     ///< trace message arguments
     18;
     19
     20/// Set trace level
     21int psSetTraceLevel(const char *facil,  ///< facilty of interest
     22                    int level)          ///< desired trace level
     23;
     24
     25/// Get the trace level
     26int psGetTraceLevel(const char *name)   ///< facilty of interest
     27;
     28
     29/// turn off all tracing, and free trace's allocated memory
     30void psTraceReset(void);
     31
     32/// print trace levels
     33void psPrintTraceLevels(void);
     34
     35/* \} */ // End of SystemGroup Functions
     36
     37//#define PS_NTRACE 1                   ///< to turn off all tracing
    1038
    1139#if defined(PS_NTRACE)
    … …  
    1644#endif
    1745
    18 /** Send a trace message */
    19 void p_psTrace(const char *facil,       //!< facilty of interest
    20                int level,               //!< desired trace level
    21                ...                      //!< trace message arguments
    22 );
    23 
    24 /** Set trace level */
    25 int psSetTraceLevel(const char *facil,  //!< facilty of interest
    26                     int level           //!< desired trace level
    27 );
    28 
    29 /** Get the trace level */
    30 int psGetTraceLevel(const char *name    //!< facilty of interest
    31 );
    32 
    33 /** turn off all tracing, and free trace's allocated memory */
    34 void psTraceReset(void);
    35 
    36 /** print trace levels */
    37 void psPrintTraceLevels(void);
    38 
    3946#endif
Note: See TracChangeset for help on using the changeset viewer.