\section{mlpack\+:\+:bindings\+:\+:r Namespace Reference}
\label{namespacemlpack_1_1bindings_1_1r}\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsection*{Classes}
\begin{DoxyCompactItemize}
\item 
class \textbf{ R\+Option}
\begin{DoxyCompactList}\small\item\em The R option class. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Default\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Return the default value of an option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::string $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ mlpack\+::data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of an option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a vector option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::string $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a string option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if\+\_\+c$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value$\vert$$\vert$std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ mlpack\+::data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a matrix option, a tuple option, a serializable option, or a string option (this returns the default filename, or \textquotesingle{}\textquotesingle{} if the default is no file). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a model option (this returns the default filename, or \textquotesingle{}\textquotesingle{} if the default is no file). \end{DoxyCompactList}\item 
std\+::string \textbf{ Get\+Binding\+Name} (const std\+::string \&binding\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a binding, print its R name. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Param} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em All R binding types are exactly what is held in the Param\+Data, so no special handling is necessary. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print an option of a simple type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a vector option, with spaces between it. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a matrix option (this prints its size). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a serializable class option (this prints the class name). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a combination Dataset\+Info/matrix parameter. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Print an option into a std\+::string. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ bool $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ double $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ int $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ size\+\_\+t $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ size\+\_\+t $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ size\+\_\+t $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ size\+\_\+t $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ size\+\_\+t, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ std\+::string $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+R\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+R\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+R\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+R\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+R\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+R\+Type$<$ bool $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+R\+Type$<$ double $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+R\+Type$<$ int $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+R\+Type$<$ size\+\_\+t $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ size\+\_\+t $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ size\+\_\+t $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ size\+\_\+t $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ size\+\_\+t, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+R\+Type$<$ std\+::string $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Function is used to generate the type names that are used in calls to functions like I\+O\+\_\+\+Set\+Param$<$type$>$() or set\+Param$<$type$>$(), and therefore what\textquotesingle{}s returned isn\textquotesingle{}t exactly the R native type used for that parameter type. \end{DoxyCompactList}\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ bool $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ double $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ float $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ float, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ int $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ std\+::string $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
bool \textbf{ Ignore\+Check} (const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Print whether or not we should ignore a check on the given parameter. \end{DoxyCompactList}\item 
bool \textbf{ Ignore\+Check} (const std\+::vector$<$ std\+::string $>$ \&constraints)
\begin{DoxyCompactList}\small\item\em Print whether or not we should ignore a check on the given set of constraints. \end{DoxyCompactList}\item 
bool \textbf{ Ignore\+Check} (const std\+::vector$<$ std\+::pair$<$ std\+::string, bool $>$$>$ \&constraints, const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Print whether or not we should ignore a check on the given set of constraints. \end{DoxyCompactList}\item 
std\+::string \textbf{ Param\+String} (const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Given the parameter name, determine what it would actually be when passed to the command line. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Dataset} (const std\+::string \&dataset\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a matrix, print it. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Default} (const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Given a parameter name, print its corresponding default value. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Doc} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Print the docstring documentation for a given parameter. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Import} ()
\begin{DoxyCompactList}\small\item\em Print any import information for the R binding. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Input\+Option\+Info} ()
\begin{DoxyCompactList}\small\item\em Print any special information about input options. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Input\+Options} ()
\begin{DoxyCompactList}\small\item\em Recursion base case. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T , typename... Args$>$ }\\std\+::string \textbf{ Print\+Input\+Options} (const std\+::string \&param\+Name, const T \&value, Args... args)
\begin{DoxyCompactList}\small\item\em Print an input option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Param} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the declaration of an input parameter as part of a line in a R function definition. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a standard option type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\item 
std\+::string \textbf{ Print\+Model} (const std\+::string \&model\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a model, print it. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Output\+Option\+Info} ()
\begin{DoxyCompactList}\small\item\em Print any special information about output options. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Output\+Options} (const bool)
\begin{DoxyCompactList}\small\item\em Recursion base case. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T , typename... Args$>$ }\\std\+::string \textbf{ Print\+Output\+Options} (const bool markdown, const std\+::string \&param\+Name, const T \&value, Args... args)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a regular parameter type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a serializable model. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\item 
void \textbf{ PrintR} (const \textbf{ util\+::\+Binding\+Details} \&doc, const std\+::string \&function\+Name)
\begin{DoxyCompactList}\small\item\em Print the code for a .R binding for an mlpack program to stdout. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Serialize\+Util} (\textbf{ util\+::\+Param\+Data} \&, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em If the type is not serializable, print nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Serialize\+Util} (\textbf{ util\+::\+Param\+Data} \&, const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Matrices are serializable but here we also print nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Serialize\+Util} (\textbf{ util\+::\+Param\+Data} \&d, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em For non-\/matrix serializable types we need to print something. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Serialize\+Util} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of an option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename std\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a vector. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a matrix option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename std\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a matrix tuple option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a model. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Print the command-\/line type of an option into a string. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Value} (const T \&value, bool quotes)
\begin{DoxyCompactList}\small\item\em Given a parameter type, print the corresponding value. \end{DoxyCompactList}\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Print\+Value} (const bool \&value, bool quotes)
\begin{DoxyCompactList}\small\item\em Special overload for booleans. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename... Args$>$ }\\std\+::string \textbf{ Program\+Call} (const bool markdown, const std\+::string \&program\+Name, Args... args)
\begin{DoxyCompactList}\small\item\em Given a name of a binding and a variable number of arguments (and their contents), print the corresponding function call. \end{DoxyCompactList}\item 
std\+::string \textbf{ Program\+Call} (const std\+::string \&program\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a binding, print a program call assuming that all options are specified. \end{DoxyCompactList}\end{DoxyCompactItemize}


\subsection{Function Documentation}
\mbox{\label{namespacemlpack_1_1bindings_1_1r_a60b48cbfcab8cd0d8cf3fb24ce42cc2e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Default\+Param@{Default\+Param}}
\index{Default\+Param@{Default\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Default\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Default\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Return the default value of an option. 

This is the function that will be placed into the \doxyref{IO}{p.}{classmlpack_1_1IO} function\+Map. 

Definition at line 80 of file default\+\_\+param.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac456242613c2898472096ce725d8e9f0}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::string $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ mlpack\+::data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return the default value of an option. 

This is for regular types. \mbox{\label{namespacemlpack_1_1bindings_1_1r_a6b5c1451baee904265c07e8c25d2cb9a}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return the default value of a vector option. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a3f035ce98131e1a11f2242f861f8b244}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::string $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return the default value of a string option. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aca4452a09cb627104777ff8487509a18}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::enable\+\_\+if\+\_\+c$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value$\vert$$\vert$std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ mlpack\+::data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return the default value of a matrix option, a tuple option, a serializable option, or a string option (this returns the default filename, or \textquotesingle{}\textquotesingle{} if the default is no file). 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ae74807c312f36179f863f09e9b525b95}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return the default value of a model option (this returns the default filename, or \textquotesingle{}\textquotesingle{} if the default is no file). 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a6b49a2adbbcd41e406784ca9c216da92}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Binding\+Name@{Get\+Binding\+Name}}
\index{Get\+Binding\+Name@{Get\+Binding\+Name}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Binding\+Name()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Binding\+Name (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{binding\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given the name of a binding, print its R name. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a82f1f31d6d8f5831904f0de8b18fa9e1}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Param@{Get\+Param}}
\index{Get\+Param@{Get\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Get\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



All R binding types are exactly what is held in the Param\+Data, so no special handling is necessary. 



Definition at line 26 of file get\+\_\+param.\+hpp.



References Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a5631e53497794fca1a1b42b73bd629d4}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print an option of a simple type. 

Print an option. 

Definition at line 26 of file get\+\_\+printable\+\_\+param.\+hpp.



References Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a4493f104d9542018fbce6baea8ef9208}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print a vector option, with spaces between it. 



Definition at line 43 of file get\+\_\+printable\+\_\+param.\+hpp.



References Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ab817dd4415d7a543385435500b0bc2aa}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print a matrix option (this prints its size). 

Print a matrix option (this just prints the filename). 

Definition at line 59 of file get\+\_\+printable\+\_\+param.\+hpp.



References Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a323f3f95fd169fd91f70851005ad599f}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print a serializable class option (this prints the class name). 

Print a serializable class option (this just prints the filename).

Print a model option (this just prints the filename). 

Definition at line 75 of file get\+\_\+printable\+\_\+param.\+hpp.



References Param\+Data\+::cpp\+Type, and Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a9517c5fcfcb6b298d1a51667fc162387}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print a combination Dataset\+Info/matrix parameter. 

Print a mapped matrix option (this just prints the filename). 

Definition at line 89 of file get\+\_\+printable\+\_\+param.\+hpp.



References Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a52e4712e3e9a26a913be87635f430e79}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Print an option into a std\+::string. 

This should print a short, one-\/line representation of the object. The string will be stored in the output pointer.


\begin{DoxyParams}{Parameters}
{\em data} & Parameter data struct. \\
\hline
{\em $\ast$} & (input) Unused parameter. \\
\hline
{\em output} & Output storage for the string. \\
\hline
\end{DoxyParams}


Definition at line 114 of file get\+\_\+printable\+\_\+param.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a6d745f299b5efade5bf040f1f48dcfb9}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac5ab8731e5aa33f96e3da403567b2de4}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ab17146d00613cb7f6525f4fb0ca557bf}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_abeaa1f0fac00fc9c3b875c18fb6de04c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a99f759b31c110574a572345aa0c2c8f9}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aefd22c9c4987eaebed12bd7309723b84}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Definition at line 106 of file get\+\_\+printable\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a904be5ad6a2925c9bbebd70169ad60f7}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type$<$ bool $>$@{Get\+Printable\+Type$<$ bool $>$}}
\index{Get\+Printable\+Type$<$ bool $>$@{Get\+Printable\+Type$<$ bool $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type$<$ bool $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type}$<$ bool $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a1d8258435d8732dc06eb707df901b4e9}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type$<$ double $>$@{Get\+Printable\+Type$<$ double $>$}}
\index{Get\+Printable\+Type$<$ double $>$@{Get\+Printable\+Type$<$ double $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type$<$ double $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type}$<$ double $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a3c5c752fef2705bf481e3bc241c7f6cb}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type$<$ int $>$@{Get\+Printable\+Type$<$ int $>$}}
\index{Get\+Printable\+Type$<$ int $>$@{Get\+Printable\+Type$<$ int $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type$<$ int $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type}$<$ int $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_abd529ea2647effe4f28dad6a298a16c3}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type$<$ size\+\_\+t $>$@{Get\+Printable\+Type$<$ size\+\_\+t $>$}}
\index{Get\+Printable\+Type$<$ size\+\_\+t $>$@{Get\+Printable\+Type$<$ size\+\_\+t $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type$<$ size\+\_\+t $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type}$<$ size\+\_\+t $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ size\+\_\+t $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ size\+\_\+t $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ size\+\_\+t $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ size\+\_\+t, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aa1c1d6dfc0a8dafd300c542ae9f242cd}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Printable\+Type$<$ std\+::string $>$@{Get\+Printable\+Type$<$ std\+::string $>$}}
\index{Get\+Printable\+Type$<$ std\+::string $>$@{Get\+Printable\+Type$<$ std\+::string $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Printable\+Type$<$ std\+::string $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Printable\+Type}$<$ std\+::string $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ab6531e3b1e2469bc20013d695f70f91c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type@{Get\+R\+Type}}
\index{Get\+R\+Type@{Get\+R\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+R\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 24 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aebea0c84a2dd1b292dd632336b77eddb}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type@{Get\+R\+Type}}
\index{Get\+R\+Type@{Get\+R\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+R\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 96 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a3f4b5c8fa83a36a646882dba8bbf4e2a}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type@{Get\+R\+Type}}
\index{Get\+R\+Type@{Get\+R\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+R\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 104 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a83c0e5a39f2defa15eb489bcc9f2e7dd}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type@{Get\+R\+Type}}
\index{Get\+R\+Type@{Get\+R\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+R\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 121 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aec8bb71884c43046e6187c272200d0be}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type@{Get\+R\+Type}}
\index{Get\+R\+Type@{Get\+R\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+R\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 130 of file get\+\_\+r\+\_\+type.\+hpp.



References Param\+Data\+::cpp\+Type, and mlpack\+::util\+::\+Strip\+Type().

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ab1fa40df4821ddd5121a1c136261241f}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type$<$ bool $>$@{Get\+R\+Type$<$ bool $>$}}
\index{Get\+R\+Type$<$ bool $>$@{Get\+R\+Type$<$ bool $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type$<$ bool $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+R\+Type}$<$ bool $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 36 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a0da4ea3c9c67b383f4dab4d12c9cf588}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type$<$ double $>$@{Get\+R\+Type$<$ double $>$}}
\index{Get\+R\+Type$<$ double $>$@{Get\+R\+Type$<$ double $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type$<$ double $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+R\+Type}$<$ double $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 72 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a55bfbf19a87f67b1b8d556f00c8cb4d3}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type$<$ int $>$@{Get\+R\+Type$<$ int $>$}}
\index{Get\+R\+Type$<$ int $>$@{Get\+R\+Type$<$ int $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type$<$ int $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+R\+Type}$<$ int $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 48 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ad5b19dd6ee3690eed34f7612ecf02036}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type$<$ size\+\_\+t $>$@{Get\+R\+Type$<$ size\+\_\+t $>$}}
\index{Get\+R\+Type$<$ size\+\_\+t $>$@{Get\+R\+Type$<$ size\+\_\+t $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type$<$ size\+\_\+t $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+R\+Type}$<$ size\+\_\+t $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ size\+\_\+t $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ size\+\_\+t $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ size\+\_\+t $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ size\+\_\+t, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 60 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a2c512d01161e204d511b7cac6cfd8f64}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+R\+Type$<$ std\+::string $>$@{Get\+R\+Type$<$ std\+::string $>$}}
\index{Get\+R\+Type$<$ std\+::string $>$@{Get\+R\+Type$<$ std\+::string $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+R\+Type$<$ std\+::string $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+R\+Type}$<$ std\+::string $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 84 of file get\+\_\+r\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a7325d0bdbe096fc2bede57cded74ba7c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type@{Get\+Type}}
\index{Get\+Type@{Get\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 25 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a96d01a05e1335c3058b32d0213f5202e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type@{Get\+Type}}
\index{Get\+Type@{Get\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 97 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a69892479f6cd19fc81196dc94962bb9c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type@{Get\+Type}}
\index{Get\+Type@{Get\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 107 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_af4ada6677c0211647c87206167c253b7}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type@{Get\+Type}}
\index{Get\+Type@{Get\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 137 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a4d76df033b4bf6ada31210404131e647}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type@{Get\+Type}}
\index{Get\+Type@{Get\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Get\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 146 of file get\+\_\+type.\+hpp.



References Param\+Data\+::cpp\+Type.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a6b92759da3690f6365505d6e668f8811}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type@{Get\+Type}}
\index{Get\+Type@{Get\+Type}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Get\+Type (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Function is used to generate the type names that are used in calls to functions like I\+O\+\_\+\+Set\+Param$<$type$>$() or set\+Param$<$type$>$(), and therefore what\textquotesingle{}s returned isn\textquotesingle{}t exactly the R native type used for that parameter type. 


\begin{DoxyParams}{Parameters}
{\em d} & Parameter data struct. \\
\hline
{\em $\ast$} & (input) Unused parameter. \\
\hline
{\em output} & Output storage for the string. \\
\hline
\end{DoxyParams}


Definition at line 165 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_afb3d3cf517eceeb69b87b10b93a7eaf4}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type$<$ bool $>$@{Get\+Type$<$ bool $>$}}
\index{Get\+Type$<$ bool $>$@{Get\+Type$<$ bool $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type$<$ bool $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Type}$<$ bool $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 85 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ab55d2664c4b168b17b914b0d90ba52bb}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type$<$ double $>$@{Get\+Type$<$ double $>$}}
\index{Get\+Type$<$ double $>$@{Get\+Type$<$ double $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type$<$ double $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Type}$<$ double $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 61 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ad382d71f08d41f1cd5878e56d49e9882}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type$<$ float $>$@{Get\+Type$<$ float $>$}}
\index{Get\+Type$<$ float $>$@{Get\+Type$<$ float $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type$<$ float $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Type}$<$ float $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ float $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ float $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ float $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ float, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 49 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a52b0f14ae78bf707b66b3678434395ff}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type$<$ int $>$@{Get\+Type$<$ int $>$}}
\index{Get\+Type$<$ int $>$@{Get\+Type$<$ int $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type$<$ int $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Type}$<$ int $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 37 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a78981a0295615f67b6a0cc40534cbfce}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Get\+Type$<$ std\+::string $>$@{Get\+Type$<$ std\+::string $>$}}
\index{Get\+Type$<$ std\+::string $>$@{Get\+Type$<$ std\+::string $>$}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Get\+Type$<$ std\+::string $>$()}
{\footnotesize\ttfamily std\+::string \textbf{ mlpack\+::bindings\+::r\+::\+Get\+Type}$<$ std\+::string $>$ (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Definition at line 73 of file get\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac1f913db71701ae166576f3ecb9c2f15}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Ignore\+Check@{Ignore\+Check}}
\index{Ignore\+Check@{Ignore\+Check}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Ignore\+Check()\hspace{0.1cm}{\footnotesize\ttfamily [1/3]}}
{\footnotesize\ttfamily bool mlpack\+::bindings\+::r\+::\+Ignore\+Check (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{param\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print whether or not we should ignore a check on the given parameter. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aa1fafc76127c0f3274ab44aba5e7457b}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Ignore\+Check@{Ignore\+Check}}
\index{Ignore\+Check@{Ignore\+Check}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Ignore\+Check()\hspace{0.1cm}{\footnotesize\ttfamily [2/3]}}
{\footnotesize\ttfamily bool mlpack\+::bindings\+::r\+::\+Ignore\+Check (\begin{DoxyParamCaption}\item[{const std\+::vector$<$ std\+::string $>$ \&}]{constraints }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print whether or not we should ignore a check on the given set of constraints. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a45c55be23b65b000e4ad48918b82727e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Ignore\+Check@{Ignore\+Check}}
\index{Ignore\+Check@{Ignore\+Check}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Ignore\+Check()\hspace{0.1cm}{\footnotesize\ttfamily [3/3]}}
{\footnotesize\ttfamily bool mlpack\+::bindings\+::r\+::\+Ignore\+Check (\begin{DoxyParamCaption}\item[{const std\+::vector$<$ std\+::pair$<$ std\+::string, bool $>$$>$ \&}]{constraints,  }\item[{const std\+::string \&}]{param\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print whether or not we should ignore a check on the given set of constraints. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a389aac3ea69ce80a583af53338d6b710}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Param\+String@{Param\+String}}
\index{Param\+String@{Param\+String}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Param\+String()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Param\+String (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{param\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given the parameter name, determine what it would actually be when passed to the command line. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_acf455e659195a2f7e72570d6e256de73}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Dataset@{Print\+Dataset}}
\index{Print\+Dataset@{Print\+Dataset}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Dataset()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Dataset (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{dataset\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given the name of a matrix, print it. 

Here we do not need to modify anything. \mbox{\label{namespacemlpack_1_1bindings_1_1r_a9679ac271579f85d3f1d21fe2101409e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Default@{Print\+Default}}
\index{Print\+Default@{Print\+Default}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Default()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Default (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{param\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given a parameter name, print its corresponding default value. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a9cbe53faf744ce5439cd284796375c20}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Doc@{Print\+Doc}}
\index{Print\+Doc@{Print\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Doc()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Print the docstring documentation for a given parameter. 

You are responsible for setting up the line---this does not handle indentation or anything. This is meant to produce a line of documentation describing a single parameter.

The indent parameter (void$\ast$ input, which should be a pointer to a size\+\_\+t) should be passed to know how much to indent for a new line.


\begin{DoxyParams}{Parameters}
{\em d} & Parameter data struct. \\
\hline
{\em $\ast$} & (input) Pointer to size\+\_\+t containing indent. \\
\hline
{\em output} & Unused parameter. \\
\hline
\end{DoxyParams}


Definition at line 36 of file print\+\_\+doc.\+hpp.



References Param\+Data\+::cpp\+Type, Param\+Data\+::desc, mlpack\+::util\+::\+Hyphenate\+String(), M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, Param\+Data\+::required, and Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aff198996c9c6ce5cbbe21d8aaad07d42}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Import@{Print\+Import}}
\index{Print\+Import@{Print\+Import}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Import()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Import (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print any import information for the R binding. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ae470d9cee45e044255fd4150cb11f144}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Option\+Info@{Print\+Input\+Option\+Info}}
\index{Print\+Input\+Option\+Info@{Print\+Input\+Option\+Info}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Option\+Info()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Input\+Option\+Info (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print any special information about input options. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ad39e71fa76b4da1db0cc0af50cb0940d}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Options@{Print\+Input\+Options}}
\index{Print\+Input\+Options@{Print\+Input\+Options}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Input\+Options (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Recursion base case. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a05875eeb5bcf3f2db4c1f035fcd8886c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Options@{Print\+Input\+Options}}
\index{Print\+Input\+Options@{Print\+Input\+Options}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Input\+Options (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{param\+Name,  }\item[{const T \&}]{value,  }\item[{Args...}]{args }\end{DoxyParamCaption})}



Print an input option. 

This will throw an exception if the parameter does not exist in \doxyref{IO}{p.}{classmlpack_1_1IO}. \mbox{\label{namespacemlpack_1_1bindings_1_1r_abd04a6088ee20daa81772554f9db0075}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Param@{Print\+Input\+Param}}
\index{Print\+Input\+Param@{Print\+Input\+Param}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Input\+Param (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{ }\end{DoxyParamCaption})}



Print the declaration of an input parameter as part of a line in a R function definition. 

This doesn\textquotesingle{}t include any commas or anything. 

Definition at line 27 of file print\+\_\+input\+\_\+param.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a9956ff799780136c3bf4b23cfb966b2c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print input processing for a standard option type. 

This gives us code like\+: \begin{DoxyVerb}if (!identical(<param_name>, NA)) {
   IO_SetParam<type>("<param_name>", <param_name>)
}
\end{DoxyVerb}


This gives us code like\+: \begin{DoxyVerb}IO_SetParam<type>("<param_name>", <param_name>)
\end{DoxyVerb}


Definition at line 27 of file print\+\_\+input\+\_\+processing.\+hpp.



References Param\+Data\+::cpp\+Type, M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a4b2e46accffc077a020a44fe67f4087e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print input processing for a matrix type. 

This gives us code like\+: \begin{DoxyVerb}if (!identical(<param_name>, NA)) {
   IO_SetParam<type>("<param_name>", to_matrix(<param_name>))
}
\end{DoxyVerb}


This gives us code like\+: \begin{DoxyVerb}IO_SetParam<type>("<param_name>", to_matrix(<param_name>))
\end{DoxyVerb}


Definition at line 73 of file print\+\_\+input\+\_\+processing.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ab9b7227621d38bf6029b9386662c5d9b}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print input processing for a matrix with info type. 

This gives us code like\+: \begin{DoxyVerb}if (!identical(<param_name>, NA)) {
   <param_name> = to_matrix_with_info(<param_name>)
   IO_SetParam<type>("<param_name>", <param_name>$info,
                       <param_name>$data)
}
\end{DoxyVerb}


This gives us code like\+: \begin{DoxyVerb}<param_name> = to_matrix_with_info(<param_name>)
IO_SetParam<type>("<param_name>", <param_name>$info,
                    <param_name>$data)
\end{DoxyVerb}


Definition at line 109 of file print\+\_\+input\+\_\+processing.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac27fea289c602b0e9df55fbf038fe6b8}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print input processing for a serializable type. 

This gives us code like\+: \begin{DoxyVerb}if (!identical(<param_name>, NA)) {
   IO_SetParam<ModelType>Ptr("<param_name>", <param_name>)
}
\end{DoxyVerb}


This gives us code like\+: \begin{DoxyVerb}IO_SetParam<ModelType>Ptr("<param_name>", <param_name>)
\end{DoxyVerb}


Definition at line 156 of file print\+\_\+input\+\_\+processing.\+hpp.



References Param\+Data\+::cpp\+Type, M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, Param\+Data\+::required, and mlpack\+::util\+::\+Strip\+Type().

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a46235d9f2d7b597d7b29f018ae7ee3a6}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{ }\end{DoxyParamCaption})}


\begin{DoxyParams}{Parameters}
{\em d} & Parameter data struct. \\
\hline
{\em $\ast$} & (input) Unused parameter. \\
\hline
{\em $\ast$} & (output) Unused parameter. \\
\hline
\end{DoxyParams}


Definition at line 195 of file print\+\_\+input\+\_\+processing.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a9dcd69f688c04daa0be2778b4e7c1a43}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Model@{Print\+Model}}
\index{Print\+Model@{Print\+Model}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Model()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Model (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{model\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given the name of a model, print it. 

Here we do not need to modify anything. \mbox{\label{namespacemlpack_1_1bindings_1_1r_a2d046b647ff99b98e9a6e89b4aeb0ce3}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Option\+Info@{Print\+Output\+Option\+Info}}
\index{Print\+Output\+Option\+Info@{Print\+Output\+Option\+Info}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Option\+Info()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Output\+Option\+Info (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print any special information about output options. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a2cc5a5f810369dec4fd01564fc819e4c}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Options@{Print\+Output\+Options}}
\index{Print\+Output\+Options@{Print\+Output\+Options}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Output\+Options (\begin{DoxyParamCaption}\item[{const bool}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Recursion base case. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a8cb4cf05bce5323880019bf8355c7f70}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Options@{Print\+Output\+Options}}
\index{Print\+Output\+Options@{Print\+Output\+Options}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Output\+Options (\begin{DoxyParamCaption}\item[{const bool}]{markdown,  }\item[{const std\+::string \&}]{param\+Name,  }\item[{const T \&}]{value,  }\item[{Args...}]{args }\end{DoxyParamCaption})}

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a321bdda915f34ddfd7ce21134cc9be5b}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print output processing for a regular parameter type. 

This gives us code like\+: \begin{DoxyVerb}"<param_name>" = IO_GetParam<Type>("param_name")
\end{DoxyVerb}


Definition at line 27 of file print\+\_\+output\+\_\+processing.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_acea785724683c00bf3878213265b240b}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print output processing for a matrix type. 

This gives us code like\+: \begin{DoxyVerb}"<param_name>" = IO_GetParam<Type>("param_name")
\end{DoxyVerb}


Definition at line 49 of file print\+\_\+output\+\_\+processing.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a298d5177cf1b1b7f8c6ba9ee4d78535e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print output processing for a matrix with info type. 

This gives us code like\+: \begin{DoxyVerb}"<param_name>" = IO_GetParam<Type>("param_name")
\end{DoxyVerb}


Definition at line 70 of file print\+\_\+output\+\_\+processing.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a797ceea51979ea18ff855bfcac47f20a}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print output processing for a serializable model. 

This gives us code like\+: \begin{DoxyVerb}"<param_name>" = <param_name>
\end{DoxyVerb}


Definition at line 90 of file print\+\_\+output\+\_\+processing.\+hpp.



References M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac99f01549741d73839ed0fbe8957a0fe}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{ }\end{DoxyParamCaption})}


\begin{DoxyParams}{Parameters}
{\em d} & Parameter data struct. \\
\hline
{\em $\ast$} & (input) Unused parameter. \\
\hline
{\em $\ast$} & (output) Unused parameter. \\
\hline
\end{DoxyParams}


Definition at line 111 of file print\+\_\+output\+\_\+processing.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a0c037e0d4c235234072f4ed45005f5e3}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!PrintR@{PrintR}}
\index{PrintR@{PrintR}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+R()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+PrintR (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Binding\+Details} \&}]{doc,  }\item[{const std\+::string \&}]{function\+Name }\end{DoxyParamCaption})}



Print the code for a .R binding for an mlpack program to stdout. 


\begin{DoxyParams}{Parameters}
{\em doc} & Documentation for the binding. \\
\hline
{\em function\+Name} & Name of the function (i.\+e. \char`\"{}pca\char`\"{}). \\
\hline
\end{DoxyParams}
\mbox{\label{namespacemlpack_1_1bindings_1_1r_a3d7b0931393483d5c7d6c6c4970965e7}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Serialize\+Util@{Print\+Serialize\+Util}}
\index{Print\+Serialize\+Util@{Print\+Serialize\+Util}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Serialize\+Util()\hspace{0.1cm}{\footnotesize\ttfamily [1/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Serialize\+Util (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



If the type is not serializable, print nothing. 



Definition at line 26 of file print\+\_\+serialize\+\_\+util.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_af936aeb99c473be5b56367bd4722addc}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Serialize\+Util@{Print\+Serialize\+Util}}
\index{Print\+Serialize\+Util@{Print\+Serialize\+Util}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Serialize\+Util()\hspace{0.1cm}{\footnotesize\ttfamily [2/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Serialize\+Util (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Matrices are serializable but here we also print nothing. 



Definition at line 38 of file print\+\_\+serialize\+\_\+util.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac9dfc0f41352071820158a5a4eb77748}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Serialize\+Util@{Print\+Serialize\+Util}}
\index{Print\+Serialize\+Util@{Print\+Serialize\+Util}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Serialize\+Util()\hspace{0.1cm}{\footnotesize\ttfamily [3/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Serialize\+Util (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename std\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



For non-\/matrix serializable types we need to print something. 

This gives us code like\+: \begin{DoxyVerb}<param_name> <- IO_GetParam<ModelType>Ptr("<param_name>")
attr(<param_name>, "type") <- "<ModelType>"
\end{DoxyVerb}


Definition at line 49 of file print\+\_\+serialize\+\_\+util.\+hpp.



References Param\+Data\+::cpp\+Type, M\+L\+P\+A\+C\+K\+\_\+\+C\+O\+U\+T\+\_\+\+S\+T\+R\+E\+AM, Param\+Data\+::name, and mlpack\+::util\+::\+Strip\+Type().

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a7c0738a96bd71243efc6b92152ccfd23}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Serialize\+Util@{Print\+Serialize\+Util}}
\index{Print\+Serialize\+Util@{Print\+Serialize\+Util}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Serialize\+Util()\hspace{0.1cm}{\footnotesize\ttfamily [4/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Serialize\+Util (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{ }\end{DoxyParamCaption})}


\begin{DoxyParams}{Parameters}
{\em d} & Parameter data struct. \\
\hline
{\em $\ast$} & (input) Unused parameter. \\
\hline
{\em $\ast$} & (output) Unused parameter. \\
\hline
\end{DoxyParams}


Definition at line 75 of file print\+\_\+serialize\+\_\+util.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ae06448d0dbd4b6c43acc841cca5f7014}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return a string representing the command-\/line type of an option. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac830311fc430722d7ea0b13128fbb3f5}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename std\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return a string representing the command-\/line type of a vector. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a7dcf29f4e381305eab03c18b70127825}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return a string representing the command-\/line type of a matrix option. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_add19c5c4f0fb82511c373a7a19c99bea}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename std\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return a string representing the command-\/line type of a matrix tuple option. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a9c44a394718d0fc8067504c620f0139b}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Return a string representing the command-\/line type of a model. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_ac84c9dec5a4cc9e7adf78389899c0d5e}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::r\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Print the command-\/line type of an option into a string. 



Definition at line 72 of file print\+\_\+type\+\_\+doc.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a2a98e625ee2e5294ff1fffcb329143b6}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Value@{Print\+Value}}
\index{Print\+Value@{Print\+Value}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Value()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Value (\begin{DoxyParamCaption}\item[{const T \&}]{value,  }\item[{bool}]{quotes }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given a parameter type, print the corresponding value. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a1802987f990a2968a3348d884ec665fb}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Print\+Value@{Print\+Value}}
\index{Print\+Value@{Print\+Value}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Print\+Value()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Print\+Value (\begin{DoxyParamCaption}\item[{const bool \&}]{value,  }\item[{bool}]{quotes }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Special overload for booleans. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_aec3cc6e45887ab2b60f5adca87ca508d}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Program\+Call@{Program\+Call}}
\index{Program\+Call@{Program\+Call}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Program\+Call()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Program\+Call (\begin{DoxyParamCaption}\item[{const bool}]{markdown,  }\item[{const std\+::string \&}]{program\+Name,  }\item[{Args...}]{args }\end{DoxyParamCaption})}



Given a name of a binding and a variable number of arguments (and their contents), print the corresponding function call. 

\mbox{\label{namespacemlpack_1_1bindings_1_1r_a8e875c191ac4c5f5d4cb050389de4d1b}} 
\index{mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}!Program\+Call@{Program\+Call}}
\index{Program\+Call@{Program\+Call}!mlpack\+::bindings\+::r@{mlpack\+::bindings\+::r}}
\subsubsection{Program\+Call()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::r\+::\+Program\+Call (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{program\+Name }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given the name of a binding, print a program call assuming that all options are specified. 

