aribas - Online en la nube

PROGRAMA:

NOMBRE

aribas - Intérprete aritmético multiprecisión

SINOPSIS

ariba [opciones] [archivo ari> [arg1>arg2> ...]]

Esta página man fue escrita para Debian ya que el software original no contenía un man
.

DESCRIPCIÓN

aribas es un intérprete interactivo adecuado para aritmética de enteros grandes y
aritmética de coma flotante multiprecisión. Tiene una sintaxis similar a Pascal o Modula-2,
pero también contiene características de otros lenguajes de programación como C, Lisp, Oberon.

USO

La forma más sencilla de utilizar ariba es como una calculadora para aritmética (números enteros grandes). Después
ariba se inicia, muestra un mensaje ==> y está listo para aceptar entradas. Simplemente ingrese el
expresión que desea calcular, seguida de un punto y luego presione RETURN, para
ejemplo

==> 123 + 456 * 789.

aribas respuestas

-: 359907

El símbolo -: introduce el resultado.
IMPORTANTE. Para marcar el final de su entrada, siempre debe escribir un punto '.' y luego
pulse Retorno.

Puede asignar el resultado de un cálculo a una variable, como en

==> F6: = 2 ** 64 + 1.
-: 18446_74407_37095_51617

Esto calcula el sexto número de Fermat (** denota exponenciación) y lo asigna a la
variable F6 (tenga en cuenta que ariba distingue entre mayúsculas y minúsculas, por lo que no es lo mismo que f6). Más tarde
puedes usar esta variable, por ejemplo, en la expresión

==> 123 ** (F6 - 1) mod F6.
-: 688_66214_58712_63971

lo que muestra (por el teorema de Fermat) que F6 no es un número primo.
Los tres resultados más recientes se almacenan en las pseudovariables _, __y ___. For
ejemplo, puede almacenar el último resultado en la variable x mediante el comando

==> x: = _.
-: 688_66214_58712_63971

Como puede ver en los ejemplos anteriores, ariba usa el subrayado _ para estructurar la salida
de números enteros grandes (> = 2 ** 32). También para la entrada de números enteros puede usar el guión bajo, el
La única condición es que inmediatamente antes y después del guión bajo haya dígitos,
ejemplo:

==> z: = 123_4567_890.
-: 1234567890

Aquí la salida no contiene un guión bajo, lo que muestra que z es menor que 2 ** 32.

aribas tiene varias funciones integradas para la factorización, por ejemplo rho_factorizar, cual
utiliza el algoritmo rho de Pollard.

==> rho_factorizar (F6).

laboral ..
factor encontrado después de 512 iteraciones

-: 274177

Para encontrar el cofactor restante, da el comando

==> x: = F6 div _.
-: 6728_04213_10721

Para probar si este factor es primo, la prueba probabilística de Rabin rab_primetest puede ser
aplicado:

==> rab_primetest (x).
-: cierto

La función rho_factorizar es bueno para encontrar factores pequeños (digamos hasta 10 decimales
dígitos); para tareas de factorización más complicadas, un algoritmo más potente como el
tamiz cuadrático qs_factorizar debería ser usado

==> qs_factorize (2 ** 128 + 1).

(Dependiendo de la potencia de su computadora, tardará unos segundos hasta unos minutos
para obtener un factor primo del séptimo número de Fermat).

Control estructuras
El para bucle y el mientras incluyete ariba tienen una sintaxis como en Modula-2. Por ejemplo, el
La siguiente secuencia de comandos calcula el factorial de 100.

==> x: = 1;
para i: = 2 a 100 do
x: = x * i;
fin;
x.

Como puede ver en este ejemplo, la entrada puede extenderse por varias líneas.

Lo anterior para bucle es equivalente al siguiente mientras loops

==> x: = 1; i: = 2;
mientras que yo <= 100 lo hago
x: = x * i;
inc (i);
fin;
x.

La construcción ramificada
if ... luego ... elsi ... más ... final
tiene también la misma sintaxis que en Modula-2.

Multiprecisión flotante punto aritmética
aribas admite diferentes tipos de números de punto flotante que están representados internamente
con mantisas de diferente longitud de bits:

single_float 32 bits
doble_flotante 64 bits
long_float 128 bits

y varias precisiones más altas hasta un límite dependiente de la implementación, típicamente 1024 o
5120 bits, que pueden ser determinados por la función max_floatprec (). Por defecto, cuando
calcular con números de tipo de datos real, se utilizan single_floats. Esto corresponde a un
precisión de 9 a 10 lugares decimales. Una precisión de 5120 bits corresponde a más de 1500
lugares decimales.

La precisión se puede cambiar usando la función set_floatprec. La función toma uno
argumento entero, que es la precisión deseada en bits. Se redondea automáticamente a
el siguiente valor disponible más alto. Por ejemplo, después

==> set_floatprec(100).
-: 128

la precisión del punto flotante es de 128 bits y puede calcular

==> arctan (sqrt(3)).
-: 1.04719_75511_96597_74615_42144_61093_16762_8

==> _ / pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

Usuario se define funciones
El usuario puede definir sus propias funciones. Un ejemplo típico se parece a

==> función fac (n: integer): integer;
var
x, i: número entero;
comenzar
x: = 1;
para i: = 2 an do
x: = x * i;
fin;
devolver x;
fin.

Si lo ha introducido correctamente, ariba repite el nombre de la función

-: cara

y de ahora en adelante puedes usar fac de la misma manera que una función incorporada, p. ej.

==> fac(32).
-: 2_63130_83693_36935_30167_21801_21600_00000

Tenga en cuenta que dentro de las definiciones de función, todas las variables utilizadas deben declararse explícitamente,
mientras que en el nivel superior de la ariba Las variables de intérprete pueden ser creadas simplemente por
asignaciones. Aquí hay otro ejemplo, que muestra algunos otros tipos de datos admitidos por
ariba:

==> función sqrt_list (n: integer): matriz de real;
var
vec: matriz [n] de real;
i: entero;
comenzar
para i: = 1 an do
vec [i-1]: = sqrt (i);
fin;
volver vec;
fin.

Esta función devuelve una matriz de las raíces cuadradas de los números enteros de 1 an, para
ejemplo

==> lista_sqrt(10).
-: (1.00000000, 1.41421356, 1.73205081, 2.00000000,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.00000000,
3.16227766).

En un proyecto de programación más grande donde necesita varias funciones, no las ingresaría
directamente en el ariba solicitar pero preparar las definiciones de función con un texto externo
editor y guárdelos en un archivo con la extensión .ari , Por ejemplo abcd.ari . Este archivo
luego puede ser cargado por ariba usando el comando

==> cargar ("abcd").

Si hay un error de sintaxis en el archivo, aparece un mensaje de error con el formato

error en la línea <= 23 del archivo cargado
si: final esperado

que le dice (en este ejemplo) que hay un error en el if construir en la línea 23 o
anteriormente en el archivo. (Tenga en cuenta que los mensajes de error a veces no son muy precisos).
A continuación, puede corregir el error y volver a cargar el archivo.

ONLINE ayuda
El comando

==> símbolos (aribas).

devuelve una lista de todas las palabras clave y nombres de funciones integradas de ariba. Esta lista tiene
alrededor de 200 entradas, y comienza y termina de la siguiente manera:

(ARGV, _, __, ___, abs, alloc, y, arccos, arcsin, arctan, arctan2, aribas, array, atof,
atoi, begin, binary, bit_and, bit_clear, bit_length, ......, tolower, toupper,
transcripción, verdadero, trunc, tipo, usuario, var, versión, mientras, escribir, escribir_bloque, escribir_byte,
escrito)

Para la mayoría de los símbolos de esta lista, puede obtener una breve ayuda en línea utilizando la función
ayuda(). Por ejemplo, el comando

==> ayuda (ARGV).

da información sobre la variable incorporada ARGV, mientras que

==> ayuda (mientras).

describe la sintaxis de la mientras círculo. Si necesita más información de la contenida
en la ayuda en línea, consulte la documentación que se puede encontrar en / usr / share / doc / aribas.

Cómo a salida
Para terminar un ariba sesión, tipo salida en el ariba puntual

==> salir

y luego presione la tecla RETURN (ENTER).

Si no quieres irte ariba, pero quiere salir de un bucle infinito o un
cálculo que dura demasiado, escriba CONTROL-C (si está ejecutando ariba desde adentro
Emacs, debe presionar CONTROL-C dos veces). Esto detendrá (en la mayoría de los casos) la corriente
cálculo y volver al ariba rápido.

Cuando no está usando la interfaz de Emacs pero la versión de línea de comando de ariba,
a veces se meten en la siguiente situación: alguna línea anterior contiene un error de escritura,
pero no puede volver a esa línea para corregirlo. En este caso, simplemente debe escribir un
parada completa '.', seguido de RETURN. Recibirá un mensaje de error que puede
ignorar, y un nuevo mensaje ==> aparece, lo que le permite volver a intentarlo.

COMANDO LÍNEA ARGUMENTOS

ariba [opciones] [archivo ari> [arg1>arg2> ...]]

opciones
Las siguientes opciones están disponibles:

-q (modo silencioso) Suprime todos los mensajes en la pantalla (número de versión, aviso de derechos de autor,
etc.) cuando ariba Está empezado

-v (modo detallado, predeterminado) No suprime los mensajes en la pantalla cuando ariba is
comenzado.

-c
ariba hace su propio salto de línea al escribir en la pantalla. Normalmente supone
que la pantalla (o la ventana en la que ariba corre) tiene 80 columnas. Con la -c
opción puede establecer otro número, que debe estar entre 40 y 160 (en decimal
representación). Por ejemplo, si corres ariba en una ventana de Xterm con 72
columnas, use la opción -c72 (o -c 72, el espacio entre -c y el número es
Opcional).

-m
Aquí es un número (en representación decimal) entre 500 y 32000. Este
número indica cuántos kilobytes de RAM ariba debe usar para el ariba montón.
El valor predeterminado depende de las opciones utilizadas cuando ariba fue compilado. Típicamente,
bajo UNIX o LINUX es de 6 Megabytes, correspondiente a -m6000

-h <ruta of ayuda archivo>
La ayuda en línea de ariba depende de un archivo aribas.hlp que debe estar situado en
el rango de la variable de entorno PATH. Si este no es el caso, puede especificar
la ruta exacta del archivo de ayuda con la opción -h. Si, por ejemplo, el archivo
aribas.hlp está en el directorio / usr / local / lib, usa la opción -h / usr / local / lib
(el espacio después de -h no es necesario). La opción -h también se puede utilizar si la ayuda
el archivo tiene un nombre diferente. Si el archivo de ayuda se llama help-aribas y se encuentra en el
directorio / inicio / joe / ari, use -h / inicio / joe / ari / help-aribas.

Con un paquete Debian correctamente instalado de ariba no debería ser necesario
utilice esta opción.

-p
Con esta opción puede especificar una ruta de búsqueda para cargar archivos con ariba fuente
código. puede ser la ruta (absoluta) de un directorio o
varios nombres de ruta separados por dos puntos. Suponga que ha llamado ariba
la opción

-p / usr / local / lib / aribas:~ / ari / ejemplos

y que su directorio personal es / home / alice /. Entonces el comando

==> carga ("factor").

buscará el archivo factor.ari primero en el directorio actual, luego en el
directorio / usr / local / lib / aribas y finalmente en / home / alice / ari / examples.

-b Modo por lotes al cargar un ariba archivo de código fuente desde la línea de comando, consulte
abajo.

Las opciones de una letra que no requieren argumentos pueden combinarse, por ejemplo

aribas-q-b

es equivalente a

aribas-qb

Promover comando línea argumentos

El siguiente argumento de la lnea de comando despus de las opciones se interpreta como el nombre de un
archivo con ariba código fuente. Si el nombre del archivo tiene la extensión .ari, este
se puede omitir la extensión. El archivo se carga como si el comando carga(" ")
se había dado después del inicio de ariba en el ariba inmediato. Si el archivo no es
que se encuentra en el directorio actual se busca en los directorios especificados por el
-p opción. Si se dio la opción -b, el archivo se carga y se ejecuta.
Después ariba sale sin mostrar su mensaje. Si el archivo no se puede cargar
completamente debido a un error, ariba sale inmediatamente después del mensaje de error.

...
Cuando siguen más argumentos de línea de comando , se recogen (como
cadenas) junto con en el vector ARGV que se puede acceder desde
dentro de ariba. Ejemplo: si llamas ariba con la línea de comando

Aribas startup 4536 eisenstein

y el directorio actual contiene el archivo startup.ari, luego ariba lo carga y
el vector ARGV tiene la forma

==> ARGV.
-: ("inicio", "4536", "eisenstein")

Si necesita algunos argumentos como números y no como cadenas, puede transformarlos por
atoi (o en); en nuestro ejemplo

==> x: = atoi (ARGV [1]).
-: 4536

lo haré. La longitud del vector ARGV puede ser determinado por longitud (ARGV).

RUNNING ARIBAS DENTRO EMACS

Tu puedes correr ariba desde dentro de Emacs dando el comando (en el minibúfer de Emacs)

Mx run-aribas

(Si no tiene una tecla META, use ESC x en lugar de Mx) Luego ariba se cargará en
una ventana de Emacs con el nombre * aribas * y puede editar su entrada para ariba con lo de siempre
Comandos de Emacs.

Si su entrada termina con un punto '.' y pulsas RETORNO, se envía a ariba. Si
Sin embargo, su entrada completa no termina con un punto final (por ejemplo, en respuesta a una
leer), la entrada se envía a ariba mediante Cj (Control-j) o Cc RETURN.

Si desea repetir una entrada anterior, Mp (o ESC p) retrocede a través de la entrada
historial, y Mn (o ESC n) avanza.

Se envía un Control-C a ariba por Cc Cc (presione Cc dos veces).

También es posible empezar ariba de Emacs con argumentos de línea de comando. Para esto
propósito el comando

Cu Mx run-aribas

tiene que ser dado. Entonces un aviso

correr-aribas: aribas

aparece en el Minibúfer de Emacs y puedes completar la línea de comando, por ejemplo

run-aribas: inicio de aribas 4536 eisenstein

(véase más arriba).

CONFIGURACIÓN ARCHIVO

Opciones para correr ariba se puede especificar también usando un archivo de configuración con nombre
.arirc. aribas busca un archivo de configuración en el siguiente orden:

1) el directorio actual
2) el directorio de inicio del usuario

Existe una tercera posibilidad: puede definir una variable de entorno ARIRC que contiene el
nombre del archivo de configuración (que puede ser diferente de .arirc), incluido el
camino.

En el archivo de configuración puede especificar todas las opciones de la línea de comando descritas anteriormente que
comience con un signo -, sin embargo, se debe usar una línea separada para cada opción. Líneas
comenzando con el carácter # o las líneas vacías se ignoran. Además de las opciones
descrito anteriormente, el archivo de configuración puede contener ariba código fuente. Para este propósito
debe haber una lectura de línea

-en eso

Entonces todo lo que sigue a esta línea se trata como ariba código fuente y ejecutado cuando ariba
Está empezado.

La existencia de un archivo de configuración para ariba no excluye la posibilidad de dar
argumentos de la línea de comandos. Si se especifica una opción (por ejemplo, la opción -m) tanto en el
archivo de configuración y la línea de comando pero con valores diferentes, luego la especificación
en la línea de comando es válido. De manera análoga, una opción -v en la línea de comando anula una -q
opción en el archivo de configuración. Si hay un código -init en el archivo de configuración y un
argumento en la línea de comando, luego el código -init se ejecuta primero y
luego el se carga y su código se ejecuta.

Utilice aribas en línea utilizando los servicios de onworks.net