777106_es-ES

liliconcom

Extraer Expr

Soy un gran admirador de Eval(Substitute(Expr(...), Expr(..), Expr(.)))

: )

La única desventaja: Expr(...), Expr(..), Expr(.)

... lo que me llevó a la idea de subst() - sustituto() 2.0 ... una función que no evalúa sus argumentos.

Mientras jugaba con el manejo de expresiones, noté que la lógica deseada para Subst() es bastante cercana a la de Extract Expr(): no es necesario usar Expr(), y Name Expr() se aplica siempre que sea posible:

Names Default to here(1);
// direct mode, no Expr necessary
Extract Expr(x^2 + y, x);// -> x
Extract Expr(x^2 + y, c);// no c in x^2 + y ->  empty

// Name Expr mode
c=Expr(x^2);
Extract Expr(x^2 + y , c);// looks up c = x^2, find "x^2"" in x^2 +y

¡Maravilloso!

... hasta que:

Extract Expr(cc * d , cc); // -> cc
cc=Expr(x^2);
Extract Expr(cc * d, cc);// looks up cc = x^2 , so doesn't find cc in cc * d anymore

Peligroso ...

Después de definir cc como un símbolo con un nombre expr , ¿todavía es posible usar c "literalmente" en Extract Expr ?

Extract Expr(cc * d , Expr(cc)); // doesn't work
Extract Expr(Expr(cc) , Expr(cc)); // finds Expr(cc)
Extract Expr(cc , Name Expr(Expr(cc))); // -> empty
Extract Expr(Name Expr(Expr(cc)) , Name Expr(Expr(cc))); // finds Name Expr(Expr(cc)), argh!

incluso:

cc=Expr(x^2);
clear symbols(cc);
Extract Expr(cc * d , cc); //->  empty()

Automatización y secuencias de comandosRe: Extraer Expr

tal vez:

use una función personalizada como contenedor para Extract Expr

Names default to here(1);
dummy=Function ({expression, pattern},
Extract Expr(expression, pattern);
);

cc = Expr(x^2);
dummy( Expr(cc+d), Expr(cc)); // -> cc

Re: Extraer Expr

¿Hay algo para lo que estás buscando respuestas? ¿También ha leído la Guía de secuencias de comandos sobre expresiones Guía de secuencias de comandos > Métodos de programación > Expresiones, macros y listas avanzadas: expresiones avanzadas y especialmente las partes sobre cómo se evalúan?

Re: Extraer expresión

En la página vinculada no encontré más información sobre ExtractExpr()

@jthi escribió:

¿Hay alguna cosa que estés buscando respuestas?

---

¿Cómo asegurarse de que JMP busque cc en la expresión cc*d ?
... incluso si cc se usa como nombre para otra expresión, como x^2.

Extract Expr(cc * d , cc); // -> cc
cc=Expr(x^2);
Extract Expr(cc * d, cc);// looks up cc = x^2 , so doesn't find cc in cc * d anymore

y más general:
Una función personalizada SIEMPRE evalúa sus argumentos y mediante Expr() se puede evitar que lo haga.
Extraer expresión SIEMPRE recupera la expresión no evaluada detrás de un nombre (si hay uno) antes de usarlo: ¿puede el usuario evitar que lo haga?

Los comandos de plataforma a menudo se ven alterados cuando se usan nombres como argumentos, y Evaluar podría solucionar el problema.

¿Cuántas categorías de manejo de argumentos hay en total en JSL? ¿Hay alguna línea roja detrás?

Re: Extraer Expr

¿Por qué usarías el mismo nombre de variable en varios lugares como ese?

Eliminar símbolos() y Borrar símbolos() no son lo mismo

Names Default To Here(1);

cc = Expr(x ^ 2);
Delete Symbols(cc);
Extract Expr(cc * d, cc);

Re: Extraer Expr

Gracias por el enlace.

Ver más...

Parece que Extract Expr() funciona de manera diferente según cómo se defina cc. Para usar cc literalmente, evita reasignarlo con Expr() o usa Name Expr() para administrar los símbolos con cuidado y evitar problemas de evaluación. Estaba luchando con un trabajo difícil, así que recurrí a https://domypaper.com/ El servicio fue excelente. El escritor estaba bien informado, siguió mis instrucciones cuidadosamente y entregó un trabajo bien organizado y de alta calidad. La comunicación fue fluida y el trabajo se entregó a tiempo. Estoy extremadamente satisfecho con los resultados y definitivamente usaría este servicio nuevamente para futuras tareas.