mlpack  2.2.5
param.hpp File Reference
Include dependency graph for param.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define PARAM_DOUBLE_IN(ID, DESC, ALIAS, DEF)   PARAM_IN(double, ID, DESC, ALIAS, DEF, false)
 Define a double input parameter. More...

 
#define PARAM_DOUBLE_IN_REQ(ID, DESC, ALIAS)   PARAM_IN(double, ID, DESC, ALIAS, 0.0d, true)
 Define a required double parameter. More...

 
#define PARAM_DOUBLE_OUT(ID, DESC)   PARAM_OUT(double, ID, DESC, "", 0.0, false)
 Define a double output parameter. More...

 
#define PARAM_FLAG(ID, DESC, ALIAS)   PARAM_FLAG_INTERNAL(ID, DESC, ALIAS);
 Define a flag parameter. More...

 
#define PARAM_IN(T, ID, DESC, ALIAS, DEF, REQ)
 Define an input parameter. More...

 
#define PARAM_INT_IN(ID, DESC, ALIAS, DEF)   PARAM_IN(int, ID, DESC, ALIAS, DEF, false)
 Define an integer input parameter. More...

 
#define PARAM_INT_IN_REQ(ID, DESC, ALIAS)   PARAM_IN(int, ID, DESC, ALIAS, 0, true)
 Define a required integer input parameter. More...

 
#define PARAM_INT_OUT(ID, DESC)   PARAM_OUT(int, ID, DESC, "", 0, false)
 Define an integer output parameter. More...

 
#define PARAM_OUT(T, ID, DESC, ALIAS, DEF, REQ)
 
#define PARAM_STRING_IN(ID, DESC, ALIAS, DEF)   PARAM_IN(std::string, ID, DESC, ALIAS, DEF, false)
 Define a string input parameter. More...

 
#define PARAM_STRING_IN_REQ(ID, DESC, ALIAS)   PARAM_IN(std::string, ID, DESC, ALIAS, "", true)
 Define a required string parameter. More...

 
#define PARAM_STRING_OUT(ID, DESC, ALIAS)   PARAM_OUT(std::string, ID, DESC, ALIAS, "", false)
 Define a string output parameter. More...

 
#define PARAM_VECTOR_IN(T, ID, DESC, ALIAS)   PARAM_IN(std::vector<T>, ID, DESC, ALIAS, std::vector<T>(), false)
 Define a vector input parameter. More...

 
#define PARAM_VECTOR_IN_REQ(T, ID, DESC, ALIAS)   PARAM_IN(std::vector<T>, ID, DESC, ALIAS, std::vector<T>(), true);
 Define a required vector parameter. More...

 
#define PARAM_VECTOR_OUT(T, ID)   PARAM_OUT(std::vector<T>, ID, DESC, "", std::vector<T>(), false)
 Define a vector output parameter. More...

 
#define PROGRAM_INFO(NAME, DESC)
 Document an executable. More...

 

Detailed Description

Author
Matthew Amidon
Ryan Curtin

Definition of PARAM_*_IN() and PARAM_*_OUT() macros, as well as the PROGRAM_INFO() macro, which are used to define input and output parameters of command-line programs and bindings to other languages.

mlpack is free software; you may redistribute it and/or modify it under the terms of the 3-clause BSD license. You should have received a copy of the 3-clause BSD license along with mlpack. If not, see http://www.opensource.org/licenses/BSD-3-Clause for more information.

Definition in file param.hpp.

Macro Definition Documentation

◆ PARAM_DOUBLE_IN

#define PARAM_DOUBLE_IN (   ID,
  DESC,
  ALIAS,
  DEF 
)    PARAM_IN(double, ID, DESC, ALIAS, DEF, false)

Define a double input parameter.

The parameter can then be specified on the command line with –ID=value.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
DEFDefault value of the parameter.
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 133 of file param.hpp.

◆ PARAM_DOUBLE_IN_REQ

#define PARAM_DOUBLE_IN_REQ (   ID,
  DESC,
  ALIAS 
)    PARAM_IN(double, ID, DESC, ALIAS, 0.0d, true)

Define a required double parameter.

The parameter must then be specified on the command line with –ID=value.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 320 of file param.hpp.

◆ PARAM_DOUBLE_OUT

#define PARAM_DOUBLE_OUT (   ID,
  DESC 
)    PARAM_OUT(double, ID, DESC, "", 0.0, false)

Define a double output parameter.

This parameter will be printed on stdout at the end of the program; for instance, if the parameter name is "number" and the value is 5.012, the output on stdout would be of the following form:

number: 5.012

If the parameter is not set by the end of the program, a fatal runtime error will be issued.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 161 of file param.hpp.

◆ PARAM_FLAG

#define PARAM_FLAG (   ID,
  DESC,
  ALIAS 
)    PARAM_FLAG_INTERNAL(ID, DESC, ALIAS);

Define a flag parameter.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 57 of file param.hpp.

◆ PARAM_IN

#define PARAM_IN (   T,
  ID,
  DESC,
  ALIAS,
  DEF,
  REQ 
)
Value:
JOIN(JOIN(io_option_dummy_object_in_, __LINE__), opt) \
(false, DEF, ID, DESC, ALIAS, REQ, true);
A static object whose constructor registers a parameter with the CLI class.
Definition: option.hpp:32

Define an input parameter.

Don't use this function; use the other ones above that call it. Note that we are using the LINE macro for naming these actual parameters when COUNTER does not exist, which is a bit of an ugly hack... but this is the preprocessor, after all. We don't have much choice other than ugliness.

Parameters
TType of the parameter.
IDName of the parameter.
DESCDescription of the parameter (1-2 sentences).
ALIASAlias for this parameter (one letter).
DEFDefault value of the parameter.
REQWhether or not parameter is required (boolean value).

Definition at line 415 of file param.hpp.

◆ PARAM_INT_IN

#define PARAM_INT_IN (   ID,
  DESC,
  ALIAS,
  DEF 
)    PARAM_IN(int, ID, DESC, ALIAS, DEF, false)

Define an integer input parameter.

The parameter can then be specified on the command line with –ID=value.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
DEFDefault value of the parameter.
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 81 of file param.hpp.

◆ PARAM_INT_IN_REQ

#define PARAM_INT_IN_REQ (   ID,
  DESC,
  ALIAS 
)    PARAM_IN(int, ID, DESC, ALIAS, 0, true)

Define a required integer input parameter.

The parameter must then be specified on the command line with –ID=value.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 298 of file param.hpp.

◆ PARAM_INT_OUT

#define PARAM_INT_OUT (   ID,
  DESC 
)    PARAM_OUT(int, ID, DESC, "", 0, false)

Define an integer output parameter.

This parameter will be printed on stdout at the end of the program; for instance, if the parameter name is "number" and the value is 5, the output on stdout would be of the following form:

number: 5

If the parameter is not set by the end of the program, a fatal runtime error will be issued.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 109 of file param.hpp.

◆ PARAM_OUT

#define PARAM_OUT (   T,
  ID,
  DESC,
  ALIAS,
  DEF,
  REQ 
)
Value:
JOIN(JOIN(io_option_dummy_object_out_, __LINE__), opt) \
(false, DEF, ID, DESC, ALIAS, REQ, false);
A static object whose constructor registers a parameter with the CLI class.
Definition: option.hpp:32

Definition at line 420 of file param.hpp.

◆ PARAM_STRING_IN

#define PARAM_STRING_IN (   ID,
  DESC,
  ALIAS,
  DEF 
)    PARAM_IN(std::string, ID, DESC, ALIAS, DEF, false)

Define a string input parameter.

The parameter can then be specified on the command line with –ID=value. If ALIAS is equal to DEF_MOD (which is set using the PROGRAM_INFO() macro), the parameter can be specified with just –ID=value.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
DEFDefault value of the parameter.
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 186 of file param.hpp.

◆ PARAM_STRING_IN_REQ

#define PARAM_STRING_IN_REQ (   ID,
  DESC,
  ALIAS 
)    PARAM_IN(std::string, ID, DESC, ALIAS, "", true)

Define a required string parameter.

The parameter must then be specified on the command line with –ID=value.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 342 of file param.hpp.

◆ PARAM_STRING_OUT

#define PARAM_STRING_OUT (   ID,
  DESC,
  ALIAS 
)    PARAM_OUT(std::string, ID, DESC, ALIAS, "", false)

Define a string output parameter.

If the parameter name does not end in "_file" (i.e. "output_file", "predictions_file", etc.), then the string will be printed to stdout at the end of the program. For instance, if there was a string output parameter called "something" with value "hello", at the end of the program the output would be of the following form:

something: "hello"

If the parameter is not set by the end of the program, a fatal runtime error will be issued.

An alias is still allowed for string output parameters, because if the parameter name ends in "_file", then the user must be able to specify it as input. The default value will always be the empty string.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 223 of file param.hpp.

◆ PARAM_VECTOR_IN

#define PARAM_VECTOR_IN (   T,
  ID,
  DESC,
  ALIAS 
)    PARAM_IN(std::vector<T>, ID, DESC, ALIAS, std::vector<T>(), false)

Define a vector input parameter.

The parameter can then be specified on the command line with –ID=value1,value2,value3.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
DEFDefault value of the parameter.
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 247 of file param.hpp.

◆ PARAM_VECTOR_IN_REQ

#define PARAM_VECTOR_IN_REQ (   T,
  ID,
  DESC,
  ALIAS 
)    PARAM_IN(std::vector<T>, ID, DESC, ALIAS, std::vector<T>(), true);

Define a required vector parameter.

The parameter must then be specified on the command line with –ID=value1,value2,value3.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
ALIASAn alias for the parameter (one letter).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 365 of file param.hpp.

◆ PARAM_VECTOR_OUT

#define PARAM_VECTOR_OUT (   T,
  ID 
)    PARAM_OUT(std::vector<T>, ID, DESC, "", std::vector<T>(), false)

Define a vector output parameter.

This vector will be printed on stdout at the end of the program; for instance, if the parameter name is "vector" and the vector holds the array { 1, 2, 3, 4 }, the output on stdout would be of the following form:

vector: 1, 2, 3, 4

If the parameter is not set by the end of the program, a fatal runtime error will be issued.

Parameters
IDName of the parameter.
DESCQuick description of the parameter (1-2 sentences).
See also
mlpack::CLI, PROGRAM_INFO()
Bug:
The COUNTER variable is used in most cases to guarantee a unique global identifier for options declared using the PARAM_*() macros. However, not all compilers have this support–most notably, gcc < 4.3. In that case, the LINE macro is used as an attempt to get a unique global identifier, but collisions are still possible, and they produce bizarre error messages. See https://github.com/mlpack/mlpack/issues/100 for more information.

Definition at line 276 of file param.hpp.

◆ PROGRAM_INFO

#define PROGRAM_INFO (   NAME,
  DESC 
)
Value:
static mlpack::util::ProgramDoc \
cli_programdoc_dummy_object = mlpack::util::ProgramDoc(NAME, DESC);
A static object whose constructor registers program documentation with the CLI class.
Definition: option.hpp:80

Document an executable.

Only one instance of this macro should be present in your program! Therefore, use it in the main.cpp (or corresponding executable) in your program.

See also
mlpack::CLI, PARAM_FLAG(), PARAM_INT_IN(), PARAM_DOUBLE_IN(), PARAM_STRING_IN(), PARAM_VECTOR_IN(), PARAM_INT_OUT(), PARAM_DOUBLE_OUT(), PARAM_VECTOR_OUT(), PARAM_INT_IN_REQ(), PARAM_DOUBLE_IN_REQ(), PARAM_STRING_IN_REQ(), PARAM_VECTOR_IN_REQ(), PARAM_INT_OUT_REQ(), PARAM_DOUBLE_OUT_REQ(), PARAM_VECTOR_OUT_REQ(), PARAM_STRING_OUT_REQ().
Parameters
NAMEShort string representing the name of the program.
DESCLong string describing what the program does and possibly a simple usage example. Newlines should not be used here; this is taken care of by CLI (however, you can explicitly specify newlines to denote new paragraphs).

Definition at line 37 of file param.hpp.