.\" -*- coding: UTF-8 -*-
.\"
.\" bc.1 - the *roff document processor source for the bc manual
.\"
.\" This file is part of GNU bc.
.\" Copyright (C) 1991-1994, 1997, 2000, 2003, 2006, 2017, 2024, 2025
.\" Free Software Foundation, Inc.
.\"
.\" This program is free software; you can redistribute it and/or modify
.\" it under the terms of the GNU General Public License as published by
.\" the Free Software Foundation; either version 2 of the License , or
.\" (at your option) any later version.
.\"
.\" This program is distributed in the hope that it will be useful,
.\" but WITHOUT ANY WARRANTY; without even the implied warranty of
.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
.\" GNU General Public License for more details.
.\"
.\" You should have received a copy of the GNU General Public License
.\" along with this program; see the file COPYING.  If not, see
.\" <https://www.gnu.org/licenses/>.
.\"
.\" You may contact the author by:
.\" e-mail: philnelson@acm.org
.\" us-mail: Philip A. Nelson
.\" Computer Science Department, 9062
.\" Western Washington University
.\" Bellingham, WA 98226-9062
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH bc 1 "5 Enero 2025" "Proyecto GNU" 
.SH NOMBRE
bc \- Un lenguaje de cálculo de precisión arbitraria
.SH SINTAXIS
\fBbc\fP [ \fB\-hlwsqv\fP ] [opciones largas] [ \fI fichero ...\fP ]
.SH DESCRIPCIÓN
\fBbc\fP 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.  \fBbc\fP comienza
procesando en orden todos los ficheros dados en la línea de órdenes. Después
de que todos los ficheros hayan sido procesados, \fBbc\fP 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 \fBbc\fP nunca leerá la entrada
estándar.)
.PP
Esta versión de \fBbc\fP tiene varias ampliaciones adicionales a las
tradicionales implementaciones de \fBbc\fP 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.
.SS OPCIONES
.IP "\-h, \-\-help"
Print the usage and exit.
.IP "\-i, \-\-interactive"
Force interactive mode.
.IP "\-l, \-\-mathlib"
Selecciona la biblioteca matemática estándar.
.IP "\-w, \-\-warn"
Da mensajes de advertencia ante las ampliaciones al \fBbc\fP de POSIX.
.IP "\-s, \-\-standard"
Procesa exactamente como el lenguaje \fBbc\fP de POSIX.
.IP "\-q, \-\-quiet"
No imprime el habitual mensaje de bienvenida del GNU bc.
.IP "\-v, \-\-version"
Imprime el número de versión el copyright y sale.
.SS NÚMEROS
The most basic element in \fBbc\fP 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
\fBbc\fP to represent a number and the scale is the total number of decimal
digits after the decimal point.  For example:
.nf
.RS
 .000001 tiene longitud 6 y escala 6.
 1935.000 tiene longitud 7 y escala 3.
.RE
.fi
.SS 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 \fBbc\fP 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 ([]).
.PP
Hay cuatro variables especiales, \fBscale\fP, \fBibase\fP, \fBobase\fP y
\fBlast\fP. \fBscale\fP define como son tratadas los dígitos tras la coma decimal
en algunas operaciones. El valor por defecto de \fBscale\fP es 0.  \fBibase\fP y
\fBobase\fP definen la base numérica de conversión para la entrada y la
salida. El valor por defecto para ambos es la base 10.  \fBlast\fP (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.
.SS COMENTARIOS
Los comentarios en \fBbc\fP comienzan con los caracteres \fB/*\fP y finalizan con
los caracteres \fB*/\fP. 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.
.PP
Para poder usar macros (scripts) en \fBbc\fP, la posibilidad de incluir
comentarios de una sola línea ha sido añadida como ampliación. Estos
comienzan con el carácter \fB#\fP 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.
.SS 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).
.PP
A simple expression is just a constant. \fBbc\fP converts constants into
internal decimal numbers using the current input base, specified by the
variable \fBibase\fP. (There is an exception in functions.)  The valid values
for \fBibase\fP are 2 through 36. (Bases greater than 16 are an extension.)
Assigning a value outside this range to \fBibase\fP 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
\fBibase\fP. (i.e.\& A = 10.)  For multi\-digit numbers, \fBbc\fP changes all input
digits greater or equal to ibase to the value of \fBibase\fP\-1.  This makes the
number \fBZZZ\fP always be the largest 3 digit number of the input base.
.PP
Las expresiones más complejas son similares a muchos otros lenguajes de alto
nivel. Como solo 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
\fBscale\fP. Los valores permitidos para \fBscale\fP son desde 0 hasta el máximo
número representable por un entero en C.
.PP
In the following descriptions of valid expressions, "expr" refers to a
complete expression and "var" refers to a simple or an array variable.  A
simple variable is just a
.RS
\fInombre\fP
.RE
y una matriz se designa así
.RS
\fInombre\fP[\fIexpr\fP]
.RE
Si no se especifica la escala del resultado, esta será la máxima escala de
las expresiones implicadas.
.IP "\- expr"
El resultado es la expresión negada.
.IP "++ var"
La variable es incrementada en uno y el nuevo valor es el resultado de la
expresión.
.IP "\-\- var"
La variable es decrementada en uno y el nuevo valor es el resultado de la
expresión.
.IP "var ++"
The result of the expression is the value of the variable and then the
variable is incremented by one.
.IP "var \-\-"
El resultado de la expresión es el valor de la variable y entonces la
variable es decrementada en uno.
.IP "expr + expr"
El resultado de la expresión es la suma de las dos expresiones.
.IP "expr \- expr"
El resultado de la expresión es la diferencia de las dos expresiones.
.IP "expr * expr"
El resultado de la expresión es el producto de las dos expresiones.
.IP "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 \fBscale\fP.
.IP "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 \fBscale\fP dígitos.  Este
resultado es usado para calcular a\-(a/b)*b a la escala que resulte mayor,
\fBscale\fP+scale(b) ó scale(a). Si \fBscale\fP vale cero y ambas expresiones son
enteros esta expresión calcula el resto entero.
.IP "expr ^ expr"
The result of the expression is the value of the first raised to the
second. The second expression must be an integer.  (If the second expression
is not an integer, a warning is generated and the expression is truncated to
get an integer value.)  The scale of the result is \fBscale\fP if the exponent
is negative.  If the exponent is positive the scale of the result is the
minimum of the scale of the first expression times the value of the exponent
and the maximum of \fBscale\fP and the scale of the first expression.  (e.g.\&
scale(a^b)  = min(scale(a)*b, max( \fBscale,\fP scale(a))).)  It should be
noted that expr^0 will always return the value of 1.
.IP "( expr )"
Altera la precedencia estándar para forzar la evaluación de la expresión.
.IP "var = expr"
Se asigna a la variable el valor de la expresión.
.IP "var <op>= expr"
Es equivalente a "var = var <op> expr" con la excepción de que "var"
solo es evaluada una vez. Esto puede afectar si "var" es una matriz.
.PP
Relational expressions are a special kind of expression that always evaluate
to 0 or 1, 0 if the relation is false and 1 if the relation is true.  These
may appear in any valid expression.  (POSIX bc requires that relational
expressions are used only in if, while, and for statements and that only one
relational test may be done in them.)  The relational operators are
.IP "expr1 < expr2"
El resultado es 1 si expr1 es estrictamente menor que expr2.
.IP "expr1 <= expr2"
El resultado es 1 si expr1 es menor o igual que expr2.
.IP "expr1 > expr2"
El resultado es 1 si expr1 es estrictamente mayor que expr2.
.IP "expr1 >= expr2"
El resultado es 1 si expr1 es mayor o igual que expr2.
.IP "expr1 == expr2"
El resultado es 1 si expr1 es igual a expr2.
.IP "expr1 != expr2"
El resultado es 1 si expr1 no es igual a expr2.
.PP
Boolean operations are also valid.  (POSIX \fBbc\fP does NOT have boolean
operations). The result of all boolean operations are 0 and 1 (for false and
true) as in relational expressions.  The boolean operators are:
.IP !expr
El resultado es 1 si expr es 0.
.IP "expr && expr"
El resultado es 1 si ambas expresiones son distintas de 0.
.IP "expr || expr"
El resultado es 1 si alguna de las expresiones es distinta de 0.
.PP
La precedencia de las expresiones es la siguiente (de menor a mayor):
.nf
.RS
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
.RE
.fi
.PP
Esta precedencia fue elegida para que los programas acordes con el \fBbc\fP 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:
.RS
a = 3 < 5
.RE
.PP
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 \fBbc\fP 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.
.PP
Hay algunas expresiones especiales más en \fBbc\fP. Estas están relacionadas
con las funciones definidas por el usuario y las funciones estándar. Tienen
la forma "\fInombre\fP\fB(\fP\fIparámetros\fP\fB)\fP". Las funciones definidas por el
usuario son tratadas en la sección FUNCIONES.  Las funciones estándar son:
.IP "length ( expresión )"
EL valor de la función length es el número de dígitos significativos en la
expresión.
.IP "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 \fBibase\fP
para la base de conversión.
.IP "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.
.IP "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.
.SS SENTENCIAS
Statements (as in most algebraic languages) provide the sequencing of
expression evaluation.  In \fBbc\fP statements are executed "as soon as
possible".  Execution happens when a newline in encountered and there is one
or more complete statements.  Due to this immediate execution, newlines are
very important in \fBbc\fP. In fact, both a semicolon and a newline are used as
statement separators.  An improperly placed newline will cause a syntax
error.  Because newlines are statement separators, it is possible to hide a
newline by using the backslash character.  The sequence "\e<nl>",
where <nl> is the newline appears to \fBbc\fP as whitespace instead of
a newline.  A statement list is a series of statements separated by
semicolons and newlines.  The following is a list of \fBbc\fP statements and
what they do: (Things enclosed in brackets ([]) are optional parts of the
statement.)
.IP expresión
This statement does one of two things.  If the expression starts with
"<variable> <assignment> ...", it is considered to be an
assignment statement.  If the expression is not an assignment statement, the
expression is evaluated and printed to the output.  After the number is
printed, a newline is printed.  For example, "a=1" is an assignment
statement and "(a=1)" is an expression that has an embedded assignment.  All
numbers that are printed are printed in the base specified by the variable
\fBobase\fP. The valid values for \fB obase\fP are 2 through BC_BASE_MAX.  (See
the section LIMITS.)  For bases 2 through 16, the usual method of writing
numbers is used.  For bases greater than 16, \fBbc\fP uses a multi\-character
digit method of printing the numbers where each higher base digit is printed
as a base 10 number.  The multi\-character digits are separated by spaces.
Each digit contains the number of characters required to represent the base
ten value of "obase\-1".  Since numbers are of arbitrary precision, some
numbers may not be printable on a single output line.  These long numbers
will be split across lines using the "\e" as the last character on a line.
The maximum number of characters printed per line is 70.  Due to the
interactive nature of \fBbc\fP, printing a number causes the side effect of
assigning the printed value to the special variable \fBlast\fP. This allows the
user to recover the last value printed without having to retype the
expression that printed the number.  Assigning to \fBlast\fP is valid and will
overwrite the last printed value with the assigned value.  The newly
assigned value will remain until the next number is printed or another value
is assigned to \fBlast\fP.  (Some installations may allow the use of a single
period (.) which is not part of a number as a short hand notation for
\fBlast\fP.)
.IP 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.
.IP "\fBprint\fP 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 \fBlast\fP. Las cadenas se imprimen en la salida y pueden contener
caracteres especiales. Los caracteres especiales comienzan con el carácter
de contra\-barra (\e). \fBbc\fP reconoce los caracteres especiales "a" (alerta o
campana), "b" (borrar carácter (backspace)), "f" (salto de línea), "n"
(nueva línea), "r" (retorno de carro), "q" (comilla doble), "t" (tabulador),
y "\e" (contra\-barra). Cualquier otro carácter que siga a una contra\-barra
será ignorado.
.IP "{ lista_de_sentencias }"
Esta es la sentencia compuesta. Permite ejecutar varias sentencias
agrupadas.
.IP "\fBif\fP ( expresión ) sentencia1 [\fBelse\fP 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).
.IP "\fBwhile\fP ( 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.
.IP "\fBfor\fP ( [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 \fBbc\fP
de POSIX requiere las tres expresiones).  Este es el código equivalente para
la sentencia for:
.nf
.RS
expresión1;
while (expresión2) {
   sentencia;
   expresión3;
}
.RE
.fi
.IP \fBbreak\fP
Esta sentencia fuerza la salida de la sentencia while o for más reciente.
.IP \fBcontinue\fP
La sentencia continue (una ampliación) provoca que la sentencia for más
reciente comience una nueva iteración.
.IP \fBhalt\fP
La sentencia halt (una ampliación) provoca que el procesador \fBbc\fP termine
solo cuando es ejecutada. Por ejemplo, "if (0 == 1) halt" no hará que \fBbc\fP
termine porque no llega a ejecutarse la sentencia halt.
.IP \fBreturn\fP
Devuelve el valor 0 desde una función. (Ver sección sobre funciones).
.IP "\fBreturn\fP ( expresión )"
Return the value of the expression from a function.  (See the section on
functions.)  As an extension, the parenthesis are not required.
.SS "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".
.IP \fBlimits\fP
Imprime los límites locales forzados por la versión local de \fBbc\fP. Esto es
una ampliación.
.IP \fBquit\fP
Cuando la sentencia quit se lee, el procesador \fBbc\fP termina, cualquiera que
sea el lugar donde se encuentre la sentencia quit. Por ejemplo, "if (0 == 1)
quit" hará que \fBbc\fP termine.
.IP \fBwarranty\fP
Imprime un aviso largo sobre la garantía. Esto es una ampliación.
.SS FUNCIONES
Las funciones proporcionan un método para definir un cálculo que será
ejecutado más tarde. Las funciones en \fBbc\fP 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:
.nf
.RS
\fBdefine \fP\fInombre \fP\fB( \fP\fIparámetros \fP\fB) { \fP\fInueva_línea     auto_lista   lista_de_sentencias \fP\fB}\fP
.RE
.fi
La ejecución de una función es simplemente una expresión de la forma
"\fInombre\fP\fB(\fP\fIparámetros\fP\fB)\fP".
.PP
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 "\fIname\fP\fB[]\fP".
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.
.PP
La \fIauto_lista\fP es una lista opcional de variables para uso "local". La
sintaxis de esta lista (si se da) es "\fBauto \fP\fInombre\fP, ... ;". (El punto y
coma es opcional). Cada \fInombre\fP 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,
\fBbc\fP admite funciones recursivas.
.PP
El cuerpo de la función es una lista de sentencias de \fBbc\fP. 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, "\fBreturn\fP", devuelve el valor
0. La segunda forma "\fBreturn ( \fP\fIexpresión \fP\fB)\fP", calcula el valor de la
expresión y lo devuelve a la expresión que ha llamado la función. Hay un
"\fBreturn (0)\fP" 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.
.PP
Las funciones también cambian el uso de la variable \fBibase\fP. Todas las
constantes en el cuerpo de la función son convertidas usando el valor de
\fBibase\fP en el momento de llamar a la función. Los cambios de \fBibase\fP serán
ignorados durante la ejecución de la función excepto para la función
estándar \fBread\fP, que siempre usará el valor actual de \fBibase\fP para la
conversión de los números.
.PP
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 \fBdefine\fP keyword and all other parts must
be on following lines.  This version of \fBbc\fP will allow any number of
newlines before and after the opening brace of the function.  For example,
the following definitions are valid.
.nf
.RS
\f(CR
define d (n) { return (2*n); }
define d (n)
  { return (2*n); }\fR
.\fR
.RE
.fi
.PP
Functions may be defined as \fBvoid\fP.  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
\fBvoid\fP is placed between the key word \fBdefine\fP and the function name.  For
example, consider the following session.
.nf
.RS
\f(CR
define py (y) { print "\-\-\->", y, "<\-\-\-", "\en"; }
define void px (x) { print "\-\-\->", x, "<\-\-\-", "\en"; }
py(1)
\-\-\->1<\-\-\-
0
px(1)
\-\-\->1<\-\-\-\fR
.\fR
.RE
.fi
\f(CRSince \fBpy\fP is not a void function, the call of \fBpy(1)\fP 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 \fBpx(1)\fP, no zero is
printed because the function is a void function.
.PP
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 "\fI*name\fP\fB[]\fP".  The call to the function remains the same as
call by value arrays.
.SS "BIBLIOTECA MATEMÁTICA"
Si se invoca \fBbc\fP con la opción \fB\-l\fP, 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:
.IP "s (\fIx\fP)"
El seno de x, con x en radianes.
.IP "c (\fIx\fP)"
El coseno de x, con x en radianes.
.IP "a (\fIx\fP)"
El arcotangente de x, con el resultado en radianes.
.IP "l (\fIx\fP)"
El logaritmo natural de x.
.IP "e (\fIx\fP)"
La función exponencial resultante de elevar e al valor de x.
.IP "j (\fIn,x\fP)"
La función Bessel de orden entero n de x.
.SS EJEMPLOS
En /bin/sh, lo siguiente asignará el valor de "pi" a la variable shell
\fBpi\fP.
.RS
\f(CR pi=$(echo "scale=10; 4*a(1)" | bc \-l)\fR
.\fR
.RE
.PP
Lo siguiente es la definición de la función exponencial usada en la
biblioteca matemática. Esta función está escrita en \fBbc\fP de POSIX.
.nf
.RS
\f(CR
scale = 20\fR

\f(CR/* Uses the fact that e^x = (e^(x/2))^2
   When x is small enough, we use the series:
     e^x = 1 + x + x^2/2! + x^3/3! + ...
*/\fR

\f(CRdefine e(x) {
  auto  a, d, e, f, i, m, v, z\fR

\f(CR  /* Check the sign of x. */
  if (x<0) {
    m = 1
    x = \-x
  }\fR

\f(CR  /* Precondition x. */
  z = scale;
  scale = 4 + z + .44*x;
  while (x > 1) {
    f += 1;
    x /= 2;
  }\fR

\f(CR  /* Initialize the variables. */
  v = 1+x
  a = x
  d = 1\fR

\f(CR  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
  }
}\fR
.\fR
.RE
.fi
.PP
El siguiente código usa las características ampliadas de \fBbc\fP 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.
.nf
.RS
\f(CR
scale=2
print "\enCheck book program!\en"
print "  Remember, deposits are negative transactions.\en"
print "  Exit by a 0 transaction.\en\en"\fR

\f(CRprint "Initial balance? "; bal = read()
bal /= 1
print "\en"
while (1) {
  "current balance = "; bal
  "transaction? "; trans = read()
  if (trans == 0) break;
  bal \-= trans
  bal /= 1
}
quit\fR
.\fR
.RE
.fi
.PP
Lo siguiente es la definición de la función factorial recursiva.
.nf
.RS
\f(CR
define f (x) {
  if (x <= 1) return (1);
  return (f(x\-1) * x);
}\fR
.\fR
.RE
.fi
.SS "OPCIÓNES READLINE Y LIBEDIT"
GNU \fBbc\fP can be compiled (via a configure option) to use the GNU
\fBreadline\fP input editor library or the BSD \fBlibedit\fP library.  This allows
the user to do editing of lines before sending them to \fBbc\fP.  It also
allows for a history of previous lines typed.  When this option is selected,
\fBbc\fP has one more special variable.  This special variable, \fBhistory\fP is
the number of lines of history retained.  For \fBreadline\fP, a value of \-1
means that an unlimited number of history lines are retained.  Setting the
value of \fBhistory\fP 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 \fBreadline\fP, \fBhistory\fP and BSD \fBlibedit\fP libraries.  One can not
enable both \fBreadline\fP and \fBlibedit\fP at the same time.
.SS DIFERENCIAS
This version of \fBbc\fP was implemented from the POSIX P1003.2/D11 draft and
contains several differences and extensions relative to the draft and
traditional implementations.  It is not implemented in the traditional way
using \fBdc\fP(1).  This version is a single process which parses and runs a
byte code translation of the program.  There is an "undocumented" option
(\-c)  that causes the program to output the byte code to the standard output
instead of running it.  It was mainly used for debugging the parser and
preparing the math library.
.PP
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.
.IP "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_.
.IP nombres
El \fBbc\fP 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.
.IP 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.
.IP last
En el \fBbc\fP de POSIX no existe la variable \fBlast\fP. Algunas implementaciones
de \fBbc\fP usan el punto (.) de manera similar.
.IP comparaciones
El \fBbc\fP de POSIX permite las comparaciones solo en la sentencia if, la
sentencia while y la segunda expresión de la sentencia for. Además, solo se
permite una operación relacional en cada una de estas sentencias.
.IP "sentencia if, cláusula else"
El \fBbc\fP de POSIX no tiene la cláusula else.
.IP "sentencia for"
El \fBbc\fP de POSIX obliga a que estén todas las expresiones de la sentencia
for.
.IP "&&, ||, !"
El \fBbc\fP de POSIX no tiene los operadores lógicos.
.IP "función read"
El \fBbc\fP de POSIX no tiene la función read.
.IP "sentencia print"
El \fBbc\fP de POSIX no tiene la sentencia print.
.IP "sentencia continue"
El \fBbc\fP de POSIX no tiene la sentencia continue.
.IP "return statement"
POSIX \fBbc\fP requires parentheses around the return expression.
.IP "parámetros de tipo matriz"
El \fBbc\fP 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 \fBbc\fP solo se pueden
usar las matrices como parámetros por valor.
.IP "function format"
POSIX \fBbc\fP requires the opening brace on the same line as the \fBdefine\fP key
word and the \fBauto\fP statement on the next line.
.IP "=+, =\-, =*, =/, =%, =^"
El \fBbc\fP 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á \fBa\fP en 1 en lugar de asignar a \fBa\fP el valor \-1.
.IP "espacios en los números"
Otras implementaciones de \fBbc\fP 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 \fBbc\fP.
.IP "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,
.nf
.RS
a = 1
b = 2
.RE
.fi
tiene dos bloques y
.nf
.RS
{ a = 1
  b = 2 }
.RE
.fi
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.
.IP 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 \fBbc\fP 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 \fBbc\fP por
completo.
.SS LÍMITES
Los límites actualmente en vigor para este procesador \fBbc\fP son los
siguientes. Algunos de ellos pueden haber cambiado en el proceso de
instalación. Utilice la sentencia limits para ver sus valores actuales.
.IP BC_BASE_MAX
The maximum output base is at least 10^9.  The maximum input base is 16.
.IP BC_DIM_MAX
Tal y como se distribuye, este límite se inicializa arbitrariamente a
65535. En su instalación puede ser diferente.
.IP 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.
.IP BC_STRING_MAX
El límite para el número de caracteres de una cadena es INT_MAX caracteres.
.IP exponente
El valor del exponente en la operación potencia (^) esta limitado a
LONG_MAX.
.IP "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.
.SH "VARIABLES DE ENTORNO"
Las siguientes variables de entorno son procesadas por \fBbc\fP:
.IP POSIXLY_CORRECT
Esto es lo mismo que la opción \fB\-s\fP.
.IP BC_ENV_ARGS
Este es otra forma de pasar argumentos a \fBbc\fP. 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 \fBbc\fP. Los ficheros listados en las
variables de entorno generalmente contendrán definiciones de funciones que
el usuario quiera tener definidas cada vez que ejecute \fBbc\fP.
.IP 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.
.SH DIAGNÓSTICOS
Si algún fichero dado en la línea de órdenes no se puede abrir, \fBbc\fP
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.
.SH ERRORES
La recuperación de errores no es muy buena todavía.
.PP
Notifique cualquier error a \fBbug\-bc@gnu.org\fP.  Compruebe que incluye la
palabra \*(lqbc\*(rq dentro del campo \*(lqAsunto:\*(rq (\*(lqSubject:\*(rq).
.SH AUTOR
.nf
Philip A. Nelson
philnelson@acm.org
.fi
.SH 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.
.PP
.SH TRADUCCIÓN
La traducción al español de esta página del manual fue creada por
J. Ramón Palacios <jotarp@iname.com>
.
.PP
Esta traducción es documentación libre; lea la
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License Version 3
.UE
o posterior con respecto a las condiciones de copyright.
No existe NINGUNA RESPONSABILIDAD.
.PP
Si encuentra algún error en la traducción de esta página del manual, envíe un
correo electrónico a
.MT debian-l10n-spanish@lists.debian.org
.ME .