3.5. Метод простых итераций (Лабораторная работа №6)

187. Метод простых итераций решения уравнения состоит в замене исходного уравнения эквивалентным ему уравнениемx=(x) и построении последовательности x_n+1=(x_n), сходящейся при n к точному решению. Достаточные условия сходимости метода простых итераций формулируются теоремой, приведенной [1,2,7].

188. Рассмотрим один шаг итерационного процесса. Исходя из найденного на предыдущем шаге значения x_n-1, вычисляется y= (x_n-1). Если , то полагаетсяx_n=y и выполняется очередная итерация. Если же , то вычисления заканчиваются и за приближенное значение корня принимается величинаx_n=y. Погрешность результата вычислений зависит от знака производной : при>0 погрешность определения корня составляет qq, а при <0 погрешность не превышает . Здесь q- число, такое, что q на отрезке [a,b]. Существование числа q является условием сходимости метода в соответствии с отмеченной выше теоремой.

189. Для применения метода простых итераций определяющее значение имеет выбор функции в уравнении, эквивалентном исходному. Функциюнеобходимо подбирать так, чтобыq. Это обусловливается тем, что если <0 на отрезке [a,b], то последовательные приближения x_n=(x_n-1) будут колебаться около корня c, если же >0, то последовательные приближения будут сходиться к корню c монотонно. Следует также помнить, что скорость сходимости последовательности {x_n} к корню c функции тем выше, чем выше числоq.

190. В лабораторной работе № 6 предлагается, используя программы-функции ITER и Round из файла methods.cpp (файл заголовков methods.h, директория LIBR1), найти корень уравнения с заданной точностьюEps методом итераций, исследовать скорость сходимости и обусловленность метода.

191. Для данной работы вид функции задается индивидуально каждому студенту преподавателем из числа вариантов, приведенных в подразделе 3.6.

192. Порядок выполнения лабораторной работы №6 должен быть следующим.

1. Графически или аналитически отделить корень уравнения .

2. Преобразовать уравнение к видутак, чтобы в некоторой окрестности[Left, Right] корня производная удовлетворяла условиюq. При этом следует иметь в виду, что чем меньше величина q, тем быстрее последовательные приближения сходятся к корню.

3. Выбрать начальное приближение, лежащее на [Left, Right].

4. Составить подпрограмму для вычисления значений ,, предусмотрев округление вычисленных значений с точностьюDelta.

5. Составить головную программу, вычисляющую корень уравнения и содержащую обращение к программам ,иITER и индикацию результатов.

6. Провести вычисления по программе. Исследовать скорость сходимости и обусловленность метода.

193. Текст программы - функции ITER, позволяющей вычислять корни уравнения x=для любой функции, которая удовлетворяет достаточным условиям сходимости метода, приводится ниже.

3.6. Курсовая работа по дисциплине и варианты заданий

196. Лабораторные работы, описанные в настоящем разделе, целесообразно объединять для выполнения курсовой работы, нацеленной на сравнительную оценку различных методов приближенного решения нелинейных уравнений. Типовое задание на курсовую работу формулируется следующим образом.

197. Задание на курсовую работу по дисциплине "Вычислительная математика".

198. Используя программы - функции BISECT, NEWTON, HORDA, ITER, Round из файла methods.cpp (файл заголовков methods.h, директория LIBR1), найти корень уравнения с заданной точностью методом бисекции, Ньютона, хорд и итераций соответственно.

199. Исследуйте обусловленность методов и зависимость числа итераций от точности результата Eps при изменении Eps от 0.0 до 0.000001.

200. Порядок выполнения курсовой работы

201. Графически или аналитически отделить корень уравнения (т.е. найти отрезки [Left, Right], на которых функция удовлетворяет условиям применимости методов).

202. Составить подпрограмму- функцию вычисления функции и ее производной(при необходимости), предусмотрев округление их значений с заданной точностьюDelta с использованием библиотечной функции Round.

203. Составить головную программу, содержащую ввод исходных данных, обращение к подпрограммам BISECT, NEWTON, HORDA, ITER вывод результатов.

204. Выполнить вычисления по программе. Построить графики зависимости числа итераций, необходимых для достижения заданной точности Eps, от величины Eps, а также достижимой точности результатов от точности Delta задания функции .

205. Теоретически и экспериментально сравнить методы бисекции, Ньютона, хорд и итераций по скорости сходимости и степени обусловленности.

206. Результаты оформить в виде отчета, содержащего постановку задачи, тексты разработанных программ, результаты теоретического и экспериментального анализа в виде таблиц и графиков, выводы.

207. Вид функции определяется вариантом задания. Эти же варианты могут использоваться при выполнении лабораторных работ №№3-6 по отдельности.

№ п/п		№ п/п
1	;	19
2	;	20	;
3	;	21	;
4	;	22	;
5	;	23	;
6	;	24	;
7	;	25	;
8	;	26	;
9	;	27	;
10	;	28	;
11	;	29	;
12	;	30	;
13	;	31	;
14	;	32	;
15	;	33	;
16	;	34	;
17	;	35	;
18	;	36	;

3.7. Программы для решения нелинейных уравнений

209. Текст заголовочного файла methods.h.

210. /*******************************************************************/

211. extern double F(double);

212. /******************************************************************/

213. /* Функция F (X) , задаваемая пользователем */

214. /******************************************************************/

216. #ifdef __NEWTON

217. extern double F1(double);

218. /******************************************************************/

219. /* Производная функции F (X) , задаваемая пользователем */

220. /******************************************************************/

221. #endif

223. double Round (double X,double Delta);

224. /******************************************************************/

225. /* Функция Round (X,Delta) , предназначена для округления */

226. /* X с точностью Delta */

227. /******************************************************************/

229. double BISECT(double Left,double Right,double Eps,int &N);

230. /******************************************************************/

231. /* Функция BISECT предназначена для решения уравнения F(X)=0 */

232. /* методом деления отрезка пополам. Использованы обозначения: */

233. /* Left - левый конец промежутка */

234. /* Right - правый конец промежутка */

235. /* Eps - погрешность вычисления корня уравнения; */

236. /* N - число итераций */

237. /******************************************************************/

239. double ITER(double X0,double Eps,int &N);

240. /******************************************************************/

241. /* Функция ITER предназначена для решения уравнения F(X)=X */

242. /* методом простой итерации. Использованы обозначения: */

243. /* X0 - начальное приближение корня */

244. /* Eps - погрешность вычисления корня уравнения; */

245. /* N - число итераций */

246. /******************************************************************/

248. double HORDA(double Left,double Right,double Eps,int &N);

249. /******************************************************************/

250. /* Функция HORDA предназначена для решения уравнения F(x)=0 */

251. /* методом хорд. Использованы обозначения: */

252. /* Left - левый конец промежутка */

253. /* Right - правый конец промежутка */

254. /* Eps - погрешность вычисления корня уравнения; */

255. /* N - число итераций */

256. /******************************************************************/

258. double NEWTON (double X,double Eps,int &N);

259. /******************************************************************/

260. /* Функция NEWTON предназначена для решения уравнения F(X)=0 */

261. /* методом касательных. Использованы обозначения: */

262. /* X - начальное приближение корня */

263. /* Eps - погрешность вычисления корня уравнения; */

264. /* N - число итераций */

265. /******************************************************************/

267. #include "methods.cpp"

268. /************************************************************************/

270. Текст программного модуля methods.cpp.

272. /*********************************************/

273. #include <stdio.h>

274. #include <math.h>

275. #include <stdlib.h>

276. extern double F(double);

277. double BISECT(double Left,double Right,double Eps,int &N)

278. {

279. double E = fabs(Eps)*2.0;

280. double FLeft = F(Left);

281. double FRight = F(Right);

282. double X = (Left+Right)/2.0;

283. double Y;

284. if (FLeft*FRight>0.0) {puts("Неверное задание интервала\n");exit(1);}

285. if (Eps<=0.0) {puts("Неверное задание точности\n");exit(1);}

286. N=0;

287. if (FLeft==0.0) return Left;

288. if (FRight==0.0) return Right;

289. while ((Right-Left)>=E)

290. {

291. X = 0.5*(Right + Left); /* вычисление середины отрезка */

292. Y = F(X);

293. if (Y == 0.0) return (X);

294. if (Y*FLeft < 0.0)

295. Right=X;

296. else

297. { Left=X; FLeft=Y; }

298. N++;

299. };

300. return(X);

301. }

302. double Round (double X,double Delta)

303. {

304. if (Delta<=1E-9) {puts("Неверное задание точности округления\n");exit(1);}

305. if (X>0.0) return (Delta*(long((X/Delta)+0.5)));

306. else return (Delta*(long((X/Delta)-0.5)));

307. }

308. double ITER(double X0,double Eps,int &N)

309. {

310. if (Eps<=0.0) {puts("Неверное задание точности\n");exit (1);}

311. double X1=F(X0);

312. double X2=F(X1);

313. N = 2;

314. while( (X1 - X2)*(X1 - X2) > fabs((2*X1-X0-X2)*Eps) )

315. {

316. X0 = X1;

317. X1 = X2;

318. X2 = F(X1);

319. N++;

320. }

321. return(X2);

322. }

323. #ifdef __NEWTON

324. double NEWTON (double X,double Eps,int &N)

325. {

326. extern double F1 (double);

327. double Y,Y1,DX;

328. N=0;

329. do

330. {

331. Y = F(X);

332. if (Y==0.0) return (X);

333. Y1 = F1(X);

334. if (Y1==0.0) {puts("Производная обратилась в ноль\n");exit(1);}

335. DX=Y/Y1; X=X-DX; N++;

336. }

337. while (fabs(DX)>Eps);

338. return (X);

339. }

340. #endif

341. double HORDA(double Left,double Right,double Eps,int &N)

342. {

343. double FLeft = F(Left);

344. double FRight = F(Right);

345. double X,Y;

346. if (FLeft*FRight>0.0) {puts("Неверное задание интервала\n");exit(1);}

347. if (Eps<=0.0) {puts("Неверное задание точности\n");exit(1);}

348. N=0;

349. if (FLeft==0.0) return Left;

350. if (FRight==0.0) return Right;

351. do

352. {

353. X = Left-(Right-Left)*FLeft/(FRight-FLeft);

354. Y = F(X);

355. if (Y == 0.0) return (X);

356. if (Y*FLeft < 0.0)

357. { Right=X; FRight=Y; }

358. else

359. { Left=X; FLeft=Y; }

360. N++;

361. }

362. while ( fabs(Y) >= Eps );

363. return(X);

364. }

365. /*********************************************************/