ДЗ Лабораторная работа №2 "Расчет площади фигуры"

В отчете должно быть указано следующие:

1. Титульный лист, где указаны ФИО преподавателя, номер задания, номер варианта
2. Формулировка задания (картинка и уравнения)
3. Ссылка на github-репозиторий с работающим кодом
4. Реализуйте Монте-Карло или Формулу Симпосона (в зависимости от варианта та или иная реализация будет удобнее) для расчета площади фигуры.
5. Вычислите расчетное значение площади криволинейной фигуры, используя интеграллы. Расчеты приведите. (Если вы не умеете еще рассчитывать, воспользуйтесь калькулятором, вбив уравнения)
6. Проведите эксперимент с расчетом площади фигуры при разном числе N. Дайте таблицу испытаний/разбиений.
7. На основе полученных данных ответьте на вопрос при каком N дальше не имеет смысла увеличивать число испытаний/разбиений?
8. Насколько точно вы смогли в ходе испытаний приблизиться к действительному значению?

Примечание: Для реализации Unit-test необходимо использовать assertAlmostEqual (assertAlmostEqual(a, b, places=7)) для Python (Проверяет, что a и b равны с точностью до places десятичных знаков) для 3 раных значений n. Для C++ для проверки приближённого равенства естьAreEqual с параметром точности (tolerance). Пример: Assert::AreEqual(a, b, epsilon, L"Значения совпали с точностью.");

1 Пример расчета интегралла криволинейной фигуры

Необходимо определить площадь фигуры, которая ограничена параболой

и прямыми линиями

Изобразим линии на графике в декартовой системе координат.

На отрезке [1; 4] график параболы y = -x² + 6x - 5 расположен выше прямой y = -(1 / 3)x - (1 / 2). В связи с этим, для получения ответа используем формулу, полученную ранее, а также способ вычисления определенного интеграла по формуле Ньютона-Лейбница:

Вычисляем определенный интеграл:

Подставляем пределы интегрирования:

Упрощаем:

Ответ:

2 Метод Монте-Карло для вычисления площади фигуры

Метод Монте-Карло — это статистический метод, использующий случайные числа для решения математических задач. Для вычисления площади фигуры можно применить этот метод следующим образом:

1. Определение области для поиска: Укажите прямоугольную область, в которой будет заключена ваша фигура. Например, если фигура — это круг, то область может быть квадратом, в который вписан этот круг.
2. Генерация случайных точек: Генерируйте случайные точки внутри указанной области.
3. Проверка попадания в фигуру: Для каждой случайной точки проверяйте, попадает ли она в фигуру. Для круга, например, можно проверить, выполняется ли условие x² + y² ≤ r², где r — радиус круга, а x и y — координаты точки.
4. Расчет площади:
   • Общее количество случайных точек, попавших в фигуру, делится на общее количество сгенерированных точек.
   • Площадь фигуры будет пропорциональна площади всей области, умноженной на этот коэффициент:
   A = ( frac{Количество точек внутри фигуры}{Общее количество точек} ) × Площадь области
5. Увеличение точности: Чем больше точек будет сгенерировано, тем точнее будет результат.

Пример Вычисление площади круга

  import random

  def monte_carlo_circle_area(radius, num_points=10000):
      inside_points = 0
      for _ in range(num_points):
          x = random.uniform(-radius, radius)
          y = random.uniform(-radius, radius)
          if x**2 + y**2 <= radius**2:
              inside_points += 1

      # Площадь квадрата, в который вписан круг = (2*radius)^2
      square_area = (2 * radius) ** 2
      circle_area = (inside_points / num_points) * square_area
      return circle_area

  # Пример использования
  radius = 5
  estimated_area = monte_carlo_circle_area(radius)
  print(f"Оцененная площадь круга с радиусом {radius}: {estimated_area}")

  #include <iostream>
  #include <vector>
  #include <cstdlib>
  #include <ctime>

  double monte_carlo_circle_area(double radius, int num_points = 10000) {
      int inside_points = 0;
      for (int i = 0; i < num_points; ++i) {
          double x = ((double)rand() / RAND_MAX) * 2 * radius - radius;
          double y = ((double)rand() / RAND_MAX) * 2 * radius - radius;
          if (x * x + y * y <= radius * radius) {
              inside_points++;
          }
      }

      // Площадь квадрата, в который вписан круг = (2*radius)^2
      double square_area = (2 * radius) * (2 * radius);
      double circle_area = (inside_points / (double)num_points) * square_area;
      return circle_area;
  }

  int main() {
      srand(time(0)); // Инициализация генератора случайных чисел
      double radius = 5;
      double estimated_area = monte_carlo_circle_area(radius);
      std::cout << "Оцененная площадь круга с радиусом " << radius << ": " << estimated_area << std::endl;
      return 0;
  }

3 Формула Симпсона

Формула Симпсона — это численный метод интегрирования, который основан на приближении функции квадратичной параболой. Он позволяет более точно вычислять определённые интегралы по сравнению с методом прямоугольников или трапеций.

1. Разбиение отрезка интегрирования:
   • Выбирается отрезок [a, b], на котором вычисляется интеграл.
   • Делим его на n равных частей (где n — чётное число), получая узлы разбиения.
2. Вычисление значений функции:
   • Определяем значения функции в узлах разбиения x₀, x₁, ..., x_n.
3. Применение формулы Симпсона:

где h = (b - a / n).

4. Уточнение результата:
   • Увеличение числа узлов разбиения n повышает точность интегрирования.

Пример Численное интегрирование функции:

import numpy as np

def simpson_rule(f, a, b, n):
    if n % 2 == 1:
        n += 1  # Делаем n четным
    h = (b - a) / n
    x = np.linspace(a, b, n+1)
    fx = f(x)

    integral = (h / 3) * (fx[0] + 4 * sum(fx[1:-1:2]) + 2 * sum(fx[2:-2:2]) + fx[-1])
    return integral

# Пример использования
f = lambda x: x**2  # Интегрируемая функция
result = simpson_rule(f, 0, 1, 10)
print(f"Приближённое значение интеграла: {result}")

#include <iostream>
#include <cmath>

double simpson_rule(double (*f)(double), double a, double b, int n) {
    if (n % 2 == 1) n++; // Делаем n четным
    double h = (b - a) / n;
    double sum = f(a) + f(b);

    for (int i = 1; i < n; i += 2)
        sum += 4 * f(a + i * h);

    for (int i = 2; i < n-1; i += 2)
        sum += 2 * f(a + i * h);

    return (h / 3) * sum;
}

double function(double x) {
    return x * x; // Интегрируемая функция
}

int main() {
    double result = simpson_rule(function, 0, 1, 10);
    std::cout << "Приближенное значение интеграла: " << result << std::endl;
    return 0;
}

4 Варианты

Выберите вариант: Вариант 1Вариант 2Вариант 3Вариант 4Вариант 5Вариант 6Вариант 7Вариант 8Вариант 9Вариант 10Вариант 11Вариант 12Вариант 13Вариант 14Вариант 15Вариант 16Вариант 17Вариант 18Вариант 19Вариант 20Вариант 21Вариант 22Вариант 23Вариант 24Вариант 25Вариант 26Вариант 27Вариант 28Вариант 29Вариант 30

Уравнения

3 < x < 4
y = x² + 4
y = -x² - 4

Картинка