Problema:

De vez en cuando necesito hacer operaciones aritméticas simples en un entorno de línea de comandos. EG dado el siguiente resultado:

Disk /dev/sdb: 256GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags: 

Number  Start   End     Size    File system     Name  Flags
 1      1049kB  106MB   105MB   fat32                 hidden, diag
 2      106MB   64.1GB  64.0GB  ext4
 3      64.1GB  192GB   128GB   ext4
 5      236GB   256GB   20.0GB  linux-swap(v1)

¿Cuál es una manera simple de calcular en la línea de comando el tamaño del espacio no asignado entre las particiones 3 y 5?

Lo que ya he probado:

antes de Cristo

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'. 
236-192
44
quit

donde el negrita de arriba es todo lo que necesito escribir para hacer un simple 236-192como bc 1+1ecosFile 1+1 is unavailable.

expr

expr 236 - 192

donde necesito escribir espacios antes y después del operador como expr 1+1solo ecos 1+1.

Puede reducir en gran medida la cantidad de verbosidad involucrada en el uso de bc:

$ bc <<<"236-192"
44
$ bc <<<"1+1"
2

(suponiendo que su shell lo soporte).

Si prefieres tener eso como una función:

$ c() { printf "%s\n" "$*" | bc }
$ c 1+1
2

Almacene la cdefinición en su archivo de inicio de shell favorito si desea que esté siempre disponible.

Cáscara

El cálculo más simple en CLI es el CLI (shell) en sí (si IFSestá predeterminado):

$ echo $(( 22 + 333 ))
355

Se pueden omitir espacios:

$ echo $((22*333))
7326

Como es parte de POSIX, casi todos los shells lo tienen. E incluye la mayor parte de la funcionalidad matemática del lenguaje C (excepto que zsh tiene una precedencia diferente, establezca C_PRECEDENCES para restaurarlo a un valor compatible):

$ echo $((22*333^2))
7324

Y algunos shells tienen la mayor parte de la sintaxis matemática del lenguaje C (incluida la coma):

$ echo $((a=22,b=333,c=a*b,c))
7326

Pero es solo matemática entera (y generalmente menos de 2 ⁶³ en los sistemas operativos actuales) en algunos shells:

$ echo $((1234/3))
411

$ zsh -c 'echo $((2**63))'
-9223372036854775808

Algunas conchas podrían hacer matemática flotante:

$ ksh -c 'echo $((1234/3.0))'
411.333333333333333

$ ksh -c 'echo $((12345678901234567890123/3.0))'
4.11522630041152263e+21

Evite zsh (zcalc tiene problemas similares):

$ zsh -c 'echo $((12345678901234567890123 + 1))'
zsh:1: number truncated after 22 digits: 12345678901234567890123 + 1
-1363962815083169259

Te recomiendo evitar expr, a veces necesita escapes extraños:

$ expr 22 \* 333
7326

antes de Cristo

En el siguiente nivel está ( también POSIX ) bc(primo de RPN dc)

$ echo '22*333' | bc
7326

$ echo '22 333 * p' | dc
7326

La dc era de POSIX, pero se habían eliminado en 2017 .

Más corto si su shell lo admite:

$ bc <<<'22*333'
7326

O incluso:

$ <<<'22*333' bc
7326

Ambas son calculadoras de precisión arbitrarias con algunas funciones matemáticas internas:

$ bc <<<2^200
1606938044258990275541962092341162602522202993782792835301376

$ echo 's(3.1415/2)' | bc -l        # sine function
.99999999892691403749

awk

Después de esas herramientas de cálculo realmente básicas , debe pasar a otros idiomas

$ awk "BEGIN {print (22*33)/7}"
103.714

$ perl -E "say 22*33/7"
103.714285714286

$ python3 -c "print(22*33/7)"
103.71428571428571

$ php -r 'echo 22*33/7,"\n";'
103.71428571429

función

Puede definir una función de cualquiera de las opciones anteriores:

c () 
{ 
    local in="$(echo " $*" | sed -e 's/\[/(/g' -e 's/\]/)/g')";
    gawk -M -v PREC=201 -M 'BEGIN {printf("%.60g\n",'"${in-0}"')}' < /dev/null
}

Y use:

$ c 22* 33 /7                   # spaces or not, it doesn't matter.
103.714285714285714285714285714285714285714285714285714285714

Al leer los comentarios de esta página , veo un programa UNIX / Linux llamado calcque hace exactamente lo que quieres. Si está en Debian / Ubuntu / derivados:

sudo apt-get install apcalc

entonces tú puedes:

calc 236-192

y si agregas un alias alias c='calc'a tu .bashrco /etc/bash.bashrcsimplemente se convierte en:

c 1+1

en la línea de comando.

En zsh:

$ autoload zcalc # best in  ~/.zshrc
$ zcalc
1> 1+1
2
2> ^D
$ zcalc 5+5
1> 10
2>

El unitsprograma, aunque no está destinado a ser utilizado como una calculadora, en realidad funciona bastante bien como tal.

$ units "236-192"
    Definition: 44
$ 

Si hay espacios en la expresión, entonces la expresión debe estar protegida por comillas.
Admite exponenciales y anidamiento profundo de corchetes

Como se comentó en un comentario a una respuesta anterior, el shell estándar (ba) sh permite evaluar las expresiones aritméticas dentro $((...)). No pude verificar dos veces si esto es parte del estándar POSIX, pero verifiqué que también funciona en Cygwin y el shell Mingw32.

Para ver el resultado, tendría que escribir echo $((...)), lo que hace que algunos caracteres sean más que (uso interactivo de) bc. Sin embargo, para usar el resultado en un script, esto probablemente será más corto que la bcsolución (que podría ser, por ejemplo `echo ...|bc`).

En cuanto a la verbosidad, el bccomando permite la opción -qque suprime la salida de la " bcbienvenida normal de GNU " .

Como comentario final, ligeramente límite, tengamos en cuenta que bcno es solo una calculadora, sino más bien un lenguaje de programación completo (incluidas las funciones definidas por el usuario, while y for loops, etc.). Otro hecho que sugiere preferir las capacidades aritméticas integradas para cálculos tan simples, en lugar de un programa externo. Dicho esto, extraer los datos para los números de partición dados y tratar con los sufijos "M", "G", como parecía preguntar la pregunta original, podría requerir (g)awkmás que bc.

Fuentes: https://www.gnu.org/software/bc/manual/html_mono/bc.html https://www.gnu.org/software/gawk/manual/html_node/Getting-Started.html

Lo que hago en zsh es:

$ <<< $(( 236 - 192 ))
44

En bash, tendría que mencionar explícitamente cat:

$ cat <<< $(( 236 - 192 ))
44

Si quisiera que el resultado incluyera dígitos fraccionarios (funciona en zsh, no en bash), agregaría un punto de raíz a uno de los operandos

$ <<< $(( 236 / 128 )) 
1
$ <<< $(( 236. / 128 ))
1.84375

Personalmente, me gusta libqalculate (la versión de línea de comandos de Qalculate ).

$ qalc
> 236-192

  236 - 192 = 44

Si bien la interfaz es ciertamente simple, (lib) qalculate es una calculadora potente y completa. p.ej

> fibonacci(133) to hex

  fibonacci(133) = approx. 0x90540BE2616C26F81F876B9

> 100!

  factorial(100) = approx. 9.3326215E157

> sin(pi)

  sin(pi * radian) = 0

También hace cosas útiles como completar pestañas, abrir / cerrar paréntesis cuando sea necesario e imprime su interpretación de la consulta.

> 18-2)/4

  (18 - 2) / 4 = 4

Para salir, simplemente presiono Ctrl + d.

Para un acceso aún más rápido, configúrelo en algo como alias ca='qalc'.

Python abierto en otra pestaña?

Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)] on 
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 3+3
6
>>>

dc -e '236 192-p'

... por supuesto, si no está familiarizado dcy necesita más que restar dos números, pasará más tiempo buscando cómo usar dc(y tal vez RPN en general) de lo que ahorrará con métodos más familiares.

Si tienes instalado Gradle, entonces tienes maravilloso ...

Si Groovy está correctamente aplicado, deberías poder usar:

groovy -e "println 1+1"

Esto puede parecer un poco redundante con todos los otros ejemplos, pero:

• Groovy es un lenguaje poderoso
• posiblemente el mejor soporte de biblioteca disponible
• funciones matemáticas potentes y simples (como las matemáticas de precisión arbitraria)
• utiliza stdout redirigible para su salida, por lo que es increíblemente flexible (excelente para usar dentro de archivos por lotes con backticks `` y similares).

Si no tiene Java instalado, probablemente no valga la pena instalar groovy & java; es solo una opción si Groovy ya está disponible.

¿Has probado concalc ?

Descripción: console calculator concalc es una calculadora para la consola Linux. Es solo el algoritmo analizador de extcalc empaquetado en un simple programa de consola. Puede usarlo si necesita una calculadora en su caparazón. Concalc también puede ejecutar scripts escritos en un lenguaje de programación tipo C.

$ concalc 1+1
2
$ concalc sqrt2
1.41421356237309505

Instalar con:

sudo apt-get install concalc

Antes de publicar cualquiera de las otras respuestas brillantes, terminé creando el script que /usr/local/bin/ccontenía:

#!/bin/sh
IFS=' '               # to be on the safe side, some shells fail to reset IFS.
if [ "$#" -eq 0 ];  then
    echo "$(basename "$0"): a (very) simple calculator."
    echo "type $(basename "$0") expression to evaluate (uses bc internally)"
fi

printf '%s\n' "$*" | bc -l  # safe for most shells
                            # we may use 'bc -l <<<"$*"` for ksh, bash, zsh

entonces: escribiendo c 1+1rendimientos 2! :-)

Nota 1: Utilicé cporque ese comando no existe en ningún sistema Unix que pude encontrar. Si hubieras alias eso a tu compilador de c, usa cualquier otra cosa que sea corta y no la uses.
Nota 2: Fuente

Si Python está instalado, puede realizar muchas operaciones matemáticas a través de la línea de comandos. Traté de proporcionar un ejemplo a continuación.

He usado python3, puedes usar python. La diferencia entre pythony python3ocurre cuando se produce una operación dividida (fraccionada), para evitar el problema, consulte a continuación python vs python3 .

Nota: La última versión de Linux dist viene con Python 2.7 y Python 3.5 de forma predeterminada. En caso de que sea necesario instalar Python, haga clic aquí .

Sumar, restar, multiplicar y dividir:

$ python3 <<< "print(12+3)"
15
$ python3 <<< "print(12-3)"
9
$ python3 <<< "print(12*3)"
36
$ python3 <<< "print(12/3)"
4

Módulo-resto de la división:

$ python3 <<< "print(14%3)"
2

División de piso:

$ python3 <<< "print(14//3)"
4

Exponente - x a la potencia de y (x ^ y):

$ python3 <<< "print(3**2)"
9

Raíz cuadrada (ej .: √4 = 2):

$ python3 <<< "print(4**0.5)"
2

Parte más científica, necesitará una biblioteca matemática importada . Ex:

El logaritmo natural de x = log (x):

$ python3 <<< "import math; print(math.log(4))"
1.386294361119890e6

El logaritmo de base 10 de x = log10 (x):

$ python3 <<< "import math; print(math.log10(10))"
1.0

Factorial (ej: 3! = 3.2.1 = 6):

$ python3 <<< "import math; print(math.factorial(3))"
6

Trigonometry- sin(x), cos(x), tan(x):

$ python3 <<< "import math; print(math.sin(90))"
0.8939966636005579

Para ver más funciones relacionadas con las matemáticas, consulte aquí .

pythonVs python3:

-Para dividir: (usar flotante):

$ python <<< "print(10.0/3)"
3.33333333333

-en lugar de

$ python <<< "print(10/3)"
3

También puedes usar terminal directo:

$ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34) 
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+3
4
>>> import math
>>> math.log10(4)
0.6020599913279624
>>> math.sqrt(4)
2.0
>>> 

Eso es. ¡Feliz codificación!

Ya sea bco qalc.

Para tener automáticamente un bcredondeo siempre a dos dígitos: (ejecutarlo -les difícil de manejar para el día a día)

Edita tu ~/.bashrc:

alias bc="BC_ENV_ARGS=<(echo "scale=2") \bc"

Abre un nuevo shell y corre bcallí.

Crear una línea:

$ c () { echo $(( ${1} )) }

Ahora puede usar matemáticas enteras simples:

$ c 1+1
2

$ c 25*4
100

$ c 25*4-10
90

$ c 20*5/4
25