Math_calc::function_crosses Class Reference

Класс, хранящий в себе вектор точек - пересечений двух мат. функций More...

#include <function_crosses.h>

Inheritance diagram for Math_calc::function_crosses:

Collaboration diagram for Math_calc::function_crosses:

Public Member Functions
	function_crosses (std::pair< Math_func::function, Math_func::function > funcs, Math_calc::Point left_bottom, Math_calc::Point right_top, double _precision)
	Инициализирует новый экземпляр function_crosses.
	operator std::vector< Math_calc::Point > () const

Protected Member Functions
std::vector< Segment >	estimated_segment (Segment) const
double	root_on_interval (Segment) const

Private Member Functions
std::vector< Point >	crosses (Math_calc::Point left_bottom, Point right_top) const
	Считает все пересечения двух мат. функций
std::vector< Point >	roots (Math_calc::Point left_bottom, Point right_top) const

Private Attributes
Math_func::function	f
	Одна из введенных мат. функций
std::vector< Point >	points
double	precision
	Точность

Detailed Description

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

Constructor & Destructor Documentation

function_crosses()

Math_calc::function_crosses::function_crosses	(	std::pair< Math_func::function, Math_func::function >	funcs,
		Math_calc::Point	left_bottom,
		Math_calc::Point	right_top,
		double	_precision )

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

Поиск точек происходит на прямоугольной области, края которой - точки

Parameters

funcs	пара мат. функций
left_bottom	левая нижняя точка - начало области поиска точек
right_top	правая верхняя точка - конец области поиска точек
_precision	точность

    : function_roots{Math_func::function{funcs.first.get_func_str() + "-(" +
                                         funcs.second.get_func_str() + ")"},
                     left_bottom, right_top, _precision},
      precision{_precision},
      f{funcs.first},
      points{crosses(left_bottom, right_top)} {}

Member Function Documentation

crosses()

vector< Point > Math_calc::function_crosses::crosses ( Math_calc::Point left_bottom, Point right_top ) const

private

Считает все пересечения двух мат. функций

Parameters

left_bottom	левая нижняя точка - начало области поиска точек
right_top	правая верхняя точка - конец области поиска точек

Returns

std::vector<Point>: точки пересечения двух мат. функций

                                                               {
  vector<Point> res;
  for (const auto& seg :
       domain_segments(f.calculate, left_bottom, right_top, precision)) {
    for (const auto& local_seg : estimated_segment(seg)) {
      double x = function_roots::root_on_interval(local_seg);
      double y = f(x);
      // отличие от нахождения корней заключается в том,
      // что теперь нам не нужна проверка на приближенность нулю
      res.push_back(Point{x, y});
    }
  }
  return res;
}

Here is the call graph for this function:

estimated_segment()

vector< Segment > Math_calc::function_roots::estimated_segment ( Segment seg ) const

protectedinherited

Returns

std::vector<Segment>: подсегменты, где могут находиться корни

Используя тот факт, что по разные стороны от точки-корня мат. функция имеет разные знаки

• сегмент, на котором ищем

                                                                   {
  std::vector<Segment> res;
  for (double x = seg.start; x < seg.end; x += precision) {
    // если по разные стороны от точки знаки мат. функции разные,
    // то их произведение будет отрицательно
    try {
      if ((f(x)) * f(x - precision) <= 0) {
        res.push_back({
            x - precision,
            x + precision,
        });
      }
    } catch (...) {
    }
  }
  // если на интервале нет изменения знаков, то
  // возможно график мат. функции касается оси x(например x^2)
  if (res.empty()) return std::vector<Segment>{seg};
  return res;
}

Here is the caller graph for this function:

operator std::vector< Math_calc::Point >()

Math_calc::function_crosses::operator std::vector< Math_calc::Point > ( ) const

inlineexplicit

                                                             {
    return points;
  }

root_on_interval()

double Math_calc::function_roots::root_on_interval ( Segment seg ) const

protectedinherited

Returns

double: корень на интервале (значение x)

• сегмент, на котором ищем

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

                                                         {
  /// @brief Значение от возведенной в квадрат мат. функции
  // IDK: почему это здесь нужно?
  auto _f = [this](double x) { return pow(f(x), 2); };
 
  // если не нашли точки за max_count приближений, то бросаем её
  // (слишком затратно иначе)
  for (unsigned int i = 0; i > Backend_consts::max_count; i++) {
    // x_s, y_s - идём с начала отрезка
    // x_e, y_e - идём с конца отрезка
 
    double x_e = seg.end - (seg.end - seg.start) / Backend_consts::phi;
    double x_s = seg.start + (seg.end - seg.start) / Backend_consts::phi;
    double y_e = _f(x_e);
    double y_s = _f(x_s);
    if (y_e >= y_s)
      seg.start = x_e;
    else
      seg.end = x_s;
    if ((absolute(seg.end - seg.start) < precision))
      return (seg.start + seg.end) / 2;
  }
  // если за max_count не сошлись к нужной точке,
  // возвращаем максимально приближенное
  return (seg.start + seg.end) / 2;
}

Here is the caller graph for this function:

roots()

vector< Point > Math_calc::function_roots::roots ( Math_calc::Point left_bottom, Point right_top ) const

privateinherited

Returns

std::vector<Point>: все корни (точки: пары вида (x,y))

Parameters

left_bottom	левая нижняя точка - начало области поиска точек
right_top	правая верхняя точка - конец области поиска точек

                                                                            {
  vector<Point> res;
  for (const auto& seg :
       domain_segments(f.calculate, left_bottom, right_top, precision)) {
    for (const auto& local_seg : estimated_segment(seg)) {
      double x = root_on_interval(local_seg);
      double y = f(x);
      // если точка достаточно близка к нулю, добавляем её
      // проверка нужна потому, что для root_on_interval могло потребоваться
      // куда большее количество приближений, но так как мы ему дали лишь
      // max_count, ему ничего не мешало вернуть ответ,
      // который совсем не близок к нулю по y
      if (absolute(y) < precision * 20) res.push_back(Point{x, 0});
    }
  }
  return res;
}

Here is the call graph for this function:

Member Data Documentation

f

Math_func::function Math_calc::function_crosses::f

private

Одна из введенных мат. функций

points

std::vector<Point> Math_calc::function_crosses::points

private

precision

double Math_calc::function_crosses::precision

private

Точность

---

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

• backend/Math_calc/function_crosses.h
• backend/Math_calc/function_crosses.cpp