function_specification.h++

Go to the documentation of this file.

/*


    Copyright (C) 2009 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program 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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <glib.h>
#include <gio/gio.h>

#ifndef FUNCTION_SPECIFICTION_HXX__
#define FUNCTION_SPECIFICTION_HXX__

#define DOMAIN_FUNCTION_SPECIFICATION 56932

namespace kdotp {
  namespace libmodelxx {
    namespace postprocessing {


      enum function_op {
  PLUS,
  MINUS,
  MUL,
  DIV,
  EXP,
  CONST,
  COS,
  SIN,
  TAN,
  LOG,
  ACOS,
  ASIN,
  ATAN,
  ABS,
  SQRT,
  DOT,
  CROSS,
  NEG,
  OR,
  AND,
  XOR,
  NOT,
  SYMBOL
      };

      /**Note that the data types correspond to 1-(the number of dimensions).  This is a feature (take advantage of int conversion)*/
      enum function_datatype {
  INVALID=-1,
  BINARY,
  SCALAR,
  VECTOR2,
  VECTOR3
      };

      struct function_exp {
  enum function_op op;
  struct function_exp *l;
  struct function_exp *r;
      };

      struct function_const {
  /*op should always be set to CONST*/
  enum function_op op;
  enum function_datatype t;
  double* value;
      };

      struct function_symbol {
  /*op should always be set to SYMBOL*/
  enum function_op op;
  char* symbol;
      };

      enum symbol_type {
  CONSTANT_SYMBOL
  //USER_FUNCTION
      };

      /**describes the symbol being referenced*/
      struct symbol_table_entry {
  enum symbol_type st;
  enum function_datatype dt;
      };
      struct symbol_table_entry_const {
  enum symbol_type st;
  enum function_datatype dt;
  double* value;
      };

      struct template_parameter_range {
  char* symbol;
  double from;
  double to;
  double stepsize;
  /*for use when iterating through*/
  double current_value;
      };


      /**get a function
       *\param c the builtin function to look up
       *\return op corresponding to the function, or NOT if couldn't determine one
       */
      enum function_op function_get_op_for_builtin_function(const char* c);

      /**Evaluates a function using a set of symbol tables
       *\param values array to store the results in
       *\param f the function to be evaluated
       *\param global_symbols the global symbol table (e.g. constants, built-in template parameters), user-defined template parameters
       *\param local_symbols the local symbol table (e.g. x, X)
       */
      GError* evaluate_function(double* values, const struct function_exp *f, GHashTable* global_symbols, GHashTable* local_symbols);
      /**This gets the data type for the function
       *\param global_symbols the global symbol table (e.g. constants, built-in template parameters), user-defined template parameters
       *\param local_symbols the local symbol table (e.g. x, X)
       *\param exp function
       */
      enum function_datatype get_function_datatype(struct function_exp *exp, GHashTable* global_symbols, GHashTable* local_symbols);

      /**Pretty prints a function tree to a sring you can print out.
       *e the expression to print
       *s a GString to which the output will be appended
       */
      void function_print_tree(struct function_exp *e, GString **s, int indentation);

      enum function_datatype get_function_datatype(struct function_exp* exp, GHashTable* global_symbols, GHashTable* local_symbols);

      struct symbol_table_entry* get_symbol_table_entry(const char* symbol, GHashTable *global_symbols, GHashTable* local_symbols, GError **e);

      GHashTable* new_symbol_table();

      void add_symbol_table_entry(GHashTable *st, const char* symbol, struct symbol_table_entry* entry);

      void parameter_list_init(GList* parameters);

      bool update_parameters_plus_check_if_done(GList* parameters);

      GFile* get_gfile_directory_for_template_state(const char* prefix, GList* parameters);

      char* get_string_for_template_state(GList* parameters);

      char* get_header_for_template_state(GList* parameters);

      void add_template_parameters_to_symbol_table(GHashTable *st, GList* parms);

      void free_function(struct function_exp *e);

    }
  }
}
#endif