Форум программистов, компьютерный форум CyberForum.ru

Интегралы - C++

Восстановить пароль Регистрация
 
Demon__2012
 Аватар для Demon__2012
0 / 0 / 1
Регистрация: 07.10.2013
Сообщений: 74
24.02.2014, 20:28     Интегралы #1
Прошу доработать программу которая решает интегралы разными методами
C++
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
#include <math.h>
#include <locale.h>
using namespace std;
const float p = 3.141592653;
 
float ingdv(float a, float b, float e, float (*f)(float,float,int));
float f1(float a, float b, int n);
float f2(float a, float b, int n);
float f3(float a, float b, int n);
 
int main()
{
    setlocale(LC_CTYPE,"Russian");
    float a,b,rez,e;
    printf("Введите A, B и точность вычисления\n");
    scanf("%f%f%f", &a,&b,&e);
    printf("\nРешение интеграла 3-мя методами:\n\n");
    rez = ingdv(a,p/b,e,f1);
    printf("Метод Трацеция %f\n",rez);
    rez = ingdv(a,p/b,e,f2);
    printf("Метод Прямоугольник %f\n",rez);
    rez = ingdv(a,p/b,e,f3);
    printf("Метод Симпсона %f\n\n",rez);
    return 0;
}
/*-----------------Метод трапеции-------------------*/
float f1(float a, float b, int n)
{
    float h,sum,x;
    int i;
    sum = 0;
    h=(b-a)/n;
    sum += sqrt(tan(a));
    for(i = 1; i < n; i++)
    {
        x = a + i*h;
        sum += 2*sqrt(tan(x));
    }
    x = a + n*h;
    sum += sqrt(tan(x));
    return(0.5*h*sum);
}
/*---------------Метод прямоугольника------------------*/
float f2(float a, float b, int n)
{
    float h,sum,x;
    int i;
    sum = 0;
    h=(b-a)/n;
    for(i = 1; i <= n; i++)
    {
        x = a + (i-0.5)*h;
        sum += sqrt(tan(x));
    }
    return h*sum;
}
/*----------------Метод Симпсона--------------------*/
float f3(float a, float b, int n)
{
    float h, sum,x;
    int i, k;
    sum = 0;
    h=(b-a)/n;
    sum += sqrt(tan(a));
    for(i = 1; i < n; i++)
    {
        x = a + i*h;
        if(i%2 == 0) {k = 2;}
        else {k = 4;}
        sum += k*sqrt(tan(x));
    }
    x = a + n*h;
    sum += sqrt(tan(x));
    return 0.333*h*sum;
}
/*-----------Общая функция-----------*/
float ingdv(float a, float b, float e, float (*f)(float,float,int))
{
    int n = 10;
    float p,k;
    k = f(a,b,n);
    do{
        p = k;
        k = f(a,b,2*n);
        n = n*2;
 
    }while(abs(p-k)<e);
    return k;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
24.02.2014, 20:28     Интегралы
Посмотрите здесь:

Интегралы в С++ C++
Интегралы C++
C++ Интегралы
C++ интегралы
определенные интегралы C++
C++ Опять интегралы....
C++ Интегралы
C++ Интегралы. BC++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Skedaddler
1 / 1 / 1
Регистрация: 24.02.2014
Сообщений: 13
24.02.2014, 20:32     Интегралы #2
Что значит доработать? Скажите, где именно у вас проблемы. Нам весь код в поисках загадочной ошибки перелопатить нужно?
Примечание: Если хотите, посмотрите мою программку (правда, на сях писал, а не плюсах), к тому же у меня еще считает с заданной точностью
Кликните здесь для просмотра всего текста

C
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
// z2-5.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    return 0;
}
 
/*Вычисление определенного интеграла функции sqrt (1+cos^2(x))*/
 
/*ЭТАЛОН 3.8202*/
 
#include <stdio.h>
#include <math.h>
#define M_PI 3.14159265358979323846 //В Visual'e M_PI не пашет, к сожалению, приходится выкручиваться
 
double f_value (double x); //Значение подинтегрального выражения
 
double pryam (double lef, double rig, int N); //Вычисление методом прямоугольника
double trap (double lef, double rig, int N); //Вычисление методом трапеций
double simp (double lef, double rig, int N);//Вычисление методом Симпсона
 
double PryamAcc (double lef, double rig, double acc, int *pNp); //Вычисление методом прямоугольника с заданной точностью
double TrapAcc (double lef, double rig, double acc, int *pNt); //Вычисление методом трапеций с заданной точностью
double SimpAcc (double lef, double rig, double acc, int *pNs); //Вычисление методом Симпсона с заданной точностью
 
int main (void)
{
    double lef = 0.0, rig = M_PI, eps; //Где lef(left) - нижняя граница интеграла, rig(right) - правая, eps(epsilon) - точность
    double val_p, val_t,val_s;  //Значения каждого метода с заданной точностью
    int Np, Nt, Ns, i = 1;      //Числа итераций и порядок точности
    
    printf ("E(acc)|Rectangles| N | Trapezoid| N | Simpson  | N\n"); 
 
    for (eps = 0.1; eps >= 0.00001; eps /= 10, i++)
    {
        Np = 1; Nt = 1; Ns = 1;
 
        val_p = PryamAcc (lef, rig, eps, &Np);
        val_t = TrapAcc (lef, rig, eps, &Nt);
        val_s = SimpAcc (lef, rig, eps, &Ns);
 
        printf("10e-%d | %lf | %d | %lf | %d | %lf | %d \n", i, val_p, Np, val_t, Nt, val_s, Ns);
    }
 
    scanf ("%lf", &lef); //Отладка
    
    return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
double PryamAcc (double lef, double rig, double acc, int *pNp) //С заданной точностью
{
    double res, res1, di; //Значение интеграла, уточненное значение интеграла, разность интегралов в каждом цикле 
    
    res = pryam(lef, rig, (*pNp));
    do
    {
        (*pNp) += 1;    //Для красоты
        //(*pNp) *= 2;  //Обычно, т.к точность пропорциональна шагу
        res1 = pryam(lef, rig, (*pNp));
        di = fabs(res - res1);
        res = res1;
    }
    while(di > acc);
    return res1;
}
 
double TrapAcc (double lef, double rig, double acc, int *pNt) //С заданной точностью
{
    double res, res1, di; //Значение интеграла, уточненное значение интеграла, разность интегралов в каждом цикле 
    
    res = trap(lef, rig, (*pNt));
    do
    {
        (*pNt) += 1;    //Для красоты
        //(*pNp) *= 2;  //Обычно, т.к точность пропорциональна шагу
        res1 = trap(lef, rig, (*pNt));
        di = fabs(res - res1);
        res = res1;
    }
    while(di > acc);
    return res1;
}
 
double SimpAcc (double lef, double rig, double acc, int *pNs) //С заданной точностью
{
    double res, res1, di; //Значение интеграла, уточненное значение интеграла, разность интегралов в каждом цикле 
    
    res = simp(lef, rig, (*pNs));
    do
    {
        //(*pNs) += 1;  //Для красоты
        (*pNs) *= 2;    //Обычно, т.к точность пропорциональна шагу
        res1 = simp(lef, rig, (*pNs));
        di = fabs(res - res1);
        res = res1;
    }
    while(di > acc);
    return res1;
}
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
double f_value (double x) //Вычисление функции
{
        return sqrt(1.0+cos(x)*cos(x)); //Значение функции
        //return x;
        //return cos(x);
}
 
double pryam (double lef, double rig, int N) //Метод прямоугольников
{
    double dx, x, summ = 0.0; //Шаг сетки; аргумент; вычисленное (возвращаемое) значение интеграла
    dx = (rig-lef)/N;
    for (x = lef; x < rig - dx*0.9; x += dx)
    {
        summ += f_value(x);
    }
    return summ*dx;
}
 
double trap (double lef, double rig, int N) //Метод  трапеции
{
    double dx, x, summ = 0.0; //Шаг сетки; аргумент; вычисленное (возвращаемое) значение интеграла
    dx = (rig-lef)/N;
    summ = 0.5*f_value(lef)+0.5*f_value(rig); //(f(x0)-f(xN))/2
    for (x = lef + dx; x < rig - dx*0.9; x += dx)
    {
        summ += f_value(x);
    }
    return summ*dx;
}
 
double simp (double lef, double rig, int N) //Метод Симпсона
{
    double dx, x, summ1 = 0.0, summ2 = 0.0; //Шаг сетки; аргумент; вычисленное (возвращаемое) значение интеграла
    dx = (rig-lef)/N;
    for (x = lef + 2*dx; x < rig-dx*0.9; x += 2*dx) //x с четным индексом (при lef = x0)
    {
        summ1 += f_value(x);
    }
    for (x = lef + dx; x < rig - dx*0.9; x += 2*dx) //x с нечетным индексом (при lef = x0)
    {
        summ2 += f_value(x);
    }
    return (f_value(lef) + f_value(rig) + 2*summ1 + 4*summ2)*dx/3;
}
Yandex
Объявления
24.02.2014, 20:32     Интегралы
Ответ Создать тему
Опции темы

Текущее время: 14:29. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru