\section{A\-I\-D\-A\-:\-:I\-Tuple\-R\-O\-O\-T Class Reference}
\label{classAIDA_1_1ITupleROOT}\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}


User level interface to a Tuple.  




{\ttfamily \#include $<$I\-Tuple\-R\-O\-O\-T.\-h$>$}

Inheritance diagram for A\-I\-D\-A\-:\-:I\-Tuple\-R\-O\-O\-T\-:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=2.000000cm]{classAIDA_1_1ITupleROOT}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item 
{\bf I\-Tuple\-R\-O\-O\-T} (const std\-::string \&name, const std\-::string \&{\bf title}, const std\-::vector$<$ std\-::string $>$ \&{\bf column\-Names}, const std\-::vector$<$ std\-::string $>$ \&{\bf column\-Type}, const std\-::string \&options=\char`\"{}\char`\"{})\label{classAIDA_1_1ITupleROOT_a86e7033ec048c062babb5687259bb36c}

\begin{DoxyCompactList}\small\item\em Constructor. \end{DoxyCompactList}\item 
virtual {\bf $\sim$\-I\-Tuple\-R\-O\-O\-T} ()\label{classAIDA_1_1ITupleROOT_afa8b4495e47002705d9086be23e49576}

\begin{DoxyCompactList}\small\item\em Destructor. \end{DoxyCompactList}\item 
virtual std\-::string {\bf title} () const 
\begin{DoxyCompactList}\small\item\em Get the title of this \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \end{DoxyCompactList}\item 
virtual bool {\bf set\-Title} (const std\-::string \&{\bf title})
\begin{DoxyCompactList}\small\item\em Set the title of the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, double value)
\begin{DoxyCompactList}\small\item\em Get the \doxyref{I\-Annotation}{p.}{classAIDA_1_1IAnnotation} corresponding to this \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, float value)
\begin{DoxyCompactList}\small\item\em Fill a given column with a float. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, int value)
\begin{DoxyCompactList}\small\item\em Fill a given column with an integer. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, short value)
\begin{DoxyCompactList}\small\item\em Fill a given column with a short. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, long value)
\begin{DoxyCompactList}\small\item\em Fill a given column with a long. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, char value)
\begin{DoxyCompactList}\small\item\em Fill a given column with a char. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (int column, bool value)
\begin{DoxyCompactList}\small\item\em Fill a given column with a boolean. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (const std\-::vector$<$ double $>$ \&values)
\begin{DoxyCompactList}\small\item\em Fill a given column with a string. \end{DoxyCompactList}\item 
virtual bool {\bf fill} (const std\-::vector$<$ float $>$ \&values)
\begin{DoxyCompactList}\small\item\em Fill all the columns at once with floats. \end{DoxyCompactList}\item 
virtual bool {\bf add\-Row} ()
\begin{DoxyCompactList}\small\item\em Add the current row to the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \end{DoxyCompactList}\item 
virtual void {\bf reset\-Row} ()\label{classAIDA_1_1ITupleROOT_a01cc6e8997c2e2e6b511ce7c934ddc6c}

\begin{DoxyCompactList}\small\item\em Clear the current(not yet added) row. \end{DoxyCompactList}\item 
virtual void {\bf reset} ()
\begin{DoxyCompactList}\small\item\em Reset the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \end{DoxyCompactList}\item 
virtual int {\bf rows} () const 
\begin{DoxyCompactList}\small\item\em Get the number of rows currently filled in the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \end{DoxyCompactList}\item 
virtual void {\bf start} ()\label{classAIDA_1_1ITupleROOT_ae0902f9aa1124652851bf68cbe28b00e}

\begin{DoxyCompactList}\small\item\em Positions the read cursor immediately before the first row. \end{DoxyCompactList}\item 
virtual bool {\bf skip} (int {\bf rows})
\begin{DoxyCompactList}\small\item\em Skips a given number of rows. \end{DoxyCompactList}\item 
virtual bool {\bf next} ()
\begin{DoxyCompactList}\small\item\em Positions the cursor at the next row. \end{DoxyCompactList}\item 
virtual bool {\bf set\-Row} (int row\-Index)
\begin{DoxyCompactList}\small\item\em Position the cursor at a give row. \end{DoxyCompactList}\item 
virtual bool {\bfseries my\-Set\-Row} (int row\-Index) const \label{classAIDA_1_1ITupleROOT_a2f761ef50185423dee4dcf0daf141b42}

\item 
virtual int {\bf find\-Column} (const std\-::string \&name) const 
\begin{DoxyCompactList}\small\item\em Get the index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} of a given column. \end{DoxyCompactList}\item 
virtual double {\bf get\-Double} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the double stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual float {\bf get\-Float} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the float stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual int {\bf get\-Int} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the integer stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual short {\bf get\-Short} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the short stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual long {\bf get\-Long} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the long stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual char {\bf get\-Char} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the character stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual bool {\bf get\-Boolean} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the boolean stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual int {\bf columns} () const 
\begin{DoxyCompactList}\small\item\em Get the string stored in a given column at the current cursor's position. \end{DoxyCompactList}\item 
virtual std\-::string {\bf column\-Name} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the name of a column from its index. \end{DoxyCompactList}\item 
virtual std\-::vector$<$ std\-::string $>$ {\bf column\-Names} () const 
\begin{DoxyCompactList}\small\item\em Get the names of all the columns. \end{DoxyCompactList}\item 
virtual std\-::string {\bf column\-Type} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the type of a give column. \end{DoxyCompactList}\item 
virtual std\-::vector$<$ std\-::string $>$ {\bf column\-Types} () const 
\begin{DoxyCompactList}\small\item\em Get the types of all the columns. \end{DoxyCompactList}\item 
virtual double {\bf column\-Min} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the minimum value of a given column (if it can be converted to a double). \end{DoxyCompactList}\item 
virtual double {\bf column\-Max} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the maximum value of a given column (if it can be converted to a double). \end{DoxyCompactList}\item 
virtual double {\bf column\-Mean} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the mean value of a given column (if it can be converted to a double). \end{DoxyCompactList}\item 
virtual double {\bf column\-Rms} (int column) const 
\begin{DoxyCompactList}\small\item\em Get the R\-M\-S of a given column (if it can be converted to a double). \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram1\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram1\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram1\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram1\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram2\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram2\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram2\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram2\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram3\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram3\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram3\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Histogram3\-D} \&histogram, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud1\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud1\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud1\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud1\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud2\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud2\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud2\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud2\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud3\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud3\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud3\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Cloud3\-D} \&cloud, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile1\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile1\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile1\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile1\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile2\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile2\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Filter} \&filter)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile2\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. \end{DoxyCompactList}\item 
virtual bool {\bf project} ({\bf I\-Profile2\-D} \&profile, {\bf I\-Evaluator} \&evaluator\-X, {\bf I\-Evaluator} \&evaluator\-Y, {\bf I\-Evaluator} \&evaluator\-Z, {\bf I\-Filter} \&filter, {\bf I\-Evaluator} \&weight)
\begin{DoxyCompactList}\small\item\em Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Protected Attributes}
\begin{DoxyCompactItemize}
\item 
T\-Tree $\ast$ {\bf \-\_\-the\-Tree}
\begin{DoxyCompactList}\small\item\em See \doxyref{I\-Managed\-Object}{p.}{classAIDA_1_1IManagedObject} for a description. \end{DoxyCompactList}\item 
std\-::vector$<$ {\bf Leaf\-Point} $>$ {\bfseries \-\_\-point\-Vec}\label{classAIDA_1_1ITupleROOT_aa77a160707e22120d4c59698184459f3}

\item 
std\-::vector$<$ {\bf Leaf\-Point} $>$ {\bfseries \-\_\-read\-Point\-Vec}\label{classAIDA_1_1ITupleROOT_ac69611fe0bf05232e369eb3ca3cd8d12}

\item 
int {\bfseries \-\_\-read\-Cursor}\label{classAIDA_1_1ITupleROOT_aae12882928fe6daf08befb07b8139bc0}

\end{DoxyCompactItemize}


\subsection{Detailed Description}
User level interface to a Tuple. 

\begin{DoxyAuthor}{Author}
T. Kraemer, D\-E\-S\-Y 
\end{DoxyAuthor}
\begin{DoxyVersion}{Version}

\end{DoxyVersion}
\begin{DoxyParagraph}{Id\-:}
\doxyref{I\-Tuple\-R\-O\-O\-T.\-h}{p.}{ITupleROOT_8h_source},v 1.\-3 2006-\/12-\/04 17\-:24\-:06 tkraemer Exp 
\end{DoxyParagraph}


\subsection{Member Function Documentation}
\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!add\-Row@{add\-Row}}
\index{add\-Row@{add\-Row}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{add\-Row}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::add\-Row (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ad0fe7acf12492a45d643710e471f31c0}


Add the current row to the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. 

This method should be called after fill has been called for the columns; unfilled columns will be filled with their default value. \begin{DoxyReturn}{Returns}
false When the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} runs out of storage space. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_adfacdefe414d762f28b4b34e352e4b09}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Max@{column\-Max}}
\index{column\-Max@{column\-Max}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Max}]{\setlength{\rightskip}{0pt plus 5cm}double I\-Tuple\-R\-O\-O\-T\-::column\-Max (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a85ecade0542193903ebb4c3242890330}


Get the maximum value of a given column (if it can be converted to a double). 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The column's maximum value. In Java Double.\-Na\-N might be returned. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ae782756f39d533098dbd176ee55cf40a}.



References \-\_\-the\-Tree, and rows().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Mean@{column\-Mean}}
\index{column\-Mean@{column\-Mean}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Mean}]{\setlength{\rightskip}{0pt plus 5cm}double I\-Tuple\-R\-O\-O\-T\-::column\-Mean (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ad078e6e0b8e13930120340e8600cb5c3}


Get the mean value of a given column (if it can be converted to a double). 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The column's mean value. In Java Double.\-Na\-N might be returned. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_afe97d4ac6b85f4dd4efa832b203f8056}.



References get\-Double(), and rows().



Referenced by column\-Rms().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Min@{column\-Min}}
\index{column\-Min@{column\-Min}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Min}]{\setlength{\rightskip}{0pt plus 5cm}double I\-Tuple\-R\-O\-O\-T\-::column\-Min (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a36776369d8b0c1aa0a2c09134b7c008a}


Get the minimum value of a given column (if it can be converted to a double). 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The column's minimum value. In Java Double.\-Na\-N might be returned. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a84de47b5a916d5bbc0b740fc26772fdd}.



References \-\_\-the\-Tree, and rows().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Name@{column\-Name}}
\index{column\-Name@{column\-Name}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Name}]{\setlength{\rightskip}{0pt plus 5cm}std\-::string I\-Tuple\-R\-O\-O\-T\-::column\-Name (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a6291341d7ce7599efeed3c52f208a2b2}


Get the name of a column from its index. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The column's name. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_af45f206d812a39efde4c045ba560d952}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Names@{column\-Names}}
\index{column\-Names@{column\-Names}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Names}]{\setlength{\rightskip}{0pt plus 5cm}std\-::vector$<$ std\-::string $>$ I\-Tuple\-R\-O\-O\-T\-::column\-Names (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a2e8e8c6945d7378a3d520039cd6bb39e}


Get the names of all the columns. 

\begin{DoxyReturn}{Returns}
The column names. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a3ae830d75f243d80b9bcaf6fc260d7c8}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Rms@{column\-Rms}}
\index{column\-Rms@{column\-Rms}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Rms}]{\setlength{\rightskip}{0pt plus 5cm}double I\-Tuple\-R\-O\-O\-T\-::column\-Rms (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a57892be3ffc8e6cdee666241d6202186}


Get the R\-M\-S of a given column (if it can be converted to a double). 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The column's R\-M\-S. In Java Double.\-Na\-N might be returned. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a523d1c302eb42ada65036f460c0a60e0}.



References column\-Mean(), get\-Double(), and rows().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!columns@{columns}}
\index{columns@{columns}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{columns}]{\setlength{\rightskip}{0pt plus 5cm}int I\-Tuple\-R\-O\-O\-T\-::columns (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a5f983d29b854fc05f8fa505e00515423}


Get the string stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The string.\-virtual std\-::string get\-String(int column) const ; Get the object stored in a given column at the current cursor's position. 
\end{DoxyReturn}

\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The object.\-virtual const \doxyref{I\-Tuple\-Entry}{p.}{classAIDA_1_1ITupleEntry} $\ast$ get\-Object(int column) const ; Return method for tuple variables of type \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} for a given column. This method can be used in order to fill a tuple variable in the master tuple. 
\end{DoxyReturn}

\begin{DoxyParams}{Parameters}
{\em column} & The column's index. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} representing the structure of this column.\-virtual const \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} $\ast$ get\-Tuple(int column) const ; virtual \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} $\ast$ get\-Tuple(int column) ; Get the number of columns in the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} 

The number of columns. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a4df10e95c16848de5f7fd8e90ae6f90a}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Type@{column\-Type}}
\index{column\-Type@{column\-Type}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Type}]{\setlength{\rightskip}{0pt plus 5cm}std\-::string I\-Tuple\-R\-O\-O\-T\-::column\-Type (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ad0633d41a9a8bc276a0b9f7fa5e4f908}


Get the type of a give column. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's type. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The column's Class. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a8481e759715afd538815947751c67da8}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!column\-Types@{column\-Types}}
\index{column\-Types@{column\-Types}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{column\-Types}]{\setlength{\rightskip}{0pt plus 5cm}std\-::vector$<$ std\-::string $>$ I\-Tuple\-R\-O\-O\-T\-::column\-Types (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_aeaa314c07a6340f3aab3d3305683c0b1}


Get the types of all the columns. 

\begin{DoxyReturn}{Returns}
The column Classes. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a3c535b2205351e64dc4e0cbe12d0d6b7}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{double}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ae5b4e278d9fe47ce1cfe5808a07f3172}


Get the \doxyref{I\-Annotation}{p.}{classAIDA_1_1IAnnotation} corresponding to this \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. 

\begin{DoxyReturn}{Returns}
The \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}'s I\-Annotation.\-virtual \doxyref{I\-Annotation}{p.}{classAIDA_1_1IAnnotation} \& annotation() ; virtual const \doxyref{I\-Annotation}{p.}{classAIDA_1_1IAnnotation} \& annotation() const ; Fill a given column with a double. 
\end{DoxyReturn}

\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The double. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a2daec1d00ccb702a3170d2046839a555}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{float}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a0421892798583f51e240c91372ce48a9}


Fill a given column with a float. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The float. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ac452efe9ec51481919828a257dbcab9f}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{int}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a8d187ac2b08fe1d9e68d6d555aa31ba1}


Fill a given column with an integer. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The integer. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a410559d1568e4b082280b5d968a2cecb}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{short}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a7fb8a229fb2a33aa390660cac1730dd9}


Fill a given column with a short. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The short. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a098471bb08fa575740b5ee233e74777f}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{long}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a93e57aa0db69109c50451d03b89997af}


Fill a given column with a long. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The long. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a5238a419dcffaf12d96725b89dc51907}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{char}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a430910d091c9d559dcc9194f8b27fc0f}


Fill a given column with a char. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The char. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a72f75227be55f0c58665e1e5ee4081a6}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{int}]{column, }
\item[{bool}]{value}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a38496638277f8a6a6ed20fa489804cf6}


Fill a given column with a boolean. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The boolean. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a261cbe2c7697952ddc0e5a5c04cd4de5}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{const std\-::vector$<$ double $>$ \&}]{values}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a6fc87b33417948889122e03fe8746304}


Fill a given column with a string. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The string. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type.\-virtual bool fill(int column, const std\-::string \& value) ; Fill a given column with an object. 
\end{DoxyReturn}

\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
{\em value} & The object. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the column is of the wrong type.\-virtual bool fill(int column, const I\-Tuple\-Entry \& value) ; Fill all the columns at once with doubles. 
\end{DoxyReturn}

\begin{DoxyParams}{Parameters}
{\em values} & The array of doubles. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If any column is not of type double or if the array has the wrong dimension. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a13d29a8c48ee7bd09e4f354a49b75b88}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!fill@{fill}}
\index{fill@{fill}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{fill}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::fill (
\begin{DoxyParamCaption}
\item[{const std\-::vector$<$ float $>$ \&}]{values}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ada6273f0d79071b6342f5bda5ffbaac1}


Fill all the columns at once with floats. 


\begin{DoxyParams}{Parameters}
{\em values} & The array of floats. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If any column is not of type float or if the array has the wrong dimension. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ab0571c404d72f94264ee65c19f280978}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!find\-Column@{find\-Column}}
\index{find\-Column@{find\-Column}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{find\-Column}]{\setlength{\rightskip}{0pt plus 5cm}int I\-Tuple\-R\-O\-O\-T\-::find\-Column (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{name}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a6e5106d1b3244c4322311c85280bd7d6}


Get the index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} of a given column. 


\begin{DoxyParams}{Parameters}
{\em name} & The colum's name. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The corresponding column's index. Note\-: in C++ -\/1 may be returned if the column does not exist. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a66d617a2dd9b2604958da6b756d44e30}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Boolean@{get\-Boolean}}
\index{get\-Boolean@{get\-Boolean}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Boolean}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::get\-Boolean (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a4d0ee13b8b24ce5e17f5e84b58496f15}


Get the boolean stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The boolean. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a2cebdbc8a21fd816c1ed60af873f1ec7}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Char@{get\-Char}}
\index{get\-Char@{get\-Char}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Char}]{\setlength{\rightskip}{0pt plus 5cm}char I\-Tuple\-R\-O\-O\-T\-::get\-Char (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ae772e7fda2d0214da96c3ca1b5001e4d}


Get the character stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The character. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_aba3a54fa58d8af29976c0eb784ab65dc}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Double@{get\-Double}}
\index{get\-Double@{get\-Double}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Double}]{\setlength{\rightskip}{0pt plus 5cm}double I\-Tuple\-R\-O\-O\-T\-::get\-Double (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a884a9eb19ee054641dae31d90f49d4c3}


Get the double stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The double. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ae733a4df5b0fbc9ce2ad31aefb7e35fe}.



References \-\_\-the\-Tree.



Referenced by column\-Mean(), and column\-Rms().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Float@{get\-Float}}
\index{get\-Float@{get\-Float}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Float}]{\setlength{\rightskip}{0pt plus 5cm}float I\-Tuple\-R\-O\-O\-T\-::get\-Float (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a4c909f57f7b13471f7991f816303b9bd}


Get the float stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The float. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a58394731ffe7050932edadde290442eb}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Int@{get\-Int}}
\index{get\-Int@{get\-Int}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Int}]{\setlength{\rightskip}{0pt plus 5cm}int I\-Tuple\-R\-O\-O\-T\-::get\-Int (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a14b48213d366ccff016f211fca113840}


Get the integer stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The integer. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a994ae4d4178f31cc1ca8ddffb29ab0a7}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Long@{get\-Long}}
\index{get\-Long@{get\-Long}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Long}]{\setlength{\rightskip}{0pt plus 5cm}long I\-Tuple\-R\-O\-O\-T\-::get\-Long (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a295ad347301248c25e09c8966959155e}


Get the long stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The long. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a1524c56db443a51f90b536e4bc354246}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!get\-Short@{get\-Short}}
\index{get\-Short@{get\-Short}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{get\-Short}]{\setlength{\rightskip}{0pt plus 5cm}short I\-Tuple\-R\-O\-O\-T\-::get\-Short (
\begin{DoxyParamCaption}
\item[{int}]{column}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a69a48fcb81c412fa2e32d269994a23c3}


Get the short stored in a given column at the current cursor's position. 


\begin{DoxyParams}{Parameters}
{\em column} & The column's index within the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The short. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a21bb9402ad4cbb9df4cf9f4f90f08782}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!next@{next}}
\index{next@{next}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{next}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::next (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_abc88882eb94412cd96482139bc202082}


Positions the cursor at the next row. 

\begin{DoxyReturn}{Returns}
false if there is no next row. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ae758eb14b05f61f187d8c31f61870d4d}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram1\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a7a67d15104a81080d191d118489fbc2e}


Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ac3d01a8c32ad8d3cd817fcf45ac4c947}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram1\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a13b47cb3b554bea906d46df2e03a37c9}


Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the histogram is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_aa5129085e28740f4553262523e2601db}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram1\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a8e7a84cc67d3f2dfdc48d12a35cb590e}


Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a13a8b514e6821c749c0901ba3451d629}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram1\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a1e1810b3c07b1c9807258c3cdb0d0803}


Fill an \doxyref{I\-Histogram1\-D}{p.}{classAIDA_1_1IHistogram1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the histogram is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ab529e90fff1934396ca06c5d0dc046db}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram2\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ab83d9590ebac03026889bef6c1ec5d91}


Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a0230bf51e18af816f8b6835403df2cab}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram2\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a2b9320fd1c0a7e2fd213888f887fe421}


Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the histogram is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a80ecda0e0bac273129be08364e8f106a}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram2\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a8bf26949bad1ccf37f6341f04abc2e45}


Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ad7406b78b15305ce3ad7b9e5196964dc}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram2\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a4bf2669b8cd7e86d57438c489108edeb}


Fill an \doxyref{I\-Histogram2\-D}{p.}{classAIDA_1_1IHistogram2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the histogram is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_abb3ea21ce02baee97016d1a39425fc5e}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram3\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_abfff2e47074ff3dd892e4d0a0e3841cd}


Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the histogram along the z axis. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a6255165ea1531dea9520e7952cc4c77d}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram3\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a49a1054b40eb19716d0edb5046f37c1c}


Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the histogram along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the histogram is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a9954484b6d55cb4b71ba94597db3f54f}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram3\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ae16bef0cd7bcd98acab47df255bdd9d3}


Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the histogram along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ade9afb6dfaae5244d74b153435d42ac1}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Histogram3\-D} \&}]{histogram, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_aa297d8b5b059d360325b5ef9add7b9b9}


Fill an \doxyref{I\-Histogram3\-D}{p.}{classAIDA_1_1IHistogram3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em histogram} & The histogram to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the histogram along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the histogram along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the histogram along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the histogram is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_acb4629a1af1b384c2f13fceb890c94f6}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud1\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a02a97f642bbcccd030863f1a51839039}


Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_af102c66c8d5f62206bebc7dca11ae62d}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud1\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a2267fb81ad04edd9535e39814737bf7e}


Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the cloud is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a9e4d257732865f34aa817ad0e287602b}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud1\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a8b9c4bbc3fc26554f58371889e666d7d}


Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a4eff5b827b24195aea8f630f8627f7c9}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud1\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a0a394e47f9ef87cc3e4391a11b5e9aac}


Fill an \doxyref{I\-Cloud1\-D}{p.}{classAIDA_1_1ICloud1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the cloud is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a19e0ae0941e5dd47c5f5962a2eb44e7e}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud2\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a8e7ffba9a7c22eed642a7b3a33b31ad2}


Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_aee56d39605679a2c3f1a1748659238fe}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud2\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_abee4f113372bb888602098e34e50ec2d}


Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the cloud is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a89d25b570bc9cb737c537e19fdbe8923}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud2\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_aeda7606b26548c0da96b6146828a05e2}


Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a8101e85d93ee1bfb0432f2f762a2260e}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud2\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_af1b71d9b8367c10357fa2128ce09e64c}


Fill an \doxyref{I\-Cloud2\-D}{p.}{classAIDA_1_1ICloud2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the cloud is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a0eabc26f45ac1036ed1fbb71e090b5c0}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud3\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a143ddf1ad74360c627cc7e328d529597}


Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the cloud along the z axis. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a07cc0d1803b76ef12514f4c3daeaef5b}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud3\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ab6c5f28a2ccab2e4dd79e6f9bacef655}


Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the cloud along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the cloud is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a4b56d0335dcfae25856a2ec11e62bea2}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud3\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a4a0967fb658d51f964efdc12314e7ecd}


Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the cloud along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a93aa4443dcd0730c81d91581d98b001e}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Cloud3\-D} \&}]{cloud, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a391a21bca252ea9a1aba62e8e629319d}


Fill an \doxyref{I\-Cloud3\-D}{p.}{classAIDA_1_1ICloud3D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em cloud} & The cloud to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the cloud along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the cloud along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the cloud along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the cloud is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a1053aa1f2a2048d60213b64fd4eeda16}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile1\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a38af8974912c0a989ca7ea5dfce4874b}


Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_abd215b7851db2bf51562e24126de0d5c}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile1\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_abf46c825e4e8a36aecb32135c3a75038}


Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the profile is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a25e7ef093733f5af88a310f541631739}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile1\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_adcd606e070676c6b479124e1d763f79a}


Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_aa1ef7a204513b5620703a33461b6287d}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile1\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a97e90f55ffc8a2b8979e4a871c8c7cbe}


Fill an \doxyref{I\-Profile1\-D}{p.}{classAIDA_1_1IProfile1D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the profile is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a1bafd6dac9e52e4edce13f47d980ecd0}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile2\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a9b1e175140d02aadc1e16e9fbe76e6dd}


Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the profile along the z axis. The value is computed from the current row of the tuple. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a59c95092dcaa457bae049dd51adb7f2a}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile2\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Filter} \&}]{filter}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a859b094f5cb0e69c3292d73781392808}


Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the profile along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the profile is not filled. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_aea955d340efd4cf4903b51f841b05f8b}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile2\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_ab76c50e9172f0e8fb53155463348d73b}


Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the profile along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_ae82f9ca0f8da538ac4a6a2d46d3fc84f}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!project@{project}}
\index{project@{project}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{project}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::project (
\begin{DoxyParamCaption}
\item[{{\bf I\-Profile2\-D} \&}]{profile, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-X, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Y, }
\item[{{\bf I\-Evaluator} \&}]{evaluator\-Z, }
\item[{{\bf I\-Filter} \&}]{filter, }
\item[{{\bf I\-Evaluator} \&}]{weight}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_aaea06a23d9e85c8423fc09c7f360700b}


Fill an \doxyref{I\-Profile2\-D}{p.}{classAIDA_1_1IProfile2D} from the tuple. 


\begin{DoxyParams}{Parameters}
{\em profile} & The profile to fill. \\
\hline
{\em evaluator\-X} & The evaluator used to compute the value to be filled in the profile along the x axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Y} & The evaluator used to compute the value to be filled in the profile along the y axis. The value is computed from the current row of the tuple. \\
\hline
{\em evaluator\-Z} & The evaluator used to compute the value to be filled in the profile along the z axis. The value is computed from the current row of the tuple. \\
\hline
{\em filter} & The filter object used to accept or not the current row. If rejected, the profile is not filled. \\
\hline
{\em weight} & The evaluator which determines the weight which is used during the filling. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If something goes wrong. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a148ae30dcea5dae04be68eaf89680f21}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!reset@{reset}}
\index{reset@{reset}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{reset}]{\setlength{\rightskip}{0pt plus 5cm}void I\-Tuple\-R\-O\-O\-T\-::reset (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a5b2db4c21c9ea2e268a1d9f181d578cf}


Reset the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. 

All the rows are reset. The \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple} is as just created. 

Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_afb25168e04f85d3ca7d9380da5bba16c}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!rows@{rows}}
\index{rows@{rows}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{rows}]{\setlength{\rightskip}{0pt plus 5cm}int I\-Tuple\-R\-O\-O\-T\-::rows (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a32f412521162b78d417191e552870f8e}


Get the number of rows currently filled in the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. 

\begin{DoxyReturn}{Returns}
The number of rows. -\/1 if empty or if it cannot be determined. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a56ffec3cbbc7dca39ba2dbfecef6cee7}.



References \-\_\-the\-Tree.



Referenced by column\-Max(), column\-Mean(), column\-Min(), column\-Rms(), and skip().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!set\-Row@{set\-Row}}
\index{set\-Row@{set\-Row}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{set\-Row}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::set\-Row (
\begin{DoxyParamCaption}
\item[{int}]{row\-Index}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a8b200a960815e1a85479fc4de3e4af7a}


Position the cursor at a give row. 


\begin{DoxyParams}{Parameters}
{\em row\-Index} & The row where the cursor has to be positioned. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If the cursor cannot be positioned at the give row. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a8650d4f08688f5a164dfd921a39249e0}.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!set\-Title@{set\-Title}}
\index{set\-Title@{set\-Title}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{set\-Title}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::set\-Title (
\begin{DoxyParamCaption}
\item[{const std\-::string \&}]{title}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a5b1a59e463036f67dc9639f42812a7b7}


Set the title of the \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. 


\begin{DoxyParams}{Parameters}
{\em title} & The new \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}'s title. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If title cannot be changed. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a6faff8869b61a35caceeb40d30cde70e}.



References \-\_\-the\-Tree.

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!skip@{skip}}
\index{skip@{skip}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{skip}]{\setlength{\rightskip}{0pt plus 5cm}bool I\-Tuple\-R\-O\-O\-T\-::skip (
\begin{DoxyParamCaption}
\item[{int}]{rows}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_afaedd455cc559f459e7a882294ed4fec}


Skips a given number of rows. 


\begin{DoxyParams}{Parameters}
{\em rows} & The number of rows to skip. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
false If rows is less than zero or if it is not possible to perform the jump. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_a4167927b410f737c17841a0e3f9e9d4a}.



References \-\_\-the\-Tree, and rows().

\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!title@{title}}
\index{title@{title}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{title}]{\setlength{\rightskip}{0pt plus 5cm}std\-::string I\-Tuple\-R\-O\-O\-T\-::title (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily [virtual]}}\label{classAIDA_1_1ITupleROOT_a005168fe13153f2e0bbd77030ee5793d}


Get the title of this \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}. 

\begin{DoxyReturn}{Returns}
The \doxyref{I\-Tuple}{p.}{classAIDA_1_1ITuple}'s title. 
\end{DoxyReturn}


Implements {\bf A\-I\-D\-A\-::\-I\-Tuple} \doxyref{}{p.}{classAIDA_1_1ITuple_af031aa2cbf36f66e7beac265c523f2a8}.



References \-\_\-the\-Tree.



\subsection{Member Data Documentation}
\index{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}!\-\_\-the\-Tree@{\-\_\-the\-Tree}}
\index{\-\_\-the\-Tree@{\-\_\-the\-Tree}!AIDA::ITupleROOT@{A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T}}
\subsubsection[{\-\_\-the\-Tree}]{\setlength{\rightskip}{0pt plus 5cm}T\-Tree$\ast$ A\-I\-D\-A\-::\-I\-Tuple\-R\-O\-O\-T\-::\-\_\-the\-Tree\hspace{0.3cm}{\ttfamily [protected]}}\label{classAIDA_1_1ITupleROOT_a618095bae264d62105114be5e5703589}


See \doxyref{I\-Managed\-Object}{p.}{classAIDA_1_1IManagedObject} for a description. 


\begin{DoxyParams}{Parameters}
{\em class\-Name} & The name of the class to cast on. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The right pointer. Return 0 if failure.\-virtual void $\ast$ cast(const std\-::string \& class\-Name) const ; 
\end{DoxyReturn}


Referenced by add\-Row(), column\-Max(), column\-Min(), get\-Boolean(), get\-Char(), get\-Double(), get\-Float(), get\-Int(), get\-Long(), get\-Short(), I\-Tuple\-R\-O\-O\-T(), next(), rows(), set\-Title(), skip(), and title().



The documentation for this class was generated from the following files\-:\begin{DoxyCompactItemize}
\item 
I\-Tuple\-R\-O\-O\-T.\-h\item 
I\-Tuple\-R\-O\-O\-T.\-cc\end{DoxyCompactItemize}
