IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 285


Ignore:
Timestamp:
Mar 23, 2004, 10:18:01 AM (22 years ago)
Author:
eugene
Message:

cleaned doxygen comments (one function description per function)
split psLibDesign appendix into group files & updated them

Location:
trunk
Files:
4 added
4 edited

Legend:

Unmodified
Added
Removed

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

    r257 r285  
    5555 */
    5656
    57 /** Constructors */
    58 psPolynomial1D *psPolynomial1DAlloc(int n //!< Number of terms
    59                                     );
    60 psPolynomial2D *psPolynomial2DAlloc(int nX, int nY //!< Number of terms in x and y
    61                                     );
    62 psPolynomial3D *psPolynomial3DAlloc(int nX, int nY, int nZ //!< Number of terms in x, y and z
    63                                     );
    64 psPolynomial4D *psPolynomial4DAlloc(int nW, int nX, int nY, int nZ //!< Number of terms in w, x, y and z
    65                                     );
    66 
    67 /** Destructors */
    68 void psPolynomial1DFree(psPolynomial1D *restrict myPoly //!< Polynomial to destroy
    69                         );
    70 void psPolynomial2DFree(psPolynomial2D *restrict myPoly //!< Polynomial to destroy
    71                         );
    72 void psPolynomial3DFree(psPolynomial3D *restrict myPoly //!< Polynomial to destroy
    73                         );
    74 void psPolynomial4DFree(psPolynomial4D *restrict myPoly //!< Polynomial to destroy
    75                         );
    76 
     57/** Constructor */
     58psPolynomial1D *psPolynomial1DAlloc(int n) //!< Number of terms
     59                                    ;
     60/** Constructor */
     61psPolynomial2D *psPolynomial2DAlloc(int nX, int nY) //!< Number of terms in x and y
     62                                    ;
     63/** Constructor */
     64psPolynomial3D *psPolynomial3DAlloc(int nX, int nY, int nZ) //!< Number of terms in x, y and z
     65                                    ;
     66/** Constructor */
     67psPolynomial4D *psPolynomial4DAlloc(int nW, int nX, int nY, int nZ) //!< Number of terms in w, x, y and z
     68                                    ;
     69
     70/** Destructor */
     71void psPolynomial1DFree(psPolynomial1D *restrict myPoly) //!< Polynomial to destroy
     72;
     73     
     74/** Destructor */
     75void psPolynomial2DFree(psPolynomial2D *restrict myPoly) //!< Polynomial to destroy
     76                        ;
     77/** Destructor */
     78void psPolynomial3DFree(psPolynomial3D *restrict myPoly) //!< Polynomial to destroy
     79                        ;
     80/** Destructor */
     81void psPolynomial4DFree(psPolynomial4D *restrict myPoly) //!< Polynomial to destroy
     82                        ;
    7783
    7884/** Evaluate 1D polynomial */
    … …  
    149155 */
    150156
    151 /** Constructors */
     157/** Constructor */
    152158psDPolynomial1D *psDPolynomial1DAlloc(int n //!< Number of terms
    153159    );
     160/** Constructor */
    154161psDPolynomial2D *psDPolynomial2DAlloc(int nX, int nY //!< Number of terms in x and y
    155162    );
     163/** Constructor */
    156164psDPolynomial3D *psDPolynomial3DAlloc(int nX, int nY, int nZ //!< Number of terms in x, y and z
    157165    );
     166/** Constructor */
    158167psDPolynomial4D *psDPolynomial4DAlloc(int nW, int nX, int nY, int nZ //!< Number of terms in w, x, y and z
    159168    );
    160169
    161170
    162 /** Destructors */
     171/** Destructor */
    163172void psDPolynomial1DFree(psDPolynomial1D *restrict myPoly //!< Polynomial to destroy
    164173    );
     174/** Destructor */
    165175void psDPolynomial2DFree(psDPolynomial2D *restrict myPoly //!< Polynomial to destroy
    166176    );
     177/** Destructor */
    167178void psDPolynomial3DFree(psDPolynomial3D *restrict myPoly //!< Polynomial to destroy
    168179    );
     180/** Destructor */
    169181void psDPolynomial4DFree(psDPolynomial4D *restrict myPoly //!< Polynomial to destroy
    170182    );

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

    r257 r285  
    7575/**** Utilities **********************************************************************/
    7676
     77/// Add entry to the end of the metadata set
    7778psMetaDataItem *psMetaDataAppend(psMetaDataSet *restrict ms, psMetaDataItem *restrict item);
     79
     80/// delete entry from the metadata set
    7881psMetaDataItem *psMetaDataRemove(psMetaDataSet *restrict ms, const char *restrict key);
    7982
     83/// reset the iterator to the start of the list
    8084void psMetaDataSetIterator(psMetaDataSet *ms);
     85
     86/// get the next entry in the sequence
    8187psMetaDataItem *psMetaDataGetNext(psMetaDataSet *restrict ms, const char *restrict match);
     88
     89/// find the metadata with the specified key
    8290psMetaDataItem *psMetaDataLookup(const psMetaDataSet *restrict ms, const char *restrict key);
    8391
     92/// print metadata item to the specified stream
    8493void psMetaDataItemPrint(FILE *fd,              // file descriptor to write to
    8594                         const psMetaDataItem *restrict ms, // item of metadata to print

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

    r277 r285  
    2222psFloatArray *
    2323psMinimizeChi2(float (*evalModel)(const psFloatArray *restrict,
    24                                   const psFloatArray *restrict), //!< Model to fit; receives domain and
    25                                                                  //!< parameters
     24                                  const psFloatArray *restrict), //!< Model to fit; (domain and params)
    2625               const psFloatArray *restrict domain, //!< The domain values for the corresponding measurements
    2726               const psFloatArray *restrict data, //!< Data to fit
    … …  
    2928               psFloatArray *restrict initialGuess, //!< Initial guess
    3029               const psIntArray *restrict guessMask //!< 1 = fit for parameter, 0 = hold parameter constant
    31                );
     30    );
    3231
    3332/** Derive a polynomial fit by least-squares --- can be done analytically */

  • trunk/doc/pslib/psLibSDRS.tex

    r284 r285  
    30103010
    30113011\subsection{System Utilities}
    3012 \begin{CompactItemize}
    3013 \item
    3014 int {\bf ps\-Set\-Log\-Destination} (int dest)
    3015 \begin{CompactList}\small\item\em Sets the log destination.\item\end{CompactList}\item
    3016 int {\bf ps\-Set\-Log\-Level} (int level)
    3017 \begin{CompactList}\small\item\em Sets the log level.\item\end{CompactList}\item
    3018 void {\bf ps\-Set\-Log\-Format} (const char $\ast$fmt)
    3019 \begin{CompactList}\small\item\em sets the log format\item\end{CompactList}\item
    3020 void {\bf ps\-Log\-Msg} (const char $\ast$name, int level, const char $\ast$fmt,...)
    3021 \begin{CompactList}\small\item\em Logs a message.\item\end{CompactList}\item
    3022 void {\bf p\_\-ps\-VLog\-Msg} (const char $\ast$name, int level, const char $\ast$fmt, va\_\-list ap)
    3023 \begin{CompactList}\small\item\em Logs a message from varargs.\item\end{CompactList}\item
    3024 void $\ast$ {\bf p\_\-ps\-Alloc} (size\_\-t size, const char $\ast$file, int lineno)
    3025 \begin{CompactList}\small\item\em Memory allocation. Underlying private function called by macro ps\-Alloc.\item\end{CompactList}\item
    3026 void $\ast$ {\bf p\_\-ps\-Realloc} (void $\ast$ptr, size\_\-t size, const char $\ast$file, int lineno)
    3027 \begin{CompactList}\small\item\em Memory re-allocation. Underlying private function called by macro ps\-Realloc.\item\end{CompactList}\item
    3028 void {\bf p\_\-ps\-Free} (void $\ast$ptr, const char $\ast$file, int lineno)
    3029 \begin{CompactList}\small\item\em Free memory. Underlying private function called by macro ps\-Free.\item\end{CompactList}\item
    3030 int {\bf ps\-Mem\-Check\-Leaks} (int id0, {\bf ps\-Mem\-Block} $\ast$$\ast$$\ast$arr, FILE $\ast$fd)
    3031 \begin{CompactList}\small\item\em Check for memory leaks.\item\end{CompactList}\item
    3032 int {\bf ps\-Mem\-Check\-Corruption} (int abort\_\-on\_\-error)
    3033 \begin{CompactList}\small\item\em Check for memory corruption.\item\end{CompactList}\item
    3034 int {\bf ps\-Mem\-Get\-Ref\-Counter} (void $\ast$vptr)
    3035 \begin{CompactList}\small\item\em Return reference counter.\item\end{CompactList}\item
    3036 void $\ast$ {\bf ps\-Mem\-Incr\-Ref\-Counter} (void $\ast$vptr)
    3037 \begin{CompactList}\small\item\em Increment reference counter and return the pointer.\item\end{CompactList}\item
    3038 void $\ast$ {\bf ps\-Mem\-Decr\-Ref\-Counter} (void $\ast$vptr)
    3039 \begin{CompactList}\small\item\em Decrement reference counter and return the pointer.\item\end{CompactList}\item
    3040 {\bf ps\-Mem\-Problem\-Callback} {\bf ps\-Mem\-Problem\-Set\-CB} ({\bf ps\-Mem\-Problem\-Callback} func)
    3041 \begin{CompactList}\small\item\em Set callback for problems.\item\end{CompactList}\item
    3042 {\bf ps\-Mem\-Exhausted\-Callback} {\bf ps\-Mem\-Exhausted\-Set\-CB} ({\bf ps\-Mem\-Exhausted\-Callback} func)
    3043 \begin{CompactList}\small\item\em Set callback for out-of-memory.\item\end{CompactList}\item
    3044 {\bf ps\-Mem\-Callback} {\bf ps\-Mem\-Allocate\-Set\-CB} ({\bf ps\-Mem\-Callback} func)
    3045 \begin{CompactList}\small\item\em Set call back for when a particular memory block is allocated.\item\end{CompactList}\item
    3046 {\bf ps\-Mem\-Callback} {\bf ps\-Mem\-Free\-Set\-CB} ({\bf ps\-Mem\-Callback} func)
    3047 \begin{CompactList}\small\item\em Set call back for when a particular memory block is freed.\item\end{CompactList}\item
    3048 int {\bf ps\-Mem\-Get\-Id} (void)
    3049 \begin{CompactList}\small\item\em get next memory ID\item\end{CompactList}\item
    3050 long {\bf ps\-Mem\-Set\-Allocate\-ID} (long id)
    3051 \begin{CompactList}\small\item\em set p\_\-ps\-Mem\-Allocate\-ID to id\item\end{CompactList}\item
    3052 long {\bf ps\-Mem\-Set\-Free\-ID} (long id)
    3053 \begin{CompactList}\small\item\em set p\_\-ps\-Mem\-Free\-ID to id\item\end{CompactList}\item
    3054 void {\bf ps\-Abort} (const char $\ast$name, const char $\ast$fmt,...)
    3055 \begin{CompactList}\small\item\em Prints an error message and aborts.\item\end{CompactList}\item
    3056 void {\bf ps\-Error} (const char $\ast$name, const char $\ast$fmt,...)
    3057 \begin{CompactList}\small\item\em Prints an error message and doesn't abort.\item\end{CompactList}\item
    3058 char $\ast$ {\bf ps\-String\-Copy} (const char $\ast$str)
    3059 \begin{CompactList}\small\item\em Allocates and returns a copy of a string.\item\end{CompactList}\item
    3060 void {\bf p\_\-ps\-Trace} (const char $\ast$facil, int level,...)
    3061 \begin{CompactList}\small\item\em Send a trace message.\item\end{CompactList}\item
    3062 int {\bf ps\-Set\-Trace\-Level} (const char $\ast$facil, int level)
    3063 \begin{CompactList}\small\item\em Set trace level.\item\end{CompactList}\item
    3064 int {\bf ps\-Get\-Trace\-Level} (const char $\ast$name)
    3065 \begin{CompactList}\small\item\em Get the trace level.\item\end{CompactList}\item
    3066 void {\bf ps\-Trace\-Reset} (void)
    3067 \begin{CompactList}\small\item\em turn off all tracing, and free trace's allocated memory\item\end{CompactList}\item
    3068 void {\bf ps\-Print\-Trace\-Levels} (void)
    3069 \begin{CompactList}\small\item\em print trace levels\item\end{CompactList}\end{CompactItemize}
     3012\input{psSystemGroup.tex}
    30703013
    30713014\subsection{Data Containers}
    3072 \begin{CompactItemize}
    3073 \item
    3074 {\bf ps\-Dlist} $\ast$ {\bf ps\-Dlist\-Alloc} (void $\ast$data)
    3075 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3076 void {\bf ps\-Dlist\-Free} ({\bf ps\-Dlist} $\ast$list, void($\ast$elem\-Free)(void $\ast$))
    3077 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3078 {\bf ps\-Dlist} $\ast$ {\bf ps\-Dlist\-Add} ({\bf ps\-Dlist} $\ast$list, void $\ast$data, int where)
    3079 \begin{CompactList}\small\item\em Add to list.\item\end{CompactList}\item
    3080 {\bf ps\-Dlist} $\ast$ {\bf ps\-Dlist\-Append} ({\bf ps\-Dlist} $\ast$list, void $\ast$data)
    3081 \begin{CompactList}\small\item\em Append to a list.\item\end{CompactList}\item
    3082 void $\ast$ {\bf ps\-Dlist\-Remove} ({\bf ps\-Dlist} $\ast$list, void $\ast$data, int which)
    3083 \begin{CompactList}\small\item\em PS\_\-DLIST\_\-PREV.\item\end{CompactList}\item
    3084 void $\ast$ {\bf ps\-Dlist\-Get} (const {\bf ps\-Dlist} $\ast$list, int which)
    3085 \begin{CompactList}\small\item\em Retrieve from a list.\item\end{CompactList}\item
    3086 void {\bf ps\-Dlist\-Set\-Iterator} ({\bf ps\-Dlist} $\ast$list, int where, int which)
    3087 \begin{CompactList}\small\item\em PS\_\-DLIST\_\-PREV.\item\end{CompactList}\item
    3088 void $\ast$ {\bf ps\-Dlist\-Get\-Next} ({\bf ps\-Dlist} $\ast$list, int which)
    3089 \begin{CompactList}\small\item\em PS\_\-DLIST\_\-PREV.\item\end{CompactList}\item
    3090 void $\ast$ {\bf ps\-Dlist\-Get\-Prev} ({\bf ps\-Dlist} $\ast$list, int which)
    3091 \begin{CompactList}\small\item\em PS\_\-DLIST\_\-PREV.\item\end{CompactList}\item
    3092 {\bf ps\-Void\-Ptr\-Array} $\ast$ {\bf ps\-Dlist\-To\-Array} ({\bf ps\-Dlist} $\ast$dlist)
    3093 \begin{CompactList}\small\item\em Convert doubly-linked list to an array.\item\end{CompactList}\item
    3094 {\bf ps\-Dlist} $\ast$ {\bf ps\-Array\-To\-Dlist} ({\bf ps\-Void\-Ptr\-Array} $\ast$arr)
    3095 \begin{CompactList}\small\item\em Convert array to a doubly-linked list.\item\end{CompactList}\item
    3096 {\bf ps\-Hash} $\ast$ {\bf ps\-Hash\-Alloc} (int nbucket)
    3097 \begin{CompactList}\small\item\em Allocate hash buckets in table.\item\end{CompactList}\item
    3098 void {\bf ps\-Hash\-Free} ({\bf ps\-Hash} $\ast$table, void($\ast$item\-Free)(void $\ast$item))
    3099 \begin{CompactList}\small\item\em Free hash buckets from table.\item\end{CompactList}\item
    3100 void $\ast$ {\bf ps\-Hash\-Insert} ({\bf ps\-Hash} $\ast$table, const char $\ast$key, void $\ast$data, void($\ast$item\-Free)(void $\ast$item))
    3101 \begin{CompactList}\small\item\em Insert entry into table.\item\end{CompactList}\item
    3102 void $\ast$ {\bf ps\-Hash\-Lookup} ({\bf ps\-Hash} $\ast$table, const char $\ast$key)
    3103 \begin{CompactList}\small\item\em Lookup key in table.\item\end{CompactList}\item
    3104 void $\ast$ {\bf ps\-Hash\-Remove} ({\bf ps\-Hash} $\ast$table, const char $\ast$key)
    3105 \begin{CompactList}\small\item\em Remove key from table.\item\end{CompactList}\item
    3106 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Float\-Array\-Alloc} (int s, int n)
    3107 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3108 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Float\-Array\-Realloc} ({\bf ps\-Float\-Array} $\ast$my\-Array, int s)
    3109 \begin{CompactList}\small\item\em Reallocator.\item\end{CompactList}\item
    3110 void {\bf ps\-Float\-Array\-Free} ({\bf ps\-Float\-Array} $\ast$restrict my\-Array)
    3111 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3112 {\bf ps\-Complex\-Array} $\ast$ {\bf ps\-Complex\-Array\-Alloc} (int s, int n)
    3113 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3114 {\bf ps\-Complex\-Array} $\ast$ {\bf ps\-Complex\-Array\-Realloc} ({\bf ps\-Complex\-Array} $\ast$my\-Array, int s)
    3115 \begin{CompactList}\small\item\em Reallocator.\item\end{CompactList}\item
    3116 void {\bf ps\-Complex\-Array\-Free} ({\bf ps\-Complex\-Array} $\ast$restrict my\-Array)
    3117 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3118 {\bf ps\-Int\-Array} $\ast$ {\bf ps\-Int\-Array\-Alloc} (int s, int n)
    3119 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3120 {\bf ps\-Int\-Array} $\ast$ {\bf ps\-Int\-Array\-Realloc} ({\bf ps\-Int\-Array} $\ast$my\-Array, int s)
    3121 \begin{CompactList}\small\item\em Reallocator.\item\end{CompactList}\item
    3122 void {\bf ps\-Int\-Array\-Free} ({\bf ps\-Int\-Array} $\ast$restrict my\-Array)
    3123 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3124 {\bf ps\-Double\-Array} $\ast$ {\bf ps\-Double\-Array\-Alloc} (int s, int n)
    3125 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3126 {\bf ps\-Double\-Array} $\ast$ {\bf ps\-Double\-Array\-Realloc} ({\bf ps\-Double\-Array} $\ast$my\-Array, int s)
    3127 \begin{CompactList}\small\item\em Reallocator.\item\end{CompactList}\item
    3128 void {\bf ps\-Double\-Array\-Free} ({\bf ps\-Double\-Array} $\ast$restrict my\-Array)
    3129 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3130 {\bf ps\-Vector\-Array} $\ast$ {\bf ps\-Vector\-Array\-Alloc} (int s, int n)
    3131 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3132 {\bf ps\-Vector\-Array} $\ast$ {\bf ps\-Vector\-Array\-Realloc} ({\bf ps\-Vector\-Array} $\ast$my\-Array, int s)
    3133 \begin{CompactList}\small\item\em Reallocator.\item\end{CompactList}\item
    3134 void {\bf ps\-Vector\-Array\-Free} ({\bf ps\-Vector\-Array} $\ast$restrict my\-Array)
    3135 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3136 {\bf ps\-Void\-Ptr\-Array} $\ast$ {\bf ps\-Void\-Ptr\-Array\-Alloc} (int n, int s)
    3137 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3138 {\bf ps\-Void\-Ptr\-Array} $\ast$ {\bf ps\-Void\-Ptr\-Array\-Realloc} ({\bf ps\-Void\-Ptr\-Array} $\ast$arr, int n)
    3139 \begin{CompactList}\small\item\em Reallocate.\item\end{CompactList}\item
    3140 void {\bf ps\-Void\-Ptr\-Array\-Free} ({\bf ps\-Void\-Ptr\-Array} $\ast$arr, void($\ast$elem\-Free)(void $\ast$))
    3141 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\end{CompactItemize}
     3015\input{psDataGroup.tex}
    31423016
    31433017\subsection{Math Utilities}
    3144 \begin{CompactItemize}
    3145 \item
    3146 {\bf ps\-Bit\-Mask} $\ast$ {\bf ps\-Bit\-Mask\-Alloc} (int n)
    3147 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3148 void {\bf ps\-Bit\-Mask\-Free} ({\bf ps\-Bit\-Mask} $\ast$restrict my\-Mask)
    3149 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3150 {\bf ps\-Bit\-Mask} $\ast$ {\bf ps\-Bit\-Mask\-Set} ({\bf ps\-Bit\-Mask} $\ast$out\-Mask, const {\bf ps\-Bit\-Mask} $\ast$my\-Mask, int bit)
    3151 \begin{CompactList}\small\item\em Set a bit mask.\item\end{CompactList}\item
    3152 int {\bf ps\-Bit\-Mask\-Test} (const {\bf ps\-Bit\-Mask} $\ast$check\-Mask, int bit)
    3153 \begin{CompactList}\small\item\em Check a bit mask.\item\end{CompactList}\item
    3154 {\bf ps\-Bit\-Mask} $\ast$ {\bf ps\-Bit\-Mask\-Op} ({\bf ps\-Bit\-Mask} $\ast$out\-Mask, const {\bf ps\-Bit\-Mask} $\ast$restrict in\-Mask1, char $\ast$operator, const {\bf ps\-Bit\-Mask} $\ast$restrict in\-Mask2)
    3155 \begin{CompactList}\small\item\em apply the given operator to two bit masks\item\end{CompactList}\item
    3156 {\bf ps\-Complex\-Array} $\ast$ {\bf ps\-Real\-FFT} ({\bf ps\-Complex\-Array} $\ast$restrict out, const {\bf ps\-Float\-Array} $\ast$restrict my\-Array)
    3157 \begin{CompactList}\small\item\em Return Fourier Transform of an array.\item\end{CompactList}\item
    3158 {\bf ps\-Complex\-Array} $\ast$ {\bf ps\-Complex\-FFT} ({\bf ps\-Complex\-Array} $\ast$restrict out, const {\bf ps\-Complex\-Array} $\ast$restrict my\-Array, int sign)
    3159 \begin{CompactList}\small\item\em Return [inverse?] Fourier Transform of a complex array.\item\end{CompactList}\item
    3160 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Power\-Spec} ({\bf ps\-Float\-Array} $\ast$restrict out, const {\bf ps\-Float\-Array} $\ast$restrict my\-Array)
    3161 \begin{CompactList}\small\item\em Return Power spectrum of a array.\item\end{CompactList}\item
    3162 {\bf ps\-Polynomial1D} $\ast$ {\bf ps\-Polynomial1DAlloc} (int n)
    3163 \begin{CompactList}\small\item\em Constructors.\item\end{CompactList}\item
    3164 {\bf ps\-Polynomial2D} $\ast$ {\bf ps\-Polynomial2DAlloc} (int n\-X, int n\-Y)
    3165 \item
    3166 {\bf ps\-Polynomial3D} $\ast$ {\bf ps\-Polynomial3DAlloc} (int n\-X, int n\-Y, int n\-Z)
    3167 \item
    3168 {\bf ps\-Polynomial4D} $\ast$ {\bf ps\-Polynomial4DAlloc} (int n\-W, int n\-X, int n\-Y, int n\-Z)
    3169 \item
    3170 void {\bf ps\-Polynomial1DFree} ({\bf ps\-Polynomial1D} $\ast$restrict my\-Poly)
    3171 \begin{CompactList}\small\item\em Destructors.\item\end{CompactList}\item
    3172 void {\bf ps\-Polynomial2DFree} ({\bf ps\-Polynomial2D} $\ast$restrict my\-Poly)
    3173 \item
    3174 void {\bf ps\-Polynomial3DFree} ({\bf ps\-Polynomial3D} $\ast$restrict my\-Poly)
    3175 \item
    3176 void {\bf ps\-Polynomial4DFree} ({\bf ps\-Polynomial4D} $\ast$restrict my\-Poly)
    3177 \item
    3178 float {\bf ps\-Eval\-Polynomial1D} (float x, const {\bf ps\-Polynomial1D} $\ast$restrict my\-Poly)
    3179 \begin{CompactList}\small\item\em Evaluate 1D polynomial.\item\end{CompactList}\item
    3180 float {\bf ps\-Eval\-Polynomial2D} (float x, float y, const {\bf ps\-Polynomial2D} $\ast$restrict my\-Poly)
    3181 \begin{CompactList}\small\item\em Evaluate 2D polynomial.\item\end{CompactList}\item
    3182 float {\bf ps\-Eval\-Polynomial3D} (float x, float y, float z, const {\bf ps\-Polynomial3D} $\ast$restrict my\-Poly)
    3183 \begin{CompactList}\small\item\em Evaluate 3D polynomial.\item\end{CompactList}\item
    3184 float {\bf ps\-Eval\-Polynomial4D} (float w, float x, float y, float z, const {\bf ps\-Polynomial4D} $\ast$restrict my\-Poly)
    3185 \begin{CompactList}\small\item\em Evaluate 4D polynomial.\item\end{CompactList}\item
    3186 {\bf ps\-DPolynomial1D} $\ast$ {\bf ps\-DPolynomial1DAlloc} (int n)
    3187 \begin{CompactList}\small\item\em Constructors.\item\end{CompactList}\item
    3188 {\bf ps\-DPolynomial2D} $\ast$ {\bf ps\-DPolynomial2DAlloc} (int n\-X, int n\-Y)
    3189 \item
    3190 {\bf ps\-DPolynomial3D} $\ast$ {\bf ps\-DPolynomial3DAlloc} (int n\-X, int n\-Y, int n\-Z)
    3191 \item
    3192 {\bf ps\-DPolynomial4D} $\ast$ {\bf ps\-DPolynomial4DAlloc} (int n\-W, int n\-X, int n\-Y, int n\-Z)
    3193 \item
    3194 void {\bf ps\-DPolynomial1DFree} ({\bf ps\-DPolynomial1D} $\ast$restrict my\-Poly)
    3195 \begin{CompactList}\small\item\em Destructors.\item\end{CompactList}\item
    3196 void {\bf ps\-DPolynomial2DFree} ({\bf ps\-DPolynomial2D} $\ast$restrict my\-Poly)
    3197 \item
    3198 void {\bf ps\-DPolynomial3DFree} ({\bf ps\-DPolynomial3D} $\ast$restrict my\-Poly)
    3199 \item
    3200 void {\bf ps\-DPolynomial4DFree} ({\bf ps\-DPolynomial4D} $\ast$restrict my\-Poly)
    3201 \item
    3202 double {\bf ps\-Eval\-DPolynomial1D} (double x, const {\bf ps\-DPolynomial1D} $\ast$restrict my\-Poly)
    3203 \begin{CompactList}\small\item\em Evaluate 1D polynomial (double precision).\item\end{CompactList}\item
    3204 double {\bf ps\-Eval\-DPolynomial2D} (double x, double y, const {\bf ps\-DPolynomial2D} $\ast$restrict my\-Poly)
    3205 \begin{CompactList}\small\item\em Evaluate 2D polynomial (double precision).\item\end{CompactList}\item
    3206 double {\bf ps\-Eval\-DPolynomial3D} (double x, double y, double z, const {\bf ps\-DPolynomial3D} $\ast$restrict my\-Poly)
    3207 \begin{CompactList}\small\item\em Evaluate 3D polynomial (double precision).\item\end{CompactList}\item
    3208 double {\bf ps\-Eval\-DPolynomial4D} (double w, double x, double y, double z, const {\bf ps\-DPolynomial4D} $\ast$restrict my\-Poly)
    3209 \begin{CompactList}\small\item\em Evaluate 4D polynomial (double precision).\item\end{CompactList}\item
    3210 {\bf ps\-Type} $\ast$ {\bf ps\-Binary\-Op} (void $\ast$out, void $\ast$in1, char $\ast$operator, void $\ast$in2)
    3211 \begin{CompactList}\small\item\em Perform a binary operation on two data items ({\bf ps\-Image} {\rm (p.\,\pageref{structpsImage})}, ps\-Vector, ps\-Scalar).\item\end{CompactList}\item
    3212 {\bf ps\-Type} $\ast$ {\bf ps\-Unary\-Op} (void $\ast$out, void $\ast$in, char $\ast$operator)
    3213 \begin{CompactList}\small\item\em Perform a binary operation on two data items ({\bf ps\-Image} {\rm (p.\,\pageref{structpsImage})}, ps\-Vector, ps\-Scalar).\item\end{CompactList}\item
    3214 {\bf p\_\-ps\-Scalar} $\ast$ {\bf ps\-Scalar} (double value)
    3215 \begin{CompactList}\small\item\em create a {\bf ps\-Type} {\rm (p.\,\pageref{structpsType})}-ed structure from a constant double value.\item\end{CompactList}\item
    3216 {\bf p\_\-ps\-Scalar} $\ast$ {\bf ps\-Scalar\-Type} (char $\ast$mode,...)
    3217 \begin{CompactList}\small\item\em create a {\bf ps\-Type} {\rm (p.\,\pageref{structpsType})}-ed structure from a specified type\item\end{CompactList}\item
    3218 {\bf ps\-Matrix} $\ast$ {\bf ps\-Matrix\-Alloc} (int Xdimen, int Ydimen)
    3219 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3220 void {\bf ps\-Matrix\-Free} ({\bf ps\-Matrix} $\ast$restrict my\-Matrix)
    3221 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3222 {\bf ps\-Matrix} $\ast$ {\bf ps\-Matrix\-Invert} ({\bf ps\-Matrix} $\ast$out, const {\bf ps\-Matrix} $\ast$my\-Matrix, float $\ast$restrict determinant)
    3223 \begin{CompactList}\small\item\em Invert matrix.\item\end{CompactList}\item
    3224 float {\bf ps\-Matrix\-Determinant} (const {\bf ps\-Matrix} $\ast$restrict my\-Matrix)
    3225 \begin{CompactList}\small\item\em Matrix determinant.\item\end{CompactList}\item
    3226 {\bf ps\-Matrix} $\ast$ {\bf ps\-Matrix\-Op} ({\bf ps\-Matrix} $\ast$out, const {\bf ps\-Matrix} $\ast$matrix1, const char $\ast$op, const {\bf ps\-Matrix} $\ast$matrix2)
    3227 \begin{CompactList}\small\item\em Matrix operations.\item\end{CompactList}\item
    3228 {\bf ps\-Matrix} $\ast$ {\bf ps\-Matrix\-Transpose} ({\bf ps\-Matrix} $\ast$out, const {\bf ps\-Matrix} $\ast$my\-Matrix)
    3229 \begin{CompactList}\small\item\em Transpose Matrix.\item\end{CompactList}\item
    3230 {\bf ps\-Vector} $\ast$ {\bf ps\-Matrix\-To\-Vector} ({\bf ps\-Matrix} $\ast$my\-Matrix)
    3231 \begin{CompactList}\small\item\em Convert matrix to vector.\item\end{CompactList}\item
    3232 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Minimize} (float($\ast$my\-Function)(const {\bf ps\-Float\-Array} $\ast$restrict), {\bf ps\-Float\-Array} $\ast$restrict initial\-Guess)
    3233 \begin{CompactList}\small\item\em Minimize a particular function.\item\end{CompactList}\item
    3234 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Minimize\-Chi2} (float($\ast$eval\-Model)(const {\bf ps\-Float\-Array} $\ast$restrict, const {\bf ps\-Float\-Array} $\ast$restrict), const {\bf ps\-Float\-Array} $\ast$restrict domain, const {\bf ps\-Float\-Array} $\ast$restrict data, const {\bf ps\-Float\-Array} $\ast$restrict errors, {\bf ps\-Float\-Array} $\ast$restrict initial\-Guess, const {\bf ps\-Int\-Array} $\ast$restrict guess\-Mask)
    3235 \begin{CompactList}\small\item\em Minimize chi$^\wedge$2 for input data.\item\end{CompactList}\item
    3236 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Get\-Array\-Polynomial} (const {\bf ps\-Float\-Array} $\ast$restrict ord, const {\bf ps\-Float\-Array} $\ast$restrict coord)
    3237 \begin{CompactList}\small\item\em Derive a polynomial that goes through the points --- can be done analytically.\item\end{CompactList}\item
    3238 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Sort} ({\bf ps\-Float\-Array} $\ast$out, const {\bf ps\-Float\-Array} $\ast$my\-Array)
    3239 \begin{CompactList}\small\item\em Sort an array.\item\end{CompactList}\item
    3240 {\bf ps\-Int\-Array} $\ast$ {\bf ps\-Sort\-Index} ({\bf ps\-Int\-Array} $\ast$restrict out, const {\bf ps\-Float\-Array} $\ast$restrict my\-Array)
    3241 \begin{CompactList}\small\item\em Sort an array, along with some other stuff.\item\end{CompactList}\item
    3242 {\bf ps\-Stats} $\ast$ {\bf ps\-Array\-Stats} (const {\bf ps\-Float\-Array} $\ast$restrict my\-Array, const {\bf ps\-Int\-Array} $\ast$restrict mask\-Array, unsigned int mask\-Val, {\bf ps\-Stats} $\ast$stats)
    3243 \begin{CompactList}\small\item\em Do Statistics on an array.\item\end{CompactList}\item
    3244 {\bf ps\-Histogram} $\ast$ {\bf ps\-Histogram\-Alloc} (float lower, float upper, float size)
    3245 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3246 {\bf ps\-Histogram} $\ast$ {\bf ps\-Histogram\-Alloc\-Generic} (const {\bf ps\-Float\-Array} $\ast$restrict lower, const {\bf ps\-Float\-Array} $\ast$restrict upper, float min\-Val, float max\-Val)
    3247 \begin{CompactList}\small\item\em Generic constructor.\item\end{CompactList}\item
    3248 void {\bf ps\-Histogram\-Free} ({\bf ps\-Histogram} $\ast$restrict my\-Hist)
    3249 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3250 {\bf ps\-Histogram} $\ast$ {\bf ps\-Get\-Array\-Histogram} ({\bf ps\-Histogram} $\ast$restrict my\-Hist, const {\bf ps\-Float\-Array} $\ast$restrict my\-Array)
    3251 \begin{CompactList}\small\item\em Calculate a histogram.\item\end{CompactList}\end{CompactItemize}
     3018\input{psMathGroup.tex}
    32523019
    32533020\subsection{Astronomy Functions}
    3254 \begin{CompactItemize}
    3255 \item
    3256 {\bf ps\-Chip} $\ast$ {\bf ps\-Chip\-In\-FPA} ({\bf ps\-FPA} $\ast$fpa, {\bf ps\-Coord} $\ast$coord)
    3257 \begin{CompactList}\small\item\em returns Chip in FPA which contains the given FPA coordinate\item\end{CompactList}\item
    3258 {\bf ps\-Cell} $\ast$ {\bf ps\-Cell\-In\-Chip} ({\bf ps\-Chip} $\ast$chip, {\bf ps\-Coord} $\ast$coord)
    3259 \begin{CompactList}\small\item\em returns Cell in Chip which contains the given chip coordinate\item\end{CompactList}\item
    3260 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-Sky\-To\-TP} ({\bf ps\-Exposure} $\ast$exp, {\bf ps\-Coord} $\ast$coord)
    3261 \begin{CompactList}\small\item\em Convert (RA,Dec) to tangent plane coords.\item\end{CompactList}\item
    3262 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-TPto\-FPA} ({\bf ps\-FPA} $\ast$fpa, {\bf ps\-Coord} $\ast$coord)
    3263 \begin{CompactList}\small\item\em Convert tangent plane coords to focal plane coordinates.\item\end{CompactList}\item
    3264 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-FPAto\-Chip} ({\bf ps\-FPA} $\ast$fpa, {\bf ps\-Chip} $\ast$chip, {\bf ps\-Coord} $\ast$coord)
    3265 \begin{CompactList}\small\item\em converts the specified FPA coord to the coord on the given Chip\item\end{CompactList}\item
    3266 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-Chipto\-Cell} ({\bf ps\-Chip} $\ast$chip, {\bf ps\-Cell} $\ast$cell, {\bf ps\-Coord} $\ast$coord)
    3267 \begin{CompactList}\small\item\em converts the specified Chip coord to the coord on the given Cell\item\end{CompactList}\item
    3268 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-Cellto\-Chip} ({\bf ps\-Cell} $\ast$cell, {\bf ps\-Coord} $\ast$coord)
    3269 \begin{CompactList}\small\item\em converts the specified Cell coord to the coord on the parent Chip\item\end{CompactList}\item
    3270 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-Chipto\-FPA} ({\bf ps\-Chip} $\ast$chip, {\bf ps\-Coord} $\ast$coord)
    3271 \begin{CompactList}\small\item\em converts the specified Chip coord to the coord on the parent FPA\item\end{CompactList}\item
    3272 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-FPATo\-TP} ({\bf ps\-FPA} $\ast$fpa, {\bf ps\-Coord} $\ast$coord)
    3273 \begin{CompactList}\small\item\em Convert focal plane coords to tangent plane coordinates.\item\end{CompactList}\item
    3274 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-TPto\-Sky} ({\bf ps\-Exposure} $\ast$exp, {\bf ps\-Coord} $\ast$coord)
    3275 \begin{CompactList}\small\item\em Convert tangent plane coords to (RA,Dec).\item\end{CompactList}\item
    3276 float {\bf ps\-Get\-Airmass} ({\bf ps\-Coord} $\ast$coord, double sidereal\-Time)
    3277 \begin{CompactList}\small\item\em Get the airmass for a given position and sidereal time.\item\end{CompactList}\item
    3278 float {\bf ps\-Get\-Parallactic} ({\bf ps\-Coord} $\ast$coord, double sidereal\-Time)
    3279 \begin{CompactList}\small\item\em Get the parallactic angle for a given position and sidereal time.\item\end{CompactList}\item
    3280 float {\bf ps\-Get\-Refraction} (float colour, {\bf ps\-Phot\-System} color\-Plus, {\bf ps\-Phot\-System} color\-Minus, {\bf ps\-Exposure} $\ast$exp)
    3281 \begin{CompactList}\small\item\em Estimate atmospheric refraction, along the parallactic.\item\end{CompactList}\item
    3282 {\bf ps\-Exposure} $\ast$ {\bf ps\-Exposure\-Alloc} (double ra, double dec, double ha, double zd, double az, double lst, float mjd, float rot\-Angle, float temp, float pressure, float humidity, float exptime)
    3283 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3284 void {\bf ps\-Exposure\-Free} ({\bf ps\-Exposure} $\ast$restrict my\-Exp)
    3285 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3286 double {\bf ps\-Get\-MJD} (void)
    3287 \begin{CompactList}\small\item\em Get current MJD, for a timestamp.\item\end{CompactList}\item
    3288 double {\bf ps\-Get\-Sidereal} (float mjd, float longitude)
    3289 \begin{CompactList}\small\item\em Get current sidereal time at longitude.\item\end{CompactList}\item
    3290 char $\ast$ {\bf ps\-Time\-To\-ISOTime} (ps\-Time time)
    3291 \begin{CompactList}\small\item\em Convert ps\-Time to ISOTime (Human-readable date/time string YYYY/MM/DD,HH:MM:SS.SSS).\item\end{CompactList}\item
    3292 double {\bf ps\-Time\-To\-UTC} (ps\-Time time)
    3293 \begin{CompactList}\small\item\em Convert ps\-Time to UTC.\item\end{CompactList}\item
    3294 double {\bf ps\-Time\-To\-MJD} (ps\-Time time)
    3295 \begin{CompactList}\small\item\em Convert ps\-Time to MJD.\item\end{CompactList}\item
    3296 double {\bf ps\-Time\-To\-JD} (ps\-Time time)
    3297 \begin{CompactList}\small\item\em Convert ps\-Time to JD.\item\end{CompactList}\item
    3298 timeval $\ast$ {\bf ps\-Time\-To\-Timeval} (ps\-Time time)
    3299 \begin{CompactList}\small\item\em Convert ps\-Time to timeval (struct timeval).\item\end{CompactList}\item
    3300 tm $\ast$ {\bf ps\-Time\-To\-Tm} (ps\-Time time)
    3301 \begin{CompactList}\small\item\em Convert ps\-Time to broken-down time (struct tm).\item\end{CompactList}\item
    3302 ps\-Time $\ast$ {\bf ps\-ISOTime\-To\-Time} (char $\ast$input)
    3303 \begin{CompactList}\small\item\em Convert ISOTime (Human-readable date/time string YYYY/MM/DD,HH:MM:SS.SSS) to ps\-Time.\item\end{CompactList}\item
    3304 ps\-Time $\ast$ {\bf ps\-UTCTo\-Time} (double input)
    3305 \begin{CompactList}\small\item\em Convert UTC to ps\-Time.\item\end{CompactList}\item
    3306 ps\-Time $\ast$ {\bf ps\-MJDTo\-Time} (double input)
    3307 \begin{CompactList}\small\item\em Convert MJD to ps\-Time.\item\end{CompactList}\item
    3308 ps\-Time $\ast$ {\bf ps\-JDTo\-Time} (double input)
    3309 \begin{CompactList}\small\item\em Convert JD to ps\-Time.\item\end{CompactList}\item
    3310 ps\-Time $\ast$ {\bf ps\-Timeval\-To\-Time} (struct timeval $\ast$input)
    3311 \begin{CompactList}\small\item\em Convert timeval to ps\-Time (struct timeval).\item\end{CompactList}\item
    3312 ps\-Time $\ast$ {\bf ps\-TMto\-Time} (struct tm $\ast$input)
    3313 \begin{CompactList}\small\item\em Convert broken-to ps\-Time down time (struct tm).\item\end{CompactList}\item
    3314 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Alloc} (int nx, int ny, {\bf ps\-Type} type)
    3315 \begin{CompactList}\small\item\em Create an image of the specified size and type.\item\end{CompactList}\item
    3316 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Subset} ({\bf ps\-Image} $\ast$image, int nx, int ny, int x0, int y0)
    3317 \begin{CompactList}\small\item\em Create a subimage of the specified area.\item\end{CompactList}\item
    3318 void {\bf ps\-Image\-Free} ({\bf ps\-Image} $\ast$image)
    3319 \begin{CompactList}\small\item\em Destroy the specified image (destroy children if they exist).\item\end{CompactList}\item
    3320 int {\bf ps\-Image\-Free\-Children} ({\bf ps\-Image} $\ast$image)
    3321 \begin{CompactList}\small\item\em Destroy the children of the specified image.\item\end{CompactList}\item
    3322 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Copy} ({\bf ps\-Image} $\ast$output, {\bf ps\-Image} $\ast$input)
    3323 \begin{CompactList}\small\item\em Create a copy of the specified image.\item\end{CompactList}\item
    3324 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Image\-Slice} ({\bf ps\-Image} $\ast$input, int x, int y, int nx, int ny, int direction, {\bf ps\-Stats} $\ast$stats)
    3325 \begin{CompactList}\small\item\em Extract pixels from rectlinear region to a vector.\item\end{CompactList}\item
    3326 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Image\-Cut} ({\bf ps\-Image} $\ast$input, float xs, float ys, float xe, float ye, float dw, {\bf ps\-Stats} $\ast$stats)
    3327 \begin{CompactList}\small\item\em Extract pixels along a line to a vector.\item\end{CompactList}\item
    3328 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Image\-Radial\-Cut} ({\bf ps\-Image} $\ast$input, float x, float y, float radius, float dr, {\bf ps\-Stats} $\ast$stats)
    3329 \begin{CompactList}\small\item\em Extract radial annulii data to a vector.\item\end{CompactList}\item
    3330 {\bf ps\-Float\-Array} $\ast$ {\bf ps\-Image\-Contour} ({\bf ps\-Image} $\ast$input, float threshold, int binning)
    3331 \begin{CompactList}\small\item\em Extract a 2-d contour from an image at the given threshold.\item\end{CompactList}\item
    3332 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Rebin} ({\bf ps\-Image} $\ast$input, float scale, {\bf ps\-Stats} $\ast$stats)
    3333 \begin{CompactList}\small\item\em Rebin image to new scale.\item\end{CompactList}\item
    3334 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Rotate} ({\bf ps\-Image} $\ast$input, float angle)
    3335 \begin{CompactList}\small\item\em Rotate image by given angle.\item\end{CompactList}\item
    3336 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Shift} ({\bf ps\-Image} $\ast$input, float dx, float dy, float exposed)
    3337 \begin{CompactList}\small\item\em Shift image by an arbitrary number of pixels in either direction.\item\end{CompactList}\item
    3338 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Roll} ({\bf ps\-Image} $\ast$input, int dx, int dy)
    3339 \begin{CompactList}\small\item\em Roll image by an integer number of pixels in either direction.\item\end{CompactList}\item
    3340 {\bf ps\-Stats} $\ast$ {\bf ps\-Image\-Get\-Stats} ({\bf ps\-Image} $\ast$input, {\bf ps\-Stats} $\ast$stats)
    3341 \begin{CompactList}\small\item\em defines statistics to be calculated\item\end{CompactList}\item
    3342 {\bf ps\-Histogram} $\ast$ {\bf ps\-Image\-Histogram} ({\bf ps\-Histogram} $\ast$hist, {\bf ps\-Image} $\ast$input)
    3343 \begin{CompactList}\small\item\em Construct a histogram from an image (or subimage).\item\end{CompactList}\item
    3344 {\bf ps\-Polynomial2D} $\ast$ {\bf ps\-Image\-Fit\-Polynomial} ({\bf ps\-Image} $\ast$input, {\bf ps\-Polynomial2D} $\ast$coeffs)
    3345 \begin{CompactList}\small\item\em Fit a 2-D polynomial surface to an image.\item\end{CompactList}\item
    3346 int {\bf ps\-Image\-Eval\-Polynomial} ({\bf ps\-Image} $\ast$input, {\bf ps\-Polynomial2D} $\ast$coeffs)
    3347 \begin{CompactList}\small\item\em Evaluate a 2-D polynomial surface to image pixels.\item\end{CompactList}\item
    3348 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Read\-Section} ({\bf ps\-Image} $\ast$output, int x, int y, int dx, int dy, int z, char $\ast$extname, char $\ast$filename)
    3349 \begin{CompactList}\small\item\em Read an image or subimage from a named file.\item\end{CompactList}\item
    3350 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-FRead\-Section} ({\bf ps\-Image} $\ast$output, int x, int y, int dx, int dy, int z, char $\ast$extname, FILE $\ast$f)
    3351 \begin{CompactList}\small\item\em Read an image or subimage from file descriptor.\item\end{CompactList}\item
    3352 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Write\-Section} ({\bf ps\-Image} $\ast$input, int x, int y, int z, char $\ast$extname, char $\ast$filename)
    3353 \begin{CompactList}\small\item\em Write an image section to named file (which may exist).\item\end{CompactList}\item
    3354 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-FWrite\-Section} ({\bf ps\-Image} $\ast$input, int x, int y, int z, char $\ast$extname, FILE $\ast$f)
    3355 \begin{CompactList}\small\item\em Write an image section to named file (which may exist).\item\end{CompactList}\item
    3356 ps\-Metadata $\ast$ {\bf ps\-Image\-Read\-Header} (struct ps\-Metadata $\ast$output, char $\ast$extname, char $\ast$filename)
    3357 \begin{CompactList}\small\item\em Read only header from image file.\item\end{CompactList}\item
    3358 ps\-Metadata $\ast$ {\bf ps\-Image\-FRead\-Header} (struct ps\-Metadata $\ast$output, char $\ast$extname, FILE $\ast$f)
    3359 \begin{CompactList}\small\item\em Read only header from image file descriptor.\item\end{CompactList}\item
    3360 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-FFT} ({\bf ps\-Image} $\ast$input, int direction)
    3361 \begin{CompactList}\small\item\em Perform an FFT on the image.\item\end{CompactList}\item
    3362 int {\bf ps\-Image\-Clip} ({\bf ps\-Image} $\ast$input, float min, float vmin, float max, float vmax)
    3363 \begin{CompactList}\small\item\em Clip image values outside of range to given values.\item\end{CompactList}\item
    3364 int {\bf ps\-Image\-Clip\-Na\-N} ({\bf ps\-Image} $\ast$input, float value)
    3365 \begin{CompactList}\small\item\em Clip Na\-N image pixels to given value.\item\end{CompactList}\item
    3366 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Binary\-Op} ({\bf ps\-Image} $\ast$out, {\bf ps\-Image} $\ast$in1, char $\ast$operator, {\bf ps\-Image} $\ast$in2)
    3367 \begin{CompactList}\small\item\em Perform a binary operation on two images.\item\end{CompactList}\item
    3368 {\bf ps\-Image} $\ast$ {\bf ps\-Image\-Unary\-Op} ({\bf ps\-Image} $\ast$out, {\bf ps\-Image} $\ast$in1, char $\ast$operator)
    3369 \begin{CompactList}\small\item\em Perform a unary operation on an image.\item\end{CompactList}\item
    3370 int {\bf ps\-Image\-Overlay\-Section} ({\bf ps\-Image} $\ast$image, {\bf ps\-Image} $\ast$overlay, int x0, int y0, char $\ast$operator)
    3371 \begin{CompactList}\small\item\em Overlay subregion of image with another image.\item\end{CompactList}\item
    3372 {\bf ps\-Meta\-Data\-Item} $\ast$ {\bf ps\-Meta\-Data\-Item\-Alloc} (int type\-Flags, const void $\ast$val, const char $\ast$comment, const char $\ast$name,...)
    3373 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3374 void {\bf ps\-Meta\-Data\-Item\-Free} ({\bf ps\-Meta\-Data\-Item} $\ast$ms)
    3375 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3376 {\bf ps\-Meta\-Data\-Set} $\ast$ {\bf ps\-Meta\-Data\-Set\-Alloc} (void)
    3377 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item
    3378 void {\bf ps\-Meta\-Data\-Set\-Free} ({\bf ps\-Meta\-Data\-Set} $\ast$ms)
    3379 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item
    3380 {\bf ps\-Meta\-Data\-Item} $\ast$ {\bf ps\-Meta\-Data\-Append} ({\bf ps\-Meta\-Data\-Set} $\ast$restrict ms, {\bf ps\-Meta\-Data\-Item} $\ast$restrict item)
    3381 \item
    3382 {\bf ps\-Meta\-Data\-Item} $\ast$ {\bf ps\-Meta\-Data\-Remove} ({\bf ps\-Meta\-Data\-Set} $\ast$restrict ms, const char $\ast$restrict key)
    3383 \item
    3384 void {\bf ps\-Meta\-Data\-Set\-Iterator} ({\bf ps\-Meta\-Data\-Set} $\ast$ms)
    3385 \item
    3386 {\bf ps\-Meta\-Data\-Item} $\ast$ {\bf ps\-Meta\-Data\-Get\-Next} ({\bf ps\-Meta\-Data\-Set} $\ast$restrict ms, const char $\ast$restrict match)
    3387 \item
    3388 {\bf ps\-Meta\-Data\-Item} $\ast$ {\bf ps\-Meta\-Data\-Lookup} (const {\bf ps\-Meta\-Data\-Set} $\ast$restrict ms, const char $\ast$restrict key)
    3389 \item
    3390 void {\bf ps\-Meta\-Data\-Item\-Print} (FILE $\ast$fd, const {\bf ps\-Meta\-Data\-Item} $\ast$restrict ms, const char $\ast$prefix)
    3391 \item
    3392 {\bf ps\-Coord} $\ast$ {\bf ps\-Coord\-Xform\-Apply} ({\bf ps\-Coord\-Xform} $\ast$frame, {\bf ps\-Coord} $\ast$coords)
    3393 \begin{CompactList}\small\item\em apply the coordinate transformation to the given coordinate\item\end{CompactList}\item
    3394 {\bf ps\-Coord} $\ast$ {\bf ps\-Distortion\-Apply} ({\bf ps\-Distortion} $\ast$pattern, {\bf ps\-Coord} $\ast$coords, float mag, float color)
    3395 \begin{CompactList}\small\item\em apply the optical distortion to the given coordinate, magnitude, color\item\end{CompactList}\item
    3396 {\bf ps\-Coord} $\ast$ {\bf ps\-Get\-Offset} (const {\bf ps\-Coord} $\ast$restrict position1, const {\bf ps\-Coord} $\ast$restrict position2, char $\ast$system)
    3397 \begin{CompactList}\small\item\em Get offset (RA,Dec) on the sky between two positions position1 and position2 may not be identical.\item\end{CompactList}\item
    3398 {\bf ps\-Coord} $\ast$ {\bf ps\-Apply\-Offset} (const {\bf ps\-Coord} $\ast$restrict position, const {\bf ps\-Coord} $\ast$restrict offset, char $\ast$system)
    3399 \begin{CompactList}\small\item\em Apply an offset to a position.\item\end{CompactList}\item
    3400 {\bf ps\-Coord} $\ast$ {\bf ps\-Get\-Sun\-Pos} (float mjd)
    3401 \begin{CompactList}\small\item\em Get Sun Position.\item\end{CompactList}\item
    3402 {\bf ps\-Coord} $\ast$ {\bf ps\-Get\-Moon\-Pos} (float mjd, double latitude, double longitude)
    3403 \begin{CompactList}\small\item\em Get Moon position.\item\end{CompactList}\item
    3404 float {\bf ps\-Get\-Moon\-Phase} (float mjd)
    3405 \begin{CompactList}\small\item\em Get Moon phase.\item\end{CompactList}\item
    3406 {\bf ps\-Coord} $\ast$ {\bf ps\-Get\-Solar\-System\-Pos} (char $\ast$solar\-System\-Object, float mjd)
    3407 \begin{CompactList}\small\item\em Get Planet positions.\item\end{CompactList}\item
    3408 {\bf ps\-Coord} $\ast$ {\bf ps\-Coordinates\-Ito\-E} (const {\bf ps\-Coord} $\ast$restrict coordinates)
    3409 \begin{CompactList}\small\item\em Convert ICRS to Ecliptic.\item\end{CompactList}\item
    3410 {\bf ps\-Coord} $\ast$ {\bf ps\-Coordinates\-Eto\-I} (const {\bf ps\-Coord} $\ast$restrict coordinates)
    3411 \begin{CompactList}\small\item\em Convert Ecliptic to ICRS.\item\end{CompactList}\item
    3412 {\bf ps\-Coord} $\ast$ {\bf ps\-Coordinates\-Ito\-G} (const {\bf ps\-Coord} $\ast$restrict coordinates)
    3413 \begin{CompactList}\small\item\em Convert ICRS to Galactic.\item\end{CompactList}\item
    3414 {\bf ps\-Coord} $\ast$ {\bf ps\-Coordinates\-Gto\-I} (const {\bf ps\-Coord} $\ast$restrict coordinates)
    3415 \begin{CompactList}\small\item\em Convert Galactic to ICRS.\item\end{CompactList}\end{CompactItemize}
    3416 
     3021\input{psAstroGroup.tex}
    34173022
    34183023\bibliographystyle{plain} \bibliography{panstarrs}
Note: See TracChangeset for help on using the changeset viewer.