Реферат

У роботі реалізується знаходження рішення однієї задачі на тему максимізації функцій багатьох змінних. При цьому розглядаються методи дихотомії і покоординатного спуску.
Пояснювальна записка до курсової роботи складається з двох основних частин: теоретичної та практичної.
У теоретичній частині розглядається пошук максимуму однієї функції багатьох змінних методом покоординатного спуску і з допомогою методу дихотомії.
Практична частина містить розробку програмного забезпечення для вирішення заданої завдання вище зазначеними методами, реалізовану на мові С + +.
Обсяг пояснювальної записки: 1
Кількість рисунків: 3
Кількість використовуваних джерел: 3

Зміст

Введення

1. Постановка завдання
2. Рішення задачі з використанням методу дихотомії
2.1 Опис методу дихотомії
2.2 Алгоритм рішення
3. Рішення задачі з використанням методу покоординатного спуску
3.1 Опис методу покоординатного спуску
3.2 Алгоритм рішення
Висновок
Список використаної літератури
Додаток 1. Лістинг програми № 1
Додаток 2. Лістинг програми № 2
Додаток 3. Лістинг програми № 3
Додаток 4. Результати роботи програми № 1
Додаток 5. Результати роботи програми № 3

Введення
У роботі розглянуті способи знаходження таких значень аргументів, при яких вихідна функція максимальна, а допоміжна (від якої залежить вихідна) - мінімальна. У пункті 2 викладено рішення задачі з використанням методу дихотомії. У пункті 3 вироблено дослідження задачі методом покоординатного спуску.

1. Постановка завдання
Вихідна функція має вигляд:
, Де:
x _i R - параметри вихідної функції;
p, q R - деякі параметри задовольняють умові 1 <p q <∞;
з = c (x ₁ ... x _n) - допоміжна функція, записана в неявному вигляді
→ min.
Завдання:
Знайти x _i ^*, : F (x ₁ ^* ... x _n ^*) = f (x ₁ ... x _n).
Виконаємо наступну заміну: x _i = ax _i + b, . При цьому значення функції не зміниться:


Таким чином, вихідну область визначення функції можна звузити до x _i R _{[0, 1].} Так як знаменник не повинен бути рівним нулю, то x _i ≠ x _j i ≠ j. Але тоді всі параметри можна розташувати за зростанням: x ₁ x ₂ ... x _i x _{i +1} ... x _n, а вибором a і b можна навести x ₁ = 0, x _n = 1.
Далі будемо розглядати завдання від n-2 змінних, тому що x ₁ і x _n є константами.

2. Рішення задачі з використанням методу дихотомії
2.1 Опис методу дихотомії
Даний метод застосовується для розв'язання нелінійних рівнянь. Якщо нелінійне рівняння досить складне, то знайти точно його коріння вдається дуже рідко. Важливе значення набувають способи наближеного знаходження коренів рівняння і оцінка ступеня їх точності.
Нехай f (x) = 0 (1)
Де f (x) визначена і неперервна в деякому кінцевому і нескінченному інтервалі a <x <b. Потрібно знайти всі або деякі корені рівняння (1). Всяке значення , Що звертає функцію f (x) в нуль, називається коренем рівняння (1). Поставлена ​​задача розпадається на кілька етапів:
1. Відділення коренів, тобто встановлення можливо більш тісних проміжків [ , ], В яких міститься тільки по одному кореню.
2. Знаходження наближених (грубих) ​​значень коренів.
3. Обчислення коренів з необхідною точністю.
Перша і друга задача вирішуються аналітичними та графічними методами.
Відділення коренів
Якщо рівняння f (x) = 0 має тільки дійсні корені, то корисно скласти таблицю значень функції f (x). Якщо у двох сусідніх точках   і   функція має різні знаки, то між цими точками лежить щонайменше один корінь. Корінь буде свідомо єдиним, якщо   визначена на відрізку [ , ] і зберігає постійний знак.

Графічні методи
Дійсні корені рівняння f (x) = 0 приблизно можна визначити як абсциси точок перетину графіка функції f (x) з віссю x.
Наближені значення коренів, знайдені грубо, надалі уточнюють за допомогою будь-якого ітераційного методу.
Метод дихотомії
Дихотомія означає розподіл навпіл. Нехай знайшли такі точки   і , Що <0, тобто на [ , ] Лежить щонайменше один корінь. Знайдемо середину відрізка [ , ]. Отримуємо . Якщо f (x 2) = 0, то якщо f ( ) 0, то з двох половин відрізка виберемо ту, для якої виконується умова <0, тому корінь лежить на цій половині. Потім знову ділимо вибраний відрізок навпіл і вибираємо ту половину, на кінцях якої функція має різні знаки.
Якщо потрібно знайти корінь з точністю , То продовжимо поділ навпіл (якщо звичайно функція в середині будь-якого відрізка не звертається в нуль), поки довжина чергового відрізка не стане <2 . Тоді середина наступного відрізка встановить значення з необхідною точністю. Метод дихотомії простий і дуже надійний. Він сходиться для будь-яких безперервних функцій f (x), в тому числі не диференційовних.
Метод стійкий до помилок округлення, але швидкість збіжності невелика. До недоліків методу слід віднести збіжність до невідомо якого кореня (якщо коріння не відокремлені). Але зазначений недолік є у всіх ітераційних методів. Дихотомія застосовується тоді, коли потрібна висока надійність рахунку, а швидкість збіжності малоістотно. Метод іноді застосовується для грубого знаходження коренів з наступним уточненням за іншим методом з більшою швидкістю збіжності.
Цей метод належить до двосторонніх (або до двох кроковим) методам, тому що для обчислення чергового наближення необхідно знати два попередніх.
2.2 Алгоритм рішення
Для знаходження максимуму функції будемо перебирати всілякі змінні x _i, , Із кроком необхідної довжини.
Потім будемо знаходити значення функції з ( ) Методом дихотомії.
Для цього обчислимо похідну функції , Що залежить від с, і прирівняємо її до 0.


Знайдемо корінь цього нелінійного рівняння методом дихотомії.
Підставимо конкретний набір і при ньому знайдене у вихідну функцію, і отримаємо її значення.
Перебираючи всі x _i, знайдемо максимум функції.
Перебираючи всілякі параметри p і q, одержимо деякі набори (Залежно від p та q) на яких функція досягає максимуму.

3. Рішення задачі з використанням методу покоординатного спуску
3.1 Опис методу покоординатного спуску
Викладемо цей метод на прикладі функції трьох змінних .
Виберемо нульове наближення . Фіксуємо значення двох координат . Тоді функція буде залежати тільки від однієї змінної ; Позначимо її через . Знайдемо мінімум функції однієї змінної і позначимо його через . Ми зробили крок з точки в точку у напрямку, паралельному осі ; На цьому кроці значення функції зменшилося.
Потім з нової точки зробимо спуск у напрямку, паралельному осі , Тобто розглянемо , Знайдемо її мінімум і позначимо його через . Другий крок приводить нас в точку . З цієї точки робимо третій крок - спуск паралельно осі і знаходимо мінімум функції . Прихід в точку завершує цикл спусків.
Будемо повторювати цикли. На кожному спуску функція не зростає, і при цьому значення функції обмежені знизу її значенням в мінімумі . Отже, ітерації сходяться до деякого межі . Чи буде тут мати місце рівність, тобто чи зійдуться спуски до мінімуму і як швидко?
Це залежить від функції і вибору нульового наближення.
Метод спуску по координатах нескладний і легко програмується на ЕОМ. Але сходиться він повільно. Тому його використовують в якості першої спроби при знаходженні мінімуму.

3.2 Алгоритм рішення
Будемо перебирати з з кроком будь-якої малої довжини.
Задамо нульове наближення, наприклад:

Знайдемо приватні похідні .

Нехай при якомусь j
Тоді k-е наближення вважаємо за формулами:

Крок t будемо вибирати таким чином, щоб
і .
У результаті, закінчивши процес за критерієм , Де -Задана точність ми прийдемо до набору , При якому функція f максимальна.
Підставимо знайдений набір і відповідне у функцію f1 = і перебравши всі с, виберемо ті , При яких f1 мінімальна.

Висновок
У ході вирішення поставленої задачі розглянуті випадки, коли n = 4,5,6. Були знайдені дві основні області наборів :
1) x _i = 0 або 1 (кількість 0 і 1 однаково)
2) x _i = 0.5, .
Причому ділянка 1 <p <1.5 покритий першою областю, при q>> p - З першої області, при q ≈ p - З другої області, а при p → ∞ область ділилася між ними приблизно навпіл.
На ділянці p> 2 з'являлися області види:
i <k => x _i = 0;
i> nk => x _i = 1;
k-1 _<i <n-k+1=> x i = 0.5.
На ділянці 2 <q <3 p 2 існує область, в якій максимум досягається при види:
x _i = a => x _{n - i} = 1-a, 0 <a <1.

Список використаних джерел
1. Амосов А.А., Дубинський Ю.А., Копченова Н.В. Обчислювальні методи для інженерів. М.: Вища школа, 1994. 543с.
2. Березін І.С. і Жидков Н. П. Методи обчислень. т.1. М.: "Наука", 1965. 633c.
3. Подбельський В.В. і Фомін С.С. Програмування на мові Сі. М.: "Фінанси і статистика", 2000. 599с.

Додаток 1. Лістинг програми № 1
/ / Вивід на екран областей максимуму функції
# Include "stdafx.h"
# Include "KE2.h"
# Include "math.h"
# Include "KE2Doc.h"
# Include "KE2View.h"
# Ifdef _DEBUG
# Define new DEBUG_NEW
# Undef THIS_FILE
static char THIS_FILE [] = __FILE__;
# Endif
IMPLEMENT_DYNCREATE (CKE2View, CView)
BEGIN_MESSAGE_MAP (CKE2View, CView)
/ / {{AFX_MSG_MAP (CKE2View)
/ / NOTE - the ClassWizard will add and remove mapping macros here.
/ / DO NOT EDIT what you see in these blocks of generated code!
/ /}} AFX_MSG_MAP
/ / Standard printing commands
ON_COMMAND (ID_FILE_PRINT, CView:: OnFilePrint)
ON_COMMAND (ID_FILE_PRINT_DIRECT, CView:: OnFilePrint)
ON_COMMAND (ID_FILE_PRINT_PREVIEW, CView:: OnFilePrintPreview)
END_MESSAGE_MAP ()
CKE2View:: CKE2View ()
{
}
CKE2View:: ~ CKE2View ()
{
}
BOOL CKE2View:: PreCreateWindow (CREATESTRUCT & cs)
{
return CView:: PreCreateWindow (cs);
}
void CKE2View:: OnDraw (CDC * pDC)
{
CKE2Doc * pDoc = GetDocument ();
ASSERT_VALID (pDoc);
drawPoint (pDC);
/ / TODO: add draw code for native data here
}
BOOL CKE2View:: OnPreparePrinting (CPrintInfo * pInfo)
{
/ / Default divparation
return DoPreparePrinting (pInfo);
}
void CKE2View:: OnBeginPrinting (CDC * / * pDC * /, CPrintInfo * / * pInfo * /)
{
/ / TODO: add extra initialization before printing
}
void CKE2View:: OnEndPrinting (CDC * / * pDC * /, CPrintInfo * / * pInfo * /)
{
/ / TODO: add cleanup after printing
}
# Ifdef _DEBUG
void CKE2View:: AssertValid () const
{
CView:: AssertValid ();
}
void CKE2View:: Dump (CDumpContext & dc) const
{
CView:: Dump (dc);
}
CKE2Doc * CKE2View:: GetDocument () / / non-debug version is inline
{
ASSERT (m_pDocument-> IsKindOf (RUNTIME_CLASS (CKE2Doc)));
return (CKE2Doc *) m_pDocument;
}
# Endif / / _DEBUG
int sgn (float a)
{
int sg;
if (a> 0) sg = 1;
if (a == 0) sg = 0;
if (a <0) sg =- 1;
return (sg);
}
# Define n 6
void CKE2View:: drawPoint (CDC * pDC)
{
double ** c, * f1, * f, * x, * w, * e, max, p = 2, q = 2, xx, yy;
int i = 0, j = 0, k, m, a, b, * l, bb = 0;
c = new double * [10000];
for (i = 0; i <10000; i + +)
{
c [i] = new double [3];
memset (c [i], 0, sizeof (double) * 3);
}
f = new double [10000];
e = new double [10000];
w = new double [10000];
f1 = new double [10000];
x = new double [n];
l = new int [10000];

for (xx = 0.5; xx <1; xx + = 0.01)
for (yy = xx; yy <1); yy + = 0.01)
{
p = 1. / (1.-xx);
q = 1. / (1.-yy);
memset (w, 0, sizeof (double) * 10000);
memset (e, 0, sizeof (double) * 10000);
memset (f1, 0, sizeof (double) * 10000);
memset (x, 0, sizeof (double) * n);
x [n-1] = 1;
j = 0;
for (i = 0; i <10000; i + +)
{J = 0;
f1 [i] = 1; c [i] [0] = 0; c [i] [1] = 1; c [i] [2] = 0.5;
while (fabs (f1 [i])> 0.00000001)
{
f1 [i] = 0;
for (k = 0; k <n; k + +)
{F1 [i] + = pow ((fabs (x [k]-c [i] [2 ])),( p-1)) * sgn (x [k]-c [i] [2]); }
if (f1 [i] <-0.00000001)
{Max = c [i] [2]; c [i] [2] = c [i] [2] - (fabs (c [i] [2]-c [i] [1]) / 2.0); c [i] [1] = max;}
if (f1 [i]> 0.00000001)
{Max = c [i] [2]; c [i] [2] = c [i] [2] + (fabs (c [i] [2]-c [i] [1]) / 2.0); c [i] [1] = max;}
if (fabs (f1 [i]) <= 0.00000001)
{C [i] [0] = c [i] [2]; goto B;}

}
B:
c [i] [0] = c [i] [2];
for (a = 0; a <n; a + +)
{

for (b = 0; b <n; b + +)
w [i] + = pow ((fabs (x [a]-x [b])), q);
e [i] + = pow ((fabs (x [a]-c [i] [0])), p);
}
f [i] = pow ((e [i] / n), (1. / p)) / pow ((w [i] / (n * n)), (1. / q));
x [n-2] + = 0.1;
for (k = 2; k <n; k + +)
{
if (x [nk]> 1.04)
{
x [nk-1] + = 0.1;
x [nk] = x [nk-1];
for (m = 2; m <k; m + +)
x [nm] = x [nk-1];
}
if (x [0]! = 0) goto A;
}

}
A:
max = f [0]; k = 0;
for (m = 0; m <i; m + +)
{
if (fabs (max-f [m]) <0.001) {k + +; l [k] = m;}
if (max <f [m]) {k = 0; max = f [m]; l [k] = m;}
}
for (a = 0; a <n-1; a + +)
x [a] = 0;

for (a = 0; a <l [0]; a + +)
{
x [n-2] + = 0.1;
for (k = 2; k <n; k + +)
if (x [nk]> 1.04)
{
x [nk-1] + = 0.1;
x [nk] = x [nk-1];
for (m = 2; m <k; m + +)
x [nm] = x [nk-1];
}
}

b = 0;
for (k = 0; k <n; k + +)
{
if ((x [k] == 0) | | (fabs (x [k] -1) <0.04)) b + +;
else
{
if (fabs (x [k] -0.5) <0.04) b + = 2;
else b =- n;
}
}
b-= n;
if (b <0) b = 24;
if (b == 0) b = 58;
if (b == bb) continue;
bb = b;
c =% f \ n ", p, q, l [0], l [k], k +1, max, c [l [0]] [0]);
COLORREF cr (RGB ((b% 3) * 127, (b% 4) * 85, (b% 5) * 63));
CBrush r (cr);
CPen rp (PS_SOLID, 0, cr);
pDC-> SelectObject (& rp);
pDC-> SelectObject (& r);
CPoint r1 [3] = {CPoint (0,360), CPoint (int (720. / P),-int (720. / Q) +360), CPoint (int (720. / P), 360)};
pDC-> Polygon (r1, 3);
}
}
Додаток 2. Лістинг програми № 2.
/ / Покоординатного узвіз
# Include <stdAfx.h>
# Include <stdio.h>
# Include <iostream.h>
# Include <conio.h>
# Include <math.h>
# Define n 4
void main ()
{
/ / Double ff (double v, double vv);
int sgn (float a);
double * aa, ** x, * f1, f, e, w, w1, e1, q = 7, p = 7, * r, * z, f2, * r1, max, m = 0, c, f20, f21;
int bb, i, MAX, k, j, a, b, mm, ss;
x = new double * [n];
for (i = 0; i <n; i + +)
x [i] = new double [2];
z = new double [3];
aa = new double [n-2];
r = new double [n];
r1 = new double [n];
/ / F2 = new double [n];
f1 = new double [n];

for (i = 1; i <n-1; i + +) / / початкове прибл - все х від 1-го до n-2-го рівні
x [i] [0] = 0.1; / /
x [n-1] [0] = 1; x [n-1] [1] = 1; x [0] [1] = 0; x [0] [0] = 0; x [1] [0 ] = 0.9; / / x [2] [0] = 0; / / x [3] [0] = 0; x [4] [0] = 1; / / початкове наближення

for (c = 0.5; c <0.7; c + = 0.1) / / Цикл по c
{
bb = 0;
for (k = 1;; k + +) / / Цикл по k
{
/ / For (i = 0; i <n; i + +)
/ / Cerr <<"x [" <<i <<"]="<< x [i] [0] <<"\ n";
/ / Cerr <<"\ n";
w = 0; e = 0; w1 = 0; e1 = 0;
for (a = 0; a <n; a + +)
r [a] = 0;
for (a = 0; a <n; a + +)
{
for (b = 0; b <n; b + +)

{
w + = pow ((fabs (x [a] [0]-x [b] [0])), q);
r [a] + = pow ((fabs (x [a] [0]-x [b] [0])), q-1) * sgn (x [a] [0]-x [b] [0 ]);
}
e + = pow ((fabs (x [a] [0]-c)), p);
}
w = pow (w / (n * n), 1. / q); / / знаменник вих ф-ції
e = pow (e / n, 1. / p); / / чисельник вих ф-ції
f = e / w;
/ / Cerr <<"\ n" <<f <<"\ n";
f1 [0] = 0; f1 [n-1] = 0;
MAX = 0;
for (j = 1; j <n-1; j + +)
{
f1 [j] = pow (n, (2./q-1./p)) * (pow (e, (1./p-1)) * pow (fabs (x [j] [0]-c ), (p-1)) * w
* Sgn (x [j] [0]-c) -2 .* pow (w, (1./q-1)) * r [j]) / (w * w); / / похідна вих. функції з x [j] [0] в точці з координатами x [i] [0] i = 0 .. n-1 на k-му наближенні
/ / Cerr <<f1 [j] <<"\ n";
for (a = 0; a <bb; a + +)
if (aa [a] == j) break;
if (a! = bb) continue;
if (fabs (f1 [j])> fabs (f1 [MAX])) MAX = j;
}
/ / Тому x [0] = 0 і x [n-1] = 1 - cosnt
mm = 0; ss = 0;
for (i = 0;; i + +)
{
if (mm == 0) z [0] = 100000000./pow (1.2, i); / / крок
if (mm == 1)
{
z [0] =- 1000000000./pow (1.2, ss);
ss + +;
}
/ * If (z [0] <0.000000000000001)
{
z [0] =- 0.5/pow (1.5, mm);
mm + +;
} * /
for (a = 0; a <n; a + +)
r1 [a] = 0;
w1 = 0; e1 = 0;
for (a = 0; a <n; a + +)
{
if (a == MAX)
{
for (b = 0; b <n; b + +)
{
w1 + = pow (fabs (x [a] [0] + f1 [a] * z [0] - (x [b] [0] + f1 [b] * z [0])), q);
r1 [a] + = pow (fabs (x [a] [0] + f1 [a] * z [0] - (x [b] [0] + f1 [b] * z [0])), q -1) *
sgn (x [a] [0] + f1 [a] * z [0] - (f1 [b] * z [0] + x [b] [0]));
}
e1 + = pow ((fabs (x [a] [0] + f1 [a] * z [0]-c)), p);
}
else
{
for (b = 0; b <n; b + +)
{
w1 + = pow ((fabs (x [a] [0]-x [b] [0])), q);
r1 [a] + = pow ((fabs (x [a] [0]-x [b] [0])), q-1) * sgn (x [a] [0]-x [b] [0 ]);
}
e1 + = pow ((fabs (x [a] [0]-c)), p);
}
}
w1 = pow (w1 / (n * n), 1 / q); e1 = pow (e1 / n, 1 / p);
/ / Printf ("\ nf =% ff [a] =% f", e / w, e1/w1);
a = 0;
/ / For (j = 1; j <n-1; j + +)
/ / If (((x [j] [0] + z [0] * f1 [j]) <1 )&&(( x [j] [0] + z [0] * f1 [j])> 0 )) a + +;
/ / If (a <n-2) continue;
if (((x [MAX] [0] + z [0] * f1 [MAX]) <1 )&&(( x [MAX] [0] + z [0] * f1 [MAX])> 0)) a + +;
if (a! = 1) continue;
if (e1/w1> e / w) break;
if ((e1/w1-e/w)> -0.00000001)
{
if (z [0]> 0)
{
mm = 1;
continue;
}
for (a = 1; a <n-1; a + +)
x [a] [1] = x [a] [0];
goto A;
}
}

for (j = 1; j <n-1; j + +)
if (j == MAX) x [j] [1] = x [j] [0] + z [0] * f1 [j];
else x [j] [1] = x [j] [0];
if (fabs (x [MAX] [1]-x [MAX] [0]) <0.00000001)
{
aa [bb] = MAX;
bb + +;
}
if (bb == n-2) break;
for (j = 1; j <n-1; j + +)
x [j] [0] = x [j] [1];
} / / Закриття циклу по k
A:
cerr <<"K-vo iteratsiy:" <<k-1 <<"\ n \ n";
for (i = 0; i <n; i + +)
cerr <<"x [" <<i <<"]="<< x [i] [0] <<"\ n";
cerr <<"\ nf =" <<f <<"\ n";
} / / Закриття циклу по с
}
int sgn (float a)
{
int sg;
if (a> 0) sg = 1;
if (a == 0) sg = 0;
if (a <0) sg =- 1;
return (sg);
}

Додаток 3. Лістинг програми № 3
# Include <stdAfx.h>
# Include <stdlib.h>
# Include <stdio.h>
# Include <conio.h>
# Include <math.h>
# Include <iostream.h>
# Define n 4
int sgn (float);
main ()
{
double ** c, * f1, * f, * x, * w, * e, max, p = 2, q = 2, xx, yy;
int i = 0, j = 0, k, m, a, b, * l;

c = new double * [10000];
for (i = 0; i <10000; i + +)
c [i] = new double [4];
f = new double [10000];
e = new double [10000];
w = new double [10000];
f1 = new double [10000];
x = new double [n];
l = new int [10000];

for (xx = 0.5; xx <1; xx + = 0.01)
for (yy = xx; yy <1; yy + = 0.01)
{
p = 1. / (1.-xx);
q = 1. / (1.-yy);
for (i = 0; i <10000; i + +)
{
w [i] = 0;
e [i] = 0;
f1 [i] = 0;
}

for (i = 0; i <10000; i + +)
for (j = 0; j <3; j + +)
{C [i] [j] = 0;
}
for (i = 0; i <n; i + +)
x [i] = 0;
x [n-1] = 1;
j = 0;
for (i = 0; i <10000; i + +)
{J = 0;
f1 [i] = 1; c [i] [0] = 0; c [i] [1] = 1; c [i] [2] = 0.5;
while (fabs (f1 [i])> 0.000000001)
{
f1 [i] = 0;
for (k = 0; k <n; k + +)
{F1 [i] + = pow ((fabs (x [k]-c [i] [2 ])),( p-1)) * sgn (x [k]-c [i] [2]); }
if (f1 [i] <-0.000000001)
{Max = c [i] [2]; c [i] [2] = c [i] [2] - (fabs (c [i] [2]-c [i] [1]) / 2.0); c [i] [1] = max;}
if (f1 [i]> 0.000000001)
{Max = c [i] [2]; c [i] [2] = c [i] [2] + (fabs (c [i] [2]-c [i] [1]) / 2.0); c [i] [1] = max;}
if (fabs (f1 [i]) <= 0.000000001)
{C [i] [0] = c [i] [2]; goto B;}

}
B:
c [i] [0] = c [i] [2];
for (a = 0; a <n; a + +)
{

for (b = 0; b <n; b + +)
w [i] + = pow ((fabs (x [a]-x [b])), q);
e [i] + = pow ((fabs (x [a]-c [i] [0])), p);
}
f [i] = pow ((e [i] / n), (1. / p)) / pow ((w [i] / (n * n)), (1. / q));
x [n-2] + = 0.1;
for (k = 2; k <n; k + +)
{
if (x [nk]> 1.04)
{
x [nk-1] + = 0.1;
x [nk] = x [nk-1];
for (m = 2; m <k; m + +)
x [nm] = x [nk-1];
}
if (x [0]! = 0) goto A;
}

}
A:
max = f [0]; k = 0;
for (m = 0; m <i; m + +)
{
if (fabs (max-f [m]) <0.0001) {k + +; l [k] = m;}
if (max <f [m]) {k = 0; max = f [m]; l [k] = m;}
}
printf ("p =% fq =% f max =% f \ n", p, q, max);
x [n-1] = 1;
for (a = 0; a <= n-2; a + +)
x [a] = 0;
for (a = 0; a <l [0]; a + +)
{
x [n-2] + = 0.1;
for (k = 2; k <n; k + +)
{
if (x [nk]> 1.04)
{
x [nk-1] + = 0.1;
x [nk] = x [nk-1];
for (m = 2; m <k; m + +)
x [nm] = x [nk-1];
}
}
}
for (a = 0; a <n; a + +)
printf ("Nabor: x [% d] =% f", a, x [a]);
}
getch ();
return 0;
}
int sgn (float a)
{
int sg;
if (a> 0) sg = 1;
if (a == 0) sg = 0;
if (a <0) sg =- 1;
return (sg);
}

Додаток № 4 Результати роботи програми № 1:
n = 6

x [i] = 0.5, i = 2 ... 5

x [3] = x [4] = 0.5 x [2] = 0 x [5] = 1

всі x [i] = 0 або 1

Решта набори

n = 5


n = 4

0

Додаток № 5. Результати роботи програми № 3.
p = 2.000000 q = 2.000000 max = 0.707107
Nabor: x [0] = 0.000000 x [1] = 0.600000 x [2] = 0.700000 x [3] = 1.000000
p = 2.000000 q = 2.100000 max = 0.696478
Nabor: x [0] = 0.000000 x [1] = 0.300000 x [2] = 0.700000 x [3] = 1.000000
p = 2.000000 q = 2.200000 max = 0.686567
Nabor: x [0] = 0.000000 x [1] = 0.300000 x [2] = 0.700000 x [3] = 1.000000
p = 2.000000 q = 2.300000 max = 0.677294
Nabor: x [0] = 0.000000 x [1] = 0.300000 x [2] = 0.700000 x [3] = 1.000000
p = 2.000000 q = 2.400000 max = 0.668738
Nabor: x [0] = 0.000000 x [1] = 0.200000 x [2] = 0.800000 x [3] = 1.000000
p = 2.000000 q = 2.500000 max = 0.660879
Nabor: x [0] = 0.000000 x [1] = 0.200000 x [2] = 0.800000 x [3] = 1.000000
p = 2.000000 q = 2.600000 max = 0.653565
Nabor: x [0] = 0.000000 x [1] = 0.200000 x [2] = 0.800000 x [3] = 1.000000
p = 2.000000 q = 2.700000 max = 0.646741
Nabor: x [0] = 0.000000 x [1] = 0.200000 x [2] = 0.800000 x [3] = 1.000000
p = 2.000000 q = 2.800000 max = 0.640603
Nabor: x [0] = 0.000000 x [1] = 0.100000 x [2] = 0.900000 x [3] = 1.000000
p = 2.000000 q = 2.900000 max = 0.635019
Nabor: x [0] = 0.000000 x [1] = 0.100000 x [2] = 0.900000 x [3] = 1.000000