Index: trunk/doc/pslib/psMathGroup.tex
===================================================================
--- trunk/doc/pslib/psMathGroup.tex	(revision 381)
+++ trunk/doc/pslib/psMathGroup.tex	(revision 747)
@@ -1,38 +1,40 @@
 \begin{CompactItemize}
 \item 
-{\bf ps\-Bit\-Mask} $\ast$ {\bf ps\-Bit\-Mask\-Alloc} (int n)
+{\bf ps\-Bitset} $\ast$ {\bf ps\-Bitset\-Alloc} (int n)
 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item 
-void {\bf ps\-Bit\-Mask\-Free} ({\bf ps\-Bit\-Mask} $\ast$restrict my\-Mask)
+void {\bf ps\-Bitset\-Free} ({\bf ps\-Bitset} $\ast$restrict my\-Bits)
 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item 
-{\bf ps\-Bit\-Mask} $\ast$ {\bf ps\-Bit\-Mask\-Set} ({\bf ps\-Bit\-Mask} $\ast$my\-Mask, int bit)
-\begin{CompactList}\small\item\em Set a bit mask.\item\end{CompactList}\item 
-int {\bf ps\-Bit\-Mask\-Test} (const {\bf ps\-Bit\-Mask} $\ast$check\-Mask, int bit)
-\begin{CompactList}\small\item\em Check a bit mask.\item\end{CompactList}\item 
-{\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)
-\begin{CompactList}\small\item\em apply the given operator to two bit masks\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTAlloc} ({\bf ps\-Image} $\ast$image)
-\begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTAlloc1D} (const {\bf ps\-Float\-Array} $\ast$arr)
-\begin{CompactList}\small\item\em Constructor for 1D case.\item\end{CompactList}\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-FFTFree} ({\bf ps\-Image} $\ast$out, {\bf ps\-FFT} $\ast$restrict fft)
-\begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTForward} ({\bf ps\-FFT} $\ast$fft)
-\begin{CompactList}\small\item\em Forward FFT: from real to fourier space.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTReverse} ({\bf ps\-FFT} $\ast$fft)
-\begin{CompactList}\small\item\em Reverse FFT: from fourier to real space.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTFilter} ({\bf ps\-FFT} $\ast$fft, float($\ast$filter\-Func)(int kx, int ky))
-\begin{CompactList}\small\item\em Apply filter function in fourier space.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTFilter\-Complex} ({\bf ps\-FFT} $\ast$fft, float($\ast$real\-Filter\-Func)(int kx, int ky), float($\ast$imag\-Filter\-Func)(int kx, int ky))
-\begin{CompactList}\small\item\em Apply complex filter function.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTCross\-Correlate} ({\bf ps\-FFT} $\ast$out const {\bf ps\-FFT} $\ast$fft1, const {\bf ps\-FFT} $\ast$fft2)
-\begin{CompactList}\small\item\em Calculate FFT of the cross-correlation.\item\end{CompactList}\item 
-{\bf ps\-FFT} $\ast$ {\bf ps\-FFTConvolve} ({\bf ps\-FFT} $\ast$out, const {\bf ps\-FFT} $\ast$fft1, const {\bf ps\-FFT} $\ast$fft2)
-\begin{CompactList}\small\item\em Calculate FFT of the convolution.\item\end{CompactList}\item 
-{\bf ps\-Float\-Array} $\ast$ {\bf ps\-FFTPower\-Spec} ({\bf ps\-FFT} $\ast$fft)
-\begin{CompactList}\small\item\em Calculate power spectrum.\item\end{CompactList}\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-FFTGet\-Image} ({\bf ps\-Image} $\ast$out, const {\bf ps\-FFT} $\ast$fft)
-\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-FFTGet\-FT} ({\bf ps\-Image} $\ast$out, const {\bf ps\-FFT} $\ast$fft)
-\begin{CompactList}\small\item\em Convert the Fourier transform data in the FFT struct to an image of complex numbers.\item\end{CompactList}\item 
+{\bf ps\-Bitset} $\ast$ {\bf ps\-Bitset\-Set} ({\bf ps\-Bitset} $\ast$restrict my\-Bits, int bit)
+\begin{CompactList}\small\item\em Set a bitset.\item\end{CompactList}\item 
+int {\bf ps\-Bitset\-Test} (const {\bf ps\-Bitset} $\ast$restrict check\-Bits, int bit)
+\begin{CompactList}\small\item\em Check a bitset.\item\end{CompactList}\item 
+{\bf ps\-Bitset} $\ast$ {\bf ps\-Bitset\-Op} ({\bf ps\-Bitset} $\ast$out\-Bits, const {\bf ps\-Bitset} $\ast$restrict in\-Bits1, char $\ast$operator, const {\bf ps\-Bitset} $\ast$restrict in\-Bits2)
+\begin{CompactList}\small\item\em apply the given operator to two bitsets\item\end{CompactList}\item 
+{\bf ps\-Bitset} $\ast$ {\bf ps\-Bitset\-Not} ({\bf ps\-Bitset} $\ast$out, {\bf ps\-Bitset} $\ast$in)
+\begin{CompactList}\small\item\em Apply unary NOT to a bitset.\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Vector\-FFT} (const {\bf ps\-Vector} $\ast$vector) int dir)
+\begin{CompactList}\small\item\em $<$ FFT direction (1: forward, -1: reverse)\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Vector\-Power\-Spectrum} (const {\bf ps\-Vector} $\ast$vector)
+\begin{CompactList}\small\item\em Calculate power spectrum of a vector of floating-point numbers.\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Vector\-Real} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Vector} $\ast$in)
+\begin{CompactList}\small\item\em Get the real part of a vector.\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Vector\-Imaginary} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Vector} $\ast$in)
+\begin{CompactList}\small\item\em Get the imaginary part of a vector.\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Vector\-Complex} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Vector} $\ast$real) const {\bf ps\-Vector} $\ast$imag)
+\begin{CompactList}\small\item\em $<$ imaginary part of vector\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Vector\-Conjugate} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Vector} $\ast$in)
+\begin{CompactList}\small\item\em Get the complex conjugate of an vector of complex floating-point numbers.\item\end{CompactList}\item 
+{\bf ps\-Image} $\ast$ {\bf ps\-Image\-FFT} (const {\bf ps\-Image} $\ast$image, int dir)
+\begin{CompactList}\small\item\em FFT an image.\item\end{CompactList}\item 
+{\bf ps\-Image} $\ast$ {\bf ps\-Image\-Power\-Spectrum} (const {\bf ps\-Image} $\ast$image)
+\begin{CompactList}\small\item\em Calculate power spectrum of an image.\item\end{CompactList}\item 
+{\bf ps\-Image} $\ast$ {\bf ps\-Image\-Real} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$in)
+\begin{CompactList}\small\item\em Get the real part of an image.\item\end{CompactList}\item 
+{\bf ps\-Image} $\ast$ {\bf ps\-Image\-Imaginary} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$in)
+\begin{CompactList}\small\item\em Get the imaginary part of an image.\item\end{CompactList}\item 
+{\bf ps\-Image} $\ast$ {\bf ps\-Image\-Complex} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$real, const {\bf ps\-Image} $\ast$imag)
+\begin{CompactList}\small\item\em Construct a complex image from real \& imaginary parts.\item\end{CompactList}\item 
+{\bf ps\-Image} $\ast$ {\bf ps\-Image\-Conjugate} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$in)
+\begin{CompactList}\small\item\em Get the complex conjugate of an image.\item\end{CompactList}\item 
 {\bf ps\-Polynomial1D} $\ast$ {\bf ps\-Polynomial1DAlloc} (int n)
 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item 
@@ -51,11 +53,11 @@
 void {\bf ps\-Polynomial4DFree} ({\bf ps\-Polynomial4D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item 
-float {\bf ps\-Eval\-Polynomial1D} (float x, const {\bf ps\-Polynomial1D} $\ast$restrict my\-Poly)
+float {\bf ps\-Polynomial1DEval} (float x, const {\bf ps\-Polynomial1D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 1D polynomial.\item\end{CompactList}\item 
-float {\bf ps\-Eval\-Polynomial2D} (float x, float y, const {\bf ps\-Polynomial2D} $\ast$restrict my\-Poly)
+float {\bf ps\-Polynomial2DEval} (float x, float y, const {\bf ps\-Polynomial2D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 2D polynomial.\item\end{CompactList}\item 
-float {\bf ps\-Eval\-Polynomial3D} (float x, float y, float z, const {\bf ps\-Polynomial3D} $\ast$restrict my\-Poly)
+float {\bf ps\-Polynomial3DEval} (float x, float y, float z, const {\bf ps\-Polynomial3D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 3D polynomial.\item\end{CompactList}\item 
-float {\bf ps\-Eval\-Polynomial4D} (float w, float x, float y, float z, const {\bf ps\-Polynomial4D} $\ast$restrict my\-Poly)
+float {\bf ps\-Polynomial4DEval} (float w, float x, float y, float z, const {\bf ps\-Polynomial4D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 4D polynomial.\item\end{CompactList}\item 
 {\bf ps\-DPolynomial1D} $\ast$ {\bf ps\-DPolynomial1DAlloc} (int n)
@@ -75,16 +77,16 @@
 void {\bf ps\-DPolynomial4DFree} ({\bf ps\-DPolynomial4D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item 
-double {\bf ps\-Eval\-DPolynomial1D} (double x, const {\bf ps\-DPolynomial1D} $\ast$restrict my\-Poly)
+double {\bf ps\-DPolynomial1DEval} (double x, const {\bf ps\-DPolynomial1D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 1D polynomial (double precision).\item\end{CompactList}\item 
-double {\bf ps\-Eval\-DPolynomial2D} (double x, double y, const {\bf ps\-DPolynomial2D} $\ast$restrict my\-Poly)
+double {\bf ps\-DPolynomial2DEval} (double x, double y, const {\bf ps\-DPolynomial2D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 2D polynomial (double precision).\item\end{CompactList}\item 
-double {\bf ps\-Eval\-DPolynomial3D} (double x, double y, double z, const {\bf ps\-DPolynomial3D} $\ast$restrict my\-Poly)
+double {\bf ps\-DPolynomial3DEval} (double x, double y, double z, const {\bf ps\-DPolynomial3D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 3D polynomial (double precision).\item\end{CompactList}\item 
-double {\bf ps\-Eval\-DPolynomial4D} (double w, double x, double y, double z, const {\bf ps\-DPolynomial4D} $\ast$restrict my\-Poly)
+double {\bf ps\-DPolynomial4DEval} (double w, double x, double y, double z, const {\bf ps\-DPolynomial4D} $\ast$restrict my\-Poly)
 \begin{CompactList}\small\item\em Evaluate 4D polynomial (double precision).\item\end{CompactList}\item 
 {\bf ps\-Type} $\ast$ {\bf ps\-Binary\-Op} (void $\ast$out, void $\ast$in1, char $\ast$op, void $\ast$in2)
-\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 
+\begin{CompactList}\small\item\em Perform a binary operation on two data items ({\bf ps\-Image} {\rm (p.\,\pageref{structpsImage})}, {\bf ps\-Vector} {\rm (p.\,\pageref{structpsVector})}, ps\-Scalar).\item\end{CompactList}\item 
 {\bf ps\-Type} $\ast$ {\bf ps\-Unary\-Op} (void $\ast$out, void $\ast$in, char $\ast$op)
-\begin{CompactList}\small\item\em Perform a unary operation on two data items ({\bf ps\-Image} {\rm (p.\,\pageref{structpsImage})}, ps\-Vector, ps\-Scalar).\item\end{CompactList}\item 
+\begin{CompactList}\small\item\em Perform a unary operation on two data items ({\bf ps\-Image} {\rm (p.\,\pageref{structpsImage})}, {\bf ps\-Vector} {\rm (p.\,\pageref{structpsVector})}, ps\-Scalar).\item\end{CompactList}\item 
 {\bf p\_\-ps\-Scalar} $\ast$ {\bf ps\-Scalar} (double value)
 \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 
@@ -95,34 +97,36 @@
 float {\bf ps\-Matrix\-Determinant} (const {\bf ps\-Image} $\ast$restrict my\-Matrix)
 \begin{CompactList}\small\item\em Matrix determinant.\item\end{CompactList}\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-Matrix\-Op} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$matrix1, const char $\ast$op, const {\bf ps\-Image} $\ast$matrix2)
+{\bf ps\-Image} $\ast$ {\bf ps\-Matrix\-Multiply} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$in1, const {\bf ps\-Image} $\ast$in2)
 \begin{CompactList}\small\item\em Matrix operation: addition, subtraction, multiplication.\item\end{CompactList}\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-Matrix\-Transpose} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$my\-Matrix)
+{\bf ps\-Image} $\ast$ {\bf ps\-Matrix\-Transpose} ({\bf ps\-Image} $\ast$out, const {\bf ps\-Image} $\ast$in)
 \begin{CompactList}\small\item\em Transpose Matrix.\item\end{CompactList}\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-Matrix\-LUD} ({\bf ps\-Image} $\ast$out, {\bf ps\-Image} $\ast$my\-Matrix)
+{\bf ps\-Image} $\ast$ {\bf ps\-Matrix\-LUD} ({\bf ps\-Image} $\ast$out, {\bf ps\-Image} $\ast$in)
 \begin{CompactList}\small\item\em LU Decomposition of a matrix.\item\end{CompactList}\item 
-{\bf ps\-Vector} $\ast$ {\bf ps\-Matrix\-LUSolve} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Image} $\ast$lu\-Matrix, const {\bf ps\-Vector} $\ast$rhs\-Vector)
+{\bf ps\-Vector} $\ast$ {\bf ps\-Matrix\-LUSolve} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Image} $\ast$LU, const {\bf ps\-Vector} $\ast$RHS)
 \begin{CompactList}\small\item\em LU Solution.\item\end{CompactList}\item 
-{\bf ps\-Vector} $\ast$ {\bf ps\-Matrix\-To\-Vector} ({\bf ps\-Vector} $\ast$out, {\bf ps\-Image} $\ast$my\-Matrix)
+{\bf ps\-Vector} $\ast$ {\bf ps\-Matrix\-Eigenvectors} ({\bf ps\-Image} $\ast$my\-Matrix)
+\begin{CompactList}\small\item\em Eigenvectors of a matrix.\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Matrix\-To\-Vector} ({\bf ps\-Vector} $\ast$out, {\bf ps\-Image} $\ast$in)
 \begin{CompactList}\small\item\em Convert matrix to vector.\item\end{CompactList}\item 
-{\bf ps\-Image} $\ast$ {\bf ps\-Vector\-To\-Matrix} ({\bf ps\-Image} $\ast$out, {\bf ps\-Vector} $\ast$my\-Vector)
+{\bf ps\-Image} $\ast$ {\bf ps\-Vector\-To\-Matrix} ({\bf ps\-Image} $\ast$out, {\bf ps\-Vector} $\ast$in)
 \begin{CompactList}\small\item\em Convert vector to matrix.\item\end{CompactList}\item 
-{\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, {\bf ps\-Int\-Array} $\ast$restrict param\-Mask)
-\begin{CompactList}\small\item\em Minimize a particular non-linear function.\item\end{CompactList}\item 
-{\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 param\-Mask)
+{\bf ps\-Vector} $\ast$ {\bf ps\-Minimize} ({\bf ps\-Vector} $\ast$restrict initial\-Guess, float($\ast$my\-Function)(const {\bf ps\-Vector} $\ast$restrict, const {\bf ps\-Vector} $\ast$restrict), float($\ast$my\-Func\-Deriv)(const {\bf ps\-Vector} $\ast$restrict, const {\bf ps\-Vector} $\ast$restrict), const {\bf ps\-Vector} $\ast$restrict param\-Mask)
+\begin{CompactList}\small\item\em Find the minimum of a particular non-linear function.\item\end{CompactList}\item 
+{\bf ps\-Vector} $\ast$ {\bf ps\-Minimize\-Chi2} ({\bf ps\-Vector} $\ast$restrict initial\-Guess, float($\ast$eval\-Model)(const {\bf ps\-Vector} $\ast$restrict, const {\bf ps\-Vector} $\ast$restrict), const {\bf ps\-Vector} $\ast$restrict domain, const {\bf ps\-Vector} $\ast$restrict data, const {\bf ps\-Vector} $\ast$restrict errors, const {\bf ps\-Vector} $\ast$restrict param\-Mask, float Chi\-Sq)
 \begin{CompactList}\small\item\em Minimize chi$^\wedge$2 for input data.\item\end{CompactList}\item 
-{\bf ps\-Polynomial1D} $\ast$ {\bf ps\-Get\-Array\-Polynomial} ({\bf ps\-Polynomial1D} my\-Poly, const {\bf ps\-Float\-Array} $\ast$restrict x, const {\bf ps\-Float\-Array} $\ast$restrict y, const {\bf ps\-Float\-Array} $\ast$restrict y\-Err)
+{\bf ps\-Polynomial1D} $\ast$ {\bf ps\-Vector\-Fit\-Polynomial} ({\bf ps\-Polynomial1D} my\-Poly, const {\bf ps\-Vector} $\ast$restrict x, const {\bf ps\-Vector} $\ast$restrict y, const {\bf ps\-Vector} $\ast$restrict y\-Err)
 \begin{CompactList}\small\item\em Derive a polynomial fit by chi$^\wedge$2 minimisation --- can be done analytically.\item\end{CompactList}\item 
-{\bf ps\-Float\-Array} $\ast$ {\bf ps\-Sort} ({\bf ps\-Float\-Array} $\ast$out, const {\bf ps\-Float\-Array} $\ast$my\-Array)
+{\bf ps\-Vector} $\ast$ {\bf ps\-Sort} ({\bf ps\-Vector} $\ast$out, const {\bf ps\-Vector} $\ast$restrict in)
 \begin{CompactList}\small\item\em Sort an array.\item\end{CompactList}\item 
-{\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)
+{\bf ps\-Vector} $\ast$ {\bf ps\-Sort\-Index} ({\bf ps\-Vector} $\ast$restrict out, const {\bf ps\-Vector} $\ast$restrict in)
 \begin{CompactList}\small\item\em Sort an array, along with some other stuff.\item\end{CompactList}\item 
-{\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)
-\begin{CompactList}\small\item\em Do Statistics on an array.\item\end{CompactList}\item 
-{\bf ps\-Histogram} $\ast$ {\bf ps\-Histogram\-Alloc} (float lower, float upper, float size)
+{\bf ps\-Stats} $\ast$ {\bf ps\-Vector\-Stats} ({\bf ps\-Stats} $\ast$stats, const {\bf ps\-Vector} $\ast$restrict my\-Array, const {\bf ps\-Vector} $\ast$restrict mask\-Array, unsigned int mask\-Val)
+\begin{CompactList}\small\item\em Do Statistics on a vector.\item\end{CompactList}\item 
+{\bf ps\-Histogram} $\ast$ {\bf ps\-Histogram\-Alloc} (float lower, float upper, int n)
 \begin{CompactList}\small\item\em Constructor.\item\end{CompactList}\item 
-{\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)
+{\bf ps\-Histogram} $\ast$ {\bf ps\-Histogram\-Alloc\-Generic} (const {\bf ps\-Vector} $\ast$restrict bounds)
 \begin{CompactList}\small\item\em Generic constructor.\item\end{CompactList}\item 
 void {\bf ps\-Histogram\-Free} ({\bf ps\-Histogram} $\ast$restrict my\-Hist)
 \begin{CompactList}\small\item\em Destructor.\item\end{CompactList}\item 
-{\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)
+{\bf ps\-Histogram} $\ast$ {\bf ps\-Histogram\-Vector} ({\bf ps\-Histogram} $\ast$restrict my\-Hist, const {\bf ps\-Vector} $\ast$restrict my\-Array)
 \begin{CompactList}\small\item\em Calculate a histogram.\item\end{CompactList}\end{CompactItemize}