Перевод кода из Pascal в C# (Консольное приложение)
Задача: написать программу, которая позволяет вычислять определенный интеграл с помощью формулы Ньютона-Котеса.
код:
{
Программа для вычисления интеграла
численным методом Ньютона-Котеса открытого типа 4-го порядка
с заданной погрешностью вычислений
}
program NewtonCotes;
{подинтегральная функция}
function F(x: real): real;
begin
F := sin(x);
end;
{вычисление интеграла на отрезке [a, b] методом Ньютона-Котеса открытого типа 4-го порядка}
function NewtonCotesOpen4(a, b: real): real;
const
n = 4; {порядок метода}
c: array [1..n - 1] of real = (2, -1, 2); {весовые коэффициенты}
K = 3.0; {делитель}
var
Res: real;
h: real; {величина шага}
x: real;
i: integer;
begin
h := (b - a) / n;
Res := 0;
for i := 1 to n - 1 do
begin
x := a + i * h;
Res := Res + c[i] * F(x);
end;
NewtonCotesOpen4 := Res * (b - a) / K;
end;
{вычисление интеграла на отрезке [a, b] как суммы интегралов на n подинтервалах}
function SumSubIntervals(a, b: real; n: integer): real;
var
h: real;
i: integer;
begin
SumSubIntervals := 0;
h := (b - a) / n;
for i := 1 to n do
SumSubIntervals := SumSubIntervals + NewtonCotesOpen4(a + pred(i) * h, a + i * h);
end;
var
a, b, {границы интегрирования}
Eps: real; {погрешность численного интегрирования}
n: integer; {количество подинтервалов интегрирования}
Icur, {значение интеграла на текущем шаге итерации}
Ipre: real; {значение интеграла на предыдущем шаге итерации}
begin
a := 0;
b := Pi;
Eps := 0.00001;
n := 1;
Icur := SumSubIntervals(a, b, n);
repeat
Ipre := Icur;
n := 2 * n; {увеличиваем количество подинтервалов}
Icur := SumSubIntervals(a, b, n);
WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
until Abs(Icur - Ipre) < Eps;
writeln('------------------------------------------------------');
WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
end.
Предыдущий
вопрос Следующий
вопрос

Question

Перевод кода из Pascal в C# (Консольное приложение)
Задача: написать программу, которая позволяет вычислять определенный интеграл с помощью формулы Ньютона-Котеса.
код:
{
Программа для вычисления интеграла
численным методом Ньютона-Котеса открытого типа 4-го порядка
с заданной погрешностью вычислений
}
program NewtonCotes;
{подинтегральная функция}
function F(x: real): real;
begin
F := sin(x);
end;
{вычисление интеграла на отрезке [a, b] методом Ньютона-Котеса открытого типа 4-го порядка}
function NewtonCotesOpen4(a, b: real): real;
const
n = 4; {порядок метода}
c: array [1..n - 1] of real = (2, -1, 2); {весовые коэффициенты}
K = 3.0; {делитель}
var
Res: real;
h: real; {величина шага}
x: real;
i: integer;
begin
h := (b - a) / n;
Res := 0;
for i := 1 to n - 1 do
begin
x := a + i * h;
Res := Res + c[i] * F(x);
end;
NewtonCotesOpen4 := Res * (b - a) / K;
end;
{вычисление интеграла на отрезке [a, b] как суммы интегралов на n подинтервалах}
function SumSubIntervals(a, b: real; n: integer): real;
var
h: real;
i: integer;
begin
SumSubIntervals := 0;
h := (b - a) / n;
for i := 1 to n do
SumSubIntervals := SumSubIntervals + NewtonCotesOpen4(a + pred(i) * h, a + i * h);
end;
var
a, b, {границы интегрирования}
Eps: real; {погрешность численного интегрирования}
n: integer; {количество подинтервалов интегрирования}
Icur, {значение интеграла на текущем шаге итерации}
Ipre: real; {значение интеграла на предыдущем шаге итерации}
begin
a := 0;
b := Pi;
Eps := 0.00001;
n := 1;
Icur := SumSubIntervals(a, b, n);
repeat
Ipre := Icur;
n := 2 * n; {увеличиваем количество подинтервалов}
Icur := SumSubIntervals(a, b, n);
WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
until Abs(Icur - Ipre) < Eps;
writeln('------------------------------------------------------');
WriteLn('I=', Icur: 10: 8, ' при n=', n, ', e=', Abs(Icur - Ipre): 10: 8);
end.
Предыдущий
вопрос Следующий
вопрос

Главная

Вопросы и ответы

Вопросы и ответы по информатике

Перевод кода из Pasc...

eva

23 Окт 2019 в 23:44

273 +1

0

Helper · Answer 1

using System;

namespace NewtonCotes
{
class Program
{
// Подинтегральная функция
static double F(double x)
{
return Math.Sin(x);
}

// Вычисление интеграла на отрезке [a, b] методом Ньютона-Котеса открытого типа 4-го порядка
static double NewtonCotesOpen4(double a, double b)
{
const int n = 4; // порядок метода
double[] c = { 2, -1, 2 }; // весовые коэффициенты
const double K = 3.0; // делитель
double Res = 0;
double h = (b - a) / n;
double x;
for (int i = 1; i < n; i++)
{
x = a + i * h;
Res += c[i-1] * F(x);
}
return Res * (b - a) / K;
}
// Вычисление интеграла на отрезке [a, b] как суммы интегралов на n подинтервалах
static double SumSubIntervals(double a, double b, int n)
{
double h = (b - a) / n;
double sum = 0;
for (int i = 1; i <= n; i++)
{
sum += NewtonCotesOpen4(a + (i - 1) * h, a + i * h);
}
return sum;
}
static void Main(string[] args)
{
double a = 0;
double b = Math.PI;
double Eps = 0.00001;
int n = 1;
double Icur;
double Ipre;
Icur = SumSubIntervals(a, b, n);
do
{
Ipre = Icur;
n *= 2;
Icur = SumSubIntervals(a, b, n);
Console.WriteLine($"I= {Icur:F8} при n= {n}, e= {Math.Abs(Icur - Ipre):F8}");
} while (Math.Abs(Icur - Ipre) > Eps);
Console.WriteLine("------------------------------------------------------");
Console.WriteLine($"I= {Icur:F8} при n= {n}, e= {Math.Abs(Icur - Ipre):F8}");
}
}

}

Другие вопросы eva

Другие вопросы
eva