3.Prednaska

Z Pascal
Prejsť na: navigácia, hľadanie
3. Prednáška

úlohy | cvičenie


V tejto časti sa zoznámime so základnými jednoduchými typmi:

  • Integer - celočíselný typ
  • Boolean - logický typ
  • Char - znakový typ
  • Real - typ desatinné čísla

Pascal je na používanie typov veľmi prísny (hovoríme, že Pascal je typový jazyk). Každú premennú musíme zadeklarovať a určiť jej typ. Na základe toho kompilátor vyhradí toľko pamäti (bajtov), koľko je potrebné pre tento typ. Rôzne typy môžu zaberať rôznu veľkosť.

Štandardná funkcia SizeOf() slúži na zisťovanie počtu vyhradzovaných bajtov, pre premenné, alebo pre typy. Napr. funkcia SizeOf(Integer) vráti hodnotu 4, čo označuje, že Integer v paäti počítača zaberá 4 bajty.


typ Integer

Na prvých dvoch prednáškach sme sa zoznámili s celočíselným typom Premenné tohto typu sa deklarujú ako Integer a označuje to, že sa pre každú takúto premennú vyhradia 4 bajty, čo je 32 bitov. Do takejto premennej môžeme uchovať celé číslo z intervalu <–2 147 483 648, 2 147 483 647>. Základnými operáciami sú +, -, *, div a mod a tiež relácie <, <=, >, >=, <>, =. My už vieme, že vyhodnocovanie aritmetických výrazov sa riadi prioritami operácií:

* div mod súčin a delenie
+ - súčet a rozdiel
< <= > >= <> = porovnanie

Celé čísla sme zatiaľ používali skoro vo všetkých našich projektoch:

  • ako riadiaca premenná for-cyklov
  • v podmienkach if a while
  • ako parametre v grafických príkazoch a v rôznych funkciách, napr. Ellipse, MoveTo, IntToStr, Random, Abs, ...


Konštanty v rôznych číselných sústavách


V programovacích jazykoch celočíselné konštanty štandardne zapisujeme v desiatkovej sústave, ako napr. desiatkové: 0, 2012, 32756, -15522, ... Najväčšia povolená celečíselná konštanta je 2147483647 - nemusíme si ju pamätať - Pascal má zadefinovaný identifikátor konštanty MaxInt.

V pascale môžeme pracovať aj so šestnástkovými konštantami. Začínajú znakom $, za ktorým musia nasledovať šestnástkové cifry: 0, 1, ..., 8, 9, a, b, c, d, e, f. Keďže šestnástkové cifry reprezentujú 4 bity (pol bajt), 4-bajtové celé číslo zapíšeme maximálne 8 ciframi, napr $0, $FF, $100, $fffffffe, ... Zrejme 1 bajt, t.j. číslo od 0 do 255 sa v šestnástkovej sústave zapisuje dvoma ciframi od $0 do $ff. Ak potrebujeme celé číslo vypísať v šestnástkovej sústave, namiesto IntToStr použijeme konverznú funkciu IntToHex. Tá ma dva parametre: vypisované celé číslo a počet vypisovaných cifier, napr.

      IntToHex(160, 3)    // vráti 0A0
      IntToHex(-2, 8)     // vráti FFFFFFFE

Na vypisovanie poznáme aj funkciu Format. Vieme, že %d slúži na vypisovanie celých čísel. %x môžeme použiť na výpis v šestnástkovej sústave, napr.

      Format('%d = $%x', [2012, 2012])         // vráti 2012 = $7DC

Podobne môžeme zapisovať aj 8-ové a 2-ové konštanty. Osmičkové konštanty začínajú znakom &, za ktorým sú cifry od 0 do 7. Dvojkové konštanty začínajú znakom % a skladajú sa len z cifier 0 a 1. Treba si uvedomiť, že ak máme nejaké číslo v dvojkovej sústave (čo sú samotné bity 32-bitového čísla), tak štvorice bitov reprezentujú šestnástkové cifry a trojice bitov osmičkové cifry. Ukážme to na príklade. To isté dvojkové číslo (32 bitov) prepíšeme do šestnástkovej aj osmičkovej sústavy:

   %01110100110111111100001010111011                                     // dvojkový zápis
    0111 0100 1101 1111 1100 0010 1011 1011    = $74DFC2BB               // šestnástkový zápis
    01 110 100 110 111 111 100 001 010 111 011 = &16467741273            // osmičkový zápis

Šestnástková sústava sa úspešne využíva pri kódovaní farieb v RGB modeli. My už poznáme funkciu RGBToColor, ktorá z troch celých čísel z intervalu <0, 255> vyrobí nejakú farbu. V počítači sú farby kódované 4-bajtovým celým číslom, pričom na RGB sa využijú len spodné 3 bajty. Platí

      RGBToColor(R, G, B) = R + G * 256 + B * 256 * 256

To znamená, že najnižší bajt obsahuje červenú zložku R, druhý bajt zelenú zložku G a tretí bajt obsahuje modrú zložku B. Ak by sme tri čísla R, G a B samostatne zapísali v šestnástkovej sústave ako rr, gg a bb, tak kompletnú farbu môžeme zapísať jedným celým číslom $bbggrr, napr.

  • farba RGBToColor(255, 160, 128) sa môže zapísať aj ako $80A0FF
  • farba clRed, čo je RGBToColor(255, 0, 0), je tiež $FF, teda číslo 255
  • farba clWhite je RGBToColor(255, 255, 255), čo je $FFFFFF
  • farba clBlack je RGBToColor(0, 0, 0), čo je $000000, teda číslo 0

Pripomeňte si zápis Random(256 * 256 * 256), ktorý používame na generovanie náhodnej farby. Hodnota 256 * 256 * 256 označuje kód najvyššej možnej farby (teda biela) + 1. Tento Random by sme mohli zapísať aj ako

  • Random(clWhite + 1), ak by sme zapísali len Random(clWhite), dostaneme všetky náhodné farby okrem najčistejšej bielej clWhite
  • Random($100 * $100 * $100) = Random($1000000)

Na výpis celých čísel v šestnástkovej sústave nám pomôže IntToHex alebo Format, ale čísla v iných sústavách musíme realizovať vlastnými programami. Väčšinou sa na to využijú operácie mod a div, ktoré z celého čísla vedia zobrať poslednú cifru v ľubovoľnej číselnej sústave. Napr. pre sústavu XX

  • posledná cifra bude hodnota mod XX
  • číslo bez poslednej cifry bude hodnota div XX


Ordinálny typ


Pojem ordinálny typ v programovacích jazykoch označuje špeciálne vlastnosti takéhoto typu:

  • pre typ existujú minimálna aj maximálna konštanta – vieme sa k nim dostať pomocou funkcií Low(), High(), napr.
  • Low(Integer) = -2147483648
  • High(Integer) = 2147483647, čo je zrejme MaxInt
  • každá hodnota má nasledovníka a predchodcu (zrejme okrem maximálnej a minimálnej hodnoty) – slúžia na to funkcie Succ(), Pred(), napr.
  • Succ(12345) = 12346, Succ(-5) = -4
  • Pred(12345) = 12344, Pred(-5) = -6
  • príkazy Inc() a Dec() slúžia na zvýšenie (inkrement), resp. zníženie (dekrement) hodnoty premennej, napr.
  • ak premenná I = 37, Inc(I); zvýši I o 1, teda v I teraz bude 38
  • ak premenná I = 37, Inc(I, 15); zvýši I o 15, teda v I teraz bude 52
  • ak premenná I = 37, Inc(I, I); zvýši I o I, teda v I teraz bude 74 (dvojnásobok)
  • ak premenná I = 37, Dec(I); zníži I o 1, teda v I teraz bude 36
  • ak premenná I = 37, Dec(I, 15); zníži I o 15, teda v I teraz bude 22
  • ak premenná I = 37, Dec(I, I); zníži I o I, teda v I teraz bude 0
  • všetky ordinálne typy môžeme použiť vo for-cykle ako typ riadiacej premennej (počítadla)
  • pre každý takýto typ vieme zistiť jeho vnútornú reprezentáciu, teda aká číselná hodnota zozpovedá nejakej hodnote - slúži na to funkcia Ord() - použitie uvidíme pri ďalších typoch



Bitová aritmetika


S celými číslami môžeme robiť aj bitové operácie. Tieto pracujú so všetkými 32 bitmi, ako postupnosťou 0 a 1.

  • unárna operácia not zneguje každý bit, napr.
  • not 0 = $FFFFFFFF, čo je -1
  • not &1101 = $FFFFFFF2, čo je -14
  • not -2 = $00000001, čo je 1
  • binárna operácia or po bitoch spočíta dve čísla, pričom 1 + 1 = 1, napr.
  • 26 or 12 = &11010 or &01100 = &11110 = 30
  • binárna operácia and po bitoch vynásobí dve čísla, napr.
  • 26 and 12 = &11010 and &01100 = &01000 = 16
  • binárna operácia xor urobí po bitoch vylučujúce alebo, t.j. 1 nechá len na tých bitoch, ktoré sú rôzne, napr.
  • 26 xor 12 = &11010 xor &01100 = &10110 = 22

Uvedomte si, že ľubovoľné celé číslo X

  • X and X = X, X or X = X, X xor X = 0
  • X and 1 = X mod 2, X and 7 = X mod 8, X and 15 = X mod 16, čo sú posledné cifry v 2-ovej, 8-ovej a 16-ovej sústave

Dve ďalšie operácie posúvajú bity buď vľavo alebo vpravo, pričom bity, ktoré "vypadnú" sa strácajú. Druhý operand určuje počet, o ktorý sa bude posúvať.

  • shl – bitový posun vľavo (funguje aj <<)
  • shr – bitový posun vpravo (funguje aj >>)

Napr.

  • 13 shl 2 = &1101 shl 2 = &110100 = 52 = 13 * 4
  • 13 shr 2 = &1101 shr 2 = &11 = 3 = 13 div 4

Uvedomte si, že shl je násobenie mocninou 2, shr je delenie mocninou 2. Pre celé číslo X platí:

  • X << 1 = X * 2, X << 2 = X * 4, X << 3 = X * 8, X << 4 = X * 16, ...
  • X >> 1 = X div 2, X >> 2 = X div 4, X >> 3 = X div 8, X >> 4 = X div 16, ...

Operácie and a shr (>>) sa často využívajú pri prevode čísla do niektorých číselných sústav.

Doplňme tieto nové operácie do tabuľky priorít operácií:

not - unárne
* div mod and shr shl << >> súčin, delenie, posun
+ - or xor súčet a rozdiel
< <= > >= <> = porovnanie

Ak by sme nejakú podmienku zapísali bez zátvoriek, napr.

if X < 100 and Y < 200 then

tak operácia and má vyššiu prioritu ako relačné <, preto si to kompilátor vnútorne ozátvorkuje takto

if (X < (100 and Y)) < 200 then

a už vieme, že (100 and Y) má v Pascale zmysel (bitový súčin) a jeho výsledkom je nejaké číslo. Toto číslo sa potom porovnáva s X, výsledkom je logická hodnota a tá sa nemôže porovnávať s 200.


typ Boolean

Logický typ Boolean slúži napr. na uchovávanie výsledkov rôznych podmienok. Premenná tohto typu zaberá 1 bajt (8 bitov). Môžeme sa o tom presvedčiť SizeOf(Boolean) = 1.

Hodnotami tohto typu sú len tieto dve konštanty:

  • True - pravda
  • False - nepravda

Logické operácie majú operandy logického typu:

  • unárna operácia not zneguje operand
  • binárna operácia and je logický súčin (konjunkcia)
  • binárna operácia or je logický súčet (disjunkcia)
  • binárna operácia xor je vylučujúce alebo (exkluzívna disjunkcia)

Priorita týchto operácií je rovnaká ako v tabuľke pre celé čísla.

S logickými hodnotami sme sa zatiaľ stretli najmä pri podmienkach c podmienených príkazoch. Videli sme, že výsledkom relačných operácií (<, <=, >, >=, <>, =) je buď pravda alebo nepravda, t.j. True alebo False.

Tieto dve logické hodnoty sú v pamäti počítača reprezentované ako celé čísla:

  • True ako 1
  • False ako 0

Keďže logický typ je ordinálny, všetky (dve) hodnoty sú usporiadané, majú svoje minimum a maximum, nasledovníka a predchodcu a pomocou funkcie Ord() vieme zistiť vnútornú reprezentáciu, tzv. ordinálnu hodnotu. Teda platí:

  • Ord(False) = 0, Ord(True) = 1
  • Low(Boolean) = False, High(Boolean) = True
  • Pred(False) = chyba, Pred(True) = False
  • Succ(False) = True, Succ(True) = chyba
  • ak premenná B = False, tak Inc(B) priradí B := True
  • ak premenná B = False, tak Dec(B) spôsobí spadnutie programu
  • ak premenná B = True, tak Inc(B) spôsobí spadnutie programu
  • ak premenná B = True, tak Dec(B) priradí B := False

Relačné operácie (<, <=, >, >=, <>, =) fungujú aj pre logické hodnoty a platí, napr.

  • False < True
  • True >= False

Okrem konverzie Ord(), ktorá prevádza logickú hodnotu na celé číslo, môžeme použiť aj opačnú konverziu z celého čísla (0 alebo 1) na logickú: funkcia Boolean() funguje ako konverzia:

  • Boolean(0) = False
  • Boolean(1) = True

Pozrite tento zápis:

var
  X: Integer;
 
...
  Inc(X, Ord(X < 17));

Hodnota Ord(X < 17) je buď 0 alebo 1, to znamená, že X sa zväčší o 0 alebo 1. Tento spôsob zápisu je veľmi zle čitateľný a preto sa neodporúča ho používať. Ale takéto a podobné zápisy by ste mali vedieť správne prečítať. Čitateľnejšie by bolo, keby sme to zapísali takto:

  if X < 17 then
    Inc(X);

Logickú premennú môžeme použiť aj ako riadiacu (počítadlo) vo for-cykle. Napr.

var
  X: Integer;
  B: Boolean;
 
...
  for B := X = 1 to X = 2 do
    {telo cyklu}

Ak má X hodnotu 2, telo cyklu sa vykoná dvakrát. Ak má X hodnotu 1, telo cyklu sa nevykoná ani raz. Pre všetky iné hodnoty X sa telo cyklu vykoná práve raz. Aj takýto zápis príkazov je ťažšie čitateľný a teda zrozumiteľný.

Ďalší príklad je tiež zaujímavým využitím logických výrazov:

if (X < 100) = (Y < 100) then ...

Táto podmienka je splnená vtedy, keď sú buď obe podpodmienky pravdivé, alebo obe nepravdivé.


typ Char

Tento typ slúži na uchovanie jedného znaku (napr. písmena, číslice alebo nejakého symbolu). Premenná tohto typu zaberá 1 bajt (8 bitov). Môžeme sa o tom presvedčiť SizeOf(Char) = 1. Do jedného bajtu sa vojde vždy iba jeden z 256 rôznych znakov. Znakové konštanty zapisujeme medzi dva apostrofy, pričom znakovú konštantu apostrof zapíšeme dvakrát. Napr. konštanty:

'a', 'A', ' ', '7', ', '+', ...

Vnútorne sú znaky reprezentované číslami od 0 do 255, pričom sa používa tzv. ASCII kódovanie. Podľa tohto kódovania, napr.

  • 'a' má kód 97, resp $61
  • 'A' má kód 65, resp $41
  • '0' má kód 48, resp $30
  • ' ' má kód 32, resp $20

Konštanty môžeme zapisovať aj inak ako symbolom medzi apostrofmi. Za znak # uvedieme ASCII kód, napr.

  • #66, alebo #$43 je to isté ako 'B'
  • #49, alebo #$31 je to isté ako '1'

So znakmi nie sú v pascale definované žiadne operácie (také ako súčet alebo súčin s číslami). Ale keďže znakový typ je tiež ordinálny, platia tieto vlastnosti:

  • Low(Char) = #0, High(Char) = #255
  • funkcia Ord() vráti ordinálnu hodnotu, t.j. ASCII kód znaku, napr.
  • Ord('C') vráti 67
  • funkcia Char() z čísla <0, 255> vyrobí znak, napr.
  • Char(50) vráti znak '2'
  • funkcia Succ() nefunguje pre #255 a platí Succ(Znak) = Char(Ord(Znak) + 1)
  • funkcia Pred() nefunguje pre #0 a platí Pred(Znak) = Char(Ord(Znak) - 1)
  • príkaz Inc() do znakovej premennej priradí nasledovný znak, napr.
  • ak v premennej Z je 'A', potom Inc(Z) do Z priradí 'B'
  • ak v premennej Z je 'A', potom Inc(Z, 32) do Z priradí 'a'
  • ak v premennej Z je 'b', potom Dec(Z) do Z priradí 'a'
  • ak v premennej Z je 'b', potom Dec(Z, 32) do Z priradí 'A'

Znaky môžeme navzájom porovnávať, pričom platí, že nejaký znak je menší ako nejaký iný vtedy, keď ASCII kód prvého je menší ako ASCII kód druhého. Platí

  • ' ' < ... < '0' < '1' < '2' < ... < '9' < ... < 'A' < ' B' < ... < 'a' < 'b' < ...

Znakový typ využijeme najmä pri práci so znakovými reťazcami a súbormi (v ďalších prednáškach). Ukážme malý príklad použitia vo for-cykle:

var
  Z: Char;
 
...
  for Z := 'A' to 'Z' do
    Image1.Canvas.TextOut(12 * (Ord(Z) - 64), 100, Z);


typ Real

Tento typ slúži na výpočty, kde nám už celočíselná aritmetika nestačí (príliš veľké čísla), prípadne keď potrebujeme pracovať aj s desatinnými číslami. Premenná tohto typu v počítači zaberajú 8 bajtov (64 bitov). Môžeme sa o tom presvedčiť SizeOf(Real) = 8. Počítač si desatinné čísla vie ukladať s 15 až 16 ciframi, pričom si pamätá aj exponent, t.j. číslo (približne od -324 do +308), ktorým sa umocní 10. Takéto čísla sa zapisujú v tzv. vedeckom (semilogaritmickom) tvare, ktorý používajú aj kalkulačky. Napr. číselné konštanty môžeme zapísať rôznym spôsobom

    430000.0 = 4.3E5 = 0.043E7
    0.000000123 = 1.23E-7 = 123E-9
    1E0 = 1.0 = 0.1E1 = 10E-1
    700000000000000000000 = 7E20

Za písmeno E píšeme exponent, ktorý je z intervalu približne ±300. Pascal odlišuje celočíselné a desatinné konštanty tak, že desatinné majú buď desatinnú bodku (napr. 5.0) alebo exponenciálnu časť (napr. 5E0).

Operácie sú podobné ako pre celé čísla: +, -, *, /. Ak aspoň jeden z operandov je desatinné číslo, tak aj výsledkom bude desatinné číslo. Operácia delenia '/' je vždy desatinného typu, teda napr. 1 / 2 má hodnotu 0.5. Pascal totiž v situáciách, kde očakáva desatinné číslo a objaví sa celé, automaticky toto celé prekonvertuje na desatinné. Napr. vo výraze 1 + 2.0 Pascal najprv automaticky prekonvertuje 1 na desatinné 1.0 a až potom tieto dve desatinné čísla spočíta. Toto ale nefunguje naopak, napr. 10.0 div 2 je v Pascale chybou.

S desatinnými číslami fungujú aj relačné operácie <, <=, >, >=, <>, =. Tu sa ale najlepšie ukážu problémy tohto typu. Totiž aritmetika tohto typu je nepresná a preto porovnávanie nepresných čísel môže spôsobovať nečakané správanie.

Pozrite nasledujúci program, v ktorom do premennej Suma 10-krát pripočítame 0.1:

var
  I: Integer;
  Suma: Real;
begin
  Suma := 0;
  for I := 1 to 10 do
    Suma :=´Suma + 0.1;
  if Suma = 1 then
    Image1.Canvas.TextOut(10, 10, 'rovná sa')
  else
    Image1.Canvas.TextOut(10, 10, 'nerovná sa');
end;

Očakávali by sme výsledok 1, lenže program nám oznámi, že Suma sa nerovná 1. Problémom v tomto príklade je to, že výpočty ako Suma + 0.1 nemusia byť matematicky presné a potom aj test Suma = 1 pre nepresnú hodnota Suma môže robiť problém. Aritmetika desatinných čísel môže byť nepresná (na rozdiel od celočíselnej), aj samotné konštanty, ktoré často vyzerajú bezproblémové, v skutočnosti môžu byť nepresné.

Pre výpis celých čísel sme využívali konverznú funkciu IntToStr(). Na výpis desatinných čísel slúži podobná funkcia FloatToStr(). Keď do nášho testovacieho programu pridáme výpis obsahu premennej Suma, dostávame:

var
  I: Integer;
  Suma: Real;
begin
  Image1.Canvas.Font.Height := 30;
  Suma := 0;
  for I := 1 to 10 do
    Suma := Suma + 0.1;
  Image1.Canvas.TextOut(10, 10, FloatToStr(Suma));
  Image1.Canvas.TextOut(10, 40, FloatToStr(Suma - 1));
  Image1.Canvas.TextOut(10, 70, IntToStr(Trunc(Suma)));
  Image1.Canvas.TextOut(10, 100, IntToStr(Round(Suma)));
end;

problém s desatinnými číslami

Vidíme, že aj na výpis desatinných čísel sa nedá úplne spoľahnúť. Hoci má premenná Suma hodnotu 1, keď vypíšeme rozdiel Suma - 1, dostávame veľmi malé číslo. Program tiež ukazuje štandardnú funkciu Trunc(), ktorá z reálneho čísla zoberie len celú časť a desatinnú zahodí. Keďže už vieme, že Suma je o veľmi malú hodnotu menšia ako 1, tak Trunc(Suma) dáva hodnotu 0. Štandardná funkcia Round() podobne ako Trunc() vyrobí z desatinného čísla celé, ale použije štandardné matematické zaokrúhľovanie.

Tieto príklady nás mohli dostatočne presvedčiť o tom, že desatinné čísla budeme používať veľmi opatrne a stále musíme počítať s chybami aritmetiky. V programoch sa preto často stretáme aj s takýmito zápismi, ktorými sa testuje "rovnosť" nejakých hodnôt:

  if Abs(Suma - 1) < 0.0001 then
    Image1.Canvas.TextOut(10, 10, 'rovná sa')
  else
    Image1.Canvas.TextOut(10, 10, 'nerovná sa');

kde Abs() je funkcia, ktorá počíta absolútnu hodnotu.

Typ Real - desatinné čísla - nie je ordinálny typ a preto ho nemôžeme použiť pre riadiacu premennú for-cyklu a tiež nefungujú príkazy Inc() a Dec().

Na výpis desatinných čísel môžeme okrem FloatToStr() použiť aj komplexnejšiu konverznú funkciu Format(), len namiesto %d pre celé čísla použijeme jednu z týchto možností:

  • %e - vedecký tvar zápisu - vždy s exponentom E
  • %f - desatinný tvar - bez exponentu
  • %g - vyberie sa najvhodnejší tvar čísla - buď vedecký alebo desatinný

Medzi % a písmeno formátu môžeme za bodku vložiť aj číslo, ktoré určuje počet desatinných miest, napr. %.4g bude vypisovať číslo s presnosťou na 4 desatinné miesta.

Typ desatinné čísla poskytuje oveľa viac štandardných funkcií ako majú celé čísla, napr.

  • Sqr, Sqrt, Abs, Round, Trunc, Frac
  • Pi, Sin, Cos, Tan, Arctan
  • Exp, Ln, Power

Goniometrické funkcie (napr. Sin() a Cos()) sú definované v radiánoch, preto ak s nimi budeme chcieť pracovať v stupňoch, musíme parameter patrične vynásobiť. Napr.

var
  Uhol, R1, R2: Real;
begin
  Uhol := 30;
  R1 := Sin(Uhol * Pi / 180);
  R2 := Cos(Uhol * Pi / 180);

počíta sínus a kosínus uhla 30 stupňov.

Body na kružnici sa dajú popísať aj pomocou sínusu a kosínusu. Ak chceme nakresliť kružnicu so stredom (X, Y) a polomerom R, tak postupne môžeme počítať body na kružnici pre rôzne uhly a tieto body spájať čiarami (LineTo). Ak budeme počítať Uhol = 0 ako smer nahor (na sever), potom smer vpravo (na východ) bude pre Uhol = 90. Potom Uhol = 180 zodpovedá smeru dole (na juh), atď.

Napíšme program, ktorý nakreslí kružnicu, ale len pomocou čiar (MoveTo a LineTo):

var
  I, X, Y, R, Uhol: Integer;
begin
  X := Random(200) + 50;
  Y := Random(100) + 50;
  R := Random(50) + 10;
  Image1.Canvas.MoveTo(X, Y - R);
  Uhol := 0;
  for I := 1 to 60 do
  begin
    Uhol := Uhol + 6;
    Image1.Canvas.LineTo(X + Round(R * Sin(Uhol*Pi/180)), Y - Round(R * Cos(Uhol*Pi/180)));
    //Repaint;
    //Sleep(100);
  end;
end;

kružnice ako 60-uholníky

Všimnite si, že v skutočnosti kreslíme pravidelný 60-uholník. Malou zmenou programu môžeme kresliť ľubovoľný N-uholník:

var
  N, I, X, Y, R: Integer;
  Uhol: Real;
begin
  X := Random(200) + 50;
  Y := Random(100) + 50;
  R := Random(50) + 10;
  N := 5;            // kreslíme 5-uholník
  Image1.Canvas.MoveTo(X, Y - R);
  Uhol := 0;
  for I := 1 to N do
  begin
    Uhol := Uhol + 360 / N;
    Image1.Canvas.LineTo(X + Round(R * Sin(Uhol*Pi/180)), Y - Round(R * Cos(Uhol*Pi/180)));
  end;
end;

pravidelný päťuholník


späť | ďalej