epyt-flow 0.14.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

epyt_flow/EPANET/EPANET-MSX/Src/mathexpr.c

@@ -1,937 +0,0 @@
-/******************************************************************************
-**  MODULE:        MATHEXPR.C
-**  PROJECT:       EPANET-MSX
-**  DESCRIPTION:   Evaluates symbolic mathematical expression consisting
-**                 of numbers, variable names, math functions & arithmetic
-**                 operators.
-**  AUTHORS:       see AUTHORS
-**  Copyright:     see AUTHORS
-**  License:       see LICENSE
-**  VERSION:       2.0.00
-**  LAST UPDATE:   09/02/2022
-******************************************************************************/
-/*
-**   Operand codes:
-** 	1 = (
-** 	2 = )
-** 	3 = +
-** 	4 = - (subtraction)
-** 	5 = *
-** 	6 = /
-** 	7 = number
-** 	8 = user-defined variable
-** 	9 = - (negative)
-**	10 = cos
-**	11 = sin
-**	12 = tan
-**	13 = cot
-**	14 = abs
-**	15 = sgn
-**	16 = sqrt
-**	17 = log
-**	18 = exp
-**	19 = asin
-**	20 = acos
-**	21 = atan
-**      22 = acot
-**	23 = sinh
-**	24 = cosh
-**	25 = tanh
-**	26 = coth
-**	27 = log10
-**  28 = step (x<=0 ? 0 : 1)
-**	31 = ^
-******************************************************************************/
-#define _CRT_SECURE_NO_WARNINGS
-
-#include <ctype.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <math.h>
-
-#include "mathexpr.h"
-
-#define MAX_STACK_SIZE  1024
-
-//***************************************************                         
-#define MAX_TERM_SIZE  1024
-struct MathTerm
-{
-    char s[MAX_TERM_SIZE];
-};
-typedef struct MathTerm Term;
-//***************************************************
-
-
-//  Local declarations
-//--------------------
-//  Structure for binary tree representation of math expression
-struct TreeNode
-{
-    int    opcode;                // operator code
-    int    ivar;                  // variable index
-    double fvalue;                // numerical value
-    struct TreeNode* left;        // left sub-tree of tokenized formula
-    struct TreeNode* right;       // right sub-tree of tokenized formula
-};
-typedef struct TreeNode ExprTree;
-
-// Local variables
-//----------------
-static int    Err;
-static int    Bc;
-static int    PrevLex, CurLex;
-static int    Len, Pos;
-static char* S;
-static char   Token[255];
-static int    Ivar;
-static double Fvalue;
-
-// math function names
-char* MathFunc[] = { "COS", "SIN", "TAN", "COT", "ABS", "SGN",
-                     "SQRT", "LOG", "EXP", "ASIN", "ACOS", "ATAN",
-                     "ACOT", "SINH", "COSH", "TANH", "COTH", "LOG10",
-                     "STEP", NULL };
-
-// Local functions
-//----------------
-static int        sametext(char*, char*);
-static int        isDigit(char);
-static int        isLetter(char);
-static void       getToken(void);
-static int        getMathFunc(void);
-static int        getVariable(void);
-static int        getOperand(void);
-static int        getLex(void);
-static double     getNumber(void);
-static ExprTree* newNode(void);
-static ExprTree* getSingleOp(int*);
-static ExprTree* getOp(int*);
-static ExprTree* getTree(void);
-static void       traverseTree(ExprTree*, MathExpr**);
-static void       deleteTree(ExprTree*);
-
-// Callback functions
-static int    (*getVariableIndex) (char*); // return index of named variable
-static double (*getVariableValue) (int);    // return value of indexed variable
-
-//=============================================================================
-
-int  sametext(char* s1, char* s2)
-/*
-**  Purpose:
-**    performs case insensitive comparison of two strings.
-**
-**  Input:
-**    s1 = character string
-**    s2 = character string.
-**
-**  Returns:
-**    1 if strings are the same, 0 otherwise.
-*/
-{
-    int i;
-    for (i = 0; toupper(s1[i]) == toupper(s2[i]); i++)
-        if (!s1[i + 1] && !s2[i + 1]) return(1);
-    return(0);
-}
-
-//=============================================================================
-
-int isDigit(char c)
-{
-    if (c >= '1' && c <= '9') return 1;
-    if (c == '0') return 1;
-    return 0;
-}
-
-//=============================================================================
-
-int isLetter(char c)
-{
-    if (c >= 'a' && c <= 'z') return 1;
-    if (c >= 'A' && c <= 'Z') return 1;
-    if (c == '_') return 1;
-    return 0;
-}
-
-//=============================================================================
-
-void getToken()
-{
-    char c[] = " ";
-    Token[0] = '\0';
-    while (Pos <= Len &&
-        (isLetter(S[Pos]) || isDigit(S[Pos])))
-    {
-        c[0] = S[Pos];
-        strcat(Token, c);
-        Pos++;
-    }
-    Pos--;
-}
-
-//=============================================================================
-
-int getMathFunc()
-{
-    int i = 0;
-    while (MathFunc[i] != NULL)
-    {
-        if (sametext(MathFunc[i], Token)) return i + 10;
-        i++;
-    }
-    return(0);
-}
-
-//=============================================================================
-
-int getVariable()
-{
-    if (!getVariableIndex) return 0;
-    Ivar = getVariableIndex(Token);
-    if (Ivar >= 0) return 8;
-    return 0;
-}
-
-//=============================================================================
-
-double getNumber()
-{
-    char c[] = " ";
-    char sNumber[255];
-    int  errflag = 0;
-    int  decimalCount = 0;
-
-    /* --- get whole number portion of number */
-    sNumber[0] = '\0';
-    while (Pos < Len && isDigit(S[Pos]))
-    {
-        c[0] = S[Pos];
-        strcat(sNumber, c);
-        Pos++;
-    }
-
-    /* --- get fractional portion of number */
-    if (Pos < Len)
-    {
-        if (S[Pos] == '.')
-        {
-            decimalCount++;
-            if (decimalCount > 1) Err = 1;
-            strcat(sNumber, ".");
-            Pos++;
-            while (Pos < Len && isDigit(S[Pos]))
-            {
-                c[0] = S[Pos];
-                strcat(sNumber, c);
-                Pos++;
-            }
-        }
-
-        /* --- get exponent */
-        if (Pos < Len && (S[Pos] == 'e' || S[Pos] == 'E'))
-        {
-            strcat(sNumber, "E");
-            Pos++;
-            if (Pos >= Len) errflag = 1;
-            else
-            {
-                if (S[Pos] == '-' || S[Pos] == '+')
-                {
-                    c[0] = S[Pos];
-                    strcat(sNumber, c);
-                    Pos++;
-                }
-                if (Pos >= Len || !isDigit(S[Pos])) errflag = 1;
-                else while (Pos < Len && isDigit(S[Pos]))
-                {
-                    c[0] = S[Pos];
-                    strcat(sNumber, c);
-                    Pos++;
-                }
-            }
-        }
-    }
-    Pos--;
-    if (errflag) return 0;
-    else return atof(sNumber);
-}
-
-//=============================================================================
-
-int getOperand()
-{
-    int code;
-    switch (S[Pos])
-    {
-    case '(': code = 1;  break;
-    case ')': code = 2;  break;
-    case '+': code = 3;  break;
-    case '-': code = 4;
-        if (Pos < Len - 1 &&
-            isDigit(S[Pos + 1]) &&
-            (CurLex <= 6 || CurLex == 31))
-        {
-            Pos++;
-            Fvalue = -getNumber();
-            code = 7;
-        }
-        break;
-    case '*': code = 5;  break;
-    case '/': code = 6;  break;
-    case '^': code = 31; break;
-    default:  code = 0;
-    }
-    return code;
-}
-
-//=============================================================================
-
-int getLex()
-{
-    int n;
-
-    /* --- skip spaces */
-    while (Pos < Len && S[Pos] == ' ') Pos++;
-    if (Pos >= Len) return 0;
-
-    /* --- check for operand */
-    n = getOperand();
-
-    /* --- check for function/variable/number */
-    if (n == 0)
-    {
-        if (isLetter(S[Pos]))
-        {
-            getToken();
-            n = getMathFunc();
-            if (n == 0) n = getVariable();
-        }
-        else if (S[Pos] == '.' || isDigit(S[Pos]))
-        {
-            n = 7;
-            Fvalue = getNumber();
-        }
-    }
-    Pos++;
-    PrevLex = CurLex;
-    CurLex = n;
-    return n;
-}
-
-//=============================================================================
-
-ExprTree* newNode()
-{
-    ExprTree* node;
-    node = (ExprTree*)malloc(sizeof(ExprTree));
-    if (!node) Err = 2;
-    else
-    {
-        node->opcode = 0;
-        node->ivar = -1;
-        node->fvalue = 0.;
-        node->left = NULL;
-        node->right = NULL;
-    }
-    return node;
-}
-
-//=============================================================================
-
-ExprTree* getSingleOp(int* lex)
-{
-    int opcode;
-    ExprTree* left;
-    ExprTree* node;
-
-    /* --- open parenthesis, so continue to grow the tree */
-    if (*lex == 1)
-    {
-        Bc++;
-        left = getTree();
-    }
-
-    else
-    {
-        /* --- Error if not a singleton operand */
-        if (*lex < 7 || *lex == 9 || *lex > 30)
-        {
-            Err = 1;
-            return NULL;
-        }
-
-        opcode = *lex;
-
-        /* --- simple number or variable name */
-        if (*lex == 7 || *lex == 8)
-        {
-            left = newNode();
-            left->opcode = opcode;
-            if (*lex == 7) left->fvalue = Fvalue;
-            if (*lex == 8) left->ivar = Ivar;
-        }
-
-        /* --- function which must have a '(' after it */
-        else
-        {
-            *lex = getLex();
-            if (*lex != 1)
-            {
-                Err = 1;
-                return NULL;
-            }
-            Bc++;
-            left = newNode();
-            left->left = getTree();
-            left->opcode = opcode;
-        }
-    }
-    *lex = getLex();
-
-    /* --- exponentiation */
-    if (*lex == 31)
-    {
-        node = newNode();
-        node->left = left;
-        node->opcode = *lex;
-        *lex = getLex();
-        node->right = getSingleOp(lex);
-        left = node;
-    }
-    return left;
-}
-
-//=============================================================================
-
-ExprTree* getOp(int* lex)
-{
-    int opcode;
-    ExprTree* left;
-    ExprTree* right;
-    ExprTree* node;
-    int neg = 0;
-
-    *lex = getLex();
-    if (PrevLex == 0 || PrevLex == 1)
-    {
-        if (*lex == 4)
-        {
-            neg = 1;
-            *lex = getLex();
-        }
-        else if (*lex == 3) *lex = getLex();
-    }
-    left = getSingleOp(lex);
-    while (*lex == 5 || *lex == 6)
-    {
-        opcode = *lex;
-        *lex = getLex();
-        right = getSingleOp(lex);
-        node = newNode();
-        if (Err) return NULL;
-        node->left = left;
-        node->right = right;
-        node->opcode = opcode;
-        left = node;
-    }
-    if (neg)
-    {
-        node = newNode();
-        if (Err) return NULL;
-        node->left = left;
-        node->right = NULL;
-        node->opcode = 9;
-        left = node;
-    }
-    return left;
-}
-
-//=============================================================================
-
-ExprTree* getTree()
-{
-    int      lex;
-    int      opcode;
-    ExprTree* left;
-    ExprTree* right;
-    ExprTree* node;
-
-    left = getOp(&lex);
-    for (;;)
-    {
-        if (lex == 0 || lex == 2)
-        {
-            if (lex == 2) Bc--;
-            break;
-        }
-
-        if (lex != 3 && lex != 4)
-        {
-            Err = 1;
-            break;
-        }
-
-        opcode = lex;
-        right = getOp(&lex);
-        node = newNode();
-        if (Err) break;
-        node->left = left;
-        node->right = right;
-        node->opcode = opcode;
-        left = node;
-    }
-    return left;
-}
-
-//=============================================================================
-
-void traverseTree(ExprTree* tree, MathExpr** expr)
-// Converts binary tree to linked list (postfix format)
-{
-    MathExpr* node;
-    if (tree == NULL) return;
-    traverseTree(tree->left, expr);
-    traverseTree(tree->right, expr);
-    node = (MathExpr*)malloc(sizeof(MathExpr));
-    if (node)
-    {
-        node->fvalue = tree->fvalue;
-        node->opcode = tree->opcode;
-        node->ivar = tree->ivar;
-        node->next = NULL;
-        node->prev = (*expr);
-    }
-    if (*expr) (*expr)->next = node;
-    (*expr) = node;
-}
-
-//=============================================================================
-
-void deleteTree(ExprTree* tree)
-{
-    if (tree)
-    {
-        if (tree->left)  deleteTree(tree->left);
-        if (tree->right) deleteTree(tree->right);
-        free(tree);
-    }
-}
-
-//=============================================================================
-
-// Turn on "precise" floating point option
-#pragma float_control(precise, on, push)
-
-double mathexpr_eval(MathExpr* expr, double (*getVariableValue) (int))
-//  Mathematica expression evaluation using a stack
-{
-
-    // --- Note: the exprStack array must be declared locally and not globally
-    //     since this function can be called recursively.
-
-    double exprStack[MAX_STACK_SIZE];
-    MathExpr* node = expr;
-    double r1, r2;
-    int stackindex = 0;
-
-    exprStack[0] = 0.0;
-    while (node != NULL)
-    {
-        switch (node->opcode)
-        {
-        case 3:
-            r1 = exprStack[stackindex];
-            stackindex--;
-            r2 = exprStack[stackindex];
-            exprStack[stackindex] = r2 + r1;
-            break;
-
-        case 4:
-            r1 = exprStack[stackindex];
-            stackindex--;
-            r2 = exprStack[stackindex];
-            exprStack[stackindex] = r2 - r1;
-            break;
-
-        case 5:
-            r1 = exprStack[stackindex];
-            stackindex--;
-            r2 = exprStack[stackindex];
-            exprStack[stackindex] = r2 * r1;
-            break;
-
-        case 6:
-            r1 = exprStack[stackindex];
-            stackindex--;
-            r2 = exprStack[stackindex];
-            exprStack[stackindex] = r2 / r1;
-            break;
-
-        case 7:
-            stackindex++;
-            exprStack[stackindex] = node->fvalue;
-            break;
-
-        case 8:
-            if (getVariableValue != NULL)
-                r1 = getVariableValue(node->ivar);
-            else r1 = 0.0;
-            stackindex++;
-            exprStack[stackindex] = r1;
-            break;
-
-        case 9:
-            exprStack[stackindex] = -exprStack[stackindex];
-            break;
-
-        case 10:
-            r1 = exprStack[stackindex];
-            r2 = cos(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 11:
-            r1 = exprStack[stackindex];
-            r2 = sin(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 12:
-            r1 = exprStack[stackindex];
-            r2 = tan(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 13:
-            r1 = exprStack[stackindex];
-            r2 = 1.0 / tan(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 14:
-            r1 = exprStack[stackindex];
-            r2 = fabs(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 15:
-            r1 = exprStack[stackindex];
-            if (r1 < 0.0) r2 = -1.0;
-            else if (r1 > 0.0) r2 = 1.0;
-            else r2 = 0.0;
-            exprStack[stackindex] = r2;
-            break;
-
-        case 16:
-            r1 = exprStack[stackindex];
-            r2 = sqrt(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 17:
-            r1 = exprStack[stackindex];
-            r2 = log(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 18:
-            r1 = exprStack[stackindex];
-            r2 = exp(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 19:
-            r1 = exprStack[stackindex];
-            r2 = asin(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 20:
-            r1 = exprStack[stackindex];
-            r2 = acos(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 21:
-            r1 = exprStack[stackindex];
-            r2 = atan(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 22:
-            r1 = exprStack[stackindex];
-            r2 = 1.57079632679489661923 - atan(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 23:
-            r1 = exprStack[stackindex];
-            r2 = (exp(r1) - exp(-r1)) / 2.0;
-            exprStack[stackindex] = r2;
-            break;
-
-        case 24:
-            r1 = exprStack[stackindex];
-            r2 = (exp(r1) + exp(-r1)) / 2.0;
-            exprStack[stackindex] = r2;
-            break;
-
-        case 25:
-            r1 = exprStack[stackindex];
-            r2 = (exp(r1) - exp(-r1)) / (exp(r1) + exp(-r1));
-            exprStack[stackindex] = r2;
-            break;
-
-        case 26:
-            r1 = exprStack[stackindex];
-            r2 = (exp(r1) + exp(-r1)) / (exp(r1) - exp(-r1));
-            exprStack[stackindex] = r2;
-            break;
-
-        case 27:
-            r1 = exprStack[stackindex];
-            r2 = log10(r1);
-            exprStack[stackindex] = r2;
-            break;
-
-        case 28:
-            r1 = exprStack[stackindex];
-            if (r1 <= 0.0) r2 = 0.0;
-            else           r2 = 1.0;
-            exprStack[stackindex] = r2;
-            break;
-
-        case 31:
-            r1 = exprStack[stackindex];
-            stackindex--;
-            if (stackindex < 0) break;
-            r2 = exprStack[stackindex];
-            if (r2 <= 0.0) r2 = 0.0;
-            else r2 = pow(r2, r1);
-            exprStack[stackindex] = r2;
-            break;
-        }
-        node = node->next;
-    }
-    if (stackindex >= 0)
-        r1 = exprStack[stackindex];
-    else
-        r1 = 0.0;
-
-    // Set result to 0 if it is NaN due to an illegal math op
-    if (r1 != r1) r1 = 0.0;
-
-    return r1;
-}
-
-// Turn off "precise" floating point option
-#pragma float_control(pop)
-
-//=============================================================================
-
-void mathexpr_delete(MathExpr* expr)
-{
-    if (expr) mathexpr_delete(expr->next);
-    free(expr);
-}
-
-//=============================================================================
-
-MathExpr* mathexpr_create(char* formula, int (*getVar) (char*))
-{
-    ExprTree* tree;
-    MathExpr* expr = NULL;
-    MathExpr* result = NULL;
-    getVariableIndex = getVar;
-    Err = 0;
-    PrevLex = 0;
-    CurLex = 0;
-    S = formula;
-    Len = (int)strlen(S);
-    Pos = 0;
-    Bc = 0;
-    tree = getTree();
-    if (Bc == 0 && Err == 0)
-    {
-        traverseTree(tree, &expr);
-        while (expr)
-        {
-            result = expr;
-            expr = expr->prev;
-        }
-    }
-    deleteTree(tree);
-    return result;
-}
-
-
-//=============================================================================
-
-char* mathexpr_getStr(MathExpr* expr, char* exprStr,                         
-    char* (*getVariableStr) (int, char*))
-{
-    Term TermStack[50];
-    MathExpr* node = expr;
-    char r1[MAX_TERM_SIZE], r2[MAX_TERM_SIZE];
-    int stackindex = 0;
-
-    strcpy(TermStack[0].s, "");
-    while (node != NULL)
-    {
-        switch (node->opcode)
-        {
-        case 3:
-            strcpy(r1, TermStack[stackindex].s);
-            stackindex--;
-            strcpy(r2, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "(%s) + (%s)", r2, r1);
-            break;
-
-        case 4:
-            strcpy(r1, TermStack[stackindex].s);
-            stackindex--;
-            strcpy(r2, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "(%s) - (%s)", r2, r1);
-            break;
-
-        case 5:
-            strcpy(r1, TermStack[stackindex].s);
-            stackindex--;
-            strcpy(r2, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "(%s) * (%s)", r2, r1);
-            break;
-
-        case 6:
-            strcpy(r1, TermStack[stackindex].s);
-            stackindex--;
-            strcpy(r2, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "(%s) / (%s)", r2, r1);
-            break;
-
-        case 7:
-            stackindex++;
-            sprintf(TermStack[stackindex].s, "%.6g", node->fvalue);
-            break;
-
-        case 8:
-            if (getVariableStr != NULL)strcpy(r1, getVariableStr(node->ivar, r2));
-            else strcpy(r1, "");
-            stackindex++;
-            strcpy(TermStack[stackindex].s, r1);
-            break;
-
-        case 9:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "-(%s)", r1);
-            break;
-
-        case 10:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "cos(%s)", r1);
-            break;
-
-        case 11:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "sin(%s)", r1);
-            break;
-
-        case 12:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "tan(%s)", r1);
-            break;
-
-        case 13:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "cot(%s)", r1);
-            break;
-
-        case 14:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "abs(%s)", r1);
-            break;
-
-        case 15:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "sgn(%s)", r1);
-            break;
-
-        case 16:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "sqrt(%s)", r1);
-            break;
-
-        case 17:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "log(%s)", r1);
-            break;
-
-        case 18:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "exp(%s)", r1);
-            break;
-
-        case 19:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "asin(%s)", r1);
-            break;
-
-        case 20:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "acos(%s)", r1);
-            break;
-
-        case 21:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "atan(%s)", r1);
-            break;
-
-        case 22:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "acot(%s)", r1);
-            break;
-
-        case 23:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "sinh(%s)", r1);
-            break;
-
-        case 24:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "cosh(%s)", r1);
-            break;
-
-        case 25:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "tanh(%s)", r1);
-            break;
-
-        case 26:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "coth(%s)", r1);
-            break;
-
-        case 27:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "log10(%s)", r1);
-            break;
-
-        case 28:
-            strcpy(r1, TermStack[stackindex].s);
-            sprintf(TermStack[stackindex].s, "step(%s)", r1);
-            break;
-
-        case 31:
-            strcpy(r1, TermStack[stackindex].s);
-            strcpy(r2, TermStack[stackindex - 1].s);
-            sprintf(TermStack[stackindex - 1].s, "pow(%s,%s)", r2, r1);
-            stackindex--;
-            break;
-        }
-        node = node->next;
-    }
-    strcpy(exprStr, TermStack[stackindex].s);
-    return exprStr;
-}