casadi::Options Struct Reference

Options metadata for a class. More...

#include <options.hpp>

Detailed Description

Author

Joel Andersson, Joris Gillis

Date

2010-2016

Extra doc: https://github.com/casadi/casadi/wiki/L_x9

Definition at line 40 of file options.hpp.

Classes
struct	Entry

Public Member Functions
const Options::Entry *	find (const std::string &name) const
std::vector< std::string >	all () const
std::string	type (const std::string &name) const
std::string	info (const std::string &name) const
void	disp (std::ostream &stream) const
std::vector< std::string >	suggestions (const std::string &word, casadi_int amount=5) const
	Get the best suggestions for a misspelled word. More...
void	best_matches (const std::string &word, std::vector< std::pair< double, std::string > > &best) const
	Find best matches. More...
void	check (const Dict &opts) const
	Check if options exist. More...
void	print_all (std::ostream &stream) const
	Print list of options. More...
void	print_one (const std::string &name, std::ostream &stream) const
	Print all information there is to know about a certain option. More...

Static Public Member Functions
static double	word_distance (const std::string &a, const std::string &b)
	A distance metric between two words. More...
static bool	has_dot (const Dict &opts)
	Does the dictionary contain a dot. More...
static bool	has_null (const Dict &opts)
	Does the dictionary has null objects. More...
static bool	is_sane (const Dict &opts)
	Is the dictionary sane. More...
static Dict	sanitize (const Dict &opts, bool top_level=true)
	Sanitize a options dictionary. More...

Public Attributes
std::vector< const Options * >	bases
std::map< std::string, Entry >	entries

Member Function Documentation

all()

std::vector< std::string > casadi::Options::all

(

)

const

Definition at line 283 of file options.cpp.

                                          {
    std::vector<std::string> ret;
    for (auto&& e : entries) ret.push_back(e.first);
    return ret;
  }

References entries.

Referenced by casadi::conic_options(), casadi::nlpsol_options(), and casadi::rootfinder_options().

best_matches()

void casadi::Options::best_matches	(	const std::string &	word,
		std::vector< std::pair< double, std::string > > &	best
	)		const

Extra doc: https://github.com/casadi/casadi/wiki/L_xc

Definition at line 127 of file options.cpp.

                                                                                 {
    // Iterate over bases
    for (auto&& b : bases) {
      b->best_matches(word, best);
    }
 
    // Worst match so far
    auto worst = max_element(best.begin(), best.end());
 
    // Loop over entries
    for (auto&& e : entries) {
      // Get word distance
      double d = word_distance(e.first, word);
 
      // Keep if better than the worst amongst the suggestions
      if (d < worst->first) {
        worst->first = d;
        worst->second = e.first;
        worst = max_element(best.begin(), best.end());
      }
    }
  }

References bases, entries, and word_distance().

Referenced by suggestions().

check()

void casadi::Options::check

(

const Dict &

opts

)

const

Definition at line 240 of file options.cpp.

                                            {
    // Make sure all options exist and have the correct type
    for (auto&& op : opts) {
      const Options::Entry* entry = find(op.first);
 
      // Informative error message if option does not exist
      if (entry==nullptr) {
        std::stringstream ss;
        ss << "Unknown option: " << op.first << std::endl;
        ss << std::endl;
        ss << "Did you mean one of the following?" << std::endl;
        for (auto&& s : suggestions(op.first)) {
          print_one(s, ss);
        }
        ss << "Use print_options() to get a full list of options." << std::endl;
        casadi_error(ss.str());
      }
 
      // Check type
      casadi_assert(op.second.can_cast_to(entry->type),
                            "Illegal type for " + op.first + ": " +
                            op.second.get_description() +
                            " cannot be cast to " +
                            GenericType::get_type_description(entry->type) + ".");
 
    }
  }

References find(), casadi::GenericType::get_type_description(), print_one(), suggestions(), and casadi::Options::Entry::type.

Referenced by casadi::ProtoFunction::construct(), and casadi::ImporterInternal::construct().

disp()

void casadi::Options::disp

(

std::ostream &

stream

)

const

Definition at line 57 of file options.cpp.

                                             {
    // Print bases
    for (auto&& b : bases) {
      b->disp(stream);
    }
 
    // Print all entries
    for (auto&& e : entries) {
      e.second.disp(e.first, stream);
    }
  }

References bases, and entries.

Referenced by print_all().

find()

const Options::Entry * casadi::Options::find

(

const std::string &

name

)

const

Definition at line 32 of file options.cpp.

                                                               {
    // Check if in one of the bases
    for (auto&& b : bases) {
      const Options::Entry* entry = b->find(name);
      if (entry) return entry;
    }
 
    // Lookup in this class
    auto it = entries.find(name);
    if (it!=entries.end()) {
      return &it->second;
    } else {
      return nullptr;
    }
  }

References bases, and entries.

Referenced by check(), casadi::ProtoFunction::has_option(), info(), print_one(), and type().

has_dot()

bool casadi::Options::has_dot ( const Dict &  opts )

static

Definition at line 151 of file options.cpp.

                                        {
    for (auto&& op : opts) {
      if (op.first.find('.') != std::string::npos || op.first.find("__") != std::string::npos) {
        return true;
      }
      // Call recursively
      if (op.second.is_dict() && has_dot(op.second)) return true;
    }
    return false;
  }

Referenced by is_sane(), and sanitize().

has_null()

bool casadi::Options::has_null ( const Dict &  opts )

static

Definition at line 162 of file options.cpp.

                                         {
    for (auto&& op : opts) {
      if (op.second.is_null()) return true;
    }
    return false;
  }

Referenced by is_sane(), and sanitize().

info()

std::string casadi::Options::info

(

const std::string &

name

)

const

Definition at line 295 of file options.cpp.

                                                     {
    const Options::Entry* entry = find(name);
    casadi_assert(entry!=nullptr, "Option \"" + name + "\" does not exist");
    return entry->description;
  }

References casadi::Options::Entry::description, and find().

Referenced by casadi::conic_option_info(), casadi::nlpsol_option_info(), and casadi::rootfinder_option_info().

is_sane()

bool casadi::Options::is_sane ( const Dict &  opts )

static

Definition at line 169 of file options.cpp.

                                        {
    return !has_dot(opts) && !has_null(opts);
  }

References has_dot(), and has_null().

Referenced by casadi::ProtoFunction::construct(), and casadi::ImporterInternal::construct().

print_all()

void casadi::Options::print_all

(

std::ostream &

stream

)

const

Extra doc: https://github.com/casadi/casadi/wiki/L_xd

Definition at line 268 of file options.cpp.

                                                  {
    stream << "\"Option name\" [type] = value" << std::endl;
    disp(stream);
    stream << std::endl;
  }

References disp().

Referenced by casadi::ProtoFunction::print_options().

print_one()

void casadi::Options::print_one	(	const std::string &	name,
		std::ostream &	stream
	)		const

Extra doc: https://github.com/casadi/casadi/wiki/L_xe

Definition at line 274 of file options.cpp.

                                                                         {
    const Options::Entry* entry = find(name);
    if (entry!=nullptr) {
      entry->disp(name, stream);
    } else {
      stream << "  \"" << name << "\" does not exist.";
    }
  }

References casadi::Options::Entry::disp(), and find().

Referenced by check(), and casadi::ProtoFunction::print_option().

sanitize()

Dict casadi::Options::sanitize ( const Dict &  opts, bool  top_level = true  )

static

Definition at line 173 of file options.cpp.

                                                         {
    // Drop nulls
    if (top_level && has_null(opts)) {
      // Create a new dictionary without the null entries
      Dict ret;
      for (auto&& op : opts) {
        if (!op.second.is_null()) ret[op.first] = op.second;
      }
      return sanitize(ret, false);
    }
 
    //  Treat the case where any of the options have a dot (dictionary shorthand)
    if (has_dot(opts)) {
      // New options dictionary being constructed
      Dict ret;
 
      // Sub-dictionary and corresponding name being constructed
      Dict sopts;
      std::string sname;
 
      // Process options
      for (auto&& op : opts) {
        // Find the dot if any
        std::string::size_type dotpos = op.first.find('.'), dotpos_end;
        if (dotpos==std::string::npos) {
          dotpos = op.first.find("__");
          if (dotpos!=std::string::npos) dotpos_end = dotpos+2;
        } else {
          dotpos_end = dotpos+1;
        }
 
        // Flush last sub-dictionary
        if (!sname.empty() && (dotpos==std::string::npos
                               || op.first.compare(0, dotpos, sname)!=0)) {
          update_dict(ret, sname, sanitize(sopts, false), true);
 
          sname.clear();
          sopts.clear();
        }
 
        GenericType value = op.second;
        if (value.is_dict()) {
          value = sanitize(value, false);
        }
 
        // Add to dictionary
        if (dotpos != std::string::npos) {
          sname = op.first.substr(0, dotpos);
          std::string target_name = op.first.substr(dotpos_end);
          sopts[target_name] = value;
        } else {
          update_dict(ret, op.first, value, true);
        }
      }
 
      // Flush trailing sub-dictionary
      if (!sname.empty()) {
        update_dict(ret, sname, sanitize(sopts, false), true);
      }
 
      return ret;
    }
 
    // Nothing to do
    return opts;
  }

References has_dot(), has_null(), casadi::GenericType::is_dict(), and casadi::update_dict().

Referenced by casadi::IpoptInterface::codegen_body(), casadi::ProtoFunction::construct(), casadi::ImporterInternal::construct(), casadi::AlpaqaInterface::init(), and casadi::IpoptInterface::init_mem().

suggestions()

std::vector< std::string > casadi::Options::suggestions	(	const std::string &	word,
		casadi_int	amount = 5
	)		const

Extra doc: https://github.com/casadi/casadi/wiki/L_xb

Definition at line 105 of file options.cpp.

                                                                                          {
    // Best distances so far
    const double inf = std::numeric_limits<double>::infinity();
    std::vector<std::pair<double, std::string>> best(amount, {inf, ""});
 
    // Iterate over elements
    best_matches(word, best);
 
    // Sort the elements in ascending order
    stable_sort(best.begin(), best.end());
 
    // Collect the values that are non-infinite
    std::vector<std::string> ret;
    ret.reserve(amount);
    for (auto&& e : best) {
      if (e.first!=inf) {
        ret.push_back(e.second);
      }
    }
    return ret;
  }

References best_matches(), and casadi::inf.

Referenced by check().

type()

std::string casadi::Options::type

(

const std::string &

name

)

const

Definition at line 289 of file options.cpp.

                                                     {
    const Options::Entry* entry = find(name);
    casadi_assert(entry!=nullptr, "Option \"" + name + "\" does not exist");
    return GenericType::get_type_description(entry->type);
  }

References find(), casadi::GenericType::get_type_description(), and casadi::Options::Entry::type.

Referenced by casadi::conic_option_type(), casadi::nlpsol_option_type(), and casadi::rootfinder_option_type().

word_distance()

double casadi::Options::word_distance ( const std::string &  a, const std::string &  b  )

static

Extra doc: https://github.com/casadi/casadi/wiki/L_xa

Levenshtein edit distance

Definition at line 69 of file options.cpp.

                                                                      {
    if (a == b) return 0;
    casadi_int na = a.size();
    casadi_int nb = b.size();
    if (na == 0) return static_cast<double>(nb);
    if (nb == 0) return static_cast<double>(na);
 
    std::vector<casadi_int> v0(nb+1, 0);
    std::vector<casadi_int> v1(nb+1, 0);
 
    for (casadi_int i=0;i<nb+1;++i)
      v0[i] = i;
 
    char s;
    char t;
    std::locale loc;
    for (casadi_int i=0;i<na;i++) {
      v1[0] = i + 1;
      for (casadi_int j=0; j<nb; j++) {
        s = std::tolower(a[i], loc);
        t = std::tolower(b[j], loc);
        casadi_int cost = 0;
        if (s != t)
          cost = 1;
 
        v1[j+1] = std::min(std::min(v1[j] + 1, v0[j+1] + 1), v0[j] + cost);
      }
 
      for (casadi_int j=0; j<nb+1; j++)
        v0[j] = v1[j];
    }
 
    return static_cast<double>(v1[nb]);
  }

Referenced by best_matches().

Member Data Documentation

bases

std::vector<const Options*> casadi::Options::bases

Definition at line 43 of file options.hpp.

Referenced by best_matches(), disp(), and find().

entries

std::map<std::string, Entry> casadi::Options::entries

Definition at line 55 of file options.hpp.

Referenced by all(), best_matches(), disp(), and find().

---

The documentation for this struct was generated from the following files:

• options.hpp
• options.cpp