cw/code/Chisl2sem5homework.cpp - master - levg/numm

cw/code/Chisl2sem5homework.cpp
111 строк3 KB
Лев Черняховский
course-2
06 ноя 2024, 16:58
06 ноя 2024, 16:58776b6d1
#include <iostream>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <vector>

#define M_PI 3.14159265358979323846

int function_calls = 0;  // Глобальная переменная для подсчета вызовов функции

double f(double x) {
    function_calls++;  // Увеличиваем счетчик при каждом вызове функции
    return std::pow(x, 4) - 2.2 * std::pow(x, 3) + 7.5 * std::pow(x, 2) - 7 * x - 3.9;
}

double rightRectanglesRule(double a, double b, int n, std::vector<double>& func_values) {
    double h = (b - a) / n;
    double integral = 0.0;

    if (func_values.empty()) { // Если массив пуст, вычисляем значения функции для первой итерации
        double x = a + h;
        for (int i = 1; i <= n; i++) {
            func_values.push_back(f(x));
            integral += func_values.back();
            x += h;
        }
    }
    else { // Увеличиваем количество точек в два раза, вычисляя только новые
        int prev_n = n / 2;
        double x = a + h;
        for (int i = 1; i <= prev_n; i++) {
            double new_x = x + h;
            func_values.push_back(f(new_x));
            integral += func_values[2 * i - 2] + func_values.back();
            x += 2 * h;
        }
    }

    return integral * h;
}


double adaptiveRightRectangles(double a, double b, double epsilon) {
    int n = 1;
    std::vector<double> func_values;
    double integral = rightRectanglesRule(a, b, n, func_values);
    double integral_half = integral;

    do {
        integral = integral_half;
        n *= 2;
        integral_half = rightRectanglesRule(a, b, n, func_values);
    } while (std::abs(integral_half - integral) > epsilon);

    return integral_half;
}


double chebyshevQuadrature(double a, double b, int num_nodes) {
    const double weight = M_PI / num_nodes;
    double integral = 0.0;

    for (int i = 1; i <= num_nodes; ++i) {
        double x_i = std::cos((2 * i - 1) * M_PI / (2 * num_nodes));
        double x_mapped = 0.5 * (b - a) * x_i + 0.5 * (b + a);
        integral += f(x_mapped);
    }

    return integral * weight * (b - a) / 2;
}

double adaptiveChebyshevQuadrature(double a, double b, double epsilon) {
    int num_nodes = 2;
    double prev_result = 0.0;
    double result = chebyshevQuadrature(a, b, num_nodes);

    do {
        prev_result = result;
        num_nodes++;
        result = chebyshevQuadrature(a, b, num_nodes);
    } while (std::abs(result - prev_result) > epsilon && num_nodes <= 100);

    return result;
}

void functionCallsVsEpsilon(double a, double b) {
    std::ofstream file("function_calls_vs_epsilon.txt");
    file << "Epsilon\tRightRectangles\tChebyshev\n";
    for (double epsilon = 1e-1; epsilon >= 1e-8; epsilon /= 10) {
        function_calls = 0;
        adaptiveRightRectangles(a, b, epsilon);
        int calls_right_rectangles = function_calls;

        function_calls = 0;
        adaptiveChebyshevQuadrature(a, b, epsilon);
        int calls_chebyshev = function_calls;

        file << epsilon << "\t" << calls_right_rectangles << "\t" << calls_chebyshev << "\n";
    }

    file.close();
}

int main() {
    double a = 0;
    double b = 1;

    functionCallsVsEpsilon(a, b);

    return 0;
}