369323_es-ES

liliconcom

¿Puedes construir esto sin escribir expresión como una cadena?

No me gusta construir expresiones jsl como cadenas, dificulta la resolución de problemas y la verificación de errores de sintaxis es un proceso de varios pasos. Esta solución de ejemplo para @A_Zaid 's Trazar condicionalmente Sin embargo, la publicación me tiene luchando.¿Es posible construir esta función de creación de gráficos? sin que escribir la cadena y analizarla como texto? Estoy atascado cuando trato de construir la 'expresión' de los argumentos Y, que es un número desconocido de argumentos y no se puede analizar por sí solo.

 

Tal vez haya un equivalente a hacer.llamar , invocar o ejecutivo operadores en R, o el salpicar operador en Python que aún no he encontrado?

 

Names default to here(1);

dt = Open("$Sample_data/probe.jmp");

//Variables to hold the dynamic parts of the graph builder expresssion
Expr1 = "";
Expr2 = "";

// Pick columns to include
cols = ( dt << get column names() )[random shuffle(8::397)[1::5]];

//Populate expressions
for(c=1, c<= n items(cols), c++,
 Expr1 = Expr1 || "Y( Column( \!"" || cols[c] || "\!" ), Position(1) ),";
 Expr2 = Expr2 || "Y( " || char( c ) || " ),";
);

Eval( Parse( substitute(
 //the graph builder script as a string with 'dummy variables' where the
 //expressions created earlier will go
 "gb = Graph Builder(
  Size( 838, 391 ),
  Variables(
   X( :DELL_RPPBR ),
   Expr1_
  ),
  Elements( Line( X, Expr2_ Legend( 10 ) ) ),
  Local Data Filter(
   Add Filter(
    columns( :DELL_RPPBR ),
    Where( :DELL_RPPBR >= -1 & :DELL_RPPBR <= 0.483837991952896 )
   )
  )
 )",
 //replace the 'dummy variables'
 "Expr1_",
 Expr1,
 "Expr2_",
 Expr2
) ) );

 

secuencias de comandosRe: ¿Puedes construir esto sin escribir la expresión como una cadena?

@Craige_Hales Solo ahora me di cuenta del poder de lo que sugirió aquí, no me di cuenta de que podría usar sustitutos para modificar partes no continuas de una expresión. Este método esencialmente es cual es la funcion r hacer.llamar hace (recreado a continuación), y es similar a invocar o ejecutivo operadores en R, o el salpicar operador en python :

 

//call another function (f) with the arguments provided in a list (l)
do.call = function({l,f}, 
 Substitute(
  Name Expr(l),
  Expr({}),
  Name Expr(f)
 );
);

//as an example, this calls concat("a", "b", "c")
do.call({"a","b","c"}, Expr(concat()))

¡¡Agradable!!

Re: ¿Puedes construir esto sin escribir la expresión como una cadena?

los insertar en el enfoque se ve muy bien; Voy a recordar eso. Había estado usando una { lista de expresiones } y reemplazando {} con el nuevo encabezado, así:

dt = Open( "$Sample_data/probe.jmp" );
// Pick columns to include
cols = (dt << get column names())[Random Shuffle( 8 :: 397 )[1 :: 5]];

//Variables to hold the dynamic parts of the graph builder expresssion
List1 = {};
List2 = {};

//Populate expressions
For( c = 1, c <= N Items( cols ), c++,
 List1[c] = Eval Expr( Y( Expr( cols[c] ), Position( 1 ) ) );
 List2[c] = Eval Expr( Y( Expr( c ) ) );
);
// list1: {Y( Name( "M1-TRENCH_ISO_IL" ), Position( 1 ) ), Y(...
// list2: {Y( 1 ), Y( 2 ), Y( 3 ), Y( 4 ), Y( 5 )}
Insert Into( List1, Expr( X( :DELL_RPPBR ) ), 1 ); // front of list1
Insert Into( List2, Expr( X ), 1 ); // front of list2
Insert Into( List2, Expr( Legend( 10 ) ) ); // back of list2

// swap the {} for variables() and line()
variablesExpr = Substitute( List1, Expr( {} ), Expr( variables() ) );
lineExpr = Substitute( List2, Expr( {} ), Expr( Line() ) );

exprGB = Expr(
 //the graph builder script as a string with 'dummy variables' where the
 //expressions created earlier will go
 (Graph Builder(
  Size( 838, 391 ),
  Variables_,
  Elements( Line_ ),
  Local Data Filter( Add Filter( columns( :DELL_RPPBR ), Where( :DELL_RPPBR >= -1 & :DELL_RPPBR <= 0.483837991952896 ) ) )
 ))
);

Substitute Into( exprGB, Expr( Variables_ ), Name Expr( variablesExpr ), Expr( Line_ ), Name Expr( lineExpr ) );

Show( Name Expr( exprGB ) );

Eval( exprGB );

editar...

Tanto InsertInto como RemoveFrom funcionan con posiciones en una expresión. Genial, ¡realmente necesito recordar eso!

 

Re: ¿Puedes construir esto sin escribir expresión en una cadena?

Aah ha, usar Insert Into() para construir una expresión de función en lugar de una lista es una gran solución.Lo intentaré esta noche, veo la luz, ¡gracias a todos!

Re: ¿Puedes construir esto sin escribir la expresión como una cadena?

Llegué hasta aquí pero ya no puedo trabajar en eso hoy. Hay un error en la expresión que usa la directiva Name(). Hay una manera de evitarlo, pero no tengo tiempo ahora.

 

Names Default To Here( 1 );

dt = Open( "$Sample_data/probe.jmp" );

//Variables to hold the dynamic parts of the graph builder expresssion
response expr = Expr(
 Variables( X( :DELL_RPPBR ) )
);

line expr = Expr(
 Line( X, Legend( 10 ) )
);

// Pick columns to include
col = (dt << Get Column Names)[Random Shuffle( 10 :: 397 )[1 :: 5]];

//Populate expressions
For( c = 1, c <= N Items( col ), c++,
 Insert Into( response expr, Substitute( Expr( Y( Name( ccc ), Position( 1 ) ) ), Expr( ccc ), Char( col[c], 1 ) ) );
 Insert Into( line expr, Substitute( Expr( Y( ccc ) ), Expr( ccc ), c ), c+1 );
);

Eval(
 Substitute( 
  Expr(
   gb = dt << Graph Builder(
    Size( 838, 391 ),
    Variables(
     vvv
    ),
    Elements( Line( X, lll, Legend( 10 ) ) ),
    Local Data Filter(
     Add Filter(
      Columns( :DELL_RPPBR ),
      Where( -1 < :DELL_RPPBR <= 0.483837991952896 )
     )
    )
   )
  ),
  Expr( vvv ), Name Expr( response expr ),
  Expr( lll ), Name Expr( line expr )
 )
);

Re: ¿Puedes construir esto sin escribir la expresión como una cadena?

También está bien insertar, en línea, expresiones resultantes de sustituciones, conversiones de caracteres, etc. Como siempre, se trata de un acto de equilibrio entre la facilidad de interpretación/mantenimiento y la concisión. En el siguiente ejemplo, he hecho esto para ilustrar.

 

El manejo de expresiones no es lo más fácil de aprender (o enseñar). Sin embargo, es bastante potente y, como mencionas, te permite mantener el texto codificado por colores que facilita el mantenimiento.

 

Names Default To Here( 1 );

dt = Open("$Sample_data/probe.jmp");

colList = {R_FUSE_16X0_5, VDP_PEMIT, "30P1_4X4_VBE"n, RM_RPB_100X7, "30N4_LE8_2RX1C_BVCBS"n}; //assume we've built this, somehow

gbExpr = Expr(
 gb = Graph Builder(
  Size( 838, 391 ),
  _VAR_EXP_,      // placeholder for Variables ( ) code.
  Elements( _LINE_EXP_ ),   // placeholder for Line ( ) code.
  Local Data Filter( Add Filter( columns( :DELL_RPPBR ), Where( :DELL_RPPBR >= -1 & :DELL_RPPBR <= 0.483837991952896 ) ) )
 )
);

varExpr = Expr( Variables( X( :DELL_RPPBR ) ) );   //Loop will insert into the last (default) position

lineExpr = Expr( Line( X, Legend( 1 ) ) );   //Loop will insert into the i+1th position

For( i = 1, i <= N Items( colList ), i++,   //note we're inserting the result of a substitute ( ) in each case
 Insert Into( varExpr, Substitute( Expr( Y( Column( _COL_ ), Position( 1 ) ) ), Expr( _COL_ ), Char( colList[i] ) ) );
 Insert Into( lineExpr, Substitute( Expr( Y( _i_ ) ), Expr( _i_ ), i ), i + 1 );
);

Substitute Into( gbExpr, Expr( _VAR_EXP_ ), Name Expr( varExpr ), Expr( _LINE_EXP_ ), Name Expr( lineExpr ) );

gbExpr; //evaluate the (now completely built) expression to show graph

Re: ¿Puedes construir esto sin escribir expresión en una cadena?

Por lo general, recurro al uso de Eval (Parse()) porque se siente mucho más fácil. Encontró esto Re: Usar lista de variables de columnas como eje Y en Graph Builder dónde @Mark_Bailey da solución a algo similar.

 

Aquí está mi intento con esto:

Names Default To Here(1);

dt = Open("$Sample_data/probe.jmp");

cols = (dt << get column names())[Random Shuffle(8 :: 397)[1 :: 5]];

var expr = Expr(
 Variables(X(:DELL_RPPBR))
);

var line = Expr(Line(X));

For(c = 1, c <= N Items(cols), c++,
 y expr = Expr(Y(Position(1)));
 Insert Into(y expr, cols[c], 1);
 Insert Into(var expr, Name Expr(y expr));
 
 yline expr = Parse("Y("||char(c)||")");
 Insert Into(var line, Name Expr(yline expr));

);

yline expr = Expr(Legend(10));
Insert Into(var line, Name Expr(yline expr));

Eval(
 Substitute(
   Expr(
    gb = dt << Graph Builder(
     Size(838, 391),
     Show Control Panel(0),
     vvv,
     Elements(yyy),
     Local Data Filter(Conditional, Add Filter(columns(:DELL_RPPBR), 
      Where(:DELL_RPPBR >= -1 & :DELL_RPPBR <= 0.483837991952896)))
    )
   ),
  Expr(vvv), Name Expr(var expr),
  Expr(yyy), Name Expr(var line)
 )
);

Pensé que esto no ayudaría en absoluto con la depuración, pero lo hace porque puede ejecutar la parte Substitute () de la generación del generador de gráficos para ver qué intenta hacer (y también obtiene el resaltado de sintaxis JSL).

Re: ¿Puedes construir esto sin escribir expresión en una cadena?

Eval(Parse()) me ha salvado en demasiadas ocasiones. No conozco ningún otro método para su script de ejemplo.Tal vez otro miembro de la comunidad tenga una solución.