yanera_postfix.c

Go to the documentation of this file.

/*==============================================================================
Copyright 2006 Thad Harroun, Kevin Yager

This file is part of "yanera 2.0".

"yanera 2.0" 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.

"yanera 2.0" 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 "yanera 2.0"; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA 
==============================================================================*/ 
/*============================================================================*/
#define _CRT_SECURE_NO_DEPRECATE

#include "yanera.h"
#include "yanera_postfix.h"
/*==========================================================================*/
short parmindex(char c, char *parm_name)
{
  unsigned int i;
  for (i=0; i<strlen(parm_name); i++)
  {
    if (parm_name[i] == c) break;
  }
  return i;
}
/*==========================================================================*/
void parse_expression(yanera_postfix *pq, \
                      char *expression, char *parm_name, short *parm)
{
  unsigned int                    i;
  short                           idx;
  short                           precedence;
  short                           precedence_level;
  struct operator_stack_element  *ose;
  enum operator_type              last;
  
  initizlize_operator_stack();

  number_string    = NULL;
  precedence_level = 0;
  last             = NONE;
  
  for (i=0; i<strlen(expression); i++)
  {
    switch(expression[i]) {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
      case '.':
        /*
        ** A number should not be preceded by:
        */
        if ((last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
           yanera_error("Invalid number in infix.", __FILE__, __LINE__, NULL);
        }
        /*
        ** If the character is a digit or decimal point,
        ** build the number_string for conversion to double later.
        */
        append_number_string(expression[i]);
        last = NUMBER;
        break;
      case '(':
        /*
        ** Open parentheis should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == PARENTHESIS_CLOSE))
        {
           yanera_error("Invalid ( in infix.", __FILE__, __LINE__, NULL);
        }
        precedence_level += 5;
        last = PARENTHESIS_OPEN;
        break;
      case ')':
        /*
        ** Close parentheis should not be preceded by:
        */
        if ((last == OPERATOR_MULTADD) || \
            (last == OPERATOR_UNARY) || \
            (last == OPERATOR_POWER) || \
            (last == OPERATOR_FUNCTION))
        {
          yanera_error("Invalid ) in infix.", __FILE__, __LINE__, NULL);
        }
        /*
        ** For close parentheis, and if preceded by a number, 
        ** make sure the number gets on postfix_queue.
        */
        if (last == NUMBER) stop_number_string(pq);
        precedence_level -= 5;
        last = PARENTHESIS_CLOSE;
        if (precedence_level < 0)
        {
          yanera_error("Invalid ) in infix.", __FILE__, __LINE__, NULL);
        }
        break;
      case '+':
        /*
        ** + should not be preceded by:
        */
        if ((last == OPERATOR_MULTADD) || \
            (last == OPERATOR_UNARY) || \
            (last == OPERATOR_POWER) || \
            (last == OPERATOR_FUNCTION))
        {
          yanera_error("Invalid operator + or - in infix.", \
                       __FILE__, __LINE__, NULL);
        }
        /* 
        ** If the previous character is a number...
        */
        if (last == NUMBER) stop_number_string(pq);
        /*
        ** ...or a close parantheis, an ordinate, or parameter, then this 
        **  operator is simple addition/subtration class (precedence 1).
        */
        if ((last == NUMBER) ||    \
            (last == ORDINATE) ||  \
            (last == PARAMETER) || \
            (last == PARENTHESIS_CLOSE))
        {
          precedence = precedence_level + 1;
          operator_decision(pq, "+  ", precedence, OPERATOR_MULTADD);
          last = OPERATOR_MULTADD;
        }
        /*
        ** Otherwise, its a unary/postive operator (precedence 4).
        ** Apend +1 to postfix_queue and * to operator stack.
        */
        else
        {
          append_number_string('+');
          append_number_string('1');
          stop_number_string(pq);
          precedence = precedence_level + 4;
          operator_decision(pq, "*  ", precedence, OPERATOR_MULTADD);
          last = OPERATOR_UNARY;
        }
        break;
      case '-':
        /*
        ** - should not be preceded by:
        */
        if ((last == OPERATOR_MULTADD) || \
            (last == OPERATOR_UNARY) || \
            (last == OPERATOR_POWER) || \
            (last == OPERATOR_FUNCTION))
        {
          yanera_error("Invalid operator + or - in infix.", \
                       __FILE__, __LINE__, NULL);
        }
        /* 
        ** If the previous character is a number...
        */
        if (last == NUMBER) stop_number_string(pq);
        /*
        ** ...or a close parantheis, an ordinate, or parameter, then this 
        **  operator is simple addition/subtration class (precedence 1).
        */
        if ((last == NUMBER) ||\
            (last == ORDINATE) ||\
            (last == PARAMETER) ||\
            (last == PARENTHESIS_CLOSE))
        {
          precedence = precedence_level + 1;
          operator_decision(pq, "-  ", precedence, OPERATOR_MULTADD);
          last = OPERATOR_MULTADD;
        }
        /*
        ** Otherwise, its a unary/negation operator (precedence 4).
        ** Apend -1 to postfix_queue and * to operator stack.
        */
        else
        {
          append_number_string('-');
          append_number_string('1');
          stop_number_string(pq);
          precedence = precedence_level + 4;
          operator_decision(pq, "*  ", precedence, OPERATOR_MULTADD);
          last = OPERATOR_UNARY;
        }
        break;
      case '*':
        /*
        ** / should not be preceded by :
        */
        if ((last == OPERATOR_MULTADD) || \
            (last == OPERATOR_UNARY) || \
            (last == OPERATOR_POWER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_OPEN))
        {
          yanera_error("Invalid operator * in infix.", \
                       __FILE__, __LINE__, NULL);
        }
        /*
        **  If the previous character is a number, then this 
        **  operator is simple multiply/divide class (precedence 2).
        */
        if (last == NUMBER) stop_number_string(pq);
        precedence = precedence_level + 2;
        operator_decision(pq, "*  ", precedence, OPERATOR_MULTADD);
        last = OPERATOR_MULTADD;
        break;
      case '/':
        /*
        ** / should not be preceded by :
        */
        if ((last == OPERATOR_MULTADD) || \
            (last == OPERATOR_UNARY) || \
            (last == OPERATOR_POWER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_OPEN))
        {
          yanera_error("Invalid operator / in infix.", \
                       __FILE__, __LINE__, NULL);
        }
        /*
        **  If the previous character is a number, then this 
        **  operator is simple multiply/divide class (precedence 2).
        */
        if (last == NUMBER) stop_number_string(pq);
        precedence = precedence_level + 2;
        operator_decision(pq, "/  ", precedence, OPERATOR_MULTADD);
        last = OPERATOR_MULTADD;
        break;
      case '^':
        /*
        ** ^ should not be preceded by:
        */
        if ((last == OPERATOR_MULTADD) || \
            (last == OPERATOR_UNARY) || \
            (last == OPERATOR_POWER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_OPEN))
        {
          yanera_error("Invalid operator ^ in infix.", \
                       __FILE__, __LINE__, NULL);
        }
        /*
        **  If the previous character is a number, add to postfix
        */
        if (last == NUMBER) stop_number_string(pq);
        precedence = precedence_level + 3;
        operator_decision(pq, "^  ", precedence, OPERATOR_POWER);
        last = OPERATOR_POWER;
        break;
      case 'a':
        /*
        ** a  should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter a in infix.", __FILE__, __LINE__, NULL);
        }
        if ((expression[i+1]=='b')&&(expression[i+2]=='s'))
        {
          precedence = precedence_level + 5;
          operator_decision(pq, "abs", precedence, OPERATOR_FUNCTION);
          i+=2;       
          last  = OPERATOR_FUNCTION;
        }
        else
        {
          idx = parmindex('a', parm_name);
          parameter_decision(pq, "a  ", parm[idx]);
          last = PARAMETER;
        }
        break;
      case 'b':
        /*
        ** b  should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter b in infix.", __FILE__, __LINE__, NULL);
        }
        else
        {
          idx = parmindex('b', parm_name);
          parameter_decision(pq, "b  ", parm[idx]);
          last = PARAMETER;
        }
        break;
      case 'c':
        /*
        ** c or cos should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter c in infix.", __FILE__, __LINE__, NULL);
        }
        if ((expression[i+1]=='o')&&(expression[i+2]=='s'))
        {
          precedence = precedence_level + 5;
          operator_decision(pq, "cos", precedence, OPERATOR_FUNCTION);
          i+=2;       
          last  = OPERATOR_FUNCTION;
        }
        else
        {
          idx = parmindex('c', parm_name);
          parameter_decision(pq, "c  ", parm[idx]);
          last = PARAMETER;
        }
        break;
      case 'd':
        /*
        ** d should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter d in infix.", __FILE__, __LINE__, NULL);
        }
        else
        {
          idx = parmindex('d', parm_name);
          parameter_decision(pq, "d  ", parm[idx]);
          last = PARAMETER;
        }
        break;
      case 'e':
        /*
        ** parameter e, exp, or exponent e should not be preceded by:
        */
        if ((last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter e in infix.", __FILE__, __LINE__, NULL);
        }
        if ((expression[i+1]=='x')&&(expression[i+2]=='p'))
        {
          precedence = precedence_level + 5;
          operator_decision(pq, "exp", precedence, OPERATOR_FUNCTION);
          i+=2;       
          last  = OPERATOR_FUNCTION;
        }
        else if ((expression[i+1]=='+')||(expression[i+1]=='-'))
        {
            append_number_string(expression[i]);
            append_number_string(expression[i+1]);
            last = NUMBER;
            i+=1;
        }
        else
        {
          idx = parmindex('e', parm_name);
          parameter_decision(pq, "e  ", parm[idx]);
          last = PARAMETER;
        }
        break;
      case 'f':
        /*
        ** f should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter f in infix.", __FILE__, __LINE__, NULL);
        }
        else
        {
          idx = parmindex('f', parm_name);
          parameter_decision(pq, "f  ", parm[idx]);
          last = PARAMETER;
        }
        break;
      case 'g':
        /*
        ** g should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter g in infix.", __FILE__, __LINE__, NULL);
        }
        else
        {
          idx = parmindex('g', parm_name);
          parameter_decision(pq, "g  ", parm[idx]);
          last = PARAMETER;
        }
        break;
    /*case 'h':
      case 'i':
      case 'j':
      case 'k':*/
      case 'l':
        /*
        ** l or log should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter l in infix.", __FILE__, __LINE__, NULL);
        }
        if ((expression[i+1]=='o')&&(expression[i+2]=='g'))
        {
          precedence = precedence_level + 5;
          operator_decision(pq, "log", precedence, OPERATOR_FUNCTION);
          i+=2;       
          last  = OPERATOR_FUNCTION;
        }
        else
        {
          idx = parmindex('l', parm_name);
          parameter_decision(pq, "l  ", parm[idx]);
          last = PARAMETER;
        }
        break;
    /*case 'm':
      case 'n':
      case 'o':
      case 'p':
      case 'q':
      case 'r':*/
      case 's':
        /*
        ** s or sin should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter s in infix.", __FILE__, __LINE__, NULL);
        }
        if ((expression[i+1]=='i')&&(expression[i+2]=='n'))
        {
          precedence = precedence_level + 5;
          operator_decision(pq, "sin", precedence, OPERATOR_FUNCTION);
          i+=2;       
          last  = OPERATOR_FUNCTION;
        }
        else
        {
          yanera_error("Parameter s in infix.", __FILE__, __LINE__, NULL);
          last = PARAMETER;
        }
        break;
      case 't':
        /*
        ** t or tan should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid letter t in infix.", __FILE__, __LINE__, NULL);
        }
        if ((expression[i+1]=='a')&&(expression[i+2]=='n'))
        {
          precedence = precedence_level + 5;
          operator_decision(pq, "tan", precedence, OPERATOR_FUNCTION);
          i+=2;       
          last  = OPERATOR_FUNCTION;
        }
        else
        {
          yanera_error("Parameter t in infix.", __FILE__, __LINE__, NULL);
          last = PARAMETER;
        }
        break;
    /*case 'u':
      case 'v':
      case 'w':
      case 'x'
      case 'y'*/
      case 'z':
        /*
        ** z is reserved as the ordinate, and should not be preceded by:
        */
        if ((last == NUMBER) || \
            (last == ORDINATE) || \
            (last == PARAMETER) || \
            (last == OPERATOR_FUNCTION) || \
            (last == PARENTHESIS_CLOSE))
        {
          yanera_error("Invalid ordinate x in infix.", \
                       __FILE__, __LINE__, NULL);
        }
        enqueue_postfix_queue(pq, "x  ", 0.0, -1, ORDINATE);
        last  = ORDINATE;
        break;
      default:
        yanera_error("Cant parse function expression.", \
                     __FILE__, __LINE__, NULL);
        break;
    } /* End of switch */
    
  } /* End of for */
  /*
  ** If the epxression ends in a number, we need to append it to the
  ** postfix_queue.
  */
  if (last == NUMBER) stop_number_string(pq);
  if (precedence_level > 0) 
  {
    yanera_error("Invalid ( in infix.", \
                 __FILE__, __LINE__, NULL);
  }
  /*
  ** Any remaining operators on the operator_stack should be appended
  ** to the postfix_queue
  */
  while (operator_stack_is_empty()==NO) {
    ose = pop_operator_stack();
    enqueue_postfix_queue(pq, ose->oper, 0.0, -1, ose->type);
    free(ose);
  };
  
  return;
}
/*============================================================================*/
void parameter_decision(yanera_postfix *pq, const char c[4], short indx)
{
  struct _postfix_queue_element *p;

  /*
   * First, check to see if this parameter is already in the queue
   */
  p = pq->front;
  while (p != NULL) {
    if ((p->type == PARAMETER)&&(strncmp(c,p->oper,3) == 0))
    {
       enqueue_postfix_queue(pq, c, 0.0, p->indx, PARAMETER);
       return;
    }
    p=p->next;
  }
  /*
   * At this point, the paramter is not already in the queue, so add it.
   */
  enqueue_postfix_queue(pq, c, 0.0, indx, PARAMETER);
  return;
}
/*==============================================================================
  NUMBER_STRING
==============================================================================*/
void append_number_string(char c)
{
  unsigned short i;
  if (number_string == NULL)
  {
    number_string = (char *)malloc(2*sizeof(char));
    memset(number_string, '\0', 2);
    number_string[0] = c;
  }
  else
  {
    i = strlen(number_string);
    number_string = (char *)realloc(number_string, \
                                   (i+2)*sizeof(char));
    number_string[i+1] = '\0';                              
    number_string[i] = c;
  }
  return;
}
/* ------------------------------------------------------------------------- */
void stop_number_string(yanera_postfix *pq)
{
  enqueue_postfix_queue(pq, NULL, \
      strtod(number_string,NULL), \
      -1, NUMBER);
  free(number_string);
  number_string = NULL;
}
/*==============================================================================
 POSTFIX_QUEUE
==============================================================================*/
yanera_postfix *initizlize_postfix_queue(void)
{
  yanera_postfix *pq;
  
  pq = (yanera_postfix *)malloc(sizeof(yanera_postfix));
  
  pq->n      = 0;
  pq->front  = NULL;
  pq->rear   = NULL;
  return pq;
}
/* ------------------------------------------------------------------------- */
void enqueue_postfix_queue(yanera_postfix *pq, \
                           const char *c, double d, short indx, short type)
{
  struct _postfix_queue_element *p;
  /*
   * Allocate a new queue element
   */
  p = (struct _postfix_queue_element *)malloc( \
                                       sizeof(struct _postfix_queue_element));
  /*
   * Initalize the element
   */
  p->type = type;
  p->numb = d;
  p->indx = indx;
  memset(p->oper, '\0', 4);
  if (c!=NULL) strncpy(p->oper, c, 3);
  p->next = NULL;
  /*
   * Queue up the new element.
   */
  if (pq->n > 0)
  {
    pq->rear->next = p;
    pq->rear       = p;
  }
  else
  { 
    pq->front = p;
    pq->rear  = p;
  }
  pq->n++;
  return;
}
/* ------------------------------------------------------------------------- */
void print_postfix(yanera_postfix *pq, double x, double *params)
{
  struct _postfix_queue_element *p;
    
  /* Step through the queue */
  p = pq->front;
  do {
    /* Print numbers directly */
    if (p->type == NUMBER) fprintf(stderr, "%f\n", p->numb);
    /* Print operators as they are stored in the size 4 string */
    if ((p->type == OPERATOR_MULTADD) || \
        (p->type == OPERATOR_UNARY) || \
        (p->type == OPERATOR_POWER) || \
        (p->type == OPERATOR_FUNCTION) || \
        (p->type == ORDINATE) || \
        (p->type == PARAMETER))
    {
      fprintf(stderr, "%s", p->oper);
      /* If the ordinate \c x, then print the value 
         (passed into the function as the x parameter) */
      if (p->type == ORDINATE) fprintf(stderr, "= %f\n", x);
      /* If a varaible, then print the value from the array
         (passed into the function as the params array */
      else if (p->type == PARAMETER) 
        fprintf(stderr, "= %f\n", params[p->indx]);
      /* Add a new line between queue elementes.  */
      else fprintf(stderr, "\n");
    }
    p=p->next;
  } while (p!=NULL);
  
  return;
}
/* ------------------------------------------------------------------------- */
double evaluate_postfix(yanera_postfix *pq, double z, double *params)
{
  struct _postfix_queue_element *p;
  double v1, v2, tmp;
  
  initizlize_evaluation_stack();
  
  tmp = 0.0;
  p = pq->front;
  do {
    if (p->type==NUMBER)
    {
      push_evaluation_stack(p->numb);
    }
    else if (p->type == OPERATOR_MULTADD)
    {
      v1 = pop_evaluation_stack();
      v2 = pop_evaluation_stack();
      switch(p->oper[0]) {
        case '+':
          tmp = v2 + v1;
          break;
        case '-':
          tmp = v2 - v1;
          break;
        case '*':
          tmp = v2 * v1;
          break;
        case '/':
          tmp = v2 / v1;
          break;
      }
      push_evaluation_stack(tmp);
    }
    else if (p->type == OPERATOR_POWER)
    {
      v1 = pop_evaluation_stack();
      v2 = pop_evaluation_stack();
      tmp = pow(v2,v1);
      push_evaluation_stack(tmp);
    }
    else if (p->type == OPERATOR_FUNCTION)
    {
      v1 = pop_evaluation_stack();
      if (strncmp(p->oper,"abs",3)==0) tmp = fabs(v1);
      if (strncmp(p->oper,"cos",3)==0) tmp = cos(v1);
      if (strncmp(p->oper,"exp",3)==0) tmp = exp(v1);
      if (strncmp(p->oper,"log",3)==0) tmp = log(v1);
      if (strncmp(p->oper,"sin",3)==0) tmp = sin(v1);
      if (strncmp(p->oper,"tan",3)==0) tmp = tan(v1);
      push_evaluation_stack(tmp);
    }
    else if (p->type==ORDINATE)
    {
      push_evaluation_stack(z);   
    }
    else if (p->type==PARAMETER)
    {
      push_evaluation_stack(params[p->indx]);   
    }
    p=p->next;
  } while (p!=NULL);
  
  tmp = pop_evaluation_stack();
  return tmp;
}
/* ------------------------------------------------------------------------- */
void free_postfix_queue(yanera_postfix *pq)
{
  struct _postfix_queue_element *p;
  struct _postfix_queue_element *f;
  
  if (pq == NULL) return;

  f = pq->front;
  while (f != NULL) {
    p = f->next;
    free(f);
    f = p;
    pq->n--;
  };
  free(pq);
  return;
}
/*==============================================================================
 OPERATOR_STACK
==============================================================================*/
/* ------------------------------------------------------------------------- */
void initizlize_operator_stack(void)
{
  operator_stack.n   = 0;
  operator_stack.top = NULL;
  return;
}
/* ------------------------------------------------------------------------- */
struct operator_stack_element *operator_stack_element_new( \
                               const char *oper, short prec,short type)
{
  struct operator_stack_element *o;
  
  o = malloc(sizeof(struct operator_stack_element));
  o->prec = prec;
  o->type = type;
  memset(o->oper, '\0', 4);
  strncpy(o->oper, oper, 3);
  return o;
}
/* ------------------------------------------------------------------------- */
void push_operator_stack(struct operator_stack_element *o)
{
  o->next = operator_stack.top;
  operator_stack.top = o;
  operator_stack.n++;
  return;
}
/* ------------------------------------------------------------------------- */
struct operator_stack_element *pop_operator_stack(void)
{
  struct operator_stack_element *o, *optr;
  
  /* 
   * Make a copy of the operator_stack_element to return.
   */
  o = (struct operator_stack_element *)malloc( \
       sizeof(struct operator_stack_element));
  o->prec = operator_stack.top->prec;
  o->type = operator_stack.top->type;
  memset(o->oper, '\0', 4);
  strncpy(o->oper,operator_stack.top->oper,3);
  /*
   * Free the top element of the stack.
   */
  optr = operator_stack.top;
  operator_stack.top = operator_stack.top->next;
  operator_stack.n--;
  free(optr);
  return o;
}
/* ------------------------------------------------------------------------- */
short operator_stack_is_empty(void)
{
  if (operator_stack.n == 0) return YES;
  return NO;
}
/* ------------------------------------------------------------------------- */
short operator_stack_top_precedence(void)
{
  int i;
  if (operator_stack.n == 0) i = 0;
  else i = operator_stack.top->prec;
  return (i);
}
/* ------------------------------------------------------------------------- */
void operator_decision(yanera_postfix *pq, \
                       const char oper[4], short prec, short type)
{
  struct operator_stack_element *ose = NULL;
  
  if ((operator_stack_is_empty()==YES) || \
      (prec > operator_stack_top_precedence()))
  { 
    ose = operator_stack_element_new(oper, prec, type);
    push_operator_stack(ose);
  }
  else
  {
    do {
      ose = pop_operator_stack();
      enqueue_postfix_queue(pq, ose->oper, 0.0, -1, ose->type);
      free(ose);
    } while ((operator_stack_is_empty() == NO) && \
             (prec <= operator_stack_top_precedence()));
    ose = operator_stack_element_new(oper, prec, type);
    push_operator_stack(ose);
  }
  return;
}
/*==============================================================================
  EVALUATION_STACK
==============================================================================*/
/* ------------------------------------------------------------------------- */
void initizlize_evaluation_stack(void)
{
  evaluation_stack.n   = 0;
  evaluation_stack.top = NULL;
  return;
}
/* ------------------------------------------------------------------------- */
void push_evaluation_stack(double d)
{
  struct evaluation_stack_element *e;
  
  e = malloc(sizeof(struct evaluation_stack_element));
  e->d = d;
  e->next = evaluation_stack.top;
  evaluation_stack.top = e;
  evaluation_stack.n++;
  return;
}
/* ------------------------------------------------------------------------- */
double pop_evaluation_stack(void)
{
  double d;
  struct evaluation_stack_element *e;

  d = evaluation_stack.top->d;
  
  e = evaluation_stack.top;
  evaluation_stack.top = evaluation_stack.top->next;
  evaluation_stack.n--;
  free(e);
  return d;
}

---