:folded_hands: Indexation des expressions : accès en lecture et en écriture☑ nouvelle fonctionnalité intéressante
☐ pourrait aider de nombreux utilisateurs !
☐ supprime un « bug »
☐ agréable à avoir
☐ personne n'en a besoin
Qu'est-ce qui a inspiré cette demande de liste de souhaits ?
edit : première partie déplacée vers l'indexation des expressions : Comment grimper dans l'arbre des expressions ?
Merci @jthi d'avoir fourni une solution :
ViaExtraire l'expressionun utilisateur a la possibilité de rechercher et d'extraire des parties d'expressions.
La fonction fournit une recherche de modèle et renvoie la première correspondance.
Même les jokers sont possibles
Quelle amélioration souhaiteriez-vous voir ?
Un mélange d'indexation d'arborescence d'affichage et d'indexation de table de données - uniquement pour les expressions :
Un accès en lecture plus précis via :
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)
<BR />// I want to use:
myExpr[2][2]["Variables"]["Y"(2)][1]
//assign // send // Graph Builder // Variables<BR /><BR />// or like it's possible for Display Trees:<BR />myExpr["Variables"]["Y"(2)][1]
Là où cela devient vraiment cool : l'accès en écriture similaire à ce qui est possible via l'indexation des tables de données :
myExpr["Variables"]["Y"(2)][1] = Expr(:height);
Comme Substitute - mais dans une dimension différente !
[modifier]
Et peut-être la meilleure application de l'indexation d'expression : Insérer dans , par exemple :
Insert Into ( myExpr["Variables"], Expr(Y(:age)))
Pourquoi cette idée est-elle importante ?
Avec la puissance de l'indexation des expressions , la gestion des expressions dans Jmp deviendra plus facile:)
plus de souhaits soumis par 
Automatisation et scriptsRe: Indexation des expressions : accès en lecture et en écriture - Statut modifié en : ReconnuRe: Indexation des expressions : accès en lecture et en écritureÉtrangeté de JMP Expr(), quelqu'un peut-il expliquer ?
Pour Insérer dans , en plus du mode turbo actuel, veuillez fournir un mode « non-fusion » supplémentaire....
mode turbo (comme se comporte désormais Insert Into ) :
si l'en-tête de l'expression à insérer est le même que l'en-tête du niveau au-dessus de la position cible, l'expression est « fusionnée » avec le niveau supérieur.
Insert Into (List(a,b), List(c,d)) // {a,b,c,d}mode de non-fusion supplémentaire :
Insert Into (List(a,b), List(c,d), merge(0)) // {a,b,{c,d}}
Comme il s'agit d'un effort considérable pour mettre en place l'indexation des expressions - et que la majorité des utilisateurs de JMP ne l'utiliseront pas : il y a peu d'espoir que le souhait soit réalisé.
découper le souhait pour Insérer dans : Insérer dans : Aplatir (0|1)
Re: Indexation des expressions : aidez-moi à grimper dans l'arbre des expressionsMerci @Craige_Hales pour ce bel exemple:)
J'espère que d'autres soutiendront également l'idée...
Re: Indexation des expressions : aidez-moi à grimper dans l'arbre des expressionsComment convertiriez-vous cela
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)))
)
);
à cela ?
myExpr = Expr(
gb = dt << Graph Builder(
Size(437, 413),
Graph Spacing(4),
Variables(X(:height), Y(:weight), /*added:*/ Y(:height), Overlay(:sex)),
Elements(Points(X, Y, Legend(1)), Smoother(X, Y, Legend(2)))
)
);
L'indexation pourrait rendre les choses beaucoup plus faciles. Cela ressemble à un problème InsertInto( myExpr, ... ). Cela fonctionnera si vous pouvez comprendre comment transformer les opérateurs en listes, puis les réintégrer, mais quelque chose comme
InsertInto( myExpr[/* = */ 2][ /* << */ 2]["Variables"], /* insert position*/ 3, expr( Y(:height)))
pourrait modifier l'expression sur place.
Preuve de concept :
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 ) ) )
)
);
Show( "Original", Name Expr( myExpr ) );
// convert operators to lists
Substitute Into( myExpr, Expr( Assign() ), {} );
Substitute Into( myExpr[2], Expr( Send() ), {} );
Substitute Into( myExpr[2][2], Expr( Graph Builder() ), {} );
Substitute Into( myExpr[2][2][3], Expr( Variables() ), {} );
// make the edit
Insert Into( myExpr[2][2][3], Expr( Y( :height ) ), 3 );
// reverse the earlier conversions
Substitute Into( myExpr[2][2][3], {}, Expr( Variables() ) );
Substitute Into( myExpr[2][2], {}, Expr( Graph Builder() ) );
Substitute Into( myExpr[2], {}, Expr( Send() ) );
Substitute Into( myExpr, {}, Expr( Assign() ) );
Show( "Edited", Name Expr( myExpr ) );
//
// wouldn't it be nice if we could use the edit line directly?
//
Write( "\!nTry without a list:" );
Insert Into( myExpr[2][2][3], Expr( Y( :height ) ), 3 ); // does not work
// it fails because expressions can't be indexed, even though they
// are extremely similar to lists (as seen above).
// I'm not sure why it needs to be that way.
Nous aimons utiliser les fonctions xxxInto(...) car elles modifient une arborescence d'expression existante, sur place. Dans certains cas, cela peut être un problème d'efficacité (par rapport à la création de copies de fragments d'une expression et à la reconstruction), mais il est également un peu plus clair de traiter les opérateurs comme des listes.
Merci @hogi , @jthi
Re: Indexation des expressions : aidez-moi à grimper dans l'arbre des expressions@jthi , avec cette belle solution, je pense que le sujet a une bien meilleure place dans les discussions :
https://community.jmp.com/t5/Discussions/Expression-Indexing-How-to-climbing-the-Expression-Tree/mp/697406
pourriez-vous s'il vous plaît ajouter votre commentaire ici - alors je l'accepterai comme solution
Re: Indexation des expressions : aidez-moi à grimper dans l'arbre des expressionsMerci @jthi !
Super - Extraire l'expression - bien mieux que ma solution de contournement via Substituer (... Liste) :
-> Corrige les problèmes 1 et 3
Pour le problème n°2, le deuxième exemple est une bonne solution de contournement - et en même temps :
illustre la simplicité deIndexation des expressions.
Avec Extract expr - disponible, il n'y a pas de besoin urgent d'accès en lecture à l'indexation des expressions.:)
modifier :
argh! Extraire Expr ne trouve que la première occurrence !
Re: Indexation des expressions : aidez-moi à grimper dans l'arbre des expressionsJMP dispose d'Extract Expr qui facilite certaines tâches.
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);
Ré: :folded_hands: Indexation des expressions : accès en lecture et en écritureune autre application pour l'indexation d'expression - mode écriture :
Remplacer la tête() ?
Il existe déjà un souhait disponible : Remplacer la première occurrence
oui s'il vous plait : )
Ré: :folded_hands: Indexation des expressions : accès en lecture et en écritureavec les cas d'utilisation les plus importants déjà disponibles ou élaborés.
@Sarah-Sylvestre , le statut pourrait être défini sur Pas prévu pour l'instant
