function_specification.c++

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 <math.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <libmodelxx/function_specification.h++>

#define FUNCTION_SPECIFICATION_GERROR_DOMAIN 38

namespace kdotp {
  namespace libmodelxx {
    namespace postprocessing {


      enum function_op function_get_op_for_builtin_function(const char* bf) {
        if(!g_ascii_strncasecmp("exp", bf, 3)) {
    return EXP;
  }else if(!g_ascii_strncasecmp("cos", bf, 3)) {
    return COS;
  }else if(!g_ascii_strncasecmp("sin", bf, 3)) {
    return SIN;
  }else if(!g_ascii_strncasecmp("tan", bf, 3)) {
    return TAN;
  }else if(!g_ascii_strncasecmp("acos", bf, 4)) {
    return ACOS;
  }else if(!g_ascii_strncasecmp("asin", bf, 4)) {
    return ASIN;
  }else if(!g_ascii_strncasecmp("atan", bf, 4)) {
    return ATAN;
  }else if(!g_ascii_strncasecmp("log", bf, 3)) {
    return LOG;
  }else if(!g_ascii_strncasecmp("abs", bf, 3)) {
    return ABS;
  }else if(!g_ascii_strncasecmp("sqrt", bf, 4)) {
    return SQRT;
  }else{
    return NOT;
  }
      }

      void function_print_tree(struct function_const *e, GString** s, int indentation) {
  g_string_append_printf(*s, "%s", "const(");
  for(int i=0; i<(e->t-1); i++) {
    g_string_append_printf(*s, "%g,", e->value[i]);
  }
  g_string_append_printf(*s, "%g)", e->value[e->t-1]);
      }

      void function_print_tree(struct function_symbol *e, GString** s, int indentation) {
  g_string_append_printf(*s, "SYMBOL(%s)", e->symbol);
      }

      void function_print_tree(struct function_exp *e, GString** s, int indentation) {
  g_string_append_printf(*s, "\n%05d", indentation);
  for(int i=0; i<indentation; i++) {
    g_string_append_printf(*s, "%s", "\t");
  }
  if(e == NULL) {
    g_string_append_printf(*s, "%s", "[*]");
    return;
  }
  const char* funcname = NULL;
  switch(e->op) {
  case CONST:
    return function_print_tree((struct function_const*)e, s, indentation);
  case SYMBOL:
    return function_print_tree((struct function_symbol*)e, s, indentation);
  case EXP:
    funcname=(funcname==NULL)?"exp":funcname;
  case LOG:
    funcname=(funcname==NULL)?"log":funcname;
  case COS:
    funcname=(funcname==NULL)?"cos":funcname;
  case SIN:
    funcname=(funcname==NULL)?"sin":funcname;
  case TAN:
    funcname=(funcname==NULL)?"tan":funcname;
  case ACOS:
    funcname=(funcname==NULL)?"acos":funcname;
  case ASIN:
    funcname=(funcname==NULL)?"asin":funcname;
  case ATAN:
    funcname=(funcname==NULL)?"atan":funcname;
  case ABS:
    funcname=(funcname==NULL)?"abs":funcname;
  case SQRT:
    funcname=(funcname==NULL)?"sqrt":funcname;
  case NEG:
    funcname=(funcname==NULL)?"NEG":funcname;
    /*The above have just one argument:
     *NOTE that funcname will just be assigned once, when we jump in.
     */
    g_string_append_printf(*s, "%s", funcname);
    /*recurse!*/
    function_print_tree(e->l, s, indentation+1);
    return function_print_tree(e->r, s, indentation+1);
  case PLUS:
    funcname=(funcname==NULL)?"PLUS":funcname;
  case MINUS:
    funcname=(funcname==NULL)?"MINUS":funcname;
  case MUL:
    funcname=(funcname==NULL)?"MUL":funcname;
  case DIV:
    funcname=(funcname==NULL)?"DIV":funcname;
  case DOT:
    funcname=(funcname==NULL)?"DOT":funcname;
  case CROSS:
    funcname=(funcname==NULL)?"CROSS":funcname;
    g_string_append_printf(*s, "%s", funcname);
    /*recurse!*/
    function_print_tree(e->l, s, indentation+1);
    return function_print_tree(e->r, s, indentation+1);
  default:
    g_string_append_printf(*s, "[UNKNOWN OPERATION (%d)]", e->op);
    function_print_tree(e->l, s, indentation+1);
    return function_print_tree(e->r, s, indentation+1);
  }
  g_string_append_printf(*s, "%s", "[hit end of routine (coding error)]");
      }

      GError* evaluate_function(double* value, const struct function_exp *f, GHashTable* global_symbols, GHashTable* local_symbols) {
  GError *err=NULL;
  GError *e=NULL;
  struct symbol_table_entry *ste;
  enum function_datatype lt=INVALID, rt=INVALID;
  double *l=NULL;
  double *r=NULL;
  /*Don't evaluate l & r if we're not actually a function_exp!!*/
  //fprintf(stderr, "carteisan_evaulate_function: op=%d", f->op);
  if((!((f->op == SYMBOL) ||(f->op == CONST))) && (f->l != NULL)) {
    lt = get_function_datatype(f->l, global_symbols, local_symbols);
    l = new double[lt];
    //fprintf(stderr, "\trecursing left\n");
    e = evaluate_function(l, f->l, global_symbols, local_symbols);
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: binary operator %d got error on left-hand side: ", f->op);
      delete[] l;
      return err;
    }
  } else {
    lt = INVALID;
    l = NULL;
  }
  /*Don't evaluate l & r if we're not actually a function_exp!!*/
  if((!((f->op == SYMBOL) ||(f->op == CONST))) && (f->r != NULL)) {
    rt = get_function_datatype(f->r, global_symbols, local_symbols);
    r = new double[rt];
    //fprintf(stderr, "\trecursing right\n");
    e = evaluate_function(r, f->r, global_symbols, local_symbols);
    if(e != NULL) {
      g_propagate_prefixed_error(&err, e, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: binary operator %d got error on right-hand side: ", f->op);
      if(l != NULL) delete[] l;
      delete[] r;
      return err;
    }
  } else {
    rt = INVALID;
    r = NULL;
  }
  /*
  fprintf(stderr, "carteisan_evaulate_function: lt=%d rt=%d op=%d", lt, rt, f->op);
  if(l != NULL) {
    fprintf(stderr, " l[0]=%g", l[0]);
  }else{
    fprintf(stderr, " l[0]=NULL");
  }
  if(r != NULL) {
    fprintf(stderr, " r[0]=%g", r[0]);
  }else{
    fprintf(stderr, " r[0]=NULL");
  }
  fprintf(stderr, "\n");
  */
  switch(f->op) {
  case PLUS:
  case MINUS:
  case MUL:
  case DIV:
    /**MUL and DIV can take scalar*vec*/
    if(!(
         ((f->op == MUL)&&((rt == 1) || (lt == 1)))
         ||((f->op == DIV)&&(rt==1))
         || (rt == lt)
         )) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary operation, left and right dimensions are not the same or a scalar * vec or vec */ scalar! (op=%d; l=%d, r=%d)", f->op, lt, rt);
    }
    if((rt < SCALAR) || (lt < SCALAR)) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 101, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary operation %d, arguments are invalid!", f->op);
    }
    /*Since we're iterating over rt, we need to iterate properly if
     *rt is 1 but lt isn't.
     */
    if((f->op == MUL) && (lt > rt)) {
      for(int i=0; i<lt; i++) {
        value[i] = l[i] * r[0];
        //fprintf(stderr, "rt*1: %g = %g*%g\n", value[i], l[i], r[i]);
      }
    }else if((f->op == DIV) && (lt > rt)) {
      for(int i=0; i<lt; i++) {
      value[i] = l[i] / r[0];
      //fprintf(stderr, "rt1/: %g = %g/%g\n", value[i], l[i], r[i]);
      }
    }else{
    for(int i=0; i<rt; i++) {
      switch(f->op) {
      case PLUS:
        value[i] = l[i] + r[i];
        //fprintf(stderr, "%g = %g+%g\n", value[i], l[i], r[i]);
        break;
      case MINUS:
        value[i] = l[i] - r[i];
        //fprintf(stderr, "%g = %g-%g\n", value[i], l[i], r[i]);
        break;
      case MUL:
        if(lt == 1) {
    value[i] = l[0] * r[i];
    //fprintf(stderr, "lt1*: %g = %g*%g\n", value[i], l[0], r[i]);
        }else{
    value[i] = l[i] * r[i];
    //fprintf(stderr, "*: %g = %g*%g\n", value[i], l[i], r[i]);
        }
        break;
      case DIV:
    value[i] = l[i] / r[i];
    //fprintf(stderr, "/: %g = %g/%g\n", value[i], l[i], r[i]);
        break;
      default:
        return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 107, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary operation %d, unhandled op-specific handling!", f->op);
      }
    }
    }
    break;
  case CONST:
    if(((struct function_const*)f)->value == NULL) {
      value[0] = 0;
      break;
    }
    if(((struct function_const*)f)->t == 0) {
      value[0] = ((struct function_const*)f)->value[0];
      break;
    }
    else for(int i=0; i<((struct function_const*)f)->t; i++) value[i] = ((struct function_const*)f)->value[i];
    //fprintf(stderr, "const: value[0]=%g\n", value[0]);
    break;
  case COS:
  case SIN:
  case TAN:
  case LOG:
  case EXP:
  case ACOS:
  case ASIN:
  case ATAN:
  case ABS:
  case SQRT:
    if(rt != 1) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 102, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with builtin function %d, argument dimension %d is not 1!", f->op, rt);
    }
    switch(f->op) {
    case COS:
      value[0] = cos(r[0]);
      //fprintf(stderr, "%g=cos(%g)\n", value[0], r[0]);
      break;
    case SIN:
      value[0] = sin(r[0]);
      //fprintf(stderr, "%g=sin(%g)\n", value[0], r[0]);
      break;
    case TAN:
      value[0] = tan(r[0]);
      //fprintf(stderr, "%g=tan(%g)\n", value[0], r[0]);
      break;
    case LOG:
      value[0] = log(r[0]);
      //fprintf(stderr, "%g=log(%g)\n", value[0], r[0]);
      break;
    case EXP:
      value[0] = ::exp(r[0]);
      //fprintf(stderr, "%g=exp(%g)\n", value[0], r[0]);
      break;
    case ACOS:
      value[0] = acos(r[0]);
      //fprintf(stderr, "%g=acos(%g)\n", value[0], r[0]);
      break;
    case ASIN:
      value[0] = asin(r[0]);
      //fprintf(stderr, "%g=asin(%g)\n", value[0], r[0]);
      break;
    case ATAN:
      value[0] = atan(r[0]);
      //fprintf(stderr, "%g=atan(%g)\n", value[0], r[0]);
      break;
    case ABS:
      value[0] = fabs(r[0]);
      //fprintf(stderr, "%g=abs(%g)\n", value[0], r[0]);
      break;
    case SQRT:
      value[0] = sqrt(r[0]);
      //fprintf(stderr, "%g=sqrt(%g)\n", value[0], r[0]);
      break;
    default:
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 107, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with builting function %d, unhandled op-specific handling!", f->op);
    }
    break;
  case DOT:
  case CROSS:
    /**MUL and DIV can take scalar*vec*/
    if(rt == lt) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary vector operation, left and right dimensions are not the same or a scalar * vec or vec */ scalar! (op=%d; l=%d, r=%d)", f->op, lt, rt);
    }
    if(rt < SCALAR) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 101, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary vector operation %d, arguments are invalid!", rt);
    }
    value[0] = 0;
    switch(f->op) {
    case DOT:
      for(int i=0; i<lt; i++) value[0] += l[i]*r[i];
      break;
    case CROSS:
      /*THIS NEEDS A CLEVER ALGO*/
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 101, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary vector operation %d, cross product is not yet implemented!", rt);
      break;
    default:
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 107, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary vector operation %d, unhandled op-specific handling!", f->op);
    }
    break;
  case postprocessing::OR:
  case postprocessing::AND:
  case postprocessing::XOR:
    if(rt == lt) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary binary operation, left and right dimensions are not the same scalar! (op=%d; l=%d, r=%d)", f->op, lt, rt);
    }
    if(rt != BINARY) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 101, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary binary operation %d, arguments are invalid!", rt);
    }
    switch(f->op) {
    case OR:
      value[0] = (l[0] || r[0]);
      break;
    case AND:
      value[0] = (l[0] && r[0]);
      break;
    case XOR:
      value[0] = ((l[0] || r[0]) && (!(l[0] && r[0])));
      break;
    default:
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 107, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with boolean binary operation %d, unhandled op-specific handling!", f->op);
    }
    break;
  case postprocessing::NOT:
    if(rt != BINARY) {
      if(l == NULL) delete[] l;
      if(r == NULL) delete[] r;
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 101, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with binary binary operation %d, arguments are invalid!", rt);
    }
    value[0] = !r[0];
    break;
  case SYMBOL:
    ste = get_symbol_table_entry(((struct function_symbol*)f)->symbol, global_symbols, local_symbols, &e);
    if((e != NULL) || (ste == NULL)) {
      if(e == NULL) {
        e = g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::evaluate_symbol: (%s) Unknown error looking up symbol in symbol tables.", (((struct function_symbol*)f)->symbol));
      }
      g_propagate_prefixed_error(&err, e, "::kdotp::libmodelxx::function_specification.c++::evaluate_symbol: (%s) Error looking up symbol in symbol tables.", (((struct function_symbol*)f)->symbol));
      return err;
    }
    switch(ste->st) {
    case CONSTANT_SYMBOL:
      for(int i=0; i<ste->dt; i++) {
        value[i]=((struct symbol_table_entry_const*)ste)->value[i];
      }
      break;
    default:
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::evaluate_symbol: (%s) Symbol is of unknown symbol type (%d).", (((struct function_symbol*)f)->symbol), ste->st);
    }
    //fprintf(stderr, "symbol %s: value[0]=%g\n", ((struct function_symbol*)f)->symbol, value[0]);
    break;
  case NEG:
    /*We can also negate a vector*/
    if(rt < 1) {
      return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 104, "::kdotp::libmodelxx::function_specification.c++::evaluate_function: with symbol (op NEG (%d)): right-hand side is not a valid number (scalar or higher-dimension)!", f->op);
    }
    for(int i=0; i<rt; i++) {
      value[i] = -r[i];
    }
    break;
  default:
    //fprintf(stderr, "Unknown op: %d\n", f->op);
    return g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 104, "WARNING: expression operator %d not implemented!", f->op);
  }
  //fprintf(stderr, "exiting op(%d)\n", f->op);
  return NULL;
      }

      enum function_datatype get_function_datatype(struct function_exp* f, GHashTable* global_symbols, GHashTable* local_symbols) {
  struct symbol_table_entry* ste;
  GError *e = NULL;
  enum function_datatype lt=INVALID, rt=INVALID;
  if(!((f->op == SYMBOL) || (f->op == CONST))) {
    if(f->l != NULL) lt = get_function_datatype(f->l, global_symbols, local_symbols);
    else lt = INVALID;
    if(f->r != NULL) rt = get_function_datatype(f->r, global_symbols, local_symbols);
    else lt = INVALID;
  }
  switch(f->op) {
  case PLUS:
  case MINUS:
    if(lt != rt) {
      //fprintf(stderr, "+-: lt!=rt: INVALID\n");
      return INVALID;
    }
    if(rt < 1) {
      //fprintf(stderr, "+-: rt<1: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "+-: default (=rt=%d)\n", rt);
    return rt;
  case MUL:
    if((lt < 1) || (rt < 1)) {
      //fprintf(stderr, "*: lt||rt<1: INVALID\n");
      return INVALID;
    }
    if(lt == 1) {
      //fprintf(stderr, "*: lt==1: =rt=%d\n", rt);
      return rt;
    }
    if(rt == 1) {
      //fprintf(stderr, "*: rt==1: =lt=\n");
      return lt;
    }
    if(lt != rt) {
      //fprintf(stderr, "*: lt!=rt: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "*: default (=rt=%d)\n", rt);
    return rt;
  case DIV:
    if((lt < 1) || (rt < 1)) {
      //fprintf(stderr, "/: lt||rt<1: INVALID\n");
      return INVALID;
    }
    if(rt == 1) {
      //fprintf(stderr, "/: rt==1: =lt=%d)\n", lt);
      return lt;
    }
    if(lt != rt) {
      //fprintf(stderr, "/: lt!=rt: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "/: default (=rt=%d)\n", rt);
    return rt;
  case CONST:
    //fprintf(stderr, "CONST: exp has type %d\n", ((struct function_const*)f)->t);
    return ((struct function_const*)f)->t;
  case COS:
  case SIN:
  case TAN:
  case LOG:
  case EXP:
  case ACOS:
  case ASIN:
  case ATAN:
  case ABS:
  case SQRT:
    if(lt != INVALID) {
      //fprintf(stderr, "builtin_scalar_func: lt(=%d)!=INVALID: INVALID\n", lt);
      return INVALID;
    }
    if(rt != 1) {
      //fprintf(stderr, "builtin_scalar_func: rt(=%d)!=SCALAR: INVALID\n", rt);
      return INVALID;
    }
    //fprintf(stderr, "builtin_scalar_func: SCALAR\n");
    return SCALAR;
  case DOT:
    if((lt < 1) || (rt < 1)) {
      //fprintf(stderr, "DOT: lt||rt<1: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "DOT: SCALAR");
    return SCALAR;
  case CROSS:
    if((lt < 1) || (rt < 1)) {
      //fprintf(stderr, "CROSS: lt||rt<1: INVALID\n");
      return INVALID;
    }
    if(lt != rt) {
      //fprintf(stderr, "CROSS: lt!=rt: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "CROSS: default(=rt)\n");
    return rt;
  case postprocessing::OR:
  case postprocessing::AND:
  case postprocessing::XOR:
    if((lt != 0) || (rt != 0)) {
      //fprintf(stderr, "|&XOR: lt||rt!=0: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "|&XOR: BINARY\n");
    return BINARY;
  case postprocessing::NOT:
    if(lt != INVALID) {
      //fprintf(stderr, "!: lt!=INVALID\n");
      return INVALID;
    }
    if(rt != 0) {
      //fprintf(stderr, "!: rt!=BINARY\n");
      return INVALID;
    }
    //fprintf(stderr, "!: BINARY\n");
    return BINARY;
  case SYMBOL:
    ste = get_symbol_table_entry(((struct function_symbol*)f)->symbol, global_symbols, local_symbols, &e);
    if((e != NULL) || (ste == NULL)) {
      return INVALID;
    }
    return ste->dt;
  case NEG:
    if(rt < 1) {
      //fprintf(stderr, "NEG: rt<1: INVALID\n");
      return INVALID;
    }
    //fprintf(stderr, "NEG: default (=rt=%d)\n", rt);
    return rt;
  default:
    fprintf(stderr, "UNRECOGNIZED OP(%d): INVALID\n", f->op);
    return INVALID;
  }
      }

      struct symbol_table_entry* get_symbol_table_entry(const char* symbol, GHashTable *global_symbols, GHashTable* local_symbols, GError **e) {
  struct symbol_table_entry *ste_global = NULL;
  if(global_symbols != NULL) ste_global = (struct symbol_table_entry *)g_hash_table_lookup(global_symbols, symbol);
  struct symbol_table_entry *ste_local = NULL;
  if(local_symbols != NULL) ste_local = (struct symbol_table_entry *)g_hash_table_lookup(local_symbols, symbol);
  if((ste_global != NULL) && (ste_local != NULL)) {
    *e = g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::get_symbol_table_entry: symbol (%s) defined both locally and globally!", symbol);
    return NULL;
  }
  if((ste_global == NULL) && (ste_local == NULL)) {
    *e = g_error_new(FUNCTION_SPECIFICATION_GERROR_DOMAIN, 100, "::kdotp::libmodelxx::function_specification.c++::get_symbol_table_entry: symbol (%s) not defined.", symbol);
    return NULL;
  }
  if(ste_global != NULL) return ste_global;
  return ste_local;
      }

      void add_symbol_table_entry(GHashTable *st, const char* symbol, struct symbol_table_entry* entry) {
  /*Copy the string*/
  GString* sb = g_string_new(symbol);
  g_hash_table_insert(st, sb->str, entry);
  g_string_free(sb, FALSE);
      }

      /*This frees a symbol table entry, e.g. when overwriting an entry.*/
      static void destroy_symbol_table_entry(void *ste_) {
  struct symbol_table_entry *ste = (struct symbol_table_entry *)ste_;
  switch(ste->st) {
  case CONSTANT_SYMBOL:
    free(((struct symbol_table_entry_const*)ste)->value);
    break;
  default:
    /*we can't communicate an error, so do no further processing*/
    ;
  }
  /*Finally, free the structure itself*/
  free((struct symbol_table_entry_const*)ste);
      }

      static void destroy_symbol_table_symbol(void *symbol) {
  free(symbol);
      }

      GHashTable* new_symbol_table() {
  return (GHashTable*)g_hash_table_new_full(g_str_hash, g_str_equal, destroy_symbol_table_symbol, destroy_symbol_table_entry);
      }

      void parameter_list_init(GList* parameters) {
  /*Initialize the loop over the template parameters*/
  for(GList* ll = parameters; ll!=NULL; ll=ll->next) ((struct template_parameter_range*)ll->data)->current_value = ((struct template_parameter_range*)ll->data)->from;
      }

      bool update_parameters_plus_check_if_done(GList* parameters) {
  for(GList* ll=parameters; ll!=NULL; ll=ll->next) {
    ((struct template_parameter_range*)ll->data)->current_value += ((struct template_parameter_range*)ll->data)->stepsize;
    if(((struct template_parameter_range*)ll->data)->current_value <= ((struct template_parameter_range*)ll->data)->to) return false;
    /*If we reach this point, the current value is greater than the stop value.  We need to reset this
     *  value and then loop around to the next value to increment.*/
    ((struct template_parameter_range*)ll->data)->current_value = ((struct template_parameter_range*)ll->data)->from;
  }
  return true;
      }

      GFile*  get_gfile_directory_for_template_state(const char* prefix, GList* parameters) {
  GString *s;
  if(prefix == NULL) {
    s = g_string_new("./");
  }else{
    s = g_string_new(prefix);
  }
  if(parameters != NULL) {
    s = g_string_append(s, ((struct template_parameter_range*)parameters->data)->symbol);
    g_string_append_printf(s, "=%g", ((struct template_parameter_range*)parameters->data)->current_value);
    /*We started with the first so that we can prefix the string with an underscore.*/
    if(parameters->next!=NULL) {
      for(GList* ll = parameters->next; ll!=NULL; ll=ll->next) {
        g_string_append_printf(s, "_%s=%g", ((struct template_parameter_range*)ll->data)->symbol, ((struct template_parameter_range*)ll->data)->current_value);
      }
    }
  }
  GFile *f = g_file_new_for_commandline_arg(s->str);
  g_string_free(s, TRUE);
  return f;
      }

      void add_template_parameters_to_symbol_table(GHashTable *st, GList* parms) {
  struct symbol_table_entry *ste;
  struct symbol_table_entry_const *stec=NULL;
  struct template_parameter_range *tpm;
  for(GList* ll=parms; ll!=NULL; ll=ll->next) {
    tpm = (struct template_parameter_range *)ll->data;
    ste = (struct symbol_table_entry*)g_hash_table_lookup(st, tpm->symbol);
    if(ste == NULL) {
      stec = (struct symbol_table_entry_const*)malloc(sizeof(struct symbol_table_entry_const));
      if(stec == NULL) {
        fprintf(stderr, "ERROR: unable to allocate new symbol table entry for symbol (%s)\n", tpm->symbol);
        continue;
      }
      stec->st = CONSTANT_SYMBOL;
      stec->dt = SCALAR;
      stec->value = (double*)malloc(sizeof(double));
      if(stec->value == NULL) {
        fprintf(stderr, "ERROR: unable to allocate new symbol table entry value storage for symbol (%s)\n", tpm->symbol);
        continue;
      }
      g_hash_table_insert(st, tpm->symbol, (struct symbol_table_entry*)stec);
    }else{
      if(ste->st != CONSTANT_SYMBOL) {
        fprintf(stderr, "ERROR:  symbol table entry for symbol (%s) is not a constant symbol (is %d)\n", tpm->symbol, stec->st);
        continue;
      }
      if(ste->dt != SCALAR) {
        fprintf(stderr, "ERROR:  symbol table entry for symbol (%s) is not a scalar type (is %d)\n", tpm->symbol, stec->dt);
        continue;
      }
      stec = (struct symbol_table_entry_const*)ste;
    }
    *(stec->value)=tpm->current_value;
  }
      }

      char* get_string_for_template_state(GList* parameters) {
  GString *s = g_string_new("");
  if(parameters == NULL) {
    char *str = s->str;
    g_string_free(s, FALSE);
    return str;
  }
  g_string_append_printf(s, "%g", ((struct template_parameter_range*)parameters->data)->current_value);
  /*We started with the first so that we can prefix the string with an underscore.*/
  if(parameters->next!=NULL) {
    for(GList* ll = parameters->next; ll!=NULL; ll=ll->next) {
      g_string_append_printf(s, "\t%g", ((struct template_parameter_range*)ll->data)->current_value);
    }
  }
  char *str = s->str;
  g_string_free(s, FALSE);
  return str;
      }

      char* get_header_for_template_state(GList* parameters) {
  GString *s = g_string_new("");
  if(parameters == NULL) {
    char *str = s->str;
    g_string_free(s, FALSE);
    return str;
  }
  s = g_string_append(s, ((struct template_parameter_range*)parameters->data)->symbol);
  /*We started with the first so that we can prefix the string with an underscore.*/
  if(parameters->next!=NULL) {
    for(GList* ll = parameters->next; ll!=NULL; ll=ll->next) {
      g_string_append_printf(s, "\t%s", ((struct template_parameter_range*)ll->data)->symbol);
    }
  }
  char *str = s->str;
  g_string_free(s, FALSE);
  return str;
      }

      void free_function(struct function_const* e) {
  free(e->value);
  free(e);
      }

      void free_function(struct function_symbol* e) {
  free(e->symbol);
  free(e);
      }

      void free_function(struct function_exp *e) {
  switch(e->op) {
  case CONST:
    free_function((struct function_const*)e);
    break;
  case SYMBOL:
    free_function((struct function_symbol*)e);
    break;
  default:
    if(e->l != NULL) free_function(e->l);
    if(e->r != NULL) free_function(e->r);
    free(e);
  }
      }

    }
  }
}