\section{mlpack\+:\+:bindings\+:\+:go Namespace Reference}
\label{namespacemlpack_1_1bindings_1_1go}\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsection*{Classes}
\begin{DoxyCompactItemize}
\item 
class \textbf{ Go\+Option}
\begin{DoxyCompactList}\small\item\em The Go option class. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item 
std\+::string \textbf{ Camel\+Case} (std\+::string s, bool lower)
\begin{DoxyCompactList}\small\item\em Given an snake\+\_\+case like, e.\+g., \char`\"{}logistic\+\_\+regression\char`\"{}, return Camel\+Case(e.\+g. \end{DoxyCompactList}\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 Go name. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Go\+Type$<$ bool $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Go\+Type$<$ double $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Go\+Type$<$ float $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ float, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Go\+Type$<$ int $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Go\+Type$<$ std\+::string $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
void \textbf{ Get\+Options} (std\+::vector$<$ std\+::tuple$<$ std\+::string, std\+::string $>$$>$ \&)
\item 
{\footnotesize template$<$typename T , typename... Args$>$ }\\void \textbf{ Get\+Options} (std\+::vector$<$ std\+::tuple$<$ std\+::string, std\+::string $>$$>$ \&results, const std\+::string \&param\+Name, const T \&value, Args... args)
\begin{DoxyCompactList}\small\item\em Assemble a vector of string tuples indicating parameter names and what should be printed for them. \end{DoxyCompactList}\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 Go 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} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Printable\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ bool $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ double $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ int $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ std\+::string $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Type} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Function is used to generate the type names that are used in calls to functions like gonum\+To\+Arma$<$type$>$() or set\+Param$<$type$>$(), and therefore what\textquotesingle{}s returned isn\textquotesingle{}t exactly the Go native type used for that parameter type. \end{DoxyCompactList}\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ bool $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ double $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ float $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ float $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ float $>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ int $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Type$<$ std\+::string $>$} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$)
\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 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Import\+Decl} (const \textbf{ util\+::\+Param\+Data} \&, const size\+\_\+t indent, 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 For a serializable type, print a cppclass definition. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Import\+Decl} (const \textbf{ util\+::\+Param\+Data} \&, const size\+\_\+t, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em For a non-\/serializable type, print nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Import\+Decl} (const \textbf{ util\+::\+Param\+Data} \&, const size\+\_\+t, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em For a matrix type, print nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Import\+Decl} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$indent, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the cppclass definition for a serializable model; print nothing for a non-\/serializable type. \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 
void \textbf{ Print\+C\+PP} (const \textbf{ util\+::\+Program\+Doc} \&program\+Info, const std\+::string \&main\+Filename, const std\+::string \&function\+Name)
\begin{DoxyCompactList}\small\item\em Given a list of parameter definition and program documentation, print a generated .cpp file to stdout. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Dataset} (const std\+::string \&dataset\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a matrix, print it. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Default} (const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Given a parameter name, print its corresponding default value. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Input} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input in method definition for a regular parameter type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Input} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input in method definition for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Input} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input in method definition for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Input} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input in method definition for a serializable model. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Input} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\begin{DoxyCompactList}\small\item\em Given parameter information and the current number of spaces for indentation, print the code to process the output to cout. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Output} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output for a regular parameter type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Output} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Output} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Output} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output for a serializable model. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Output} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\begin{DoxyCompactList}\small\item\em Given parameter information and the current number of spaces for indentation, print the code to process the output to cout. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Doc} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$is\+Lower)
\begin{DoxyCompactList}\small\item\em Print the docstring documentation for a given parameter. \end{DoxyCompactList}\item 
void \textbf{ Print\+Go} (const \textbf{ util\+::\+Program\+Doc} \&program\+Info, const std\+::string \&function\+Name)
\begin{DoxyCompactList}\small\item\em Given a list of parameter definition and program documentation, print a generated .go file to stdout. \end{DoxyCompactList}\item 
void \textbf{ PrintH} (const \textbf{ util\+::\+Program\+Doc} \&program\+Info, const std\+::string \&function\+Name)
\begin{DoxyCompactList}\small\item\em Given a list of parameter definition and program documentation, print a generated .h file to stdout. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Import} ()
\begin{DoxyCompactList}\small\item\em Print any import information for the Go binding. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Input\+Option\+Info} ()
\begin{DoxyCompactList}\small\item\em Print any special information about input options. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Input\+Options} ()
\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\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a standard option type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print input processing for a serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Input\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$)
\begin{DoxyCompactList}\small\item\em Given parameter information and the current number of spaces for indentation, print the code to process the input to cout. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Config} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print param in configuration struct for a standard option type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Config} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print param in configuration struct for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Config} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, 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 param in configuration struct for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Config} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, 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 param in method configuration struct for a serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Config} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$)
\begin{DoxyCompactList}\small\item\em Given parameter information and the current number of spaces for indentation, print the code to process the input to cout. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Init} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print parameter with it\textquotesingle{}s default value for a standard option type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Init} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print parameter with its default value for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Init} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, 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 parameter with its default value for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Init} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, 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 parameter with its default value for a serializable type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Method\+Init} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$input, void $\ast$)
\begin{DoxyCompactList}\small\item\em Given parameter information and the current number of spaces for indentation, print the code to process the input to cout. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Model} (const std\+::string \&model\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a model, print it. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+C\+PP} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Non-\/serializable models don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+C\+PP} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Matrices don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+C\+PP} (const \textbf{ util\+::\+Param\+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 Matrices with Info don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+C\+PP} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Serializable models require a special class definition. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+C\+PP} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the function to set and get serialization models from Go to mlpack. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+Go} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Non-\/serializable models don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+Go} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Matrices don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+Go} (const \textbf{ util\+::\+Param\+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 Matrices with Info don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+Go} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Serializable models require a special class definition. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+Util\+Go} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the Go struct for Go serialization model and their associated set and get methods. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+UtilH} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Non-\/serializable models don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+UtilH} (const \textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Matrices don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+UtilH} (const \textbf{ util\+::\+Param\+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 Matrices with Info don\textquotesingle{}t require any special definitions, so this prints nothing. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+UtilH} (const \textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Serializable models require a special class definition. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Model\+UtilH} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\begin{DoxyCompactList}\small\item\em Print the function to set and get serialization models from Go to mlpack. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Optional\+Inputs} ()
\item 
{\footnotesize template$<$typename T , typename... Args$>$ }\\std\+::string \textbf{ Print\+Optional\+Inputs} (const std\+::string \&param\+Name, const T \&value, Args... args)
\begin{DoxyCompactList}\small\item\em Print an input option. \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... Args$>$ }\\std\+::string \textbf{ Print\+Output\+Options} (Args... args)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a regular parameter type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename std\+::enable\+\_\+if$<$!std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a matrix type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a matrix with info type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const size\+\_\+t indent, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print output processing for a serializable model. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Output\+Processing} (const \textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\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 
{\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 
void \textbf{ Strip\+Type} (const std\+::string \&input\+Type, std\+::string \&go\+Stripped\+Type, std\+::string \&stripped\+Type, std\+::string \&printed\+Type, std\+::string \&defaults\+Type)
\begin{DoxyCompactList}\small\item\em Given an input type like, e.\+g., \char`\"{}\+Logistic\+Regression$<$$>$\char`\"{}, return four types that can be used in Go code. \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_1go_a76ec81242ffb9c156f9ba5764c24cd50}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Camel\+Case@{Camel\+Case}}
\index{Camel\+Case@{Camel\+Case}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Camel\+Case()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+Camel\+Case (\begin{DoxyParamCaption}\item[{std\+::string}]{s,  }\item[{bool}]{lower }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given an snake\+\_\+case like, e.\+g., \char`\"{}logistic\+\_\+regression\char`\"{}, return Camel\+Case(e.\+g. 

\char`\"{}\+Logistic\+Regression\char`\"{}) that can be used in Go code.


\begin{DoxyParams}{Parameters}
{\em s} & input string. \\
\hline
{\em lower} & is of bool type. If lower is true then output must be lower\+Camel\+Case else Upper\+Camel\+Case. \\
\hline
\end{DoxyParams}


Definition at line 28 of file camel\+\_\+case.\+hpp.



Referenced by Print\+Defn\+Input(), Print\+Doc(), Print\+Input\+Processing(), Print\+Method\+Config(), Print\+Method\+Init(), and Print\+Output\+Processing().

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a4f77d7580e6527d8f8b9ddc30c04a697}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Default\+Param@{Default\+Param}}
\index{Default\+Param@{Default\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Default\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+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_1go_a386f7801c92bc96cb9b7523934e485de}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_aa2c7b6b335699bb1274d2aa9c4e03ea3}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [2/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a69dfdf43e67f209fbadc64fb61bf0380}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a208b3141d946cd9d7be9c2b8244e1430}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a42eb70cc18c59b37417c12f6bdd54145}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Default\+Param\+Impl@{Default\+Param\+Impl}}
\index{Default\+Param\+Impl@{Default\+Param\+Impl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Default\+Param\+Impl()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_aba7be021859aac664e036568b37ba994}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Binding\+Name@{Get\+Binding\+Name}}
\index{Get\+Binding\+Name@{Get\+Binding\+Name}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Binding\+Name()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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 Go name. 

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



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

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



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

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



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

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



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

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



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



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

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



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

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



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

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



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

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



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

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



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a1ec8fec2ae7384b5cdd3a3ee2da53f6d}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Options@{Get\+Options}}
\index{Get\+Options@{Get\+Options}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [1/2]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Get\+Options (\begin{DoxyParamCaption}\item[{std\+::vector$<$ std\+::tuple$<$ std\+::string, std\+::string $>$$>$ \&}]{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\mbox{\label{namespacemlpack_1_1bindings_1_1go_ae0f373fe77f97d9fec702dd317df5701}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Options@{Get\+Options}}
\index{Get\+Options@{Get\+Options}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Get\+Options (\begin{DoxyParamCaption}\item[{std\+::vector$<$ std\+::tuple$<$ std\+::string, std\+::string $>$$>$ \&}]{results,  }\item[{const std\+::string \&}]{param\+Name,  }\item[{const T \&}]{value,  }\item[{Args...}]{args }\end{DoxyParamCaption})}



Assemble a vector of string tuples indicating parameter names and what should be printed for them. 

(For output parameters, we just need to print the value.) \mbox{\label{namespacemlpack_1_1bindings_1_1go_adce628543bae7b2deb933f0a6fc52bd0}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Param@{Get\+Param}}
\index{Get\+Param@{Get\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Param()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Get\+Param (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



All Go 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_1go_a55977264c1fde249db3d8a6b3f3f6054}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a4f30a686b7ed09ce71e26b219e5b1bfc}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_af7ba01818e330aaa2c5dc84d6fa29691}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a0491f0a4d08e10136614149cdf4a87c1}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a20f24161a023f8d6e250a0b5bd9c132f}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_af67396857b45ed27235b4cf02e5627df}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Get\+Printable\+Param@{Get\+Printable\+Param}}
\index{Get\+Printable\+Param@{Get\+Printable\+Param}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Get\+Printable\+Param()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+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 $\ast$} & (input) Unused parameter. \\
\hline
{\em output} & Output storage for the string. \\
\hline
\end{DoxyParams}


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

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

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

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

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

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

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



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

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

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

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

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

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



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

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



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

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



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

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



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



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

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



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


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


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

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



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

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



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

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



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

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



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

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



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

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



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

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



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

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



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a82c93312d3da71dcfdfe4618534c2dc5}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Import\+Decl@{Import\+Decl}}
\index{Import\+Decl@{Import\+Decl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Import\+Decl()\hspace{0.1cm}{\footnotesize\ttfamily [1/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Import\+Decl (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const size\+\_\+t}]{indent,  }\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})}



For a serializable type, print a cppclass definition. 

This will give output of the form\+:

Definition at line 25 of file print\+\_\+import\+\_\+decl.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a303f0763df7398ec9ffbaef7bc12ae25}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Import\+Decl@{Import\+Decl}}
\index{Import\+Decl@{Import\+Decl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Import\+Decl()\hspace{0.1cm}{\footnotesize\ttfamily [2/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Import\+Decl (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const size\+\_\+t}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



For a non-\/serializable type, print nothing. 



Definition at line 44 of file print\+\_\+import\+\_\+decl.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a4518c5499ed6c52489df932c938a9428}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Import\+Decl@{Import\+Decl}}
\index{Import\+Decl@{Import\+Decl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Import\+Decl()\hspace{0.1cm}{\footnotesize\ttfamily [3/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Import\+Decl (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const size\+\_\+t}]{,  }\item[{const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



For a matrix type, print nothing. 



Definition at line 57 of file print\+\_\+import\+\_\+decl.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a967d64120f883ae207aee16e59329936}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Import\+Decl@{Import\+Decl}}
\index{Import\+Decl@{Import\+Decl}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Import\+Decl()\hspace{0.1cm}{\footnotesize\ttfamily [4/4]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Import\+Decl (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{indent,  }\item[{void $\ast$}]{ }\end{DoxyParamCaption})}



Print the cppclass definition for a serializable model; print nothing for a non-\/serializable type. 


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


Definition at line 74 of file print\+\_\+import\+\_\+decl.\+hpp.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_aed42bd588a5336a8e78e8fe1419f9a94}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Param\+String@{Param\+String}}
\index{Param\+String@{Param\+String}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Param\+String()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a652bd25d7096c987bd0aed964deb801a}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+C\+PP@{Print\+C\+PP}}
\index{Print\+C\+PP@{Print\+C\+PP}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+C\+P\+P()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+C\+PP (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Program\+Doc} \&}]{program\+Info,  }\item[{const std\+::string \&}]{main\+Filename,  }\item[{const std\+::string \&}]{function\+Name }\end{DoxyParamCaption})}



Given a list of parameter definition and program documentation, print a generated .cpp file to stdout. 

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



Given the name of a matrix, print it. 

Here we do not need to modify anything. \mbox{\label{namespacemlpack_1_1bindings_1_1go_acac3f93d6ddc9eae7c0cf94881ef1d91}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Default@{Print\+Default}}
\index{Print\+Default@{Print\+Default}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Default()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_ad0a6d5eb8bb076da7c6095d733764a42}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Defn\+Input@{Print\+Defn\+Input}}
\index{Print\+Defn\+Input@{Print\+Defn\+Input}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Defn\+Input()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Defn\+Input (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print input in method definition for a regular parameter type. 



Definition at line 29 of file print\+\_\+defn\+\_\+input.\+hpp.



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

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



Print input in method definition for a matrix type. 



Definition at line 47 of file print\+\_\+defn\+\_\+input.\+hpp.



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

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



Print input in method definition for a matrix with info type. 



Definition at line 63 of file print\+\_\+defn\+\_\+input.\+hpp.



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

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



Print input in method definition for a serializable model. 



Definition at line 80 of file print\+\_\+defn\+\_\+input.\+hpp.



References Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::name, Param\+Data\+::required, and Strip\+Type().

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



Given parameter information and the current number of spaces for indentation, print the code to process the output to cout. 

This code assumes that data.\+input is false, and should not be called when data.\+input is true. If this is the only output, the results will be different.

The input pointer should be a pointer to a std\+::tuple$<$size\+\_\+t, bool$>$ where the first element is the indentation and the second element is a boolean representing whether or not this is the only output parameter.


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


Definition at line 112 of file print\+\_\+defn\+\_\+input.\+hpp.

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



Print output for a regular parameter type. 



Definition at line 28 of file print\+\_\+defn\+\_\+output.\+hpp.

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



Print output for a matrix type. 



Definition at line 42 of file print\+\_\+defn\+\_\+output.\+hpp.

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



Print output for a matrix with info type. 



Definition at line 54 of file print\+\_\+defn\+\_\+output.\+hpp.

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



Print output for a serializable model. 



Definition at line 67 of file print\+\_\+defn\+\_\+output.\+hpp.



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

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



Given parameter information and the current number of spaces for indentation, print the code to process the output to cout. 

This code assumes that data.\+input is false, and should not be called when data.\+input is true. If this is the only output, the results will be different.

The input pointer should be a pointer to a std\+::tuple$<$size\+\_\+t, bool$>$ where the first element is the indentation and the second element is a boolean representing whether or not this is the only output parameter.


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


Definition at line 93 of file print\+\_\+defn\+\_\+output.\+hpp.

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



Print the docstring documentation for a given parameter. 

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

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


\begin{DoxyParams}{Parameters}
{\em d} & Parameter data struct. \\
\hline
{\em input} & Pointer to size\+\_\+t containing indent. \\
\hline
{\em is\+Lower} & is pointer to bool if is\+Lower is true then parameter is Output or Required Input. \\
\hline
\end{DoxyParams}


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



References Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::desc, mlpack\+::util\+::\+Hyphenate\+String(), if(), Param\+Data\+::name, Param\+Data\+::required, and Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a35190e5e77241014740c890049da40c7}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Go@{Print\+Go}}
\index{Print\+Go@{Print\+Go}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Go()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Go (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Program\+Doc} \&}]{program\+Info,  }\item[{const std\+::string \&}]{function\+Name }\end{DoxyParamCaption})}



Given a list of parameter definition and program documentation, print a generated .go file to stdout. 


\begin{DoxyParams}{Parameters}
{\em program\+Info} & Documentation for the program. \\
\hline
{\em function\+Name} & Name of the function (i.\+e. \char`\"{}pca\char`\"{}). \\
\hline
\end{DoxyParams}
\mbox{\label{namespacemlpack_1_1bindings_1_1go_a19573d5c9484e3d19236eb7b1cfff3a5}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!PrintH@{PrintH}}
\index{PrintH@{PrintH}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+H()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+PrintH (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Program\+Doc} \&}]{program\+Info,  }\item[{const std\+::string \&}]{function\+Name }\end{DoxyParamCaption})}



Given a list of parameter definition and program documentation, print a generated .h file to stdout. 


\begin{DoxyParams}{Parameters}
{\em program\+Info} & Documentation for the program. \\
\hline
{\em function\+Name} & Name of the function (i.\+e. \char`\"{}pca\char`\"{}). \\
\hline
\end{DoxyParams}
\mbox{\label{namespacemlpack_1_1bindings_1_1go_ae1964063d8654fe8a0ade4b91dbe3d2d}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Import@{Print\+Import}}
\index{Print\+Import@{Print\+Import}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Import()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+Print\+Import (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Print any import information for the Go binding. 

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



Print any special information about input options. 

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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a11290b7658f2d7d81771b65ec58204ca}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Input\+Options@{Print\+Input\+Options}}
\index{Print\+Input\+Options@{Print\+Input\+Options}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Input\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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}. \mbox{\label{namespacemlpack_1_1bindings_1_1go_a3b8e1ccb62c34bd6f2e54cda39ce8642}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Input\+Processing@{Print\+Input\+Processing}}
\index{Print\+Input\+Processing@{Print\+Input\+Processing}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Input\+Processing()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Input\+Processing (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const size\+\_\+t}]{indent,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Print input processing for a standard option type. 

This gives us code like\+:

// Detect if the parameter was passed; set if so. if param.\+Name != nil \{ set\+Param$<$d.\+cpp\+Type$>$(\char`\"{}param\+Name\char`\"{}, param.\+Name) set\+Passed(\char`\"{}param\+Name\char`\"{}) \}

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



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

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



Print input processing for a matrix type. 

This gives us code like\+:

// Detect if the parameter was passed; set if so. if param.\+Name != nil \{ gonum\+To\+Arma$<$type$>$(\char`\"{}param\+Name\char`\"{}, param.\+Name) set\+Passed(\char`\"{}param\+Name\char`\"{}) \}

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



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

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



Print input processing for a matrix with info type. 

This gives us code like\+:

// Detect if the parameter was passed; set if so. if param.\+Name != nil \{ gonum\+To\+Arma\+Mat\+With\+Info$<$type$>$(\char`\"{}param\+Name\char`\"{}, param.\+Name) set\+Passed(\char`\"{}param\+Name\char`\"{}) \}

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



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

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



Print input processing for a serializable type. 

This gives us code like\+:

// Detect if the parameter was passed; set if so. if param.\+Name != nil \{ set$<$\+Model\+Type$>$(\char`\"{}param\+Name\char`\"{}, param.\+Name) set\+Passed(\char`\"{}param\+Name\char`\"{}) \}

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



References Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::name, Param\+Data\+::required, and Strip\+Type().

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



Given parameter information and the current number of spaces for indentation, print the code to process the input to cout. 

This code assumes that data.\+input is true, and should not be called when data.\+input is false.

The number of spaces to indent should be passed through the input pointer.


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


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

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



Print param in configuration struct for a standard option type. 



Definition at line 29 of file print\+\_\+method\+\_\+config.\+hpp.



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

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



Print param in configuration struct for a matrix type. 



Definition at line 64 of file print\+\_\+method\+\_\+config.\+hpp.



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a2170469114fdb6be64c0f6ad7bc316fc}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Method\+Config@{Print\+Method\+Config}}
\index{Print\+Method\+Config@{Print\+Method\+Config}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Method\+Config()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Method\+Config (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const size\+\_\+t}]{indent,  }\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 param in configuration struct for a matrix with info type. 



Definition at line 96 of file print\+\_\+method\+\_\+config.\+hpp.



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a31347080b22c301186cda5d8920999a2}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Method\+Config@{Print\+Method\+Config}}
\index{Print\+Method\+Config@{Print\+Method\+Config}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Method\+Config()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Method\+Config (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const size\+\_\+t}]{indent,  }\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 param in method configuration struct for a serializable type. 



Definition at line 129 of file print\+\_\+method\+\_\+config.\+hpp.



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

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



Given parameter information and the current number of spaces for indentation, print the code to process the input to cout. 

This code assumes that data.\+input is true, and should not be called when data.\+input is false.

The number of spaces to indent should be passed through the input pointer.


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


Definition at line 170 of file print\+\_\+method\+\_\+config.\+hpp.

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



Print parameter with it\textquotesingle{}s default value for a standard option type. 



Definition at line 29 of file print\+\_\+method\+\_\+init.\+hpp.



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

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



Print parameter with its default value for a matrix type. 



Definition at line 86 of file print\+\_\+method\+\_\+init.\+hpp.



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a9d439a913f4e7575354b1946836709eb}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Method\+Init@{Print\+Method\+Init}}
\index{Print\+Method\+Init@{Print\+Method\+Init}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Method\+Init()\hspace{0.1cm}{\footnotesize\ttfamily [3/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Method\+Init (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const size\+\_\+t}]{indent,  }\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 parameter with its default value for a matrix with info type. 



Definition at line 118 of file print\+\_\+method\+\_\+init.\+hpp.



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a0cf7ad25e92f1c311cf58ba10341f9fc}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Method\+Init@{Print\+Method\+Init}}
\index{Print\+Method\+Init@{Print\+Method\+Init}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Method\+Init()\hspace{0.1cm}{\footnotesize\ttfamily [4/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Method\+Init (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const size\+\_\+t}]{indent,  }\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 parameter with its default value for a serializable type. 



Definition at line 151 of file print\+\_\+method\+\_\+init.\+hpp.



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

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



Given parameter information and the current number of spaces for indentation, print the code to process the input to cout. 

This code assumes that data.\+input is true, and should not be called when data.\+input is false.

The number of spaces to indent should be passed through the input pointer.


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


Definition at line 192 of file print\+\_\+method\+\_\+init.\+hpp.

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



Given the name of a model, print it. 

Here we do not need to modify anything. \mbox{\label{namespacemlpack_1_1bindings_1_1go_adef1991e3ee0fb3585c89259c39dd2b7}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Model\+Util\+C\+PP@{Print\+Model\+Util\+C\+PP}}
\index{Print\+Model\+Util\+C\+PP@{Print\+Model\+Util\+C\+PP}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Model\+Util\+C\+P\+P()\hspace{0.1cm}{\footnotesize\ttfamily [1/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Model\+Util\+C\+PP (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{,  }\item[{const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$}]{ = {\ttfamily 0},  }\item[{const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$}]{ = {\ttfamily 0} }\end{DoxyParamCaption})}



Non-\/serializable models don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 27 of file print\+\_\+model\+\_\+util.\+hpp.

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



Matrices don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 41 of file print\+\_\+model\+\_\+util.\+hpp.

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



Matrices with Info don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 52 of file print\+\_\+model\+\_\+util.\+hpp.

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



Serializable models require a special class definition. 

This gives us code like\+:

extern \char`\"{}\+C\char`\"{} void mlpack\+Set$<$Type$>$Ptr( const char$\ast$ identifier, void {\itshape value) \{ Set\+Param\+Ptr$<$Type$>$(identifier, static\+\_\+cast$<$Type$>$}(value)); \}

This gives us code like\+:

extern \char`\"{}\+C\char`\"{} void {\itshape mlpack\+Get$<$Type$>$Ptr(const char} identifier) \{ $<$Type$>$ $\ast$modelptr = Get\+Param\+Ptr$<$Type$>$(identifier); return modelptr; \}

Definition at line 64 of file print\+\_\+model\+\_\+util.\+hpp.



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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_ad9159ac10b028f60760ae7107d873b75}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Model\+Util\+C\+PP@{Print\+Model\+Util\+C\+PP}}
\index{Print\+Model\+Util\+C\+PP@{Print\+Model\+Util\+C\+PP}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Model\+Util\+C\+P\+P()\hspace{0.1cm}{\footnotesize\ttfamily [5/5]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Print\+Model\+Util\+C\+PP (\begin{DoxyParamCaption}\item[{const \textbf{ util\+::\+Param\+Data} \&}]{d,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{ }\end{DoxyParamCaption})}



Print the function to set and get serialization models from Go to mlpack. 


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


Definition at line 125 of file print\+\_\+model\+\_\+util.\+hpp.

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



Non-\/serializable models don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 227 of file print\+\_\+model\+\_\+util.\+hpp.

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



Matrices don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 241 of file print\+\_\+model\+\_\+util.\+hpp.

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



Matrices with Info don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 252 of file print\+\_\+model\+\_\+util.\+hpp.

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



Serializable models require a special class definition. 

This gives us code like\+:

type $<$Type$>$ struct \{ mem unsafe.\+Pointer \}

This gives us code like\+:

func (m $\ast$$<$Type$>$) alloc$<$Type$>$(identifier string) \{ m.\+mem = C.\+mlpack\+Get$<$Type$>$Ptr(C.\+C\+String(identifier)) runtime.\+Keep\+Alive(m) \}

This gives us code like\+:

func (m $\ast$$<$Type$>$) get$<$Type$>$(identifier string) \{ m.\+alloc$<$Type$>$(identifier) \}

Definition at line 264 of file print\+\_\+model\+\_\+util.\+hpp.



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

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



Print the Go struct for Go serialization model and their associated set and get methods. 


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


Definition at line 338 of file print\+\_\+model\+\_\+util.\+hpp.

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



Non-\/serializable models don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 138 of file print\+\_\+model\+\_\+util.\+hpp.

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



Matrices don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 153 of file print\+\_\+model\+\_\+util.\+hpp.

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



Matrices with Info don\textquotesingle{}t require any special definitions, so this prints nothing. 



Definition at line 164 of file print\+\_\+model\+\_\+util.\+hpp.

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



Serializable models require a special class definition. 

This gives us code like\+:

extern void {\itshape mlpack\+Set$<$Type$>$Ptr(const char} identifier, void$\ast$ value);

This gives us code like\+:

extern void {\itshape mlpack\+Get$<$Type$>$Ptr(const char} identifier);

Definition at line 176 of file print\+\_\+model\+\_\+util.\+hpp.



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

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



Print the function to set and get serialization models from Go to mlpack. 


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


Definition at line 215 of file print\+\_\+model\+\_\+util.\+hpp.

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

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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_ac0a4c394df7a5ab7caa9f51a549b51ac}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Output\+Options@{Print\+Output\+Options}}
\index{Print\+Output\+Options@{Print\+Output\+Options}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Output\+Options()\hspace{0.1cm}{\footnotesize\ttfamily [2/2]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+Print\+Output\+Options (\begin{DoxyParamCaption}\item[{Args...}]{args }\end{DoxyParamCaption})}

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



Print output processing for a regular parameter type. 

This gives us code like\+:

$<$param\+Name$>$ \+:= Get\+Param$<$Type$>$(\char`\"{}param\+Name\char`\"{})

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



References Camel\+Case(), and Param\+Data\+::name.

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



Print output processing for a matrix type. 

This gives us code like\+:

var $<$param\+Name$>$Ptr mlpack\+Arma $<$param\+Name$>$ \+:= $<$param\+Name$>$\+\_\+ptr.\+Arma\+To\+Gonum\+\_\+$<$Type$>$(\char`\"{}param\+Name\char`\"{})

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



References Camel\+Case(), and Param\+Data\+::name.

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



Print output processing for a matrix with info type. 

This gives us code like\+:

var $<$param\+Name$>$\+\_\+ptr mlpack\+Arma $<$param\+Name$>$ \+:= $<$param\+Name$>$Ptr.\+Arma\+To\+Gonum\+With\+Info$<$Type$>$(\char`\"{}param\+Name\char`\"{})

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



References Camel\+Case(), and Param\+Data\+::name.

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



Print output processing for a serializable model. 

This gives us code like\+:

var model\+Out $<$Type$>$ model\+Out.\+get$<$Type$>$(\char`\"{}param\+Name\char`\"{})

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



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

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


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


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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_adcaee5f3f7bbacdf4dd0129b2c0e47e5}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [1/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_ac66a5798589c03fc9c9500179569cc19}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [2/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a34ddcb686dc1c11e76bc35d77ce6b7c7}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [3/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a77b5ed91ea65510e09f39ee801e8a493}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [4/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a537d179cb65e1dee364d72521d0bbbce}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [5/6]}}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_ae1ee14e407b5eb948253ad4191f8386f}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Print\+Type\+Doc@{Print\+Type\+Doc}}
\index{Print\+Type\+Doc@{Print\+Type\+Doc}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Print\+Type\+Doc()\hspace{0.1cm}{\footnotesize\ttfamily [6/6]}}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+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 67 of file print\+\_\+type\+\_\+doc.\+hpp.

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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a57f9d66c5bd1c6dbacee52c716d15336}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Program\+Call@{Program\+Call}}
\index{Program\+Call@{Program\+Call}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Program\+Call()}
{\footnotesize\ttfamily std\+::string mlpack\+::bindings\+::go\+::\+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_1go_a5da63fccac0f8eb8bd6950232c8dd363}} 
\index{mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}!Strip\+Type@{Strip\+Type}}
\index{Strip\+Type@{Strip\+Type}!mlpack\+::bindings\+::go@{mlpack\+::bindings\+::go}}
\subsubsection{Strip\+Type()}
{\footnotesize\ttfamily void mlpack\+::bindings\+::go\+::\+Strip\+Type (\begin{DoxyParamCaption}\item[{const std\+::string \&}]{input\+Type,  }\item[{std\+::string \&}]{go\+Stripped\+Type,  }\item[{std\+::string \&}]{stripped\+Type,  }\item[{std\+::string \&}]{printed\+Type,  }\item[{std\+::string \&}]{defaults\+Type }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}



Given an input type like, e.\+g., \char`\"{}\+Logistic\+Regression$<$$>$\char`\"{}, return four types that can be used in Go code. 

go\+Stripped\+Type will be a type with lower first letter of parameter name so it is of unexported type in Go\+Doc (e.\+g. \char`\"{}logistic\+Regression\char`\"{}), stripped\+Type will be a type with no template parameters (e.\+g. \char`\"{}\+Logistic\+Regression\char`\"{}), printed\+Type will be a printable type with the template parameters (e.\+g. \char`\"{}\+Logistic\+Regression$<$$>$\char`\"{}), and defaults\+Type will be a printable type with a default template parameter (e.\+g. \char`\"{}\+Logistic\+Regression\textbackslash{}$<$\+T\textbackslash{}$>$\char`\"{}) that can be used for class definitions. 

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



Referenced by Get\+Go\+Type(), Print\+Defn\+Input(), Print\+Defn\+Output(), Print\+Input\+Processing(), Print\+Model\+Util\+C\+P\+P(), Print\+Model\+Util\+Go(), Print\+Model\+Util\+H(), and Print\+Output\+Processing().



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