Es gibt bereits einige Optionen, wie Sie dies tun können (aber die Subskription von Ausdrücken könnte nützlich sein). Wie ich im Wunschlistenpunkt erwähnt habe ( Ausdrucksindizierung: Helfen Sie mir, den Ausdrucksbaum zu erklimmen – JMP-Benutzergemeinschaft ), verfügt JMP über Extract Expr(), das Wild() und Wild List() verwendet.
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);
Es gibt auch andere Dinge, die Sie tun können (aber Sie sind sich nicht wirklich sicher, ob Sie das sollten)
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];
Es könnte noch andere seltsame Dinge geben, die man mit Listen machen könnte ...
Erweiterte Ausdrücke, Makros und Listen (jmp.com) kann eine gute Lektüre sein
Dieser Beitrag wurde als Wunschlisteneintrag geboren – aber es stellt sich heraus, dass der Wunsch bereits teilweise möglich ist (siehe die Antwort von @jthi unten).
Deshalb habe ich es hierher verschoben, um die Ergebnisse besser sichtbar zu machen.
Den ursprünglichen Wunsch, der eine Funktionalität verlangt, die über das bereits Mögliche hinausgeht, finden Sie hier:
Ausdrucksindizierung: Lese- und Schreibzugriff
Schauen Sie doch mal rein und entscheiden Sie, ob es auch für Sie weiterhelfen könnte...
_______________________________________________
In vielen Programmiersprachen kann man Listen und Matrizen indizieren. Auch in Jmp ist dies möglich:
list= {"A", "B", "C"};
mat=[1,2,3];
list[3]
mat[2]
Mit Jmp 13 wurde eine weitere Ebene der Indizierung möglich: Datentabellen-Indizierung
Heutzutage kann der Benutzer Einträge in der Datentabelle problemlos mit Lese- und Schreibzugriff indizieren.
Es gibt eine dritte Art der Indizierung: Display Tree Indexing
Für einen bestimmten Bericht können Sie den Anzeigebaum nach unten durchgehen, um ein bestimmtes Objekt zu identifizieren:
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)]
Vielleicht gibt es in Jmp noch weitere Stellen, wo die Indizierung dem Benutzer bei seiner täglichen Arbeit hilft …
Bei Ausdrücken ist es viel komplizierter, den Baum durchzugehen:
Um die Y-Variable :weight zu erhalten von
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 ) ) )
));
man muss verwenden
Arg(Arg(Arg(Arg(Arg(myExpr,2),2),3),2),1) // :weight
sehr zerbrechlich !!!!
Ein Workaround: Konvertieren Sie den Variablenausdruck in eine Liste und verwenden Sie die Listenindizierung:
myExpr=Expr(Variables( X( :height ), Y( :weight ), Overlay( :sex ) ))
Substitute(Name Expr(myExpr),Expr(Variables()),Expr(List()))["Y"];
Es gibt jedoch mehrere Nachteile:
- funktioniert nur für eine einzige Ebene - flache Hierarchie
- 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
Gibt es eine Möglichkeit, analog zur Display Tree Indexing, einen Expression Tree zu erklimmen?
anstatt
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)
Ich möchte verwenden
myExpr[2][2["Variables"]["Y"(2)][1]
Danke, @jthi. Extract Expr() ist sehr hilfreich, um auf die richtige Ebene des Baums zu gelangen.
Es hat mir letztes Jahr sehr geholfen 
Mir ist gerade aufgefallen, dass die Verarbeitung von Argumenten innerhalb einer Ebene deutlich einfacher erfolgen kann:
For Each , Transform Each und Filter Each können mit Ausdrücken verwendet werden. Cool!
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);
