Sto cercando un calcolatore basato su TTY compatibile con Linux. Per esempio:
user@host:~$ calculate
> 2
2
user@host:~$ calculate
> 8*6-4
44
user@host:~$ calculate
> 8*(6-4)
16
Esiste qualcosa di simile che supporta le operazioni di base, alcune funzioni incorporate simili atan()e possibilmente funzioni personalizzate tramite script?
Risposte:
bce dcsono i 2 calcolatori che userò spesso quando è necessario l'accesso da un terminale.
$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
Quindi puoi digitare le tue domande:
2
2
5+5
10
Quando hai finito puoi uscire con un Ctrl+ C.
Questi calcolatori sono piuttosto ricchi di funzionalità.
scalata
scale=5
193 * 1/3
64.33333
equazioni
principal=100
ir = 0.05
years = 5
futurevalue = principal * (1 + ir)^years
futurevalue
127.62800
i tuoi esempi
8*6-4
44
8*(6-4)
16
Se vuoi qualcosa di un po 'più interattivo c'è calc.
$ calc
C-style arbitrary precision calculator (version 2.12.4.4)
Calc is open software. For license details type: help copyright
[Type "exit" to exit, or "help" for help.]
; 10+10
20
; 8*6-4
44
; 8*(6-4)
16
;
Puoi usare le frecce su / giù per passare attraverso i comandi precedenti e ha anche una guida interattiva.
; help
Ti dà questo:
For more information while running calc, type help followed by one of the
following topics:
topic description
----- -----------
intro introduction to calc
overview overview of calc
help this file
assoc using associations
builtin builtin functions
command top level commands
config configuration parameters
custom information about the custom builtin interface
define how to define functions
environment how environment variables effect calc
errorcodes calc generated error codes
expression expression sequences
file using files
history command history
interrupt how interrupts are handled
list using lists
mat using matrices
...
calcla pagina di riferimento principalecalc's pagina manCi sono molte risposte alla tua domanda ...
Quelli semplici che potresti fare nella shell.
$ echo $((8*(6-4)))
16
Come programma dedicato c'è bc.
$ echo "8*(6-4)" | bc
16
Funzioni personalizzate tramite scripting? Bene, gli script di shell e bc li hanno entrambi, in un certo senso. Dipende da quanto lontano vuoi portarlo.
Perché non Python? È facile da imparare
$ python
>>> from math import atan
>>> 8*(6-4)+atan(0)
16.0
In zsh:
$ autoload zcalc # best in ~/.zshrc
$ zcalc
1> 8*(6-4)
16
2> $1*2
32
L (t): = exp (% i * t * 2 *% pi); / * cerchio unitario parametrizzato con angolo in curva * /
plot2d (
[Atan2 (imagpart (L (x)), realpart (L (x)))],
[x], 0,1,
[Y, -2% * pi, pi 2% *],
[plot_format, gnuplot],
[Gnuplot_term, "png"],
[gnuplot_out_file, "atan2.png"],
[legenda, "atan2"],
[xlabel, "angolo in radianti"],
[ylabel, "angolo in radianti"],
[Gnuplot_preamble,"
imposta la chiave in alto a sinistra;
impostare xtics ('pi / 2' 0.25, 'pi' 0.5, '3pi / 2' 0.75, '2pi' 1.0);
impostare ytics ('-2pi' -6.283, '-pi' -3.1415, '-pi / 2' -1.5708, '0' 0, 'pi / 2' 1.5708, 'pi' 3.1415, '2pi' 6.283);
imposta grid xtics ytics "]
);
HTH
Ecco un piccolo trucco bash che ti permetterà di fare semplici aritmetiche direttamente dalla riga di comando.
alias calc='set -o noglob; docalc'
function docalc { perl -e "print STDOUT $*, \"\\n\""; set +o noglob; }
Quindi puoi fare, ad es.
calc 3 * 15 + 5
Sfortunatamente non gioca bene con le parentesi. (Se ricordo bene, puoi far sì che anche tcsh accetti quelli, ma non riesco a convincere Bash a.)
PS. Puoi fare affidamento su bash per l'aritmetica, sostituendo la perlchiamata con echo $(( $* )); ma questo ti darà una divisione intera per 5/6, ecc. L'aritmetica di Perl è più utile.
Alternativa: se la tua unica carne di manzo con pitone è quella di cui hai bisogno import math, il tuo amico è il seguente:
% alias calc='python -i -c "from math import *"'
% calc
>>> 5 * atan(0.25)
Un altro modo è usare un interprete come Python 3:
$ python3
> from math import *
> 213/53*exp(0.8)/asin(3)
9.645423462356044
Avere il vantaggio di poter scrivere tutto, ci sono già molte funzioni (è anche possibile importare cmathse si necessitano numeri complessi), non è necessario impostare alcuna precisione per la maggior parte dei casi e Python è già installato sulla maggior parte delle installazioni Linux.
Python 3.x è meglio per un calcolatore generico di Python 2.x, perché Python 3.x esegue una divisione in virgola mobile se il risultato non è un int.
$ python3
> 3/2
1.5
$ python2
> 3/2
1
Il principale svantaggio, almeno per me, è che i float non sono stampati nella notazione scientifica se non sono molto grandi o piccoli, senza una stringa di formato:
> exp(35)
1586013452313430.8
> "{:e}".format(exp(35))
'1.586013e+15'