697359_it-IT

liliconcom

:folded_hands: Indicizzazione delle espressioni: accesso in lettura e scrittura

☑ nuova fantastica funzionalità
☐ potrebbe aiutare molti utenti!

☐ rimuove un "bug"

☐ bello da avere

☐ nessuno ne ha bisogno

Cosa ti ha ispirato a richiedere questa lista dei desideri?

modifica: prima parte spostata su Indicizzazione delle espressioni: come scalare l'albero delle espressioni?

Grazie @jthi per aver fornito una soluzione:

TramiteEstrarre exprun utente ha la possibilità di cercare ed estrarre parti di Espressioni.
La funzione fornisce una ricerca di pattern e restituisce la prima corrispondenza.

Sono possibili anche i caratteri jolly

Quale miglioramento vorresti vedere?

Una combinazione di indicizzazione ad albero di visualizzazione e indicizzazione di tabelle dati, solo per le espressioni:

Un accesso di lettura più preciso tramite:

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]

Dove diventa davvero interessante: accesso in scrittura simile a quello possibile tramite l'indicizzazione delle tabelle dati:

myExpr["Variables"]["Y"(2)][1] = Expr(:height);

Come Substitute , ma in una dimensione diversa!

[modificare]
E forse la migliore applicazione dell'Expression Indexing: Inserisci in , ad esempio:

Insert Into ( myExpr["Variables"], Expr(Y(:age)))

Perché questa idea è importante?

Con la potenza dell'indicizzazione delle espressioni , la gestione delle espressioni in Jmp diventerà più semplice:)

altri desideri inviati da

Automazione e scriptingRe: Indicizzazione delle espressioni: accesso in lettura e scrittura - Stato modificato in: RiconosciutoRe: Indicizzazione delle espressioni: accesso in lettura e scrittura

Stranezza di JMP Expr(), qualcuno può spiegarla?

Per Inserisci in , oltre all'attuale modalità turbo, fornire un'ulteriore modalità "non unione".

modalità turbo (come si comporta ora Insert Into

se la testa dell'espressione da inserire è uguale alla testa del livello sopra la posizione di destinazione, l'espressione viene "unita" al livello superiore.

Insert Into (List(a,b), List(c,d)) // {a,b,c,d}

modalità non-merge aggiuntiva:

Insert Into (List(a,b), List(c,d), merge(0)) // {a,b,{c,d}}

Poiché è piuttosto impegnativo impostare l'indicizzazione delle espressioni e poiché la maggior parte degli utenti JMP non lo utilizzerà, ci sono poche speranze che questo desiderio venga realizzato.

ritaglia il desiderio per Inserisci in: Inserisci in: Appiattisci(0|1)

Re: Indicizzazione delle espressioni: aiutami a scalare l'albero delle espressioni

Grazie @Craige_Hales per il bell'esempio:)

Spero che anche altri sostengano l'idea...

Re: Indicizzazione delle espressioni: aiutami a scalare l'albero delle espressioni

Come convertiresti questo?

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)))
	)
);

a questo?

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'indicizzazione potrebbe semplificare molto le cose. Sembra un problema InsertInto( myExpr, ... ). Funzionerà se riesci a capire come trasformare gli operatori in elenchi e poi di nuovo indietro, ma qualcosa come

InsertInto( myExpr[/* = */ 2][ /* << */ 2]["Variables"], /* insert position*/ 3, expr( Y(:height))) 

potrebbe modificare l'espressione sul posto.

Prova di concetto:

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.

Ci piace usare le funzioni xxxInto(...) perché modificano un albero di espressione esistente, sul posto. In alcuni casi potrebbe essere un problema di efficienza (rispetto alla creazione di copie di frammenti di un'espressione e alla ricostruzione), ma è anche un po' più chiaro trattare gli operatori come elenchi.

Grazie @hogi , @jthi

Re: Indicizzazione delle espressioni: aiutami a scalare l'albero delle espressioni

@jthi , con questa bella soluzione, penso che l'argomento abbia un posto molto più importante nelle discussioni:
https://community.jmp.com/t5/Discussions/Expression-Indexing-How-to-climbing-the-Expression-Tree/mp/697406

potresti aggiungere il tuo commento lì, quindi lo accetterò come soluzione

Re: Indicizzazione delle espressioni: aiutami a scalare l'albero delle espressioni

Grazie @jthi !
Ottimo - Estrai expr - molto meglio della mia soluzione alternativa tramite Sostituisci (... Elenco):

-> Risolve i problemi 1 e 3

Per il problema n. 2, il secondo esempio è una buona soluzione alternativa e allo stesso tempo:

illustra la semplicità diIndicizzazione delle espressioni.

Con Extract expr - available, non c'è più bisogno urgente di accedere in lettura all'Expression Indexing.:)

modificare :
argh! Extract Expr trova solo la prima occorrenza!

Re: Indicizzazione delle espressioni: aiutami a scalare l'albero delle espressioni

JMP ha Extract Expr che rende alcune di queste cose più semplici

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);

Re: :folded_hands: Indicizzazione delle espressioni: accesso in lettura e scrittura

un'altra applicazione per Expression Indexing - modalità scrittura:
Sostituire Head() ?

C'è già un desiderio disponibile: Sostituisci prima occorrenza
sì per favore : )

Re: :folded_hands: Indicizzazione delle espressioni: accesso in lettura e scrittura

con i casi d'uso più importanti già disponibili o individuati.
@Sarah-Sylvestre , lo stato potrebbe essere impostato su Non pianificato per ora