369323_fr-FR

liliconcom

Pouvez-vous construire cela sans écrire expression sous forme de chaîne?

Je n'aime pas construire des expressions jsl sous forme de chaînes, cela les rend difficiles à dépanner et la vérification des erreurs de syntaxe est un processus en plusieurs étapes. Cet exemple de solution pour @A_Zaid c'est Tracer conditionnellement le poste m'a du mal cependant.Est-il possible de construire cette fonction de générateur de graphes sans écrire la chaîne et l'analyser en tant que texte? Je suis bloqué lorsque j'essaie de construire "l'expression" des arguments Y qui est un nombre inconnu d'arguments et ne peut pas être analysée par elle-même.

 

Peut-être y a-t-il un équivalent à appeler , invoquer ou exec opérateurs dans R, ou les éclabousser opérateur en Python que je n'ai pas encore trouvé ?

 

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

 

Automatisation et scriptRe : Pouvez-vous construire ceci sans écrire l'expression sous forme de chaîne ?

@Craige_Hales Je viens seulement de réaliser la puissance de ce que vous avez suggéré ici, je ne savais pas que vous pouviez utiliser un substitut pour modifier des parties non continues d'une expression. Cette méthode essentiellement est c'est quoi la fonction R appeler fait (recréé ci-dessous), et est similaire à invoquer ou exec opérateurs dans R, ou les éclabousser opérateur en python :

 

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

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

Bon!!

Re : Pouvez-vous construire ceci sans écrire l'expression sous forme de chaîne ?

Le insérer dans l'approche semble vraiment bonne; Je vais m'en souvenir. J'avais utilisé une { liste d'expressions } et remplacé le {} par la nouvelle tête, comme ceci :

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

modifier...

Et InsertInto et RemoveFrom fonctionnent tous les deux avec des positions dans une expression. Cool, il faut vraiment que je m'en souvienne !

 

Re : Pouvez-vous construire ceci sans écrire d'expression dans une chaîne ?

Aah ha, utiliser Insert Into() pour créer une expression de fonction au lieu d'une liste est une excellente solution.Je vais essayer ce soir, je vois la lumière, merci à tous !

Re : Pouvez-vous construire ceci sans écrire l'expression sous forme de chaîne ?

J'en suis arrivé là mais je ne peux plus travailler dessus aujourd'hui. Il y a une erreur dans l'expression utilisant la directive Name(). Il y a un moyen de contourner cela, mais je n'ai pas le temps maintenant.

 

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 : Pouvez-vous construire ceci sans écrire l'expression sous forme de chaîne ?

Il convient également d'insérer - en ligne - des expressions résultant de substitutions, de conversions de caractères, etc. Comme toujours, il s'agit d'un équilibre entre facilité d'interprétation/maintenance et concision. Dans l'exemple ci-dessous, j'ai fait cela pour illustrer.

 

La gestion des expressions n'est pas la chose la plus facile à apprendre (ou à enseigner). Il est cependant assez puissant et, comme vous l'avez mentionné, vous permet de conserver le texte à code couleur qui facilite la maintenance.

 

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 : Pouvez-vous construire ceci sans écrire d'expression dans une chaîne ?

En général, je me contente d'utiliser Eval(Parse()) parce que c'est beaucoup plus facile. Trouvé ceci Re : Utiliser la liste variable des colonnes comme axe Y dans le générateur de graphiques où @Mark_Bailey donne une solution à quelque chose de similaire.

 

Voici ma tentative avec ceci:

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

Je pensais que cela n'aiderait pas du tout avec le débogage, mais c'est le cas parce que vous pouvez simplement exécuter la partie Substitute() de la génération du générateur de graphes pour voir ce qu'il essaie de faire (et vous obtenez également la coloration syntaxique JSL).

Re : Pouvez-vous construire ceci sans écrire d'expression dans une chaîne ?

Eval(Parse()) m'a sauvé trop d'occasions. Je ne connais aucune autre méthode pour votre exemple de script.Peut-être qu'un autre membre de la communauté a une solution