bc(1)                           General Commands Manual                           bc(1)

NÉV
       bc - Lebegőpontos kalkulátor nyelv

ÁTTEKINTÉS
       bc [ -lws ] [  fájl ... ]

VERZIÓ
       Ez a kézikönyv lap a GNU bc 1.03-as verzióját írja le.

LEÍRÁS
       bc   egy   olyan   nyelv,   amely   lebegőpontos   számolást  nyújt,  interaktív
       végrehajtással. Van némi hasonlóság a  C  programozási  nyelvvel.  Egy  standard
       matematikai   könyvtár  megadható  parancssor  paraméterként.  Ha  szükséges,  a
       matematikai  könyvtárat   definiálni   kell,   mielőtt   bármilyen   más   fájlt
       feldolgoznánk.  A  bc  a  megadott  fájlokban  levő  kódot a megadás sorrenjében
       dolgozza fel. Miután minden fájlt feldolgozott a bc a szabványos bemenetről  vár
       további  utasításokat.  Minden kódot a beolvasás pillanatában végrehajt. (Ha egy
       fájlban olyan utasítás található, amely megállítja a feldolgozót, a bc nem fog a
       szabványos bemenetről olvasni.

       A bc ezen implementációja sok bővítéssel rendelkezik a POSIX standardhoz képest.
       Parancssor opcióval megadható, hogy  a  program  ezeknél  figyelmeztessen,  vagy
       dobja  vissza  őket. Ez a dokumentum az ezen feldolgozó által elfogadott nyelvet
       írja le. A kiterjesztések természetesen jelölésre kerülnek.

OPCIÓK
       -l     Definiálja a standard matematikai könyvtárat.

       -w     Figyelmeztet a POSIX bc-hez képest használt kiterjesztésekre.

       -s     Csak a pontos POSIX bc nyelvet dolgozza fel.

SZÁMOK
       A bc legalapvetőbb eleme a szám. A számok pontossága  bármekkora  lehet.   Ez  a
       pontosság  mind  az  egész,  mind a tört részre vonatkozik. Minden szám belsőleg
       decimálisan tárolódik, és a számítások is decimálisan hajtódnak  végre.   (Ez  a
       verzió  az osztásnál és a szorzásnál csonkít.) A számoknak két jellemzője van, a
       hossz és a lépték. A hossz a szignifikáns decimális számjegyek számát jelenti, a
       lépték pedig a tizedspont után levőkét.  Például:
               .000001 számnak a hossza és a léptéke is 6.
              míg az 1935.000 számnak a hossza 7, a léptéke 3.

VÁLTOZÓK
       A számokat két fajta változóban lehet tárolni, egyszerű változóban vagy tömbben.
       Mind az egyszerű, mind a  tömbváltozónak  van  neve.  A  neveknek  betűvel  kell
       kezdődniük,  ezt  követhetik  számok,  betűk  vagy  aláhúzások.  Minden  betűnek
       kisbetűnek kell lennie. (A teljes alfanumerikus nevek már  egy  kiterjesztés.  A
       POSIX  bc-ben  minden  név  egy kisbetűből áll.) A változó típusa a kontextusból
       tisztán kiderül, mivel minden tömb  változót  egy  szögletes  zárójel  pár  ([])
       követ.

       Négy  speciális  változó  van,  scale,  ibase,  obase,  és  last.  A  scale  azt
       definiálja, hogy néhány művelet a tizdes pont után hány számjegyet használjon. A
       scale  alapértelmezett értéke 0. Az ibase és az obase definiálja a bemeneti és a
       kimeneti  számrendszer  konverziót.  Az  alapértelmezett  számrendszer  mind   a
       bemenetre,  mind  a  kimenetre 10-es. A last (kiterjesztés) változóban az utolsó
       kiírt érték szerepel. Ez később kerül részletezésre. Ezeknek  vátlozóknak  lehet
       értéket adni, de kifejezésben is használhatóak.

MEGJEGYZÉS
       A megjegyzések a bc-ben a /* karakterekkel kezdődnek és a */ karakterek jelzik a
       végét. A  megjegyzések  bárhol  megjelenhetnek,  és  a  bemenetben  egy  szóközt
       jelentenek.  (Ez azt jelenti, hogy a megjegyzések elhatárolnak más objektumokat.
       Például, egy megjegyzés nem lehet egy  változónév  közepén.)  A  megjegyzésekben
       bármennyi újsor lehet (sor vége), a megjegyzés kezdete és vége között.

KIFEJEZÉSEK
       A  számokat  kifejezésekkel  és utasításokkal lehet manipulálni. Mivel a nyelvet
       interaktívra készítették, az utasítások és a kifejezések rögtön  végrehajtódnak.
       Nincs "fő" program (main függvény). A kód olyan sorrendben hajtódik végre, ahogy
       a  bc  beolvassa.  (A  függvények,  később  kerülnek   leírásra,   a   beolvasás
       sorrendjében kerülnek definiálásra.)

       Egy  egyszerű  kifejezés  egy  konstans.  A  bc  a konstanst az ibase változóban
       megadott bemeneti számrendszer szerint decimális számmá konvertálja. (Kivétel  a
       függvényeknél.)  Az ibase érvényes értékei 2-től 16-ig terjednek. Ezen a határon
       túli értéket megadva az ibase változónak, a változó értéke 2  vagy  16  lesz.  A
       bemenő  számok  a  0-9-ig  és  az  A-F-ig  terjedő karaktereket tartalmazhatják.
       (Megjegyzés:  Nagybetűknek  kell  lenniük.  A  kisbetűk  a  változóknak   vannak
       fenntartva.)  Az  egy  számjegyű számoknak mindig a számjegy az értéke, az ibase
       változótól függetlenül (pl.: A = 10). A több számjegyű számoknál a bc az  ibase-
       nél  nagyobb  számjegyeket  bc  -  1-re  cseréli. Ezáltal, a FFF mindig a lehetó
       legnagyobb háromjegyű számot jelenti.

       A teljes kifejezések hasonlóak a többi magas szintű  nyelvben  levőkhöz.   Mivel
       csak  egyetlen  típusú szám van, nincs szabály a típusok keverésének kezelésére.
       Minden kifejezésnek van egy pontossága. Ez az eredeti  számokból,  az  elvégzett
       műveletekból  és  még  sok  egyébből tevődik össze, az értéke a scale változóban
       található. Ezen változó legális értékei a  0-tól  a  C  nyelvben  egész  számnak
       megadható legnagyobb értékig terjednek.

       Itt  következik a legalis kifejezések leírása, az "expr" a teljes kifejezésre, a
       "var" pedig egy egyszerű, vagy egy  tömb  változóra  vonatkozik.   Egy  egyszerű
       változóra a
              name
       míg egy tömbre a
              name[expr]
       leírásával  hivatkozhatunk.   Hacsak  másként  nem  specifikáljuk,  az  eredmény
       pontossága a kifejezések pontosságának a maximuma lesz.

       - expr Az eredmény a kifejezés negáltja.

       ++ var A változó értéke eggyel nő, és az eredmény a változó új értéke lesz.

       -- var A változó értéke eggyel csökken, és az eredmény a változó új értéke lesz.

       var ++ A kifejezés eredménye a változó eredeti értéke, majd a változó értéke  nő
              eggyel.

       var -- A  kifejezés  eredménye  a  változó eredeti értéke, majd a változó értéke
              csökken eggyel.

       expr + expr
              Az eredmény a két kifejezés összege.

       expr - expr
              Az eredmény a két kifejezés különbsége.

       expr * expr
              Az eredmény a két kifejezés szorzata.

       expr / expr
              Az eredmény a két kifejezés hányadosa. Az eredmény  pontosságát  a  scale
              változó értéke határozza meg.

       expr % expr
              Az  eredmény a "maradék", amely a következőképpen kerül kiszámolásra.  Az
              a%b kiszámolásához először, kiszámolásra kerül az a/b, scale  számjegyre.
              Az   eredmény   a  következőképpen  adódik:  a-(a/b)*b,  a  pontossága  a
              scale+scale(b) és scale(a) közül a  nagyobb  lesz.  Ha  a  scale  egyenlő
              nullával, vagy mindkét kifejezés egész, a maradék is egész lesz.

       expr ^ expr
              Az  eredmény az első kifejezés a másodikra emelve. A második kifejezésnek
              egésznek  kell  lennie.  (Ha  a  második   kifejezés   nem   egész,   egy
              figyelmeztetés  generálódik,  és  az érték egész értékre csonkolódik.) Az
              eredmény pontossága scale lesz, ha a kitevő negatív. Ha a kitevő pozitív,
              az  eredmény  pontossága  az  első  kifejezés  pontosságának  és a kitevő
              értékének a szorzata és - az első kifejezés és  a  scale  változó  értéke
              közül  a nagyobb - közül a kisebb lesz. (Pl. scale(a^b) = min(scale(a)*b,
              max( scale, scale(a))).)  Megjegyezendő, hogy az expr^0 mindig 1 értékkel
              tér vissza.

       ( expr )
              Ez megváltoztatja a kifejezés kiértékelésének standard precedenciáját.

       var = expr
              A változó értéke a kifejezés lesz.

       var <op>= expr
              Ez  ekvivalens  a "var = var <op> expr" kifejezéssel, azzal a kivétellel,
              hogy  a  "var"  rész  csak  egyszer  értékelődik  ki.  Ez  akkor  okozhat
              különbséget, ha a "var" egy tömb.

        A  relációs  kifejezések  speciális  kifejezés fajták, amelyek mindig 0-t, vagy
       1-et adnak vissza, 0-át, ha a reláció hamis, és 1-et, ha  igaz.  Ezek  bármilyen
       legális  kifejezésben megjelenhetnek.  (A bc POSIX változatában, hogy a relációs
       kifejezések csak if, while és for utasításokban szerepelhetnek, illetve csak egy
       tesztelésük lehetséges.) A relációs operátorok a következők:

       expr1 < expr2
              Az eredmény 1, ha az expr1 kisebb, mint az expr2.

       expr1 <= expr2
              Az eredmény 1, ha az expr1 kisebb, vagy egyenlő, mint az expr2.

       expr1 > expr2
              Az eredmény 1, ha az expr1 nagyobb, mint az expr2.

       expr1 >= expr2
              Az eredmény 1, ha az expr1 nagyobb, vagy egyenlő, mint az expr2.

       expr1 == expr2
              Az eredmény 1, ha az expr1 egyenlő az expr2-vel.

       expr1 != expr2
              Az eredmény 1, ha az expr1 nem egyenlő az expr2-vel.

       A boolean műveletek is legálisak. ( A POSIX bc-ben nincsenek boolean műveletek.)
       Minden boolean műveletnek az értéke  0,  vagy  1  (hamis,  vagy  igaz),  mint  a
       relációs műveleteknél. A boolean műveletek a következőek:

       !expr  Az eredmény 1, ha a kifejezés 0.

       expr && expr
              Az eredmény 1, ha a mindkét kifejezés nem 0.

       expr || expr
              Az eredmény 1, ha a bármelyik kifejezés nem 0.

       A kifejezések precedenciája a következő (alacsonytól a magas felé):
              || operátor, balról asszociatív
              && operátor, balról asszociatív
              ! operátor, nem asszociatív
              Relációs operátorok, balról asszociatív
              Értékadó operátor, jobbról asszociatív
              + és - operátorok, balról associative
              *, / és % operátorok, balról asszociatív
              ^ operátor, jobbról asszociatív
              unáris - operátor, nem asszociatív
              ++ és -- operátorok, nem asszociatív

       Ez  a  precedencia  úgy  van  megválasztva,  hogy  a  POSIX  bc alá programok is
       korrekten fussanak. Emiatt, a  relációs  és  logikai  operátorokat  az  értékadó
       operátoroknál néha szokatlan eredmény is kijöhet. Lásd a következő kifejezést:
              a = 3 < 5

       A  legtöbb C programozó ezt úgy értelmezi, hogy a "3 < 5" (az értéke 1) kerül az
       "a" változóba. A bc itt a  következőt  csinálja,  hozzárendeli  a  3-at  az  "a"
       változóhoz,  majd  a  3-at  összehasonlítja az 5-tel. A legjobb, hogyha értékadó
       operátort  használsz  relációs,  és  logikai  operátorokkal,   akkor   használsz
       zárójeleket.

       Van  néhány  egyéb  speciális  kifejezés,  amelyet  még  a  bc  nyújt.   Ezek  a
       felhasználó által definiálható függvények, és a standard függvények hívása. Ezek
       a  következő  alakban  jelennek meg: name(parameters) A függvényekhez lásd még a
       felhasználó által  definiált  függvények  fejezetet.  A  standard  függvények  a
       következőek:

       length ( expression )
              A  length  függvény értéke a kifejezésben megadott szám értékes jegyeinek
              száma.

       read ( )
              A  read  függvény  (kiterjesztés)  beolvas  egy   számot   a   szabványos
              bemenetről,   függetlenül   attól,   hogy   a   függvény  hol  található.
              Figyelmeztetés: ez problémát okozhat, ha mind a program, mind az adatok a
              standard  bementről  jönnek.  A  legjobb,  ha  ezt a függvényt csak előre
              megírt programoknál használjuk, amely adatokat kér a  felhasználótól,  de
              nem  engedi  meg,  hogy  a  felhasználó  program kódot is beírjon. A read
              függvény értéke a szabványos bemenetről beolvasott szám értéke, az  ibase
              változó értékét, mint számrendszert használva a konverzió alapjául.

       scale ( expression )
              A   scale   függvény  értéke  a  kifejezés  tizedespont  mögött  szereplő
              számjegyeinek száma.

       sqrt ( expression )
              Az sqrt függvény értéke a kifejezés értékének a négyzetgyökével  egyenlő.
              Ha a kifejezés negatív, egy futási hiba generálódik.

UTASÍTÁSOK
       Az  utasítások  (mint  a legtöbb algebrai nyelvnél) határozzák meg a kifejezések
       kiértékelésének sorrendjét. A bc-ben az utasítások akkor hajtódnak végre,  amint
       "arra  mód  van".  A végrehajtás akkor történik meg, mikor az interpreter új sor
       karakterrel találkozik, illetve, mikor egy, vagy több komplett utasítás felépül.
       Ezen azonnali végrehajtás miatt, az újsorok nagyon fontosak a bc-ben. Valójában,
       mind a pontosvessző, mind az újsor használható utasításelválasztóként. Egy rossz
       helyre   rakott  újsor  szintaktikai  hibát  okoz.  Mivel  az  újsorok  utasítás
       elhatárolók, el lehet őket rejteni, a backslash karakter segítségével. A "\<nl>"
       karaktersorozattal, ahol az <nl> az újsort jelenti, az újsor csak egy szóközként
       jelenik meg a bc-ben.  Egy  utasítás  lista  a  pontosvesszővel,  vagy  újsorral
       elválasztott  utasítások sorozata.  Itt következnek a bc utasításai, és az, hogy
       mit  csinálnak:  (A  szögletes  zárójelbe  ([])  zárt  részek   az   utasításból
       elhagyhatóak.)

       expression
              Ez az utasítás kétféle képpen is megjelenhet. Az egyik, mikor a kifejezés
              "<változó> <értékadás> ...", ez egy értékadási utasítás.  Ha a  kifejezés
              nem értékadási utasítás, akkor kiértékelése után kapott eredmény kiírásra
              kerül a szabványos kimenetre. A szám kiírása után egy újsor  is  kiírásra
              kerül.  Például,  az  "a=l"  egy  értékadási utasítás, míg az "(a=l)" egy
              kifejezés, amelyben van egy értékadás. Minden szám  az  obase  változóban
              tárolt  számrendszer  alapján  kerül  kiírásra.  Az obase változó legális
              értékei 2-től a BC_BASE_MAX konstansban tárolt  értékig  mehetnek.  (Lásd
              még  a HATÁRÉRTÉKEK fejezetet.) A 2-estől a 16-os számrendszerig a számok
              kiírása a szokásos módon történik. 16-osnál nagyobb  számrendszereknél  a
              bc  több  karakterből  álló  számjegyeket  használ,  ahol minden magasabb
              számrendszerbeli számjegynek a tizes számrendszerbeli számképe íródik ki.
              A  több karakteres számjegyeket egymástól a program szóközökkel választja
              el. Minden számjegy annyi karakterből  áll,  amennyi  az  "obase-1"  szám
              kiírásához   kell,   10-es   számrendszerben.   Mivel  a  számok  változó
              pontosságúak, előfordulhat, hogy néhány  szám  kiírása  nem  fér  ki  egy
              sorba.  Ezeket a hosszú számokat a program sorokra tördeli, a sorok végén
              egy-egy "\" karakterrel.  Az egy sorba kiírt karakterek  maximális  száma
              70.  A  bc  interaktivitása  miatt,  az utolsó kiírt számot eltárolja egy
              speciális  változóban.  Így  az  utoljára  kiírt  szám  megkapásához  nem
              szükséges  újra  leírni  az  egész  kifejezést, hanem csak a last változó
              értékét kell előszedni. A last  változónak  értéket  is  lehet  adni,  ez
              esetben  a  benne tárolt utolsó érték egyszerűen felülíródik. Ez az érték
              addig marad meg benne, amíg a következő szám kiírásra nem kerül, vagy más
              értéket  nem  adnak  neki. (Némelyik implementáció megengedi, hogy a last
              változóra  egy  egyedüli  ponttal  ("."),  amely   nem   része   számnak,
              hivatkozzunk.)

       string A  string  a  kimenetre  íródik  ki. A stringek idézőjellel kezdődnek, és
              bármilyen karaktert  tartalmazhatnak  a  következő  idézőjelig.  Egyetlen
              karakter  sem  kerül  értelmezésre,  még  az újsor karakter sem. A string
              kiírása után nem íródik ki újsor karakter.

       print list
              A print utasítás (kiterjesztés), a kiírás egy újabb módozatát kínálja.  A
              "list"  egy  string  és  kifejezés  lista,  vesszővel elválasztva. Minden
              string vagy kifejezés a lista sorrendjében  íródik  ki.  Záró  újsor  nem
              íródik  ki.  A  kifejezések  kiértékelődnek,  és  az  eredményük  a  last
              változóban  tárolásra  kerül.  A  stringek  pedig   egyszerűen   kiírásra
              kerülnek,   speciális   karaktereket   is  tartalmazhatnak.  A  speciális
              karakterek a backslalsh karakterrel kezdődnek (\). A speciális karakterek
              a  következőek:  "a"  (figyelmeztetés,  vagy  bip),  "b" (backspace), "f"
              (lapdobás),  "n"  (újsor),  "r"  (kocsi  vissza),  "q"  (idézőjel),   "t"
              (tabulátor)  és  "\"  (backslash).  Minden  más,  a  backslash  után levő
              karaktert figyelmen kívül hagy a program.

       { utasítás_lista }
              Ez egy összetett utasítás. Ennek segítségével  lehet  több  végrehajtandó
              utasítást egybekapcsolni.

       if ( kifejezés ) then utasítás1 [else utasítás2]
              Az  if  kiértékeli  a kifejezést, és végrehajtja az utasítás1-et, vagy az
              utasítás2-t, a kifejezés értékétől függően. Ha a kifejezés eredménye  nem
              nulla,  az  utasítás1  hajtódik  végre.  Ha  az  utasítás2  létezik, és a
              kifejezés eredménye nulla, az  utasítás2  hajtódik  végre.  (Az  else  ág
              kiterjesztés.)

       while ( kifejezés ) utasítás
              A  while  utasítás  mindaddig  végrehajtja az utasítást, amíg a kifejezés
              eredménye nem nulla. Az utasítás minden végrehajtása előtt  kiértékeli  a
              kifejezést.  A  ciklus akkor fejeződik be, ha a kifejezés eredménye nulla
              lesz, vagy ha végrehajtódik egy break utasítás.

       for ( [kifejezés1] ; [kifejezés2] ; [kifejezés3] ) utasítás
              A for utasítás egy utasítás ismételt végrehajtását vezérli. A  kifejezés1
              a   ciklus   előtt   kiértékelődik.   A  kifejezés2  az  utasítás  minden
              végrehajtása   előtt   kiértékelődik.   Ha   nem   nulla,   az   utasítás
              végrehajtódik,   ha   nulla,  a  ciklus  véget  ér.  Az  utasítás  minden
              végrehajtása után,  a  kifejezés3  kiértékelődik,  mielőtt  a  kifejezés2
              kiszámolódna. Ha a kifejezés1 és a kifejezés3 hiányzik, a kiértékelődésük
              helyén semmi nem fog történni.   Ha  a  kifejezés2  hiányzik,  az  olyan,
              mintha  a  kifejezés2  helyén  egy  olyan  kifejezés  lenne,  amelynek az
              eredménye mindig 1.  (Az  opcionális  kifejezések  egy  kiterjesztés.)  A
              következő ekvivalens kódokat ad a for utasításra:
              kifejezés1;
              while (kifejezés2) {
                 utasítás;
                 kifejezés3;
              }

       break  Ezzel   az  utasítással  ki  lehet  lépni  a  legbelső  while,  vagy  for
              utasításból.

       continue
              Ez az utasítás  (kiterjesztés)  azt  eredményezi,  hogy  a  legbelső  for
              utasítás egy új ciklust kezd.

       halt   Ez  az utasítás (kiterjesztés), ha végrehajtódik, azt eredményezi, hogy a
              bc kilép.

       return Nulla  értékkel  tér  vissza  egy  függvényből  (lásd  még  a  függvények
              fejezetet).

       return ( expression )
              A  kifejezés eredményével tér vissza a függvényből (lásd még a függvények
              fejezetet).

PSZEUDO UTASÍTÁSOK
       Ezek az utasítások a tradicionális  értelemben  nem  utasítások.  Nem  hajtódnak
       végre. Funkciójukat "fordítási" időben fejtik ki.

       limits Kiírja a bc adott verziója által használt határokat. Kiterjesztés.

       quit   Ha a quit utasítást beolvassa, a bc feldolgozó kilép. Nem számít, hogy az
              utasítás hol található (pl. az "if (0 == 1) quit"  hatására  is  kilép  a
              bc.)

       warranty
              Kiírja a figyelmeztető üzenetet. Kiterjesztés.

FÜGGVÉNYEK
       A  függvényekkel  definiálhatunk  számításokat,  amelyeket  csak később kívánunk
       végrehajtani. A függvények a bc  -ben  mindig  egy  értéket  számolnak,  és  azt
       visszaadják  a  hívónak. A függvény definíciója "dinamikus" abban az értelemben,
       hogy mindaddig definiálatlan, amíg a feldolgozó nem találkozik vele a bemeneten.
       Ez   a   definícó  mindaddig  használható,  amíg  egy  ugyanezen  névű  függvény
       definicóval nem találkozik.  Az új definíció felülírja  a  régit.  Egy  függvény
       definíciója a következőképpen néz ki:
              define name ( parameters ) { newline
                  auto_list   statement_list }
       A függvényhívás is egy kifejezés, a következő formában: "name(parameters)".

       A   paraméterek   számok,   vagy  tömbök  lehetnek  (kiterjesztés).  A  függvény
       definícójában nulla, vagy több paraméter definiálható, vesszővel elválasztva.  A
       számok  csak  érték  szerinti  átadással,  a  tömbök csak cím szerinti átadással
       hívódnak meg. A tömböket a paraméterek között a "név[]" módon kell specifikálni.
       A  függvényhívásnál  a szám paraméterek teljes kifejezések lehetnek. A tömböknél
       ugyanaz a jelölés használandó, mint a definiáláskor.  A  nevesitett  tömbök  cím
       szerinti  átadással  kerülnek  a  függvényhez.   Mivel  a  függvény  definíciója
       dinamikus, a paraméterek  száma  és  típusa  csak  a  hívás  pillanatában  kerül
       ellenőrzésre.  Ha ebben eltérés mutatkozik, egy futási-hiba váltódik ki. Futási-
       hiba váltódik ki akkor is, ha egy nem létező függvényt hívunk meg.

       Az auto_list egy opcionális változó lista, amely "helyi" változókat tartalmazza.
       A  szintaxisa:  "auto  név, ... ;".  (A pontosvessző opcionális.) Minden név egy
       auto változó neve. Tömbök is  definiálhatóak  így,  a  szokásos  módon.  Ezek  a
       változók  a  vermen  kapnak helyet, a függvény belépése után.  A változók ezután
       inicializálásra kerülnek nulla kezdőértékkel, és a függvény  végrehajtása  során
       használhatóak.  Amikor  a  függvény  kilép,  ezeket  a  változókat eltávolítja a
       veremből,  így  az  eredeti  értékük  helyreállítódik.  A  paraméterek  is  auto
       változók, amelyek a függvény meghívásakor kapják meg értéküket. Az auto változók
       különböznek a  tradícionális  helyi  változóktól  a  következő  dologban:  ha  A
       meghívja  a  B  függvényt,  B  látja  az  A  auto  változóit, hacsak B-ben nincs
       ugyanezen néven is auto változó  definiálva.  Azon  tény  miatt,  hogy  az  auto
       változók  és  a  paraméterek  egy  vermen  kapnak helyet, a bc kezeli a rekurzív
       függvényeket is.

       A függvény törzse bc utasítások listája.  Az  utasításokat  pontosvesszők,  vagy
       újsorok  választják el. A return utasítás hatására a függvény végrehajtása véget
       ér, és visszatér egy értékkel. Az első forma,  a  "return",  0-át  ad  vissza  a
       hívónak,  míg  a második, "return ( kifejezés )", kiértékeli a kifejezést, és az
       eredményt adja vissza. A függvény végén, ha mást nem írunk ki,  mindig  van  egy
       "return  (0)",  ez  megkímél  attól,  hogy  explicite  ki  kelljen írni a return
       utasítást.

       A  függvényeknél  megváltozik  az  ibase  változó  használata  is.   A  függvény
       törzsében  szereplő  minden  konstans,  a  függvény  hívásakor használatos ibase
       alapján konvertálódik. Ha az ibase-t megváltoztatjuk egy függvényben, annak  nem
       lesz  hatása,  kivéve  a read standard függvényt, amely mindig az ibase aktuális
       értékét használja a számok konvertálásához.

MATEMATIKAI KÖNYVTÁR
       Ha a bc-t a -l opcióval  indítjuk,  a  matematikai  könyvtár  betöltődik,  és  a
       pontosság 20-as lesz. A matematikai függvények azzal a pontossággal számolják ki
       az eredményt, amely a meghívásukkor be volt állítva. A  matematikai  könyvtár  a
       következő függvényeket definiálja:

       s (x)  Az x (radián) színusza.

       c (x)  Az x (radián) koszínusza.

       a (x)  Az x arkusz tangense.

       l (x)  Az x természetes logaritmusa.

       e (x)  Az e x-edik hatványa.

       j (n,x)
              Az n-ed rendű Bessel fuggvenye x-nek.

PÉLDÁK
       A  /bin/sh-ban  a  következő  utasítás visszaadja a "pi" értékét a pi környezeti
       változóban.
               pi=$(echo "scale=10; 4*a(1)" | bc -l)

       Az itt következő példában a matematikai könyvtárban található  hatvány  függvény
       definícióját mutatjuk be. A függvény POSIX bc nyelven íródott.
              scale = 20

              /* Kihasználja a következó tényt: e^x = (e^(x/2))^2.
                 Mikor az x elég kicsi, a következő sort használjuk:
                   e^x = 1 + x + x^2/2! + x^3/3! + ...
              */

              define e(x) {
                auto  a, d, e, f, i, m, v, z

                /* Ellenőrzi az x előjelét. */
                if (x<0) {
                  m = 1
                  x = -x
                }

                /* Elófeltétel. */
                z = scale;
                scale = 4 + z + .44*x;
                while (x > 1) {
                  f += 1;
                  x /= 2;
                }

                /* Inicializálja a változókat. */
                v = 1+x
                a = x
                d = 1

                for (i=2; 1; i++) {
                  e = (a *= x) / (d *= i)
                  if (e == 0) {
                    if (f>0) while (f--)  v = v*v;
                    scale = z
                    if (m) return (1/v);
                    return (v/1);
                  }
                  v += e
                }
              }

       A  következő  kód  a  bc  kiterjesztett  szolgáltatásait használja, egy egyszerű
       csekkfüzet egyenleg kiszámolására. Legjobb, ha ezt a programot fájlba lementjük,
       hogy többször is használhassuk anélkül, hogy újra be kelljen gépelni.
              scale=2
              print "\nCsekkfüzet program!\n"
              print "  Emlékeztető, a letétek negatív tranzakciók.\n"
              print "  Kilépés 0 összegű tranzakció bevitelével.\n\n"

              print "Kezdeti egyenleg? "; bal = read()
              bal /= 1
              print "\n"
              while (1) {
                "jelenlegi egyenleg = "; bal
                "tranzakció? "; trans = read()
                if (trans == 0) break;
                bal -= trans
                bal /= 1
              }
              quit

       A következő függvény a faktoriális rekurzív definíciója.
              define f (x) {
                if (x <= 1) return (1);
                return (f(x-1) * x);
              }

ELTÉRÉSEK
       A  bc  ezen  verziója  a  POSIX  P1003.2/D11  tervezete  alapján  készült  és  a
       tervezethez  és  a  tradícionális  implementációhoz  képest  sok   bővítést   és
       különbséget  tartalmaz.  Ez nincs implementálva a tradícionális dc(1)-ben.  Ez a
       verzió egy egyszerű feldolgozó, amely csak átfordítja  a  programot.   Egy  "nem
       dokumentált"   kapcsoló  (-c)  kiírja  az  átfordított  programot  a  szabványos
       kimenetre, és nem futtatja le.  Ez  főleg  az  értelmező  nyomkövetésekor  és  a
       matematikai könyvtár előkészítésekor használatos.

       A  különbségek  legfőbb  forrásai  a  kiterjesztések,  hol egy szolgáltatás lett
       kiterjesztve, hogy több  lehetősége  legyen,  hol  pedig  új  szolgáltatás  lett
       létrehozva. A következó lista megmutatja a különbségeket és a kiterjesztéseket.

       LANG környezeti változó
              Ez  a  verzió  nem  követi  a  POSIX  szabványt a LANG környezeti változó
              használatában, és minden környezeti változó az "LC_" prefixszel kezdődik.

       nevek  A tradícionális és a POSIX bc -ben a funkciók, változók és  tömbök  nevei
              csak   egy   karakter  hosszúak  lehettek.  Itt  már  több  karaktert  is
              használhatunk, de a  neveknek  betűvel  kell  kezdődni  és  csak  betűket
              számokat és aláhúzásjeleket tartalmazhatnak.

       Stringek
              A  stringek  nem  tartalmazhatnak  NUL  (ASCII  nulla) karaktert. A POSIX
              szerint bármilyen karakter lehet egy stringben.

       last   A POSIX bc-ben nincs last változó.  Néhány  implementáció  a  pontot  (.)
              használja erre a célra.

       összehasonlítások
              A   POSIX   bc   csak   az   if,  vagy  a  while  utasításban  enged  meg
              összehasonlításokat, vagy a for utasítás második kifejezésében.  Továbbá,
              utasításonként csak egy relációs operátor van megengedve.

       if utasítás, else ág
              A POSIX bc-ben nincs else ág.

       for utasítás
              A POSIX bc-ben minden kifejezésnek szerepelnie kell.

       &&, ||, !
              A POSIX bc-ben nincsenek logikai operátorok.

       read függvény
              A POSIX bc-ben nincs read függvény.

       print utasítás
              A POSIX bc-ben nincs print utasítás.

       continue utasítás
              A POSIX bc-ben nincs continue utasítás.

       tömb paraméterek
              A   POSIX   bc-ben  nincsenek  tömb  paraméterek.  Más  implementációkban
              lehetnek.

       =+, =-, =*, =/, =%, =^
              A  POSIX  bc-ben  nincs  szükség  ezekre  a   "régi   stílusú"   értékadó
              operátorokra.  Ez a verzió megengedi ezeket. Használd a limits utasítást,
              hogy megtudd, hogy az installált verzió megengedi-e ezeket.  Ha igen,  az
              "a  =-  1"  kifejezés csökkenti az a értékét 1-gyel, egyébként pedig az a
              értékét beállítja -1-re.

       szóközök a számokban
              A bc más implementációi  megengedik  szóközök  használatát  a  számokban.
              Például,  az  "x=1  3"  kifejezés  az  x változóhoz hozzárendeli a 13-at.
              Ebben a bc-ben ugyanez az utasítás szintaktikai hibát ad.

       hibák és végrehajtás
              Ez az impelmentáció különbözik a többitől abban, hogy mely kódokat hajtja
              végre,   mikor  egy  szintaktikai,  vagy  más  hibába  belefut.   Ha  egy
              szintaktikai  hibát  talál  a  függvény  definíciójában,   a   hibakezelő
              megpróbálja  megtalálni  az  utasítás  elejét,  és  folytatni  a függvény
              feldolgozását. Ha a szintaktikai hiba a függvény törzsében következik be,
              a függvény nem lesz definiálva, és nem lehet meghívni sem.  Az interaktív
              végrehajtási blokkokban levő szintaktikai hibák érvénytelenítik az  egész
              blokkot.  Egy  végrehajtási  blokknak  minősül az az utasítássor, amely a
              következő soremelésig tart.  Például:
              a = 1
              b = 2
       ez két végrehajtási blokk és
              { a = 1
                b = 2 }
       ez egy. A futási-hibák hatására a jelenlegi blokk  végrehajtása  befejeződik.  A
       futási-figyelmezetetés nem állítja meg a blokk végrehajtását.

       Megszakítások
              Egy   interaktív   végrehajtás  során,  a  SIGINT  szignál  (általában  a
              terminálról érkező Control-C karakter  generálja)  hatására  a  jelenlegi
              blokk  végrehajtása  megszakad.  Kijelzésre kerül egy "futási" hiba, hogy
              melyik függvény lett megszakítva. Miután minden futási struktúra  kiürül,
              egy  üzenet  kerül  kiírásra  a  felhasználó felé, hogy a bc kész további
              adatok  fogadására.  Minden  korábban  definiált  függvény  továbbra   is
              definiálva  marad,  és minden nem-auto változóban a megszakításkori érték
              lesz. Minden auto változó (a függvények paraméterei is) törlésre kerül  a
              kiürítési  eljárás  során. Nem-interaktív végrehajtáskor a SIGINT szignál
              az egész bc futását megszakítja.

HATÁROK
       A következő határok vannak beépítve ebbe a bc -be. Néhányuk  egy  installálással
       megváltoztatható.   Az   aktuális  értékeik  megszerzéséhez  használd  a  limits
       utasítást.

       BC_BASE_MAX
              A legnagyobb kimeneti számrendszer,  jelenleg  999.  A  maximum  bemeneti
              számrendszer 16.

       BC_DIM_MAX
              Ez  a  jelenlegi  pontossági  határ,  655535.  Az ön installációjában más
              lehet.

       BC_SCALE_MAX
              A tizedes pont előtti és utáni számjegyek  számát  az  INT_MAX  határozza
              meg.

       BC_STRING_MAX
              A karakterek maximális száma egy stringben INT_MAX.

       exponens
              A  hatványozás  operátor  (^)  kitevőjének  maximum  értékét  a  LONG_MAX
              határozza meg.

       szorzás
              A szorzó rutin inkorrekt  eredményt  adhat,  ha  a  számnak  (LONG_MAX  /
              90)-nél több számjegye van. 32-bites long-nál ez 23,860,929 számjegy.

       kód méret
              Minden  függvénynek  és a "fő" programnak is limitálva van a mérete 16384
              byte lefordított kódban. Ez a határ (BC_MAX_SEGS) könnyen túlléphető,  ha
              több, mint 16 1024 byte-os szegmensünk van.

       változó nevek
              A  jelenlegi  limit  az egyedi nevekre 32767 mind az egyszerű változókra,
              mind a tömbökre és a függvényekre.

FÁJLOK
       A legtöbb  installációban  a  bc-nek  nincs  szüksége  egyéb  fájlokra.   Míg  a
       végrehajtható  program  hossza  fontos,  illetve a C fordító nem tudja kezelni a
       nagyon  hosszú  stringeket,  a  bc   a   standard   matematikai   könyvtárat   a
       /usr/local/lib/libmath.b  fájlból  olvassa  be.  (A  fájl  helye  rendszerenként
       változhat, lehet /lib/libmath.b is.)

DIAGNOSZTIKA
       Ha egy a parancssorban szereplő fájl nem nyitható meg, a bc üzen,  hogy  a  fájl
       nem  elérhető, és kilép. Ugyanígy, a fordítási és a futási idejű diagnosztika is
       önmagyarázó.

HIBÁK
       A hibakezelés még nem túl jó.

SZERZŐ
       Philip A. Nelson
       phil@cs.wwu.edu

KÖSZÖNETNYILVÁNÍTÁSOK
       A szerző szeretné megköszönni Setve  Sommars-nak  (Steve.Sommars@att.com),  hogy
       oly  nagy  mértékben  segített  az  implementáció  tesztelésében.  Sok nagyon jó
       tanácsot adott. Segítségével egy sokkal jobb terméket sikerült létrehozni.

MAGYAR FORDÍTÁS
       Csehi András <acsehi@flexum.hu>

                                           .                                      bc(1)

usage: bc [options] [file ...]
  -h  --help         print this usage and exit
  -i  --interactive  force interactive mode
  -l  --mathlib      use the predefined math routines
  -q  --quiet        don't print initial banner
  -s  --standard     non-standard bc constructs are errors
  -w  --warn         warn about non-standard bc constructs
  -v  --version      print version information and exit