Pastebin.vip

C\

From , 5 Years ago, written in C#, viewed 186 times.
URL https://pastebin.vip/view/6c2e4991
  1. public class ExpressionHelper
  2.     {
  3.         public double CalculateByExpression(string expression)
  4.         {
  5.             Dictionary<string, Fraction> dic = new Dictionary<string, Fraction>();
  6.             double result = 0D;
  7.             int index = 0;
  8.             string key = string.Empty;
  9.             string value = string.Empty;
  10.             double num = 0D;
  11.             string pattern = string.Empty;
  12.             string option = string.Empty;
  13.             //step1 去除表达式里的空格
  14.             expression = Regex.Replace(expression, @"\s+", string.Empty);
  15.             //step2 替换第一个数字为分数表示
  16.             pattern = @"^(\d+(\.\d+)?)";
  17.             Match m = Regex.Match(expression, pattern);
  18.             if (m.Success)
  19.             {
  20.                 value = m.Groups[1].Value;
  21.                 num = double.Parse(value);
  22.                 key = string.Format("F{0}", index++);
  23.                 dic[key] = new Fraction
  24.                 {
  25.                     Denominator = 1D,
  26.                     Element = num
  27.                 };
  28.                 expression = Regex.Replace(expression, pattern, key);
  29.             }
  30.             //step3 替换紧贴括号的值为分数表示
  31.             pattern = @"\((\d+(\.\d+)?)";
  32.             m = Regex.Match(expression, pattern);
  33.             while (m.Success)
  34.             {
  35.                 value = m.Groups[1].Value;
  36.                 num = double.Parse(value);
  37.                 key = string.Format("F{0}", index++);
  38.                 dic[key] = new Fraction
  39.                 {
  40.                     Denominator = 1D,
  41.                     Element = num
  42.                 };
  43.                 expression = expression.Replace(m.Value, "(" + key);
  44.                 m = Regex.Match(expression, pattern);
  45.             }
  46.             //step4 替换+-*/后面跟的值为分数表示
  47.             pattern = @"(\+|\-|\*|\/)(\d+(\.\d+)?)";
  48.             m = Regex.Match(expression, pattern);
  49.             while (m.Success)
  50.             {
  51.                 option = m.Groups[1].Value;
  52.                 value = m.Groups[2].Value;
  53.                 num = double.Parse(value);
  54.                 key = string.Format("F{0}", index++);
  55.                 dic[key] = new Fraction
  56.                 {
  57.                     Denominator = 1D,
  58.                     Element = num
  59.                 };
  60.                 expression = expression.Replace(m.Value, option + key);
  61.                 m = Regex.Match(expression, pattern);
  62.             }
  63.  
  64.             //step5 计算乘除和括号运算
  65.             MatchCollection matchs = null;
  66.             while (Regex.IsMatch(expression, @"\(|\)|\*\/"))
  67.             {
  68.                 pattern = @"(F\d+)(\*|\/)(F\d+)";
  69.                 while (Regex.IsMatch(expression, pattern))
  70.                 {
  71.                     m = Regex.Match(expression, pattern);
  72.                     key = m.Groups[1].Value;
  73.                     Fraction f1 = dic[key];
  74.                     key = m.Groups[3].Value;
  75.                     Fraction f2 = dic[key];
  76.                     option = m.Groups[2].Value;
  77.                     Fraction f = Calculate(f1, f2, option);
  78.                     key = string.Format("F{0}", index++);
  79.                     dic[key] = f;
  80.                     expression = expression.Replace(m.Value, key);
  81.  
  82.                     while (Regex.IsMatch(expression, @"\(F\d+\)"))
  83.                     {
  84.                         m = Regex.Match(expression, @"\((F\d+)\)");
  85.                         expression = expression.Replace(m.Value, m.Groups[1].Value);
  86.                     }
  87.                 }
  88.  
  89.                 //step3 计算括号里的值，并替换掉括号
  90.                 pattern = @"\((F\d+)(\+|\-)(F\d+)";
  91.                 while (Regex.IsMatch(expression, pattern))
  92.                 {
  93.                     m = Regex.Match(expression, pattern);
  94.                     key = m.Groups[1].Value;
  95.                     Fraction f1 = dic[key];
  96.                     key = m.Groups[3].Value;
  97.                     Fraction f2 = dic[key];
  98.                     option = m.Groups[2].Value;
  99.                     Fraction f = Calculate(f1, f2, option);
  100.                     key = string.Format("F{0}", index++);
  101.                     dic[key] = f;
  102.                     expression = expression.Replace(m.Value, "(" + key);
  103.                     while (Regex.IsMatch(expression, @"\(F\d+\)"))
  104.                     {
  105.                         m = Regex.Match(expression, @"\((F\d+)\)");
  106.                         expression = expression.Replace(m.Value, m.Groups[1].Value);
  107.                     }
  108.                 }
  109.             }
  110.  
  111.             //step4 重复step2 计算乘除运算
  112.             pattern = @"(F\d+)(\*|\/)(F\d+)";
  113.             option = string.Empty;
  114.             while (Regex.IsMatch(expression, pattern))
  115.             {
  116.                 matchs = Regex.Matches(expression, pattern);
  117.                 foreach (Match match in matchs)
  118.                 {
  119.                     key = match.Groups[1].Value;
  120.                     Fraction f1 = dic[key];
  121.                     key = match.Groups[3].Value;
  122.                     Fraction f2 = dic[key];
  123.                     option = match.Groups[2].Value;
  124.                     Fraction f = Calculate(f1, f2, option);
  125.                     key = string.Format("F{0}", index++);
  126.                     dic[key] = f;
  127.                     expression = expression.Replace(match.Value, key);
  128.                 }
  129.             }
  130.  
  131.             //step5 重复step3 计算加减运算
  132.             pattern = @"(F\d+)(\+|\-)(F\d+)";
  133.             while (Regex.IsMatch(expression, pattern))
  134.             {
  135.                 matchs = Regex.Matches(expression, pattern);
  136.                 foreach (Match match in matchs)
  137.                 {
  138.                     key = match.Groups[1].Value;
  139.                     Fraction f1 = dic[key];
  140.                     key = match.Groups[3].Value;
  141.                     Fraction f2 = dic[key];
  142.                     option = match.Groups[2].Value;
  143.                     Fraction f = Calculate(f1, f2, option);
  144.                     key = string.Format("F{0}", index++);
  145.                     dic[key] = f;
  146.                     expression = expression.Replace(match.Value, key);
  147.                 }
  148.             }
  149.  
  150.             //step6 最后一步 计算结果
  151.             key = string.Format("F{0}", index - 1);
  152.             Fraction fraction = dic[key];
  153.             result = fraction.Element / fraction.Denominator;
  154.             return result;
  155.         }
  156.  
  157.         /// <summary>
  158.         /// 计算两个分数的加减乘除，并返回一个分数表示
  159.         /// </summary>
  160.         /// <param name="expression"></param>
  161.         /// <returns></returns>
  162.         private Fraction Calculate(Fraction f1, Fraction f2, string option)
  163.         {
  164.             Fraction result = new Fraction();
  165.             double dencominator = 0D;
  166.             switch (option)
  167.             {
  168.                 case "+":
  169.                     dencominator = CalculateLeaseCommonMultiple(f1.Denominator, f2.Denominator);
  170.                     f1.Element = (dencominator / f1.Denominator) * f1.Element;
  171.                     f2.Element = (dencominator / f2.Denominator) * f2.Element;
  172.                     result.Denominator = dencominator;
  173.                     result.Element = f1.Element + f2.Element;
  174.                     break;
  175.                 case "-":
  176.                     dencominator = CalculateLeaseCommonMultiple(f1.Denominator, f2.Denominator);
  177.                     f1.Element = (dencominator / f1.Denominator) * f1.Element;
  178.                     f2.Element = (dencominator / f2.Denominator) * f2.Element;
  179.                     result.Denominator = dencominator;
  180.                     result.Element = f1.Element - f2.Element;
  181.                     break;
  182.                 case "*":
  183.                     dencominator = f1.Denominator * f2.Denominator;
  184.                     result.Denominator = dencominator;
  185.                     result.Element = f1.Element * f2.Element;
  186.                     break;
  187.                 case "/":
  188.                     dencominator = f1.Denominator * f2.Element;
  189.                     result.Denominator = dencominator;
  190.                     result.Element = f1.Element * f2.Denominator;
  191.                     break;
  192.             }
  193.             return result;
  194.         }
  195.  
  196.         /// <summary>
  197.         /// 计算最小公倍数
  198.         /// </summary>
  199.         /// <param name="d1"></param>
  200.         /// <param name="d2"></param>
  201.         /// <returns></returns>
  202.         private double CalculateLeaseCommonMultiple(double d1, double d2)
  203.         {
  204.             double result = Math.Max(d1, d2);
  205.             double i = 1D;
  206.             do
  207.             {
  208.                 if (result % d1 == 0D
  209.                     && result % d2 == 0D)
  210.                 {
  211.                     break;
  212.                 }
  213.                 else
  214.                 {
  215.                     result *= (++i);
  216.                 }
  217.             } while (true);
  218.  
  219.             return result;
  220.         }
  221.     }
  222.  
  223.     /// <summary>
  224.     /// 分数类
  225.     /// </summary>
  226.     public struct Fraction
  227.     {
  228.         private double m_Denominator;
  229.         private double m_Element;
  230.         /// <summary>
  231.         /// 分母
  232.         /// </summary>
  233.         public double Denominator
  234.         {
  235.             get
  236.             {
  237.                 return m_Denominator;
  238.             }
  239.             set
  240.             {
  241.                 if (value == 0)
  242.                 {
  243.                     throw new InvalidOperationException("分母不能为0");
  244.                 }
  245.                 m_Denominator = value;
  246.             }
  247.         }
  248.  
  249.         /// <summary>
  250.         /// 分子
  251.         /// </summary>
  252.         public double Element
  253.         {
  254.             get
  255.             {
  256.                 return m_Element;
  257.             }
  258.             set
  259.             {
  260.                 m_Element = value;
  261.             }
  262.         }
  263.     }
  264.  
  265.  
  266. //csharp/7133

Reply to "C\"

Here you can reply to the paste above

captcha

https://burned.cc - Burn After Reading Website
Powered by Pastebin.vip paste tool since 2022!