bc

bc(1)                        General Commands Manual                       bc(1)



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

ÁTTEKINTÉS
       bc [ -hlwsqv ] [long-options] [  file ... ]

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.

   KAPCSOLÓK
       -h, --help
              Print the usage and exit.

       -i, --interactive
              Force interactive mode.

       -l, --mathlib
              Definiálja a standard matematikai könyvtárat.

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

       -s, --standard
              Csak a pontos POSIX bc nyelvet dolgozza fel.

       -q, --quiet
              Do not print the normal GNU bc welcome.

       -v, --version
              Print the version number and copyright and quit.

   SZÁMOK
       The most basic element in bc is the number.  Numbers are arbitrary
       precision numbers.  This precision is both in the integer part and the
       fractional part.  All numbers are represented internally in decimal and
       all computation is done in decimal.  (This version truncates results from
       divide and multiply operations.)  There are two attributes of numbers,
       the length and the scale.  The length is the total number of decimal
       digits used by bc to represent a number and the scale is the total number
       of decimal digits after the decimal point.  For example:
               .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.

       To support the use of scripts for bc, a single line comment has been
       added as an extension.  A single line comment starts at a # character and
       continues to the next end of the line.  The end of line character is not
       part of the comment and is processed normally.

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

       A simple expression is just a constant. bc converts constants into
       internal decimal numbers using the current input base, specified by the
       variable ibase. (There is an exception in functions.)  The legal values
       of ibase are 2 through 36. (Bases greater than 16 are an extension.)
       Assigning a value outside this range to ibase will result in a value of 2
       or 36.  Input numbers may contain the characters 0-9 and A-Z. (Note: They
       must be capitals.  Lower case letters are variable names.)  Single digit
       numbers always have the value of the digit regardless of the value of
       ibase. (i.e. A = 10.)  For multi-digit numbers, bc changes all input
       digits greater or equal to ibase to the value of ibase-1.  This makes the
       number ZZZ always be the largest 3 digit number of the input base.

       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
              név
       míg egy tömbre a
              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.
       Unless specifically mentioned the scale of the result is the maximum
       scale of the expressions involved.

       - 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 ( kifejezés )
              Return the value of the expression from a function.  (See the
              section on functions.)  As an extension, the parenthesis are not
              required.

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

       Parameters are numbers or arrays (an extension).  In the function
       definition, zero or more parameters are defined by listing their names
       separated by commas.  All parameters are call by value parameters.
       Arrays are specified in the parameter definition by the notation
       "name[]".  In the function call, actual parameters are full expressions
       for number parameters.  The same notation is used for passing arrays as
       for defining array parameters.  The named array is passed by value to the
       function.  Since function definitions are dynamic, parameter numbers and
       types are checked when a function is called.  Any mismatch in number or
       types of parameters will cause a runtime error.  A runtime error will
       also occur for the call to an undefined function.

       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.

       Several extensions have been added to functions.  First, the format of
       the definition has been slightly relaxed.  The standard requires the
       opening brace be on the same line as the define keyword and all other
       parts must be on following lines.  This version of bc will allow any
       number of newlines before and after the opening brace of the function.
       For example, the following definitions are legal.
              define d (n) { return (2*n); }
              define d (n)
                { return (2*n); }


       Functions may be defined as void.  A void funtion returns no value and
       thus may not be used in any place that needs a value.  A void function
       does not produce any output when called by itself on an input line.  The
       key word void is placed between the key word define and the function
       name.  For example, consider the following session.
              define py (y) { print "--->", y, "<---", "\n"; }
              define void px (x) { print "--->", x, "<---", "\n"; }
              py(1)
              --->1<---
              0
              px(1)
              --->1<---

       Since py is not a void function, the call of py(1) prints the desired
       output and then prints a second line that is the value of the function.
       Since the value of a function that is not given an explicit return
       statement is zero, the zero is printed.  For px(1), no zero is printed
       because the function is a void function.

       Also, call by variable for arrays was added.  To declare a call by
       variable array, the declaration of the array parameter in the function
       definition looks like "*name[]".  The call to the function remains the
       same as call by value arrays.

   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)  The arctangent of x, arctangent returns radians.

       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);
              }


   READLINE AND LIBEDIT OPTIONS
       GNU bc can be compiled (via a configure option) to use the GNU readline
       input editor library or the BSD libedit library.  This allows the user to
       do editing of lines before sending them to bc.  It also allows for a
       history of previous lines typed.  When this option is selected, bc has
       one more special variable.  This special variable, history is the number
       of lines of history retained.  For readline, a value of -1 means that an
       unlimited number of history lines are retained.  Setting the value of
       history to a positive number restricts the number of history lines to the
       number given.  The value of 0 disables the history feature.  The default
       value is 100. For more information, read the user manuals for the GNU
       readline, history and BSD libedit libraries.  One can not enable both
       readline and libedit at the same time.

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

       return utasítás
              POSIX bc requires parentheses around the return expression.

       tömb paraméterek
              POSIX bc does not (currently) support array parameters in full.
              The POSIX grammar allows for arrays in function definitions, but
              does not provide a method to specify an array as an actual
              parameter.  (This is most likely an oversight in the grammar.)
              Traditional implementations of bc have only call by value array
              parameters.

       function format
              POSIX bc requires the opening brace on the same line as the define
              key word and the auto statement on the next line.

       =+, =-, =*, =/, =%, =^
              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
              The number of digits after the decimal point is limited to INT_MAX
              digits.  Also, the number of digits before the decimal point is
              limited to INT_MAX digits.

       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.

       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.

KÖRNYEZETI VÁLTOZÓK
       The following environment variables are processed by bc:

       POSIXLY_CORRECT
              This is the same as the -s option.

       BC_ENV_ARGS
              This is another mechanism to get arguments to bc.  The format is
              the same as the command line arguments.  These arguments are
              processed first, so any files listed in the environment arguments
              are processed before any command line argument files.  This allows
              the user to set up "standard" options and files to be processed at
              every invocation of bc.  The files in the environment variables
              would typically contain function definitions for functions the
              user wants defined every time bc is run.

       BC_LINE_LENGTH
              This should be an integer specifying the number of characters in
              an output line for numbers. This includes the backslash and
              newline characters for long numbers.  As an extension, the value
              of zero disables the multi-line feature.  Any other value of this
              variable that is less than 3 sets the line length to 70.

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

       Email bug reports to bug-bc@gnu.org.  Be sure to include the word “bc”
       somewhere in the “Subject:” field.

SZERZŐ
       Philip A. Nelson
       philnelson@acm.org

KÖSZÖNETNYILVÁNÍTÁS
       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.


FORDÍTÁS
       A kézikönyv magyar fordítását a Csehi András <acsehi@merlin.flexum.hu>
       készítette.

       Ez a fordítás ingyenes dokumentáció; lásd a GNU General Public License 3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩. Vagy újabb verzióját a
       szerzői jogi feltételekkel kapcsolatban.  Feltételezzük, hogy NEM
       FELELŐSSÉG.

       Ha hibát talál a kézikönyv oldal fordításában, küldje el a e-mail cím:
       TODO.  ⟨⟩.



GNU Project                      2006. június 11                           bc(1)