697359_es-ES

liliconcom

:folded_hands: Indexación de expresiones: acceso de lectura y escritura

☑ nueva característica interesante
☐ ¡podría ayudar a muchos usuarios!

☐ elimina un "error"

☐ Es bueno tenerlo

☐ nadie lo necesita

¿Qué inspiró esta solicitud de lista de deseos?

editar: la primera parte se trasladó a Indexación de expresiones: ¿Cómo escalar el árbol de expresiones?

Gracias @jthi por brindar una solución:

A través deExtraer exprUn usuario tiene la posibilidad de buscar y extraer partes de Expresiones.
La función proporciona una búsqueda de patrones y devuelve la primera coincidencia.

Incluso son posibles los comodines

¿Cuál es la mejora que le gustaría ver?

Una combinación de indexación de árbol de visualización e indexación de tabla de datos, solo para expresiones:

Un acceso de lectura más preciso a través de:

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]

Donde se pone realmente interesante: acceso de escritura similar a lo que es posible a través de la indexación de la tabla de datos:

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

Como Substitute - ¡pero en una dimensión diferente!

[editar]
Y quizás la mejor aplicación de la indexación de expresiones: Insertar en , por ejemplo:

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

¿Por qué es importante esta idea?

Con el poder de la indexación de expresiones , el manejo de expresiones en Jmp será más fácil:)

Más deseos enviados por

Automatización y scriptingRe: Indexación de expresiones: acceso de lectura y escritura - Estado cambiado a: ReconocidoRe: Indexación de expresiones: acceso de lectura y escritura

Rareza de JMP Expr(), ¿alguien puede explicarlo?

Para Insertar en , además del modo turbo actual, proporcione un modo "sin fusión" adicional...

modo turbo (como se comporta ahora Insertar en

Si el encabezado de la expresión que se va a insertar es el mismo que el encabezado del nivel superior a la posición de destino, la expresión se "fusiona" con el nivel superior.

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

Modo adicional sin fusión:

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

Dado que es un gran esfuerzo configurar la indexación de expresiones (y como la mayoría de los usuarios de JMP no la utilizan), hay pocas esperanzas de lograr implementar el deseo.

Deseo de insertar en: Insertar en: Aplanar(0|1)

Re: Indexación de expresiones: ayúdenme a escalar el árbol de expresiones

Gracias @Craige_Hales por el buen ejemplo.:)

Espero que otros también apoyen la idea...

Re: Indexación de expresiones: ayúdame a escalar el árbol de expresiones

¿Cómo convertirías esto?

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 esto?

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

La indexación podría facilitarlo mucho. Parece un problema de InsertInto(myExpr, ...). Eso funcionará si puede averiguar cómo convertir los operadores en listas y luego volver a convertirlos, pero algo como

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

Podría editar la expresión en el lugar.

Prueba de concepto:

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.

Nos gusta usar las funciones xxxInto(...) porque modifican un árbol de expresión existente en su lugar. En algunos casos, esto podría ser un problema de eficiencia (en comparación con hacer copias de fragmentos de una expresión y volver a generarla), pero también es un poco más claro tratar los operadores como listas.

Gracias @hogi , @jthi

Re: Indexación de expresiones: ayúdame a escalar el árbol de expresiones

@jthi , con la buena solución, creo que el tema tiene un lugar mucho mejor en las Discusiones:
https://community.jmp.com/t5/Discussions/Expression-Indexing-How-to-climbing-the-Expression-Tree/mp/697406

¿Podrías agregar tu comentario allí? Entonces lo aceptaré como solución.

Re: Indexación de expresiones: ayúdenme a escalar el árbol de expresiones

¡Gracias @jthi !
Excelente. Extraer expr es mucho mejor que mi solución alternativa mediante Sustituto (... Lista):

-> Corrige los problemas 1 y 3

Para el problema n.° 2, el segundo ejemplo es una buena solución alternativa y, al mismo tiempo:

ilustra la simplicidad deIndexación de expresiones.

Con Extract expr - disponible, no hay necesidad urgente de indexación de expresiones con acceso de lectura.:)

editar :
¡Argh! ¡Extract Expr solo encuentra la primera ocurrencia!

Re: Indexación de expresiones: ayúdame a escalar el árbol de expresiones

JMP tiene Extract Expr, lo que hace que parte de esto sea más fácil.

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: Indexación de expresiones: acceso de lectura y escritura

Otra aplicación para la indexación de expresiones: modo escritura:
¿Reemplazar Head()?

Ya hay un deseo disponible: Sustituir primera ocurrencia
sí, por favor : )

Re: :folded_hands: Indexación de expresiones: acceso de lectura y escritura

con los casos de uso más importantes ya disponibles o desarrollados.
@Sarah-Sylvestre , el estado podría estar configurado como No planeado por ahora