\section{AMatrix  Class Reference}
\label{class_AMatrix}\index{AMatrix@{AMatrix}}
{\tt \#include $<$amatrix.h$>$}

Collaboration diagram for AMatrix:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=116pt]{class_AMatrix_coll_graph}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
enum {\bf init\_\-type} \{ {\bf garbage} = -1, 
{\bf zero} = 0, 
{\bf ident}, 
{\bf rand}
 \}
\item 
enum {\bf coord\_\-type} \{ {\bf rect\_\-c} = 0, 
{\bf spher\_\-c}, 
{\bf polar\_\-c} = spher\_\-c, 
{\bf spher2\_\-c}, 
{\bf polar2\_\-c} = spher2\_\-c, 
{\bf cyl\_\-c}, 
{\bf cyl2\_\-c}
 \}
\end{CompactItemize}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
{\bf AMatrix} ()
\item 
{\bf AMatrix} (int r, int c, double d)
\item 
{\bf AMatrix} (int r, int c, {\bf init\_\-type} which=garbage)
\item 
{\bf AMatrix} (const AMatrix \&m)
\item 
{\bf $\sim$AMatrix} ()
\item 
const AMatrix\& {\bf operator=} (const AMatrix \&)
\item 
AMatrix {\bf Unique\-Copy} () const
\item 
AMatrix {\bf Inverse} () const
\item 
AMatrix {\bf SVD\_\-U} () const
\item 
AMatrix {\bf SVD\_\-W} () const
\item 
AMatrix {\bf SVD\_\-Diag\-W} () const
\item 
AMatrix {\bf SVD\_\-V} () const
\item 
AMatrix {\bf SVDInverse} () const
\item 
AMatrix {\bf SVD\_\-Fit} (int num\_\-funcs, void($\ast$funcer)(double x, double $\ast$dest, int nf), double \&chisq) const
\item 
AMatrix {\bf GJSolve} (const AMatrix \&b) const
\item 
AMatrix {\bf GJInverse} () const
\item 
AMatrix {\bf Linear\-Solve} (const AMatrix \&b) const
\item 
AMatrix {\bf Transpose} () const
\item 
double\& {\bf operator()} (int r, int c)
\item 
double {\bf operator()} (int r, int c) const
\item 
double\& {\bf operator()} (int r)
\item 
double {\bf operator()} (int r) const
\item 
double\& {\bf operator[$\,$]} (int c)
\item 
double {\bf operator[$\,$]} (int c) const
\item 
int {\bf Rows} () const
\item 
int {\bf Cols} () const
\item 
int {\bf Compare} (const AMatrix \&m) const
\item 
bool {\bf operator==} (const AMatrix \&m) const
\item 
bool {\bf operator!=} (const AMatrix \&m) const
\item 
bool {\bf operator$<$} (const AMatrix \&m) const
\item 
bool {\bf operator$>$} (const AMatrix \&m) const
\item 
bool {\bf operator$<$=} (const AMatrix \&m) const
\item 
bool {\bf operator$>$=} (const AMatrix \&m) const
\item 
bool {\bf Is\-Bad\-Matrix} () const
\item 
double {\bf Lp\_\-Distance} (AMatrix m, double p=0.0) const
\item 
double {\bf Lp\_\-Metric} (double p) const
\item 
double {\bf Lp\_\-Distance} (AMatrix m, double p, int minx, int maxx, int miny, int maxy) const
\item 
double {\bf Lp\_\-Metric} (double p, int minx, int maxx, int miny, int maxy) const
\item 
double {\bf Mod\-Lp\_\-Distance} (AMatrix m, AMatrix modulus, double p=0.0) const
\item 
double {\bf Mod\-Lp\_\-Metric} (AMatrix modulus, double p) const
\item 
double {\bf Mod\-Lp\_\-Distance} (AMatrix m, AMatrix modulus, double p, int minx, int maxx, int miny, int maxy) const
\item 
double {\bf Mod\-Lp\_\-Metric} (AMatrix modulus, double p, int minx, int maxx, int miny, int maxy) const
\item 
const AMatrix\& {\bf operator+=} (double d)
\item 
const AMatrix\& {\bf operator-=} (double d)
\item 
const AMatrix\& {\bf operator $\ast$=} (double d)
\item 
const AMatrix\& {\bf operator/=} (double d)
\item 
AMatrix {\bf operator+} (double d) const
\item 
AMatrix {\bf operator-} (double d) const
\item 
AMatrix {\bf operator $\ast$} (double d) const
\item 
AMatrix {\bf operator/} (double d) const
\item 
const AMatrix\& {\bf operator+=} (const AMatrix \&m)
\item 
const AMatrix\& {\bf operator-=} (const AMatrix \&m)
\item 
const AMatrix\& {\bf operator $\ast$=} (const AMatrix \&m)
\item 
const AMatrix\& {\bf operator/=} (const AMatrix \&m)
\item 
AMatrix {\bf operator+} (const AMatrix \&m) const
\item 
AMatrix {\bf operator-} (const AMatrix \&m) const
\item 
AMatrix {\bf operator $\ast$} (const AMatrix \&m) const
\item 
AMatrix {\bf operator/} (const AMatrix \&m) const
\item 
AMatrix {\bf Filter} (double d={\bf epsilon}, double repl=0.0) const
\item 
AMatrix {\bf Mod\-Normalize} (AMatrix modulus) const
\item 
void {\bf Reset} () const
\item 
AMatrix {\bf Embed} (const AMatrix \&m, int r=1, int c=1)
\item 
AMatrix {\bf Submatrix} (int r, int c, int rlen, int clen) const
\item 
AMatrix {\bf Convert\-From\-Rect} ({\bf coord\_\-type} to) const
\item 
AMatrix {\bf Convert\-To\-Rect} ({\bf coord\_\-type} from) const
\item 
AMatrix {\bf Convert} ({\bf coord\_\-type} from, {\bf coord\_\-type} to) const
\end{CompactItemize}
\subsection*{Static Public Methods}
\begin{CompactItemize}
\item 
AMatrix {\bf Rotation\-Matrix} (int n, int a, int b, double rad)
\item 
void {\bf Set\_\-Begin\_\-Row} (const char $\ast$)
\item 
void {\bf Set\_\-End\_\-Row} (const char $\ast$)
\end{CompactItemize}
\subsection*{Static Public Attributes}
\begin{CompactItemize}
\item 
double {\bf epsilon}
\item 
char$\ast$ {\bf os\_\-begin\_\-row}
\item 
char$\ast$ {\bf os\_\-end\_\-row}
\end{CompactItemize}
\subsection*{Protected Methods}
\begin{CompactItemize}
\item 
void {\bf calculate\_\-gj\_\-inverse} () const
\item 
void {\bf calculate\_\-svd} () const
\item 
void {\bf mod} ()
\end{CompactItemize}
\subsection*{Static Protected Methods}
\begin{CompactItemize}
\item 
AMatrix {\bf Small\-Product} (const AMatrix \&m1, const AMatrix \&m2)
\item 
AMatrix {\bf Big\-Product} (const AMatrix \&m1, const AMatrix \&m2)
\item 
void {\bf converttorect} (const AMatrix \&, AMatrix \&, int, {\bf coord\_\-type})
\item 
void {\bf convertfromrect} (const AMatrix \&, AMatrix \&, int, {\bf coord\_\-type})
\end{CompactItemize}
\subsection*{Static Protected Attributes}
\begin{CompactItemize}
\item 
const int {\bf product\_\-threshold}
\item 
const AMatrix {\bf bad\_\-matrix}
\item 
double {\bf bad\_\-val}
\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
{\bf AMatrix\-Rep}$\ast$ {\bf the\_\-rep}
\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
AMatrix {\bf operator+} (double d, const AMatrix \&m)
\item 
AMatrix {\bf operator-} (double d, const AMatrix \&m)
\item 
AMatrix {\bf operator $\ast$} (double d, const AMatrix \&m)
\item 
AMatrix {\bf operator/} (double d, const AMatrix \&m)
\item 
ostream\& {\bf operator$<$$<$} (ostream \&os, const AMatrix \&m)
\item 
istream\& {\bf operator$>$$>$} (istream \&is, AMatrix \&m)
\item 
ostream\& {\bf operator$<$=} (ostream \&, const AMatrix \&)
\item 
istream\& {\bf operator$>$=} (istream \&, AMatrix \&)
\item 
ostream\& {\bf Output\-Binary} (ostream \&, const AMatrix \&)
\item 
istream\& {\bf Input\-Binary} (istream \&, AMatrix \&)
\end{CompactItemize}


\subsection{Member Enumeration Documentation}
\index{AMatrix@{AMatrix}!coord_type@{coord\_\-type}}
\index{coord_type@{coord\_\-type}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum AMatrix::coord\_\-type}\label{class_AMatrix_s12}


\begin{Desc}
\item[{\bf Enumeration values:}]\par
\begin{description}
\index{rect_c@{rect\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!rect_c@{rect\_\-c}}\item[
{\em rect\_\-c}\label{class_AMatrix_s12s4}
]\index{spher_c@{spher\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!spher_c@{spher\_\-c}}\item[
{\em spher\_\-c}\label{class_AMatrix_s12s5}
]\index{polar_c@{polar\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!polar_c@{polar\_\-c}}\item[
{\em polar\_\-c}\label{class_AMatrix_s12s6}
]\index{spher2_c@{spher2\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!spher2_c@{spher2\_\-c}}\item[
{\em spher2\_\-c}\label{class_AMatrix_s12s7}
]\index{polar2_c@{polar2\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!polar2_c@{polar2\_\-c}}\item[
{\em polar2\_\-c}\label{class_AMatrix_s12s8}
]\index{cyl_c@{cyl\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!cyl_c@{cyl\_\-c}}\item[
{\em cyl\_\-c}\label{class_AMatrix_s12s9}
]\index{cyl2_c@{cyl2\_\-c}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!cyl2_c@{cyl2\_\-c}}\item[
{\em cyl2\_\-c}\label{class_AMatrix_s12s10}
]\end{description}
\end{Desc}



Definition at line 68 of file amatrix.h.\footnotesize\begin{verbatim}00068                            {
00069                                 rect_c=0, spher_c, polar_c=spher_c,
00070 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!init_type@{init\_\-type}}
\index{init_type@{init\_\-type}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum AMatrix::init\_\-type}\label{class_AMatrix_s11}


\begin{Desc}
\item[{\bf Enumeration values:}]\par
\begin{description}
\index{garbage@{garbage}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!garbage@{garbage}}\item[
{\em garbage}\label{class_AMatrix_s11s0}
]\index{zero@{zero}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!zero@{zero}}\item[
{\em zero}\label{class_AMatrix_s11s1}
]\index{ident@{ident}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!ident@{ident}}\item[
{\em ident}\label{class_AMatrix_s11s2}
]\index{rand@{rand}!AMatrix@{AMatrix}}\index{AMatrix@{AMatrix}!rand@{rand}}\item[
{\em rand}\label{class_AMatrix_s11s3}
]\end{description}
\end{Desc}



Definition at line 67 of file amatrix.h.\footnotesize\begin{verbatim}00067                           { garbage=-1, zero=0, ident, rand }
00068 \end{verbatim}\normalsize 


\subsection{Constructor \& Destructor Documentation}
\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix::AMatrix ()\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a0}




Definition at line 56 of file amatrix.inc.\footnotesize\begin{verbatim}00057 {
00058         the_rep = new AMatrixRep;
00059 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix::AMatrix (int {\em r}, int {\em c}, double {\em d})}\label{class_AMatrix_a1}


\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix::AMatrix (int {\em r}, int {\em c}, {\bf init\_\-type} {\em which} = garbage)}\label{class_AMatrix_a2}


\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\index{AMatrix@{AMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix::AMatrix (const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a3}




Definition at line 60 of file amatrix.inc.\footnotesize\begin{verbatim}00061 {
00062         the_rep = m.the_rep;
00063         the_rep->Reference();
00064 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!~AMatrix@{$\sim$AMatrix}}
\index{~AMatrix@{$\sim$AMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix::$\sim$AMatrix ()\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a4}




Definition at line 66 of file amatrix.inc.\footnotesize\begin{verbatim}00067 {
00068         the_rep->Dereference();
00069         the_rep = 0;
00070 \end{verbatim}\normalsize 


\subsection{Member Function Documentation}
\index{AMatrix@{AMatrix}!BigProduct@{BigProduct}}
\index{BigProduct@{BigProduct}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Big\-Product (const AMatrix \& {\em m1}, const AMatrix \& {\em m2})\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_e1}




Referenced by operator $\ast$().\index{AMatrix@{AMatrix}!Cols@{Cols}}
\index{Cols@{Cols}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int AMatrix::Cols () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a25}




Definition at line 303 of file amatrix.h.

Referenced by Compare(), GJInverse(), operator $\ast$(), operator $\ast$=(), operator()(), operator/(), operator/=(), and operator[$\,$]().\footnotesize\begin{verbatim}00303                              { return the_rep->cols; }
00304 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!Compare@{Compare}}
\index{Compare@{Compare}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int AMatrix::Compare (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a26}




Definition at line 190 of file amatrix.inc.

Referenced by operator!=(), operator$<$(), operator$<$=(), operator==(), operator$>$(), and operator$>$=().\footnotesize\begin{verbatim}00191 {
00192         if (the_rep == m.the_rep)
00193                 return 0;
00194 
00195         if (Rows() > m.Rows())
00196                 return 1;
00197         else if (Rows() < m.Rows())
00198                 return -1;
00199 
00200         if (Cols() > m.Cols())
00201                 return 1;
00202         else if (Cols() < m.Cols())
00203                 return -1;
00204 
00205         for (int i=1; i<=the_rep->rows; ++i)
00206                 for (int j=1; j<=the_rep->cols; ++j)
00207                 {
00208                         if ( the_rep->operator()(i,j) > m.the_rep->operator()(i,j) )
00209                                 return 1;
00210                         else if ( the_rep->operator()(i,j) < m.the_rep->operator()(i,j) )
00211                                 return -1;
00212                 }
00213 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!Convert@{Convert}}
\index{Convert@{Convert}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Convert ({\bf coord\_\-type} {\em from}, {\bf coord\_\-type} {\em to}) const}\label{class_AMatrix_a65}


\index{AMatrix@{AMatrix}!ConvertFromRect@{ConvertFromRect}}
\index{ConvertFromRect@{ConvertFromRect}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Convert\-From\-Rect ({\bf coord\_\-type} {\em to}) const}\label{class_AMatrix_a63}


\index{AMatrix@{AMatrix}!ConvertToRect@{ConvertToRect}}
\index{ConvertToRect@{ConvertToRect}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Convert\-To\-Rect ({\bf coord\_\-type} {\em from}) const}\label{class_AMatrix_a64}


\index{AMatrix@{AMatrix}!Embed@{Embed}}
\index{Embed@{Embed}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Embed (const AMatrix \& {\em m}, int {\em r} = 1, int {\em c} = 1)}\label{class_AMatrix_a61}


\index{AMatrix@{AMatrix}!Filter@{Filter}}
\index{Filter@{Filter}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Filter (double {\em d} = {\bf epsilon}, double {\em repl} = 0.0) const}\label{class_AMatrix_a58}


\index{AMatrix@{AMatrix}!GJInverse@{GJInverse}}
\index{GJInverse@{GJInverse}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::GJInverse () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a15}




Definition at line 287 of file amatrix.inc.\footnotesize\begin{verbatim}00288 {
00289 #ifndef NOERRORCHECKING_MATRIX
00290         if (Rows() != Cols())
00291     {
00292 #       ifdef   DEBUG_MATRIX
00293         log << "Error: " << Rows() << 'x' << Cols() << " GJInverse" << endl;
00294 #       endif
00295         return bad_matrix;
00296     }
00297 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!GJSolve@{GJSolve}}
\index{GJSolve@{GJSolve}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::GJSolve (const AMatrix \& {\em b}) const}\label{class_AMatrix_a14}


\index{AMatrix@{AMatrix}!Inverse@{Inverse}}
\index{Inverse@{Inverse}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Inverse () const}\label{class_AMatrix_a7}




Referenced by operator/(), and operator/=().\index{AMatrix@{AMatrix}!IsBadMatrix@{IsBadMatrix}}
\index{IsBadMatrix@{IsBadMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::Is\-Bad\-Matrix () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a33}




Definition at line 184 of file amatrix.inc.\footnotesize\begin{verbatim}00185 {
00186         return (this->the_rep) == (bad_matrix.the_rep);
00187 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!LinearSolve@{LinearSolve}}
\index{LinearSolve@{LinearSolve}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Linear\-Solve (const AMatrix \& {\em b}) const}\label{class_AMatrix_a16}


\index{AMatrix@{AMatrix}!Lp_Distance@{Lp\_\-Distance}}
\index{Lp_Distance@{Lp\_\-Distance}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Lp\_\-Distance (AMatrix {\em m}, double {\em p}, int {\em minx}, int {\em maxx}, int {\em miny}, int {\em maxy}) const}\label{class_AMatrix_a36}


\index{AMatrix@{AMatrix}!Lp_Distance@{Lp\_\-Distance}}
\index{Lp_Distance@{Lp\_\-Distance}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Lp\_\-Distance (AMatrix {\em m}, double {\em p} = 0.0) const}\label{class_AMatrix_a34}


\index{AMatrix@{AMatrix}!Lp_Metric@{Lp\_\-Metric}}
\index{Lp_Metric@{Lp\_\-Metric}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Lp\_\-Metric (double {\em p}, int {\em minx}, int {\em maxx}, int {\em miny}, int {\em maxy}) const}\label{class_AMatrix_a37}


\index{AMatrix@{AMatrix}!Lp_Metric@{Lp\_\-Metric}}
\index{Lp_Metric@{Lp\_\-Metric}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Lp\_\-Metric (double {\em p}) const}\label{class_AMatrix_a35}


\index{AMatrix@{AMatrix}!ModLp_Distance@{ModLp\_\-Distance}}
\index{ModLp_Distance@{ModLp\_\-Distance}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Mod\-Lp\_\-Distance (AMatrix {\em m}, AMatrix {\em modulus}, double {\em p}, int {\em minx}, int {\em maxx}, int {\em miny}, int {\em maxy}) const}\label{class_AMatrix_a40}


\index{AMatrix@{AMatrix}!ModLp_Distance@{ModLp\_\-Distance}}
\index{ModLp_Distance@{ModLp\_\-Distance}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Mod\-Lp\_\-Distance (AMatrix {\em m}, AMatrix {\em modulus}, double {\em p} = 0.0) const}\label{class_AMatrix_a38}


\index{AMatrix@{AMatrix}!ModLp_Metric@{ModLp\_\-Metric}}
\index{ModLp_Metric@{ModLp\_\-Metric}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Mod\-Lp\_\-Metric (AMatrix {\em modulus}, double {\em p}, int {\em minx}, int {\em maxx}, int {\em miny}, int {\em maxy}) const}\label{class_AMatrix_a41}


\index{AMatrix@{AMatrix}!ModLp_Metric@{ModLp\_\-Metric}}
\index{ModLp_Metric@{ModLp\_\-Metric}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::Mod\-Lp\_\-Metric (AMatrix {\em modulus}, double {\em p}) const}\label{class_AMatrix_a39}


\index{AMatrix@{AMatrix}!ModNormalize@{ModNormalize}}
\index{ModNormalize@{ModNormalize}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Mod\-Normalize (AMatrix {\em modulus}) const}\label{class_AMatrix_a59}


\index{AMatrix@{AMatrix}!Reset@{Reset}}
\index{Reset@{Reset}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::Reset () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a60}




Definition at line 361 of file amatrix.inc.\footnotesize\begin{verbatim}00362 {
00363         if (the_rep->have_svd_flag)
00364         {
00365                 the_rep->have_svd_flag = 0;
00366                 delete the_rep->svd_u;
00367                 the_rep->svd_u = 0;
00368                 delete the_rep->svd_diagw;
00369                 the_rep->svd_diagw = 0;
00370                 delete the_rep->svd_v;
00371                 the_rep->svd_v = 0;
00372         }
00373         if (the_rep->have_inverse_flag);
00374         {
00375                 the_rep->have_inverse_flag = 0;
00376                 delete the_rep->gj_inverse;
00377                 the_rep->gj_inverse = 0;
00378         }
00379 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!RotationMatrix@{RotationMatrix}}
\index{RotationMatrix@{RotationMatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Rotation\-Matrix (int {\em n}, int {\em a}, int {\em b}, double {\em rad})\hspace{0.3cm}{\tt  [static]}}\label{class_AMatrix_d0}


\index{AMatrix@{AMatrix}!Rows@{Rows}}
\index{Rows@{Rows}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int AMatrix::Rows () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a24}




Definition at line 300 of file amatrix.h.

Referenced by Compare(), GJInverse(), operator $\ast$(), operator $\ast$=(), operator()(), operator/(), operator/=(), and operator[$\,$]().\footnotesize\begin{verbatim}00300                              { return the_rep->rows; }
00301 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!SVDInverse@{SVDInverse}}
\index{SVDInverse@{SVDInverse}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::SVDInverse () const}\label{class_AMatrix_a12}


\index{AMatrix@{AMatrix}!SVD_DiagW@{SVD\_\-DiagW}}
\index{SVD_DiagW@{SVD\_\-DiagW}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::SVD\_\-Diag\-W () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a10}




Definition at line 304 of file amatrix.inc.\footnotesize\begin{verbatim}00305 {
00306         if (!the_rep->have_svd_flag)
00307                 calculate_svd();
00308         return *(the_rep->svd_diagw);
00309 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!SVD_Fit@{SVD\_\-Fit}}
\index{SVD_Fit@{SVD\_\-Fit}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::SVD\_\-Fit (int {\em num\_\-funcs}, void($\ast$ {\em funcer})(double x, double $\ast$dest, int nf), double \& {\em chisq}) const}\label{class_AMatrix_a13}


\index{AMatrix@{AMatrix}!SVD_U@{SVD\_\-U}}
\index{SVD_U@{SVD\_\-U}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::SVD\_\-U () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a8}




Definition at line 311 of file amatrix.inc.\footnotesize\begin{verbatim}00312 {
00313         if (!the_rep->have_svd_flag)
00314                 calculate_svd();
00315         return *(the_rep->svd_u);
00316 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!SVD_V@{SVD\_\-V}}
\index{SVD_V@{SVD\_\-V}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::SVD\_\-V () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a11}




Definition at line 318 of file amatrix.inc.\footnotesize\begin{verbatim}00319 {
00320         if (!the_rep->have_svd_flag)
00321                 calculate_svd();
00322         return *(the_rep->svd_v);
00323 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!SVD_W@{SVD\_\-W}}
\index{SVD_W@{SVD\_\-W}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::SVD\_\-W () const}\label{class_AMatrix_a9}


\index{AMatrix@{AMatrix}!Set_Begin_Row@{Set\_\-Begin\_\-Row}}
\index{Set_Begin_Row@{Set\_\-Begin\_\-Row}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::Set\_\-Begin\_\-Row (const char $\ast$ {\em s})\hspace{0.3cm}{\tt  [inline, static]}}\label{class_AMatrix_d1}




Definition at line 382 of file amatrix.inc.\footnotesize\begin{verbatim}00383 {
00384         if (strlen(s) > strlen(os_begin_row))
00385         {
00386                 delete[] os_begin_row;
00387                 os_begin_row = new char[strlen(s)+1];
00388         }
00389 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!Set_End_Row@{Set\_\-End\_\-Row}}
\index{Set_End_Row@{Set\_\-End\_\-Row}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::Set\_\-End\_\-Row (const char $\ast$ {\em s})\hspace{0.3cm}{\tt  [inline, static]}}\label{class_AMatrix_d2}




Definition at line 393 of file amatrix.inc.\footnotesize\begin{verbatim}00394 {
00395         if (strlen(s) > strlen(os_end_row))
00396         {
00397                 delete[] os_end_row;
00398                 os_end_row = new char[strlen(s)+1];
00399         }
00400 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!SmallProduct@{SmallProduct}}
\index{SmallProduct@{SmallProduct}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Small\-Product (const AMatrix \& {\em m1}, const AMatrix \& {\em m2})\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_e0}




Referenced by operator $\ast$().\index{AMatrix@{AMatrix}!Submatrix@{Submatrix}}
\index{Submatrix@{Submatrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Submatrix (int {\em r}, int {\em c}, int {\em rlen}, int {\em clen}) const}\label{class_AMatrix_a62}


\index{AMatrix@{AMatrix}!Transpose@{Transpose}}
\index{Transpose@{Transpose}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Transpose () const}\label{class_AMatrix_a17}


\index{AMatrix@{AMatrix}!UniqueCopy@{UniqueCopy}}
\index{UniqueCopy@{UniqueCopy}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::Unique\-Copy () const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a6}




Definition at line 82 of file amatrix.inc.\footnotesize\begin{verbatim}00083 {
00084         AMatrix m;
00085         m.the_rep->Dereference();
00086         m.the_rep = new AMatrixRep(*the_rep);
00087         return m;
00088 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!calculate_gj_inverse@{calculate\_\-gj\_\-inverse}}
\index{calculate_gj_inverse@{calculate\_\-gj\_\-inverse}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::calculate\_\-gj\_\-inverse () const\hspace{0.3cm}{\tt  [protected]}}\label{class_AMatrix_b0}




Referenced by GJInverse().\index{AMatrix@{AMatrix}!calculate_svd@{calculate\_\-svd}}
\index{calculate_svd@{calculate\_\-svd}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::calculate\_\-svd () const\hspace{0.3cm}{\tt  [protected]}}\label{class_AMatrix_b1}




Referenced by SVD\_\-Diag\-W(), SVD\_\-U(), and SVD\_\-V().\index{AMatrix@{AMatrix}!convertfromrect@{convertfromrect}}
\index{convertfromrect@{convertfromrect}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::convertfromrect (const AMatrix \&, AMatrix \&, int, {\bf coord\_\-type})\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_e3}


\index{AMatrix@{AMatrix}!converttorect@{converttorect}}
\index{converttorect@{converttorect}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::converttorect (const AMatrix \&, AMatrix \&, int, {\bf coord\_\-type})\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_e2}


\index{AMatrix@{AMatrix}!mod@{mod}}
\index{mod@{mod}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void AMatrix::mod ()\hspace{0.3cm}{\tt  [protected]}}\label{class_AMatrix_b2}




Referenced by operator $\ast$=(), operator()(), operator/=(), and operator[$\,$]().\index{AMatrix@{AMatrix}!operator *@{operator $\ast$}}
\index{operator *@{operator $\ast$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator $\ast$ (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a56}




Definition at line 248 of file amatrix.inc.\footnotesize\begin{verbatim}00249 {
00250 #ifndef NOERRORCHECKING_MATRIX
00251         if (Cols() != m.Rows())
00252     {
00253 #       ifdef   DEBUG_MATRIX
00254         log << "Error: " << Rows() << 'x' << Cols()
00255             << " * " << m.Rows() << 'x' << m.Cols() << endl;
00256 #       endif
00257         return bad_matrix;
00258     }
00259 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator *@{operator $\ast$}}
\index{operator *@{operator $\ast$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator $\ast$ (double {\em d}) const}\label{class_AMatrix_a48}


\index{AMatrix@{AMatrix}!operator *=@{operator $\ast$=}}
\index{operator *=@{operator $\ast$=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix \& AMatrix::operator $\ast$= (const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a52}




Definition at line 268 of file amatrix.inc.\footnotesize\begin{verbatim}00269 {
00270 #ifndef NOERRORCHECKING_MATRIX
00271         if (Cols() != m.Rows())
00272     {
00273 #       ifdef   DEBUG_MATRIX
00274         log << "Error: " << Rows() << 'x' << Cols()
00275             << " *= " << m.Rows() << 'x' << m.Cols() << endl;
00276 #       endif
00277         return bad_matrix;
00278     }
00279 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator *=@{operator $\ast$=}}
\index{operator *=@{operator $\ast$=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix\& AMatrix::operator $\ast$= (double {\em d})}\label{class_AMatrix_a44}


\index{AMatrix@{AMatrix}!operator"!=@{operator"!=}}
\index{operator"!=@{operator"!=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::operator!= (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a28}




Definition at line 222 of file amatrix.inc.\footnotesize\begin{verbatim}00223 {
00224         return Compare(m) != 0;
00225 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator()@{operator()}}
\index{operator()@{operator()}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::operator() (int {\em r}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a21}




Definition at line 90 of file amatrix.inc.\footnotesize\begin{verbatim}00091 {
00092 #ifndef NOERRORCHECKING_MATRIX
00093         if ( (r < 1) || (r > Rows()) )
00094         {
00095 #       ifdef   DEBUG_MATRIX
00096                 log << "Error: " << Rows() << 'x' << Cols()
00097                         << " ( " << r << " ) const" << endl;
00098 #       endif
00099                 return bad_val;
00100         }
00101 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator()@{operator()}}
\index{operator()@{operator()}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double \& AMatrix::operator() (int {\em r})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a20}




Definition at line 105 of file amatrix.inc.\footnotesize\begin{verbatim}00106 {
00107 #ifndef NOERRORCHECKING_MATRIX
00108         if ( (r < 1) || (r > Rows()) )
00109         {
00110 #       ifdef   DEBUG_MATRIX
00111                 log << "Error: " << Rows() << 'x' << Cols()
00112                         << " ( " << r << " ) " << endl;
00113 #       endif
00114                 return bad_val;
00115         }
00116 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator()@{operator()}}
\index{operator()@{operator()}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::operator() (int {\em r}, int {\em c}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a19}




Definition at line 152 of file amatrix.inc.\footnotesize\begin{verbatim}00153 {
00154 #ifndef NOERRORCHECKING_MATRIX
00155         if ( (r < 1) || (c < 1) || (r > Rows()) || (c > Cols()) )
00156         {
00157 #       ifdef   DEBUG_MATRIX
00158                 log << "Error: " << Rows() << 'x' << Cols()
00159                         << " ( " << r << ',' << c << " ) const" << endl;
00160 #       endif
00161                 return bad_val;
00162         }
00163 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator()@{operator()}}
\index{operator()@{operator()}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double \& AMatrix::operator() (int {\em r}, int {\em c})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a18}




Definition at line 167 of file amatrix.inc.

Referenced by Compare().\footnotesize\begin{verbatim}00168 {
00169 #ifndef NOERRORCHECKING_MATRIX
00170         if ( (r < 1) || (c < 1) || (r > Rows()) || (c > Cols()) )
00171         {
00172 #       ifdef   DEBUG_MATRIX
00173                 log << "Error: " << Rows() << 'x' << Cols()
00174                         << " ( " << r << ',' << c << " ) " << endl;
00175 #       endif
00176                 return bad_val;
00177         }
00178 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator+@{operator+}}
\index{operator+@{operator+}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator+ (const AMatrix \& {\em m}) const}\label{class_AMatrix_a54}


\index{AMatrix@{AMatrix}!operator+@{operator+}}
\index{operator+@{operator+}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator+ (double {\em d}) const}\label{class_AMatrix_a46}


\index{AMatrix@{AMatrix}!operator+=@{operator+=}}
\index{operator+=@{operator+=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix\& AMatrix::operator+= (const AMatrix \& {\em m})}\label{class_AMatrix_a50}


\index{AMatrix@{AMatrix}!operator+=@{operator+=}}
\index{operator+=@{operator+=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix\& AMatrix::operator+= (double {\em d})}\label{class_AMatrix_a42}


\index{AMatrix@{AMatrix}!operator-@{operator-}}
\index{operator-@{operator-}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator- (const AMatrix \& {\em m}) const}\label{class_AMatrix_a55}


\index{AMatrix@{AMatrix}!operator-@{operator-}}
\index{operator-@{operator-}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator- (double {\em d}) const}\label{class_AMatrix_a47}


\index{AMatrix@{AMatrix}!operator-=@{operator-=}}
\index{operator-=@{operator-=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix\& AMatrix::operator-= (const AMatrix \& {\em m})}\label{class_AMatrix_a51}


\index{AMatrix@{AMatrix}!operator-=@{operator-=}}
\index{operator-=@{operator-=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix\& AMatrix::operator-= (double {\em d})}\label{class_AMatrix_a43}


\index{AMatrix@{AMatrix}!operator/@{operator/}}
\index{operator/@{operator/}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator/ (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a57}




Definition at line 327 of file amatrix.inc.\footnotesize\begin{verbatim}00328 {
00329 #ifndef NOERRORCHECKING_MATRIX
00330         if (Cols() != m.Rows())
00331     {
00332 #       ifdef   DEBUG_MATRIX
00333         log << "Error: " << Rows() << 'x' << Cols()
00334             << " / " << m.Rows() << 'x' << m.Cols() << endl;
00335 #       endif
00336         return bad_matrix;
00337     }
00338 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator/@{operator/}}
\index{operator/@{operator/}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix AMatrix::operator/ (double {\em d}) const}\label{class_AMatrix_a49}


\index{AMatrix@{AMatrix}!operator/=@{operator/=}}
\index{operator/=@{operator/=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix \& AMatrix::operator/= (const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a53}




Definition at line 343 of file amatrix.inc.\footnotesize\begin{verbatim}00344 {
00345 #ifndef NOERRORCHECKING_MATRIX
00346         if (Cols() != m.Rows())
00347     {
00348 #       ifdef   DEBUG_MATRIX
00349         log << "Error: " << Rows() << 'x' << Cols()
00350             << " /= " << m.Rows() << 'x' << m.Cols() << endl;
00351 #       endif
00352         return bad_matrix;
00353     }
00354 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator/=@{operator/=}}
\index{operator/=@{operator/=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix\& AMatrix::operator/= (double {\em d})}\label{class_AMatrix_a45}


\index{AMatrix@{AMatrix}!operator<@{operator$<$}}
\index{operator<@{operator$<$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::operator$<$ (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a29}




Definition at line 232 of file amatrix.inc.\footnotesize\begin{verbatim}00233 {
00234         return Compare(m) < 0;
00235 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator<=@{operator$<$=}}
\index{operator<=@{operator$<$=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::operator$<$= (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a31}




Definition at line 227 of file amatrix.inc.\footnotesize\begin{verbatim}00228 {
00229         return Compare(m) <= 0;
00230 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator=@{operator=}}
\index{operator=@{operator=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix \& AMatrix::operator= (const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a5}




Definition at line 72 of file amatrix.inc.\footnotesize\begin{verbatim}00073 {
00074         if (the_rep == m.the_rep)
00075                 return *this;
00076         the_rep->Dereference();
00077         the_rep = m.the_rep;
00078         the_rep->Reference();
00079         return *this;
00080 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator==@{operator==}}
\index{operator==@{operator==}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::operator== (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a27}




Definition at line 217 of file amatrix.inc.\footnotesize\begin{verbatim}00218 {
00219         return Compare(m) == 0;
00220 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator>@{operator$>$}}
\index{operator>@{operator$>$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::operator$>$ (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a30}




Definition at line 242 of file amatrix.inc.\footnotesize\begin{verbatim}00243 {
00244         return Compare(m) > 0;
00245 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator>=@{operator$>$=}}
\index{operator>=@{operator$>$=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool AMatrix::operator$>$= (const AMatrix \& {\em m}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a32}




Definition at line 237 of file amatrix.inc.\footnotesize\begin{verbatim}00238 {
00239         return Compare(m) >= 0;
00240 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::operator[$\,$] (int {\em c}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a23}




Definition at line 121 of file amatrix.inc.\footnotesize\begin{verbatim}00122 {
00123 #ifndef NOERRORCHECKING_MATRIX
00124         if ( (c < 1) || (c > Cols()) )
00125         {
00126 #       ifdef   DEBUG_MATRIX
00127                 log << "Error: " << Rows() << 'x' << Cols()
00128                         << " [ " << c << " ] const" << endl;
00129 #       endif
00130                 return bad_val;
00131         }
00132 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double \& AMatrix::operator[$\,$] (int {\em c})\hspace{0.3cm}{\tt  [inline]}}\label{class_AMatrix_a22}




Definition at line 136 of file amatrix.inc.\footnotesize\begin{verbatim}00137 {
00138 #ifndef NOERRORCHECKING_MATRIX
00139         if ( (c < 1) || (c > Cols()) )
00140         {
00141 #       ifdef   DEBUG_MATRIX
00142                 log << "Error: " << Rows() << 'x' << Cols()
00143                         << " [ " << c << " ] " << endl;
00144 #       endif
00145                 return bad_val;
00146         }
00147 \end{verbatim}\normalsize 


\subsection{Friends And Related Function Documentation}
\index{AMatrix@{AMatrix}!InputBinary@{InputBinary}}
\index{InputBinary@{InputBinary}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}istream\& Input\-Binary (istream \&, AMatrix \&)\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l9}


\index{AMatrix@{AMatrix}!OutputBinary@{OutputBinary}}
\index{OutputBinary@{OutputBinary}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& Output\-Binary (ostream \&, const AMatrix \&)\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l8}


\index{AMatrix@{AMatrix}!operator *@{operator $\ast$}}
\index{operator *@{operator $\ast$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix operator $\ast$ (double {\em d}, const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l2}


\index{AMatrix@{AMatrix}!operator+@{operator+}}
\index{operator+@{operator+}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix operator+ (double {\em d}, const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l0}


\index{AMatrix@{AMatrix}!operator-@{operator-}}
\index{operator-@{operator-}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix operator- (double {\em d}, const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l1}


\index{AMatrix@{AMatrix}!operator/@{operator/}}
\index{operator/@{operator/}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}AMatrix operator/ (double {\em d}, const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l3}


\index{AMatrix@{AMatrix}!operator<<@{operator$<$$<$}}
\index{operator<<@{operator$<$$<$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& operator$<$$<$ (ostream \& {\em os}, const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l4}


\index{AMatrix@{AMatrix}!operator<=@{operator$<$=}}
\index{operator<=@{operator$<$=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& operator$<$= (ostream \& {\em os}, const AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l6}




Definition at line 404 of file amatrix.inc.\footnotesize\begin{verbatim}00405 { return OutputBinary(os,m); }
00406 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator>=@{operator$>$=}}
\index{operator>=@{operator$>$=}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}istream\& operator$>$= (istream \& {\em is}, AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l7}




Definition at line 408 of file amatrix.inc.\footnotesize\begin{verbatim}00409 { return InputBinary(is,m); }
00410 \end{verbatim}\normalsize 
\index{AMatrix@{AMatrix}!operator>>@{operator$>$$>$}}
\index{operator>>@{operator$>$$>$}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}istream\& operator$>$$>$ (istream \& {\em is}, AMatrix \& {\em m})\hspace{0.3cm}{\tt  [friend]}}\label{class_AMatrix_l5}




\subsection{Member Data Documentation}
\index{AMatrix@{AMatrix}!bad_matrix@{bad\_\-matrix}}
\index{bad_matrix@{bad\_\-matrix}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const AMatrix AMatrix::bad\_\-matrix\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_q1}




Definition at line 110 of file amatrix.h.\index{AMatrix@{AMatrix}!bad_val@{bad\_\-val}}
\index{bad_val@{bad\_\-val}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::bad\_\-val\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_q2}




Definition at line 111 of file amatrix.h.\index{AMatrix@{AMatrix}!epsilon@{epsilon}}
\index{epsilon@{epsilon}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double AMatrix::epsilon\hspace{0.3cm}{\tt  [static]}}\label{class_AMatrix_p0}




Definition at line 128 of file amatrix.h.\index{AMatrix@{AMatrix}!os_begin_row@{os\_\-begin\_\-row}}
\index{os_begin_row@{os\_\-begin\_\-row}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ AMatrix::os\_\-begin\_\-row\hspace{0.3cm}{\tt  [static]}}\label{class_AMatrix_p1}




Definition at line 494 of file amatrix.h.\index{AMatrix@{AMatrix}!os_end_row@{os\_\-end\_\-row}}
\index{os_end_row@{os\_\-end\_\-row}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ AMatrix::os\_\-end\_\-row\hspace{0.3cm}{\tt  [static]}}\label{class_AMatrix_p2}




Definition at line 495 of file amatrix.h.\index{AMatrix@{AMatrix}!product_threshold@{product\_\-threshold}}
\index{product_threshold@{product\_\-threshold}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const int AMatrix::product\_\-threshold\hspace{0.3cm}{\tt  [static, protected]}}\label{class_AMatrix_q0}




Definition at line 108 of file amatrix.h.\index{AMatrix@{AMatrix}!the_rep@{the\_\-rep}}
\index{the_rep@{the\_\-rep}!AMatrix@{AMatrix}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf AMatrix\-Rep} $\ast$ AMatrix::the\_\-rep\hspace{0.3cm}{\tt  [private]}}\label{class_AMatrix_o0}




Definition at line 102 of file amatrix.h.

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
{\bf amatrix.h}\item 
{\bf amatrix.inc}\end{CompactItemize}
