Ya existen algunas opciones sobre cómo hacer esto (pero los subíndices de expresiones podrían ser útiles). Como mencioné en el elemento de la lista de deseos ( Indexación de expresiones: ayúdame a escalar el árbol de expresiones - Comunidad de usuarios de JMP ), JMP tiene Extract Expr() que usa Wild() y Wild List()
Names Default To Here(1);
myExpr = Expr(
gb = dt << Graph Builder(
Size(437, 413),
Graph Spacing(4),
Variables(X(:height), Y(:weight), Overlay(:sex)),
Elements(Points(X, Y, Legend(1)), Smoother(X, Y, Legend(2)))
)
);
yexpr = Extract Expr(myExpr, Y(Wild()));
variables_expr = Extract Expr(myExpr, Variables(Wild List()));
Names Default To Here(1);
myExpr = Expr(
gb = dt << Graph Builder(
Size(437, 413),
Graph Spacing(4),
Variables(X(:height), Y(:weight), Y(:height), Overlay(:sex)),
Elements(Points(X, Y, Legend(1)), Smoother(X, Y, Legend(2)))
)
);
variables_expr = Extract Expr(myExpr, Variables(Wild List()));
idx = 0;
For(i = 1, i <= N Arg(variables_expr), i++,
firstlevel = Arg(variables_expr, i); // could use Extract Expr
If(Head(firstlevel) == Expr(Y) & idx == 2,
secondlevel = Arg(firstlevel, 1);
);
);
show(secondlevel);
También hay otras cosas que puedes hacer (pero no estoy seguro de si deberías hacerlo)
Names Default To Here(1);
myExpr = Expr(
Variables(X(:height), Y(:weight), Y(:height), Overlay(:sex))
);
listconversion = Substitute(Name Expr(myExpr), Expr(Variables()), Expr(List()));
yexprs = {};
While(yexpr = Contains(listconversion, Extract Expr(listconversion, Y(Wild()))),
Insert Into(yexprs, Remove From(listconversion, yexpr));
);
show(yexprs);
yexprs[2];
Podría haber otras cosas raras que podrías hacer con las listas...
Expresiones, macros y listas avanzadas (jmp.com) puede ser una buena lectura
Esta publicación nació como una entrada de lista de deseos, pero resulta que el deseo ya es parcialmente posible (ver la respuesta de @jthi a continuación).
Así que lo moví aquí para que los resultados fueran más visibles.
El deseo original, que pide una funcionalidad que vaya más allá de lo que ya es posible, se puede encontrar aquí:
Indexación de expresiones: acceso de lectura y escritura
Por favor, échale un vistazo y decide si podría ayudarte también...
___________________________________________
En muchos lenguajes de programación, se pueden indexar listas y matrices. Esto también es posible en Jmp:
list= {"A", "B", "C"};
mat=[1,2,3];
list[3]
mat[2]
Con Jmp 13, se hizo posible otro nivel de indexación: subíndices de tablas de datos
Hoy en día, el usuario puede indexar fácilmente entradas en la tabla de datos con acceso de lectura y escritura.
Existe un tercer tipo de indexación: indexación de árbol de visualización
Para un informe determinado, puede recorrer el árbol de visualización para identificar un objeto específico:
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
gb = dt << Graph Builder(
Size( 437, 413 ),
Graph Spacing( 4 ),
Variables( X( :height ), Y( :weight ), Overlay( :sex ) ),
Elements( Points( X, Y, Legend( 1 ) ), Smoother( X, Y, Legend( 2 ) ) )
)
Report(gb)["Graph Builder"][AxisBox(1)]
Tal vez haya más lugares en Jmp donde la indexación ayude al usuario con su trabajo diario...
Para las expresiones es mucho más complicado recorrer el árbol:
Para obtener la variable Y :weight de
myExpr=Expr(gb = dt << Graph Builder(
Size( 437, 413 ),
Graph Spacing( 4 ),
Variables( X( :height ), Y( :weight ), Overlay( :sex ) ),
Elements( Points( X, Y, Legend( 1 ) ), Smoother( X, Y, Legend( 2 ) ) )
));
Hay que usarlo
Arg(Arg(Arg(Arg(Arg(myExpr,2),2),3),2),1) // :weight
muy frágil !!!!
Una solución alternativa: convertir la expresión de variables en una lista y utilizar la indexación de listas :
myExpr=Expr(Variables( X( :height ), Y( :weight ), Overlay( :sex ) ))
Substitute(Name Expr(myExpr),Expr(Variables()),Expr(List()))["Y"];
Pero hay varias desventajas:
- Sólo funciona para un solo nivel: jerarquía plana
- just the first named argument is found, further named arguments with the same identifier are ignored:
myExpr=Expr(Variables( X( :height ), Y( :weight ),Y(:height ), Overlay( :sex ) ));
Substitute(Name Expr(myExpr),Expr(Variables()),Expr(List()))["Y"]; // returns :weight, ignores Y(:height)
- just returns the first argument, further arguments get lost
myExpr = Expr(Distribution(columns(:height, :weight)));
Substitute(Name Expr(myExpr),Expr(Distribution()),Expr(List()))["columns"];
//returns :height -> :weight gets lost
¿Existe una posibilidad, análoga a la indexación del árbol de visualización, de escalar un árbol de expresión?
en lugar de
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
myExpr=Expr(gb = dt << Graph Builder(
Size( 437, 413 ),
Graph Spacing( 4 ),
Variables( X( :height ), Y( :weight ), Y(:height), Overlay( :sex ) ),
Elements( Points( X, Y, Legend( 1 ) ), Smoother( X, Y, Legend( 2 ) ) )
));
//instead of:
Arg(Arg(Arg(Arg(Arg(myExpr,2),2),3),3),1)
Quiero usar
myExpr[2][2["Variables"]["Y"(2)][1]
Gracias, @jthi Extract Expr() es muy útil para llegar al nivel correcto del árbol.
Me ayudó mucho el año pasado : )
Acabo de darme cuenta de que el procesamiento de argumentos dentro de un nivel se puede realizar de forma mucho más sencilla:
Se pueden usar For Each , Transform Each y Filter Each con expresiones. ¡Genial!
Main Script = Expr(dt << Graph Builder(
Size( 437, 413 ),
Graph Spacing( 4 ),
Variables( X( :height ), Y( :weight ), Y (:sex), Overlay( :sex ) ),
Elements( Points( X, Y, Legend( 1 ) ), Smoother( X, Y, Legend( 2 ) ) )
));
snippet = Extract Expr(Main Script, Variables(Wild List()))
For each({variable}, Name Expr(snippet), Show(Head(variable), Arg(variable)))
selection = Filter Each ({code}, Name Expr(snippet), Head(code)==Expr(Y()));
Show(selection)
changed= Transform Each ({code}, Name Expr(snippet), If (Head(code)==Expr(X()), Expr(my changed code),Name Expr(code)))
Show(changed);
