\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 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Default\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Return the default value of an option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::string $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ mlpack\+::data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of an option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a vector option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::string $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a string option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if\+\_\+c$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value$\vert$$\vert$std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ mlpack\+::data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a matrix option, a tuple option, a serializable option, or a string option (this returns the default filename, or \textquotesingle{}\textquotesingle{} if the default is no file). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Default\+Param\+Impl} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return the default value of a model option (this returns the default filename, or \textquotesingle{}\textquotesingle{} if the default is no file). \end{DoxyCompactList}\item 
std\+::string \textbf{ Get\+Binding\+Name} (const std\+::string \&binding\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a binding, print its Go name. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Go\+Type} (\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} (\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} (\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 $>$} (\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 $>$} (\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 $>$} (\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 $>$} (\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 $>$} (\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} (\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} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print an option of a simple type. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a vector option, with spaces between it. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a matrix option (this prints its size). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a serializable class option (this prints the class name). \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Print a combination Dataset\+Info/matrix parameter. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Printable\+Param} (\textbf{ util\+::\+Param\+Data} \&data, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Print an option into a std\+::string. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Printable\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ bool $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ bool $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ bool, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ double $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ double $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ double, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ int $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ int $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ int, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Get\+Printable\+Type$<$ std\+::string $>$} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ std\+::string $>$$>$\+::type $\ast$, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ std\+::string, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&, const typename boost\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Get\+Type} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Function is used to generate the type names that are used in calls to functions like 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 $>$} (\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 $>$} (\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 $>$} (\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 $>$} (\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 $>$} (\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 
std\+::string \textbf{ Param\+String} (const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Given the parameter name, determine what it would actually be when passed to the command line. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Dataset} (const std\+::string \&dataset\+Name)
\begin{DoxyCompactList}\small\item\em Given the name of a matrix, print it. \end{DoxyCompactList}\item 
std\+::string \textbf{ Print\+Default} (const std\+::string \&param\+Name)
\begin{DoxyCompactList}\small\item\em Given a parameter name, print its corresponding default value. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Defn\+Input} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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\+::\+Binding\+Details} \&doc, 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 
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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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} (\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 
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} (\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} (\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} (\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} (\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} (\textbf{ util\+::\+Param\+Data} \&d, const void $\ast$, void $\ast$)
\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::disable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of an option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename std\+::enable\+\_\+if$<$ \textbf{ util\+::\+Is\+Std\+Vector}$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a vector. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename std\+::enable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a matrix option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename std\+::enable\+\_\+if$<$ std\+::is\+\_\+same$<$ T, std\+::tuple$<$ \textbf{ data\+::\+Dataset\+Info}, arma\+::mat $>$$>$\+::value $>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a matrix tuple option. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const typename boost\+::disable\+\_\+if$<$ arma\+::is\+\_\+arma\+\_\+type$<$ T $>$$>$\+::type $\ast$=0, const typename boost\+::enable\+\_\+if$<$ \textbf{ data\+::\+Has\+Serialize}$<$ T $>$$>$\+::type $\ast$=0)
\begin{DoxyCompactList}\small\item\em Return a string representing the command-\/line type of a model. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\void \textbf{ Print\+Type\+Doc} (\textbf{ util\+::\+Param\+Data} \&data, const void $\ast$, void $\ast$output)
\begin{DoxyCompactList}\small\item\em Print the command-\/line type of an option into a string. \end{DoxyCompactList}\item 
{\footnotesize template$<$typename T $>$ }\\std\+::string \textbf{ Print\+Value} (const T \&value, bool quotes)
\begin{DoxyCompactList}\small\item\em Given a parameter type, print the corresponding value. \end{DoxyCompactList}\item 
{\footnotesize template$<$$>$ }\\std\+::string \textbf{ Print\+Value} (const bool \&value, bool quotes)
\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_a2ed85213a0458c58adacd694dd1dd5b3}} 
\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[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



Return the default value of an option. 

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

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

\mbox{\label{namespacemlpack_1_1bindings_1_1go_ad9ad724a09278f46bfeafc6250d674f1}} 
\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[{\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_a1495232b06083207b4d8a4a7e73d9436}} 
\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[{\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_a05be07f76d7e0c1c5a4e0a3f3f5d3b69}} 
\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[{\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_ad63a0e3d345cac7208170299dd5e6fec}} 
\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[{\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_ac5ce818c8b25725ba39dde10ba3133d9}} 
\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[{\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_a59be27929d163660564671a9ca7356de}} 
\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[{\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_a1ae42ae3a989d22b3eb19234afa750aa}} 
\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[{\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_a22bf3d5e3612c5d18a1e135ef205b940}} 
\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[{\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_a1d6eba4d1c838d6d39315766d03a464c}} 
\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[{\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_a26c52c35a2e9e88e9297bd088245aaf1}} 
\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[{\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_a0d4f8f9ea239fd6fbceed7521e904196}} 
\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[{\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_ab96cd368d01c38e140342aaa46357af5}} 
\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[{\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_a3ac7e016079757cda5e6ea4e585534ad}} 
\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[{\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_ac2a8713cf15cb373bced4a4d835d127a}} 
\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[{\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_ae0994916ef5017bafd25d796eabdff06}} 
\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[{\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_ab149b92e15ca0bacc6e2da5369f7d694}} 
\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[{\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_a2f4fe517829c401305711fe1209b0f1f}} 
\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[{\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_abde257865ab750e6f70c3ae7f3c9243e}} 
\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[{\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_adf755a15fcede6ad38bc97ba8733083d}} 
\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[{\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_ab9cdf1f19bd418a517c98c1749b15ff1}} 
\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[{\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_a7a936911feb5a9c2c832649f4694fe2a}} 
\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[{\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_a84fbc0ace6b708579de048653a34d7f7}} 
\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[{\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_a366c97a56f46e1161903851b1176c0c4}} 
\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[{\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_a7cc3c64fcd7d293c959541856e3eb610}} 
\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[{\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_aabc5da007fd9bda3d617f608102eee1e}} 
\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[{\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_a067dad1b6cd0192a43f4fd35ceeb427d}} 
\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[{\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_af5c22138f79098a765306d6b8d9916fe}} 
\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[{\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_a577273a6850549249c13276ce291090b}} 
\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[{\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_aea07a7b656343aa536856ff5c25b8add}} 
\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[{\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_a45c326151fabd3b8d61d734247fddf17}} 
\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[{\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_a94ed42d56f43e6248acd10b5439e59cd}} 
\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[{\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_a6db66a523fef2e2fa7e9776ccf7105d9}} 
\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[{\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_ac7cd4a5a87971f8ea03209dc87955958}} 
\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[{\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_a39b56e708543011969bfc982ea055cd8}} 
\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[{\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_a6a0bc6a172a745e35eed847fa9e44965}} 
\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[{\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_a9f8ab0bef325d00d61d1903b62f0ed5a}} 
\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[{\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_a3e5518b9c7482e0a3e99b9cdda263a95}} 
\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[{\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_a0b64bcf9f9e9fa9bde51a0e2d1ef499f}} 
\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[{\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_a9848fcd31fc9af34c5d9b792a5b8102a}} 
\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[{\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_ac3867ba467242b3993d39dcf6da1653d}} 
\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[{\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_a1e84eefe3d6779ca52229261fd5d00af}} 
\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[{\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_ac699a8f6196ad42654c225fbb6e99d6a}} 
\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[{\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_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_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_a7c05388978bbd1562bd5f855b3be264d}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a5d84f3226b0710a1dce63c318cb25c44}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a9304f847bfab3a206dfbae155e38fb67}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a3afeab55fb05ed79fd8b6aeeff28a54b}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::name, Param\+Data\+::required, and Strip\+Type().

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a731f376817cf55a3f890736273b1c24a}} 
\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[{\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_a5b78d4297a88abf616d234e5c6c67230}} 
\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[{\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_a9cd1ed48be52e0f2a586cae8513abec4}} 
\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[{\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_a9e237d7a1046c18cf64760cef778ed2d}} 
\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[{\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_aec80a21508c1ef569000d7d43606dd08}} 
\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[{\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_aef39ef8ed7dbe3a87312c6cfe8dc217d}} 
\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[{\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_adbaa72724d7f6265c12c4d205c1d78a9}} 
\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[{\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 mlpack\+::util\+::\+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_a3a22bd0b5aa284ae0dc3d7542986df31}} 
\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\+::\+Binding\+Details} \&}]{doc,  }\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 doc} & 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{IO}{p.}{classmlpack_1_1IO}. \mbox{\label{namespacemlpack_1_1bindings_1_1go_a3866346aeed26609b1a97d962fa6fe32}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::cpp\+Type, if(), Param\+Data\+::name, Param\+Data\+::required, and Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a911152b857b829bce01e0f2315469ef0}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_afb3b41c7acd988435e1247e0b059025c}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a727ea710755594dcf66893842758914a}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::name, Param\+Data\+::required, and Strip\+Type().

\mbox{\label{namespacemlpack_1_1bindings_1_1go_afd8a8bda79eb0fe9cd05cb1e606e6d3b}} 
\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[{\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_af86c61eac4dcbbdd4d677dc8d078da9f}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a5b9b2774841764f8a98ab1f9d2a72496}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a0d8063b436cef596ccf11dba0bd69f74}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_acca74696bab849f5ec8ed4fdc73a2e7f}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a4e3af333092d8d43f5dde75160c4f6f9}} 
\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[{\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_ae18e5140e357a39e7fd9c171a6cdf5e6}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::name, Param\+Data\+::required, and Param\+Data\+::value.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_aced0e06495ee82b31245842674a5378b}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a38ed6119bb2faef89f5b0876d4f575de}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a9eb3901d029907356bc3832465516c64}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::name, and Param\+Data\+::required.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a2259799a668d3ec4aa7c84ace0efc935}} 
\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[{\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_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{IO}{p.}{classmlpack_1_1IO}. \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_a76b2a04be53e39d1b6e87074bcf7a12f}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_add5951094bdc9e48cc57696b0d1915e0}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a961fc633a0e424d1de53ec3ee94d25c2}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), and Param\+Data\+::name.

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a401bf030afff5dd49b05e053e019fc30}} 
\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[{\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 mlpack\+::util\+::\+Camel\+Case(), Param\+Data\+::cpp\+Type, Param\+Data\+::name, and Strip\+Type().

\mbox{\label{namespacemlpack_1_1bindings_1_1go_a038c56948726207f110343778afe05bd}} 
\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[{\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_a17ed667c655d683a42d3cc2257d26aa3}} 
\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[{\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_ac843da709d024507e23107b59566954c}} 
\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[{\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_a255685e61562b5866a91b981b0570c26}} 
\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[{\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_a9c1162e25791cada81c9b62451b01d47}} 
\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[{\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_a901b6698f38fe8af3ca38ab0fff6cd44}} 
\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[{\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_a7d383dd208dff138425ad289d6bacbbd}} 
\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[{\textbf{ util\+::\+Param\+Data} \&}]{data,  }\item[{const void $\ast$}]{,  }\item[{void $\ast$}]{output }\end{DoxyParamCaption})}



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



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

\mbox{\label{namespacemlpack_1_1bindings_1_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(), 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}

