\section{j\-Vector  Class Reference}
\label{class_jVector}\index{jVector@{j\-Vector}}
{\tt \#include $<$jvector.h$>$}

Collaboration diagram for j\-Vector:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=62pt]{class_jVector_coll_graph}
\end{center}
\end{figure}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
int {\bf Resize} (int size)
\item 
int {\bf Copy} (const j\-Vector \&y)
\item 
{\bf operator double $\ast$} () const
\item 
const double\& {\bf get} (int i) const
\item 
void {\bf set} (int i, const double \&d)
\item 
const j\-Vector\& {\bf set} (const double \&d)
\item 
const j\-Vector\& {\bf zero} ()
\item 
{\bf j\-Vector} (int length={\bf Creation\-Length})
\item 
{\bf j\-Vector} (const j\-Vector \&v)
\item 
{\bf j\-Vector} (int length, double d)
\item 
{\bf $\sim$j\-Vector} ()
\item 
const j\-Vector\& {\bf transpose} ()
\item 
int {\bf Vertical} ()
\item 
int {\bf Length} () const
\item 
double {\bf sum} () const
\begin{CompactList}\small\item\em Returns the sum of all the components.\item\end{CompactList}\item 
double {\bf sumsqr} () const
\begin{CompactList}\small\item\em Returns the sum of the squares.\item\end{CompactList}\item 
double {\bf variance} () const
\begin{CompactList}\small\item\em Returns the variance.\item\end{CompactList}\item 
double {\bf max} () const
\item 
int {\bf argmax} () const
\item 
double {\bf min} () const
\item 
int {\bf argmin} () const
\item 
double {\bf mean} () const
\item 
double {\bf median} () const
\item 
double {\bf nrm} () const
\begin{CompactList}\small\item\em Returns the norm (square of magnitude.\item\end{CompactList}\item 
j\-Vector {\bf norm\_\-unit} () const
\begin{CompactList}\small\item\em Returns a j\-Vector of unit length;.\item\end{CompactList}\item 
double {\bf mag} () const
\begin{CompactList}\small\item\em returns magnitude.\item\end{CompactList}\item 
j\-Vector {\bf unit} () const
\begin{CompactList}\small\item\em Returns a j\-Vector of unit length;.\item\end{CompactList}\item 
const double\& {\bf operator[$\,$]} (int i) const
\begin{CompactList}\small\item\em indexing.\item\end{CompactList}\item 
double\& {\bf operator[$\,$]} (int i)
\item 
j\-Vector {\bf operator-} ()
\begin{CompactList}\small\item\em negation.\item\end{CompactList}\item 
const j\-Vector\& {\bf operator=} (const j\-Vector \&y)
\item 
const j\-Vector\& {\bf operator=} (const double \&d)
\item 
int {\bf Compare} (const j\-Vector \&v) const
\item 
const j\-Vector\& {\bf operator-=} (const j\-Vector \&y)
\item 
const j\-Vector\& {\bf operator+=} (const j\-Vector \&y)
\item 
const j\-Vector\& {\bf operator\%=} (const j\-Vector \&y)
\item 
const j\-Vector\& {\bf operator $\ast$=} (double d)
\item 
const j\-Vector\& {\bf operator/=} (double d)
\item 
const j\-Vector\& {\bf operator\%=} (double d)
\item 
int {\bf Input} (istream \&is)
\item 
int {\bf Output} (ostream \&os) const
\item 
int {\bf dynread} (istream \&is, const {\bf DS} \&compdelim="$\backslash$t", const {\bf DS} \&vectdelim="$\backslash$n")
\item 
int {\bf Input\-Binary} (istream \&is)
\item 
int {\bf Output\-Binary} (ostream \&os) const
\item 
{\bf MAKE\_\-IO\_\-STREAM\_\-OPERATORS} (j\-Vector)
\item 
{\bf MAKE\_\-BIN\_\-STREAM\_\-OPERATORS} (j\-Vector)
\end{CompactItemize}
\subsection*{Static Public Attributes}
\begin{CompactItemize}
\item 
int {\bf Creation\-Length} = {\bf DEFAULTLEN}
\item 
char {\bf IODelimiter} = 
\item 
j\-Vector {\bf Zero}
\end{CompactItemize}
\subsection*{Private Methods}
\begin{CompactItemize}
\item 
void {\bf mult} (double d)
\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
double$\ast$ {\bf V}
\item 
int {\bf L}
\item 
{\bf usint} {\bf vert}
\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
int {\bf operator==} (const j\-Vector \&x, const j\-Vector \&y)
\begin{CompactList}\small\item\em Comparison operators.\item\end{CompactList}\item 
int {\bf operator!=} (const j\-Vector \&x, const j\-Vector \&y)
\item 
int {\bf operator$<$} (const j\-Vector \&x, const j\-Vector \&y)
\item 
int {\bf operator$>$} (const j\-Vector \&x, const j\-Vector \&y)
\item 
int {\bf operator$<$=} (const j\-Vector \&x, const j\-Vector \&y)
\item 
int {\bf operator$>$=} (const j\-Vector \&x, const j\-Vector \&y)
\item 
j\-Vector {\bf operator-} (j\-Vector x, const j\-Vector \&y)
\item 
j\-Vector {\bf operator+} (j\-Vector x, const j\-Vector \&y)
\item 
double {\bf operator $\ast$} (j\-Vector x, const j\-Vector \&y)
\item 
j\-Vector {\bf operator\%} (j\-Vector x, const j\-Vector \&y)
\item 
j\-Vector {\bf operator $\ast$} (j\-Vector y, double d)
\item 
j\-Vector {\bf operator $\ast$} (double d, j\-Vector y)
\item 
j\-Vector {\bf operator/} (j\-Vector y, double d)
\item 
j\-Vector {\bf operator\%} (j\-Vector x, double d)
\item 
double {\bf JVAngle} (const j\-Vector \&x, const j\-Vector \&y)
\item 
double {\bf euclid} (const j\-Vector \&x, const j\-Vector \&y)
\item 
ostream\& {\bf VBPrint\-Line} (ostream \&os, const j\-Vector \&x, const j\-Vector \&y, const {\bf Dyn\-String} \&color)
\item 
ostream\& {\bf VBPrint\-Point} (ostream \&os, const j\-Vector \&x, const {\bf Dyn\-String} \&color)
\item 
ostream\& {\bf VBPrint\-Circle} (ostream \&os, const j\-Vector \&x, const double \&radius, const {\bf Dyn\-String} \&color)
\item 
void {\bf JVqsort} (j\-Vector \&v)
\item 
int {\bf binsearch} (const j\-Vector \&v, double d)
\item 
double {\bf Covariance} (const j\-Vector \&x, const j\-Vector \&y)
\end{CompactItemize}


\subsection{Constructor \& Destructor Documentation}
\index{jVector@{j\-Vector}!jVector@{jVector}}
\index{jVector@{jVector}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::j\-Vector (int {\em length} = {\bf Creation\-Length})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a7}




Definition at line 72 of file jvector.h.\footnotesize\begin{verbatim}00073   { L=0; V=0; vert=1; Resize(length); }
00074 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!jVector@{jVector}}
\index{jVector@{jVector}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::j\-Vector (const j\-Vector \& {\em v})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a8}




Definition at line 75 of file jvector.h.\footnotesize\begin{verbatim}00076   { L=0; V=0; Copy(v); }
00077 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!jVector@{jVector}}
\index{jVector@{jVector}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::j\-Vector (int {\em length}, double {\em d})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a9}




Definition at line 77 of file jvector.h.\footnotesize\begin{verbatim}00078   { L=0; V=0; Resize(length); set(d); }
00079 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!~jVector@{$\sim$jVector}}
\index{~jVector@{$\sim$jVector}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::$\sim$j\-Vector ()\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a10}




Definition at line 80 of file jvector.h.\footnotesize\begin{verbatim}00080              { delete[] V; }
00081 \end{verbatim}\normalsize 


\subsection{Member Function Documentation}
\index{jVector@{j\-Vector}!Compare@{Compare}}
\index{Compare@{Compare}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Compare (const j\-Vector \& {\em v}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a32}




Definition at line 203 of file jvector.h.\footnotesize\begin{verbatim}00204   {
00205     if(*this==v)
00206       return 0;
00207     if(*this>v)
00208       return 1;
00209     return -1;
00210 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!Copy@{Copy}}
\index{Copy@{Copy}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Copy (const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a1}




Definition at line 48 of file jvector.h.

Referenced by j\-Vector(), and operator=().\footnotesize\begin{verbatim}00049   {
00050     if(&y == this) return 1;
00051     if(!Resize(y.L)) return 0;
00052     memcpy(V, y.V, sizeof(double)*L);
00053     vert = y.vert;
00054     return 1;
00055 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!Input@{Input}}
\index{Input@{Input}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Input (istream \& {\em is})}\label{class_jVector_a39}




Definition at line 165 of file jvector.C.\footnotesize\begin{verbatim}00166 {
00167   double w;
00168   for(int i=0; i<L; ++i)
00169   {
00170     if(!(is >> w)) return i;
00171     V[i] = w;
00172   }
00173 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!InputBinary@{InputBinary}}
\index{InputBinary@{InputBinary}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Input\-Binary (istream \& {\em is})}\label{class_jVector_a42}




Definition at line 281 of file jvector.C.\footnotesize\begin{verbatim}00282   {
00283     // Read L:
00284     //
00285     int e;
00286     is >= e;
00287     if(!Resize(e))
00288         { cerr << "jVector::InputBinary\n"; raise(SIGQUIT); }
00289 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!Length@{Length}}
\index{Length@{Length}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Length () const\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a13}




Definition at line 84 of file jvector.h.

Referenced by Stop\-Eval::check\_\-stress\_\-max\_\-tot(), and Anim\-Frame::run().\footnotesize\begin{verbatim}00084                      { return L; }
00085 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!MAKE_BIN_STREAM_OPERATORS@{MAKE\_\-BIN\_\-STREAM\_\-OPERATORS}}
\index{MAKE_BIN_STREAM_OPERATORS@{MAKE\_\-BIN\_\-STREAM\_\-OPERATORS}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::MAKE\_\-BIN\_\-STREAM\_\-OPERATORS (j\-Vector)}\label{class_jVector_a45}


\index{jVector@{j\-Vector}!MAKE_IO_STREAM_OPERATORS@{MAKE\_\-IO\_\-STREAM\_\-OPERATORS}}
\index{MAKE_IO_STREAM_OPERATORS@{MAKE\_\-IO\_\-STREAM\_\-OPERATORS}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::MAKE\_\-IO\_\-STREAM\_\-OPERATORS (j\-Vector)}\label{class_jVector_a44}


\index{jVector@{j\-Vector}!Output@{Output}}
\index{Output@{Output}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Output (ostream \& {\em os}) const}\label{class_jVector_a40}




Definition at line 176 of file jvector.C.\footnotesize\begin{verbatim}00177 {
00178   for(int i=0; i<L; ++i)
00179   {
00180     os << V[i];
00181     if(i != L-1) os << IODelimiter;
00182   }
00183 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!OutputBinary@{OutputBinary}}
\index{OutputBinary@{OutputBinary}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Output\-Binary (ostream \& {\em os}) const}\label{class_jVector_a43}




Definition at line 304 of file jvector.C.\footnotesize\begin{verbatim}00305   {
00306     // Write "L":
00307     //
00308     os <= L;
00309 
00310     // Write "vert":
00311     //
00312     os <= vert;
00313 
00314     // Write "V":
00315     //
00316     if(V && L>0)
00317       {
00318         os <= 1;
00319         os.write((char*)V,L*sizeof(double));
00320       }
00321 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!Resize@{Resize}}
\index{Resize@{Resize}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Resize (int {\em size})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a0}




Definition at line 34 of file jvector.h.

Referenced by Copy(), sd\-Graph::Dijkstra(), Grid::Grid(), Input\-Binary(), Grid::Re\-Size(), dynread(), and j\-Vector().\footnotesize\begin{verbatim}00035   { 
00036     if(L == size) return 1; 
00037     if(size<1)
00038       { delete[] V; V = 0; L = 0; return 1; }
00039     double * tmp = V;
00040     if(!(V = new double[size]))
00041       { V = tmp; return 0; }
00042 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!Vertical@{Vertical}}
\index{Vertical@{Vertical}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Vertical ()\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a12}




Definition at line 83 of file jvector.h.\footnotesize\begin{verbatim}00083                  { return (int) vert; }
00084 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!argmax@{argmax}}
\index{argmax@{argmax}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::argmax () const}\label{class_jVector_a18}




Definition at line 64 of file jvector.C.\footnotesize\begin{verbatim}00065 {
00066   if(!L) return -1;
00067   double m = V[0];
00068   int mi = 0;
00069   for(int i=1; i<L; ++i) { if(m < V[i]) m = V[i]; mi = i; }
00070 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!argmin@{argmin}}
\index{argmin@{argmin}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::argmin () const}\label{class_jVector_a20}




Definition at line 81 of file jvector.C.\footnotesize\begin{verbatim}00082 {
00083   if(!L) return -1;
00084   double m = V[0];
00085   int mi = 0;
00086   for(int i=1; i<L; ++i) { if(m > V[i]) m = V[i]; mi = i; }
00087 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!dynread@{dynread}}
\index{dynread@{dynread}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::dynread (istream \& {\em is}, const {\bf DS} \& {\em compdelim} = " $\backslash$t", const {\bf DS} \& {\em vectdelim} = "$\backslash$n")}\label{class_jVector_a41}




Definition at line 186 of file jvector.C.

Referenced by Molecule::Dyn\-Read().\footnotesize\begin{verbatim}00188   {
00189     if(is.eof() || is.bad()) return 0;
00190 
00191     DS old_delim = GetDSDelim();
00192     SetDSDelim(vectdelim);
00193 
00194     DLList<double> ComponentList;
00195     DS VecString;
00196     // DSIterator it;
00197     double component;
00198 
00199     // Read in the next string from the input stream:
00200     is >> VecString;
00201     // cout << '[' << VecString << "]\n";
00202     // it.SetString(VecString);
00203     // it.SetDelim(compdelim);
00204     DSIterator it(VecString,compdelim);
00205 
00206     // Extract the components from the string:
00207     for(; it; ++it)
00208       {
00209         component = ($\ast$it).ToDbl();
00210         ComponentList.AddToBack(component);
00211       }
00212 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!get@{get}}
\index{get@{get}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const double \& j\-Vector::get (int {\em i}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a3}




Definition at line 60 of file jvector.h.\footnotesize\begin{verbatim}00061   { return V[i]; }
00062 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!mag@{mag}}
\index{mag@{mag}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::mag () const}\label{class_jVector_a25}


returns magnitude.



Definition at line 110 of file jvector.C.

Referenced by Envelope\-Constraint::Find\-Model\-Translation\-To\-COM(), JVAngle(), Envelope\-Constraint::Move\-Modelby\-Grad(), Envelope::Write\-VRMLgr(), gw\-Relax\-Atom::run(), and unit().\footnotesize\begin{verbatim}00111   { return sqrt(nrm()); }
00112 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!max@{max}}
\index{max@{max}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::max () const}\label{class_jVector_a17}




Definition at line 56 of file jvector.C.

Referenced by jd\-Err\_\-Eval::run().\footnotesize\begin{verbatim}00057 {
00058   if(!L) return INF;
00059   double m = V[0];
00060   for(int i=1; i<L; ++i) { if(m < V[i]) m = V[i]; }
00061 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!mean@{mean}}
\index{mean@{mean}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::mean () const}\label{class_jVector_a21}




Definition at line 100 of file jvector.C.

Referenced by Covariance().\footnotesize\begin{verbatim}00101   { return sum() / L; }
00102 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!median@{median}}
\index{median@{median}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::median () const}\label{class_jVector_a22}




Definition at line 91 of file jvector.C.\footnotesize\begin{verbatim}00092   {
00093     // Find the middle element.  Have to sort first:
00094     jVector sorted(*this);
00095     JVqsort(sorted);
00096     int i = (int) floor(L/2);
00097     return ( (L%2) ? sorted.V[i] : (sorted.V[i] + sorted.V[i+1]) );
00098 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!min@{min}}
\index{min@{min}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::min () const}\label{class_jVector_a19}




Definition at line 73 of file jvector.C.\footnotesize\begin{verbatim}00074 {
00075   if(!L) return INF;
00076   double m = V[0];
00077   for(int i=1; i<L; ++i) { if(m > V[i]) m = V[i]; }
00078 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!mult@{mult}}
\index{mult@{mult}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void j\-Vector::mult (double {\em d})\hspace{0.3cm}{\tt  [private]}}\label{class_jVector_c0}


\index{jVector@{j\-Vector}!norm_unit@{norm\_\-unit}}
\index{norm_unit@{norm\_\-unit}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector j\-Vector::norm\_\-unit () const\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a24}


Returns a j\-Vector of unit length;.



Definition at line 106 of file jvector.h.

Referenced by Envelope::Calc\-Gradient().\footnotesize\begin{verbatim}00106                             { return *this/nrm(); }
00107 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!nrm@{nrm}}
\index{nrm@{nrm}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::nrm () const}\label{class_jVector_a23}


Returns the norm (square of magnitude.



Definition at line 103 of file jvector.C.

Referenced by Envelope\-Constraint::Align\-Modelto\-COM(), Constraint\-Manager::Translate\-Model(), gw\-Numerics::add\-VDWSegments(), mag(), and norm\_\-unit().\footnotesize\begin{verbatim}00104   {
00105     double sumsqr = 0.0;
00106     for(int i=0; i<L; ++i) sumsqr += V[i]*V[i];
00107     return sumsqr;
00108 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator *=@{operator $\ast$=}}
\index{operator *=@{operator $\ast$=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator $\ast$= (double {\em d})}\label{class_jVector_a36}




Definition at line 138 of file jvector.C.\footnotesize\begin{verbatim}00139   { for(int i=0; i<L; ++i) V[i] *= d; return *this; }
00140 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator double *@{operator double $\ast$}}
\index{operator double *@{operator double $\ast$}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector::operator double $\ast$ () const}\label{class_jVector_a2}




Definition at line 20 of file jvector.C.\footnotesize\begin{verbatim}00021 {
00022   double * d = 0;
00023   if(!V || L<1 || !(d = new double[L])) 
00024     { cerr << "jVector::operator double *\n"; raise(SIGQUIT); }
00025 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator\%=@{operator\%=}}
\index{operator\%=@{operator\%=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator\%= (double {\em d})}\label{class_jVector_a38}




Definition at line 147 of file jvector.C.\footnotesize\begin{verbatim}00148   { for(int i=0; i<L; ++i) V[i] = fmod(V[i],d); return *this; }
00149 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator\%=@{operator\%=}}
\index{operator\%=@{operator\%=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator\%= (const j\-Vector \& {\em y})}\label{class_jVector_a35}




Definition at line 132 of file jvector.C.\footnotesize\begin{verbatim}00133   { return y; }
00134 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator+=@{operator+=}}
\index{operator+=@{operator+=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator+= (const j\-Vector \& {\em y})}\label{class_jVector_a34}




Definition at line 119 of file jvector.C.\footnotesize\begin{verbatim}00120   { if(L == y.L) for(int i=0; i<L; ++i) V[i] += y.V[i]; return *this; }
00121 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator-@{operator-}}
\index{operator-@{operator-}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector j\-Vector::operator- ()\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a29}


negation.



Definition at line 129 of file jvector.h.\footnotesize\begin{verbatim}00130   { 
00131     jVector x(L); 
00132     for(int i=0; i<L; ++i) 
00133       x.V[i] = -V[i]; 
00134     return x; 
00135 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator-=@{operator-=}}
\index{operator-=@{operator-=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator-= (const j\-Vector \& {\em y})}\label{class_jVector_a33}




Definition at line 115 of file jvector.C.\footnotesize\begin{verbatim}00116   { if(L == y.L) for(int i=0; i<L; ++i) V[i] -= y.V[i]; return *this; }
00117 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator/=@{operator/=}}
\index{operator/=@{operator/=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator/= (double {\em d})}\label{class_jVector_a37}




Definition at line 143 of file jvector.C.\footnotesize\begin{verbatim}00144   { if(d==0.0) return *this; for(int i=0; i<L; ++i) V[i] /= d; return *this; }
00145 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator=@{operator=}}
\index{operator=@{operator=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator= (const double \& {\em d})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a31}




Definition at line 141 of file jvector.h.\footnotesize\begin{verbatim}00142   { return set(d); }
00143 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator=@{operator=}}
\index{operator=@{operator=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::operator= (const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a30}




Definition at line 138 of file jvector.h.\footnotesize\begin{verbatim}00139   { Copy(y); return *this; }
00140 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double \& j\-Vector::operator[$\,$] (int {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a28}




Definition at line 121 of file jvector.h.\footnotesize\begin{verbatim}00122   { 
00123     if(i<0||i>=L) 
00124       { cerr << "jVector::operator[]\n"; raise(SIGQUIT); }
00125 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const double \& j\-Vector::operator[$\,$] (int {\em i}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a27}


indexing.



Definition at line 115 of file jvector.h.\footnotesize\begin{verbatim}00116   { 
00117     if(i<0||i>=L) 
00118       { cerr << "jVector::operator[]\n"; raise(SIGQUIT); }
00119 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!set@{set}}
\index{set@{set}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::set (const double \& {\em d})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a5}




Definition at line 65 of file jvector.h.\footnotesize\begin{verbatim}00066   { for(int i=0; i<L; ++i) V[i]=d; return *this; }
00067 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!set@{set}}
\index{set@{set}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void j\-Vector::set (int {\em i}, const double \& {\em d})\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a4}




Definition at line 62 of file jvector.h.

Referenced by j\-Vector(), operator=(), and zero().\footnotesize\begin{verbatim}00063   { V[i]=d; }
00064 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!sum@{sum}}
\index{sum@{sum}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::sum () const}\label{class_jVector_a14}


Returns the sum of all the components.



Definition at line 29 of file jvector.C.

Referenced by mean(), jd\-Rand\_\-Eval::run(), and jd\-Err\_\-Eval::run().\footnotesize\begin{verbatim}00030   {
00031     if(!L) return INF;
00032     double s=0.0;
00033     for(int i=0; i<L; ++i)
00034         s += V[i];
00035     return s;
00036 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!sumsqr@{sumsqr}}
\index{sumsqr@{sumsqr}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::sumsqr () const}\label{class_jVector_a15}


Returns the sum of the squares.



Definition at line 38 of file jvector.C.\footnotesize\begin{verbatim}00039   {
00040     if(!L) return INF;
00041     double s=0.0;
00042     for(int i=0; i<L; ++i)
00043         s += V[i]*V[i];
00044     return s;
00045 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!transpose@{transpose}}
\index{transpose@{transpose}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::transpose ()\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a11}




Definition at line 82 of file jvector.h.\footnotesize\begin{verbatim}00082                              { vert = vert ^ 1; return *this; }
00083 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!unit@{unit}}
\index{unit@{unit}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector j\-Vector::unit () const\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a26}


Returns a j\-Vector of unit length;.



Definition at line 112 of file jvector.h.

Referenced by Envelope\-Constraint::Move\-Modelby\-Grad().\footnotesize\begin{verbatim}00112                        { return *this/mag(); }
00113 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!variance@{variance}}
\index{variance@{variance}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double j\-Vector::variance () const}\label{class_jVector_a16}


Returns the variance.



Definition at line 47 of file jvector.C.\footnotesize\begin{verbatim}00048   {
00049     if(!L) return INF;
00050     double s=0.0,ss=0.0;
00051     for(int i=0; i<L; ++i)
00052       { s += V[i]; ss += V[i]*V[i]; }
00053 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!zero@{zero}}
\index{zero@{zero}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const j\-Vector \& j\-Vector::zero ()\hspace{0.3cm}{\tt  [inline]}}\label{class_jVector_a6}




Definition at line 68 of file jvector.h.

Referenced by Envelope::Calc\-Gradient(), Grid::Grid(), Envelope\-Constraint::Move\-Modelby\-Grad(), Grid::Re\-Size(), and Envelope::Upsize().\footnotesize\begin{verbatim}00069   { return set(0.0); }
00070 \end{verbatim}\normalsize 


\subsection{Friends And Related Function Documentation}
\index{jVector@{j\-Vector}!Covariance@{Covariance}}
\index{Covariance@{Covariance}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Covariance (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l21}




Definition at line 326 of file jvector.C.\footnotesize\begin{verbatim}00327   {
00328     if(x.L != y.L || x.L == 0)
00329         return INF;
00330     
00331     double x_mean = x.mean();
00332     double y_mean = y.mean();
00333     double cov = 0.0;
00334 
00335     for(int i=0; i<x.L; ++i)
00336         cov += (x[i] - x_mean)*(y[i] - y_mean);
00337     cov /= (x.L-1);
00338 
00339     return cov;
00340 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!JVAngle@{JVAngle}}
\index{JVAngle@{JVAngle}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double JVAngle (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l14}




Definition at line 152 of file jvector.C.\footnotesize\begin{verbatim}00153   { return acos( (x*y) / x.mag() / y.mag() ); }
00154 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!JVqsort@{JVqsort}}
\index{JVqsort@{JVqsort}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void JVqsort (j\-Vector \& {\em v})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l19}




Definition at line 329 of file jvector.h.

Referenced by median().\footnotesize\begin{verbatim}00329                          { qsort((void *) v.V, v.L, sizeof(double), dcomp); }
00330 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!VBPrintCircle@{VBPrintCircle}}
\index{VBPrintCircle@{VBPrintCircle}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& VBPrint\-Circle (ostream \& {\em os}, const j\-Vector \& {\em x}, const double \& {\em radius}, const {\bf Dyn\-String} \& {\em color})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l18}




Definition at line 264 of file jvector.C.\footnotesize\begin{verbatim}00266   {
00267     
00268     if((x.L>3) || (x.L<2)) return os;
00269     char old_delim = jVector::IODelimiter;
00270     jVector::IODelimiter = ',';
00271 
00272     if(x.L==3)
00273       os << "circle (" << x << ") " << radius << " :" << color;
00274     else if(x.L==2)
00275       os << "circle (" << x << ",0) " << radius << " :" << color;
00276     os << '\n';
00277     jVector::IODelimiter = old_delim;
00278     return os;
00279 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!VBPrintLine@{VBPrintLine}}
\index{VBPrintLine@{VBPrintLine}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& VBPrint\-Line (ostream \& {\em os}, const j\-Vector \& {\em x}, const j\-Vector \& {\em y}, const {\bf Dyn\-String} \& {\em color})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l16}




Definition at line 226 of file jvector.C.\footnotesize\begin{verbatim}00228   {
00229     if((x.L != y.L) || (x.L>3) || (y.L>3) || (x.L<1) || (y.L<1)) return os;
00230 
00231     char old_delim = jVector::IODelimiter;
00232     jVector::IODelimiter = ',';
00233 
00234     if(x.L==3)
00235       os << "line (" << x << ") (" << y << ") :" << color;
00236     else if(x.L==2)
00237       os << "line (" << x << ",0) (" << y << ",0) :" << color;
00238     else if(x.L==1)
00239       os << "line (" << x << "0,0) (" << y << "0,0) :" << color;
00240     os << '\n';
00241     jVector::IODelimiter = old_delim;
00242     return os;
00243 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!VBPrintPoint@{VBPrintPoint}}
\index{VBPrintPoint@{VBPrintPoint}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& VBPrint\-Point (ostream \& {\em os}, const j\-Vector \& {\em x}, const {\bf Dyn\-String} \& {\em color})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l17}




Definition at line 245 of file jvector.C.\footnotesize\begin{verbatim}00246   {
00247     
00248     if((x.L>3) || (x.L<1)) return os;
00249     char old_delim = jVector::IODelimiter;
00250     jVector::IODelimiter = ',';
00251 
00252     if(x.L==3)
00253       os << "point " << x << " :" << color;
00254     else if(x.L==2)
00255       os << "point " << x << ",0 :" << color;
00256     else if(x.L==1)
00257       os << "point " << x << ",0,0 :" << color;
00258     os << '\n';
00259     jVector::IODelimiter = old_delim;
00260     return os;
00261 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!binsearch@{binsearch}}
\index{binsearch@{binsearch}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int binsearch (const j\-Vector \& {\em v}, double {\em d})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l20}




Definition at line 299 of file jvector.h.\footnotesize\begin{verbatim}00300 {
00301   // left index, right index, pivot, respectively.
00302   //
00303   int i=0;
00304   int j=v.L-1;
00305   int p;
00306 
00307   while((i<=j) && (j>=0))
00308     {
00309       p = (j+i)/2;
00310       if(d < v.V[p]) j = p-1;
00311       else if(d > v.V[p]) i = p+1;
00312       else return p;
00313     }
00314 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!euclid@{euclid}}
\index{euclid@{euclid}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double euclid (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l15}




Definition at line 155 of file jvector.C.\footnotesize\begin{verbatim}00156   {
00157     if(x.L != y.L) return -1.0;
00158     double sumproducts = 0.0;
00159     for(int i=0; i<x.L; ++i) sumproducts += pow(x.V[i]-y.V[i], 2.0);
00160     return sqrt(sumproducts);
00161 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator *@{operator $\ast$}}
\index{operator *@{operator $\ast$}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator $\ast$ (double {\em d}, j\-Vector {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l11}




Definition at line 141 of file jvector.C.\footnotesize\begin{verbatim}00141                                          { return y*=d; }
00142 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator *@{operator $\ast$}}
\index{operator *@{operator $\ast$}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator $\ast$ (j\-Vector {\em y}, double {\em d})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l10}




Definition at line 140 of file jvector.C.\footnotesize\begin{verbatim}00140                                          { return y*=d; }
00141 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator *@{operator $\ast$}}
\index{operator *@{operator $\ast$}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double operator $\ast$ (j\-Vector {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l8}




Definition at line 124 of file jvector.C.\footnotesize\begin{verbatim}00125 {
00126   double product_sum=0.0;
00127   if(x.L == y.L) for(int i=0; i<x.L; ++i) product_sum += x.V[i]*y.V[i];
00128   return product_sum;
00129 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator"!=@{operator"!=}}
\index{operator"!=@{operator"!=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int operator!= (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l1}




Definition at line 152 of file jvector.h.\footnotesize\begin{verbatim}00153   { return !(x == y); }
00154 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator\%@{operator\%}}
\index{operator\%@{operator\%}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator\% (j\-Vector {\em x}, double {\em d})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l13}




Definition at line 149 of file jvector.C.\footnotesize\begin{verbatim}00150   { return x%=d; }
00151 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator\%@{operator\%}}
\index{operator\%@{operator\%}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator\% (j\-Vector {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l9}




Definition at line 134 of file jvector.C.\footnotesize\begin{verbatim}00134                                                   { return x %= y; }
00135 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator+@{operator+}}
\index{operator+@{operator+}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator+ (j\-Vector {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l7}




Definition at line 121 of file jvector.C.\footnotesize\begin{verbatim}00121                                                  { return (x += y); }
00122 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator-@{operator-}}
\index{operator-@{operator-}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator- (j\-Vector {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l6}




Definition at line 117 of file jvector.C.\footnotesize\begin{verbatim}00117                                                  { return (x -= y); }
00118 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator/@{operator/}}
\index{operator/@{operator/}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector operator/ (j\-Vector {\em y}, double {\em d})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l12}




Definition at line 145 of file jvector.C.\footnotesize\begin{verbatim}00145                                          { return y/=d; }
00146 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator<@{operator$<$}}
\index{operator<@{operator$<$}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int operator$<$ (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l2}




Definition at line 154 of file jvector.h.\footnotesize\begin{verbatim}00155   {
00156     if(x.L < y.L) return 1;
00157     else if(x.L > y.L) return 0;
00158     // If the vectors are the same size:
00159     for(int i=x.L-1; i>=0; --i)
00160       {
00161         if(x.V[i] > y.V[i]) return 0;
00162         else if(x.V[i] < y.V[i]) return 1;
00163       }
00164 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator<=@{operator$<$=}}
\index{operator<=@{operator$<$=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int operator$<$= (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l4}




Definition at line 178 of file jvector.h.\footnotesize\begin{verbatim}00179   {
00180     if(x.L < y.L) return 1;
00181     else if(x.L > y.L) return 0;
00182     // If the vectors are the same size:
00183     for(int i=x.L-1; i>=0; --i)
00184       {
00185         if(x.V[i] > y.V[i]) return 0;
00186         else if(x.V[i] < y.V[i]) return 1;
00187       }
00188 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator==@{operator==}}
\index{operator==@{operator==}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int operator== (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l0}


Comparison operators.



Definition at line 145 of file jvector.h.\footnotesize\begin{verbatim}00146   {
00147     if((x.L != y.L) || (x.vert != y.vert)) return 0;
00148     for(int i=x.L-1; i>=0; --i)
00149       if(x.V[i] != y.V[i]) return 0;
00150     return 1;
00151 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator>@{operator$>$}}
\index{operator>@{operator$>$}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int operator$>$ (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l3}




Definition at line 166 of file jvector.h.\footnotesize\begin{verbatim}00167   {
00168     if(x.L > y.L) return 1;
00169     else if(x.L < y.L) return 0;
00170     // If the vectors are the same size:
00171     for(int i=x.L-1; i>=0; --i)
00172       {
00173         if(x.V[i] < y.V[i]) return 0;
00174         else if(x.V[i] > y.V[i]) return 1;
00175       }
00176 \end{verbatim}\normalsize 
\index{jVector@{j\-Vector}!operator>=@{operator$>$=}}
\index{operator>=@{operator$>$=}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int operator$>$= (const j\-Vector \& {\em x}, const j\-Vector \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_jVector_l5}




Definition at line 190 of file jvector.h.\footnotesize\begin{verbatim}00191   {
00192     if(x.L > y.L) return 1;
00193     else if(x.L < y.L) return 0;
00194     // If the vectors are the same size:
00195     for(int i=x.L-1; i>=0; --i)
00196       {
00197         if(x.V[i] < y.V[i]) return 0;
00198         else if(x.V[i] > y.V[i]) return 1;
00199       }
00200 \end{verbatim}\normalsize 


\subsection{Member Data Documentation}
\index{jVector@{j\-Vector}!CreationLength@{CreationLength}}
\index{CreationLength@{CreationLength}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::Creation\-Length = {\bf DEFAULTLEN}\hspace{0.3cm}{\tt  [static]}}\label{class_jVector_p0}




Definition at line 15 of file jvector.C.\index{jVector@{j\-Vector}!IODelimiter@{IODelimiter}}
\index{IODelimiter@{IODelimiter}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char j\-Vector::IODelimiter = \hspace{0.3cm}{\tt  [static]}}\label{class_jVector_p1}




Definition at line 16 of file jvector.C.\index{jVector@{j\-Vector}!L@{L}}
\index{L@{L}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int j\-Vector::L\hspace{0.3cm}{\tt  [private]}}\label{class_jVector_o1}




Definition at line 291 of file jvector.h.\index{jVector@{j\-Vector}!V@{V}}
\index{V@{V}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double $\ast$ j\-Vector::V\hspace{0.3cm}{\tt  [private]}}\label{class_jVector_o0}




Definition at line 290 of file jvector.h.\index{jVector@{j\-Vector}!Zero@{Zero}}
\index{Zero@{Zero}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}j\-Vector j\-Vector::Zero\hspace{0.3cm}{\tt  [static]}}\label{class_jVector_p2}




Definition at line 18 of file jvector.C.\index{jVector@{j\-Vector}!vert@{vert}}
\index{vert@{vert}!jVector@{j\-Vector}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf usint} j\-Vector::vert\hspace{0.3cm}{\tt  [private]}}\label{class_jVector_o2}




Definition at line 293 of file jvector.h.

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