aribas - Online sa Cloud

PROGRAMA:

NAME

aribas - Multiprecision Arithmetic Interpreter

SINOPSIS

aribas [pagpipilian] [ari-file> [arg1>arg2> ...]]

Ang man page na ito ay isinulat para sa Debian dahil ang orihinal na software ay walang laman
pahina.

DESCRIPTION

Aribas ay isang interactive na interpreter na angkop para sa big integer arithmetic at
multiprecision floating point arithmetic. Mayroon itong syntax na katulad ng Pascal o Modula-2,
ngunit naglalaman din ng mga tampok mula sa iba pang mga programming language tulad ng C, Lisp, Oberon.

PAGGAMIT

Ang pinakasimpleng paraan ng paggamit aribas ay bilang isang calculator para sa (malaking integer) arithmetic. Pagkatapos
aribas ay nagsimula, ito ay nagpapakita ng isang prompt ==> at handang tumanggap ng input. Ipasok lamang ang
expression na gusto mong kalkulahin, na sinusundan ng isang full stop, at pagkatapos ay pindutin ang RETURN, para sa
halimbawa

==> 123 + 456*789.

Aribas sagot

-: 359907

Ang simbolo -: ipinakilala ang resulta.
MAHALAGA. Upang markahan ang pagtatapos ng iyong input, kailangan mong palaging mag-type ng full stop '.' at pagkatapos
pindutin ang RETURN.

Maaari mong italaga ang resulta ng isang pagkalkula sa isang variable, tulad ng sa

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

Kinakalkula nito ang ika-6 na numero ng Fermat (** nagsasaad ng exponentiation) at itinalaga ito sa
nagbabago F6 (tandaan na aribas ay case sensitive, kaya hindi ito katulad ng f6). Mamaya
maaari mong gamitin ang variable na ito halimbawa sa expression

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

na nagpapakita (sa pamamagitan ng teorama ni Fermat) na ang F6 ay hindi isang prime number.
Ang tatlong pinakabagong resulta ay naka-imbak sa mga pseudo variable _, __, at ___. Para sa
halimbawa maaari mong iimbak ang huling resulta sa variable x sa pamamagitan ng utos

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

Tulad ng makikita mo sa mga halimbawa sa itaas, aribas gumagamit ng underscore _ upang buuin ang output
ng malalaking integer (>= 2**32). Gayundin para sa input ng mga integer maaari mong gamitin ang underscore, ang
kundisyon lang na kaagad bago at pagkatapos ng underscore ay may mga digit,
halimbawa:

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

Dito ang output ay walang underscore, na nagpapakita na ang z ay mas mababa sa 2**32.

Aribas ay may ilang built-in na function para sa factorization, halimbawa rho_factorize, Na
gumagamit ng pollard's rho algorithm.

==> rho_factorize(F6).

nagtatrabaho..
factor na natagpuan pagkatapos ng 512 na pag-ulit

-: 274177

Upang mahanap ang natitirang cofactor, ibigay ang utos

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

Upang subukan kung ang salik na ito ay prime, ang probabilistic test ni Rabin rab_primetest ay maaaring maging
inilapat:

==> rab_primetest(x).
-: totoo

Ang function na rho_factorize ay mabuti para sa paghahanap ng maliliit na salik (sabihin hanggang 10 decimal
mga digit); para sa mas kumplikadong mga gawain sa factorization isang mas malakas na algorithm tulad ng
parisukat na salaan qs_factorize dapat gamitin

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

(Depende sa kapangyarihan ng iyong computer, tatagal ito ng ilang segundo hanggang ilang minuto
para makakuha ng prime factor ng 7th Fermat number.)

Kontrolin kaayusan
Ang para loop at ang habang isali aribas magkaroon ng syntax tulad ng sa Modula-2. Halimbawa, ang
sumusunod na command sequence ay kinakalkula ang factorial ng 100.

==> x := 1;
para sa i: = 2 hanggang 100 gawin
x := x*i;
katapusan;
x.

Tulad ng makikita mo sa halimbawang ito, ang input ay maaaring lumampas sa ilang linya.

Ang itaas para loop ay katumbas ng mga sumusunod habang silo

==> x := 1; ako := 2;
habang ako <= 100 ginagawa
x := x*i;
inc(i);
katapusan;
x.

Ang branching construct
if ... pagkatapos ... elsif ... iba ... dulo
ay mayroon ding parehong syntax tulad ng sa Modula-2.

Multiprecision lumulutang punto aritmetika
Aribas sumusuporta sa iba't ibang uri ng mga numero ng floating point na panloob na kinakatawan
na may mga mantissa na may iba't ibang bit-length:

single_float 32 bits
double_float 64 bits
long_float 128 bits

at ilang mas mataas na katumpakan hanggang sa limitasyon na umaasa sa pagpapatupad, karaniwang 1024 o
5120 bits, na maaaring matukoy ng function max_floatprec(). Bilang default, kapag
pagkalkula gamit ang mga numero ng uri ng data tunay, ginagamit ang mga single_floats. Ito ay tumutugma sa a
katumpakan ng 9 hanggang 10 decimal na lugar. Ang katumpakan ng 5120 bits ay tumutugma sa higit sa 1500
mga decimal na lugar.

Ang katumpakan ay maaaring mabago gamit ang function set_floatprec. Ang function ay tumatagal ng isa
integer argument, na kung saan ay ang nais na katumpakan sa bits. Awtomatiko itong binibilog sa
ang susunod na mas mataas na magagamit na halaga. Halimbawa, pagkatapos

==> set_floatprecNa (100).
-: 128

ang katumpakan ng floating point ay 128 bits at maaari mong kalkulahin

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

==> _/pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

gumagamit tinukoy function
Maaaring tukuyin ng user ang kanyang sariling mga function. Mukhang isang tipikal na halimbawa

==> function fac(n: integer): integer;
ay
x,i: integer;
simulan
x := 1;
para sa i := 2 sa n gawin
x := x*i;
katapusan;
ibalik ang x;
end.

Kung naipasok mo ito ng tama, aribas echoes ang pangalan ng function

-: mukha

at mula ngayon ay magagamit mo na fac sa parehong paraan tulad ng isang built-in na function, hal

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

Tandaan na ang mga kahulugan sa loob ng function ay dapat na tahasang ipahayag ang lahat ng ginamit na variable,
samantalang sa pinakamataas na antas ng aribas ang mga variable ng interpreter ay maaaring gawin lamang ng
mga takdang-aralin. Narito ang isa pang halimbawa, na nagpapakita ng ilang iba pang uri ng data na sinusuportahan ng
aribas:

==> function sqrt_list(n: integer): array of real;
ay
vec: array[n] ng tunay;
i: integer;
simulan
para sa i := 1 sa n gawin
vec[i-1] := sqrt(i);
katapusan;
bumalik vec;
end.

Ang function na ito ay nagbabalik ng array ng square roots ng integers mula 1 hanggang n, para sa
halimbawa

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

Sa isang mas malaking proyekto ng programming kung saan kailangan mo ng ilang mga function na hindi mo ipasok ang mga ito
direkta sa aribas prompt ngunit ihanda ang mga kahulugan ng function na may panlabas na teksto
editor at i-save ang mga ito sa isang file na may extension .ari , Halimbawa abcd.ari . Ang file na ito
pagkatapos ay mai-load ng aribas gamit ang utos

==> load("abcd").

Kung mayroong error sa syntax sa file, makakakuha ka ng mensahe ng error ng form

error sa linya <= 23 ng na-load na file
kung: inaasahang wakas

na nagsasabi sa iyo (sa halimbawang ito) na mayroong error sa if bumuo sa linya 23 o
kanina sa file. (Tandaan na ang mga mensahe ng error ay minsan ay hindi masyadong tumpak.) Ikaw
pagkatapos ay maaaring itama ang error at i-load muli ang file.

online Tulungan
Ang utos

==> mga simbolo(aribas).

nagbabalik ng listahan ng lahat ng keyword at pangalan ng mga builtin na function ng aribas. Ang listahang ito ay may
humigit-kumulang 200 entries, at magsisimula at magtatapos tulad ng sumusunod:

(ARGV, _, __, ___, abs, alloc, at, 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,
writeln)

Para sa karamihan ng mga simbolo sa listahang ito, maaari kang makakuha ng maikling online na tulong gamit ang function
tulong(). Halimbawa, ang utos

==> tulong(ARGV).

nagbibigay ng impormasyon sa builtin na variable ARGV, samantalang

==> tulong(habang).

inilalarawan ang syntax ng habang loop. Kung kailangan mo ng higit pang impormasyon kaysa sa nilalaman nito
sa online na tulong, kumonsulta sa dokumentasyon na makikita sa /usr/share/doc/aribas.

Gaano sa lumabas
Upang tapusin ang isang aribas session, uri lumabas sa aribas prompt

==> lumabas

at pagkatapos ay pindutin ang RETURN (ENTER) key.

Kung ayaw mong umalis aribas, ngunit nais na lumabas sa isang walang katapusang loop o a
pagkalkula na masyadong mahaba, i-type ang CONTROL-C (kung ikaw ay tumatakbo aribas mula sa loob
Mga Emac, kailangan mong pindutin ang CONTROL-C nang dalawang beses). Ito ay (sa karamihan ng mga kaso) ay titigil sa kasalukuyang
pagkalkula at pagbalik sa aribas prompt.

Kapag hindi mo ginagamit ang interface ng Emacs ngunit ang bersyon ng command line ng aribas, Mo
minsan napupunta sa sumusunod na sitwasyon: Ang ilang nakaraang linya ay naglalaman ng error sa pag-type,
ngunit hindi ka makakabalik sa linyang iyon para itama ito. Sa kasong ito, i-type mo lang ang a
lubusang paghinto '.' , na sinundan ng RETURN. Makakakuha ka ng mensahe ng error na maaari mong ligtas
huwag pansinin, at isang bagong prompt ==> lalabas, na nagbibigay-daan sa iyong subukang muli.

COMMAND LINE MGA PANGANGATWIRANG

aribas [pagpipilian] [ari-file> [arg1>arg2> ...]]

pagpipilian
Magagamit ang mga sumusunod na pagpipilian:

-q (quiet mode) Pinipigilan ang lahat ng mensahe sa screen (bersyon no, abiso sa copyright,
atbp.) kapag aribas ay nagsimula na

-v (verbose mode, default) Hindi pinipigilan ang mga mensahe sa screen kung kailan aribas is
nagsimula.

-c
aribas ang sarili nitong line breaking kapag nagsusulat sa screen. Karaniwan itong ipinapalagay
na ang screen (o ang window kung saan aribas runs) ay mayroong 80 column. Gamit ang -c
opsyon na maaari kang magtakda ng isa pang numero, na dapat nasa pagitan ng 40 at 160 (sa decimal
representasyon). Halimbawa, kung tatakbo ka aribas sa isang Xterm window na may 72
mga column, gamitin ang opsyon -c72 (o -c 72, ang espasyo sa pagitan ng -c at ang numero ay
opsyonal).

-m
Dito ay isang numero (sa decimal na representasyon) sa pagitan ng 500 at 32000. Ito
numero ay nagpapahiwatig kung gaano karaming Kilobytes ng RAM aribas dapat gamitin para sa aribas magbunton
Ang default na halaga ay depende sa mga opsyon na ginamit kung kailan aribas ay pinagsama-sama. Karaniwan,
sa ilalim ng UNIX o LINUX ito ay 6 Megabytes, katumbas ng -m6000

-h <landas of Tulungan file>
Ang online na tulong ng aribas depende sa isang file na aribas.hlp kung saan dapat matatagpuan
ang saklaw ng variable ng kapaligiran na PATH. Kung hindi ito ang kaso maaari mong tukuyin
ang eksaktong landas ng help file na may opsyong -h. Kung halimbawa ang file
aribas.hlp ay nasa direktoryo / usr / local / lib, gamitin ang opsyon -h / usr / local / lib
(ang espasyo pagkatapos ng -h ay hindi kailangan). Ang -h na opsyon ay maaari ding gamitin kung ang tulong
may ibang pangalan ang file. Kung ang help file ay pinangalanang help-aribas at nasa
direktoryo /home/joe/ari, gamitin ang -h/home/joe/ari/help-aribas.

Gamit ang isang maayos na naka-install na Debian package ng aribas hindi dapat kailanganin
gamitin ang opsyong ito.

-p
Sa pagpipiliang ito maaari mong tukuyin ang isang landas sa paghahanap para sa paglo-load ng mga file aribas pinagmulan
code. maaaring alinman sa (ganap) pathname ng isang direktoryo o
ilang pathname na pinaghihiwalay ng mga colon. Ipagpalagay na tumawag ka aribas sa
ang pagpipilian

-p/usr/local/lib/aribas:~/ari/mga halimbawa

at ang iyong home directory ay /home/alice/. Pagkatapos ay ang utos

==> load("factor").

hahanapin muna ang file factor.ari sa kasalukuyang direktoryo, pagkatapos ay sa
direktoryo /usr/local/lib/aribas at sa wakas sa /home/alice/ari/examples.

-b Batch mode kapag naglo-load ng isang aribas source code file mula sa command line, tingnan
sa ibaba.

Halimbawa, maaaring pagsamahin ang isang opsyon sa titik na hindi nangangailangan ng mga argumento

aribas -q -b

ay katumbas ng

aribas -qb

Pa utos linya argumento

Ang susunod na argumento ng command line pagkatapos ng mga opsyon ay binibigyang kahulugan bilang pangalan ng a
file na may aribas source code. Kung ang pangalan ng file ay may extension na .ari, ito
maaaring tanggalin ang extension. Ang file ay na-load na parang command load(" ")
ay ibinigay pagkatapos ng pagsisimula ng aribas sa aribas prompt. Kung ang file ay hindi
matatagpuan sa kasalukuyang direktoryo ito ay hinanap sa mga direktoryo na tinukoy ng
-p opsyon. Kung ang opsyon -b ay ibinigay, ang file ay na-load at naisakatuparan.
Pagkatapos aribas lalabas nang hindi ipinapakita na ito ay prompt. Kung hindi ma-load ang file
ganap na dahil sa isang pagkakamali, aribas lalabas kaagad pagkatapos ng mensahe ng error.

...
Kapag sumunod ang karagdagang mga argumento sa command line , sila ay kinokolekta (bilang
string) kasama ng sa vector ARGV na maaaring ma-access mula sa
sa loob ng aribas. Halimbawa: Kung tatawag ka aribas gamit ang command line

aribas startup 4536 eisenstein

at ang kasalukuyang direktoryo ay naglalaman ng file startup.ari, pagkatapos aribas naglo-load ito at
ang vector ARGV may porma

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

Kung kailangan mo ng ilang mga argumento bilang mga numero at hindi bilang mga string, maaari mong baguhin ang mga ito sa pamamagitan ng
inyo (O atof); sa ating halimbawa

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

gagawin ito. Ang haba ng vector ARGV maaaring matukoy ng haba(ARGV).

PAGPAPAKITA ARIBAS SA LOOB NG EMACS

Maaari kang tumakbo aribas mula sa loob ng Emacs sa pamamagitan ng pagbibigay ng utos (sa minibuffer ng Emacs)

Mx run-aribas

(Kung wala kang META key, gamitin ang ESC x sa halip na Mx) Pagkatapos aribas ilo-load sa
isang Emacs window na may pangalang *aribas* at maaari mong i-edit ang iyong input sa aribas kasama ang dati
Mga utos ng Emacs.

Kung ang iyong input ay nagtatapos sa isang full stop na '.' at pinindot mo ang RETURN, ipapadala ito sa aribas. Kung
gayunpaman ang iyong kumpletong input ay hindi nagtatapos sa isang full stop, (halimbawa bilang tugon sa a
readln), ang input ay ipinadala sa aribas ni Cj (Control-j) o Cc RETURN.

Kung gusto mong ulitin ang isang nakaraang input, ang Mp (o ESC p) ay umiikot pabalik sa pamamagitan ng input
kasaysayan, at ang Mn (o ESC n) ay pasulong.

Ang isang Control-C ay ipinadala sa aribas sa pamamagitan ng Cc Cc (pindutin ang Cc nang dalawang beses).

Posible rin na magsimula aribas mula sa Emacs na may mga argumento sa command line. Para dito
layunin ang utos

Cu Mx run-aribas

kailangang ibigay. Pagkatapos ay isang prompt

run-aribas: aribas

lilitaw sa Minibuffer ng Emacs at maaari mong kumpletuhin ang command line, halimbawa

run-aribas: aribas startup 4536 eisenstein

(tingnan sa itaas).

Configuration FILE

Mga pagpipilian para sa pagtakbo aribas ay maaaring tukuyin din gamit ang isang configuration file na may pangalan
.arirc. Aribas naghahanap ng configuration file sa sumusunod na pagkakasunud-sunod:

1) ang kasalukuyang direktoryo
2) ang home directory ng user

May ikatlong posibilidad: Maaari mong tukuyin ang isang variable ng kapaligiran ARIRC naglalaman ng
pangalan ng configuration file (na maaaring iba sa .arirc), kasama ang buo
landas.

Sa configuration file maaari mong tukuyin ang lahat ng mga opsyon sa command line na inilarawan sa itaas kung saan
magsimula sa isang - sign, gayunpaman isang hiwalay na linya ay dapat gamitin para sa bawat solong opsyon. Mga linya
na nagsisimula sa karakter # o walang laman na linya ay binabalewala. Bilang karagdagan sa mga pagpipilian
inilarawan sa itaas, maaaring naglalaman ang configuration file aribas source code. Para sa layuning ito
dapat may line reading

-sa loob

Pagkatapos ang lahat pagkatapos ng linyang ito ay itinuturing bilang aribas source code at naisakatuparan kapag aribas
ay nagsimula na

Ang pagkakaroon ng configuration file para sa aribas hindi ibinubukod ang posibilidad na magbigay
mga argumento ng command line. Kung ang isang opsyon (hal. ang -m na opsyon) ay tinukoy pareho sa
configuration file at ang command line ngunit may magkakaibang mga halaga, pagkatapos ay ang detalye
sa command line ay may bisa. Katulad nito, ang isang -v na opsyon sa command line ay nag-o-override sa isang -q
opsyon sa configuration file. Kung mayroong -init code sa configuration file at isang
argumento sa command line, pagkatapos ay ang -init code ay ipapatupad muna at
pagkatapos ay ang ay na-load at ang code nito ay naisakatuparan.

Gumamit ng aribas online gamit ang mga serbisyo ng onworks.net