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

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

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

366. extern double F(double);

367. /******************************************************************/

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

369. /******************************************************************/

371. #ifdef __NEWTON

372. extern double F1(double);

373. /******************************************************************/

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

375. /******************************************************************/

376. #endif

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

379. /******************************************************************/

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

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

382. /******************************************************************/

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

385. /******************************************************************/

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

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

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

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

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

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

392. /******************************************************************/

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

395. /******************************************************************/

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

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

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

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

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

401. /******************************************************************/

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

404. /******************************************************************/

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

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

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

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

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

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

411. /******************************************************************/

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

414. /******************************************************************/

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

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

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

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

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

420. /******************************************************************/

421. #include "methods.cpp"

422. /************************************************************************/

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

426. /*********************************************/

427. #include <stdio.h>

428. #include <math.h>

429. #include <stdlib.h>

430. extern double F(double);

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

432. {

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

434. double FLeft = F(Left);

435. double FRight = F(Right);

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

437. double Y;

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

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

440. N=0;

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

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

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

444. {

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

446. Y = F(X);

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

448. if (Y*FLeft < 0.0)

449. Right=X;

450. else

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

452. N++;

453. };

454. return(X);

455. }

456. double Round (double X, double Delta)

457. {

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

459. exit(1);}

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

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

462. }

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

464. {

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

466. double X1=F(X0);

467. double X2=F(X1);

468. N = 2;

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

470. {

471. X0 = X1;

472. X1 = X2;

473. X2 = F(X1);

474. N++;

475. }

476. return(X2);

477. }

478. #ifdef __NEWTON

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

480. {

481. extern double F1 (double);

482. double Y,Y1,DX;

483. N=0;

484. do

485. {

486. Y = F(X);

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

488. Y1 = F1(X);

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

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

491. }

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

493. return (X);

494. }

495. #endif

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

497. {

498. double FLeft = F(Left);

499. double FRight = F(Right);

500. double X,Y;

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

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

503. N=0;

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

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

506. do

507. {

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

509. Y = F(X);

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

511. if (Y*FLeft < 0.0)

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

513. else

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

515. N++;

516. }

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

518. return(X);

519. }

520. /*********************************************************/