bc

bc(1)                        General Commands Manual                       bc(1)



NOMBRE
       bc - Un lenguaje de cálculo de precisión arbitraria

SINTAXIS
       bc [ -hlwsqv ] [opciones largas] [  fichero ... ]

DESCRIPCIÓN
       bc es un lenguaje que permite la ejecución interactiva de sentencias con
       precisión numérica arbitraria. La sintaxis es similar a la del lenguaje
       de programación C. Se puede disponer de una biblioteca matemática
       estándar a través de una opción en la línea de órdenes. En ese caso, la
       biblioteca matemática se determina antes de procesar ningún fichero.  bc
       comienza procesando en orden todos los ficheros dados en la línea de
       órdenes. Después de que todos los ficheros hayan sido procesados, bc lee
       la entrada estándar. Todo el código es ejecutado tal y como es leído. (Si
       un fichero contiene una orden que detiene el procesador bc nunca leerá la
       entrada estándar.)

       Esta versión de bc tiene varias ampliaciones adicionales a las
       tradicionales implementaciones de bc y el estándar POSIX.  Las opciones
       en la línea de órdenes pueden causar que estas extensiones impriman un
       aviso o sean rechazadas. Este documento describe el lenguaje aceptado por
       este procesador. Las ampliaciones serán identificadas como tales.

   OPCIONES
       -h, --help
              Print the usage and exit.

       -i, --interactive
              Force interactive mode.

       -l, --mathlib
              Selecciona la biblioteca matemática estándar.

       -w, --warn
              Da mensajes de advertencia ante las ampliaciones al bc de POSIX.

       -s, --standard
              Procesa exactamente como el lenguaje bc de POSIX.

       -q, --quiet
              No imprime el habitual mensaje de bienvenida del GNU bc.

       -v, --version
              Imprime el número de versión el copyright y sale.

   NÚMEROS
       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 tiene longitud 6 y escala 6.
               1935.000 tiene longitud 7 y escala 3.

   VARIABLES
       Los números son almacenados en dos tipos de variables, variables simples
       y matrices. Ambos tipos son designados por nombres. Estos nombres
       comienzan con una letra, seguida por cualquier número de letras, dígitos
       y caracteres de subrayado. Todas las letras deben ir en minúsculas.
       (Estos nombres alfanuméricos son una ampliación. En el bc de POSIX todos
       los nombres son una sola letra minúscula).  El tipo de variable queda
       claro según el contexto ya que a todas las variables de tipo matriz les
       sigue unos corchetes ([]).

       Hay cuatro variables especiales, scale, ibase, obase y last. scale define
       como son tratadas los dígitos tras la coma decimal en algunas
       operaciones. El valor por defecto de scale es 0.  ibase y obase definen
       la base numérica de conversión para la entrada y la salida. El valor por
       defecto para ambos es la base 10.  last (una ampliación) es la variable
       en la que se guardar el último número mostrado. Todo esto será tratado en
       detalle cuando proceda. Todas estas variables pueden tener un valor
       asignado así como ser usadas en expresiones.

   COMENTARIOS
       Los comentarios en bc comienzan con los caracteres /* y finalizan con los
       caracteres */. Los comentarios pueden empezar en cualquier lugar y
       aparecen como un solo espacio en la entrada. (Esto hace que delimiten
       otros elementos de entrada. Por ejemplo, un comentario no puede
       encontrarse en medio del nombre de una variable).  Los comentarios pueden
       incluir saltos de línea.

       Para poder usar macros (scripts) en bc, la posibilidad de incluir
       comentarios de una sola línea ha sido añadida como ampliación. Estos
       comienzan con el carácter # y continúan hasta el final de la línea. El
       final de línea no es parte del comentario y es procesado de forma normal.

   EXPRESIONES
       Los números son manipulados por las expresiones y las sentencias. Como el
       lenguaje fue diseñado para ser interactivo, las sentencias y expresiones
       son ejecutadas tan pronto como es posible. No hay programa principal
       ("main"). En su lugar, el código es ejecutado tal y como se encuentra.
       (Las funciones, tratadas en detalle más abajo, se definen cuando se
       encuentran).

       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.

       Las expresiones más complejas son similares a muchos otros lenguajes de
       alto nivel. Como sólo hay un tipo de número, no hay reglas para mezclar
       tipos. En cambio, hay reglas para la escala de las expresiones. Cada
       expresión tiene una escala. Esta es derivada de la escala de los números
       originales, la operación realizada y, en muchos casos, el valor de la
       variable scale. Los valores permitidos para scale son desde 0 hasta el
       máximo número representable por un entero en C.

       En las siguientes descripciones de expresiones permitidas, "expr" se usa
       para indicar un expresión completa y "var" una variable, simple o
       matricial. Una variable simple es, simplemente
              nombre
       y una matriz se designa así
              nombre[expr]
       Si no se especifica la escala del resultado, esta será la máxima escala
       de las expresiones implicadas.

       - expr El resultado es la expresión negada.

       ++ var La variable es incrementada en uno y el nuevo valor es el
              resultado de la expresión.

       -- var La variable es decrementada en uno y el nuevo valor es el
              resultado de la expresión.

       var ++ El resultado de la expresión es el valor de la variable y entonces
              la variable es incrementada en uno.

       var -- El resultado de la expresión es el valor de la variable y entonces
              la variable es decrementada en uno.

       expr + expr
              El resultado de la expresión es la suma de las dos expresiones.

       expr - expr
              El resultado de la expresión es la diferencia de las dos
              expresiones.

       expr * expr
              El resultado de la expresión es el producto de las dos
              expresiones.

       expr / expr
              El resultado de la expresión es el cociente de las dos
              expresiones.  La escala del resultado es el valor de la variable
              scale.

       expr % expr
              El resultado de la expresión es el "resto" y se calcula de la
              siguiente manera. Para calcular a%b, primero se calcula a/b en
              scale dígitos.  Este resultado es usado para calcular a-(a/b)*b a
              la escala que resulte mayor, scale+scale(b) ó scale(a). Si scale
              vale cero y ambas expresiones son enteros esta expresión calcula
              el resto entero.

       expr ^ expr
              El resultado de la expresión es el valor de la primera elevada a
              la segunda. La segunda expresión debe ser un entero. (Si la
              segunda expresión no es un entero, se genera un mensaje de
              advertencia y la expresión es truncada a un valor entero). La
              escala del resultado es scale si el exponente es negativo. Si el
              exponente es positivo la escala del resultado es el mínimo de
              estos valores: la escala de la base por el exponente o el máximo
              de scale y la escala de la base. (ej. scale(a^b) = min(scale(a)*b,
              max( scale, scale(a))).). Hay que tener en cuenta que el resultado
              de expr^0 siempre será 1.

       ( expr )
              Altera la precedencia estándar para forzar la evaluación de la
              expresión.

       var = expr
              Se asigna a la variable el valor de la expresión.

       var <op>= expr
              Es equivalente a "var = var <op> expr" con la excepción de que
              "var" sólo es evaluada una vez. Esto puede afectar si "var" es una
              matriz.

       Las expresiones relacionales son de un tipo especial que siempre se
       evalúan a 0 ó 1, 0 si la relación es falsa y 1 si la relación es
       verdadera. Pueden aparecer en cualquier expresión permitida. (El bc de
       POSIX sólo permite el uso de expresiones relacionales en las sentencias
       if, while y for y sólo una expresión relacional en cada una de ellas).
       Los operadores relacionales son:

       expr1 < expr2
              El resultado es 1 si expr1 es estrictamente menor que expr2.

       expr1 <= expr2
              El resultado es 1 si expr1 es menor o igual que expr2.

       expr1 > expr2
              El resultado es 1 si expr1 es estrictamente mayor que expr2.

       expr1 >= expr2
              El resultado es 1 si expr1 es mayor o igual que expr2.

       expr1 == expr2
              El resultado es 1 si expr1 es igual a expr2.

       expr1 != expr2
              El resultado es 1 si expr1 no es igual a expr2.

       Las operaciones booleanas también están permitidas. (El bc de POSIX NO
       tiene operaciones booleanas). El resultado de toda operación booleana es
       0 ó 1 (falso o verdadero) como en las expresiones relacionales. Los
       operadores booleanos son:

       !expr  El resultado es 1 si expr es 0.

       expr && expr
              El resultado es 1 si ambas expresiones son distintas de 0.

       expr || expr
              El resultado es 1 si alguna de las expresiones es distinta de 0.

       La precedencia de las expresiones es la siguiente (de menor a mayor):
              operador || , asociativo por la izquierda
              operador && , asociativo por la izquierda
              operador !  , no asociativo
              operadores relacionales, asociativos por la izquierda
              operador asignación, asociativo por la derecha
              operadores + y - , asociativos por la izquierda
              operadores *, / y % , asociativos por la izquierda
              operador ^ , asociativo por la derecha
              operador unario - , no asociativo
              operadores ++ y -- , no asociativo

       Esta precedencia fue elegida para que los programas acordes con el bc de
       POSIX funcionaran correctamente. Esto hará que el uso de operadores
       relacionales y lógicos tenga un comportamiento inusual cuando se usen con
       expresiones de asignación. Considere la expresión:
              a = 3 < 5

       La mayoría de los programadores de C asumirían que se asignaría el
       resultado de "3 < 5" (el valor 1) a la variable "a". Lo que ocurre en bc
       es que se asigna el valor 3 a la variable "a" y entonces se compara 3 con
       5. Es mejor usar paréntesis cuando se usan operadores relacionales y
       lógicos con operadores de asignación.

       Hay algunas expresiones especiales más en bc. Estas están relacionadas
       con las funciones definidas por el usuario y las funciones estándar.
       Tienen la forma "nombre(parámetros)". Las funciones definidas por el
       usuario son tratadas en la sección FUNCIONES.  Las funciones estándar
       son:

       length ( expresión )
              EL valor de la función length es el número de dígitos
              significativos en la expresión.

       read ( )
              La función read (una ampliación) leerá un número de la entrada
              estándar, independientemente del lugar dónde aparezca la función.
              Tenga cuidado pues esto puede causar problemas mezclando datos y
              programa en la entrada estándar. El mejor uso de esta función es
              ponerla en un programa previamente escrito que necesite la entrada
              del usuario, pero nunca permitiendo que el usuario introduzca
              código de programa. El valor de la función read es el número leído
              de la entrada estándar usando el valor de la variable ibase para
              la base de conversión.

       scale ( expresión )
              El valor de la función scale es el número de dígitos tras la coma
              decimal en la expresión.

       sqrt ( expresión )
              El valor de la función sqrt es la raíz cuadrada de la expresión.
              Si la expresión es negativa, se genera un error en tiempo de
              ejecución.

   SENTENCIAS
       Las sentencias (como en la mayoría de los lenguajes algebraicos)
       proporcionan la secuencia de las evaluación de las expresiones. En bc las
       sentencias son ejecutadas "tan pronto como es posible". La ejecución
       ocurre cuando se encuentra un cambio de línea y hay una o más sentencias
       completas. Debido a esta ejecución inmediata, los cambios de línea son
       muy importantes en bc. En realidad, tanto el punto y coma como el cambio
       de línea son usados como separadores de sentencias. Un cambio de línea en
       un lugar inapropiado provocará un error de sintaxis. Es posible ocultar
       el que un cambio de línea sea un separador de sentencias usando el
       carácter de contra-barra. bc toma la secuencia "\<nl>", donde <nl> es el
       cambio de línea, como un espacio en blanco en lugar de como un cambio de
       línea. Una lista de sentencias es una serie de sentencias separadas por
       punto y coma y cambios de línea. Lo siguiente es un lista de sentencias y
       la descripción de lo que realizan: (Las partes entre corchetes de las
       sentencias son opcionales).

       expresión
              Esta sentencia hace una de estas dos cosas. Si la expresión
              comienza con "<variable> <asignación> ...", es considerada como
              una sentencia de asignación. Si no es una sentencia de asignación,
              la expresión es evaluada e impresa en la salida. Tras el número
              viene un cambio de línea. Por ejemplo, "a=1" es una sentencia de
              asignación y "(a=1)" es una expresión que tiene una asignación
              incluida. Todos los números se imprimen en la base especificada
              por la variable obase. Los valores posibles para obase van desde 2
              hasta BC_BASE_MAX. (Ver sección LÍMITES). Para las bases
              comprendidas entre 2 y 16, se usa el método usual de impresión.
              Para las bases mayores de 16, bc usa un método de impresión en el
              que utiliza dígitos multi-carácter para imprimir cada dígito mayor
              que la base como un número en base 10. Los dígitos multi-carácter
              son separados por espacios. Cada dígito emplea tantos caracteres
              como sean necesarios para representar "obase-1" en base diez. Como
              los números son de precisión arbitraria, puede que algunos números
              no se puedan imprimir en una sola línea. Estos números grandes
              serán repartidos en varias lineas con el carácter "\" al final de
              cada línea. El número máximo de caracteres que se imprimen por
              línea es 70. Debido a la naturaleza interactiva de bc, la
              impresión de un número lleva consigo la asignación del valor
              impreso a la variable especial last. Esto permite al usuario
              utilizar el último valor impreso sin tener que volver a teclear la
              expresión que causó su impresión. Está permitido asignar valores a
              last y esto sobreescribirá el último valor impreso con el valor
              asignado. El nuevo valor permanecerá hasta que se imprima el
              siguiente número o se le asigne otro valor a last. (Algunas
              instalaciones pueden permitir usar un punto (.) que no sea parte
              de un número como una notación más corta para last).

       cadena Se imprime la cadena en la salida. Las cadenas comienzan con una
              comilla doble y contienen todos los caracteres hasta la siguiente
              comilla doble.  Todos los caracteres son tomados literalmente,
              incluidos los cambios de línea. Tras la cadena no se cambia de
              línea.

       print lista
              La sentencia print (una ampliación) proporciona otro método de
              impresión.  La "lista" es una lista de cadenas y expresiones
              separadas por comas. La lista se imprime en el orden en el que
              está. Tras la lista no se cambia de línea. Las expresiones son
              evaluadas y sus valores impresos y asignados a la variable last.
              Las cadenas se imprimen en la salida y pueden contener caracteres
              especiales. Los caracteres especiales comienzan con el carácter de
              contra-barra (\). bc reconoce los caracteres especiales "a"
              (alerta o campana), "b" (borrar carácter (backspace)), "f" (salto
              de línea), "n" (nueva linea), "r" (retorno de carro), "q" (comilla
              doble), "t" (tabulador), y "\" (contra-barra). Cualquier otro
              carácter que siga a una contra-barra será ignorado.

       { lista_de_sentencias }
              Esta es la sentencia compuesta. Permite ejecutar varias sentencias
              agrupadas.

       if ( expresión ) sentencia1 [else sentencia2]
              Esta sentencia evalúa la expresión y ejecuta la sentencia1 o la
              sentencia2 dependiendo del valor de la expresión. Si el valor es
              distinto de 0, se ejecuta la sentencia1. Si se da la sentencia2 y
              el valor de la expresión es 0, entonces se ejecuta la sentencia2.
              (La cláusula else es una ampliación).

       while ( expresión ) sentencia
              Se ejecuta la sentencia mientras la expresión sea distinta de 0.
              Se evalúa la expresión antes de cada ejecución de la sentencia. El
              bucle termina al tomar la expresión el valor 0 o ante una
              sentencia break.

       for ( [expresión1] ; [expresión2] ; [expresión3] ) sentencia
              La sentencia for controla la ejecución repetitiva de la sentencia.
              La expresión1 es evaluada antes del bucle. La expresión2 es
              evaluada antes de cada ejecución de la sentencia. Si es 0, el
              bucle termina. Después de cada ejecución de la sentencia, se
              evalúa la expresión3 antes de reevaluar la expresión2. Si la
              expresión1 o la expresión3 no se dan, no se evalúa nada en su
              lugar. Si la expresión2 no se da, es lo mismo que sustituirla por
              el valor 1. (El que las expresiones sean opcionales es una
              ampliación. El bc de POSIX requiere las tres expresiones).  Este
              es el código equivalente para la sentencia for:
              expresión1;
              while (expresión2) {
                 sentencia;
                 expresión3;
              }

       break  Esta sentencia fuerza la salida de la sentencia while o for más
              reciente.

       continue
              La sentencia continue (una ampliación) provoca que la sentencia
              for más reciente comience una nueva iteración.

       halt   La sentencia halt (una ampliación) provoca que el procesador bc
              termine sólo cuando es ejecutada. Por ejemplo, "if (0 == 1) halt"
              no hará que bc termine porque no llega a ejecutarse la sentencia
              halt.

       return Devuelve el valor 0 desde una función. (Ver sección sobre
              funciones).

       return ( expresión )
              Return the value of the expression from a function.  (See the
              section on functions.)  As an extension, the parenthesis are not
              required.

   PSEUDO SENTENCIAS
       Estas sentencias no son sentencias en el sentido tradicional. No son
       sentencias que se ejecuten. Su función se realiza en "tiempo de
       compilación".

       limits Imprime los límites locales forzados por la versión local de bc.
              Esto es una ampliación.

       quit   Cuando la sentencia quit se lee, el procesador bc termina,
              cualquiera que sea el lugar donde se encuentre la sentencia quit.
              Por ejemplo, "if (0 == 1) quit" hará que bc termine.

       warranty
              Imprime un aviso largo sobre la garantía. Esto es una ampliación.

   FUNCIONES
       Las funciones proporcionan un método para definir un cálculo que será
       ejecutado más tarde. Las funciones en bc siempre calculan un valor que
       devuelven a quien la ha llamado. La definición de las funciones son
       "dinámicas" en el sentido de que una función está indefinida hasta que se
       encuentra una definición en la entrada. Se usa esa definición hasta que
       se encuentra otra definición de función con el mismo nombre. La nueva
       definición reemplaza a la anterior.  Una función se define como sigue:
              define nombre ( parámetros ) { nueva_línea
                  auto_lista   lista_de_sentencias }
       La ejecución de una función es simplemente una expresión de la forma
       "nombre(parámetros)".

       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.

       La auto_lista es una lista opcional de variables para uso "local". La
       sintaxis de esta lista (si se da) es "auto nombre, ... ;". (El punto y
       coma es opcional). Cada nombre es el nombre de una variable auto. Las
       matrices se pueden especificar con la misma notación que se usa en los
       parámetros. Los valores de estas variables se guardan en una pila al
       comienzo de la función. Entonces son inicializadas a cero y se usan en el
       transcurso de la función. Al finalizar la función, se recuperan de la
       pila los valores originales (en el momento de la llamada a la función).
       Los parámetros son realmente variables auto que se inicializan al valor
       proporcionado en la llamada a la función. Las variables auto son
       diferentes de las tradicionales variables locales en que si la función A
       llama a la función B, B puede acceder a las variables auto de A
       simplemente usando sus nombres, a no ser que la función B tenga variables
       auto del mismo nombre.  Como tanto las variables auto como los parámetros
       son guardados en una pila, bc admite funciones recursivas.

       El cuerpo de la función es una lista de sentencias de bc. De nuevo las
       sentencias van separadas por punto y coma o cambio de línea. La sentencia
       return hace que la función termine y devuelva un valor a la expresión que
       ha llamado a la función.. La primera forma, "return", devuelve el valor
       0. La segunda forma "return ( expresión )", calcula el valor de la
       expresión y lo devuelve a la expresión que ha llamado la función. Hay un
       "return (0)" implícito al final de cada función. Esto permite a una
       función terminar y devolver 0, sin necesidad de una sentencia return
       explícita.

       Las funciones también cambian el uso de la variable ibase. Todas las
       constantes en el cuerpo de la función son convertidas usando el valor de
       ibase en el momento de llamar a la función. Los cambios de ibase serán
       ignorados durante la ejecución de la función excepto para la función
       estándar read, que siempre usará el valor actual de ibase para la
       conversión de los números.

       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.

   BIBLIOTECA MATEMÁTICA
       Si se invoca bc con la opción -l, una biblioteca matemática es
       pre-cargada y la escala por defecto se pone a 20. Las funciones
       matemáticas calcularán sus resultados a la escala definida en el momento
       de su llamada.  La biblioteca matemática define las siguientes funciones:

       s (x)  El seno de x, con x en radianes.

       c (x)  El coseno de x, con x en radianes.

       a (x)  El arcotangente de x, con el resultado en radianes.

       l (x)  El logaritmo natural de x.

       e (x)  La función exponencial resultante de elevar e al valor de x.

       j (n,x)
              La función Bessel de orden entero n de x.

   EJEMPLOS
       En /bin/sh, lo siguiente asignará el valor de "pi" a la variable shell
       pi.
               pi=$(echo "scale=10; 4*a(1)" | bc -l)

       Lo siguiente es la definición de la función exponencial usada en la
       biblioteca matemática. Esta función está escrita en bc de POSIX.
              scale = 20

              /* Usa el hecho de que  e^x = (e^(x/2))^2
                 Si x es lo suficientemente pequeño, se usa la serie:
                   e^x = 1 + x + x^2/2! + x^3/3! + ...
              */

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

                /* Comprueba el signo de x. */
                if (x<0) {
                  m = 1
                  x = -x
                }

                /* Precondición x. */
                z = scale;
                scale = 4 + z + .44*x;
                while (x > 1) {
                  f += 1;
                  x /= 2;
                }

                /* Inicialización de las variables. */
                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
                }
              }


       El siguiente código usa las características ampliadas de bc para
       implementar un simple programa para calcular balances. Es mejor guardar
       este programa en un fichero para poderlo usar varias veces sin tener que
       teclearlo cada vez.
              scale=2
              print "\n¡Programa de balances!\n"
              print " Recuerde, los depósitos son transacciones negativas.\n"
              print " Para salir introducir una transacción 0 .\n\n"

              print "¿ Balance inicial ? "; bal = read()
              bal /= 1
              print "\n"
              while (1) {
                "Balance actual = "; bal
                "¿ transacción ? "; trans = read()
                if (trans == 0) break;
                bal -= trans
                bal /= 1
              }
              quit


       Lo siguiente es la definición de la función factorial recursiva.
              define f (x) {
                if (x <= 1) return (1);
                return (f(x-1) * x);
              }


   OPCIÓNES READLINE Y LIBEDIT
       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.

   DIFERENCIAS
       Esta versión de bc fue implementada a partir del borrador POSIX
       P1003.2/D11 y contiene varias diferencias y ampliaciones respecto a este
       borrador y las implementaciones tradicionales. No está implementada
       usando dc(1) como suele ser tradicional. Esta versión es un simple
       proceso que analiza el programa y ejecuta una traducción de este a un
       código de bytes (byte code). Hay una opción "indocumentada" (-c) que hace
       que el programa imprima en la salida estándar este código en lugar de
       ejecutarlo. Fue usada principalmente para depurar el analizador y
       preparar la biblioteca matemática.

       Una mayor fuente de diferencias son las ampliaciones, tanto cuando son
       añadidas para dar más funcionalidad como cuando añaden nuevas
       características.  Esta es la lista de las diferencias y ampliaciones.

       LANG environment
              Esta versión no se ajusta al estándar POSIX sobre el proceso de la
              variable de entorno LANG y todas las variables de entorno que
              comienzan por LC_.

       nombres
              El bc tradicional y el de POSIX usan nombres de una sola letra
              para funciones, variables y matrices. Han sido ampliados para ser
              nombres multi-carácter que comienzan por una letra y pueden
              contener letras, dígitos y caracteres de subrayado.

       Cadenas
              No se permite que las cadenas contengan caracteres nulos (NUL). El
              estándar POSIX dice que todos los caracteres se deben incluir en
              las cadenas.

       last   En el bc de POSIX no existe la variable last. Algunas
              implementaciones de bc usan el punto (.) de manera similar.

       comparaciones
              El bc de POSIX permite las comparaciones sólo en la sentencia if,
              la sentencia while y la segunda expresión de la sentencia for.
              Además, sólo se permite una operación relacional en cada una de
              estas sentencias.

       sentencia if, cláusula else
              El bc de POSIX no tiene la cláusula else.

       sentencia for
              El bc de POSIX obliga a que estén todas las expresiones de la
              sentencia for.

       &&, ||, !
              El bc de POSIX no tiene los operadores lógicos.

       función read
              El bc de POSIX no tiene la función read.

       sentencia print
              El bc de POSIX no tiene la sentencia print.

       sentencia continue
              El bc de POSIX no tiene la sentencia continue.

       return statement
              POSIX bc requires parentheses around the return expression.

       parámetros de tipo matriz
              El bc de POSIX (actualmente) no admite totalmente las matrices
              como parámetros. La gramática POSIX permite incluir matrices en la
              definición de las funciones, pero no proporciona un método para
              especificar una matriz como parámetro en la llamada. (Se puede
              considerar esto como un error de la gramática). En las
              implementaciones tradicionales de bc sólo se pueden usar las
              matrices como parámetros por valor.

       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.

       =+, =-, =*, =/, =%, =^
              El bc de POSIX no define estos operadores de asignación "al viejo
              estilo". Esta versión puede que las permita. Utilice la sentencia
              limits para ver si la versión instalada las admite. Si se admiten,
              la sentencia "a =- 1" decrementará a en 1 en lugar de asignar a a
              el valor -1.

       espacios en los números
              Otras implementaciones de bc permiten espacios en los números. Por
              ejemplo, "x=1 3" asignaría a la variable x el valor 13. La misma
              sentencia provocará un error de sintaxis en esta versión de bc.

       errores y ejecución
              Esta implementación varia de otras implementaciones en el tema de
              qué código se ejecutará cuando en el programa se encuentren
              errores sintácticos o de otro tipo. Si en la definición de una
              función se encuentra un error sintáctico, se intenta recuperar el
              error encontrando el principio de la sentencia y continuando con
              el análisis de la función. Una vez que el error se encuentra en la
              función, la función no podrá usarse y queda indefinida.  Los
              errores sintácticos en la ejecución de código interactivo
              invalidarán el actual bloque en ejecución. El bloque en ejecución
              acaba con un salto de línea tras una secuencia completa de
              sentencias. Por ejemplo,
              a = 1
              b = 2
       tiene dos bloques y
              { a = 1
                b = 2 }
       tiene un bloque. Cualquier error en tiempo de ejecución terminará con el
       actual bloque en ejecución. Un mensaje de aviso (warning) en tiempo de
       ejecución no terminará con el actual bloque en ejecución.

       Interrupciones
              Durante una sesión interactiva, la señal SIGINT (habitualmente
              generada por el carácter control-C desde el terminal) provocará la
              interrupción del actual bloque en ejecución. Se mostrará un error
              en tiempo de ejecución indicando que función fue interrumpida.
              Después de limpiar todas las estructuras, se muestra un mensaje al
              usuario para indicarle que bc esta listo para aceptar más entrada.
              Todas las funciones definidas previamente permanecen definidas y
              las variables que no sean del tipo auto conservan el valor que
              tenían en el momento de la interrupción. Durante una sesión
              no-interactiva, la señal SIGINT interrumpirá la ejecución de bc
              por completo.

   LÍMITES
       Los límites actualmente en vigor para este procesador bc son los
       siguientes. Algunos de ellos pueden haber cambiado en el proceso de
       instalación. Utilice la sentencia limits para ver sus valores actuales.

       BC_BASE_MAX
              La máxima base de salida se inicializa actualmente a 999. La base
              máxima de entrada es 16.

       BC_DIM_MAX
              Tal y como se distribuye, este límite se inicializa
              arbitrariamente a 65535. En su instalación puede ser diferente.

       BC_SCALE_MAX
              El número de dígitos tras la coma decimal se limita a INT_MAX
              dígitos. De igual manera, el número de dígitos delante de la coma
              decimal se limita a INT_MAX dígitos.

       BC_STRING_MAX
              El límite para el número de caracteres de una cadena es INT_MAX
              caracteres.

       exponente
              El valor del exponente en la operación potencia (^) esta limitado
              a LONG_MAX.

       nombres de variables
              El límite actual para el número de nombres únicos de variables
              simples, matrices y funciones es de 32767 para cada tipo.

VARIABLES DE ENTORNO
       Las siguientes variables de entorno son procesadas por bc:

       POSIXLY_CORRECT
              Esto es lo mismo que la opción -s.

       BC_ENV_ARGS
              Este es otra forma de pasar argumentos a bc. El formato es el
              mismo que los argumentos de la línea de órdenes. Estos argumentos
              se procesan primero, por lo que cualquier fichero presente en los
              argumentos de entorno es procesado antes que cualquiera que
              aparezca en la línea de órdenes. Esto permite al usuario
              establecer opciones "estándar" y los ficheros que serán procesados
              en todas las invocaciones de bc. Los ficheros listados en las
              variables de entorno generalmente contendrán definiciones de
              funciones que el usuario quiera tener definidas cada vez que
              ejecute bc.

       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.

DIAGNÓSTICOS
       Si algún fichero dado en la línea de órdenes no se puede abrir, bc
       informará que el fichero no está disponible y terminará. Asimismo, hay
       errores en tiempo de compilación y de ejecución que deberían ser
       auto-explicativos.

ERRORES
       La recuperación de errores no es muy buena todavía.

       Notifique cualquier error a bug-bc@gnu.org.  Compruebe que incluye la
       palabra “bc” dentro del campo “Asunto:” (“Subject:”).

AUTOR
       Philip A. Nelson
       philnelson@acm.org

RECONOCIMIENTOS
       El autor quisiera agradecer a Steve Sommars (Steve.Sommars@att.com) su
       gran ayuda probando la implementación. Me dio muchas sugerencias
       estupendas. Éste es un producto mejor gracias a su implicación.


TRADUCCIÓN
       La traducción al español de esta página del manual fue creada por J.
       Ramón Palacios <jotarp@iname.com>

       Esta traducción es documentación libre; lea la GNU General Public License
       Version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o posterior con
       respecto a las condiciones de copyright.  No existe NINGUNA
       RESPONSABILIDAD.

       Si encuentra algún error en la traducción de esta página del manual,
       envíe un correo electrónico a debian-l10n-spanish@lists.debian.org>.  ⟨⟩.



Proyecto GNU                      11 Junio 2006                            bc(1)