{
int n=4;
double I0=0, I1 = I(a, b, n,sif);
for(n=8; n < Math.Pow(2.0,15.0); n*=2)
{
I0 =I1; I1=I(a,b,n,sif);
if(Math.Abs(I1-10)<eps) break;
}
if(Math.Abs(I1–10)< eps)
Console.WriteLine("Требуемая точность достигнута! "+
" eps = {0}, достигнутая точность ={1}, n= {2}",
eps,Math.Abs(11–10), n);
else
Console.WriteLine("Требуемая точность не достигнута! "+
" eps = {0}, достигнутая точность ={1}, n= {2}",
eps,Math.Abs(I1–I0), n);
return(I1);
}
private double I(double a, double b, int n,
SublntegralFun sif)
{
//Вычисляет частную сумму по методу трапеций
double х = a, sum = sif(x)/2, dx = (b-a)/n;
for (int i= 2; i <= n; i++)
{
x += dx; sum += sif (x);
}
x = b; sum += sif(x)/2;
return(sum*dx);
}
}//class HighOrderIntegral
Прокомментирую этот текст:
• Класс HighOrderIntegral предназначен для работы с функциями. В него вложено описание функционального класса — делегата SubIntegralFun, задающего класс функций с одним аргументом типа double и возвращающих значение этого же типа.
• Метод EvalIntegral — основной метод класса позволяет вычислять определенный интеграл. Этот метод есть функция высшего порядка, поскольку одним из его аргументов является подынтегральная функция, принадлежащая классу SubIntegralFun.
• Для вычисления интеграла применяется классическая схема. Интервал интегрирования разбивается на n частей, и вычисляется частичная сумма по методу трапеций, представляющая приближенное значение интеграла. Затем n удваивается, и вычисляется новая сумма. Если разность двух приближений по модулю меньше заданной точности eps, то вычисление интеграла заканчивается, иначе процесс повторяется в цикле. Цикл завершается либо по достижении заданной точности, либо когда n достигнет некоторого предельного значения (в нашем случае — 215).
• Вычисление частичной суммы интеграла по методу трапеций реализовано закрытой процедурой I.
• Впоследствии класс может быть расширен, и помимо вычисления интеграла он может вычислять и другие характеристики функций.
Чтобы продемонстрировать работу с классом HighOrderIntegral, приведу еще класс Functions, где описано несколько функций, удовлетворяющих контракту, который задан классом SubIntegralFun;
class functions
{
//подынтегральные функции
static public double sif1(double x)
{
int k = 1; int b = 2;
return (double)(k*x +b);
}
static public double sif2(double x)
{
double a = 1.0; double b = 2.0; double c= 3.0;
return (double)(a*x*x +b*x +c);
}
}//class functions
А теперь рассмотрим метод класса клиента, выполняющий создание нужных объектов и тестирующий их работу:
public void TestEvalIntegrals ()
{
double myint1=0.0;
HighOrderIntegral.SubIntegralFun hoisifl =
new HighOrderIntegral.SubIntegralFun(functions.sif1);
HighOrderIntegral hoi = new HighOrderIntegral();
myint1 = hoi.EvalIntegral(2,3,0.le-5,hoisifl);
Console.WriteLine("myIntegral1 = {0}",myint1);
HighOrderIntegral.SubIntegralFun hoisif2 =
new HighOrderIntegral.SublntegralFun(functions.sif2);
myint1= hoi.Evaiintegral(2,3,0.1e-5,hoisif2);
Console.WriteLine("myIntegral2 = {0}",myint1);
}//Evallntegrals
Здесь создаются два экземпляра делегата и объект класса HighOrderIntegral, вызывающий метод вычисления интеграла. Результаты работы показаны на 20.2.
Рис. 20.2. Вычисление интеграла с использованием функций высших порядков
Построение программных систем методом "раскрутки". Функции обратного вызова
Метод "раскрутки" является одним из основных методов функционально-ориентированного построения сложных программных систем. Суть его состоит в том, что программная система создается слоями. Вначале пишется ядро системы — нулевой слой, реализующий базовый набор функций. Затем пишется первый слой с новыми функциями, которые интенсивно вызывают в процессе своей работы функции ядра. Теперь система обладает большим набором функций. Каждый новый слой расширяет функциональность системы. Процесс продолжается, пока не будет достигнута заданная функциональность. На рис. 20.3, изображающем схему построения системы методом раскрутки, стрелками показано, как функции внешних слоев вызывают функции внутренних слоев.