369323_de-DE

liliconcom

Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Ich mag es nicht, jsl-Ausdrücke als Zeichenfolgen zu konstruieren, es erschwert die Fehlersuche und die Überprüfung auf Syntaxfehler ist ein mehrstufiger Prozess. Diese Beispiellösung für @A_Zaid 's Plotten bedingt post hat mich kämpfen aber.Ist es möglich, diese Graph-Builder-Funktion zu konstruieren? ohne Schreiben Sie die Zeichenfolge und analysieren Sie sie als Text? Ich stecke fest, wenn ich versuche, den 'Ausdruck' von Y-Argumenten zu konstruieren, der eine unbekannte Anzahl von Argumenten ist und nicht alleine analysiert werden kann.

 

Vielleicht gibt es ein Äquivalent zu tun.rufen , aufrufen, oder Exekutive Operatoren in R oder die platsch Operator in Python, den ich noch nicht gefunden habe?

 

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

 

SkripterstellungBetreff: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

@Craige_Hales Ich habe erst jetzt die Kraft dessen erkannt, was Sie hier vorgeschlagen haben. Ich habe nicht erkannt, dass Sie Substitut verwenden können, um nicht kontinuierliche Teile eines Ausdrucks zu ändern. Diese Methode im Wesentlichen ist was die R-Funktion tun.rufen tut (unten neu erstellt) und ist ähnlich wie aufrufen bzw Exekutive Operatoren in R oder die platsch Operator in 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()))

Nett!!

Betreff: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Das einfügen in Ansatz sieht wirklich gut aus; Das werde ich mir merken. Ich hatte eine { Liste von Ausdrücken } verwendet und das {} durch den neuen Kopf ersetzt, wie folgt:

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

bearbeiten...

Und InsertInto und RemoveFrom arbeiten beide mit Positionen in einem Ausdruck. Cool, das muss ich mir unbedingt merken!

 

Re: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Aah ha, die Verwendung von Insert Into() zum Erstellen eines Funktionsausdrucks anstelle einer Liste ist eine großartige Lösung.Ich werde es heute Abend versuchen, ich sehe das Licht, danke an alle!

Betreff: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Ich bin so weit gekommen, aber ich kann heute nicht mehr daran arbeiten. Es gibt einen Fehler im Ausdruck, der die Direktive Name() verwendet. Es gibt einen Ausweg, aber ich habe jetzt keine Zeit.

 

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

Betreff: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Es ist auch in Ordnung, Ausdrücke einzufügen, die sich aus Substitutionen, Zeichenkonvertierungen usw. ergeben. Wie immer ist dies ein Balanceakt zwischen einfacher Interpretation/Wartung und Prägnanz. Im folgenden Beispiel habe ich dies zur Veranschaulichung getan.

 

Die Handhabung von Ausdrücken ist nicht die einfachste Sache, die man lernen (oder lehren) kann. Es ist jedoch ziemlich leistungsfähig und ermöglicht es Ihnen, wie Sie bereits erwähnt haben, den farbcodierten Text beizubehalten, der die Wartung erleichtert.

 

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: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Normalerweise greife ich einfach auf Eval(Parse()) zurück, weil es sich viel einfacher anfühlt. Ich habe es gefunden Betreff: Variable Spaltenliste als Y-Achse im Graph Builder verwenden wo @Mark_Bailey gibt Lösung für etwas ähnliches.

 

Hier mein Versuch damit:

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

Ich dachte, dass dies beim Debuggen überhaupt nicht helfen würde, aber es tut es, weil Sie einfach den Substitute()-Teil der Graph-Builder-Generierung ausführen können, um zu sehen, was es zu tun versucht (und Sie erhalten auch JSL-Syntax-Highlighting).

Re: Können Sie dies konstruieren, ohne den Ausdruck als Zeichenfolge zu schreiben?

Eval(Parse()) hat mich zu oft gerettet. Ich kenne keine andere Methode für Ihr Beispielskript.Vielleicht hat ein anderes Community-Mitglied eine Lösung