fork(1) download
copy 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import java.math.BigDecimal;
  4. import java.math.RoundingMode;
  5. import java.util.EmptyStackException;
  6. import java.util.Stack;
  7.  
  8. /**
  9.  * Класс калькулятора. Калькулятор со скобками.
  10.  * <p>
  11.  * !!!ВНИМАНИЕ!! Операторы не должны содеражать части названий друг друга.
  12.  * Например, не допускается делать операторы вида "tan" и "ctan". ctan содержит tan. Так нельзя.
  13.  * <p>
  14.  * Чтобы добавить новый оператор, надо внести изменения в 4 места:
  15.  * - REGEX_OPERATORS
  16.  * - getPriority()
  17.  * - isLeftAssociative()
  18.  * - calculateReversePolishNotation()
  19.  */
  20. class Calculator
  21. {
  22.     /**
  23.      * Регулярка для проверки числа типа double.
  24.      */
  25.     public static final String REGEX_DOUBLE = "^-?(0|[1-9][0-9]*)(\\.[0-9]+)*(E-?[1-9][0-9]*)?$";
  26.  
  27.     /**
  28.      * Регулярка для определения операторов.
  29.      */
  30.     protected static String REGEX_OPERATORS = "^(\\+|-|\\*|/|\\^|±|sin|cos|tan|ctg|ln)$";
  31.     //------------------------------------------------------------------------------------------------------------------
  32.  
  33.     /**
  34.      * Исключение, которое бросает калькулятор при ошибках.
  35.      */
  36.     public static class CalculatorErrorException extends Exception
  37.     {
  38.         public CalculatorErrorException (String _msg)
  39.         {
  40.             super (_msg);
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * Это исключение выдается, когда результат вычисления равен "NaN".
  46.      * Например, при делении на ноль или при возведении отрицательного числа в дробную степень.
  47.      */
  48.     public static class CalculatorNaNException extends Exception
  49.     {
  50.         public CalculatorNaNException (String _msg)
  51.         {
  52.             super (_msg);
  53.         }
  54.     }
  55.  
  56.     //------------------------------------------------------------------------------------------------------------------
  57.  
  58.     /**
  59.      * Вычислить значение переданного выражения.
  60.      *
  61.      * @param _expression Выражение в нормальной форме.
  62.      *
  63.      * @return
  64.      *
  65.      * @throws Exception Бросает исключения в случае синтаксических ошибок или неправильности скобочной структуры.
  66.      */
  67.     public static double calculateNormal (String _expression) throws CalculatorErrorException, CalculatorNaNException
  68.     {
  69.         return calculateReversePolishNotation (convertInfixToRPN (_expression));
  70.     }
  71.  
  72.     /**
  73.      * Вычислить значение уравнения.
  74.      *
  75.      * @param _expressionNormal Строка с выражением. Может содержать символ "x".
  76.      * @param _x                Значение параметра "x". Символ "x" из строки будет заменен на это значение.
  77.      *
  78.      * @return
  79.      *
  80.      * @throws CalculatorErrorException
  81.      */
  82.     public static double calculateNormalEquation (String _expressionNormal, double _x) throws CalculatorErrorException, CalculatorNaNException
  83.     {
  84.         _expressionNormal = _expressionNormal.replaceAll ("[xX]", "(" + _x + ")");
  85.  
  86.         return calculateReversePolishNotation (convertInfixToRPN (_expressionNormal));
  87.     }
  88.  
  89.     //------------------------------------------------------------------------------------------------------------------
  90.     // МЕТОДЫ КОНВЕРТИРОВАНИЯ INFIX TO RPN, А ТАКЖЕ ВЫЧИСЛЕНИЕ RPN.
  91.     //------------------------------------------------------------------------------------------------------------------
  92.  
  93.     /**
  94.      * Преобразовать инфиксную скобочную запись арифметического выражения в обратную польскую нотацию.
  95.      *
  96.      * @param _exp Выражение в обычной инфиксной скобочной форме..
  97.      *
  98.      * @return Выражение в форме RPN.
  99.      */
  100.     public static String convertInfixToRPN (String _exp) throws CalculatorErrorException, CalculatorNaNException
  101.     {
  102.         // Стек. На нем будем вычислять.
  103.         Stack<String> stack = new Stack<String> ();
  104.  
  105.         // Итоговая строка
  106.         String result = "";
  107.  
  108.         String exp = formatExpToSystemView (_exp);
  109. //        System.out.println ("ToRPN: Выражение в инфиксной форме (User):   \"" + _exp + "\".");
  110. //        System.out.println ("ToRPN: Выражение в инфиксной форме (System): \"" + exp + "\".");
  111.         if (!checkBracketsStructure (exp))
  112.         {
  113.             throw new CalculatorErrorException ("ToRPN: Структура скобок неверна!");
  114.         }
  115.  
  116.         // Проходимся по символам.
  117.         String[] chars = exp.trim ().split ("\\s");
  118.         for (String token : chars)
  119.         {
  120.             //----------------------------
  121.             if (isNumber (token))
  122.             {
  123.                 result += token + " ";
  124.             }
  125.             else if (token.equals ("("))
  126.             {
  127.                 stack.push (token);
  128.             }
  129.             else if (token.equals (")"))
  130.             {
  131.                 try
  132.                 {
  133.                     while (!stack.peek ().equals ("("))
  134.                     {
  135.                         result += stack.pop () + " ";
  136.                     }
  137.                     stack.pop ();// Извлекаем открывающую скобку, не добавляя ее в выходную строку.
  138.                 }
  139.                 catch (EmptyStackException e)
  140.                 {
  141.                     throw new CalculatorErrorException ("ToRPN: Синтаксическая ошибка при конвертации в RPN: неверный разделитель. Выражение: \"" + exp + "\".");
  142.                 }
  143.             }
  144.             else
  145.             {
  146.                 while (!stack.isEmpty ())
  147.                 {
  148.                     // Если на вершине стека оператор и приоритет текущего оператора меньше чем топового
  149.                     // - кладем топовый в вывод.
  150.                     if (isOperator (stack.peek ()) &&
  151.                             ((isLeftAssociative (token) && (getPriority (token) <= getPriority (stack.peek ())))
  152.                                     || (!isLeftAssociative (token) && (getPriority (token) < getPriority (stack.peek ())))))
  153.                     {
  154.                         // Кладем топовый оператор в вывод.
  155.                         result += stack.pop () + " ";
  156.                     }
  157.                     else
  158.                     {
  159.                         break;
  160.                     }
  161.                 }
  162.  
  163.                 // Помещаем текущий оператор в стек.
  164.                 stack.push (token);
  165.             }
  166.         }
  167.  
  168.         // Выталкиваем оставшиеся элементы из стека.
  169.         String stackLost = "";
  170.         while (!stack.isEmpty ())
  171.         {
  172.             stackLost += stack.pop () + " ";
  173.         }
  174.         result += stackLost;
  175.  
  176. //        System.out.println ("ToRPN: Проверка. Стек:                       \"" + stackLost + "\".");
  177. //        System.out.println ("ToRPN: Результат в ОПН:                      \"" + result + "\".");
  178. //        System.out.println ("ToRPN: Результат вычисления ОПН:             \"" + calculateReversePolishNotation (result) + "\".");
  179. //        System.out.println ();
  180.  
  181.         return result;
  182.     }
  183.  
  184.     /**
  185.      * Выполнить вычисление в Обратной Польской Нотации.
  186.      *
  187.      * @param _exp
  188.      *
  189.      * @return Результат вычисления.
  190.      */
  191.     public static double calculateReversePolishNotation (String _exp) throws CalculatorErrorException, CalculatorNaNException
  192.     {
  193.         // Стек. На нем будем вычислять.
  194.         Stack<Double> stack = new Stack<Double> ();
  195.  
  196.         // Грузим символы.
  197.         String[] chars = _exp.split ("\\s");
  198.  
  199.         for (String ch : chars)
  200.         {
  201.             double op1;
  202.             double op2;
  203.  
  204.             try
  205.             {
  206.                 switch (ch)
  207.                 {
  208.                     // Бинарные операторы:
  209.                     case "+":
  210.                         op1 = stack.pop ();
  211.                         op2 = stack.pop ();
  212.                         stack.push (op2 + op1);
  213.                         break;
  214.                     case "-":
  215.                         op1 = stack.pop ();
  216.                         op2 = stack.pop ();
  217.                         stack.push (op2 - op1);
  218.                         break;
  219.                     case "*":
  220.                         op1 = stack.pop ();
  221.                         op2 = stack.pop ();
  222.                         stack.push (op1 * op2);
  223.                         break;
  224.                     case "/":
  225.                         op1 = stack.pop ();
  226.                         op2 = stack.pop ();
  227.                         stack.push (op2 / op1);
  228.                         break;
  229.  
  230.                     // Унарные операторы:
  231.                     case "^":
  232.                         op1 = stack.pop ();
  233.                         op2 = stack.pop ();
  234.                         stack.push (Math.pow (op2, op1));
  235.                         break;
  236.                     case "±":
  237.                         op1 = stack.pop ();
  238.                         stack.push (-1 * op1);
  239.                         break;
  240.                     case "sin":
  241.                         op1 = stack.pop ();
  242.                         stack.push (Math.sin (op1));
  243.                         break;
  244.                     case "cos":
  245.                         op1 = stack.pop ();
  246.                         stack.push (Math.cos (op1));
  247.                         break;
  248.                     case "tan":
  249.                         op1 = stack.pop ();
  250.                         stack.push (Math.tan (op1));
  251.                         break;
  252.                     case "ctg":
  253.                         op1 = stack.pop ();
  254.                         stack.push (1.0 / Math.tan (op1));
  255.                         break;
  256.                     case "ln":
  257.                         op1 = stack.pop ();
  258.                         stack.push (Math.log (op1));
  259.                         break;
  260.  
  261.                     default:
  262.                         if (!isNumber (ch))
  263.                         {
  264.                             throw new CalculatorErrorException ("CalculateRPN: \"" + ch + "\" - неверный формат операнда!");
  265.                         }
  266.                         else
  267.                         {
  268.                             stack.push (Double.valueOf (ch));
  269.                         }
  270.                         break;
  271.                 }
  272.             }
  273.             catch (EmptyStackException e)
  274.             {
  275.                 throw new CalculatorErrorException ("CalculateRPN: Синтаксическая ошибка при вычислении RPN: неверный разделитель. Выражение: \"" + _exp + "\".");
  276.             }
  277.         }
  278.  
  279.         double result = stack.pop ();
  280.  
  281.         if (String.valueOf (result).equals ("NaN") || String.valueOf (result).equals ("Infinity") || String.valueOf (result).equals ("-Infinity"))
  282.         {
  283.             throw new CalculatorNaNException ("CalculateRPN: Математическая ошибка. Результат равен \"NaN/Infinity/-Infinity \".");
  284.         }
  285.  
  286.         return result;
  287.     }
  288.     //------------------------------------------------------------------------------------------------------------------
  289.  
  290.     /**
  291.      * Получить приоритет оператора.
  292.      * <p>
  293.      * Операторы:
  294.      * Приоритет Оператор Ассоциативность
  295.      * 4 ! правая
  296.      * 3 * / % левая
  297.      * 2 + - левая
  298.      * 1 = левая
  299.      *
  300.      * @param _op
  301.      *
  302.      * @return
  303.      */
  304.     protected static int getPriority (String _op)
  305.     {
  306.         switch (_op)
  307.         {
  308.             case "±":
  309.                 return 5;
  310.             case "!":
  311.             case "^":
  312.             case "sin":
  313.             case "cos":
  314.             case "tan":
  315.             case "ctg":
  316.             case "ln":
  317.                 return 4;
  318.             case "*":
  319.             case "/":
  320.                 return 3;
  321.             case "+":
  322.             case "-":
  323.                 return 2;
  324.             case "(":
  325.             case ")":
  326.                 return 1;
  327.             default:
  328.                 return -1;
  329.         }
  330.     }
  331.  
  332.     protected static boolean isLeftAssociative (String _op)
  333.     {
  334.         switch (_op)
  335.         {
  336.             case "±":
  337.             case "!":
  338.             case "^":
  339.             case "sin":
  340.             case "cos":
  341.             case "tan":
  342.             case "ctg":
  343.             case "ln":
  344.                 return false;
  345.             default:
  346.             case "*":
  347.             case "/":
  348.             case "+":
  349.             case "-":
  350.                 return true;
  351.         }
  352.     }
  353.  
  354.     /**
  355.      * Проверить правильность скобочной структуры.
  356.      *
  357.      * @param _exp Выражение со скобками.
  358.      *
  359.      * @return
  360.      */
  361.     protected static boolean checkBracketsStructure (String _exp)
  362.     {
  363.         int number = -1;
  364.         int a      = 0;
  365.  
  366.         while (++number < _exp.length ())
  367.         {
  368.             String ch = String.valueOf (_exp.charAt (number));
  369.             if (ch.equals ("("))
  370.             {
  371.                 ++a;
  372.             }
  373.             else if (ch.equals (")") && --a < 0)
  374.             {
  375.                 break;
  376.             }
  377.         }
  378.  
  379.         return (a == 0);
  380.     }
  381.  
  382.  
  383.     //------------------------------------------------------------------------------------------------------------------
  384.  
  385.     /**
  386.      * Является ли эта строка числом? Точнее, является ли она допустимым оператором.
  387.      *
  388.      * @param _str
  389.      *
  390.      * @return
  391.      */
  392.     protected static boolean isNumber (String _str)
  393.     {
  394.         return _str.matches (REGEX_DOUBLE);
  395.     }
  396.  
  397.     /**
  398.      * Является ли эта строка оператором?
  399.      *
  400.      * @param _str
  401.      *
  402.      * @return
  403.      */
  404.     protected static boolean isOperator (String _str)
  405.     {
  406.         return _str.matches (REGEX_OPERATORS);
  407.     }
  408.  
  409.     /**
  410.      * Округлить число до заданных знаков после запятой.
  411.      *
  412.      * @param _num
  413.      * @param _scale
  414.      *
  415.      * @return
  416.      */
  417.     protected static double round (double _num, int _scale)
  418.     {
  419.         BigDecimal bd = new BigDecimal (_num).setScale (_scale, RoundingMode.HALF_UP);
  420.         return bd.doubleValue ();
  421.     }
  422.  
  423.     //------------------------------------------------------------------------------------------------------------------
  424.  
  425.     /**
  426.      * Форматировать выражение в системный вид - с пробельным разделением всех операторов и операндов.
  427.      *
  428.      * @param _exp
  429.      *
  430.      * @return
  431.      */
  432.     public static String formatExpToSystemView (String _exp)
  433.     {
  434.         return prepareOperatorsInString (_exp)
  435.                 .replaceAll ("([0-9])\\s*E\\s*-\\s*([0-9])", "$1E-$2")
  436.  
  437.                 .replaceAll ("\\s*([^ 0-9E\\)]+)\\s*-", " $1 ± ")
  438.                 .replaceAll ("^\\s*-\\s*([^-]+)", " ± $1 ")
  439.  
  440.                 .replaceAll ("\\s*\\(\\s*", " ( ")
  441.                 .replaceAll ("\\s*\\)\\s*", " ) ")
  442.                 .replaceAll ("\\s+", " ")
  443.                 .trim ();
  444.     }
  445.  
  446.     /**
  447.      * Расставить пробелы вокруг всех встреченных в строке операторов.
  448.      *
  449.      * @param _exp
  450.      *
  451.      * @return
  452.      */
  453.     protected static String prepareOperatorsInString (String _exp)
  454.     {
  455.         String   result = _exp;
  456.         String[] ops    = REGEX_OPERATORS.substring (2, REGEX_OPERATORS.length () - 2).split ("\\|");
  457.  
  458.         for (String op : ops)
  459.         {
  460.             result = result.replaceAll ("\\s*" + op + "\\s*", " " + op + " ");
  461.         }
  462.  
  463.         return result;
  464.     }
  465.  
  466.     public static String formatExpToBeautifulView (String _exp)
  467.     {
  468.         return formatExpToSystemView (_exp)
  469.                 .replaceAll ("\\s*\\(\\s*", " (")
  470.                 .replaceAll ("\\s*\\)\\s*", ") ")
  471.  
  472.                 .replaceAll ("\\)\\s*\\)", "))")
  473.                 .replaceAll ("\\(\\s*\\(", "((")
  474.  
  475.                 .replaceAll ("±\\s*", "-");
  476.     }
  477. }
  478.  
  479.  
  480. /* Name of the class has to be "Main" only if the class is public. */
  481. class Ideone
  482. {
  483. 	public static void main (String[] args) throws java.lang.Exception
  484. 	{
  485. 		try
  486. 		{    
  487. 			String exp = "sin 0.4 - 2 * (3 / (ln tan 4) ^ cos 0.3)";
  488. 			System.out.println (Calculator.calculateNormal (exp));
  489. 		}
  490. 		catch (Calculator.CalculatorNaNException e)
  491. 		{
  492. 		    e.printStackTrace ();
  493. 		}
  494. 		catch (Calculator.CalculatorErrorException e)
  495. 		{
  496. 		    e.printStackTrace ();
  497. 		}
  498. 	}
  499. }
Success #stdin #stdout 0.05s 2184192KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
-37.189445145237336
https://ideone.com/IPHtov
language:
Java (HotSpot 12)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!