Wie führe ich Integer & Float-Berechnungen in Bash oder anderen Sprachen / Frameworks durch?

Die echo "20+5"wörtliche Verwendung erzeugt den Text " 20+5".

Welchen Befehl kann ich 25in diesem Fall verwenden, um die numerische Summe abzurufen?

Und was ist der einfachste Weg, dies mit bash als Gleitkommazahl zu tun? Zum Beispiel echo $((3224/3807.0))druckt 0:(.

Ich suche nach Antworten, indem ich entweder die Basisbefehlsshell ('Befehlszeile') selbst verwende oder indem ich Sprachen verwende, die über die Befehlszeile verfügbar sind.

Es gibt viele Möglichkeiten !!!

Zusammenfassung

$ printf %.10f\\n "$((10**9 * 20/7))e-9"   # many shells. Not mksh.
$ echo "$((20.0/7))"                       # (ksh93/zsh/yash, not bash)
$ awk "BEGIN {print (20+5)/2}"
$ zcalc
$ bc <<< 20+5/2
$ bc <<< "scale=4; (20+5)/2"
$ dc <<< "4 k 20 5 + 2 / p"
$ expr 20 + 5
$ calc 2 + 4
$ node -pe 20+5/2  # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
$ echo 20 5 2 / + p | dc 
$ echo 4 k 20 5 2 / + p | dc 
$ perl -E "say 20+5/2"
$ python -c "print(20+5/2)"
$ python -c "print(20+5/2.0)"
$ clisp -x "(+ 2 2)"
$ lua -e "print(20+5/2)"
$ php -r 'echo 20+5/2;'
$ ruby -e 'p 20+5/2'
$ ruby -e 'p 20+5/2.0'
$ guile -c '(display (+ 20 (/ 5 2)))'
$ guile -c '(display (+ 20 (/ 5 2.0)))'
$ slsh -e 'printf("%f",20+5/2)'
$ slsh -e 'printf("%f",20+5/2.0)'
$ tclsh <<< 'puts [expr 20+5/2]'
$ tclsh <<< 'puts [expr 20+5/2.0]'
$ sqlite3 <<< 'select 20+5/2;'
$ sqlite3 <<< 'select 20+5/2.0;'
$ echo 'select 1 + 1;' | sqlite3 
$ psql -tAc 'select 1+1'
$ R -q -e 'print(sd(rnorm(1000)))'
$ r -e 'cat(pi^2, "\n")'
$ r -e 'print(sum(1:100))'
$ smjs
$ jspl

Einzelheiten

Muscheln

Sie können POSIX arithmetische Erweiterung für verwenden Integer - Arithmetik echo "$((...))":

$ echo "$((20+5))"
25
$ echo "$((20+5/2))"
22

Ziemlich portabel ( ash dash yash bash ksh93 lksh zsh):
Mit der printf-Funktion zum Drucken von Floats können wir die meisten Shells erweitern, um Gleitkomma-Berechnungen durchzuführen, wenn auch mit einem begrenzten Bereich (nicht mehr als 10 Stellen):

$ printf %.10f\\n "$((1000000000 *   20/7  ))e-9"
2.8571428570

ksh93, yashund zshunterstütze Floats hier:

$ echo "$((1.2 / 3))"
0.4

nur ksh93(direkt) und zshLaden der Bibliothek mathfunc hier:

$ echo "$((4*atan(1)))"
3.14159265358979324

( zshmüssen geladen werden zmodload zsh/mathfunc, um Funktionen wie zu erhalten atan).

Interaktiv mit zsh:

$ autoload zcalc
$ zcalc
1> PI/2
1.5708
2> cos($1)
6.12323e-17
3> :sci 12
6.12323399574e-17

Mit (t) csh (nur Ganzzahl):

% @ a=25 / 3; echo $a
8

In der rcShell-Familie akangaist die mit arithmetischer Erweiterung:

; echo $:25/3
8

POSIX-Werkzeugkasten

bc(siehe unten für den interaktiven Modus), Handbuch hier

Mnemonic: best calculator (obwohl das beigentlich für basic ist ).

$ echo 20+5/2 | bc
22
$ echo 'scale=4;20+5/2' | bc
22.5000

(unterstützt beliebige Präzisionszahlen)

bc interaktiver Modus:

$ 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'. 
5+5
10

2.2+3.3
5.5

Rushs Lösung expr(kein interaktiver Modus):

$ expr 20 + 5
25
$ expr 20 + 5 / 2
22

Joshuas Lösung : awk(kein interaktiver Modus):

$ calc() { awk "BEGIN{print $*}"; }
$ calc 1/3
0.333333

Andere mehr oder weniger tragbare Werkzeuge

Die Lösung von Arcegedc (interaktiver Modus :)dc :

Was noch mehr Spaß macht, da es in umgekehrter polnischer Notation funktioniert.

$ echo 20 5 2 / + p | dc 
22
$ echo 4 k 20 5 2 / + p | dc 
22.5000

Aber nicht so praktisch, es sei denn, Sie arbeiten viel mit umgekehrter polnischer Notation.

^{Beachten Sie, dass es dcälter ist bcund in bcder Vergangenheit als Wrapper implementiert wurde dc, dcjedoch nicht von POSIX standardisiert wurde}

DQdims 's calc(erforderlich sudo apt-get install apcalc):

$ calc 2 + 4
6

Allzwecksprachdolmetscher:

manatworks lösung, node(interaktiver modus :; ausgabefunktionnode nicht erforderlich):

$ node -pe 20+5/2  # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
22.5

Perl (interaktiver Modus:) perl -de 1:

$ perl -E "say 20+5/2"
22.5

Python (interaktiver Modus python:; Ausgabefunktion nicht erforderlich):

$ python -c "print(20+5/2)"
22 # 22.5 with python3
$ python -c "print(20+5/2.0)"
22.5

Unterstützt auch beliebige Präzisionszahlen:

$ python -c 'print(2**1234)'
295811224608098629060044695716103590786339687135372992239556207050657350796238924261053837248378050186443647759070955993120820899330381760937027212482840944941362110665443775183495726811929203861182015218323892077355983393191208928867652655993602487903113708549402668624521100611794270340232766099317098048887493809023127398253860618772619035009883272941129544640111837184

Wenn Sie clispinstalliert haben, können Sie auch die polnische Notation verwenden:

$ clisp -x "(+ 2 2)"

Marcos Lösung lua(interaktiver Modus:) lua:

$ lua -e "print(20+5/2)"
22.5

PHP (interaktiver Modus:) php -a:

$ php -r 'echo 20+5/2;'
22.5

Ruby (interaktiver Modus irb:; Ausgabefunktion nicht erforderlich):

$ ruby -e 'p 20+5/2'
22
$ ruby -e 'p 20+5/2.0'
22.5

Guile (interaktiver Modus :)guile :

$ guile -c '(display (+ 20 (/ 5 2)))'
45/2
$ guile -c '(display (+ 20 (/ 5 2.0)))'
22.5

S-Lang (interaktiver Modus slsh:; Ausgabefunktion nicht erforderlich, nur ein ;Abschlusszeichen):

$ slsh -e 'printf("%f",20+5/2)'
22.000000
$ slsh -e 'printf("%f",20+5/2.0)'
22.500000

Tcl (interaktiver Modus tclsh:; Ausgabefunktion wird nicht benötigt, ist aber expr):

$ tclsh <<< 'puts [expr 20+5/2]'
22
$ tclsh <<< 'puts [expr 20+5/2.0]'
22.5

Javascript- Shells:

$ smjs
js> 25/3
8.333333333333334
js>

$ jspl
JSC: 25/3

RP: 8.33333333333333
RJS: [object Number]
JSC:
Good bye...

$ node
> 25/3
8.333333333333334
>

Verschiedene SQL's:

SQLite (interaktiver Modus :)sqlite3 :

$ sqlite3 <<< 'select 20+5/2;'
22
$ sqlite3 <<< 'select 20+5/2.0;'
22.5

MySQL :

mysql -BNe 'select 1+1'

PostgreSQL :

psql -tAc 'select 1+1

_Die Optionen für mysql und postgres stoppen das 'ASCII Art'-Image!

Spezialisierte mathematisch orientierte Sprachen:

R im normalen Modus - Lässt 1000 normale Zufallszahlen generieren und die Standardabweichung abrufen und ausdrucken

$ R -q -e 'print(sd(rnorm(1000)))'
> print(sd(rnorm(1000)))
[1] 1.031997

R mit dem kleinen Skript - Lässt pi im Quadrat drucken

$ r -e 'cat(pi^2, "\n")'
9.869604
$  r -e 'print(sum(1:100))'
[1] 5050

PARI / GP , ein umfangreiches Computeralgebrasystem für Zahlentheorie, lineare Algebra und viele andere Dinge

$ echo "prime(1000)"|gp -q
7919                        // the 1000th prime
$ echo "factor(1000)" | gp -q
[2 3]
[5 3]                       // 2^3*5^3
$ echo "sum(x=1,5,x)" | gp -q
15                          // 1+2+3+4+5

GNU Octave (eine hochinterpretierte Sprache, die hauptsächlich für numerische Berechnungen gedacht ist)

Unterstützt auch komplexe Zahlen:

$ octave
>> 1.2 / 7
ans =  0.17143
>> sqrt(-1)
ans =  0 + 1i

Julia , Hochleistungssprache und Dolmetscherin für wissenschaftliches und numerisches Rechnen.

Nicht interaktive Option:

$ julia -E '2.5+3.7'
6.2

Es gibt viele Möglichkeiten zu berechnen. Für einfache Ausdrücke können Sie sich bashselbst verwenden:

echo $((20+5))

oder expr:

expr 20 + 5

Und für komplexe Fälle gibt es ein großartiges Werkzeug bc:

echo "20+5" | bc

Übrigens kann bc auch sehr komplexe Ausdrücke mit Wurzeln, Logarithmen, cos, sin usw. berechnen.

Die genannten Lösungen eignen sich für sehr einfache Berechnungen, sind aber sehr fehleranfällig. Beispiele:

# without spaces expr 20+5 produces literally 20+5
expr 20+5
→ 20+5

# bc's result doesn't give the fractional part by default
bc <<< 9.0/2.0
→ 4

# expr does only integer
expr 9 / 2
→ 4

# same for POSIX arithmetic expansion
echo $((9/2))
→ 4

# bash arithmetic expansion chokes on floats
echo $((9.0/2.0))
→ bash: 9/2.0: syntax error: invalid arithmetic operator (error token is ".0")

# Most `expr` implementations also have problems with floats
expr 9.0 / 2.0
→ expr: non-integer argument

Ein Syntaxfehler wie der letzte wird leicht bemerkt, aber ganzzahlige Antworten mit einem verworfenen Float-Teil können leicht unbemerkt bleiben und zu falschen Ergebnissen führen.

Deshalb benutze ich immer eine Skriptsprache wie Lua. Sie können jedoch jede Ihnen vertraute Skriptsprache auswählen. Ich benutze nur Lua als Beispiel. Die Vorteile sind

• eine vertraute Syntax
• vertraute Funktionen
• bekannte Vorbehalte
• flexible Eingabe
• Leerzeichen spielen normalerweise keine Rolle
• Gleitkomma-Ausgabe

Beispiele:

lua -e "print(9/2)"
→ 4.5

lua -e "print(9 / 2)"
→ 4.5

lua -e "print(9.0/2)"
→ 4.5

lua -e "print (9 /2.)"
→ 4.5

lua -e "print(math.sqrt(9))"
→ 3

Hat noch niemand awk erwähnt?

Definieren Sie mit POSIX-Shell-Funktionen und awk math power einfach diese (einzeilige) Funktion:

calc(){ awk "BEGIN { print $*}"; }

Dann führen Sie einfach Dinge wie calc 1+1oder auscalc 5/2

Hinweis: Damit die Funktion immer verfügbar ist, fügen Sie sie zu ~ / .bashrc (oder der Startdatei Ihrer entsprechenden Shell) hinzu.

Natürlich ein kleines Skript namens "calc" mit folgendem Inhalt:

#!/bin/sh -
awk "BEGIN { print $* }"

könnte auch funktionieren.

Du könntest es gebrauchen bc. Z.B,

$ echo "25 + 5" | bc
30

Alternativ bc <<< 25+5klappt das auch.

Oder interaktiv, wenn Sie mehr als nur eine einfache Berechnung durchführen möchten:

$ 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'. 
25 + 5
30

Die GNU-Implementierung von gibt bcdiese Header- / Copyright-Informationen beim Start aus, wenn sowohl stdin als auch stdout an ein Terminal gesendet werden. Sie können es mit der (GNU-spezifischen) -qOption unterdrücken . Weitere Informationen finden Sie auf der bc-Manpage

Sie können verwenden calc:

Wenn Sie nur calcohne weitere Argumente eingeben, wird ein interaktiver Modus aufgerufen, in dem Sie einfach weiter rechnen können. Sie beenden dies, indem Sie exit eingeben:

C-style arbitrary precision calculator (version 2.12.3.3)
Calc is open software. For license details type:  help copyright
[Type "exit" to exit, or "help" for help.]

; 2+4
6
; 3+5
8
; 3.4+5
8.4
; 2^4
16
; exit

Oder Sie verwenden es mit dem Ausdruck als Argument und es liefert die Antwort und beendet dann

$calc 2 + 4
    6
$

calcist ähnlich wie bc, ich mag nur die Art und Weise, wie es sich als Standard besser verhält

Ich starte gerne Python und verwende es als interaktiven Taschenrechner (aber ich bin auch ein Python-Programmierer).

Da es von niemand anderem erwähnt wurde und es sich nicht ausschließlich um einen Taschenrechner handelt (es handelt sich jedoch auch nicht um all diese Allzweck-Skriptsprachen), möchte ich Folgendes erwähnen units:

$ units "1 + 1"
        Definition: 2
$ units "1 lb" "kg"
        * 0.45359237
         / 2.2046226

Oder für weniger Ausgabe, damit Sie nur die Nummer erhalten $(), mit der Sie etwas zuweisen können:

$ units -t "1 + 1"
2
$ units -t "1 lb" "kg"
0.4539237

Und es werden sogar Temperaturumrechnungen durchgeführt

$ units -t "tempC(20)" "tempF"
68

Gehen Sie folgendermaßen vor, um die Temperaturkonvertierung in einem Ausdruck für die weitere Berechnung abzurufen:

$ units -t "~tempF(tempC(20))+1"
68.1

$> ghc -e '20 + 5'
25
it :: Integer

Auch ghci, das ist der Glasgow-Haskell Compiler im interaktiven Modus ( ghc --interactiveim Gegensatz zu ihm einen Ausdruck mit Auswertung -e), sorgt für einen faszinierenden „Taschenrechner“:

$>ghci
GHCi, version 7.8.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> pi
3.141592653589793
Prelude> ceiling pi
4
Prelude> compare 1 2
LT

Ich kann nicht glauben, "die Macht von JavaScript" zu lesen (aber ich musste die Antwort für die anderen Teile positiv bewerten, außer natürlich für Perl.

In der Praxis verwende ich für die einfachen Fälle, in denen Integer-Arithmetik ausreicht, das buildin $ ((...)) und empfehle es. Andernfalls wird in fast allen Fällen das Echo "..." | bc ist ausreichend.

Für einige arithmetische Operationen wie Statistiken, Matrixoperationen und mehr Rist das bessere Werkzeug:

echo 25 + 5 | R --vanilla

und für kleine Datensätze und grafische Ergebnisse wegwerfen, oocalcist ein schönes Dienstprogramm.

Ich benutze ein kleines Python-Skript, das einen Python-Ausdruck auswertet und das Ergebnis ausgibt, dann kann ich so etwas wie ausführen

$ pc '[i ** 2 for i in range(10)]'
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Das Drehbuch lautet:

#!/usr/local/bin/python3

import sys
import traceback
from codeop import CommandCompiler

compile = CommandCompiler()
filename = "<input>"
source = ' '.join(sys.argv[1:]) + '\n'

try:
    code = compile(source, filename) 
except (OverflowError, SyntaxError, ValueError):
    type, value, sys.last_traceback = sys.exc_info()
    sys.last_type = type
    sys.last_value = value
    if filename and type is SyntaxError:
        # Work hard to stuff the correct filename in the exception
        try:
            msg, (dummy_filename, lineno, offset, line) = value.args
        except ValueError:
            # Not the format we expect; leave it alone
            pass
        else:
            # Stuff in the right filename
            value = SyntaxError(msg, (filename, lineno, offset, line))
            sys.last_value = value
    lines = traceback.format_exception_only(type, value)
    print(''.join(lines))
else:
    if code:
        exec(code)
    else:
        print('incomplete')

Leider kann ich mich nicht erinnern, woher ich den größten Teil des Codes ausgeliehen habe, daher kann ich ihn nicht zitieren.

Gnuplot

gnuplot - ein interaktives Plotprogramm
Folgen Sie dem obigen Link oder geben Siegnuplotdie Eingabeaufforderunghelpim gnuplot- Interpreter ein.
Gnuplot ist ein Programm zum Zeichnen von Daten, kann aber auch zur Berechnung verwendet werden. Es bietet den Vorteil, dass Sie Funktionen definieren und / oder die eingebauten verwenden können.

echo  "pr 20+5/2"  |  gnuplot          #  Lazy-note `pr` instead of print
22                                     #  Integer calculation & result
echo  "pr 20.+5/2"  |  gnuplot         #  Lazy-note `pr` instead of print
22.0                                   #  Floating point result
echo  "pr sin(2*pi/3.)"  |  gnuplot    #  Some functions ...
0.866025403784439

Root (oder ein anderer C-Interpreter )

Das ROOT-System bietet eine Reihe von OO-Frameworks mit allen Funktionen, die für die effiziente Verarbeitung und Analyse großer Datenmengen erforderlich sind ...

Sie können es als C-Interpreter , CINT oder als einen der vielen anderen C-Interpreter verwenden . IMHO, es ist riesig, komplex, mächtig und nicht immer freundlich, kann aber auch große Befriedigung geben.

Wenn du die kleine Stimme in dir, die Confucio zitiert, wirklich nicht hören willst und bereit bist , eine (Butter-) Fliege auf dem Rad zu zerbrechen, kannst du root verwenden . In diesem Fall -list zwingend zu vermeiden, Splash-Screen zu zeigen ...

echo  "20+5/2"   | root -l
(const int)22
echo  "20+5/2."  | root -l
(const double)2.25000000000000000e+01

echo  "cout<< 20+5/2 << endl;"   | root -l
22

Für ganzzahlige Arithmetik (wobei 3/2 = 1)

• bash echo $(( 1+1 ))
• fish math 1+1
• zsh* echo $((1+1))

*: und ksh93, yash

Für Gleitkomma-Arithmetik (wobei 3/2 = 1,5)

• bash awk "BEGIN {print 10/3}" (geringe Präzision)
• bash echo "10/3"|bc -l (hohe Präzision)
• fish math -s4 10/3
• zsh* echo $((10./3))

*: und ksh93, yash

Sie können Ihre Shell natürlich so konfigurieren, dass awk mit minimaler Eingabe wie folgt verwendet wird calc 10/3(siehe Hinweise zur Vorgehensweise für Bash ¹ und Fish ² ).

Der Hauptgrund für die Empfehlung von awk für bash ist, dass es auf fast allen Unix-ähnlichen Betriebssystemen vorinstalliert ist und einigermaßen leicht ist (natürlich sind die Kosten für das Starten eines Prozesses hoch) mit einer weniger präzisen, aber benutzerfreundlicheren Ausgabe als bc -lder Ausgabe von 20 Dezimalstellen Stellen (obwohl Sie sicherlich awk zwicken können, um mehr Dezimalstellen zu erhalten ).

Anmerkungen

(1) Verwendung der vereinfachten Syntax in Bash

Fügen Sie diese Bash-Funktion hinzu zu ~/.bashrc:

calc(){ awk "BEGIN { print $*}"; }

(2) Verwendung der vereinfachten Syntax in Fischen

Erstellen Sie eine calcFischfunktion (dh eine Textdatei mit dem Namen /home/ndemou/.config/fish/functions/calc.fish):

function calc
    awk "BEGIN{ print $argv }" ;
end

Für Konsolenberechnungen verwende ich concalc. ( sudo aptitude install concalc)

Geben Sie danach einfach ein concalc und drücken Sie die Eingabetaste. Es wird keine Eingabeaufforderung angezeigt, aber geben Sie einfach Ihre Berechnung ein (keine Leerzeichen) und drücken Sie die Eingabetaste. In der nächsten Zeile wird der numerische Wert angezeigt.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

mysql -e 'select 1 + 1 from dual;'

PostgreSQL :

psql -c 'select 1 + 1 as sum;'

Verwenden Sie die GNU Multiple Precision Arithmetic Library über das mitgelieferte run-exprProgramm:

• Downloaden und extrahieren (Sie benötigen lzip): tar -xvf gmp-5.1.3.tar.lz
• Im obersten Verzeichnis ./configureund make(keine Installation erforderlich)
• In Demos / Ausdrucken make run-expr
• Ich erstelle gerne einen symbolischen Link dazu in meinem ~/binVerzeichnis:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Fügen Sie einen Alias ​​für die einfache Verwendung hinzu. zum Beispiel alias calcf='run-expr -f'zur Gleitkomma-Auswertung

Ausgabe:

# calcf '2/3'
"2/3" base 0: result 0.666666666666666666667e0

Aus der run-expr.cAkte:

Usage: ./run-expr [-z] [-q] [-f] [-p prec] [-b base] expression...

   Evaluate each argument as a simple expression.  By default this is in mpz
   integers, but -q selects mpq or -f selects mpf.  For mpf the float
   precision can be set with -p.  In all cases the input base can be set
   with -b, or the default is "0" meaning decimal with "0x" allowed.

Im Handbuch finden Sie Unterschiede und Einzelheiten zu Funktionsklassen.