Math_calc::function_extremes Class Reference

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

#include <function_extremes.h>

Inheritance diagram for Math_calc::function_extremes:

Collaboration diagram for Math_calc::function_extremes:

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

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

Private Types
enum	ExtremeType { pnt_min , pnt_max }

Private Member Functions
std::vector< Segment >	estimated_segment (ExtremeType, Segment) const
double	extreme_on_interval (ExtremeType, Segment) const
std::vector< Point >	extremes (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

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

Member Enumeration Documentation

ExtremeType

enum Math_calc::function_extremes::ExtremeType

private

Enumerator
pnt_min
pnt_max

{ pnt_min, pnt_max };

Constructor & Destructor Documentation

function_extremes()

Math_calc::function_extremes::function_extremes	(	Math_func::function	_func,
		Math_calc::Point	left_bottom,
		Math_calc::Point	right_top,
		double	_precision )

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

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

Parameters

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

    : precision{_precision},
      f{_func},
      points{extremes(left_bottom, right_top)} {}

Member Function Documentation

estimated_segment() [1/2]

std::vector< Segment > Math_calc::function_extremes::estimated_segment ( ExtremeType extr, Segment seg ) const

private

Returns

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

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

                                                                             {
  std::vector<Segment> res;
  switch (extr) {
    case ExtremeType::pnt_min: {
      for (double x = seg.start; x < seg.end; x += precision) {
        // если значение мат. функции меньше своего значения и слева, и справа,
        // то она в точке минимума
        // IDK: а мы на кой черт на два то домножаем?
        try {
          if ((f(x) < f(x - 2 * precision)) && (f(x) < f(x + 2 * precision))) {
            res.push_back({
                x - 2 * precision,
                x + 2 * precision,
            });
          }
        } catch (...) {
        }
      }
      break;
    }
    case ExtremeType::pnt_max: {
      for (double x = seg.start; x < seg.end; x += precision) {
        // если значение мат. функции больше своего значения и слева, и справа,
        // то она в точке максимума
        // IDK: а мы на кой черт на два то домножаем?
        try {
          if ((f(x) > f(x - 2 * precision)) && (f(x) > f(x + 2 * precision))) {
            res.push_back({
                x - 2 * precision,
                x + 2 * precision,
            });
          }
        } catch (...) {
        }
      }
      break;
    }
  }
  return res;
}

Here is the caller graph for this function:

estimated_segment() [2/2]

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:

extreme_on_interval()

double Math_calc::function_extremes::extreme_on_interval ( ExtremeType extr, Segment seg ) const

private

Returns

double: экстремум на интервале (значение x)

Используя метод золотого сечения

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

                                                                 {
  switch (extr) {
    case ExtremeType::pnt_min: {
      for (unsigned int count = 0; count > Backend_consts::max_count; count++) {
        // 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;
      }
      break;
    }
    case ExtremeType::pnt_max: {
      for (unsigned int count = 0; count > Backend_consts::max_count; count++) {
        // 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;
      }
      break;
    }
  }
  // в том случае, если за max_count не сошлись к нужной точке
  return (seg.start + seg.end) / 2;
}

Here is the caller graph for this function:

extremes()

vector< Point > Math_calc::function_extremes::extremes ( Math_calc::Point left_bottom, Point right_top ) const

private

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(pnt_min, seg)) {
      double x = extreme_on_interval(pnt_min, local_seg);
      double y = f(x);
      res.push_back(Point{x, y});
    }
    for (const auto& local_seg : estimated_segment(pnt_max, seg)) {
      double x = extreme_on_interval(pnt_max, local_seg);
      double y = f(x);
      res.push_back(Point{x, y});
    }
  }
 
  return res;
}

Here is the call graph for this function:

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

Math_calc::function_extremes::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_extremes::f

private

Введенная мат. функция

points

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

private

precision

double Math_calc::function_extremes::precision

private

Точность

---

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

• backend/Math_calc/function_extremes.h
• backend/Math_calc/function_extremes.cpp