Калькулятор, что можно улучшить/переработать

float tol = fabs(Eval(Subst(LineEditTol->Text)));

#include <vcl.h>
#include <Math.hpp>
#include <math.h>
 
#include "FormMain.h"
#include "Evaluate.h"
//---------------------------------------------------------------------------
bool FastVerify = false;
double epsilon = 1e-14;
 
AnsiString VeriSign(AnsiString str)
{ int i;
 while(str.AnsiPos("++") || str.AnsiPos("+-") || \
       str.AnsiPos("-+") || str.AnsiPos("--"))
 {
  if((i=str.AnsiPos("++"))!=0) str.Delete(i,1);
  if((i=str.AnsiPos("+-"))!=0) str.Delete(i,1);
  if((i=str.AnsiPos("-+"))!=0) str.Delete(i+1,1);
  if((i=str.AnsiPos("--"))!=0){ str.Delete(i,2); str.Insert("+",i);}
 }
 return str;
}
//---------------------------------------------------------------------------
 
int ExtractNumber(AnsiString str, bool dir, int cur)
{//Функция получает строку, содержащую запись числа
// требуется выделить число в нужном направлении dir(true - right, false - left)
// от текущей позиции cur и вернуть позицию последнего либо первого символа числа
// варианты числа: 1,12E70 1E7 1E-7 -1E-08
//допустимые комбинации символов: ","  "E-"  "E"  "-"
 int i;
 bool f = true;
 AnsiString sub;
 str = str.UpperCase();
 sub = str.SubString(cur, 1);
 if(sub>="0" && sub<="9")
 {
  if(cur<str.Length())
  {
   sub = str.SubString(cur+1,1);
   if((sub <"0" || sub>"9") && sub !="," && sub != "E")
   return cur;
  }
 }
 (dir ? cur++ : cur--);
 for(i = cur; i>0 && i<=str.Length() && f; (dir ? i++ : i--))
 {
  sub = str.SubString(i,1);
  if(sub>="0" && sub<="9") continue;
  if(sub==",") continue;
  if(sub=="E") continue;
  if((sub=="-" || sub=="+") && i==cur) continue;
  if((sub=="-" || sub=="+") && i>1 && str.SubString(i-1,1)=="E") continue;
//  if((str.SubString(i,1)=="-" || str.SubString(i,1)=="+") && i==1) return i;
  f = false;
  return (dir?--i:++i);
 }
 return (dir?--i:++i);
}
//---------------------------------------------------------------------------
 
double SpecFun(int num, AnsiString str)
{
/* AnsiString function[NumFuns]=
 {
  "asin", "acos", "atan", "actg",
  "sin", "cos", "ctg", "tg",
  "ln","lg","exp",
  "sqrt","sqr"};
*/
 double z = NaN;
 double xin = str.ToDouble();
 //тригонометрические функции считают в радианах
 switch(num)
 {
  case 4:  z = sin(xin); break;
  case 5:  z = cos(xin); break;
  case 7:  z = tan(xin); break;
  case 6:  if(!IsZero(xin, epsilon)) z = Cot(xin);
           else{
            if(xin>0) z=Infinity;
            if(xin<0) z=NegInfinity;
            if(xin==0) z=NaN;
           } break;
  case 0:  if(fabs(xin)<=1) z = asin(xin); else z = NaN; break;
  case 1:  if(fabs(xin)<=1) z = acos(xin); else z = NaN; break;
  case 2:  z = atan(xin); break;
  case 3:  z = ArcCot(xin); break;
  case 8:  if(xin>0) z = log(xin); else z = NaN; break;
  case 9:  if(xin>0) z = log10(xin); else z = NaN; break;
  case 10: z = exp(xin); break;
  case 12: z = pow(xin,2); break;//square
  case 11: if (xin<0) z=NaN;
           else z = sqrt(xin); break;//square root
 }
 return z;
}
//---------------------------------------------------------------------------
 
AnsiString DeleteSpaces(AnsiString str)
{
 int i;
 while((i=str.AnsiPos(" "))!=0)
  str.Delete(i,1);
 return str;
}
//---------------------------------------------------------------------------
 
bool IsNumber(const AnsiString str)
{
 if(!FastVerify)
 {
  AnsiString string = str.LowerCase();
  bool al_e = false;//E уже было
  bool al_c = false;// запятая уже была
  int i;//позиция в строке
  AnsiString sub;//подстрока - символ для проверки
  //проверка
  if(string.IsEmpty()) return false;
// string = string.LowerCase();
  for(i=1; i<string.Length(); i++)
  {
   sub = string.SubString(i,1);
   if(i!=1 && sub!="+" && sub!="-" && sub!="," && (sub<"0" || sub>"9") && sub!="e") return false;
   if(i==1 && sub=="e") return false;
   if(sub==","){ if(al_c) return false; else al_c = true;}
   if(sub=="e"){ if(al_e) return false; else al_e = true;}
   if(i!=1 && (sub=="-" || sub=="+")){ if(string.SubString(i-1,1)!="e") return false;}
  }
  return true;
 }
 else
 {
  try
  {
   str.ToDouble();
   return true;
  }
  catch(...)
  {
   return false;
  }
 }
}
//---------------------------------------------------------------------------
 
double Eval(AnsiString str)
{ double epsilon=1e-14;
/* Уровни операций в выражении
        Уровень 1       ()      Скобочное группирование
        Уровень 2       -       Унарный минус
        Уровень 3       вызов функции. Получить значение от RETURN
        Уровень 4       ^       Возведение в степень
        Уровень 5       * / %   Умножение, деление, остаток от деления
        Уровень 6       + -     Сложение, вычитание
        Уровень 7       &       Конкатенация. Не используется.
*/
 double fy,fy1,fy2, y = NaN;
 double z;
StartAnalize:
 str = VeriSign(str);//Исправление рядом стоящих + и -
/* try//проверка на возможность прямого преобразования
 {
  y = str.ToDouble();
  return y;
 }
 catch(const EConvertError &)
 {
  //Nothing to do !
 }*/
 if(IsNumber(str)) return str.ToDouble();
 //проверка на наличие скобочного группирования
 //все выражения в скобках вычисляются и подставляются
 int i,s,p;
 AnsiString sub;
 if((i=str.AnsiPos("("))!=0)//учитывая: если есть '(', то есть и ')'
 {
  s = 1;
  p = i;//++;
  while(s != 0)
  {
   i++;
   if(str.SubString(i,1) == "(") s++;
   if(str.SubString(i,1) == ")") s--;
  }
  sub = str.SubString(p+1,i-p-1);
  str.Delete(p,i-p+1);
  fy = Eval(sub);
  if(IsInfinite(fy)||IsNan(fy)) return fy;
  sub = AnsiString(fy);
  str.Insert(sub, p);
  goto StartAnalize;
  //в результате многократного рекурсивного вызова выражение упрощается
  //удалением скобочных групп
 }
 //Операция 1-го уровня выполнена
 //Уровень 2. Унарный минус. Выполняется попутно с другими операциями
 //Уровень 3. Вызов функции, получение результата от return.
 //небольшой набор функций
 const BYTE NumFuns = 13;
 AnsiString function[NumFuns]=
 {
  "asin", "acos", "atan", "actg",
  "sin", "cos", "ctg", "tg",
  "ln","lg","exp",
  "sqrt","sqr"};
 bool f = true, ff = false;
 int i1, i2;
 while(f)
 {
  for(i=0; i<NumFuns; i++)
  {
   if((p=str.AnsiPos(function[i]))!=0)
   {
    i1 = p + function[i].Length();//определено начало аргумента функции
    i2 = ExtractNumber(str, true, i1);
    sub = str.SubString(i1,i2-i1+1);
    str.Delete(p, i2-p+1);
    ff = true;
    fy = SpecFun(i, sub);
    if(IsInfinite(fy)||IsNan(fy)) return fy;
    str.Insert(AnsiString(fy), p);
   }
  }
  if(i == NumFuns && p == 0)
  {
   f = false;
  }
 }
 str = VeriSign(str);//Исправление рядом стоящих + и -
 if(ff)
 {
  if(IsNumber(str)) return str.ToDouble();
 }// goto StartAnalize;
 ff = false;
 //3 уровень завершен
 //Уровень 4. Возведение в степень.
 // учет унарных минусов: x^-y -x^y -x^-y
 while((p=str.AnsiPos("^"))!=0)
 {
  i1 = ExtractNumber(str, false, p);
  i2 = ExtractNumber(str, true, p);
  AnsiString x1, x2;
  x1 = str.SubString(i1, p-i1);
  x2 = str.SubString(p+1, i2-p);
  if(i1>1 && str.SubString(i1-1,1)=="-")
  {
   x1 = "-" + x1;
   str.Delete(i1-1, 1);
   str.Insert("+", i1-1);
  }
  fy1 = Eval(x1);
  fy2 = Eval(x2);
  if(IsInfinite(fy1)||IsNan(fy1)) return fy1;
  if(IsInfinite(fy2)||IsNan(fy2)) return fy2;
  if(fy1<0 && fabs(fy2)<1) return NaN;
  z = pow(fy1, fy2);
  str.Delete(i1, i2-i1+1);
  str.Insert(AnsiString(z), i1);
  ff = true;
 }
 str = VeriSign(str);//Исправление рядом стоящих + и -
 if(ff)
 {
  if(IsNumber(str)) return str.ToDouble();
 }// goto StartAnalize;
 ff = false;
 //Обработка 4-го уровн завершена
/* Уровни операций в выражении
        Уровень 1       ()      Скобочное группирование
        Уровень 2       -       Унарный минус
        Уровень 3       вызов функции. Получить значение от RETURN
        Уровень 4       ^       Возведение в степень
        Уровень 5       * / %   Умножение, деление, остаток от деления(не используется)
        Уровень 6       + -     Сложение, вычитание
        Уровень 7       &       Конкатенация. Не используется.
*/
 //Уровень 5. Умножение и деление.
 while(str.AnsiPos("*") || str.AnsiPos("/"))
 {
  p = 1;
  while(str.SubString(p,1)!="*"&&str.SubString(p,1)!="/") p++;
 
  if(str.SubString(p,1)=="*") s = 1;
  if(str.SubString(p,1)=="/") s = 2;
  i1 = ExtractNumber(str, false, p);
  i2 = ExtractNumber(str, true, p);
  AnsiString x1, x2;
  x1 = str.SubString(i1, p-i1);
  x2 = str.SubString(p+1, i2-p);
  //проверка деления на ноль
  double xd1 = x1.ToDouble(), xd2 = x2.ToDouble();
  bool z1 = IsZero(xd1,epsilon), z2 = IsZero(xd2,epsilon);
  if(s==2 && z2 && !z1)
  {
//   RELog->Lines->Add("Деление на ноль! "+x1+"/"+x2);
   if((xd1 > 0 && xd2 < 0) || (xd1 < 0 && xd2 > 0)) return NegInfinity;
   return Infinity;
  }
  if(s==2 && z2 && z1)
  {
//   RELog->Lines->Add("Неопределенность вида 0/0!");
   return NaN;
  }
  fy1 = Eval(x1);
  fy2 = Eval(x2);
  if(IsInfinite(fy1)||IsNan(fy1)) return fy1;
  if(IsInfinite(fy2)||IsNan(fy2)) return fy2;
  if(s==2 && IsZero(fy2,epsilon)) return ((fy1*fy2)>0 ? Infinity : -Infinity);
  switch(s)
  {
   case 1: z = fy1 * fy2; break;
   case 2: z = fy1 / fy2; break;
  }
  str.Delete(i1, i2-i1+1);
  str.Insert(AnsiString(z), i1);
  ff = true;
 }
 str = VeriSign(str);//Исправление рядом стоящих + и -
 if(ff)
 {
  if(IsNumber(str)) return str.ToDouble();
 }// goto StartAnalize;
 //Уровень 5 завершен.
 //Уровень 6. Сложение и вычитание.
 str = VeriSign(str);
 z = 0;
 i1 = 1;
 //-12313+123165-12313-545
 for(i2=2; i2<str.Length();)
 {
  i2 = ExtractNumber(str, true, i1);
  sub = str.SubString(i1, i2-i1+1);
  fy = Eval(sub);
  if(IsInfinite(fy)||IsNan(fy)) return fy;
  z += fy;//sub.ToDouble();
  i1 = i2+1;
 }
 y = z;
 return y;
}
//---------------------------------------------------------------------------
 
double Calc(AnsiString fun, double xin)
{
 AnsiString x = AnsiString(xin);
 int i;
 double y;
 if(xin > 0) x = "+" + x;
 
 AnsiString str = fun.LowerCase();
 
 while((i=str.AnsiPos("x"))!=0)
 {
  if(i>1 && i<str.Length() && str.SubString(i-1, 3) == "exp")
  {
   str.Delete(i-1,3);
   str.Insert("EXP",i-1);
   continue;
  }
  str.Delete(i,1);
  str.Insert(x,i);
 }
 str = str.LowerCase();
 
 while((i=str.AnsiPos("pi"))!=0)
 {
  str.Delete(i,2);
  str.Insert("3,141592653589793",i);//3.1415926535897932384626433832795028841971
 }
 
 str = VeriSign(str);
 y = Eval(str);
 return y;
}

#pragma once
#include <stack>
#include <iostream>
#include <cctype>
#include <exception>
 
template <class T>
struct Operations
{
    virtual ~Operations() {};
    virtual T Execute(const T & lhs, const T & rhs) = 0;
    const int class_priority = 0;
    virtual unsigned int get_priority() const { return 0; };
    //GOF
    static Operations<T>* Create_Operation(const char type_operation);
};
 
template<class T>
struct Minus : public Operations<T>
{
    virtual T Execute(const T & lhs, const T & rhs) { return lhs - rhs; };
    const int class_priority = 0;
    unsigned int get_priority() const { return class_priority; }
};
 
template<class T>
struct Plus : public Operations<T>
{
    virtual T Execute(const T & lhs, const T & rhs) { return lhs + rhs; };
    const int class_priority = 0;
    unsigned int get_priority() const { return class_priority; }
};
 
template<class T>
struct Division : public Operations<T>
{
    virtual T Execute(const T & lhs, const T & rhs)
    {
        if (rhs == 0)
            throw std::runtime_error("division by zero");
        else
            return lhs / rhs;
    };
 
    const int class_priority = 1;
    unsigned int get_priority() const { return class_priority; }
 
};
 
template<class T>
struct Multiplication : public Operations<T>
{
    virtual T Execute(const T & lhs, const T & rhs) { return (lhs * rhs); }
    const int class_priority = 1;
    unsigned int get_priority() const { return class_priority; }
};
 
template <class T>
bool operator<(const Operations<T> &one_op, const Operations<T> &sec_op)
{
    //return one_op.class_priority < sec_op.class_priority;
    return one_op.get_priority() < sec_op.get_priority();
};
 
//call this function in "main"
void Calculate(std::string& ss);
 
void one_operation(std::stack<double>& numbers, Operations<double> &operation);
 
template <class T>
Operations<T>* Operations<T>::Create_Operation(const char type_operation)
{
    Operations<T>* ptr;
    switch (type_operation)
    {
        case '+': { ptr = new Plus<T>(); break; }
        case '-': { ptr = new Minus<T>(); break; }
        case '*': { ptr = new Multiplication<T>(); break; }
        case '/': { ptr = new Division<T>(); break; }
        default:
        { throw std::runtime_error("Error: unexpected character"); break; }
    }
        return ptr;
}

#include "Operations.h"
 
void one_operation(std::stack <double>& numbers,  Operations<double> &op)
{
    const double second = numbers.top();
    numbers.pop();
    const double first = numbers.top();
    numbers.pop();
 
    numbers.push(op.Execute(first, second));
 
}
 
void Calculate(std::string& tstring)
{
    std::stack<Operations<double>*> operations;
    std::stack<double> numbers; 
    Operations<double>* operation = 0;
 
    for (char ch : tstring)
    {       
        if (isdigit(ch))
        {
            numbers.push(ch - '0');
            continue;
        }
        
        try
            {
                operation = Operations<double>::Create_Operation(ch);
            }
        catch(std::exception &e)
            {
                std::cerr<<e.what() << std::endl;
            }
 
        while (!operations.empty() && *operation < *operations.top())
            {
                one_operation(numbers, *operations.top());
                operations.pop();
            };
    
            operations.push(operation);                 
        
    }
    //считаем...
    while (!operations.empty())
    {
        operation = operations.top();
        operations.pop();
        one_operation(numbers, *operation);
    }
 
    double result = numbers.top();
    std::cout << "result:" << result << std::endl;
 
}

#include <sstream>
#include <conio.h>
#include "Operations.h"
 
using namespace std;
 
int main()
{
    string ss;
    while (true)
    {
        getline(cin, ss);
 
        try
        {
            Calculate(ss);
        }
        catch (exception& e)
        {
            cerr << e.what() << endl;
        }
 
        _getch();
    }
    return 0;
}