Calculadora de línea de comandos simple

19

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.

Fabby
fuente
3
Si está con la intención de hacer esto de forma interactiva, usted no tiene que escribir quiten bc; presionar ctrl-Dservirá, como lo hará en cualquier programa interactivo.
marcelm
2
dces (IMO) muy superior a bc.
William Pursell el
1
¿ Creo que el espacio no asignado entre ptn 3 y 5 debería ser 236-192 y no 236-128?
Trauma digital el
@DigitalTrauma buen ojo! (¡Fue solo un ejemplo y nadie lo vio!)
Fabby
1
@JanM. Yo fui quien votó ... ;-)
Fabby

Respuestas:

33

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.

Stephen Kitt
fuente
2
bc<RET>236-128<RET>quit<RET>son 16 pulsaciones de teclas. bc<<<"236-128"<RET>son 15 pulsaciones de teclas. No es lo que yo llamaría "cantidad de tipeo muy reducida" :-) Además, bcse puede salir ^D, por lo que la primera opción se reduce a 13 pulsaciones de teclas (contando ^Dcomo dos).
L. Levrel
Correcto, se trata más de verbosidad ;-).
Stephen Kitt el
2
@ L.Levrel ¡Con la función c 1+1es justo lo que necesitaba! :-) (respuesta actualizada para
aclararlo
Y si haces coma flotante: c 'scale = 2; 17/3 '(o mejor, escale una variable utilizada dentro de la función' c () 'y defina su valor siempre que necesite tener n dígitos decimales. El valor predeterminado es 0.)
Olivier Dulac
1
En su lugar, utilícelo bc -len la definición de la función para hacerlo más capaz.
Isaac
22

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 63 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
Isaac
fuente
20

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.

Número 9
fuente
1
No es perfecto, pero es lo suficientemente bueno para un voto positivo. Malentendido corregido en chat y downvote eliminado por otro usuario . Eliminé mi propia respuesta (inferior) ... ;-)
Fabby
15

En zsh:

$ autoload zcalc # best in  ~/.zshrc
$ zcalc
1> 1+1
2
2> ^D
$ zcalc 5+5
1> 10
2>
Stéphane Chazelas
fuente
9

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

CSM
fuente
3
Es versátil: units -t -d 10 "236GB - 192GB" GBsalidas 44, units -t -d 15 "236GB - 192GB" bytessalidas 44000000000, etc.
agc
6

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

Max
fuente
¡Gracias! Excelente primera respuesta! +1
Fabby
2
$((...))se llama Expansión Aritmética y es parte de POSIX: pubs.opengroup.org/onlinepubs/9699919799/utilities/… Para mí, el mayor inconveniente de esta característica de un shell POSIX es que solo admite aritmética de enteros :(
pabouk
6

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
JoL
fuente
77
echo $((236 - 128))también funciona ;-).
Stephen Kitt
Evitar zsh: zsh -c 'print $((12345678901234567890123 + 1))' zsh:1: number truncated after 22 digits: 12345678901234567890123 + 1 -1363962815083169259.
Isaac
@Isaac al menos zsh te dice que se está truncando; bash solo te da una respuesta incorrecta sin quejarte.
Stephen Kitt
@StephenKitt El problema con zsh es más complejo de lo que muestra una salida. Comparar: zsh -c 'print $((12345678901234567890123 + 1))'y zsh -c 'print $((123456789012345678901 + 1))'. Se está truncando a diferentes longitudes y produciendo diferentes resultados numéricos.
Isaac
@StephenKitt En cambio, Bash sigue el manual (y el lenguaje C sobre el desbordamiento de un int firmado). No es que personalmente me guste, pero está documentado como tal. Pruebe bash -c 'echo $((1<<63))'y `` bash -c 'echo $ (((1 << 63) -1))' '.
Isaac
6

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'.

Gavilán
fuente
Leí el TOC del manual pero no pude encontrar nada sobre CLI. (+1 mientras tanto)
Fabby
1
Gracias @Fabby. Me confundí, y la parte de CLI es en realidad un poco diferente. He actualizado la respuesta para aclarar.
Sparhawk el
¡Ojalá pudiera votarte dos veces! ;-)
Fabby
4

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
>>>
Michael Hearn
fuente
¡No, no realmente, pero de todos modos es una buena idea! :-) +1
Fabby
Powershell también puede hacer lo mismo
phuclv
1
@phuclv sí, pero a nadie le gusta PS
Dev
3
@Dev toneladas de personas Unix aman PS
phuclv
2

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.

Aaron Thomas
fuente
Sí, eché un vistazo de 3 minutos a la Calculadora de escritorio y supe que no era para mí: era un TI, no un estudiante de HP.
Fabby
2

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.

Bill K
fuente
¡No, no realmente, pero de todos modos es una buena idea! :-) +1
Fabby
2

¿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
Jan M.
fuente
1
prueba ... Graag gedaan ... :-D
Fabby
2

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

Fabby
fuente
1
(1) Decidí usarlo echo "$*" | bc -lcomo el shebang que usaste /bin/shy no sé si tienes ksh / bash / zsh disponible. (2) Tenga en cuenta que puede cambiar la escala para calcular si ejecuta 'c' scale = 60; 777/333 ', por ejemplo. Espero que ayude @Fabby
Isaac
1

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!

AHJeebon
fuente
0

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í.

sjas
fuente
-1

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
WinEunuuchs2Unix
fuente
Esto ya se discute en la respuesta de Isaac .
Stephen Kitt
@StephenKitt Sí, voté por la respuesta muy detallada de Isaac. Pensé que sería útil un resumen que resuma algo de lo que publicó. El ${1}uso del parámetro es exclusivo de todas las respuestas.
WinEunuuchs2Unix
2
Te animo a que analices las razones por las que otras respuestas no usan ${1};-)
Stephen Kitt