                      Tehty Lamer's tutorialia varten
                         Teemu 'Brainless' Keinosen
                 toimesta vuonna 1997 20. piv maaliskuuta.

   Laelliset nkkohdat:

   Min, tmn dokumentin kirjoittaja, en ota minknlaista vastuuta
   siit, mita tm teksti on aiheuttanut, vlillisesti tai vlittmsti,
   sinulle tai kenellekkn muulle, tai yleenskkn millekkn.

   Paska homma, mutta maailma on julma.

   Itse tutoriaali:

   1.    Muut lukujrjestelmt
   2.    Bittioperaatiot
   3.    'lookup tables'
   4.    Jlkilpint
 ڿ
 Ŀ
                                                                       
   1.    Muut lukujrjestelmt

     Olemme tottuneet laskemaan 10-jrjestelmll luultavasti johtuen
   siit, ett meill on kymmenen sormea.
   Mutta on muitakin lukujrjestelmi, esimerkiksi oktaali ja
   heksadesimaalijrjestelmt.
     Tss luvussa me tarkastelemme muita lukujrjestelmi, ja eritoten
   binrijrjestelm.

     Tietokone osaa ksitell vain ykksi ja nollia, eli se kytt
   binrijrjestelm. Tll jrjestelmll on kymmenjrjestelmn
   vain yksi mainittava ero: se kytt kahta merkki kymmenen asemasta.
   Tss pieni esimerkki:

           binri     kymmenjrj.
        
              1             1
             10             2
            100             4
           1000             8
         10 000             16
        100 000             32

     Havainnollistan nyt muutamaa muuta lukujrjestelm samalla luvulla
   x, jonka arvo olkoot 27 kymmenjrjestelmss:

    x  Binrisen                        11011
    x  Oktaalijrjestelmss                 33
    x  Heksadesimaalijrjestelmss          1B

     Bittejen ksittely on kuitenkin aika vaikeaa, ja siksi kytetn
   jrjestelmi, jotka helpottavat tyt. Oktaalijrjestelm on yksi
   tllainen, mutta se ei ole jrin kytnnllinen siit yksinkertaisesta
   syyst, ett teitokone kytt bittimri, jotka kaikki ovat
   jaollisia neljll, eivtk kolmella.

             oktaali  binri
             
                1         1
                2        10
                3        11
                4       100
                5       101
                6       110
                7       111

     Paljon parempi jrjestelm on heksadesimaalijrjestelm, joka
   perustuu lukuun kuusitoista, joka on aikaansaatavissa neljll
   bitill. Tll tavalla bittej on helppo ksitell, koska yksi
   heksa korvaa aina nelj bitti, ja kaikki tietokoneen ksittelemt
   tietomrt ovat jaollisia neljll.

           hex    binri     
                        1011 0110 1100 0000
             1       1                     
             2      10                    B    6    C    0
             3      11        
             4     100                  eli
             5     101        
             6     110                  101101101100000
             7     111                  joka on heksana
             8    1000                  B6C0
             9    1001                  joka on 10-jrj.
             A    1010                  46784
             B    1011        
             C    1100        
             D    1101        
             E    1110        
             F    1111        

     Lukujen muuttaminen jrjestelmst toiseen on hyv taito, vaikka
   sit ei tarvitsisikaan, ainakaan usein. Kytnnss se tapahtuu nin:
   Otamme lukujrjestelmn, ja taulukon, jossa ovat potenssit
   lukujrjestelmlle y, joka olkoot esimerkiss binrinen.

         potenssi  luku
         
           y^0      1
           y^1      2
           y^2      4
           y^3      8
           y^4     16
           y^5     32
    Dodii

   Dodii, ja sitten: otamme luvun 0101 ja alamme purkamaan sit.

   Katsomme: ensimminen sarake: 1. Siit tulee toimitus 2^0 * 1 = 1.
   Katsomme: toinen      sarake: 0. Siit tulee toimitus 2^1 * 0 = 0.
   Katsomme: kolmas      sarake: 1. Siit tulee toimitus 2^2 * 1 = 4.
   Katsomme: neljs      sarake: 0. Siit tulee toimitus 2^3 * 0 = 0.
                                                              + -------
             Ja tm todistaa laskumme oikeiksi:                   5

     Toisin pin tm on samanlaista, mutta toisinpin.
   Katsokaamme miten luku 39 muutetaan binriksi:
     Ensin otamme taulukon, jossa ovat potenssit lukujrjestelmlle y,
   joka on binrinen, eli perustuu lukuun kaksi.

                        potenssi  tulo  sarake
                        
                           2^0     1      1
                           2^1     2      2
                           2^2     4      3
                           2^3     8      4
                           2^4     16     5
                           2^5     32     6
                           2^6     64     7

     Ensin katsomme, mik on suurin luku, johon luku 39 menee.
   Se on luku 32, jonka vhennmme 39:st ja laitamme sarakkeeseen
   kuusi ykksen.
     Seuraavaksi katsomme mihin sopii luku 7, joka ji jljelle.
   Se ei mene potenssiin nelj, joten laitamme sarakkeeseen viisi
   arvon nolla.
     Se ei myskn mene sarakkeeseen nelj, joten siihenkin nolla.
     Seuraava on sarake kolme, jonka potenssiarvoon luku 7 menee.
   Laitamme sarakkeeseen kolme ykksen.
     Jljell on luku kolme, joka menee sarakkeisiin kaksi ja yksi,
   vrjten ne ykksiksi.

      Sarake: 6 5 4 3 2 1
      Bitti : 1 0 0 1 1 1
      Luku  : 39

     Luvun muuttaminen esimerkiksi kymmenjrjestelmst oktaaliksi
   on muuten samanlaista, mutta katsomme jokaisen sarakkeen kohdalla
   _monestiko_ luku menee kulloiseenkin potenssiin. Tm ei ole
   tarpeellista binrijrjestelmss sattuneesta syyst, ett
   jrjestelmss on vain numerot 0 ja 1.

     HUOM!
   
     Kikka 10-jrjestelmn luvun muuttamiseksi muihin lukujrjestelmiin:
   Ota 10-jrjestelmn luku x ja jaa se halutun
   lukujrjestelmn kantaluvulla y. Jakojnns laitetaan paperin
   vasempaan reunaan. Summa joka on jljell, jaetaan taas y:ll, ja
   jakojnns laitetaan seuraavaksi oikealle viimeisimmst jako-
   jnnksest. Tt jatketaan, kunnes luku katoaa.

   Voitte tarkistella nit mielenne mukaan ees ja taas ja aina tulla
   samaan tulokseen, ellette ole laskeneet vrin.
 ڿ
 Ŀ
                                                                        
  2. Bittioperaatiot

     Tm onkin jo paljon mielenkiintoisempi aihe, eik niin kamalan
   matemaattinenkaan. Joten luu kurkkuun ja bittioperaatioiden kimppuun.
     Niit on nelj perustyyppi: AND, OR, XOR ja NOT. Ksittelemme
   ne kaikki.

   Bitin asettamisella tarkoitetaan sen asettamista todeksi (1),
   ja kntmisell sen asettamista eptodeksi (0).

   AND - bittinen JA operaatio

      11110000       Asettaa bitin, jos sek vertailun lhde JA kohde
      00111100       ovat asetetut.
   JA----------
      00110000


   OR - bittinen TAI operaatio

      11110000       Asettaa bitin, jos joko toinen TAI kummatkin bitit
      00111100       ovat asetetut.
   TAI---------
      11111100


  XOR - bitittinen poissulkeva TAI operaatio

     11110000       Asettaa bitin, jos vain ja ainoastaan toinen bitti
     00111100       on pll. (oiva rekistereiden nollaamiseen)
  XOR---------
     11001100


  NOT - bitittinen EI operaatio

     11110000       Asettaa nollatut bitit ja toisinpin.
  NOT---------
     00001111

   3. 'lookup tables'

     Tm on siis juttu siit, miten aikaavievt laskutoimitukset
   kannattaa laskea etukteen, ja varastoida ne taulukkoon.
   Tst on hyty monissa asioissa, ei vhiten peleiss.

   Otamme suoraan esimerkin C:ll:

   float sin_table[270];
   ...
   for (int a=0; a<270; a++)      sin_
     sin_table[a] = sin(a);

   Ja sielt niit sitten kannatta haeskella aina tarvittaessa:

   joku_luku = (sin_table[0] * cos_table[180]);  // hih. ;)

   Tm nopeuttaa sovelluksia, joissa kytetn raskasta toistuvaa
   matematiikkaa _hyvin_ paljon.
   Se siit. Helppo aihe.

  ڿ
  Ŀ
                                                                        
   4. Loppulpint

     Mitp tss, loppu on.
   Virhekorjaukset, ehdotukset, vitsit, roskan, rahan ja
   flamet ja muut kivat asiat saa lhett seuraavaan osoitteeseen:

   teemu.keinonen@mbnet.fi

   TAI

   joonas.pihlajamaa@mbnet.fi
