\section{mlpack\+:\+:bindings\+:\+:julia Namespace Reference}
\label{namespacemlpack_1_1bindings_1_1julia}\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsection*{Classes}
\begin{DoxyCompactItemize}
\item 
class \textbf{ Julia\+Option}
\begin{DoxyCompactList}\small\item\em The Julia option class. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Default\+Param} (const \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} (const \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} (const \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} (const \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} (const \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} (const \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 Julia name (this just returns the binding name). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Julia\+Type} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Julia\+Type} (const typename std\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Julia\+Type} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Julia\+Type} (const typename std\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Julia\+Type} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$=0, 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)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Julia\+Type$<$ bool $>$} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ bool $>$\+::value $>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Julia\+Type$<$ double $>$} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ double $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ double $>$\+::value $>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Julia\+Type$<$ int $>$} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ int $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ int $>$\+::value $>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Julia\+Type$<$ size\+\_\+t $>$} (const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ size\+\_\+t $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ size\+\_\+t $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ size\+\_\+t, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ size\+\_\+t $>$\+::value $>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Julia\+Type$<$ std\+::string $>$} (const typename std\+::enable\+\_\+if$<$ !\textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$ !arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$, const typename std\+::enable\+\_\+if$<$ !\textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$\+::value $>$\+::type $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Param} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em All Julia 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} (const \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} (const \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} (const \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} (const \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} (const \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} (const \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} (const \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{ Get\+Printable\+Type} (const \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{ Get\+Printable\+Type} (const \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{ Get\+Printable\+Type} (const \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{ Get\+Printable\+Type} (const \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{ Get\+Printable\+Type} (const \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 
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)
\begin{DoxyCompactList}\small\item\em Print a dataset type parameter. \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} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\item 
std\+::string \textbf{ Print\+Import} (const std\+::string \&binding\+Name)
\begin{DoxyCompactList}\small\item\em Print any imports for Julia. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Input\+Options} ()
\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} (const \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 Julia function definition. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::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 the input processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a non-\/serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::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 the input processing for an Armadillo type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, 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, 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 the input processing for a serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, 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 the input processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a matrix with Dataset\+Info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the input processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a type. \end{DoxyCompactList}\item 
void \textbf{ Print\+JL} (const \textbf{ util\+::\+Program\+Doc} \&program\+Info, const std\+::string \&function\+Name, const std\+::string \&mlpack\+Julia\+Lib\+Suffix)
\begin{DoxyCompactList}\small\item\em Print the code for a .jl binding for an mlpack program to stdout. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Model} (const std\+::string \&model)
\begin{DoxyCompactList}\small\item\em Print a model type parameter. \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} ()
\item 
{\footnotesize template$<$typename T , typename... Args$>$ }\\std\+::string \textbf{ Print\+Output\+Options} (const std\+::string \&param\+Name, const T \&value, Args... args)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::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 the output processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a non-\/serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::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 the output processing for an Armadillo type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, 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, 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 the output processing for a serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&function\+Name, 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 the output processing for a mat/\+Dataset\+Info tuple type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the output processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Param\+Defn} (const \textbf{ util\+::\+Param\+Data} \&, const std\+::string \&, 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\+Param\+Defn} (const \textbf{ util\+::\+Param\+Data} \&, const std\+::string \&, 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\+Param\+Defn} (const \textbf{ util\+::\+Param\+Data} \&d, const std\+::string \&\textbf{ program\+Name}, 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\+Param\+Defn} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$)
\begin{DoxyCompactList}\small\item\em If the type is serializable, print the definition of a special utility function to set a \doxyref{C\+LI}{p.}{classmlpack_1_1CLI} parameter of that type to stdout. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Type} (const \textbf{ util\+::\+Param\+Data} \&param)
\begin{DoxyCompactList}\small\item\em Print the type of a parameter that a user would specify from Julia. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (const \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} (const \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} (const \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} (const \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} (const \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} (const \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 
std\+::string \textbf{ Print\+Type\+Docs} ()
\begin{DoxyCompactList}\small\item\em Print documentation for each of the types. \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)
\item 
{\footnotesize template$<$typename... Args$>$ }\\std\+::string \textbf{ Program\+Call} (const std\+::string \&\textbf{ 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{ Strip\+Type} (std\+::string cpp\+Type)
\begin{DoxyCompactList}\small\item\em Given a C++ type name, turn it into something that has no special characters that can simply be printed. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Variables}
\begin{DoxyCompactItemize}
\item 
std\+::string \textbf{ program\+Name}
\end{DoxyCompactItemize}


\subsection{Function Documentation}
\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a38f4eb1fcd54e6d822d3acfcb62391c1}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Default\+Param@{Default\+Param}}
\index{Default\+Param@{Default\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Default\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Default\+Param (\begin{DoxyParamCaption}\item[{const \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{C\+LI}{p.}{classmlpack_1_1CLI} function\+Map. 

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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_aaabef9a462f740239bcc70a984f80f11}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{const \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_1julia_a95a23a4a22da76d2dc4cb835395cec1d}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{const \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_1julia_afef9d810d86d4b8ebaab5d964fe4f40a}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{const \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_1julia_a7ee6b18b149e99cb979f419bf01e5f1c}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{const \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_1julia_a0ea66301be4691c4ed9277cca13a20a1}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Default\+Param\+Impl (\begin{DoxyParamCaption}\item[{const \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_1julia_a8d9828ad9cbc4d7a011cbe18bd7e6f0c}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Binding\+Name@{Get\+Binding\+Name}}
\index{Get\+Binding\+Name@{Get\+Binding\+Name}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Binding\+Name()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+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 Julia name (this just returns the binding name). 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a6430760d959ce5a496fcd261a92bf3c0}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Julia\+Type@{Get\+Julia\+Type}}
\index{Get\+Julia\+Type@{Get\+Julia\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Julia\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Julia\+Type (\begin{DoxyParamCaption}\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::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},  }\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a397a5594f4b141e4ca6f99c3a09e46f0}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Julia\+Type@{Get\+Julia\+Type}}
\index{Get\+Julia\+Type@{Get\+Julia\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Julia\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Julia\+Type (\begin{DoxyParamCaption}\item[{const typename std\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::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},  }\item[{const typename std\+::enable\+\_\+if$<$!arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a29c6d3c00740a0c9831dade6c922397d}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Julia\+Type@{Get\+Julia\+Type}}
\index{Get\+Julia\+Type@{Get\+Julia\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Julia\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Julia\+Type (\begin{DoxyParamCaption}\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::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},  }\item[{const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_acd5d5b951fc01822a41fad1f2d1722ed}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Julia\+Type@{Get\+Julia\+Type}}
\index{Get\+Julia\+Type@{Get\+Julia\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Julia\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Julia\+Type (\begin{DoxyParamCaption}\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})\hspace{0.3cm}{\ttfamily [inline]}}



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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a4f1f0ed086846831cf5e1fdd93b1f9ff}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Julia\+Type@{Get\+Julia\+Type}}
\index{Get\+Julia\+Type@{Get\+Julia\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Julia\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Julia\+Type (\begin{DoxyParamCaption}\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$}]{ = {\ttfamily 0},  }\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})\hspace{0.3cm}{\ttfamily [inline]}}



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

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



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

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



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

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



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

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



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

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



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

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



All Julia 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_1julia_ad6e3e52782b730dfa1bea16198933fb9}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{const \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.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a90405a2904ab278275b817e6d07bbd9a}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{const \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.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ab1ab62eb5940248fdc05d48842b77daa}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{const \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.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a98801453278ebff1124e557170f13389}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{const \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.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ab3508dfe7a6be571635a76a9562d191d}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{const \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.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a055dde26e83a6668d73cc89ca8aca75b}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Param (\begin{DoxyParamCaption}\item[{const \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 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_1julia_ab0b110b121b8a30a1e0857ff97103ea5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{const \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_1julia_ad782e224d9ffabaabaf27fede08d0967}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{const \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_1julia_a6f31c3de0fc83a71fca931c7826e28b5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{const \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_1julia_abbdff0d97d8c6c98ba9a2ece17df264b}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{const \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_1julia_a6da3627817e7fc7adfd5f3581f06c4e5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{const \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_1julia_a8747f24b276e50af9c6b70932f9f1e14}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Get\+Printable\+Type@{Get\+Printable\+Type}}
\index{Get\+Printable\+Type@{Get\+Printable\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Get\+Printable\+Type()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Get\+Printable\+Type (\begin{DoxyParamCaption}\item[{const \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 70 of file get\+\_\+printable\+\_\+type.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a2721640ebb8e5ad4abf7e7be3d2cdac8}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Ignore\+Check@{Ignore\+Check}}
\index{Ignore\+Check@{Ignore\+Check}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Ignore\+Check()\hspace{0.1cm}{\footnotesize\ttfamily [1/3]}}
{\footnotesize\ttfamily bool mlpack\+::bindings\+::julia\+::\+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. 

For Julia bindings, we ignore any checks on output parameters, so if param\+Name is an output parameter, this returns true. \mbox{\label{namespacemlpack_1_1bindings_1_1julia_af39b9d7b6b7d368b766fb1ef482d25b4}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Ignore\+Check@{Ignore\+Check}}
\index{Ignore\+Check@{Ignore\+Check}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Ignore\+Check()\hspace{0.1cm}{\footnotesize\ttfamily [2/3]}}
{\footnotesize\ttfamily bool mlpack\+::bindings\+::julia\+::\+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. 

For Julia bindings, we ignore any checks on output parameters, so if any parameter is an output parameter, this returns true. \mbox{\label{namespacemlpack_1_1bindings_1_1julia_a48bbe25414605037ae8acd32ed73bdf5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Ignore\+Check@{Ignore\+Check}}
\index{Ignore\+Check@{Ignore\+Check}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Ignore\+Check()\hspace{0.1cm}{\footnotesize\ttfamily [3/3]}}
{\footnotesize\ttfamily bool mlpack\+::bindings\+::julia\+::\+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. 

For Julia bindings, we ignore any checks on output parameters, so if any constraint parameter or the main parameter are output parameters, this returns true. \mbox{\label{namespacemlpack_1_1bindings_1_1julia_a627997ec4999091e2c734c8e5369c456}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Param\+String@{Param\+String}}
\index{Param\+String@{Param\+String}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Param\+String()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+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_1julia_ab81006e8cf130a5968777dcf9c82baa3}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Dataset@{Print\+Dataset}}
\index{Print\+Dataset@{Print\+Dataset}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Dataset()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Dataset (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{dataset }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print a dataset type parameter. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a6a712d2a0342de59cfd5ac5033138d6f}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Default@{Print\+Default}}
\index{Print\+Default@{Print\+Default}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Default()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+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_1julia_a0a17a9ed9042a4cfbeb1363f00f78bf9}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Doc@{Print\+Doc}}
\index{Print\+Doc@{Print\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Doc()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Doc (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



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



References Param\+Data\+::cpp\+Type, Param\+Data\+::desc, if(), Param\+Data\+::name, Param\+Data\+::required, and Param\+Data\+::value.

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



Print any imports for Julia. 

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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ae8ccf211291da278631c06ce5b6f828a}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Input\+Options@{Print\+Input\+Options}}
\index{Print\+Input\+Options@{Print\+Input\+Options}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Input\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+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{C\+LI}{p.}{classmlpack_1_1CLI}. For a parameter \textquotesingle{}x\textquotesingle{} with value \textquotesingle{}5\textquotesingle{}, this will print something like x=5. \mbox{\label{namespacemlpack_1_1bindings_1_1julia_ac3c05827594c4a400854d9468d10ebdf}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Input\+Param@{Print\+Input\+Param}}
\index{Print\+Input\+Param@{Print\+Input\+Param}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Input\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Input\+Param (\begin{DoxyParamCaption}\item[{const \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 Julia function definition. 

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

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



References if(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a7f0e2ef3de290224b229f3beb028ce5b}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::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 the input processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a non-\/serializable type. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a1c776a1f4f9872a2664ae7e0a677326a}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\item[{const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::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 the input processing for an Armadillo type. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ad2e4e66c1c7cc8271faa2f4ff3da3a96}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\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},  }\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 the input processing for a serializable type. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a487ae81137e65d63bdfa2bf5608e6ea5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\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 the input processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a matrix with Dataset\+Info type. 

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



Print the input processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a type. 



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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ab867a1579dfa96b13b9e2f7f6b121e2a}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+JL@{Print\+JL}}
\index{Print\+JL@{Print\+JL}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+J\+L()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+JL (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Program\+Doc} \&}]{program\+Info,  }\item[{const std\+::string \&}]{function\+Name,  }\item[{const std\+::string \&}]{mlpack\+Julia\+Lib\+Suffix }\end{DoxyParamCaption})}



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

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



Print a model type parameter. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a2db624423dfe22092c563dd12f4bbe8d}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Output\+Option\+Info@{Print\+Output\+Option\+Info}}
\index{Print\+Output\+Option\+Info@{Print\+Output\+Option\+Info}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Output\+Option\+Info()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+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_1julia_a458cbef16b35aa69753765e7ccdb0398}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Output\+Options@{Print\+Output\+Options}}
\index{Print\+Output\+Options@{Print\+Output\+Options}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Output\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Output\+Options (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a7f521ed4dd336c0694c226bbd8bb9cd0}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\item[{const typename std\+::enable\+\_\+if$<$!\textbf{ data\+::\+Has\+Serialize}$<$ T $>$\+::value $>$\+::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 the output processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a non-\/serializable type. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ad2085aab5c12535052f6e4b2de283769}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\item[{const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::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 the output processing for an Armadillo type. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_aca77575070f10fbadb9a09f6bb828cf2}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\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},  }\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 the output processing for a serializable type. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a07f2e3c7231d934df5d3253d7c9d8cec}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Output\+Processing@{Print\+Output\+Processing}}
\index{Print\+Output\+Processing@{Print\+Output\+Processing}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Output\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Output\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{function\+Name,  }\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 the output processing for a mat/\+Dataset\+Info tuple type. 

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



Print the output processing (basically calling \doxyref{C\+L\+I\+::\+Get\+Param$<$$>$()}{p.}{classmlpack_1_1CLI_a6c641e7bd5291c24b787f379f25cb9b8}) for a type. 



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

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a194bd940b077dcd8db1a3649eaceacec}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Param\+Defn@{Print\+Param\+Defn}}
\index{Print\+Param\+Defn@{Print\+Param\+Defn}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Param\+Defn()\hspace{0.1cm}{\footnotesize\ttfamily [1/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Param\+Defn (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const std\+::string \&}]{,  }\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\+\_\+param\+\_\+defn.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a4b9a887b16148f71a1a0fc26413791b8}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Param\+Defn@{Print\+Param\+Defn}}
\index{Print\+Param\+Defn@{Print\+Param\+Defn}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Param\+Defn()\hspace{0.1cm}{\footnotesize\ttfamily [2/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Param\+Defn (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const std\+::string \&}]{,  }\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 39 of file print\+\_\+param\+\_\+defn.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ae23ba913359280da97782a35392ff6a5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Param\+Defn@{Print\+Param\+Defn}}
\index{Print\+Param\+Defn@{Print\+Param\+Defn}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Param\+Defn()\hspace{0.1cm}{\footnotesize\ttfamily [3/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Param\+Defn (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const std\+::string \&}]{program\+Name,  }\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. 



Definition at line 51 of file print\+\_\+param\+\_\+defn.\+hpp.



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

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



If the type is serializable, print the definition of a special utility function to set a \doxyref{C\+LI}{p.}{classmlpack_1_1CLI} parameter of that type to stdout. 



Definition at line 95 of file print\+\_\+param\+\_\+defn.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_aaca6c5c31e37305c0945d0689f46b7fd}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type@{Print\+Type}}
\index{Print\+Type@{Print\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{param }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print the type of a parameter that a user would specify from Julia. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_af2df9414f3d95be28542667358934ec5}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{const \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_1julia_a523f54cc19f3bc80b38b50db822f6336}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{const \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_1julia_ae73ee995b469138cb4f5cae1892656ac}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{const \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_1julia_a2d805706146a1d2968b73be0c466c141}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{const \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_1julia_a1c9c5a221c47e514914f88e5f003fc7a}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{const \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_1julia_aa7b086ec5e226f33ce22a5baeb82be57}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::julia\+::\+Print\+Type\+Doc (\begin{DoxyParamCaption}\item[{const \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_1julia_a66c87276bb72b6efb12d2b7d53202ca8}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Type\+Docs@{Print\+Type\+Docs}}
\index{Print\+Type\+Docs@{Print\+Type\+Docs}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Type\+Docs()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Type\+Docs (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print documentation for each of the types. 

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_afddeb0074153b920a7da3051b1046675}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Value@{Print\+Value}}
\index{Print\+Value@{Print\+Value}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Value()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+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_1julia_ab215ccae826d137bb18e251b63f79318}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Print\+Value@{Print\+Value}}
\index{Print\+Value@{Print\+Value}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Print\+Value()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Print\+Value (\begin{DoxyParamCaption}\item[{const bool \&}]{value,  }\item[{bool}]{quotes }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1julia_ab5edf3302fabe8ebafc3ed7228b149df}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Program\+Call@{Program\+Call}}
\index{Program\+Call@{Program\+Call}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Program\+Call()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Program\+Call (\begin{DoxyParamCaption}\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_1julia_a681baf992c0324a83a10a146d968a0eb}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!Strip\+Type@{Strip\+Type}}
\index{Strip\+Type@{Strip\+Type}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{Strip\+Type()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::julia\+::\+Strip\+Type (\begin{DoxyParamCaption}\item[{std\+::string}]{cpp\+Type }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given a C++ type name, turn it into something that has no special characters that can simply be printed. 

This is similar to but not identical to \doxyref{mlpack\+::bindings\+::python\+::\+Strip\+Type()}{p.}{namespacemlpack_1_1bindings_1_1python_ad9aef93ac2450f69e902b2bae75296fa}.


\begin{DoxyParams}{Parameters}
{\em cpp\+Type} & C++ type as a string. \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
Stripped type with no special characters. 
\end{DoxyReturn}


Definition at line 28 of file strip\+\_\+type.\+hpp.



Referenced by Print\+Param\+Defn().



\subsection{Variable Documentation}
\mbox{\label{namespacemlpack_1_1bindings_1_1julia_a24d855d329269931b59bdf1b36706a88}} 
\index{mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}!program\+Name@{program\+Name}}
\index{program\+Name@{program\+Name}!mlpack\+::bindings\+::julia@{mlpack\+::bindings\+::julia}}
\subsubsection{program\+Name}
{\footnotesize\ttfamily std\+::string program\+Name}

