dc (programa informático)

Además de estas operaciones aritméticas y de pila básicas, dc incluye soporte para macros , condicionales y almacenamiento de resultados para su posterior recuperación.

El mecanismo subyacente a las macros y condicionales es el registro , que en dc es una ubicación de almacenamiento con un nombre de un solo carácter que se puede almacenar y recuperar: scextrae la parte superior de la pila y la almacena en el registro c, y lccoloca el valor del registro c en la pila. Por ejemplo:

3 sc 4 ​​lc * p 

Los registros también pueden tratarse como pilas secundarias, por lo que los valores pueden insertarse y extraerse entre ellos y la pila principal utilizando los comandos Sy .L

Los valores de cadena se encierran entre [caracteres ]y pueden colocarse en la pila y almacenarse en registros. El acomando convierte el byte de menor orden del valor numérico en un carácter ASCII , o si la parte superior de la pila es una cadena, la reemplaza con el primer carácter de la cadena. No hay forma de construir cadenas ni de manipularlas, salvo ejecutándolas con el xcomando o imprimiéndolas con el Pcomando.

El #personaje comienza un comentario hasta el final de la línea.

Las macros se implementan permitiendo que los registros y las entradas de la pila sean tanto cadenas como números. Una cadena se puede imprimir, pero también se puede ejecutar (es decir, procesar como una secuencia de comandos dc). Por ejemplo, podemos almacenar una macro para sumar uno y luego multiplicar por 2 en el registro m:

[1 + 2 *] sm 

y luego (usando el xcomando que ejecuta la parte superior de la pila) podemos usarlo así:

3 lm xp 

Finalmente, podemos usar este mecanismo de macros para proporcionar condicionales. El comando =rextrae dos valores de la pila y ejecuta la macro almacenada en el registro rsolo si son iguales. Por lo tanto, esto imprime la cadena equalsolo si los dos valores superiores de la pila tienen el mismo valor:

[[igual]p] sr 5 5 =r 

Otras condiciones son >, !>, <, !<, !=, que ejecutan la macro especificada si los dos valores superiores de la pila son mayores, menores o iguales que ("no mayor que"), menores que, mayores o iguales que ("no menor que") y distintos de, respectivamente. Nótese que el orden de los operandos en las comparaciones de desigualdad es el opuesto al orden para la aritmética; 5 3 -se evalúa como 5 - 3 = 2, pero ejecuta el contenido del registro porque .5 3 <tt3 < 5

El bucle se puede crear definiendo una macro que se reinicie (condicionalmente). Un factorial simple del elemento superior de la pila podría implementarse de la siguiente manera:

# F(x): ¡devuelve x! # si x-1 > 1 # devolver x * F(x-1) # de lo contrario # devolver x [d1-d1<F*]dsFxp 

El 1Qcomando sale de una macro, lo que permite un retorno anticipado. qSale de dos niveles de macros (y del propio dc si hay menos de dos niveles en la pila de llamadas). zEmpuja la profundidad actual de la pila antes de la zoperación.

Esto se implementa con una macro almacenada en un registro aque se llama a sí misma condicionalmente, realizando una suma cada vez, hasta que solo queda un valor en la pila. El zoperador se utiliza para insertar en la pila el número de entradas que hay en ella. El operador de comparación >extrae dos valores de la pila al realizar la comparación.

dc -e "1 2 4 8 16 100 0d[+z1<a]dsaxp"

Y el resultado es 131.

Un número simple es una expresión DC válida, por lo que se puede usar para sumar un archivo donde cada línea contiene un solo número.

Esto se implementa nuevamente con una macro almacenada en un registro aque se llama a sí misma de forma condicional, realizando una suma cada vez, hasta que solo queda un valor en la pila.

dc -e "0d[?+z1<a]dsaxp" < archivo 

El ?operador lee otro comando del flujo de entrada. Si la línea de entrada contiene un número decimal, ese valor se agrega a la pila. Cuando el archivo de entrada llega al final, el comando es nulo y no se agrega ningún valor a la pila.

{ echo "5" ; echo "7" ; } | dc -e "0d[?+z1<a]dsaxp"

Y el resultado es 12.

Las líneas de entrada también pueden ser comandos dc complejos.

{ echo "3 5 *" ; echo "4 3 *" ; echo "5dd++" ; } | dc -e "0d[?+z1<a]dsaxp"

Y el resultado es 42.

Tenga en cuenta que, dado que dc admite precisión arbitraria, no hay que preocuparse por el desbordamiento numérico o la pérdida de precisión, independientemente de la cantidad de líneas que contenga el flujo de entrada, a diferencia de una solución igualmente concisa en AWK .

Las desventajas de esta solución son: el bucle se detiene al encontrar una línea en blanco en el flujo de entrada (técnicamente, cualquier línea de entrada que no agregue al menos un valor numérico a la pila); y, para manejar números negativos, las instancias iniciales de '-' para denotar un signo negativo deben cambiarse a '_' en el flujo de entrada, debido al signo negativo no estándar de dc. El ?operador en dc no proporciona una forma clara de distinguir la lectura de una línea en blanco de la lectura del final del archivo.

Como ejemplo de un programa relativamente simple en dc, este comando (en 1 línea):

dc -e '[[Ingrese un número (metros), o 0 para salir]PAP]sh[q]sz[lhx?d0=zAk.0254/.5+0kC~1/rn[ pies ]Pn[ pulgadas]PAPdx]dx'

Convierte distancias de metros a pies y pulgadas; la mayor parte del programa se dedica a solicitar la entrada de datos, imprimir la salida en un formato adecuado y repetir el proceso para convertir otro número.

Como ejemplo, aquí se muestra una implementación del algoritmo euclidiano para hallar el MCD :

dc -e '??[dSarLa%d0<a]dsax+p' # versión más corta dc -e '[a=]P?[b=]P?[dSarLa%d0<a]dsax+[GCD:]Pp' # versión más fácil de leer

Calcular el factorial de un valor de entrada,${\displaystyle n!=\prod _{i=1}^{n}i}$

dc -e '?[q]sQ[d1=Qd1-lFx*]dsFxp'

También existen quines en el lenguaje de programación dc; programas que producen su código fuente como salida.

dc -e '[91Pn[dx]93Pn]dx' dc -e '[91PP93P[dx]P]dx'

dc -e '2p3p[dl!d2+s!%0=@l!l^!<#]s#[s/0ds^]s@[p]s&[ddvs^3s!l#x0<&2+lx]ds.x'

Este programa fue escrito por Michel Charpentier. Genera una secuencia de números primos. Cabe destacar que existe una versión más corta que requiere catorce símbolos menos.

dc -e '2p3p[pq]s$[l!2+ds!l^<$dl!%0<#]s#[+dvs^1s!l#x2l.x]ds.x'

dc -e '[n=]P?[p]s2[lip/dli%0=1dvsr]s12sid2%0=13sidvsr[dli%0=1lrli2+dsi!>.]ds.xd1<2'

Este programa también fue escrito por Michel Charpentier. ^{[ 7 ]}

Hay uno más corto

dc -e "[n=]P?[lfp/dlf%0=Fdvsr]sF[dsf]sJdvsr2sf[dlf%0=Flfdd2%+1+sflr<Jd1<M]dsMx"

y una solución más rápida (intente con el número de 200 bits 2 ²⁰⁰ -1 (entrada 2 200^1-)

dc -e "[n=]P?[lfp/dlf% 0=Fdvsr]sFdvsr2sfd2%0=F3sfd3%0=F5sf[dlf%0=Flfd4+sflr>M]sN[dlf%0=Flfd2+sflr>N]dsMx[p]sMd1<M"

Cabe señalar que esto último se puede acelerar aún más si el acceso a una constante se reemplaza por un acceso a un registro.

dc -e "[n=]P?[lfp/dlf%l0=Fdvsr]sF2s2dvsr2sf4s4d2%0=F3sfd3%0=F5sf[dlf%l0=Flfdl4+sflr>M]sN[dlf%l0=Flfdl2+sflr>N]dsMx[p]sMd1<M"

Implementación del algoritmo de Chudnovsky en el lenguaje de programación dc. El programa imprimirá aproximaciones cada vez mejores a medida que se ejecute. Sin embargo, dado que pi es un número trascendental, el programa continuará hasta que se interrumpa o se agoten los recursos de la máquina en la que se ejecuta.

dc -e '_640320[0ksslk3^16lkd12+sk*-lm*lhd1+sh3^/smlxlj*sxll545140134+dsllm*lxlnk/ls+dls!=P]sP3^sj7sn[6sk1ddshsxsm13591409dsllPx10005v426880*ls/K3-k1/pcln14+snlMx]dsMx'

Implementación rápida de la misma fórmula mediante el método de divide y vencerás, cuyo tamaño se duplica en cada iteración. Evalúa un número finito cuyas sumas resultan en un número racional exacto y realiza una única división y raíz cuadrada por iteración. Es rápida, pero su velocidad disminuye rápidamente a medida que aumenta el tamaño de la fracción.

dc -e '1Sk1SR13591409dSBSP426880dSQ4/3^9*SC[0r-]s-[lkE*1-k10005vlQ*lP/nAan0k]dSox[Lkd1+Skdd1+Sk3^lC*SQ2*1-d3*d*4-*dSR545140134LB+dSB*lk2%0=-SP]dszx[LRLRdLP*LPLQdLQ*SQ*+SP*SR]sc[d1-d0<yd0<yd0=z0=zlcx]sy0[lcxlox1+lyxllx]dslx'

Un ejemplo más complejo del uso de dc integrado en un script de Perl realiza un intercambio de claves Diffie-Hellman . Esto fue popular como bloque de firma entre los cypherpunks durante los debates de ITAR , donde el breve script podía ejecutarse solo con Perl y dc, programas omnipresentes en sistemas operativos tipo Unix: ^{[ 8 ]}

#!/usr/bin/env perl -- -export-a-crypto-system-sig Diffie-Hellman-2-lines ( $g , $e , $m ) = @ARGV , $m || die "$0 gen exp mod\n" ; print `echo "16dio1[d2%Sa2/d0<X+d*La1=z\U$m%0]SX$e"[$g*]\EszlXx+p | dc`

Una versión comentada es un poco más fácil de entender y muestra cómo usar bucles, condicionales y el qcomando para retornar desde una macro. Con la versión GNU de dc, el |comando se puede usar para realizar exponenciaciones modulares de precisión arbitraria sin necesidad de escribir la función X.

#!/usr/bin/env perlmi ( $g , $e , $m ) = map { "\U$_" } @ARGV ; die "$0 gen exp mod\n" unless $m ;print `echo $g $e $m | dc -e ' # Entrada y salida hexadecimal 16dio # Leer m, e y g desde stdin en una línea ?SmSeSg# Función z: devuelve g * cima de la pila [lg*]sz# Función Q: elimina la parte superior de la pila y devuelve 1 [sb1q]sQ# Función X(e): calcula recursivamente g^e % m # Es lo mismo que Sm^Lm%, pero maneja exponentes arbitrariamente grandes. # Pila en la entrada: e # Pila en la salida: g^e % m # Dado que e puede ser muy grande, esto usa la propiedad de que g^e % m == # si( e == 0 ) # devuelve 1 # x = (g^(e/2)) ^ 2 # si( e % 2 == 1 ) # x *= g # devuelve x % [  d 0=Q # devuelve 1 si e==0 (de lo contrario, pila: e)  d 2% Sa # Almacena e%2 en a (pila: e)  2/ # calcula e/2  lXx # llama a X(e/2)  d* # calcula X(e/2)^2  La1=z # multiplica por g si e%2==1  lm % # calcula (g^e) % m ] SXle # Cargar e del registro lXx # calcular g^e % m p # Imprimir el resultado '` ;

Si la variable de entorno DC_LINE_LENGTH existe y contiene un número entero mayor que 1 y menor que${\displaystyle 2^{16}-1}$La salida de dígitos numéricos (según la base de salida) se limitará a este valor, insertando posteriormente barras invertidas y saltos de línea. La longitud de línea predeterminada es 70. El valor especial 0 desactiva los saltos de línea.