informatika-2022-23: urtarrila 2023

2023(e)ko urtarrilaren 29(a), igandea

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:

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)

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

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

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

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).

2. ASTEA | ikasgelan egindakoa

2. astea (2023/01/30 eta 2023/02/03) ikasgelan egin dena

2023/01/30

Arbela erabiliz, INTEGER datu-mota artikulutik abiatuta ondoko kontzeptuak ikasi ditugu:

ZENBAKIAREN KONTZEPTUA

Zenbatu

Neurtu

ZENBAKIEN OINARRIZKO TEOREMA

Zenbakien Sistema desberdinak

Bit-en taldekatzeak

ZENBAKI OSOEN DATU-MOTAK

Zenbaki osoen heinak (Integer datu-mota berezitxoa da)

Zenbaki osoen eragile aritmetikoak

Zenbaki osoen erlaziozko eragileak

ZENBAKI OSOEN IRTEERAKO FORMATUA

ZENBAKI OSOA TEKLATUAREN BITARTEZ IRAKURRI

PARAMETRO IZATEAN JOKAMOLDEA (honek aurrerago garrantzia izango du)

ADIBIDEAK (aipatzea besterik ez dugu egin)

INTEGER datu-mota artikulutik hartutako taula hau astiro azaldu dugu:

Datu-mota	Formatua	Balio kopurua 2^N	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

Konturatu gaitezen Integer datu-mota hardwarearen araberakoa dela eta memorian 2 byte edo 4 byte har ditzakeela. Horren haritik bi programa erakutsi ditugu:

KonpilazioBerezia_TP_bai.pas (INTEGER: derrigorrez 2 byte)

KonpilazioBerezia_TP_ez.pas (INTEGER: hardwarearen araberako bit kopurua, 2 edo 4 byte)

Aurrekoarekin lotuta 1. astea | hamarretik bitarrera artikulua gain-gainetik aipatu dugu, baina une honetan ez du batere garrantzirik

Zenbaki osoak direla eta, ADIBIDEAK ataleko haritik 1. astea | hiru zifrako zenbaki oso bat atzekoz aurrera adibidea laborategian azalduko dugu

eGela-autoebaluazioa: Integer eta Real datu-motak ezagutzen dituzula, eGela webguneko ESKOLA MAGISTRALAK fitxan ikusi Autoebaluazioa: Esleipen agindua ikasten (II) zereginari dagoeneko erantzun diozu

2023/02/03

Arbela erabiliz eta REAL datu-mota artikulutik abiatuta ondoko atalak ikusi ditugu:

ZENBAKIAREN KONTZEPTUA (errepikatu)

Zenbatu

Neurtu

Zenbaki osoen eta zenbaki ez-osoen haritik, gogoratu desberdiketa egin beharra daukagula zenbaki zenbakagarrien eta zenbaki zenbakaitzen artean

ZENBAKIEN OINARRIZKO TEOREMA (errepikatu)

Koma Finkoko Adierazpidea

Koma Higikorreko Adierazpidea

ZENBAKI ERREALEN DATU-MOTAK

Zenbaki errealen heinak

Zenbaki errealen eragileak (aritmetikoak eta erlaziozkoak)

Eragile aritmetiko eta eragigaien arteko bateragarritasuna

ZENBAKI ERREALEN IRTEERAKO FORMATUA

WriteLn(rZenbakia) ← idazkera zientifikoa 23ko eremu batean

WriteLn(rZenbakia:n) ← idazkera zientifikoa nko eremu batean

WriteLn(rZenbakia:n:m) ← idazkera arrunta nko eremuan m dezimal

KOPURU OSOTIK ZENBAKI ERREALERA

ZENBAKI ERREAL BATEN ATALAK ETA ZENBAKI ERREALETIK KOPURU OSORA

Int eta Frac funtzioak zenbaki erreal baten atalak eskuratzeko

Trunc eta Round funtzioak zenbaki erreal batetik bere zenbaki osoa lortzeko

PARAMETROA IZATEAN JOKAMOLDE (honek aurrerago garrantzia izango du)

ADIBIDEAK

2. astea | erakarpen grabitatorioa

2. astea | kartesiar-polar (radianetan)

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

2. astea | radianak bihurtu gradu-minutu-segundo

Proiektua | 4. Ariketa: zenbaki errealetik kopuru osora (I)

eGela-autoebaluazioa: Ezaguna den 1. astea | 3 zifra eta 2 dezimaleko zenbaki erreal bat atzekoz aurrera ariketatik abiatuta, eGela webguneko ESKOLA MAGISTRALAK fitxan ikusi Autoebaluazioa: XYZ.AB zenbakitik ZYX.BA zenbakira zereginari erantzun zure programa bidaliz

eGela-autoebaluazioa: Aurrekoaren antzekoa den 2. astea | radianak bihurtu gradu-minutu-segundo ariketa ikasgelan azaldu da, eta zuei dagokizue Proiektua | 4. Ariketa: zenbaki errealetik kopuru osora (I) artikuluan ematen den programa aztertzea eta ulertzea

Blogeko BOOLEAN datu-mota artikuluaren bitartez datu-mota boolearrari hasiera eman diogu

REAL datu-mota

ZENBAKIAREN KONTZEPTUA

Zenbakia kontzeptua funtsezkoa da gizarteko komunikazio eta harremanetarako. Hizkera orokor arruntean, zenbakiek etengabeko presentzia dute, objektuak zenbatzeko eta neurtzeko ohitura baitugu, eta zenbatzean eta neurtzean zenbakiak erabili behar baititugu.

Zenbatu eta neurtu aditzak nahasirik erabil daitezke hizkera orokorrean, baina teknikan eta zientzian bereizi behar ditugu bakoitzak ekintza desberdina adierazten baitu. Nahiz eta ekintza bietan zenbakiak erabili gauza bat da zenbatu eta beste gauza bat da neurtu.

ADITZA	ERAGIKETA	EMAITZA	OBJEKTUAK
Zenbatu	Zenbaketa	Kopurua	Zenbakagarriak (diskretuak)
Neurtu	Neurketa	Neurria	Zenbakaitzak (jarraituak)

Zenbatu

Zehatz hitz eginda, zenbatu aditzak mota bereko zenbat objektu dauden kontatzea adierazten du. Beraz, zenbatu aditzaren esanahia kontaketarekin loturik dago eta dagokion eragiketa zenbaketa deitzen da. Zenbaketa eragiketaren emaitza kopurua da, hots, zenbat objektu dauden esatea.

Zer esanik ez, zenbatu ahal izateko, objektuek edo magnitudeek diskretuak izan behar dute, zenbakagarriak alegia, eta zenbaketaren emaitza zenbaki osoa izango da.

Pascal programazio-lengoaian zenbaki osoak adierazteko ondoko datu-motak erabiliko ditugu:

LongInt

Integer

Byte

Neurtu

Bestalde, neurtu aditzak honako ekintza adierazten du: objektu edo magnitude fisiko neurrian unitatea zenbat aldiz sartzen den kalkulatzea. Beraz, neurtu aditzaren esanahia konparaketa batekin loturik dago eta dagokion eragiketa neurketa deitzen da. Neurketa eragiketaren emaitza neurria da, hots, magnitude fisikoa zein tamainatakoa den esatea.

Neurtu ahal izateko, magnitude fisikoek jarraituak izan behar dute, zenbakaitzak edo ez-zenbakagarriak alegia, eta neurketaren emaitza zenbaki ez-osoa izango da (edo bestela esanik zenbaki erreal).

Pascal programazio-lengoaian zenbaki ez-osoak adierazteko ondoko datu-mota erabiliko dugu:

Real

ZENBAKIEN OINARRIZKO TEOREMA

Zenbakien Oinarrizko Teorema gogoratuz, badakigu magnitude fisiko bat sistema bitarrean adieraz daitekeela. Zenbaki osoentzat Polinomioaren Adierazpidea erabiltzen bada, gauza bera egiten da ere zenbaki errealentzat.

Zenbaki errealen adierazpidea hasi aurretik, ikus dezagun eskematikoki nola igaro kopuru bat hamartarretik bitarrera. Zenbaki errealaren alde osoa eta alde frakzionatua desberdindu behar dira, bati zatiketa osoak aplikatuz eta bestetik hondarraren dobleak lortuz. Esate baterako, ikusi 42.375 zenbakia nola adierazten den kode bitarrean:

Zenbaki errealak errepresentatzeko bi idazkera edo adierazpide erabiltzen dira:

Koma Finkoko Adierazpidea: dezimalen kopurua aldez aurretik finkaturik dago.

Koma Higikorreko Adierazpidea: zati dezimalaren bit kopurua aldakorra da.

Aipaturiko bi adierazpide horiek estuki loturik daude. Izan ere, Koma Higikorreko Adierazpidea eraikitzean Koma Finkoko Adierazpidea oinarritzat hartzen da.

Koma Finkoko Adierazpidea

Ikusten denez, kopuru hamartar guztiak ezin dira kode bitarrean errepresentatu. Goiko adibidean 0.16_h kopuru hamartarra 0.0010_b eta 0.0011_b artekoa da, baina lau bitekin ezin da zehatz-mehatz adierazi. Goiko adibideko 0.16_h kopuru hamartarrari gehien hurbiltzen zaien adierazpide bitarrak hauek dira:

0.16_h datuari hurbilketa bitar bat: 0.0010_b ⇒ 0.125_h

0.16_hri beste hurbilketa bitar bat: 0.0011_b ⇒ 0.1875_h

Koma Finkoa: Adibide bat

Arkitektura berezia eta mugatua duen ordenadore honek doitasun batekin lan egingo du, ondorioz irudi honetan erakusten diren zenbaki errealak errepresenta ditzake:

Esan bezala, makina digitalek ezin dituzte errepresentatu kopuru erreal guztiak. Hurrenez hurren dauden bi errepresentazio bitarren artean "zuloa" geratzen da, sistema informatikoak zenbat eta bit gehiago eduki zulo horiek txikiagoak izango dira. Edozein kasutan ere, makina digital batek doitasun jakin batekin jokatzen du.

Koma Higikorreko Adierazpidea

Formatu exponentzial normalduan idazten dira zenbaki errealak. Zenbaki erreal bakoitzeko hiru kontzeptu gordetzen dira: zeinua, berretzailea eta mantisa.

ZENBAKI ERREALEN DATU-MOTAK

Aurredefiniturik dauden datu-mota errealak sei dira:

Real, Single, Double, Extended, Comp eta Currency.

Zenbaki errealen heinak

Gorago aipatu den datu-mota bakoitzak, bit kopuru desberdinak hartzen dituzte memorian. Horren arabera, ondoko taulan datu-mota bakoitzearen behemuga eta goimuga erakusten dira:

Gure ariketa guztietan Real datu-mota erabiliko dugu, beste bostak ez ditugu beharko.

Zenbaki errealen eragileak (aritmetikoak eta erlaziozkoak)

Datu-mota errealek ezagutzen dituzten operazioak aritmetikoak eta erlaziozkoak dira. Lehenengoek, adierazpen aritmetikoak, formula matematikoak idazteko balio dute, eta erlaziozko eragileak berriz, adierazpen logikoak sortzeko erabiltzen dira. Ondoko tauletan biltzen dira operadore horiek:

Eragile horiek dituzten lehentasun arauak zenbaki osoek dituztenak berberak dira.

Eragile aritmetiko eta eragigaien arteko bateragarritasuna

Dagoenekoz zenbaki osoak eta zenbaki frakzionatuak adierazteko datu-motak ikasi ditugu, eta datu-motarekin batera memoriko biltegitze sistema bat eta onargarriak diren eragiketak definiturik daude. Orain arteko espresio aritmetikoetan zenbaki osoak eta zenbaki errealak erabili ditugu baina talde bakoitza bere aldetik eta nahastu gabe.

Adierazpen aritmetiko batek, ikusi dugunez, balio bakar batera ebaluatzen da. Adierazpen aritmetikoaren eragigaietan datu-mota ezberdinak agertzen direnean, espresioak hartzen duen balio bakar hori adierazpen aritmetikoaren emaitza izango da, eta honen datu-mota ere bakarra izango da. Baina, zein emaitzaren datu-mota eragigaiak datu-mota desberdinekoak badira? Adibidez, iEgunak zenbaki osoa izanik, eta rAbiadura zenbaki erreala izanik, zer datu-motakoa izango da haien arteko biderkadura?

      Emaitza := iEgunak * rAbiadura ;   { Emaitza REAL ala INTEGER? }
         ?          21        1.5
         ?          20        1.5

Argi dago Emaitza aldagaiak 31.5 balioa jaso behar duela kasu batean, eta 30.0 balioa bestean. Horregatik Emaitza aldagaia Real datu-motakoa izan beharko da derrigorrez.

Eragigaien konpatibilitatea edo bateragarritasuna lege batez gidatzen da: bi eragigai arteko operazio batean, eragigai bat datu-mota batekoa izanik eta beste eragigaia beste datu-mota batekoa izanik, emaitzari dagokion datu-mota eragigaien bi datu-motetatik garaiena izango da. Esate baterako, Real datu-mota Integer datu-mota baino "handiagoa" da.

Lege horren ondorio bezala, ondokoa baiezta daiteke: bi eragigai arteko operazio bat egitean, eragigai biak datu-mota berekoak direnean, emaitzaren datu-mota eragigaiena izango da; baldin eta operazioak berak kontrakorik behartzen ez badu. Esate baterako, eragigai biak osoak izan arren / zatiketaren emaitzari dagokion datu-mota beti erreala izango da.

Eragile aritmetikoak eta euren eragigaien arteko konpatibilitatea taula honetan laburbiltzen dira:

ZENBAKI ERREALEN IRTEERAKO FORMATUA

Datu-mota errealeko aldagai baten edukia pantailan idatzi nahi denean Write eta WriteLn prozedura estandarrak erabiliko dira. Zenbaki erreala pantailaratzekoan ez bada kontrakorik agintzen zenbaki idazkera zientifikoan agertuko da, horretarako 23 karaktereko eremu bat erabiltzen da honela banaturik:

3 posizio (zeinua, unitatea eta puntua)

15 posizio (hamabost zifra)

5 posizio (E, zeinua, hiru zifra)

Zenbaki errealen idazkera zientifikoa mantenduz, dezimal gutxiago erakutsi nahi baditugu, formatua zehaztu beharko da, horretarako :n gehitu beharko dugu (non, n kopuru osoa den). Zenbaki errealak idazkera zientifikoan erakustea ekidin nahi badugu, formatua zehaztu beharko da, horretarako :n:m gehitu beharko dugu (non, n eta m kopuru osoak diren).

Esate baterako, demagun rZbk aldagaian 123.456789 gorde dela eta bi instrukzio hauek idatzi direla:

  WriteLn('rZbk|', rZbk) ;    { positibo baten idazkera zientifikoa }
  WriteLn('rZbk|', -rZbk) ;   { negatibo baten idazkera zientifikoa }

Bi pantailaraketak honako hauek izango dira, hurrenez hurren:

                11111111112222
       12345678901234567890123
  rZbk| 1.234567890000000E+002
  rZbk|-1.234567890000000E+002
       12312345678901234512345

Aurreko rZbk aldagaiaren edukia mantenduz, demagun instrukzioak hauek direla non :n formatua erabili den:

  WriteLn('rZbk|', rZbk:15) ;  { 15eko eremu batean idazkera zientifikoa }

  WriteLn('rZbk|', rZbk:10) ;  { 10eko eremu batean idazkera zientifikoa }

  WriteLn('rZbk|', rZbk:5) ;   {  5eko eremu batean idazkera zientifikoa }
  WriteLn('rZbk|', rZbk:1) ;   {  1eko eremu batean idazkera zientifikoa }

  WriteLn('rZbk|', rZbk:30) ;  { 30eko eremu batean idazkera zientifikoa }

Bigarren adibiderako pantailaraketak honako hauek izango dira, hurrenez hurren:

                111111
       123456789012345
       123123456712345
  rZbk| 1.2345679E+002                  [15eko eremuan]
       123123456712345 
  rZbk| 1.23E+002                       [10eko eremuan]
  rZbk| 1.2E+002                        [ 5eko eremuan]
  rZbk| 1.2E+002                        [ 1eko eremuan]
  rZbk|        1.234567890000000E+002   [30eko eremuan]
       123456712312345678901234512345
       123456789012345678901234567890
                111111111122222222223

Aurreko rZbk aldagaiaren edukia mantenduz, demagun instrukzioak hauek direla non :n:m formatua erabili den:

  WriteLn('rZbk|', rZbk:17:4) ;  { 17ko eremu batean 4 dezimalekin idatzi }
  WriteLn('rZbk|', rZbk:11:4) ;  { 11ko eremu batean 4 dezimalekin idatzi }
  WriteLn('rZbk|', rZbk:0:4) ;   {  0ko eremu batean 4 dezimalekin idatzi }

Hirugarren adibiderako pantailaraketak honako hauek izango dira, hurrenez hurren:

  rZbk|         123.4568   [17ko eremuan 4 dezimal]
  rZbk|   123.4568         [11ko eremuan 4 dezimal]
  rZbk|123.4568            [ 0ko eremuan 4 dezimal]
       12345678901234567
                11111111

KOPURU OSOTIK ZENBAKI ERREALERA

Datu-mota osoa den aldagai baten edukia zenbaki erreala bihurtzeko ez da aparteko ezer egin behar. Adibidez, demagun iKopura aldagaiak 73 balioa gordetzen duela, balio hori zuzen-zuzean esleitu ahal diogu rEmaitza aldagai erreal bati:

  Write('iKopurua aldagaian kopuru osoa gorde: ') ;
  ReadLn(iKopurua) ;       { adibidez, 73 balio osoa teklatuaz irakurri  }
  rEmaitza := iKopurua ;   { 73.0 balioa gordetzen da rEmaitza aldagaian }

Erreala den aldagaiari esleipena egitean, 73 kopuru osoaren 73.0 bihurketa automatikoki egiten da.

ZENBAKI ERREAL BATEN ATALAK ETA ZENBAKI ERREALETIK KOPURU OSORA

Zenbaki erreal batek bi atal izango ditu: alde osoa eta alde dezimala. Zenbaki erreal baten atal biak eskuratzeko Int eta Frac funtzio estandarrak aplikatuko dira (bi funtzio horien emaitza zenbaki erreala izango da). Int eta Frac funtzioen azalpena 2. astea | zenbaki erreal baten atalak artikuluan ikus daiteke.

Zenbaki erreal baten baliotik kopuru oso bat lor dezakegu, baina bihurketa egiterakoan erabaki behar da zenbaki errealaren alde dezimala moztuko dugun, ala emaitza osoa lortzeko zenbaki erreala biribilduz egingo den. Zenbaki errealetik kopuru osora igarotzeko Trunc eta Round funtzio estandarrak aplikatuko dira (bi funtzio horien emaitza zenbaki osoa izango da). Trunc eta Round funtzioen azalpena 2. astea | zenbaki errealetik kopuru osora artikuluan ikus daiteke.

PARAMETRO IZATEAN JOKAMOLDEA

Datu-mota erreala sinplea izanik, azpiprograma batean honela agertuko da jokamoldearen arabera:

Irteerakoa denean VAR marka izango du aurrean

Sarrerakoa denean ez du inolako markarik izango

ADIBIDEAK

Hona hemen zenbaki errealen zenbait programa:

2. astea | erakarpen grabitatorioa

2. astea | kartesiar-polar (radianetan)

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

2. astea | radianak bihurtu gradu-minutu-segundo

Proiektua | 4. Ariketa: zenbaki errealetik kopuru osora (I)

INTEGER

REAL

BOOLEAN

CHAR

STRING

ARRAY

RECORD

FILE

1. astea | segundoen kopuruak

Datu-mota	Formatua	Balio kopurua 2^N	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.

Orriak

2023(e)ko urtarrilaren 29(a), igandea