问题出在数学表达式求值中的小数转换上。

huangapple
go评论186阅读模式
英文:

Problem with decimal convertion in Math Expression Evaluator

问题

我正在使用C#实现一个数学表达式计算器，但无法使用十进制数，例如，如果我输入"3.4"，程序会将其视为"34"。如果使用逗号如"3,4"，问题也是一样的。

我已经尝试强制代码使用"en-US"的全球化，但没有成功。我还尝试了不同的解析方法，试图将字符串转换为浮点数，但也没有成功。

英文:

I'm implementing a math expression evaluator in C# but I has not able to use decimal numbers, like, if I enter "3.4" the program consider it as "34". The problem is the same if use coma like "3,4".

  3.         static void EvaluateInput(string input)
  4.         {
  5.             string[] parts = input.Split('=');
  6.             if (parts.Length == 2)
  7.             {
  8.                 string variableName = parts[0].Trim();
  9.                 if (IsValidVariableName(variableName))
  10.                 {
  11.                     string expression = parts[1].Trim();
  13.                     double result = SolveExpression(expression);
  14.                     variables[variableName] = SolveExpression(expression);
  15.                     lastResult = result;
  17.                     Console.WriteLine($"{variableName} = {result}");
  18.                 }
  19.                 else
  20.                 {
  21.                     Console.WriteLine("Invalid variable name. Use lowercase letters.");
  22.                 }
  23.             }
  24.             else
  25.             {
  26.                 double result = SolveExpression(input);
  27.                 lastResult = result;
  28.                 Console.WriteLine($"  = {result}");
  29.             }
  30.         }
  32.         static bool IsValidVariableName(string variableName)
  33.         {
  34.             return !string.IsNullOrEmpty(variableName) && variableName.Length == 1 && char.IsLower(variableName[0]);
  35.         }
  37.         static double SolveExpression(string expression)
  38.         {
  39.             expression = expression.Replace(',', '.');
  41.             foreach (var constant in constants)
  42.             {
  43.                 expression = expression.Replace(constant.Key, constant.Value.ToString(CultureInfo.InvariantCulture));
  44.             }
  46.             expression = Regex.Replace(expression, @"(?<=[^\d\.])-", "-");
  47.             expression = Regex.Replace(expression, @"(?<=\d)-", " -");
  48.             string[] tokens = TokenizeExpression(expression);
  50.             Stack<string> operators = new Stack<string>();
  51.             Stack<double> values = new Stack<double>();
  53.             foreach (string token in tokens)
  54.             {
  55.                 if (double.TryParse(token, out double number))
  56.                 {
  57.                     values.Push(number);
  58.                 }
  59.                 else if (IsValidVariableName(token))
  60.                 {
  61.                     if (variables.ContainsKey(token))
  62.                     {
  63.                         values.Push(variables[token]);
  64.                     }
  65.                     else
  66.                     {
  67.                         throw new InvalidOperationException($"Undefined variable: {token}");
  68.                     }
  69.                 }
  71.                 else if (IsOperator(token))
  72.                 {
  73.                     while (operators.Count > 0 && Priority(operators.Peek()) >= Priority(token))
  74.                     {
  75.                         if (operators.Peek() == "(")
  76.                             break;
  78.                         if (values.Count >= 2)
  79.                         {
  80.                             double val2 = values.Pop();
  81.                             double val1 = values.Pop();
  82.                             string op = operators.Pop();
  83.                             values.Push(ApplyOperator(op, val1, val2));
  84.                         }
  85.                         else
  86.                         {
  87.                             break;
  88.                         }
  89.                     }
  90.                     operators.Push(token);
  91.                 }
  92.                 else if (token == "(")
  93.                 {
  94.                     operators.Push(token);
  95.                 }
  96.                 else if (token == ")")
  97.                 {
  98.                     while (operators.Peek() != "(")
  99.                     {
  100.                         double val2 = values.Pop();
  101.                         double val1 = values.Pop();
  102.                         string op = operators.Pop();
  103.                         values.Push(ApplyOperator(op, val1, val2));
  104.                     }
  105.                     operators.Pop();
  106.                 }
  107.             }
  109.             while (operators.Count > 0)
  110.             {
  111.                 if (values.Count >= 2)
  112.                 {
  113.                     double val2 = values.Pop();
  114.                     double val1 = values.Pop();
  115.                     string op = operators.Pop();
  116.                     values.Push(ApplyOperator(op, val1, val2));
  117.                 }
  118.                 else
  119.                 {
  120.                     break;
  121.                 }
  122.             }
  124.             return values.Count > 0 ? values.Pop() : 0;
  125.         }
  127.         static string[] TokenizeExpression(string expression)
  128.         {
  129.             List<string> tokens = new List<string>();
  130.             string currentToken = "";
  132.             for (int i = 0; i < expression.Length; i++)
  133.             {
  134.                 char c = expression[i];
  136.                 if (char.IsDigit(c) || c == '.' || c == ',')
  137.                 {
  138.                     currentToken += c;
  139.                 }
  140.                 else
  141.                 {
  142.                     if (!string.IsNullOrEmpty(currentToken))
  143.                     {
  144.                         if (double.TryParse(currentToken.Replace(',', '.'), NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedNumber))
  145.                         {
  146.                             tokens.Add(parsedNumber.ToString(CultureInfo.InvariantCulture));
  147.                         }
  148.                         else
  149.                         {
  150.                             tokens.Add(currentToken);
  151.                         }
  152.                         currentToken = "";
  153.                     }
  155.                     if (IsOperator(c.ToString()) || c == '(' || c == ')')
  156.                     {
  157.                         tokens.Add(c.ToString());
  158.                     }
  159.                     else if (char.IsLetter(c))
  160.                     {
  161.                         currentToken = c.ToString();
  162.                     }
  163.                 }
  164.             }
  166.             if (!string.IsNullOrEmpty(currentToken))
  167.             {
  168.                 if (double.TryParse(currentToken.Replace(',', '.'), NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedNumber))
  169.                 {
  170.                     tokens.Add(parsedNumber.ToString(CultureInfo.InvariantCulture));
  171.                 }
  172.                 else
  173.                 {
  174.                     tokens.Add(currentToken);
  175.                 }
  176.             }
  178.             return tokens.ToArray();
  179.         }
  181.         static bool IsOperator(string token)
  182.         {
  183.             return token == "+" || token == "-" || token == "*" || token == "/" || token == "^";
  184.         }
  186.         static int Priority(string op)
  187.         {
  188.             if (op == "^")
  189.                 return 3;
  190.             if (op == "*" || op == "/")
  191.                 return 2;
  192.             if (op == "+" || op == "-")
  193.                 return 1;
  194.             return 0;
  195.         }
  197.         static double ApplyOperator(string op, double a, double b)
  198.         {
  199.             switch (op)
  200.             {
  201.                 case "+": return a + b;
  202.                 case "-": return a - b;
  203.                 case "*": return a * b;
  204.                 case "/": return a / b;
  205.                 case "^": return Math.Pow(a, b);
  206.                 default: throw new ArgumentException($"Invalid operator: {op}");
  207.             }
  208.         }

I have tried to force the code to use "en-US" globalization but I no success. I also tried difference parses in sense to convert the string to a float number, also not succeed

答案1

得分: 0

尝试这样做：

  1. if (new Regex(@"\d+(\.\d+)?").IsMatch(token))
  2. {
  3.   values.Push(double.Parse(token, CultureInfo.InvariantCulture));
  4. }

其他的 TryParse 也可能需要更改。

英文:

Instead of doing:

  1. if (double.TryParse(token, out double number))
  2. {
  3.   values.Push(number);
  4. }

try this:

  1. if (new Regex(@"\d+(\.\d+)?").IsMatch(token))
  2. {
  3.   values.Push(double.Parse(token, CultureInfo.InvariantCulture));
  4. }

Other TryParses might also need changing.

huangapple
  • 本文由 发表于 2023年8月11日 03:54:45
  • 转载请务必保留本文链接：https://go.coder-hub.com/76878929.html
  • c#
  • evaluator
  • expression
  • math
  • parsing
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定