903135_de-DE

liliconcom

Robuste Spaltenreferenz

Nach ein paar Minuten Programmieren mit JSL wundern sich Benutzer über seltsame Objekte wie :Sex in

dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

x = :sex

Erfahrene Benutzer haben einige Erfahrung mit solchen Spaltenverweisen und verwenden sie ständig.
Aber was ist :sex? Ist dt:sex robuster? Wo finde ich eine Dokumentation?

Lassen Sie uns einige Erkenntnisse sammeln und teilen. Bitte fügen Sie Ihre Gedanken hinzu und korrigieren Sie meine Beiträge, wenn Sie Fehler finden ...

meine 5 Cent:

Automatisierung und SkriptingBetreff: Robuste Spaltenreferenz

In JSL kann ein und dieselbe Spaltenreferenz :Sex (oder dt:sex ) auf zwei Arten verwendet werden:

# 1) als Bezugnahme auf eine Spalte

:sex << get name;
Data Table( "Big Class Families" ) << Distribution(	Nominal Distribution( Column( :sex ) ));

... und Nr. 2
Um den Eintrag der aktuellen Zeile in dieser Spalte abzurufen, wie in:

[Bearbeiten]: Nein!

„Zur Verwendung in Spaltenformeln – und kann üblicherweise als der ‚Wert der aktuellen Zeile‘ betrachtet werden.“
Es gibt aber noch viele weitere Fälle, die diese Art von :sex ebenfalls erfordern.

</CODE></PRE> 
   <BR /> 
   <P>Bitte beachten Sie: Bei Spaltenformeln sind die folgenden Ansätze äquivalent.</P> 
   <PRE><CODE class=" language-jsl">new column("s", formula (:sex));
new column("s", formula (:sex[]));
new column("s", formula (:sex[row()]))
row()=5;
s=:sex; // value of the current row

// other cases:
lag(:sex,1); // value of the previous row
Col Mean(:height, :age)); // mean :height of rows with same :age

Um ein solches Objekt aus einer Zeichenkette zu erstellen, hat man 2 Möglichkeiten:

column name = "sex";
col= Column (column name); // for the first one (accessing the column)

val = As Column (column name) // for the second one (accessing the column in formulas)

Tatsächlich gibt es noch eine sehr coole dritte Option, die ich von @jthi gelernt habe:

the universal column reference = Name Expr(As Column(column name))

Es kann wie :Sex für beide Ansätze verwendet werden. Dabei wird auf die Spalte verwiesen und auf den Eintrag der aktuellen Zeile zugegriffen.

Column() vs As Column() vs datable:column vs dt:As name("column")

Betreff: Robuste Spaltenreferenz

:Sex sieht zerbrechlich aus – was passiert, wenn der Benutzer den Spaltennamen ändert?

Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

x = Name Expr(As column("name"));
Show(Name Expr(x)); // : name 

:name << set name("The name");

Show(Name Expr(x)); // :The name

wow, toll! Überhaupt nicht zerbrechlich!

Betreff: Robuste Spaltenreferenz

Und wenn der Benutzer die Datentabelle ändert?

Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

x = Name Expr(As column("name"));
Show(Name Expr(x));
x[1] = "Marker";

:name << set name("The name");

dt = Open( "$SAMPLE_DATA/Big Class Families.jmp" );

Show(Name Expr(x));
Show(x[1])

Das unschuldige :Sex weiß sogar, zu welcher Datentabelle es eigentlich gehört. Wunderbar!

Betreff: Robuste Spaltenreferenz

Gehen wir nun von 1 Spalte zu 2 Spalten über:

myList1 = {:name,:sex,:age};

Eine sehr komplizierte und nutzlose Möglichkeit, diese Liste zu erstellen, ist:

myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});

Betreff: Robuste Spaltenreferenz

nutzlos?

Sie bemerken den großen Unterschied bereits, wenn Sie versuchen, den obigen Code ohne

dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

In der ersten Zeile wird nicht berücksichtigt, dass keine Datentabelle geöffnet ist. Wenn Sie die zweite Zeile ausführen, beschwert sich JMP:

Noch besser: Wenn die Liste mit dem zweiten Ansatz erstellt wird, sind die Spaltenreferenzen sehr robust.
Unabhängig von der aktuellen Datentabelle geht JMP zu dt und verwendet die Spalten von dort:

dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

myList1 = {:name,:sex,:age};

myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});

dt2= Open( "$SAMPLE_DATA/Big Class Families.jmp" );

dt << Select Rows( [1] ) << Delete Rows; // now dt starts with Louise - there is no Katie anymore!

Show(Eval List(myList1), // Katie? why Katie!!!
Eval List(myList2)); // Louise -> works!

Wie funktioniert es?

Show(Type(myList1[1]), Type(myList2[1]))

bietet weitere Einblicke:

Die einfache Liste ( meineListe1 ) enthält " Namen " , *)

die komplizierte Liste ( meineListe2 ) enthält " Spalten " **)

*) Bei der Auswertung eines Namens folgt JMP einer bestimmten Regel, um die Bedeutung dieses Namens zu bestimmen:
https://www.jmp.com/support/help/en/19.0/#page/jmp/rules-for-resolving-names.shtml

Unter den Rollen sucht JMP nach einer Spalte in der aktuellen Datentabelle ( dt2 ).

**) Für eine Spalte muss JMP nur zur Datentabelle („ dt “) gehen und auf die Spalte zugreifen.
Sehr robust!

Betreff: Robuste Spaltenreferenz

Name Expr(As column(:col))

ist soooo cool!

Betreff: Robuste Spaltenreferenz

Die Funktion „Column()“ funktioniert in vielen Situationen und ist hinsichtlich des Formats des Spaltennamens ziemlich flexibel.

Distribution(
	Continuous Distribution( Column( :Random Normal )), 
	Continuous Distribution( Column( "Random Normal" )),
	Continuous Distribution( Column( :"Random Normal"n )),
	Continuous Distribution( Column( "Random Normal"n )),
	 Process Capability( 0 ) )

Betreff: Robuste Spaltenreferenz

interessant: Wenn nach Spaltenlisten gefragt wird, geben JSL-Funktionen Namenslisten zurück, keine Spaltenlisten!

Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );


colList = Eval List({Name Expr(As column("sex"))});
write(Name Expr(colList[1]), " is a  ", // :sex
Type(Name Expr(colList[1])), "\!n"); // Column -> universal & robust


selectedCols = dt << select columns (:sex) << get selected columns;
write(Name Expr(selectedCols[1])," is a ", // : sex
Type(Name Expr(selectedCols[1])), "\!n"); // Name -> fragile

dt << Group Columns(Item Range( :sex, :height ),"myColGroup");
colsFromColumnGroup = dt << get column group("myColGroup");
Write(Name Expr(colsFromColumnGroup[1]), " is a  ", // :sex
Type(Name Expr(colsFromColumnGroup[1])), "\!n"); // Name -> fragile

Der Unterschied zwischen Spaltennamen abrufen() und Spaltenreferenzen abrufen() :

ColNames = dt << get column names; // default setting: returns names, not Strings 
Write(Name Expr(ColNames[3]), " is a  ", // sex (more or less the same as :sex)
Type(Name Expr(ColNames[3])), "\!n"); // Name -> fragile


ColRefs = dt << get column references;
Write(Name Expr(ColRefs[3]), " is a  ", // Column("sex"
Type(Name Expr(ColRefs[3])), "\!n"); // Column -> robust, but not :sex, see below

und jetzt spielen wir mit der Spalte und fragen dann nach dem Wert von :Sex in Zeile 1:

//hide the column
:sex <<  set name("hidden");

// who finds it?
row()=1;
Try(Show(Eval(ColList[1])), print(exception_msg));
Try(Show(Eval(colsFromColumnGroup[1])), print(exception_msg));
Try(Show(Eval(selectedCols[1])), print(exception_msg));
Try(Show(Eval(ColNames[3])), print(exception_msg));
Try(Show(Eval(ColRefs[3])), print(exception_msg));

Betreff: Robuste Spaltenreferenz

Botschaft zum Mitnehmen:

Mit dem Lernen aus

myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});

Wir können jede von JMP bereitgestellte Liste über in eine robuste Spaltenliste konvertieren

ColNames = dt << get column names;
colList = Transform Each({col}, ColNames, Name Expr(As Column (col)));

Betreff: Robuste Spaltenreferenz

---

@Byron_JMP wrote:

Die Funktion „Column()“ funktioniert in vielen Situationen und ist hinsichtlich des Formats des Spaltennamens ziemlich flexibel.

Distribution(
	Continuous Distribution( Column( :Random Normal )), 
	Continuous Distribution( Column( "Random Normal" )),
	Continuous Distribution( Column( :"Random Normal"n )),
	Continuous Distribution( Column( "Random Normal"n )),
	 Process Capability( 0 ) )

---

Hallo @Byron_JMP , man kann viel Spaß mit Spalte() innerhalb von Verteilung() haben

Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );

Distribution(Continuous Distribution( Column( :height )) );
Distribution(Continuous Distribution( Column( "height")) );

Eine Spaltenreferenz, ein Name – sogar ein String! Alles funktioniert.

... bis Sie versuchen, eine Spalte zu verwenden, die außerhalb des Verteilungsbefehls definiert ist:

col = Column("height");
Show(col); // shows: it's a column
Distribution(Continuous Distribution(col));
Distribution(Continuous Distribution(Eval(col)));
Distribution(Continuous Distribution(Name Expr(col)));

Man kann alle diese esoterischen „Probieren wir sie einfach alle aus – einer davon sollte funktionieren“-Tricks zur Ausdrucksbehandlung ausprobieren, keiner davon funktioniert!

Immer der gleiche Hinweis, aber was bedeutet er?!?

Die Lösung ist ganz einfach – kann aber Stunden dauern, wenn man an der falschen Stelle danach sucht.
Finden Sie die Lösung selbst, bevor Sie öffnen

:mano_con_el_dedo_índice_apuntando_hacia_abajo:

Mehr anzeigen...

Column( :height ) inside Kontinuierliche Verteilung() Aussehen like Spalte("Höhe") in
col = Spalte("Höhe");
But it is a benanntes Argument - like Formel() in Neue Spalte(Formel(...)).

So the "obvious" solution is: keep the name of the named argument and place the column inside:

Distribution(Continuous Distribution(Column(col)));

Betreff: Robuste Spaltenreferenz

Mein Ansatz ist viel einfacher. Ich achte darauf, meine Spaltenliste für den jeweiligen Zweck zu erstellen. Manchmal habe ich mehrere Spaltenlisten in unterschiedlichen Formaten.

Names Default To Here( 1 );
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
text = dt << Get Column Names();
quote = dt << Get Column Names( String );
colformat = dt << get column reference();
quote = dt << Get Column Names( String );
show(text, quote, colformat);

was zurückgibt:

Text = {Name, Alter, Geschlecht, Größe, Gewicht};

Zitat = {"Name", "Alter", "Geschlecht", "Größe", "Gewicht"};

colformat = {Spalte("Name"), Spalte("Alter"), Spalte("Geschlecht"), Spalte("Größe"), Spalte("Gewicht")};

einer der drei funktioniert im Allgemeinen, auch wenn ich auf eval(parse()) zurückgreifen muss

Betreff: Robuste Spaltenreferenz

Grundsätzlich bin ich ganz deiner Meinung. Namen sind nach einiger Vorsicht nicht sehr gefährlich:

Man kann darüber streiten, ob es klug ist, eine Spalte nach dem Erstellen einer Spaltenliste umzubenennen – und sich dann darüber wundern/beschweren, dass der alte Name nicht mehr funktioniert.

Und wenn man mit zwei Tabellen arbeitet, muss man sicherstellen, dass die richtige Datentabelle die aktuelle Datentabelle ist().

Dasselbe gilt für Spaltennamen:
Man kann davon ausgehen, dass JMP Spaltennamen korrekt verarbeitet – auch mit Großbuchstaben und Leerzeichen. [Link finden]
Oder man kann vorsichtig sein und einige Regeln befolgen (keine Kollisionen von Namen, Variablen und Spaltennamen; Vorsicht mit Leerzeichen usw.) und den größten Teil des Tages sicher und ohne Probleme leben.

Betreff: Robuste Spaltenreferenz

Hallo @Byron_JMP , um pingelig zu sein ...

---

Spaltennamen abrufen() gibt eine Liste mit Namen zurück

Betreff: Robuste Spaltenreferenz

Wichtige Erkenntnis – ich habe gerade einen der ersten Beiträge bearbeitet!

Ich hoffe, meine Gedanken sind verständlich – zumindest für einige Benutzer wie @Craige_Hales .
Ich schätze, diese Benutzer werden auch mein Erstaunen/meine Erleuchtung/meine Freude teilen und/oder helfen, indem sie bestätigen, dass es so ist, eine Erklärung liefern oder Korrekturen vornehmen.

Bisher habe ich über Als Spalte (Spalte) als eine Möglichkeit nachgedacht, den Wert der aktuellen Zeile abzurufen – insbesondere im Vergleich zu Spalte (col) für den „Spaltenzugriff“ (Sie wissen schon, wie in Column(col) << get name).

Mit der umgekehrten Implikation:
Wenn ich :col für etwas anderes als den „ Wert der aktuellen Zeile “ verwende und es dann durch eine Variable ersetzen möchte, muss ich nicht Als Spalte() verwenden, sondern stattdessen das andere , nämlich Spalte (col).

[Ich muss zugeben, dass mich der Name auch verwirrt hat:

Als Spalte () - für die Funktion, die die Umkehrung durchführt, nicht die Spalte, sondern den Wert der aktuellen Zeile erhalten? Das ist Ihr Ernst?

noch ein Gedanke:
Wenn Als Spalte (Spalte) in solchen Fällen funktioniert, dann liegt das nur daran, dass JMP den Fehler des Benutzers automatisch korrigiert – oder an einem esoterischen Effekt, den jeder nutzt, aber niemand erklärt – wie in Name Ausdruck (als Spalte (Spalte))

Ich fühle mich jetzt sehr wohl, nachdem ich Folgendes herausgefunden habe: ....]

Diese Interpretation muss falsch sein. Sie wird durch einen Automatismus in JMP ausgelöst, der der folgenden Idee folgen könnte:

Als Spalte(col) erhält man Zugriff auf die Spalte .
Wenn es ( Eval(As Column() ...) )i ausgewertet wird , wird es in Spalte(Spalte)[] bzw. Spalte(Spalte)[Zeile()] konvertiert, womit auf den Wert der aktuellen Zeile zugegriffen werden kann. Wird es nicht ausgewertet, sondern in anderen Funktionen verwendet, ermöglicht es Zugriff auf die Spalte.

Warum denke ich, dass es so ist?

Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class Families.jmp" );

row()=10;

Lag(:height);                           // 60
Show(lag(Column ("height"),1));         // Column("height") !!!
Show(lag(As Column ("height"),1));     // 60 !!!

Col Mean(:height);                             // 6255
Col Mean(:height, :age);                       // 60.285...
Show(Col Mean(Column ("height")));             // 62.55 (why does it work? another automatism because it is used so often?)
Try(Show(Col Mean(Column ("height"), :age)),Print(exception_msg)); //  !!!
Show(Col Mean(As Column ("height"), :age));    // 60.285...

[ ausgelöst durch https://community.jmp.com/t5/Discussions/Using-numeric-objects-in-a-column-equation/mp/903939/highlight/true#M106270 ]

Betreff: Robuste Spaltenreferenz

Aufgrund dieser Erkenntnisse habe ich eine konkrete Frage:

Gibt es einen umfassenden Überblick über

1. which functions act in the spirit of
   Eval(:col), Where(:col=1) and Type(:col) ?
   i.e. taking the column :col and interpretieren es als:Spalte[Zeile()] ?
   
   Mehr anzeigen...

   rw = Row();
   Where( :age == Column( "age" )[rw] );

2. , und welche Funktionen behandeln die Spalte einfach als Spalte – ohne „ [Zeile] kostenlos hinzuzufügen“?
   wie Spaltenmedian(:Spalte), Lag(:Spalte,1)

Welche Gruppe hat die meisten Mitglieder?

Betreff: Robuste Spaltenreferenz

Ich glaube nicht, dass Col Mean in einem Drehbuch besonders gut funktioniert.

Allerdings ist „60,285714286“ der Wert von Zeile 10, wenn die Spaltenformel Col Mean(:Größe,:Alter) in einer Formelspalte in der Datentabelle angewendet würde.

Und „62,55“ ist der Wert von Zeile 10, wenn sie in einer Formelspalte mit Col Mean(;height) wäre.

Dies wäre eine wirklich großartige Möglichkeit, das Nachschlagen von Werten in einer anderen Tabelle zu verschleiern, insbesondere wenn die Tabelle privat wäre.

Betreff: Robuste Spaltenreferenz

Tut mir leid, ich bin nicht sicher, ob ich den Punkt verstehe.

Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" , Private);

col median(dt:height);

vals= dt:height << get values();
vals=dt[0,"height"];
Median(vals);