Il existe déjà quelques options sur la façon dont vous pouvez le faire (mais l'indice d'expression pourrait être utile). Comme je l'ai mentionné dans l'élément de la liste de souhaits ( Indexation des expressions : aidez-moi à gravir l'arborescence des expressions - Communauté d'utilisateurs JMP ), JMP dispose d'Extract Expr() qui utilise Wild() et 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);
Il y a aussi d'autres choses que vous pouvez faire (mais vous ne savez pas vraiment si vous devriez le faire)
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];
Il pourrait y avoir d'autres choses étranges que vous pourriez faire avec des listes...
Expressions avancées, macros et listes (jmp.com) peut être une bonne lecture
Ce post est né comme une entrée de liste de souhaits - mais il s'avère que le souhait est déjà partiellement possible (voir la réponse de @jthi ci-dessous).
Je l'ai donc déplacé ici pour rendre les résultats plus visibles.
Le souhait originel - qui demande une fonctionnalité qui va au-delà de ce qui est déjà possible - se trouve ici :
Indexation des expressions : accès en lecture et en écriture
S'il vous plaît, jetez un œil et décidez si cela pourrait également vous aider...
___________________________________________
Dans de nombreux langages de programmation, il est possible d'indexer des listes et des matrices. C'est également possible dans Jmp :
list= {"A", "B", "C"};
mat=[1,2,3];
list[3]
mat[2]
Avec Jmp 13, un autre niveau d'indexation est devenu possible : l'indexation des tables de données
De nos jours, l'utilisateur peut facilement indexer les entrées de la table de données avec un accès en lecture et en écriture.
Il existe un troisième type d'indexation : l'indexation de l'arborescence d'affichage
Pour un rapport donné, vous pouvez parcourir l'arborescence d'affichage pour identifier un objet spécifique :
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)]
Peut-être qu'il y a plus d'endroits dans Jmp où l'indexation aide l'utilisateur dans son travail quotidien...
Pour les Expressions, il est beaucoup plus compliqué de descendre dans l'arbre :
Pour obtenir la variable Y :poids 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 ) ) )
));
il faut utiliser
Arg(Arg(Arg(Arg(Arg(myExpr,2),2),3),2),1) // :weight
très fragile !!!!
Une solution de contournement : convertissez l'expression des variables en une liste et utilisez l'indexation de liste :
myExpr=Expr(Variables( X( :height ), Y( :weight ), Overlay( :sex ) ))
Substitute(Name Expr(myExpr),Expr(Variables()),Expr(List()))["Y"];
mais il y a plusieurs inconvénients :
- fonctionne uniquement pour un seul niveau - hiérarchie plate
- 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-t-il une possibilité, analogue à l’indexation de l’arbre d’affichage, de grimper dans un arbre d’expression ?
au lieu 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)
Je veux utiliser
myExpr[2][2["Variables"]["Y"(2)][1]
Merci, @jthi Extract Expr() est très utile pour atteindre le niveau correct de l'arbre.
Cela m'a beaucoup aidé l'année dernière : )
Je viens de remarquer que le traitement des arguments au sein d'un même niveau peut être effectué beaucoup plus facilement :
Pour chaque , Transformer chaque et Filtrer chaque peuvent être utilisés avec des expressions. Super !
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);
