Метод Симпсона.

[Демик]

Здравствуйте, подскажите как узнать вершины и середину отрезка заданного таким интегралом: интеграл 0 до 1 (3x^2-4x)dx.
Для расчета с помощью метода Симпсона.

[Демик]

А случайно формула (b-a)/n это не нахождение середины отрезка? И следовательно 0 это начало, а 1 это конец? И если всё верно, то что тогда n?

[Демик]

Может быть n это шаг, от a до b?
Ну народ, подскажите хоть что нибудь (по теме) = )

[val_nnm]

Смотри в http://ru.wikipedia.org/wiki/Метод_Симпсона

Интеграл по формуле симпсона s=((b-a)/6)*(f(a)+4*f((a+b)/2)+f(b))
где a это начало отрезка
b это конец отрезка
(a+b)/2 это середина отрезка
соответсвенно у тебя a=0 b=1

f(0)=3*0^2-4*0=0
f((0+1)/2) = f(0.5)=3*0.5^2-4*0.5=0,75-2=-1,25
f(1)=3*1^2-4*1=3-4=-1

тогда интеграл s=((1-0)/6)*(0+4*(-1.25)+(-1))=(1/6)*(-6)=-1

иногда для расчёта интеграла на некотором участке. Весь участок разбивают на n участков и на каждом из них вычисляют значение выражения в начале участка, в середине и в конце. И затем на каждом из них уже считают интеграл по формуле Симпсона. (см. Составная формула (формула Котеса) в той же ссылке на википедия что я дал) Но у тебя нет необходимоти разбивать на участки. т.к. у тебя исходное выражение это и есть полином 2й сетпени.

[Демик]

val_nnm, спасибо огромное! Я просто с математикой не очень дружу)

[Демик]

Вот так правильно ли?

using System;
namespace Simpson
{
	class Program
	{
		public static void Main()
		{
			double res,a,b,fa,fmx,fm,fb;
			
		Console.WriteLine("Введите a:");
		a=Convert.ToDouble(Console.ReadLine());
		Console.WriteLine("Введите b:");
		b=Convert.ToDouble(Console.ReadLine());
			fa=3*(a*a)-4*a;
			fmx=(a+b)/2;
			fm=3*(fmx*fmx)-4*fmx;
			fb=3*(b*b)-4*b;
			res=((b-a)/6)*(fa+4*fm+fb);
	   	System.Console.Write("Интеграл равен:",res);
		System.Console.Write(res);	   	
	   	System.Console.ReadKey();
		}
	}
}

[val_nnm]

В общем вроде правильно. (не совсем красиво но работать должно)
Только
1) вместо

	   	System.Console.Write("Интеграл равен:",res);
		System.Console.Write(res);	   	
	   	System.Console.ReadKey();

вы видимо хотели написать

	   	System.Console.Write("Интеграл равен:{0}",res);	   	
	   	System.Console.ReadKey();

2) Я бы лично написал примерно так. (здесь аккуратно, я использовал "Лямбда-выражение" x=> (3*x*x-4*x) , а Func<double, double> это универсальный делегатат. если используете его, препод может спросить "а что это такое?")

using System;

namespace Simpson
{
	class Program
	{
        public static double Simpson(Func<double, double> F, double A, double B)
        {
            return ((B-A)/6)*(F(A)+4*F((A+B)/2)+F(B));
        }
		public static void Main (string[] args)
		{
            Console.WriteLine("Введите a:"); double a = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("Введите b:"); double b = Convert.ToDouble(Console.ReadLine());
            Console.Write("Интеграл равен:{0}", Simpson(x=> (3*x*x-4*x),a,b));
            Console.ReadKey();
		}
	}
}

[Демик]

Сообщение от val_nnm

Simpson(x=> (3*x*x-4*x),a,b));

Вот этот отрывок означает, что мы поочерёдно присваиваем переменной x, значения которые записали после функции и на выходе получаем возможность получать результат вычисления обращаясь к переменным таким способом F(A), F(B), F(C) значения полученные в результате выполнения функции? А если бы у нас было допустим 3 переменных, тогда эта функция(или это называется делегатом?) выглядела вот так:

Simpson(Func<double, double ,double> F, double A, double B, double C)

Верно?

[val_nnm]

Честно говоря не совем понял ваши обьяснения в предыдущем посте.
Попробую обьяснить с нуля (обьясняю своими словами, если нужна точные определения - смотрите MSDN)
Вот написал немного проще для понимния.

using System;
namespace Simpson
{
	class Program
	{
		public delegate double func (double x);

		public static double Simpson (func F, double A, double B)
		{
			return ((B - A) / 6) * (F (A) + 4 * F ((A + B) / 2) + F (B));
		}

		public static double F1 (double x)
		{
			return 3 * x * x - 4 * x;
		}

		public static void Main (string[] args)
		{
			Console.WriteLine ("Введите a:");
			double a = Convert.ToDouble (Console.ReadLine ());
			Console.WriteLine ("Введите b:");
			double b = Convert.ToDouble (Console.ReadLine ());
			Console.WriteLine ("Интеграл равен:{0}", Simpson (F1, a, b));
			Console.ReadKey ();
		}
	}
}

Делегат это какбы тип ссылки на некоторую функцию. Здесь я обьявил делегат "public delegate double func (double x);" это значит что если мы гденибуть в коде обьявим переменную типа func то она сможет ссылаться на функцию которая принимает один параметр типа double и возвращает значение типа double.
Функция Simpson (func F, double A, double B) собственно требует чтобы ей в качестве первого параметра (F) былла переданная такая ссылка на функцию. И дальше она использует эту ссылку F (A) т.е. это значит вызови функцию ссылка на которую храниться в переменной F передай ей в качестве первого параметра A и получи значение которая она вернёт.

Функция "public static double F1 (double x)" думаю проблем вызывать недолжна. Это собсвенно и есть функция вычисляющая выражение по заданию.

Дальше в коде "... Simpson (F1, a, b) ..." собственно вызывает функцию Simpson передаёт её в качесве первого параметра ссылку на функцию F1. Ну и соответсвенно значеиня a и b.

Надеюсь этот код понятно обьяснил.

Дальше в моём прошлом посте. Я чтобы не описывать делегат func использовал встроенный универсальный делегат.
Там их на самом деле несколько. (я немнго изменю их код чтобы было проще).
Есть например такой "public delegate TResult Func<out TResult>()" (он нам ненужен)
есть "public delegate TResult Func<T1,T2, TResult>(T1 arg1,T2 arg2)" (он нам тоже не нужен) и ещё несколько в том же духе.

Нас интересует "public delegate TResult Func<T, TResult>(T arg)"
Здесь в скобочках <> описанны его параметры.
Как только мы используем гденибуть в коде чтото вроде Func<double, double> то какбы автоматом создастся чтото вроде "public delegate double Func(double arg)". Ну а работу с таим делегатом я уже описал выше.

Дальше лямбда-выражение x=> (3*x*x-4*x)
Мы бы здесь могли также передать ссылку на функцию F1 которую я описал выше.
Но нам лень делать отдельную функцию, назначать ей имя и.т.п. Тогда мы используем лямбда-выражение которое какбы автоматом создает функцию (на самом деле эти выражения могут также использовать и локальные переменные в отличии от обычной функции, но небудем вдоваться в подробности) которая принемает 1 аргумент (x) и возвращает результат от выполнения действий с этим x т.е. возвращает результат вычисления (3*x*x-4*x).

[Демик]

val_nnm, спасибо большое вы очень понятно всё объяснили.