Math_func::function Class Reference

Математическая функция More...

#include <function.h>

Collaboration diagram for Math_func::function:

Public Member Functions
	function ()=default
	function (const function &)
	function (std::string _func_str)
	Инициализирует новый экземпляр function.
	~function ()=default
std::string	get_func_str () const
	Возвращает значение мат. функции в виде строки
bool	has_var () const
double	operator() (double x) const
	: Значение мат. функции
function &	operator= (const function &)

Public Attributes
const std::function< double(double)>	calculate
	Значение мат. функции
const std::function< double(double)>	differentiate
	Значение производной мат. функции

Private Member Functions
double	calc (double x) const
	Значение мат. функции
void	func_lexs_validation () const
	Проверяет вектор лексем от мат. функции на валидность
void	func_str_validation () const
	Проверяет мат. функцию в виде строки, на валидность
std::vector< std::string >	lexemes () const
std::vector< std::string >	reverse_polish () const

Private Attributes
std::string	func_str
	Мат. функция в виде строки
std::vector< std::string >	lexs
	Вектор лексем от мат. функции
std::vector< std::string >	rev_pol
	Вектор лексем, записанный в обратной польской нотации

Detailed Description

Математическая функция

Constructor & Destructor Documentation

function() [1/3]

Math_func::function::function ( )

default

function() [2/3]

Math_func::function::function

(

std::string

_func_str

)

Инициализирует новый экземпляр function.

Parameters

_func_str

строка, представляющая собой мат. функцию

    : func_str{spaces_deleted(_func_str)},
      lexs{lexemes()},
      rev_pol{reverse_polish()} {}

function() [3/3]

Math_func::function::function

(

const function &

func

)

    : func_str{func.func_str}, lexs{func.lexs}, rev_pol{func.rev_pol} {}

~function()

Math_func::function::~function ( )

default

Member Function Documentation

calc()

double Math_func::function::calc ( double x ) const

private

Значение мат. функции

Parameters

x

Returns

double

Стек, куда складываем уже посчитанные числа

Последний символ в стеке

Предпоследний символ в стеке (последний после удаления l)

Символ, обозначающий текущую лексему в обратной польской записи

                                    {
  /// @brief Стек, куда складываем уже посчитанные числа
  // IDK: а это точно так?
  stack<double> calced_numbs;
 
  // TODO: написать комментарии по работе этого цикла
 
  // раскрываем обратную польскую нотацию, подставляя x
  for (const auto& lex : rev_pol) {
    /// @brief Последний символ в стеке
    double l;
 
    /// @brief Предпоследний символ в стеке (последний после удаления l)
    double p;
 
    /// @brief Символ, обозначающий текущую лексему в обратной польской записи
    // (нужен для switch-case)
    char l_c = s_to_c(lex);
 
    if (c_in_s(l_c, math_func_chars)) {
      l = calced_numbs.top();  // запоминаем только последний
                               // (так как элем. мат. функции унарны)
      calced_numbs.pop();
      switch (l_c) {
        case c_sin:
          calced_numbs.push(sin(l));
          break;
        case c_cos:
          calced_numbs.push(cos(l));
          break;
        case c_tan:
          calced_numbs.push(tan(l));
          break;
        case c_exp:
          calced_numbs.push(exp(l));
          break;
        case c_ln:
          calced_numbs.push(log(l));
          break;
        case uminus:
          calced_numbs.push(-l);
          break;
      }
    } else if (c_in_s(l_c, math_oper_chars)) {
      l = calced_numbs.top();
      calced_numbs.pop();
      p = calced_numbs.top();  // также запоминаем предпоследний
                               // (так как мат. операции бинарны)
      calced_numbs.pop();
      switch (l_c) {
        case plus:
          calced_numbs.push(p + l);
          break;
        case minus:
          calced_numbs.push(p - l);
          break;
        case mul:
          calced_numbs.push(p * l);
          break;
        case divi:
          calced_numbs.push(p / l);
          break;
        case power:
          calced_numbs.push(pow(p, l));
          break;
      }
    } else {
      switch (l_c) {
        case number:
          calced_numbs.push(stod(lex));
          break;
        case var_x:
          calced_numbs.push(x);
          break;
        default:
          throw std::runtime_error("Oops");
          break;
      }
    }
 
    // получили математически недопустимое число
    if (std::isnan(calced_numbs.top()) || std::isinf(calced_numbs.top()))
      throw invalid_argument("violation of feasible region");
  }
 
  // последнее, что осталось в стеке после всех действий - и есть ответ
  return calced_numbs.top();
}

Here is the call graph for this function:

Here is the caller graph for this function:

func_lexs_validation()

void Math_func::function::func_lexs_validation ( ) const

private

Проверяет вектор лексем от мат. функции на валидность

Правильное использование элементарной мат. функций (типа exp, sin, ln), отсутствие лишних переменных

Exceptions

std::invalid_argument

в том случае, если ввод инвалиден

Вектор, со всеми разреш. лекс., обозначающими элем. мат. функции

Символ, обозначающий текущую лексему

Символ, обозначающий следующую лексему

                                          {
  /// @brief Вектор, со всеми разреш. лекс., обозначающими элем. мат. функции
  const vector<string> functions{"sin", "cos", "tan", "exp", "ln", "um"};
 
  for (size_t i = 0; i < lexs.size(); i++) {
    // string l = lexs[i];
    /// @brief Символ, обозначающий текущую лексему
    char l_c = s_to_c(lexs[i]);
 
    /// @brief Символ, обозначающий следующую лексему
    char n_c = ' ';
 
    // (вычисление этого символа)
    if (i < (lexs.size() - 1)) n_c = s_to_c(lexs[i + 1]);
 
    // FIXME: дальше какая-то дичь творится..
 
    // проверка использования постороннего имени
    if (isalpha(l_c) && !(is_double(lexs[i]))) {
      if (c_in_s(l_c, math_func_chars)) {
        size_t j = math_func_chars.find(l_c);
        if (lexs[i] != functions[j]) {
          if (lexs.size() > 1) {
            // если есть скобка, то это посторонняя элем. мат. функция
            if (lexs[i + 1] == "(")
              throw invalid_argument("invalid function name '" + lexs[i] + "'");
            else
              throw invalid_argument("extra variable '" + lexs[i] + "'");
          } else
            throw invalid_argument("extra variable '" + lexs[i] + "'");
        }
        // ситуации рода: tan | x + tan
        else if (l_c != uminus && (lexs.size() < 4 || i == lexs.size() - 1))
          throw invalid_argument("wrong function usage");
 
        // ситуация рода: x + tan + x
        else if (l_c != uminus && n_c != open_br)
          throw invalid_argument("wrong function usage");
      } else if (l_c != var_x)  // если имя начинается не с разрешенной буквы и
                                // не является x, то оно постороннее
        throw invalid_argument("extra variable '" + string{l_c} + "'");
 
      else if (l_c == var_x) {
        if (lexs.size() > 1 && i != lexs.size() - 1) {
          // если есть скобка, то это посторонняя элем. мат. функция
          // (ситуация рода: "x(x)")
          if (lexs[i + 1] == "(")
            throw invalid_argument("invalid function name '" + lexs[i] + "'");
        }
        // ситуация рода: "xx"
        if (lexs[i].size() > 1)
          throw invalid_argument("extra variable '" + lexs[i] + "'");
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

func_str_validation()

void Math_func::function::func_str_validation ( ) const

private

Проверяет мат. функцию в виде строки, на валидность

Правильное кол-во скобок, отсутствие лишних символов, правильное использование знаков, точек, цифр)

Exceptions

std::invalid_argument

в том случае, если ввод инвалиден

Строка со всеми разрешенными символами

Строка с разрешенными мат. операциями

Счетчик незакрытых скобочек

Текущий символ

Предыдущий символ

Следующий символ

Строка с почти всеми символами, которые могут быть возле цифры

Левый (предыдущий) символ валиден

Правый (следующий) символ валиден

                                         {
  // проверка на пустую строку
  if (func_str == "") throw invalid_argument("empty expression");
 
  /// @brief Строка со всеми разрешенными символами
  const string calc_chars = ".1234567890+-*/^()cosinexptal";
  /// @brief Строка с разрешенными мат. операциями
  const string math_oper_chars = "+-*/^";
 
  // проверка на количество скобочек
  if (count(func_str.begin(), func_str.end(), open_br) !=
      count(func_str.begin(), func_str.end(), closed_br))
    throw invalid_argument("brackets number mismatch");
 
  // первый и последний символы не должны быть знаками или точками
  // (кроме минуса спереди)
  if ((c_in_s(func_str[0], math_oper_chars + point) && func_str[0] != minus) ||
      c_in_s(func_str[func_str.size() - 1], math_oper_chars + point))
    throw invalid_argument("invalid syntax at edges");
 
  /// @brief Счетчик незакрытых скобочек
  int count_brackets = 0;
 
  // проходимся по всей строке
  for (size_t i = 0; i < func_str.size(); i++) {
    /// @brief Текущий символ
    char c = func_str[i];
 
    /// @brief Предыдущий символ
    char p_c = ' ';
 
    /// @brief Следующий символ
    char n_c = ' ';
 
    // (вычисление значений этих символов)
    if (i > 0) p_c = func_str[i - 1];
    if (i < (func_str.size() - 1)) n_c = func_str[i + 1];
 
    // проверка на отсутствие лишних символов
    if (!c_in_s(c, calc_chars)) {
      if (isalpha(c))
        throw invalid_argument("extra variable '" + string{c} + "'");
      else
        throw invalid_argument("unknown character '" + string{c} + "'");
    }
 
    // возле знака операции не должно быть других операций и точек,
    // а также открытой скобки слева или закрытой скобки справа
    // (минус на это мы не проверяем, так как он может быть унарный)
    if (c_in_s(c, math_oper_chars) && c != minus) {
      if ((c_in_s(p_c, math_oper_chars + point) ||
           c_in_s(n_c, math_oper_chars + point)) &&
          n_c != minus)  // но после знака минус стоять может
        throw invalid_argument("invalid syntax near sign");
 
      // минус не может стоять по обе стороны от знака
      else if (p_c == minus && n_c == minus)
        throw invalid_argument("invalid syntax near sign");
 
      // проверка на правильность скобок возле знака
      if (p_c == open_br || n_c == closed_br)
        throw invalid_argument("invalid brackets near sign");
    }
 
    // возле точки должны быть только числа
    if (c == point) {
      if ((!isdigit(p_c) || !isdigit(n_c)))
        throw invalid_argument("invalid syntax near point");
    }
 
    // считаем скобки
    else if (c == open_br) {
      count_brackets += 1;
      // и проверяем, что нету пустых
      if (n_c == closed_br) throw invalid_argument("empty brackets");
    } else if (c == closed_br) {
      count_brackets -= 1;
      // случай, когда после очередной закрытой скобки
      // - закрытых скобок оказывается больше
      if (count_brackets < 0) throw invalid_argument("extra bracket");
    }
 
    // возле числа должен стоять либо знак, либо точка, либо скобка
    // (при строке из одной цифры, эта проверка не подходит)
    else if (isdigit(c) && func_str.size() > 1) {
      /// @brief Строка с почти всеми символами, которые могут быть возле цифры
      // (почти, так как еще скобки с разных сторон, но мы их считаем далее)
      string valid_chars_near_digit = "0123456789" + math_oper_chars + point;
 
      /// @brief Левый (предыдущий) символ валиден
      // (у цифры слева может быть: цифра, точка, знак или открытая скобка)
      bool is_left_valid = 1;
 
      /// @brief Правый (следующий) символ валиден
      // (у цифры справа может быть: цифра, точка, знак или закрытая скобка)
      bool is_right_valid = 1;
 
      // (вычисление значений этих флагов)
      if (i == 0)
        is_right_valid = c_in_s(n_c, valid_chars_near_digit + closed_br);
      else if (i == func_str.size() - 1)
        is_left_valid = c_in_s(p_c, valid_chars_near_digit + open_br);
      else {
        is_right_valid = c_in_s(n_c, valid_chars_near_digit + closed_br);
        is_left_valid = c_in_s(p_c, valid_chars_near_digit + open_br);
      }
 
      // если хотя бы с одной стороны мы имеем не валидный символ
      if (!is_left_valid || !is_right_valid)
        throw invalid_argument("invalid syntax near digit");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_func_str()

std::string Math_func::function::get_func_str ( ) const

inline

Возвращает значение мат. функции в виде строки

Returns

std::string: строка

{ return func_str; }

Here is the caller graph for this function:

has_var()

bool Math_func::function::has_var

(

)

const

{ return c_in_s('x', func_str); }

Here is the call graph for this function:

lexemes()

vector< string > Math_func::function::lexemes ( ) const

private

Текущая лексема

Текущий символ строки

                                       {
  func_str_validation();
 
  vector<string> res;
 
  /// @brief Текущая лексема
  string lex;
 
  // TODO: написать комментарии по работе этого цикла
 
  for (size_t i = 0; i < func_str.size(); i++) {
    /// @brief Текущий символ строки
    char ch = func_str[i];
    switch (ch) {
      case minus: {
        if (lex.size() > 0) {
          res.push_back(lex);
          lex = "";
        }
        if (i == 0)
          res.push_back("um");
        else if (c_in_s(s_to_c(res[res.size() - 1]),
                        math_oper_chars + "(" + "u"))
          res.push_back("um");
        else
          res.push_back("-");
        break;
      }
      case open_br:
      case closed_br:
      case plus:
      case mul:
      case divi:
      case power: {
        if (lex.size() > 0) {
          res.push_back(lex);
          lex = "";
        }
        lex = ch;
        res.push_back(lex);
        lex = "";
        break;
      }
      case point:
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9': {
        if (lex.size() > 0 && !isdigit(lex[0])) {
          res.push_back(lex);
          lex = "";
        }
        lex += ch;
        break;
      }
      default: {
        if (!isblank(ch)) {
          if (lex.size() > 0 && isdigit(lex[0])) {
            res.push_back(lex);
            lex = "";
          }
          lex += ch;
        }
      }
    }
  }
  if (lex.size() > 0) res.push_back(lex);
  return (res);
}

Here is the call graph for this function:

operator()()

double Math_func::function::operator() ( double x ) const

inline

: Значение мат. функции

Parameters

x

Returns

double

{ return calc(x); }

Here is the call graph for this function:

operator=()

function & Math_func::function::operator=

(

const function &

func

)

                                                  {
  if (this != &func) {
    func_str = func.func_str;
    lexs = func.lexs;
    rev_pol = func.rev_pol;
  }
 
  return *this;
}

reverse_polish()

vector< string > Math_func::function::reverse_polish ( ) const

private

Вектор, куда записывается итоговая обратная польская запись

Стек с записанными операциями

Символ, обозначающий текущую лексему

Символ, обозначающий последний элемент в стеке с операциями

                                              {
  func_lexs_validation();
 
  /// @brief Вектор, куда записывается итоговая обратная польская запись
  vector<string> res;
 
  /// @brief Стек с записанными операциями
  // (нужен для хранения операций в правильном порядке)
  stack<string> st_oper;
  st_oper.push("\0");
 
  for (const auto& lex : lexs) {
    /// @brief Символ, обозначающий текущую лексему
    // (нужен для switch-case)
    char l_c = s_to_c(lex);
 
    /// @brief Символ, обозначающий последний элемент в стеке с операциями
    char last = s_to_c(st_oper.top());
 
    // TODO: написать комментарии по работе этого свитча
 
    switch (l_c) {
      case number:
      case var_x: {
        res.push_back(lex);
        if (st_oper.size() > 0 && last == uminus) {
          res.push_back(st_oper.top());
          st_oper.pop();
        }
        break;
      }
 
      case power: {
        while (last == power || c_in_s(last, math_func_chars)) {
          res.push_back(st_oper.top());
          st_oper.pop();
          last = s_to_c(st_oper.top());
        }
        st_oper.push(lex);
        break;
      }
 
      case mul:
      case divi: {
        while (last == mul || last == divi || last == power ||
               c_in_s(last, math_func_chars)) {
          res.push_back(st_oper.top());
          st_oper.pop();
          last = s_to_c(st_oper.top());
        }
        st_oper.push(lex);
        break;
      }
 
      case plus:
      case minus: {
        while (c_in_s(last, math_oper_chars) || c_in_s(last, math_func_chars)) {
          res.push_back(st_oper.top());
          st_oper.pop();
          last = s_to_c(st_oper.top());
        }
        st_oper.push(lex);
        break;
      }
 
      case open_br: {
        st_oper.push(lex);
        break;
      }
 
      case closed_br: {
        while (true) {
          if (last == open_br) {
            st_oper.pop();
            break;
          } else {
            res.push_back(st_oper.top());
            st_oper.pop();
          }
          last = s_to_c(st_oper.top());
        }
        break;
      }
      case c_sin:
      case c_cos:
      case c_tan:
      case c_exp:
      case c_ln:
      case uminus: {
        st_oper.push(lex);
        break;
      }
      default: {
        throw std::runtime_error("Oops");
        break;
      }
    }
  }
 
  // перевод оставшихся в стеке знаков в обратную польскую запись
  while (st_oper.top() != "\0") {
    res.push_back(st_oper.top());
    st_oper.pop();
  }
  return res;
}

Here is the call graph for this function:

Member Data Documentation

calculate

const std::function<double(double)> Math_func::function::calculate

Initial value:

= [this](double x) {
    return calc(x);
  }

Значение мат. функции

                                                                 {
    return calc(x);
  };

differentiate

const std::function<double(double)> Math_func::function::differentiate

Initial value:

= [this](double x) {
    return (calc(x + Backend_consts::delta_x) -
            calc(x - Backend_consts::delta_x)) /
           (2 * Backend_consts::delta_x);
  }

Значение производной мат. функции

                                                                     {
    return (calc(x + Backend_consts::delta_x) -
            calc(x - Backend_consts::delta_x)) /
           (2 * Backend_consts::delta_x);
  };

func_str

std::string Math_func::function::func_str

private

Мат. функция в виде строки

lexs

std::vector<std::string> Math_func::function::lexs

private

Вектор лексем от мат. функции

rev_pol

std::vector<std::string> Math_func::function::rev_pol

private

Вектор лексем, записанный в обратной польской нотации

---

The documentation for this class was generated from the following files:

• backend/Math_func/function.h
• backend/Math_func/function.cpp
• backend/Math_func/function_validation.cpp