riferimento di colonna robustoDopo pochi minuti di codifica con JSL, gli utenti si chiedono cosa siano strani oggetti come :sesso in
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
x = :sex
Gli utenti esperti hanno una certa esperienza con tali riferimenti di colonna e li utilizzano costantemente.
Ma cos'è :sex? Dt:sex è più robusto? Dove posso trovare la documentazione?
Raccogliamo e condividiamo alcune idee. Aggiungete i vostri pensieri e correggete i miei post se trovate errori...
il mio contributo:
Automazione e scriptingOggetto: riferimento alla colonna robustaIn JSL, lo stesso riferimento di colonna :sesso (o dt:sex ) può essere utilizzato in due modi:
# 1) come riferimento a una colonna
:sex << get name;
Data Table( "Big Class Families" ) << Distribution( Nominal Distribution( Column( :sex ) ));
...e il numero 2
per recuperare la voce della riga corrente in questa colonna, come in:
[modifica]: no!
"Da utilizzare nelle formule di colonna - e generalmente può essere considerato come il 'valore della riga corrente'."
Ma ci sono molti altri casi che richiedono anche questo tipo di :sesso
</CODE></PRE>
<BR />
<P>Nota bene: nelle formule di colonna, i seguenti approcci sono equivalenti</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
Per creare un oggetto di questo tipo a partire da una stringa, si hanno due opzioni:
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)
In realtà, esiste una terza opzione molto interessante, che ho appreso da @jthi :
the universal column reference = Name Expr(As Column(column name))
Può essere utilizzato come :sesso per entrambi gli approcci, facendo riferimento alla colonna e accedendo alla voce della riga corrente.
Column() vs As Column() vs datable:column vs dt:As name("column")
Re: riferimento di colonna robusto:sesso sembra fragile: cosa succede quando l'utente modifica il nome della colonna?
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, fantastico! Per niente fragile!
Re: riferimento di colonna robustoE quando l'utente modifica la tabella dati?
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])
L'innocente :sesso sa persino a quale tabella dati appartiene in realtà. Meraviglioso!
Re: riferimento di colonna robustoOra passiamo da 1 a 2 colonne:
myList1 = {:name,:sex,:age};
Un modo molto complicato e inutile per creare questa lista è:
myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});
Re: riferimento di colonna robustoinutile?
si nota già la grande differenza quando si tenta di eseguire il codice sopra senza un
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
La prima riga non si preoccupa dell'assenza di una tabella dati aperta. Quando si esegue la seconda riga, JMP emetterà un messaggio di errore:
Ancora meglio: quando l'elenco viene creato con il secondo approccio, i riferimenti alle colonne sono molto robusti.
Indipendentemente dalla tabella dati corrente, JMP andrà a dt e utilizzerà le colonne da lì:
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!
Come funziona?
Show(Type(myList1[1]), Type(myList2[1]))
fornisce maggiori informazioni:
L'elenco semplice ( la mia lista1 ) contiene "N Ames " , *)
l'elenco complicato ( la mia lista2 ) contiene " Colonne " **)
*) Quando un nome viene valutato, JMP segue una regola specifica per determinare il significato di tale nome:
https://www.jmp.com/support/help/en/19.0/#page/jmp/rules-for-resolving-names.shtml
Tra i ruoli, JMP cercherà una colonna nella tabella dati corrente ( dt2 ).
**) Per una colonna , JMP deve semplicemente andare alla tabella dati (" dt ") e accedere alla colonna.
Molto robusto!
Re: riferimento di colonna robustoName Expr(As column(:col))
è davvero fantastico!
Re: riferimento di colonna robustoLa funzione Column() funziona in molte situazioni ed è piuttosto flessibile per quanto riguarda il formato del nome della colonna.
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 ) )
Re: riferimento di colonna robustointeressante: quando vengono richiesti elenchi di colonne, le funzioni JSL restituiscono elenchi di nomi , non elenchi di colonne!
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
La differenza tra Ottieni nomi di colonna() e Ottieni riferimenti di colonna() :
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
e ora giochiamo con la colonna e poi chiediamo il valore di :sesso nella riga 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));
Re: riferimento di colonna robustoMessaggio da portare a casa:
Con l'apprendimento da
myList2 = Eval List({Name Expr(As column(:name)),Name Expr(As column(:sex)),Name Expr(As column(:age))});
possiamo convertire qualsiasi elenco fornito da JMP in un elenco robusto di colonne tramite
ColNames = dt << get column names;
colList = Transform Each({col}, ColNames, Name Expr(As Column (col)));
Re: riferimento di colonna robusto
@Byron_JMP wrote:
La funzione Column() funziona in molte situazioni ed è piuttosto flessibile per quanto riguarda il formato del nome della colonna.
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 ) )
Ciao @Byron_JMP , ci si può divertire molto con Colonna() all'interno di distribution()
Names Default to Here(1);
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
Distribution(Continuous Distribution( Column( :height )) );
Distribution(Continuous Distribution( Column( "height")) );
Un riferimento a una colonna, un nome, persino una stringa! Tutto funziona.
... finché non provi a utilizzare una colonna definita al di fuori del comando Distribuzione :
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)));
Si possono provare tutti questi esoterici trucchi di gestione delle espressioni del tipo "Proviamoli tutti, uno dovrebbe funzionare", ma nessuno funziona!
Sempre lo stesso suggerimento, ma cosa significa?!?
La soluzione è molto semplice, ma può richiedere ore se la si cerca nel posto sbagliato.
Trova la soluzione da solo prima di aprire 
:mano_con_el_dedo_índice_apuntando_hacia_abajo:
Scopri di più...
Column( :height ) inside
Distribuzione continua()
sembra like
Colonna("altezza") in
col = Colonna("altezza");
But it is a
argomento denominato - like
Formula() in
Nuova colonna(Formula(...)).
So the "obvious" solution is: keep the name of the named argument and place the column inside:
Distribution(Continuous Distribution(Column(col)));
Re: riferimento di colonna robustoIl mio approccio è molto più semplicistico. Faccio attenzione a creare il mio elenco di colonne in base allo scopo specifico che ho in mente. A volte ho più elenchi di colonne in formati diversi.
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);
che restituisce:
testo = {nome, età, sesso, altezza, peso};
citazione = {"nome", "età", "sesso", "altezza", "peso"};
colformat = {Colonna("nome"), Colonna("età"), Colonna("sesso"), Colonna("altezza"), Colonna("peso")};
uno dei tre generalmente funziona, anche se devo ricorrere a eval(parse())
Re: riferimento di colonna robustoIn sostanza, sono d'accordo con te. Dopo aver preso qualche precauzione, i nomi non sono poi così pericolosi:
Si potrebbe discutere se sia intelligente rinominare una colonna dopo aver creato un elenco di colonne, per poi chiedersi/lamentarsi che il vecchio nome non funzioni più.
Quando si lavora con due tabelle, è necessario assicurarsi che la tabella dati corretta sia la tabella dati corrente().
Lo stesso vale per i nomi delle colonne:
Si può presumere che JMP gestisca correttamente i nomi delle colonne, anche con lettere maiuscole e spazi. [trova il link]
Oppure si può essere cauti e seguire alcune regole (niente collisioni di nomi, variabili e nomi di colonne; attenzione agli spazi, ...) e trascorrere la maggior parte della giornata in tutta sicurezza e senza problemi.
Re: riferimento di colonna robustoCiao @Byron_JMP , per essere pignoli...
ottenere i nomi delle colonne() restituisce un elenco di nomi ; )
Re: riferimento di colonna robustoScoperta importante: ho appena modificato uno dei primi post!
Spero che i miei pensieri siano comprensibili, almeno per alcuni utenti come @Craige_Hales .
Immagino che anche questi utenti condivideranno il mio stupore/illuminazione/gioia e/o :aiuteranno confermando che è così, fornendo una spiegazione o apportando correzioni.
Finora ho pensato ad Come colonna (col) come un modo per recuperare il valore della riga corrente , soprattutto se paragonato a Colonna (col) per "l'accesso alle colonne" (come in Column(col) << get name).
Con l'implicazione inversa:
Ogni volta che utilizzo :col per qualcosa di diverso dal " valore della riga corrente ", quando voglio sostituirlo con una variabile, non devo usare Come colonna() , devo usare l'altro , ovvero Colonna(col).
[Devo ammettere che anche io sono rimasto perplesso dal nome:
Come colonna () - per la funzione che esegue l'inverso, non ottieni la colonna, ma il valore della riga corrente? Stai scherzando?
un altro pensiero:
Se Come colonna (col) funziona in questi casi, è semplicemente perché JMP corregge automaticamente l'errore dell'utente, oppure a causa di un effetto esoterico che tutti usano ma nessuno spiega, come in Nome expr(Come colonna(col))
Quindi ora mi sento molto tranquillo dopo aver scoperto: ....]
Questa interpretazione deve essere errata. È innescata da un automatismo in JMP che potrebbe seguire il principio:
Poiché column(col) fornisce accesso alla colonna .
Se viene valutato ( Eval(Come colonna() ...) )i, viene convertito in column(col)[], ovvero column(col)[row()], che può essere utilizzato per accedere al valore della riga corrente. Se non viene valutato, ma utilizzato in altre funzioni, fornisce accesso alla colonna.
Perché penso che sia così?
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...
[ innescato da https://community.jmp.com/t5/Discussions/Using-numeric-objects-in-a-column-equation/mp/903939/highlight/true#M106270 ]
Re: riferimento di colonna robustoSulla base di quanto appreso, ho una domanda specifica:
Esiste una panoramica completa di
- which functions act in the spirit of
Eval(:col), Where(:col=1) and Type(:col) ?
i.e. taking the column :col and interpretandolo come:col[riga()] ?
Scopri di più...
rw = Row();
Where( :age == Column( "age" )[rw] );
- e quali funzioni trattano semplicemente la colonna come una colonna , senza "aggiungere [riga] gratuitamente"?
come Col mediana(:col), Lag(:col,1)
Quale gruppo ha il maggior numero di membri?
Re: riferimento di colonna robustoNon credo che Col Mean funzioni molto bene in una sceneggiatura.
Tuttavia, "60.285714286" è il valore della riga 10, se la formula della colonna, Col Mean(:height,:age) è stata applicata in una colonna formula nella tabella dati.
E "62,55" è il valore della riga 10 se fosse in una colonna formula con Col Mean(;height).
Questo sarebbe un ottimo modo per nascondere la ricerca di valori in un'altra tabella, soprattutto se la tabella fosse privata.
Re: riferimento di colonna robustoMi dispiace, non sono sicuro di aver capito il punto.
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);
