math.h

Go to the documentation of this file.

//
// Copyright (c) 2015 by François Mauger <mauger@lpccaen.in2p3.fr>
//
// This file is part of Bayeux.
//
// Bayeux is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Bayeux is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Bayeux. If not, see <http://www.gnu.org/licenses/>.

#ifndef MYGSL_MATH_H
#define MYGSL_MATH_H

// Standard library:
#include <string>
#include <map>
#include <iostream>

namespace mygsl {

  typedef double (*plain_function_type)(double);

  typedef double (*plain_function_with_parameters_type)(double, void*);

  enum plain_function_flag {
    PLAIN_FUNCTION_INVALID = 0,     
    PLAIN_FUNCTION_SIMPLE = 1,      
    PLAIN_FUNCTION_WITH_PARAMS = 2  
  };

  struct plain_function_entry {
    plain_function_entry();
    void reset();
    std::string         name; //< Registration name of the plain function
    plain_function_flag type; 
    plain_function_type func_simple; 
    plain_function_with_parameters_type func_with_params; 
  };

  typedef std::map<std::string, plain_function_entry> plain_function_dict_type;

  void basic_plain_function_registration(plain_function_dict_type & dict_);

  void register_plain_function_simple(plain_function_dict_type & dict_,
                                      const std::string & name_,
                                      const plain_function_type & func_);

  void register_plain_function_with_params(plain_function_dict_type & dict_,
                                           const std::string & name_,
                                           const plain_function_with_parameters_type & func_with_params_);

  void tree_dump(const plain_function_dict_type & dict_,
                 std::ostream & out_ = std::clog,
                 const std::string & title_ = "",
                 const std::string & indent_ = "");

  plain_function_dict_type & grab_plain_function_dict();

  const plain_function_dict_type & get_plain_function_dict();

  bool plain_function_is_known(const std::string & name_);

  bool is_plain_function_simple(const std::string & name_);

  bool is_plain_function_with_params(const std::string & name_);

  plain_function_type get_simple_function(const std::string & name_);

} // end of namespace mygsl

#define MYGSL_MATH_REGISTER_FUNCTION(FunctionName, FunctionAddress, FunctionType) \
  {                                                                     \
    if (FunctionType == mygsl::PLAIN_FUNCTION_SIMPLE) {                 \
      register_plain_function_simple(mygsl::grab_plain_function_dict(), FunctionName, FunctionAddress); \
    } else if (FunctionType == mygsl::PLAIN_FUNCTION_WITH_PARAMS) {     \
      register_plain_function_with_params(mygsl::grab_plain_function_dict(), FunctionName, FunctionAddress); \
    }                                                                   \
  }                                                                     \
  

#endif // MYGSL_MATH_H

/* Local Variables: */
/* mode: c++        */
/* coding: utf-8    */
/* End:             */