Provided by: aribas_1.64-6_amd64 bug


       aribas - Multiprecision Arithmetic Interpreter


       aribas [options] [<ari-file> [<arg1> <arg2> ...]]

       This  man  page  was  written for Debian since the original software did not contain a man


       Aribas  is  an  interactive  interpreter  suitable  for   big   integer   arithmetic   and
       multiprecision  floating point arithmetic.  It has a syntax similar to Pascal or Modula-2,
       but contains also features from other programming languages like C, Lisp, Oberon.


       The simplest way to use aribas is as a calculator  for  (big  integer)  arithmetic.  After
       aribas is started, it displays a prompt ==> and is ready to accept input. Simply enter the
       expression you want to calculate, followed by a full stop,  and  then  press  RETURN,  for

           ==> 123 + 456*789.

       Aribas answers

           -: 359907

       The symbol -: introduces the result.
       IMPORTANT.   To mark the end of your input, you must always type a full stop '.'  and then
       press RETURN.

       You can assign the result of a calculation to a variable, as in

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

       This calculates the 6th Fermat number (** denotes exponentiation) and assigns  it  to  the
       variable  F6  (note  that aribas is case sensitive, so this is not the same as f6).  Later
       you can use this variable for example in the expression

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

       which shows (by Fermat's theorem) that F6 is not a prime number.
       The three most recent results are stored in the pseudo  variables  _,  __,  and  ___.  For
       example you can store the last result in the variable x by the command

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

       As you can see in the above examples, aribas uses the underscore _ to structure the output
       of big integers (>= 2**32). Also for input of integers you may  use  the  underscore,  the
       only  condition  is  that  immediately  before  and after the underscore there are digits,

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

       Here the output contains no underscore, which shows that z is less than 2**32.

       Aribas has several built-in functions for factorization, for example rho_factorize,  which
       uses Pollard's rho algorithm.

           ==> rho_factorize(F6).

           working ..
           factor found after 512 iterations

           -: 274177

       To find the remaining cofactor, give the command

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

       To  test  whether  this  factor  is prime, Rabin's probabilistic test rab_primetest can be

           ==> rab_primetest(x).
           -: true

       The function rho_factorize is good for  finding  small  factors  (say  up  to  10  decimal
       digits);  for  more  complicated  factorization  tasks  a more powerful algorithm like the
       quadratic sieve qs_factorize should be used

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

       (Depending on the power of your computer, it will take a few seconds up to a  few  minutes
       to get a prime factor of the 7th Fermat number.)

   Control structures
       The  for  loop and the while loop in aribas have a syntax as in Modula-2. For example, the
       following command sequence calculates the factorial of 100.

           ==> x := 1;
               for i := 2 to 100 do
                   x := x*i;

       As you can see in this example, the input may extend over several lines.

       The above for loop is equivalent to the following while loop

           ==> x := 1; i := 2;
               while i <= 100 do
                   x := x*i;

       The branching construct
       if ...  then ...  elsif ...  else ...  end
       has also the same syntax as in Modula-2.

   Multiprecision floating point arithmetic
       Aribas supports different types of floating point numbers which are internally represented
       with mantissas of different bit-length:

               single_float    32 bits
               double_float    64 bits
               long_float     128 bits

       and  several  higher precisions up to an implementation dependent limit, typically 1024 or
       5120 bits, which can be determined by  the  function  max_floatprec().  By  default,  when
       calculating  with numbers of data type real, single_floats are used. This corresponds to a
       precision of 9 to 10 decimal places.  A precision of 5120 bits corresponds  to  over  1500
       decimal places.

       The  precision  can  be  changed  using the function set_floatprec. The function takes one
       integer argument, which is the desired precision in bits. It is automatically  rounded  to
       the next higher available value. For example, after

           ==> set_floatprec(100).
           -: 128

       the floating point precision is 128 bits and you can calculate

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

           ==> _/pi.
           -: 0.33333_33333_33333_33333_33333_33333_33333_33

   User defined functions
       The user can define his or her own functions. A typical example looks like

           ==> function fac(n: integer): integer;
                   x,i: integer;
                   x := 1;
                   for i := 2 to n do
                       x := x*i;
                   return x;

       If you have entered this correctly, aribas echoes the function name

           -: fac

       and from now on you can use fac in the same way as a built-in function, e.g.

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

       Note  that  inside  function  definitions  all used variables must be explicitly declared,
       whereas on top level of  the  aribas  interpreter  variables  can  be  simply  created  by
       assignments.  Here  is  another  example,  which  shows some other data types supported by

           ==> function sqrt_list(n: integer): array of real;
                   vec: array[n] of real;
                   i: integer;
                   for i := 1 to n do
                       vec[i-1] := sqrt(i);
                   return vec;

       This function returns an array of the square roots of  the  integers  from  1  to  n,  for

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

       In  a bigger programming project where you need several functions you would not enter them
       directly at the aribas prompt but prepare the function definitions with an  external  text
       editor and save them in a file  with the extension .ari , for example abcd.ari . This file
       can then be loaded by aribas using the command

           ==> load("abcd").

       If there is a syntax error in the file, you get an error message of the form

           error in line <= 23 of loaded file
           if: end expected

       which tells you (in this example) that there is an error in the if construct in line 23 or
       earlier  in  the  file. (Note that the error messages are sometimes not very precise.) You
       can then correct the error and load the file again.

   Online help
       The command

           ==> symbols(aribas).

       returns a list of all keywords and names of builtin functions of aribas.   This  list  has
       about 200 entries, and begins and ends as follows:

       (ARGV,  _, __, ___, abs, alloc, and, arccos, arcsin, arctan, arctan2, aribas, array, atof,
       atoi,  begin,  binary,  bit_and,  bit_clear,  bit_length,  ......  ,   tolower,   toupper,
       transcript,  true, trunc, type, user, var, version, while, write, write_block, write_byte,

       For most of the symbols in this list, you can get a short online help using  the  function
       help(). For example, the command

           ==> help(ARGV).

       gives an information on the builtin variable ARGV, whereas

           ==> help(while).

       describes  the  syntax of the while loop. If you need more information than that contained
       in the online help, consult the documentation which can be found in /usr/share/doc/aribas.

   How to exit
       To end an aribas session, type exit at the aribas prompt

           ==> exit

       and then press the RETURN (ENTER) key.

       If you don't want to leave aribas, but want  to  break  out  of  an  infinite  loop  or  a
       calculation  that  lasts  too  long, type CONTROL-C (if you are running aribas from within
       Emacs, you must press CONTROL-C twice).  This  will  (in  most  cases)  stop  the  current
       calculation and return to the aribas prompt.

       When  you  are  not  using the Emacs interface but the command line version of aribas, you
       sometimes get into the following situation: Some previous line contains  a  typing  error,
       but  you  cannot return to that line to correct it.  In this case you should simply type a
       full stop '.' , followed by RETURN. You will get an error message  which  you  can  safely
       ignore, and a new prompt ==> appears, allowing you to try again.


       aribas [options] [<ari-file> [<arg1> <arg2> ...]]

       The following options are available:

       -q     (quiet  mode)  Suppresses all messages to the screen (version no, copyright notice,
              etc.) when aribas is started

       -v     (verbose mode, default) Does not suppress messages to the  screen  when  aribas  is

       -c <cols>
              aribas does its own line breaking when writing to the screen.  Normally it supposes
              that the screen (or the window in which aribas runs) has 80 columns.  With  the  -c
              option  you  can  set  another number, which must be between 40 and 160 (in decimal
              representation).  For example, if you  run  aribas  in  an  Xterm  window  with  72
              columns,  use  the  option  -c72  (or -c 72, the space between -c and the number is

       -m <mem>
              Here <mem> is a number (in decimal representation)  between  500  and  32000.  This
              number  indicates  how many Kilobytes of RAM aribas should use for the aribas heap.
              The default value depends on the options used when aribas was compiled.  Typically,
              under UNIX or LINUX it is 6 Megabytes, corresponding to -m6000

       -h <path of help file>
              The online help of aribas depends on a file aribas.hlp which should be situated  in
              the range of the environment variable PATH. If this is not the case you can specify
              the  exact  path  of  the  help  file  with  the -h option. If for example the file
              aribas.hlp is in the directory /usr/local/lib, use  the  option  -h  /usr/local/lib
              (the  space after -h is not necessary).  The -h option can also be used if the help
              file has a different name. If the help file is named help-aribas and  lies  in  the
              directory /home/joe/ari, use -h/home/joe/ari/help-aribas.

              With  a  properly  installed Debian package of aribas it should not be necessary to
              use this option.

       -p <ari-search-path>
              With this option you can specify a search path for loading files with aribas source
              code.  <ari-search-path>  may be either the (absolute) pathname of one directory or
              several pathnames separated by colons.  Suppose that you have  called  aribas  with
              the option


              and that your home directory is /home/alice/. Then the command

                   ==> load("factor").

              will  search  the  file  factor.ari  first  in  the  current directory, then in the
              directory /usr/local/lib/aribas and finally in /home/alice/ari/examples.

       -b     Batch mode when loading an aribas source code  file  from  the  command  line,  see

       One letter options which require no arguments may be merged, for example

           aribas -q -b

       is equivalent to

           aribas -qb

   Further command line arguments
              The  next  command  line argument after the options is interpreted as the name of a
              file with aribas source code. If  the  file  name  has  the  extension  .ari,  this
              extension  may  be omitted. The file is loaded as if the command load("<ari-file>")
              had been given after the start of aribas at the aribas prompt. If the file  is  not
              found  in  the current directory it is searched in the directories specified by the
              -p option.  If  the  option  -b  was  given,  the  file  is  loaded  and  executed.
              Afterwards  aribas  exits without showing it's prompt. If the file cannot be loaded
              completely because of an error, aribas exits immediately after the error message.

       <arg1> <arg2> ...
              When further command line arguments  follow  <ari-file>,  they  are  collected  (as
              strings)  together  with  <ari-file>  in the vector ARGV which can be accessed from
              within aribas.  Example: If you call aribas with the command line

                   aribas startup 4536 eisenstein

              and the current directory contains the file startup.ari, then aribas loads  it  and
              the vector ARGV has the form

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

              If you need some arguments as numbers and not as strings, you can transform them by
              atoi (or atof); in our example

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

              will do it. The length of the vector ARGV can be determined by length(ARGV).


       You can run aribas from within Emacs by giving the command (in Emacs' minibuffer)

            M-x run-aribas

       (If you don't have a META key, use ESC x instead of M-x) Then aribas will be  loaded  into
       an  Emacs  window  with name *aribas* and you can edit your input to aribas with the usual
       Emacs commands.

       If your input ends with a full stop '.' and you press RETURN, it is sent  to  aribas.   If
       however  your  complete input does not end with a full stop, (for example in response to a
       readln), the input is sent to aribas by C-j (Control-j) or C-c RETURN.

       If you want to repeat a previous input, M-p (or  ESC  p)  cycles  backward  through  input
       history, and M-n (or ESC n) cycles forward.

       A Control-C is sent to aribas by C-c C-c (press C-c twice).

       It  is  also  possible  to  start  aribas from Emacs with command line arguments. For this
       purpose the command

            C-u M-x run-aribas

       has to be given. Then a prompt

            run-aribas: aribas

       appears in the Minibuffer of Emacs and you can complete the command line, for example

            run-aribas: aribas startup 4536 eisenstein

       (see above).


       Options for running aribas can be specified also using  a  configuration  file  with  name
       .arirc.  Aribas searches for a configuration file in the following order:

           1) the current directory
           2) the home directory of the user

       There  is a third possibility: You can define an environment variable ARIRC containing the
       name of the configuration file (which may be different from .arirc),  including  the  full

       In  the  configuration file you can specify all command line options described above which
       begin with a - sign, however a separate line must be used for every single  option.  Lines
       beginning  with  the  character  # or empty lines are ignored.  In addition to the options
       described above, the configuration file may contain aribas source code. For  this  purpose
       there must be a line reading


       Then  everything after this line is treated as aribas source code and executed when aribas
       is started.

       The existence of a configuration file for aribas does not exclude the possibility to  give
       command  line  arguments.  If  an  option  (e.g.  the  -m option) is specified both in the
       configuration file and the command line but with different values, then the  specification
       at  the command line is valid. Analogously, a -v option on the command line overrides a -q
       option in the configuration file.  If there is -init code in the configuration file and an
       <ari-file>  argument  at  the  command  line,  then  the  -init code is executed first and
       afterwards the <ari-file> is loaded and its code executed.


       $ARIRC, .arirc, $HOME/.arirc

              Optional configuration file.


       $ARIRC Location of the optional configuration file.



       More information on how to use aribas can be found in /usr/share/doc/aribas.

       The aribas home page is


       Bug reports should be sent by email to



       Otto Forster <> is the author  of  the  aribas  program.
       This  man  page  was  compiled  by  Ralf  Treinen  <>  from  the  aribas
       documentation for the Debian package of aribas, and supplemented by the author.