3. astea | bigarren graduko ekuazioa

Matematikan, aldagai bakarreko bigarren mailako ekuazioa edo ekuazio koadratikoa honela adierazten den aldagai bakarreko ekuazio polinomiko bat da:   a x² + b x + c = 0




Bigarren mailako ekuazioaren soluzioari erro esaten zaio eta ondoko irudiko formula honek ematen du:

Formula horren b²-4ac zatiari diskriminatzaile esaten zaio eta Δ bitartez adierazten da (Δ, delta izeneko letra maiuskula grekoaz). Diskriminatzailearen arabera, bigarren mailako ekuazio batek, koefizienteak zenbaki errealak izanik, soluzio desberdinak izan ditzake:

• Δ > 0, diskriminatzailea positiboa bada, bi soluzioak zenbaki erreal dira.


• Δ = 0, diskriminatzailea 0 bada, soluzioa bakarra da eta gainera zenbaki erreala.


• Δ < 0, diskriminatzailea negatiboa bada, ez dago erro errealik eta bi soluzioak zenbaki konplexuak dira eta bata bestearen zenbaki konplexu konjugatu dira.

ARIKETA: Bigarren mailako ekuazio baten rA, rB eta rC koefizienteak teklatuaren bitartez irakurri eta ekuazio koadratiko horren soluzioa nolakoa den pantailaratu, hau da, erroak nolakoak diren pantailan idatzi. Ariketa honek begi bistako hedapena du, hots, erroak nolakoak diren zehazteaz gain erroak kalkulatzea.

---

Aldagai boolearrak erabiliz

Orain arte ikasitakoa gogoratuz, hiru aldagai boolear deklaratu eta diskrimanatzailearen arabera balioak esleituko genizkioke, bukatzeko aldagai boolear horien edukiak pantailaratuko genituzke. Honela:

            rDiskr := rB*rB - 4*rA*rC ;
            boErrealBi      := rDiskr > 0 ;
            boErrealBakarra := rDiskr = 0 ;
            boIrudikariBi   := rDiskr < 0 ;

Hemen daukazu Erroak0.pas iturburu-programa, non koefizienteak teklatuz irakurri ondoren, hiru aldagai boolearrentzat balioak kalkulatzen diren eta ostean balio horiek pantailara kanporatzen diren:

program NolakoErroakDiren_AldagaiBoolearrekin;
var
    rA, rB, rC, rDiskr: real;
    boErrealBi, boErrealBakarra, boIrudikariBi: Boolean;
begin
   write('A koefizientearen balioa eman: ');
   readln(rA);
   write('B koefizientearen balioa eman: ');
   readln(rB);
   write('C koefizientearen balioa eman: ');
   readln(rC);

   rDiskr := sqr(rB) - 4*rA*rC;

   boErrealBi      := rDiskr > 0;
   boErrealBakarra := rDiskr = 0;
   boIrudikariBi   := rDiskr < 0;

   writeln;
   writeln('Erroak bi erreal dira:   ', boErrealBi);
   writeln('Erroa erreal bakarra da: ', boErrealBakarra);
   writeln('Erroak irudikariak dira: ', boIrudikariBi);
	
   writeln;
   writeln;
   writeln('=======================');
   writeln('RETURN sakatu amaitzeko');
   writeln('=======================');
   readln;
end. { PROGRAMAREN BUKAERA }

---

IF-THEN kontrol-egitura erabiliz

Aldagai boolearrak erabili ordez adierazpen logikoak erabil ditzagun IF-THEN kontrol-egitura batekin batera. Programa bakar bat izango da eta programa beraren irteera posibleak hauek izan daitezke rA, rB eta rC koefizienteen balioen arabera:

Bigarren graduko ekuazio baten erroak nolakoak diren jakiteko algoritmo hau erabil daiteke:

Algoritmo hori jarraitzen duen iturburu-programa Erroak1.pas da, non IF-THEN sententziak isolaturik dauden elkarrekiko. Programa hobeto ulertzeko ikusi bere algoritmoaren fluxu-diagrama:

---

IF-THEN-ELSE kontrol-egitura erabiliz

IF-THEN kontrol-egitura erabili ordez bere hedapena den IF-THEN-ELSE kontrol-egitura bitartez ekin diozaiogun ariketa berari. Oraingoak erroak nolakoak diren zehazteaz gain, erroak kalkulatu egingo ditugu.

rA, rB eta rC koefizienteak dituen bigarren graduko ekuazio baten erroak nolakoak eta zeintzuk diren jakiteko Erroak2.pas iturburu-programa idatzi da. Programa horrek erroak kalkulatzen ditu eta oraingoan IF-THEN-ELSE bi erabili dira, ikusi nola kontrol-sententzia bat bestearen barruan kabiatuta dagoen. Hauek dira programaren algoritmoa eta fluxu-diagrama:

 

3. astea | angelua 1. koadrantera eraman

Demagun angelu bat irakurriko dugula teklatuaren bitartez, bere balioa aldagai erreal batean gordez. Berdintsu litzateke angelua radianetan zein graduetan ematea, edozein modutan honelako lau egoera batean egongo ginateke:

Goiko irudi horietan erakusten den bezala, datua den angelua handia denean, hainbat bira eman ondoren koadranteren batean eroriko da. Datua den angeluaren baliokidea kalkulatzea helburutzat harturik, emaitza bi hauek zehaztu behar ditugu:

• Teklatuz eman den angeluaren koadrantea


• 1. koadranteko angelu efektiboa

Emaitza horiek lortzeko bidean, sarrerako datuak izan ditzakeen soberazko birak kentzea da lehen lana. Soberazko birak kendu ondoren jarraian erakusten diren egoerak izango genitzake. Non, sarrerako angeluaren koadrantea ezaguna delarik, helburuko angelu efektiboa kenketa batez kalkulatzen den:

Hona hemen balizko programaren irteera bat:

Eta hemen programaren kodea: 

{ -----------------------------------------------------------------------------
   Edozeien koadranteko angelua eman radianetan eta 1. koadranteko
   angelu baliokidea kalkulatu graduetan. Horrek esan nahi du emaitzak
   bi izango direla:
         - jatorrizko angeluaren koadrantea
         - 1. koadranteko angelu efektiboa 
  -----------------------------------------------------------------------------}

program Radianak_1_KoadranteraEraman;
var
   rDatuaRadianetan: real;      // datua
   rDatuaGradutan: real;        // laguntzailea
   rItzuliKopurua: real;        // laguntzailea
   rItzulienHondarra: real;     // laguntzailea
   rGraduMoldatuak: real;       // laguntzailea
   iKoadrantea: integer;        // emaitza
   rGraduEfektiboak: real;      // emaitza
   rSinua: real;                // laguntzailea
   rKosinua: real;              // laguntzailea
begin
   writeln;
   writeln('//////////////////////////////////////////////////////////////////////////');
   writeln;
   
   repeat
      writeln('Edozein koadranteko angelu positiboa eman radianetan, adibidez:');
      writeln('   32.76 radian 1. koadranteko angelua izan dadin');
      writeln('   34.43 radian 2. koadranteko angelua izan dadin');
      writeln('   28.31 radian 3. koadranteko angelua izan dadin');
      writeln('   31.24 radian 4. koadranteko angelua izan dadin');
      write('Radianak eman: ');
      readln(rDatuaRadianetan);
   until rDatuaRadianetan >= 0.0;
   
   writeln;
   writeln('-----Gradu Moldatuak kalkulatu-------------------------------------');
   
   writeln('rDatuaRadianetan = ':35, rDatuaRadianetan:0:5, ' radian');
   
   rDatuaGradutan := (rDatuaRadianetan*360)/(2*PI);
   writeln('rDatuaGradutan = ':35, rDatuaGradutan:0:5, ' gradu');
   
   rItzuliKopurua := rDatuaGradutan/360;
   writeln('rItzuliKopurua = ':35, rItzuliKopurua:0:5, ' itzuli');
   
   rItzulienHondarra := frac(rItzuliKopurua);
   writeln('rItzulienHondarra = ':35, rItzulienHondarra:0:5, ' itzuli');

   rGraduMoldatuak := rItzulienHondarra*360;
   writeln('rGraduMoldatuak = ':35, rGraduMoldatuak:0:5, ' gradu');
   
   writeln;
   writeln('-----Koadrantea eta gradu efektiboak kalkulatu---------------------');
   
   if (rGraduMoldatuak < 90.0) and (rGraduMoldatuak >= 0.0) then
   begin
      iKoadrantea := 1;
      rGraduEfektiboak := rGraduMoldatuak;
   end;
      
   if (rGraduMoldatuak < 180.0) and (rGraduMoldatuak >= 90.0) then
   begin
      iKoadrantea := 2;
      rGraduEfektiboak := 180 - rGraduMoldatuak;
   end;
      
   if (rGraduMoldatuak < 270.0) and (rGraduMoldatuak >= 180.0) then
   begin
      iKoadrantea := 3;
      rGraduEfektiboak := 270 - rGraduMoldatuak;
   end;
      
   if (rGraduMoldatuak < 360.0) and (rGraduMoldatuak >= 270.0) then
   begin
      iKoadrantea := 4;
      rGraduEfektiboak := 360 - rGraduMoldatuak;
   end;

   writeln('Koadrantea = ':35, iKoadrantea, '. koadrantea');
   writeln('rGraduEfektiboak = ':35, rGraduEfektiboak:0:5, ' gradu');
   
   writeln;
   writeln('-----Emaitzak konprobatu sin() eta cos() funtzioak aplikatuz-------');
   
   writeln('Datua den angeluaren sinua = ':35, sin(rDatuaRadianetan):8:5);
   rSinua := sin(rGraduEfektiboak*(2*PI)/360);
   if (iKoadrantea = 3) or (iKoadrantea = 4) then
      rSinua := -rSinua;
   writeln('Angelu efektiboaren sinua = ':35, rSinua:8:5);
   
   writeln('Datua den angeluaren kosinua = ':35, cos(rDatuaRadianetan):8:5);
   rKosinua := cos(rGraduEfektiboak*(2*PI)/360);
   if (iKoadrantea = 2) or (iKoadrantea = 3) then
      rKosinua := -rKosinua;
   writeln('Angelu efektiboaren kosinua = ':35, rKosinua:8:5);
   
   writeln;
   writeln('//////////////////////////////////////////////////////////////////////////');
   
   writeln; writeln; writeln; writeln;
   readln;
end.

 

3. astea | ekuazio-sistema

Cramer-en metodoa egokia da ekuazio linealen sistemak ebazteko. Hona hemen ekuazio-sistema bat eta ikusi nola lortzen den bere ebazpena koefizienteen determinanteak erabiliz:

Koefiziente guztiak zenbaki errealak izanik, koefizienteak teklatuaren bitartez irakurri eta sistemaren ebazpena pantailan idatzi. 

Kontutan izan A·E - B·D = 0 baldin bada, programa konpilagarria izango dela, baina errorea gertatuko dela exekuzio-denboran.

Konpilatu izanak ez du esan nahi programa ondo dagoenik

2. astea | radianak bihurtu gradu-minutu-segundo

ADI! 2. astea | radianak bihurtu gradu-minutu-segundo ariketa hau eta 1. astea | billeteak eta txanponak desberdinak dira, batean abiapuntuko datua Real datu-motakoa delako eta bestean Integer datu-motakoa delako. Bestalde, proiektuaren ariketen artean programa hauxe eskatzen da. Ikusi proiektuaren blogean 4. Ariketa: zenbaki errealetik kopuru osora (I) izeneko ariketa.

Zergatik angeluak neurtzeko gradu-minutu-segundo unitateak erabiltzen dira? Orduak banatzerakoan minutuak eta segundoak darabilkigun formatuaren arrazoi historiko beragatik.

---

Sarrerako angelua positiboa izanik




rRadianak aldagaiak angelu baten radianak gordeko ditu, teklatuaren bitartez irakurriko den angelua hain zuzen ere. Radianetan datutzat aukeratu den angeluari dagozkion gradu, minutu eta segundo kalkulatuko dituen programa idatzi.

Sarrerako datua zenbaki erreala izango da, erreala eta positiboa. Graduak eta minutuak zenbaki osoak izango dira, eta segundoak zenbaki erreala izango da.

Sarrerako datua eta azken emaitza, bitarteko kalkuluak erakutsi gabe

Goiko irudiko programa hori gogoan duzula, hurrengo irudian erakusten da Radianak1.exe programa exekutagarriaren irteera bat. Bertan ikusten dira sarrerako datua, azken emaitzak eta bitarteko kalkuluak. Zure lana: irudiko irteera ematen duen Radianak1.pas iturburu-programa idaztea.

Sarrerako datua negatiboa denean emaitza ez da zuzena

---

Sarrerako angelua negatiboa izanik




Aurrekoaren ariketa berbera da baina orain rRadianak angeluaren aldagaia zenbaki erreala eta negatiboa izango da. Lehen bezala, graduak eta minutuak zenbaki osoak izango dira eta segundoak zenbaki erreala izango da.

Hartu hemendik Radianak2.exe programa exekutagarria eta ikusi nola dabilen sarrerako kopuru negatiboekin:

Sarrerako datua positiboa denean emaitza ez da zuzena

Zergatik angeluak neurtzeko gradu-minutu-segundo unitateak erabiltzen dira? Orduak neurtzeko arrazoi historiko beragatik.

---

Sarrerako angelua positiboa edo negatiboa izanik

Aurreko ariketa biak paretsuak dira eta zentzuduna izan daiteke programa bakar batean batzea. Horrek esan nahi du rRadianak sarrerako datua positiboa izatean agindu batzuk exekutatuko liratekeela, eta sarrerako angelua negatiboa izatean beste agindu batzuk exekutatuko liratekeela.

Oraindik ez dakigu nahikorik programa hori idazteko, baina hartu hemendik Radianak3.exe programa exekutagarria eta ikusi nola dabilen edozein sarrerako angeluarekin:

Sarrerako datua positiboa edo negatiboa onartzeaz gain segundoen

hamarrenak, ehunenak eta milarenak banaturik erakusten ditu

 

2. astea | erakarpen grabitatorioa

R distantzian daudenean, M₁ eta M₂ masak jasaten duten erakarpen grabitatorioaren balioa idatz ezazu. Programak aurreko hiru datuak eskatuko dizkio (M₁ eta M₂ kilogramoetan eta R metroetan) erabiltzaileari eta F indarraren balioa pantailaratuko du.

Non G hau den:

Gogoratu berdintsua den proiektuaren blogeko 3. Ariketa: datuak teklatuz irakurri adibidea.

 

2. astea | kartesiar-polar (radianetan)

Zenbaki errealekin lan eginez, puntu baten koordenatu kartesiarrak ezagutzen dira eta dagozkien koordenatu polarrak lortu behar dira (alfa angeluaren balioa radianetan eskatzen da). Ariketa honetan ondoko bi funtzio estandar hauek aplikatu behar dira:

• sqrt() funtzioak zenbaki baten erro karratua ematen du, emaitza zenbaki erreal bat izango da


• arctan() funtzioak tangente bati dagokion angelua ematen du radianetan, emaitza zenbaki erreal bat izango da

---

Ariketa:

XY planoan dagoen rP puntu baten koordenatu kartesiarretan teklatutik irakurri. rP puntuari dagozkion koordenatu polarrak lortu.

rP puntuaren koordenatu polarraren angelua gradu-minutu-segundotan radianetan pantailaratu.

Hauxe izan daiteke balizko kodifikazio bat:

{-----------------------------------------------------------
     Demagun P puntua lehen koadrantean dagoela, hots,
     P puntuaren koordenatu biak positiboak direla.

     Kontuz P puntua OY ardatzean dagoenean. Adibidez: 
     P(0.0, 7.2) denean Alfa angeluaren tangenteak
     infinitu balioko du eta ondorioz exekuzio-denborako
     errorea gertatuko da.
-----------------------------------------------------------}
PROGRAM KartesiarPolar ;

VAR
   rPx, rPy, rDist, rAng : Real ;

BEGIN
   WriteLn('//////////////////////////////////////') ;
   WriteLn ;

   Write('P puntuaren x koordenatua eman: ':40) ;   { sarrera hau kontrolatu beharko litzateke ezin daitekeelako 0.0 izan }
   ReadLn(rPx) ;
   Write('P puntuaren y koordenatua eman: ':40) ;
   ReadLn(rPy) ;
   
   rDist := sqrt(sqr(rPx) + sqr(rPy)) ; 
   rAng := arctan(rPy / rPx) ;  
 
   WriteLn ; 
   WriteLn('OP Distantzia = ':24, rDist:0:5, ' unitate') ;
   WriteLn('Alfa angelua  = ':24, rAng:0:5, ' radian') ;
   
   WriteLn ; 
   WriteLn('Koordenatuak:   (':25, rPx:0:3, ', ', rPy:0:3, ') = [', rDist:0:3, ' | ', rAng:0:3, ']') ;

   WriteLn ;
   WriteLn('//////////////////////////////////////') ;
   ReadLn ;
END. { PROGRAMAREN BUKAERA }

2. astea | 3 zifra eta 2 dezimaleko zenbaki erreal bat atzekoz aurrera

XYZ.AB ereduko zenbaki erreala atzekoz aurrera jarri: ZYX.BA

Aurreko egunetan ikusi genuen 1. astea | hiru zifrako zenbaki oso bat atzekoz aurrera ariketatik abiatuta ondoko hauek egingo ditugu:

1. Sarrerako datua den rDatua teklatuaren bitartez irakurri, suposatuz ReadLn prozedurari erantzutean XYZ.AB ereduko datua sartuko dugula, hots, 3 zifra alde osorako eta 2 dezimal (2 hamartar)
   



2. XYZ.AB ereduko datua Int eta Frac funtzioen bitartez bi zatitan banatuko dugu, zati bakoitza rAldeOsoa eta rAldeDezimala aldagaietan gordeko ditugu



3. XYZ.AB ereduko datuaren bi zatiak datu-mota osoak bezala adieraziko ditugu, horretarako Trunc eta Round funtzio biak erabili eta aztertu haien emaitzen arteko aldea (beheko irudiak ikusi). Ondorioz, zati bakoitza iAldeOsoa eta iAldeDezimala aldagaietan gordeta izango ditugu 



4. DIV eta MOD eragileen bitartez ehunekoak (X), hamarrekoak (Y, A) eta unitateak (Z, B) lortuko ditugu.



5. Eskatzen den rEmaitza konposatu bere edukiak ZYX.BA itxura duelarik

0.23456x10³ kopurua memorian gordetzean sistema informatikoak duen doitasunaren arabera egiten du (ikusi 234.5600000000000023 dela)

0.23457x10³ kopurua memorian gordetzean sistema informatikoak duen doitasunaren arabera egiten du (ikusi 234.5699999999999932 dela)

REAL datu-mota ikastean, irudi honen bitartez ikusi genuen zenbaki errealak zehaztasunik gabeak direla:

• 0.23456x10³ kopurua memorian kokatzean gehien hurbiltzen zaioa pixka bat handiagoa da


• 0.23457x10³ kopurua memorian kokatzean gehien hurbiltzen zaioa pixka bat txikiagoa da 

Beraz, ariketa honetan hobe da Round funtzioa aplikatzea eta ez Trunc funtzioa.

2. astea | zenbaki errealetik kopuru osora

Zenbaki errealetan bi atal desberdintzen dira: alde osoa eta alde dezimala. Eta zenbaki erreal bati dagokion zenbaki osoa lor dezakegu, esate baterako:

        readln(rDatua);
        iOsoaTrunkatua := trunc(rDatua);
        iOsoaBiribildua := round(rDatua);

Zenbaki erreal bat teklatuaren bitartez irakurri eta bere dagozkion bi zenbaki oso erakutsi. Horretarako Trunc eta Round funtzio estandarrak aplikatuko dira, emaitzak zenbaki osoak izango dira. Sarrerako datua den zenbaki errealaren balioa moztuz ala biribilduz emaitza lortuko dugu:

{------------------------------------------------------------------------------
      Sarrera zenbaki erreala izanik irteera zenbaki osoa izango da
       
      round() funtzioa mugan, parametroa X.5 denean:
                 X bakoitia izatean    round(X.5)  --->  X+1
                 X bikoitia izatean    round(X.5)  --->  X
-------------------------------------------------------------------------------}
program TruncRound_funtzioak;
var
   rZbk1, rZbk2: real;
   iOsoaTrunkatua: integer;      { integer datu-mota derrigorrez }
   iOsoaBiribildua: integer;     { integer datu-mota derrigorrez }
begin
   writeln;
   writeln;
   write('Zenbaki erreala eta positiboa eman: ');
   readln(rZbk1);
   writeln;
 
   iOsoaTrunkatua := trunc(rZbk1);
   iOsoaBiribildua := round(rZbk1);
   
   writeln('Hona hemen emandako zenbakia: ', rZbk1:0:3);
   writeln('trunc(', rZbk1:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', rZbk1:0:3, ') = ', iOsoaBiribildua);
   writeln;
   
   iOsoaTrunkatua := trunc(-rZbk1);
   iOsoaBiribildua := round(-rZbk1);
   
   writeln('Hemen emandakoaren negatiboa: ', -rZbk1:0:3);
   writeln('trunc(', -rZbk1:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', -rZbk1:0:3, ') = ', iOsoaBiribildua);
   writeln;
   writeln;
 
   rZbk2 := rZbk1 + 0.4;
   iOsoaTrunkatua := trunc(rZbk2);
   iOsoaBiribildua := round(rZbk2);
   
   writeln('Aurreko sarrerari 0.4 gehitu: ', rZbk2:0:3);
   writeln('trunc(', rZbk2:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', rZbk2:0:3, ') = ', iOsoaBiribildua);
   writeln;
   
   iOsoaTrunkatua := trunc(-rZbk2);
   iOsoaBiribildua := round(-rZbk2);
   
   writeln('Hementxe berriaren negatiboa: ', -rZbk2:0:3);
   writeln('trunc(', -rZbk2:0:3, ') = ', iOsoaTrunkatua);
   writeln('round(', -rZbk2:0:3, ') = ', iOsoaBiribildua);
   writeln;
   writeln;
 
   writeln('=======================');
   writeln('RETURN sakatu amaitzeko');
   write  ('_______________________');
   readln;
end. { PROGRAMAREN BUKAERA }

Ikusi ere zenbaki erreal baten bi atalak nola eskuratzen diren (2. astea | zenbaki erreal baten atalak).




Round() funtzioaren muga X.5 kopurua da eta bere emaitza X araberakoa da, jakin dezagun Round() funtzioaren biribiltze emaitza zenbaki bikoitia dela ondoko irudian erakusten den bezala:

Noiz Trunc() funtzioa eta noiz Round() funtzioa? Adibide batekin erantzungo dugu, baina lehenik gogoratuz zenbaki erreal guztiak ezin direla errepresentatu memorian gordetzeko, ikusi izan dugu "zuloak" geratzen direla bi zenbaki erreal artean.



Noiz Trunc() funtzioa eta noiz Round() funtzioa? galderaren harira adibide hau azter ezazu:
2. astea | 3 zifra eta 2 dezimaleko zenbaki erreal bat atzekoz aurrera  (XYZ.AB → ZYX.BA   autoebaluazioa) .

2. astea | zenbaki erreal baten atalak

Zenbaki errealetan bi atal desberdintzen dira: alde osoa eta alde dezimala.

        readln(rDatua);
        rAldeOsoa := int(rDatua);
        rAldeDezimala := frac(rDatua);

Zenbaki erreal bat teklatuaren bitartez irakurri eta bere atalak banatzeko funtzioak ikusten dira hemen. Sarrerako zenbaki errealaren atalak Int eta Frac funtzioek eskainiko dituzte eta zenbaki errealak izango dira ere, hots, bilatzen ditugun emaitzak zenbaki errealak izango dira:

{------------------------------------------------------------------------------
      Sarrera zenbaki erreala izanik irteera zenbaki erreala izango da
-------------------------------------------------------------------------------}
program IntFrac_funtzioak;
var
   rZbk1: real;
   rAldeOsoa: real;          { real datu-mota derrigorrez }
   rAldeDezimala: real;      { real datu-mota derrigorrez }
begin
   writeln;
   writeln;
   write('Zenbaki erreala eta positiboa eman: ');
   readln(rZbk1);
   writeln;

   rAldeOsoa := int(rZbk1);
   rAldeDezimala := frac(rZbk1);
   
   writeln('Hona hemen emandako zenbakia: ', rZbk1:0:3);
   writeln('  int(', rZbk1:0:3, ') = ', rAldeOsoa:0:3);
   writeln(' frac(', rZbk1:0:3, ') = ', rAldeDezimala:0:3);
   writeln;
   
   rAldeOsoa := int(-rZbk1);
   rAldeDezimala := frac(-rZbk1);
   
   writeln('Hemen emandakoaren negatiboa: ', -rZbk1:0:3);
   writeln('  int(', -rZbk1:0:3, ') = ', rAldeOsoa:0:3);
   writeln(' frac(', -rZbk1:0:3, ') = ', rAldeDezimala:0:3);
   writeln;
   writeln;

   writeln('=======================');
   writeln('RETURN sakatu amaitzeko');
   write  ('_______________________');
   readln;
end. { PROGRAMAREN BUKAERA }

Ikusi ere zenbaki erreal bat nola bihurtzen den zenbaki oso (2. astea | zenbaki errealetik kopuru osora).

1. astea | segundoen kopuruak

Datu-mota	Formatua	Balio kopurua 2N	Balioen heina edo barrutia
ShortInt	8 bit (+ eta -)	256	-128..127
Byte	8 bit (+)	256	0..255
SmallInt	16 bit (+ eta -)	65536	-32768..32767
Integer Integer	16 bit (+ eta -)  32 bit (+ eta -)	65536 4294967296	-32768..32767 -2147483648..2147483647
Word	16 bit (+)	65536	0..65535
LongInt	32 bit (+ eta -)	4294967296	-2147483648..2147483647

Goiko taula aintzakotzat harturik ondoko bi ariketak egin:






Ariketa_1:

INTEGER datu-motak 2 byte har ditzan, zure programan {$MODE TP} konpilazio-direktiba idatzi eta ondoko hau egin:
iSegundo kopuru handi bat teklatuz irakurri, non iSegundo aldagaia INTEGER datu-motakoa den. Irakurritako denbora pantailaratu orduak-minutuak-segundoak bezala (hiru balioetatik bat edo beste zero balitz, ez da pantailaratu beharko).

{-----------------------------------------------------------------
      Behartu INTEGER datu-motak 2 byte hartzera.
 ------------------------------------------------------------------}
program SegundoenKopurua_INTEGER;
{$MODE TP}

var
   iSegundo: integer;

Ariketa_2:

liSegundo kopuru erraldoi bat teklatuz irakurri, non liSegundo aldagaia LONGINT datu-motakoa den. Irakurritako denbora pantailaratu egunak-orduak-minutuak-segundoak bezala (hiru balioetatik bat edo beste zero balitz, ez da pantailaratu beharko).

{-----------------------------------------------------------------
      INTEGER datu-motak 2 byte edo 4 byte hartuko ditu.
      LONGINT datu-motak beti 4 byte hartuko ditu memorian.
 ------------------------------------------------------------------}
program SegundoenKopurua_LONGINT;

var
   liSegundo: longint;

1. astea | billeteak eta txanponak

ADI! 1. astea | billeteak eta txanponak ariketa hau eta aurrerago ikusiko den 2. astea | radianak bihurtu gradu-minutu-segundo ariketa desberdinak dira. Izan ere, kalkuluak era desberdinean burutzen dira ariketa batean abiapuntuko datua Integer datu-motakoa delako eta beste ariketan sarrerako datua Real datu-motakoa delako.

---

iEuroak euro kopurua emanik, kalkulatu zenbat 500, 200, 100, 50, 20, 10, eta 5 euroko billete, eta  euro bateko eta 2 euroko txanponak behar diren emandako kopurua osatzeko. Banaketa egitean billete eta txanpon kopurua ahalik eta txikien izan beharko dira.




Eskatzen den BilleteakTxanponak.pas programa hau 1. astea | hiru zifrako zenbaki oso bat atzekoz aurrera ariketa bezalakoa da. Eskatzen den BilleteakTxanponak.pas programa exekutatzean lor daitekeen balizko irteera bat hau izan daiteke:

Eskatzen den BilleteakTxanponak.pas iturburu-programari dagokion BilleteakTxanponak.exe programa exekutagarria hemendik jaso dezakezu: BilleteakTxanponak.exe.

1. astea | hiru zifrako zenbaki oso bat atzekoz aurrera

Osoa den hiru zifrako zenbakia atzekoz aurrera jarri

Idatz ezazu zera burutzen duen programa Pascal lengoaia erabiliz. Programak teklatutik hiru digituko zenbaki bakarra irakurri eta emandako hiru digituak alderantzizko ordenan idatzi egiten duena. Honez gain, alderantzizko ordenak osatzen duen zenbakia ere pantailaratuko du programak.

Adibidez:

Sartu hiru digituko zenbakia, 100 eta 999 artekoa: 123 Emandako zenbakiaren digituak atzekoz aurrera: 3, 2, 1 Sartutako zenbakia: 123 Atzekoz aurrerakoa: 321

Oharra: Erabiltzaileak sartutako zenbakia (123) lodian dago eta ReadLn bakar baten bitartez irakurri da programan. Ariketaren programabat hau izan daiteke:

{---------------------------------------------------------------------------
       Hiru zifrako zenbaki osoa irakurri, ondoren zifrak banan banan
       hartu eta sarreraren zenbaki simetrikoa osatu eta pantailaratu
 ---------------------------------------------------------------------------}

program HiruZifrakoZenbakiarenSimetrikoa ;

var
   iZenbakia, iSimetrikoa : integer ;
   iEhunekoak, iHamarrekoak, iUnitateak, iHondarra : integer ;

begin
   writeln('//////////////////////////////////////') ;
   writeln ;
   
   write('Sartu hiru digituko zenbakia, 100 eta 999 artekoa: ') ;
   readln(iZenbakia) ;

   iEhunekoak := iZenbakia div 100 ;
   iHondarra := iZenbakia mod 100 ;

   iHamarrekoak := iHondarra div 10 ;
   iUnitateak := iHondarra mod 10 ;

   writeln('Emandako zenbakiaren digituak atzekoz aurrera: ', iUnitateak, ', ', iHamarrekoak, ', ', iEhunekoak) ;

   iSimetrikoa := iUnitateak*100 + iHamarrekoak*10 + iEhunekoak ;

   writeln ;
   writeln('Sartutako zenbakia: ', iZenbakia) ;
   writeln('Atzekoz aurrerakoa: ', iSimetrikoa) ;

   writeln ;
   writeln ;
   writeln('=======================') ;
   writeln('RETURN sakatu amaitzeko') ;
   writeln('=======================') ;
   readln ;
end. { PROGRAMAREN BUKAERA }

Hemen daukazu programa hori exekutatzean lortzen den emaitzaren irudi bat:

Aurreko programa hau aintzat harturik, oso antzekoa den  1. astea | billeteak eta txanponak ariketari ekin.

Lengoaia ikasteko lehen urratsak

---

LENGOAIAREN FUNTSEZKO ELEMENTUAK




Dakigunez programa bat instrukzioen (edo sententzien) multzo bat da. Instrukzio bat funtsezko elementuetan bana daiteke. Instrukzio bat elementu desberdinaz osaturik dago, esanahi berezia duten elementu horiei token esaten zaie literatura anglosaxoian, eta gainerako hizkuntzen hiztunok hitz hori inportatu egin dugu. Bi token arteko bereizketa egiteko, zenbaitetan, token biren artean banatzaileren bat jarri behar da, banatzailerik erabiliena zuriunea da (baina tabuladorea eta orga-itzulera onargarriak dira ere).

• Programa bat  →  Instrukzio multzoa


• Instrukzio bat  →  Funtsezko elementuen multzoa (token batzuen multzoa)

Beraz, programa bat instrukzioen multzoa bada, eta instrukzio bat zenbait token bilduma dela onarturik, oso sinplistak izanik, programa bat hainbat token multzoa bezala ikus daiteke.



Hona hemen, Pascal programazio-lengoaian emandako instrukzio pare bat. Zertarako balio duten jakin gabe, instrukzio biren itxura azter dezagun token desberdinak identifikatuz:

rLuzera := 2*PI*(rDiametroa/2) ;

rAzalera := Sqr((rDiametroa/2))*PI ;

Lehen instrukzioak 12 token ditu, hauexek dira banan-banan zerrendaturik:

rLuzera	:=	2	*	PI	*	(	rDiametroa	/	2	)	;
1	2	3	4	5	6	7	8	9	10	11	12

Bigarren instrukzioak 13 token ditu, hauexek dira banan-banan zerrendaturik:

rAzalera	:=	Sqr	(	(	rDiametroa	/	2	)	)	*	PI	;
1	2	3	4	5	6	7	8	9	10	11	12	13

Token desberdinen sailkapena egitean, lau motatakoak ager daitezkeela jakin behar da:

1. Hitz erreserbatuak. Adibidez: aurreko bi instrukzioetan hitz erreserbaturik ez dago


2. Ikur bereziak edo sinboloak. Adibidez: :=, (, ), * eta ;


3. Identifikadoreak. Adibidez: rLuzera, rAzalera, rDiametroa, Sqr eta PI


4. Konstanteak. Adibidez: 2

---

1. Hitz erreserbatuak



Hitz erreserbatuak, Pascal programazio-lengoaiak aurredefiniturik dituen elementuak dira. Hitz erreserbatuek ingelesetik hartutako terminoak dira eta konpiladoreak esanahia zehatz eta berezia ezagutzen die. Hitz erreserbatuak programazio-lengoaiaren primitiboak liratekeenez programak idazteko ezinbestekoak dira.



Hitz erreserbatuak, banatzaile gabeko karaktere-kateak dira. Konpiladoreak ez du maiuskula eta minuskula artean bereizketa egiten baina ohitura da hitz erreserbatuak maiuskuletan idaztea. Hitz erreserbatuen aplikazioak lau dira:

1. Blokeak definitzeko: BEGIN, END, FUNCTION, PROCEDURE, PROGRAM, ... 


2. Operazioak egiteko: DIV, MOD, AND, OR, NOT eta XOR


3. Datu-egiturak definitzeko: INTEGER, REAL, FILE, ARRAY, STRING, RECORD, ... 


4. Kontrol-egiturak definitzeko:
   IF,
   CASE,
   FOR,
   WHILE,
   REPEAT, ... 

---

2. Ikur bereziak eta sinboloak



Ondoren agertzen diren karaktereak ikur bereziak dira Pascal programazio-lengoaiarako, eta hitz erreserbatuen antzera aurredefinituriko zereginak dituzte. Hona hemen karaktere bakarra daukaten sinboloak:

+	Batuketa
-	Kenketa edo minus zeinua
*	Biderketa
/	Zatiketa erreala
=	Berdintasuna
<	Txikiago baino
>	Handiago baino
[	Array datu-motaren dimentsioaren mugatzailea
]	Array datu-motaren dimentsioaren mugatzailea
.	Erregistroetan eremuen arteko banatzailea
,	Identifikadoreen arteko banatzailea
(	Prozedura eta funtzioetan parametro zerrendaren mugatzailea
)	Prozedura eta funtzioetan parametro zerrendaren mugatzailea
:	Identifikadore eta datu-moten arteko banatzailea
;	Instrukzioa amaitzeko marka
'	Karaktere-katearen mugatzailea
{	Iruzkinaren mugatzailea edo konpiladorearen direktiba
}	Iruzkinaren mugatzailea edo konpiladorearen direktiba
^	Erakuslea     (EZ)
@	Eragigai baten helbidea     (EZ)
$	Jarraian doazen karaktereak kode hamaiseitarran daude     (EZ)
#	Jarraian doazen karaktereak ASCII kodean daude     (EZ)

Badira zenbait sinbolo bi karakterez adierazten direnak, ondokoak:

<>	Desberdin
<=	Txikiago edo berdin
>=	Handiago edo berdin
:=	Esleipena
(*	Iruzkinaren mugatzailea edo konpiladorearen direktiba, { bezalakoa
*)	Iruzkinaren mugatzailea edo konpiladorearen direktiba, } bezalakoa
..	Balioen heina
(.	Array datu-motaren dimentsioaren mugatzailea, [ bezalakoa     (EZ)
.)	Array datu-motaren dimentsioaren mugatzailea, ] bezalakoa     (EZ)

---

3. Identifikadoreak



Lengoaiaren elementuak izendatzeko erabiltzen diren etiketak dira identifikadoreak. Identifikadoreak edozein luzerako karaktere-kateak dira, baina lehenengo hirurogeita hiruak esanguratsuak dira. Derrigorrez letra batez edo _ karakterez hasiko dira. Identifikadoreetan maiuskulak eta minuskulak ez dira bereizten.



Identifikadoreek izendatzen dituzten elementuak hauek dira: aldagaiak, konstanteak, datu-motak, programak, prozedurak, funtzioak, unitateak eta erregistroen eremuak.



Identifikadoreak bi eratakoak izan daitezke: Identifikadore estandarrak eta Erabiltzailearen identifikadoreak.





3.1 Identifkadore estandarrak



Pascal programazio-lengoaiak identifikadore batzuk ezagutzen ditu, aurredefiniturik daudelako. Horiei identifikadore estandar esaten zaie eta edozein programatan erabil daitezke:

Konstanteak	MAXINT, PI, MAXLONGINT, TRUE, ...
Datu-motak	Integer, Real, Boolean, Byte, Char, ...
Prozedurak	ReadLn, WriteLn, Assign, Delete, ...
Funtzioak	Cos, Abs, Eof, Pi, Length, ...
Unitateak	Crt, Graph, SysUtils, System, ...

3.2 Erabiltzailearen identifkadoreak



Identifikadore estandarrak ez bezala, erabiltzailearen identifikadoreak programadore batek programa jakin baterako asmatu eta definitu duen etiketa da. Identifikadoreak finkatzeko arauak berriro gogoratuz:

1. Hitz erreserbatuak ezin dira identifikadore bezala erabili


2. Identifikadorearen luzera edozein izan daiteke


3. Karaktere esanguratsuak lehenengo 63 karaktereak dira


4. Maiuskulak = Minuskulak


5. Lehenengo karakterea letra bat edo _ azpimarra karakterea izango da


6. Bigarren eta hurrengo karaktereak ondoko hauek izan daitezke:

a b c d e f g h i j k l m n o p q r s t u v w x y z

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

0 1 2 3 4 5 6 7 8 9

Ikus ditzagun programa batetik hartutako identifikadoreak, batzuk baliagarriak dira beste batzuk berriz programa konpilatzerakoan ez dira onartuko.

Onargarriak:

• iAdina


• byAdina


• Deitura_1


• BaturaLortu


• Batura_Lortu

Onartezinak:

• Begin                        (hitz erreserbatua delako)


• 1_Deitura               (zenbakiz hasten delako)


• Batura Lortu        (zuriunea banatzaileak 2 token eragiten dituelako)


• Batura-Lortu        (- karakterea token bat delako)

---

4. Konstanteak



Programa batean aldatzen ez diren balioak konstanteak deitzen dira. Konstanteak programetan bi modutan ager daitezke, balioak zuzenki ager daitezke edo konstanteari lotu zaion identifikadore baten bitartez. Hurrengo adibideetan konstanteak ematen dira:

• 109 zenbakizko konstante bat (zenbaki osoa)


• -4.082 zenbakizko konstante bat (zenbaki erreala)


• 7E-2 zenbakizko konstante bat (zenbaki erreala)


• 'M' karaktere konstante bat


• 'kaixo!' karaktere-kate konstante bat


• iMINIMOA zenbaki osoa dirudien konstantea (konstante horren definiziora joan bere balioa eta izaera ikusteko)


• rGRABITAZIOUNIBERTSALA zenbaki erreala dirudien konstantea (konstante horren definiziora joan bere balioa eta izaera ikusteko)

Programa baten konstante guztien definizioak CONST izeneko bloke bakar batean egin daitezke. Adibidez:

    CONST
          iMINIMOA = -16 ;
          rGRABITAZIOUNIBERTSALA = 6.674E-11 ;

---

5. Aldagaiak



Identifikadoreak aipatzean, aldagaien identifikadoreak erabili dira. Baina, zer da aldagai bat programazio-lengoaietan?



Programa baten exekuzioan datu batzuk ez dira aldatzen baina beste batzuek balio ezberdinak har ditzakete. Alda daitezkeen datuak aldagaien bitartez adierazten dira, eta funtsean aldagai batek memoriaren zati zehatz bat erabiltzea ahalbideratzen du.



Programa baten aldagaien deklarazioa (edo erazagupena) VAR izeneko blokeetan egiten dira. Adibidez:

    VAR
          iKontagailua : Integer ;
          cErantzuna : Char ;
          boAurkitua, boBukaturik : Boolean ;
          rEmaitza, rErroreMaximoa : Real ;

Aldagaia deklaratzeko, aldagaiaren identifikadorea eta aldagaiaren datu-mota zehaztu beharko dira. Identifikadorearen eta datu-motaren bitartez ordenagailuaren memoria zati bat erreserbatzen da, eta memoriaren zati horretan datu bat gorde ahalko da, eta datu horrekin berari dagozkion operazioak egin ahal izango dira.



Aldagai batean balio jakin bat gordetzeko instrukziorik errazena esleipena da. Adibidez, iKontagailia izeneko zenbakizko aldagaian 0 bat gordetzeko, honelaxe egingo litzateke:

    BEGIN
          iKontagailua := 0 ;

---

6. Esleipena



Esleipen sententzia oinarrizko agindua da, honen bitartez aldagai batek duen balioa espresio baten emaitzagatik ordezkatzen da. Esleipen batean beraz, alde bi izango dira: 1) ezkerraldean balio berria hartuko duen aldagaia, eta, 2) eskuinaldean espresioa (espresioaren datu-mota helburuko aldagaiarekiko koherentea izango da). Zati bien artean := sinboloa agertuko da.

Demagun agindu hau dugula rEmaitza:=rDatua; eta aldagaien tokiak trukatzen
ditugula rDatua:=rEmaitza; agindua lortuz. Agindu biak sintaktikoki ondo daude, baina
argi dago agindu bakoitzaren ondorioa desberdina dela programan

Esleipen agindua exekutatzean eskuinetik ezkerrera egiten da, hasteko eskuinean dagoen espresioa ebaluatzen da, eta bere emaitza ezkerraldean dagoen aldagaiak erreferentziatzen duen memoriko txokoan gordetzen da (memoriko posizio horietan aurretik zegoena galduz). Horra hor zenbait esleipen:

    BEGIN
          iKontagailua := 6 ;                             { 1. esleipena }
          sIzena := 'Eguzkine' ;                          { 2. esleipena }
          cLetra := 'W' ;                                 { 3. esleipena }
          iKopurua := iKontagailua ;                      { 4. esleipena }
          iKontagailua := iKontagailua + 1 ;              { 5. esleipena }
          rSalneurria := rKostua + rKostua * BEZ /100 ;   { 6. esleipena }
          rX := iKopurua ;                                { 7. esleipena }
          rY := sin(rX) ;                                 { 8. esleipena }

1., 2. eta 3. esleipenen adibideetan eskuineko adierazpenak konstanteak dira. Konstante bat bere baliora ebaluatzen denez, 6 konstantearen ebaluzio-emaitza 6 izango da eta horixe gordetzen da iKontagailua identifikadoreak markatzen duen memoriako gelasketan. Modu beretsuan, 'Eguzkine' konstantearen ebaluzio-emaitza Eguzkine izango da eta horixe gordetzen da sIzena identifikadoreak markatzen duen memoriako gelasketan. Berdin berdin gertatzen da 'W' konstantearekin, bere ebaluzio-emaitza W izanik cLetra identifikadoreari dagokion memoriako gelaskan biltegitzen baita.



4. esleipenaren adibidean espresioa aldagai bat da, eta aldagai bat duen baliora ebaluatzen da, horregatik eta iKontagailua aldagaiak 6 balio duenez iKopurua aldagaiak ere 6 balioko du 4. esleipen hori exekutatzean.



5. eta 6. esleipenen adibideetan eskuineko espresioak adierazpen aritmetikoak dira, horiek ebaluatu ondoren euren emaitza ezkerreko aldagaiek erreferentziatzen dituzten gelasketan gordeko dira. Goazen esandako honetaz sakontzera, 5. adibidean agertzen den moldea askotan agertzen denez astiro azter dezagun: 1. esleipena kontutan izanik iKontagailua aldagaiak 6 balio du, eta iKontagailua+1 espresioaren emaitza 7 izango da, zazpiko hori gordetzeko iKontagailua aldagaiak adierazten duen posizioan egiten denez, azkenean honek izango duen balioa 7 izango da eta iKontagailua aldagaiaren inkrementua litzateke.


7. esleipenaren adibidean, eskuineko iKopurua aldagaiak kopuru oso bat gordetzen du (6 balioa) eta kopuru hori rX aldagaian biltegitzen da; rXi aldagaia zenbaki errealak gordetzeko gai denez, bere benetako edukia 6.0 izango da (erne! duck-rabbit ≠ rabbit-duck).


8. esleipenaren adibidean Pascal programazio-lengoaiak aurredefiniturik duen sin() funtzio estandarra agertzen da, rX aldagaia berak gordetzen duen baliora ebaluatu ondoren sin() funtzio trigonometrikoak rX balioari dagokion sinua itzultzen du, emaitza hori zenbakizko balio bat da eta rY aldagaiak markatzen duen memoriko posizioetan gorderik geratuko da.

---

7. Iruzkinak



Programa baten sententziak egiten dutena hobeto ulertzeko oharrak edo iruzkinak tartekatzen dira. Iruzkinak testuak izango dira eta konpiladoreak aintzat har ez ditzan testuaren hasieran giltza karakterea { jartzen da eta amaieran bere simetrikoa }.



Gorago dagoen 2. Ikur bereziak eta sinboloak izeneko atalean esandakoa gogoratuz, giltzen ordez (* eta *) karaktere bikoteak erabil daitezke.



Programa editatzen (idazten) ari garenean lerro oso bat iruzkin bezala markatzeko, nahikoa da / karakterea birritan idaztea lerroaren hasieran.



Adibideak:

    (* Iruzkin baten adibidea *)
    { Beste iruzkin baten adibidea }
    { Iruzkin habiatuak { bat bestearen barnean } ez dira onartzen }
    (* Iruzkin habiatuak (* bat bestearen barnean *) ez dira onartzen *)
    { Iruzkinak habiatzeko (* bat bestearen barnean *) sinboloak konbinatu }
    (* Iruzkinak habiatzeko { bat bestearen barnean } sinboloak konbinatu *)
    // Beste iruzkin bat, lerro batean bi barretatik eskuinera dagoena