C lengoaia ☀ ariketak: Ariketa 30 | Newton-en metodoa, erro karratua eta erro kuboa

ZER DAKIDAN:
Dagoeneko for, do-while eta while agindu errepikakorra erabili ditut. Baina bakoitza edozein egoeratan erabil daiteke?

ZER IKASIKO DUDAN:
Prozesu errepikakorraren iterazio kopurua ezezaguna denean, do-while edo while agindu errepikakorrak erabiliko ditut.

Newton-en hurbilketa-metodoa √n eta ∛n kalkulatzeko

Ariketa 29 | Newton-en metodoa, bigarren graduko edozein parabolarekin azaldutako ariketa erabiliko dugu zenbaki baten erro koadroa kalkulatzeko, baldin eta ax²+bx+c parabolaren koefizienteak egokiak badira.

ax²+bx+c parabola orokorraren koefizienteak hauek izanik:

a=1

b=0

c=-n

Ateratzen den ekuazioa x²-n=0 da (edo x²=n).
Ondorioz, x erroa n-ren erro karratua x=∓√n izango da.

Esate baterako, alboko irudian ikusten den bezala c=-2 denean, ekuazioa x²-2=0 da (edo x²=2). Horregatik x erroa, 2-ren erro karratua x=∓√2=∓1.4142 izango da.

Newton–Raphson metodoa (Newton-en metodo gisa ere ezagutzen dena) zenbakizko analisi-metodo bat da. Metodo honek funtzioen erro gero eta hobeak lortzen ditu, hau da, funtzioa zero egiten duen x balioa bilatzen du. Beste modu batez esanik, funtzioak OX ardatza mozten duen balioa (funtzioaren erroa) ematen du Newton–Raphson metodoak. Algoritmoa erroaren hurbilketa batekin hasten da eta urrats bakoitzean erroaren hurbilketa hobea lortzen du.

Aldagai bakarreko funtzio errealen kasuan honakoa da metodoa:

Izan bedi ƒ funtzioa x errealentzat definitua, eta izan bedi ƒ' bere deribatua. Erroaren hasierako hurbilketa bat behar dugu, x₀. Erroaren hurbilketa horretan oinarrituz hurbilketa hobea izango den x₁ honelaxe lortzen da:

Iterazioak eginez, n+1 hurbilketa n hurbilketan oinarritzen da formula honen arabera:

Formula horren zergatia geometrikoki adieraz daiteke. Hurrengo irudiko lerro urdina f(x) funtzioa da, eta lerro zuzen gorria f(x) funtzioaren tangentea (x_n, f(x_n)) puntuan:

Berde koloreko distantziari hobekuntza deitzen badiogu, orduan alfa angeluaren tangentea f(x_n)/hobekuntza litzateke, baina tangente hori f(x) funtzioaren deribatua (x_n, f(x_n))puntuan da, lerro zuzen gorriaren malda alfa angeluaren tangentea da. Horregatik:

tag(alfa)= f(x_n)/hobekuntza eta aldi berean tag(alfa)=malda= f'(x_n)
beraz f'(x_n)= f(x_n)/hobekuntza (non hobekuntza=x_n-x_n+1)

f'(x_n)= f(x_n)/(x_n-x_n+1) nondik x_n-x_n+1= f(x_n)/f'(x_n)

x_n+1= x_n- f(x_n)/f'(x_n)

n zenbaki erreal positibo baten erro koadroa kalkula dezagun. Hona hemen, Newton–Raphson metodotik eratorren formula:

x_n+1= x_n- f(x_n)/f'(x_n)

n ezaguna izanik x lortu: x = √n

x² = n

x²—n = 0

f(x) = x²—n

f'(x) = 2x

x_i+1= x_i- f(x_i)/f'(x_i)

x_i+1= x_i- (x_i²—n)/2x_i

Programaren zuzentasuna konprobatzeko sqrt() funtzio estandarra aplika daiteke.

Hona hemen zenbaki baten erro karratua kalkulatzen duen Ariketa-30a_NewtonHurbilketaMetodoa programaren kodea:

/* Ariketa-30a_NewtonMetodoa-ErroKarratua: do-while */

//    Newton-Raphson metodoa
//    ----------------------
//    Xi+1 = Xi - f(Xi)/f'(Xi)
//    Xi+1 = Xi - (X¡*Xi - N) / 2*Xi
//    Xi+1 = (N/Xi + Xi) / 2

//    Irteteko baldintza, jarraitu hau betetzean:
//    fabs(Xi+1 - Xi) > fDoitasuna

//    -------

//    Bigarren graduko edozein parabola
//    Ax^2 + Bx + C = 0

//    f(x) = x^3 - N
//    f'(x) = 3x^2

//    Newton-Raphson metodoa
//    Xi+1 = Xi - f(Xi)/f'(Xi)
//    Xi+1 = Xi - (AXi^2 + BXi + C)/(2AXi + B)

//    -------

//    Bigarren graduko parabola berezia
//    A=1, B=0, C=-N  --> x^2 - N = 0

//    f(x) = x^2 - N
//    f'(x) = 2x

//    Newton-Raphson metodoa
//    Xi+1 = Xi - f(Xi)/f'(Xi)
//    Xi+1 = Xi - (Xi^2 - N)/2Xi
//    Kontuz Xi ez dadila zero izan, halakoetan
//    beste datu bat hautatu.

#include <stdio.h>
#include <math.h> // sqrt() funtziorako

int main()
{
    double fZbk, fEmaitza, fAurrekoa;

    printf("\n");
    printf("   NEWTON vs. SQRT()\n");
    printf("   Eskuko kalkulagailu balitz bezala lan eginez\n");

    do // zero ez den zenbaki positiboa eskatu erabiltzaileari
    {
        printf("   Zenbaki positiboa eman (datu bakarra): ");
        scanf("%lf", &fZbk);
        if (fZbk <= 0.0)
            printf("   Datua 0.0 baino handiagoa izan dadila\n");
    } while (fZbk <= 0.0);

    fEmaitza = fZbk / 2.0; // lehenengo hurbilketa

    printf("   rEPSILOM = %.9f   rHurbilketa = %.9f\n", rEPSILOM, fEmaitza);
    printf("\n");

    do // Newton-Raphson iterazio metodoa erro karratua kalkulatzeko
    {
        fAurrekoa = fEmaitza;
        fEmaitza = fAurrekoa - (fAurrekoa * fAurrekoa - fZbk) / (2 * fAurrekoa);
        printf("fAurrekoa=%22.16f     fEmaitza=%22.16f\n", fAurrekoa, fEmaitza);
    } while (fabs(fEmaitza - fAurrekoa) > rEPSILOM);

    printf("\n");
    printf("%.4f-ren erro koadroa (Newton-Raphson) %.16f da\n", fZbk, fEmaitza);
    printf("%.4f-ren erro koadroa sqrt() funtzioaz %.16f da\n", fZbk, sqrt(fZbk));

    printf("\n");
    printf("============================\n");
    printf("ENTER tekla sakatu amaitzeko\n");
    printf("============================\n");

    getchar(); // ENTER teklari itxaron (bufferra garbitzeko)
    getchar(); // edozein tekla sakatu programatik irteteko
    return 0;
}

Grafiko interaktiboarekin lan egiteko, sakatu x^3 —27000 funtzioan edo irudiaren gainean

n zenbaki erreal positibo baten erro kubikoa kalkula dezagun. Hona hemen, Newton–Raphson metodotik eratorrren formula:

Konprobazioa egiteko, logaritmoak har daitezke programan:

x³ = n     x = n^1/3    log(x) = log(n^1/3)    x = exp(log(n^1/3))    x = exp(1/3·log(n))

Hona hemen zenbaki baten erro karratua kalkulatzen duen Ariketa-30a_NewtonHurbilketaMetodoa programaren kodea:

/* Ariketa-30b_NewtonMetodoa-ErroKuboa: do-while */

//    Newton-Raphson metodoa
//    ----------------------
//    Xi+1 = Xi - f(Xi)/f'(Xi)
//    Xi+1 = Xi - (X¡*Xi - N) / 2*Xi
//    Xi+1 = (N/Xi + Xi) / 2

//    Irteteko baldintza, jarraitu hau betetzean:
//    fabs(Xi+1 - Xi) > fDoitasuna

//    -------

//    Hirugarren graduko parabola
//    x^3 - N = 0  ->  x^3 = N

//    f(x) = x^3 - N
//    f'(x) = 3X^2

//    Newton-Raphson metodoa
//    Xi+1 = Xi - f(Xi)/f'(Xi)
//    Xi+1 = Xi - (Xi^3 - N)/3Xi^2
//    Xi+1 = (N/Xi^2 + 2Xi)/3

//    Kontuz Xi ez dadila zero izan, halakoetan
//    beste datu bat hautatu.

#include <stdio.h>
#include <math.h>  // log() eta exp() funtzioetarako

int main()
{
    double fZbk, fEmaitza, fAurrekoa;

    printf("\n");
    printf("   NEWTON vs. SQRT()\n");
    printf("   Eskuko kalkulagailu balitz bezala lan eginez\n");

    do // zero ez den zenbaki positiboa eskatu erabiltzaileari
    {
        printf("   Zenbaki positiboa eman (datu bakarra): ");
        scanf("%lf", &fZbk);
        if (fZbk <= 0.0)
            printf("   Datua 0.0 baino handiagoa izan dadila\n");
    } while (fZbk <= 0.0);

    fEmaitza = fZbk / 2.0; // lehenengo hurbilketa

    printf("   rEPSILOM = %.9f   rHurbilketa = %.9f\n", rEPSILOM, fEmaitza);
    printf("\n");

    do // Newton-Raphson iterazio metodoa erro karratua kalkulatzeko
    {
        fAurrekoa = fEmaitza;
        fEmaitza = fAurrekoa - (fAurrekoa * fAurrekoa - fZbk) / (2 * fAurrekoa);
        printf("fAurrekoa=%22.16f     fEmaitza=%22.16f\n", fAurrekoa, fEmaitza);
    } while (fabs(fEmaitza - fAurrekoa) > rEPSILOM);

    printf("\n");
    printf("%.4f-ren erro koadroa (Newton-Raphson) %.16f da\n", fZbk, fEmaitza);
    printf("%.4f-ren erro koadroa sqrt() funtzioaz %.16f da\n", fZbk, sqrt(fZbk));

    printf("\n");
    printf("============================\n");
    printf("ENTER tekla sakatu amaitzeko\n");
    printf("============================\n");

    getchar(); // ENTER teklari itxaron (bufferra garbitzeko)
    getchar(); // edozein tekla sakatu programatik irteteko
    return 0;
}