Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertHallo
Ich versuche, eine Funktion zu definieren, die den Fehler der Annahme der Linearität in einem Bereich einer anderen Funktion berechnet.
Meine Funktion muss Folgendes tun:
- Akzeptieren Sie 3 Eingaben: die nichtlineare Funktion (vorzugsweise nur einen an anderer Stelle definierten Funktionsnamen f(x)), den Mittelpunkt der Region (xi) und die Halbwertsbreite der untersuchten Region (Delta).
- Erzeugen Sie Steigung und Achsenabschnitt der asymptotenlinearen Funktion in xi, Lin(x).
- Erzeugen Sie per Definition eine Fehlerfunktion err(x) = Lin(x) - f(x), err(xi) = 0.
- Integrieren Sie err(x) von xi-delta bis xi+delta und dividieren Sie durch 2*delta, um den mittleren Fehler in der Region zu ermitteln.
- Verwenden Sie den mittleren Fehler, um die Standardabweichung des Fehlers in der Region zu berechnen (beinhaltet auch Integration).
Bei dem Versuch, dies zu tun, stoße ich auf drei Probleme:
- Wie bringe ich die Funktionsfunktion in jsl dazu, eine andere Funktion als Eingabe zu akzeptieren?
- Wie kann ich die Ableitungsfunktion dazu bringen, ein Funktionsargument zu differenzieren, das durch den Funktionsnamen bereitgestellt wird, z. B. Derivative(f(x),x)?
- Wie bringe ich JSL dazu, eine Funktion in einer bestimmten Region zu integrieren? Ich kann keine integrierte Funktion dafür finden.
Ich hoffe, dass einige helfen können.
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertNur zur Info, wer auch immer diesen Beitrag verfolgt hat. Der JMP-Support stellte alternative Methoden bereit, um den Ausdruck aus einer bereits definierten Funktion abzurufen. Es ist eine Alternative zu Capture Log( Show(func) );
funcExpr = Parse( "Expr(" || Char( Name Expr( func ) ) || ")" );
innerf = Arg( Arg( funcExpr, 1 ), 2 );
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertIch denke, Ihre Vorschläge haben mir auf dem Weg geholfen.
In der Zwischenzeit habe ich meine Meinung darüber geändert, was ich mit der Funktion bewirken soll.
Aber hier ist, was ich bisher bekommen habe:
expression = Expr( x ^ 2 );
LinearityError = Function( {expression, location, sigma, sigmaRange = 3},
locationY = Eval( Substitute( Name Expr( expression ), Expr( x ), location ) );
SlopeFunc = Derivative( Name Expr( expression ), x );
Slope = Eval( Substitute( Name Expr( SlopeFunc ), Expr( x ), location ) );
Intercept = locationY - Slope * location;
LinExpr = Parse( Eval Insert( "^Slope^*x + ^Intercept^" ) );
errExpr = Substitute( Expr( (a) - (b) ), Expr( a ), Name Expr( LinExpr ), Expr( b ), Name Expr( expression ) );
errExpr = Simplify Expr( Name Expr( errExpr ) );
lowerLimit = location - sigma * sigmaRange;
upperLimit = location + sigma * sigmaRange;
errMean = Integrate( errExpr, x, lowerLimit, upperLimit ) / (2 * sigma * sigmaRange);
errErrSquaredExpr = Substitute( Expr( ((a) - (b))^2 ), Expr( a ), Name Expr( errExpr ), Expr( b ), errMean );
errErrSquaredExpr = Simplify Expr( Name Expr( errErrSquaredExpr ) );
errStdDev = Sqrt(Integrate( errErrSquaredExpr, x, lowerLimit, upperLimit ) / (2 * sigma * sigmaRange));
Return(errStdDev);
);Ich nehme einen Ausdruck als Argument und nicht als Funktion, aber Sie haben dafür eine Lösung bereitgestellt. Es ist einfach noch nicht umgesetzt.
Tank dich!
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertAnmerkung des Bloggers zu Ihrer Information
JMP 14 verfügt über ein neues Objekt namens „Custom Function“ mit nützlichen Meldungen. Als Erweiterung habe ich eine Get Expr-Nachricht angefordert. Ich glaube nicht, dass dies auf Ihre Anfrage zutrifft, es wäre jedoch einfacher, die Funktion zu erhalten: func << Get Function, anstelle der 2 Schritte mit LogCapture(show(func)) usw....
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertJesper,
Ich weiß, dass Sie Derivative( f(x), x) finden möchten, allerdings erfordert die JMP-symbolische Derivative-Funktion, dass das erste Argument ein Ausdruck ist.Es könnte einfacher sein, Ihnen zu helfen, wenn Sie erklären, wie dies funktionieren soll. Ich gehe davon aus, dass Sie Ihre eigene Funktion oder Anwendung mit drei Argumenten erstellen möchten und f(x) erwähnt haben, aber Wo und wie wird f(x) eingelesen bzw. definiert?
JMP-Ausdrücke und -Funktionen versuchen, sofort auszuwerten.Kopieren Sie diesen nächsten Codeblock in ein Skriptfenster, klicken Sie mit der rechten Maustaste, um das eingebettete Protokoll anzuzeigen, markieren Sie dann die Codesegmente, führen Sie sie aus und sehen Sie sich die Ergebnisse im Protokoll an. So funktionieren JMP-Funktionen und -Ausdrücke.
Names Default to Here(1);
func = Function({x}, x^2);
xp = Expr(x^2);
show(func, func(x)); //will get an error func(x/*###*/) since there is no such symbol, x
//----run to here---
show(xp); // xp=x^2 JMP does not evaluate an expression within when it is a Show() function argument
//----run to here---
x= Empty();
show(func, func(x), xp, Eval(xp) ); //func(x) = .; since x is empty, then any calculation involving x is empty
//----run to here---
x=2;
show(func, func(x), xp, Eval(xp)); //func(x) = 4; since x = 2.
//----run to here---
Show(Derivative(xp,x), Derivative(NameExpr(xp),x) )
//----run to here---
//: JMP tries to evaluate func(x), and Derivative(xp,x) evaluates xp unless you specify NameExpr(xp)
Die einzige mir bekannte Methode zur Verwendung der integrierten Funktion Derivative() besteht also darin, das erste Argument in einen Ausdruck umzuwandeln.
Ihre Frage hat eine interessante Frage aufgeworfen, Wie kann JSL das Ausdrucksargument extrahieren? (das letzte Argument) einer bereits definierten Benutzerfunktion.Vielleicht haben andere erfahrene Blogger eine bessere Lösung. Oder vielleicht ist dies ein Wunschlisteneintrag, dass eine zukünftige Version von JMP eine Funktion oder Nachricht bereitstellt, die den Ausdruck aus einer benutzerdefinierten Funktion extrahiert.
Der nächste Codeblock zeigt eine Methode zum Extrahieren des Ausdrucks aus einer benutzerdefinierten Funktion.
Teilen Sie dem Blog also mit, wie die Funktion eingelesen (erstellt) wird, und vielleicht erhalten Sie eine schmackhaftere Lösung. Wenn Ihre Anwendung den Benutzer beispielsweise zur Eingabe einer Funktion in einem Textfeld auffordert, kann die Arbeit mit Text einfacher sein.
func = Function({x},x^2);<BR />
//assumes a function has been defined
tfxp=Parse(Word( 2, Trim(LogCapture(show(func))), "=") );<BR />//show(func) writes the function definition to the Log<BR />//Log Capture() captures that as a string<BR />//the Word() function above gets the right hand side of the equal sign<BR />//Parse turns it into an expression<BR />
fxp = argExpr(tfxp, nargExpr(tfxp) );
//this extracts the last argument of Function()<BR />
show(Derivative(nameExpr(fxp),x));
//______________________________________________________________
//instead of creating a function and doing all the steps to extract the expression
//create the function from an expression
//---create expression
myxp = Expr(3*x^3 -17*x + 12 );
//---this is a template, an expression that will assign func to the expression
myfunc = Expr(func= Function({x}, _xp));
//---create the function
//this substitutes the expression and evaluates
//once it is run, func=Function({x}, 3*x^3 -17*x +12 ) has been defined
Eval(Substitute(NameExpr(myfunc), Expr(_xp), NameExpr(myxp)) );
//this verifies
show(func, myxp, func(2), Derivative(NameExpr(myxp), x));
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertOh, und ich verwende JMP 14
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertDanke für Ihre Antwort.
Die Integrate-Funktion hat eines meiner Probleme gelöst.
Vielleicht verstehe ich nicht alles in Ihrem Code, aber ich kann JSL immer noch nicht dazu bringen, mir die Ableitung einer benannten Funktion zu liefern. Mit anderen Worten, ich möchte der1=der2 im Code:
func = Function({x},x^2);
der1 = Derivative(x^2,x);
der2 = Derivative(func(x),x);Es muss einen Weg geben, dies zu erreichen.
Außerdem speist Ihr Code die Jesper-Funktion ein Ausdruck , nicht die Funktion Name zur Jesper-Funktion. Wie mache ich das? Idealerweise sollte die Jesper-Funktion beides akzeptieren, d. h. Jesper(x^2) = Jesper(func(x))
Betreff: Definieren einer Funktion, die eine andere Funktion als Argument akzeptiertJesper,
Sie haben nicht erwähnt, welche Version von JMP Sie verwenden. JMP 12 und höher verfügen sowohl über die Funktionen „integrate()“ als auch „symbolic derivative()“.
Im Anhang finden Sie ein Beispiel. Es entsteht nicht die asymptotische lineare Formel, sondern nur eine einfache Linearität. Das Ziel dieses Skripts besteht jedoch darin, die Syntax zu demonstrieren.Um auf symbolische Formeln verweisen zu können, müssen diese Ausdrücke sein.Im Scripting-Index sollten Sie nachschlagen:
- Substitute(), NameExpr, EvalInsert(), Parse(), Simplify() und
- natürlich Integrate(), Derivative(). Hinweis: Verwenden Sie für die Integrationsfunktion einen leeren Punkt (Punkt), um die Unendlichkeit anzugeben.
Die Ergebnisse der Testfälle werden in das Protokollfenster geschrieben und im zweiten Codefenster angezeigt.
Sie sollten Ihre endgültige Version veröffentlichen. Es sieht nach einer coolen Funktion aus.
Names Default to Here(1);
//I think you meant you wanted a formula.
//The Jesper Function just finds the linear function, not the asymptotic linear function ... this code is a syntax example.
funList = {2*x+3, 2^x + 3, 2*sqrt(x)+1.2}; //test case for 3 formulas for x1=1 and x2=2, i.e. cntr=1.5, delta=0.5
Jesper = Function({form_xp, cntr, delta}, {x1, x2, y1, y2, m, b, err_xp, err, deriv },
x1 = cntr - delta;
x2 = cntr + delta;
y1 = Eval( Substitute(NameExpr(form_xp), Expr(x), x1 ));
y2 = Eval( Substitute(NameExpr(form_xp), Expr(x), x2 ));
m = (y2-y1)/(x2-x1) ;
b = y2 - m*x2;
lin_xp = Parse( EvalInsert( "^m^*x + ^b^"));
err_xp = Substitute(Expr((a)-(b)), Expr(a), NameExpr(form_xp), Expr(b), NameExpr(lin_xp) );
err_xp = SimplifyExpr(NameExpr(err_xp));
err = 1/(2*delta) * Eval ( Substitute( NameExpr(Integrate(_xp, x, _lo, _hi)), Expr(_xp), NameExpr(err_xp), Expr(_lo), x1, Expr(_hi), x2) );
deriv = Derivative(NameExpr(form_xp), x);
Eval List({err, NameExpr(form_xp), NameExpr(lin_xp), NameExpr(err_xp), NameExpr(deriv)});
);
for(i=1 ,i<=nitems(funlist), i++,
{err, func_xp, line_xp, err_xp, deriv_xp} =Jesper(funlist[i], 1.5, .5);
show(i, err, func_xp, line_xp, err_xp, deriv_xp);
write("\!N" ||Repeat("-", 80) );
);Die Ergebnisse dieser 3 Formeln sind
/*:
i = 1;
err = 0;
func_xp = 2 * x + 3;
line_xp = 2 * x + 3;
err_xp = 0;
deriv_xp = 2;
--------------------------------------------------------------------------------
i = 2;
err = -0.114609918222073;
func_xp = 2 ^ x + 3;
line_xp = 2 * x + 3;
err_xp = -2 * x + 2 ^ x;
deriv_xp = 2 ^ x * Log(2);
--------------------------------------------------------------------------------
i = 3;
err = 0.0236892706214399;
func_xp = 2 * Sqrt(x) + 1.2;
line_xp = 0.82842712474619 * x + 2.37157287525381;
err_xp = (-1.17157287525381) + -0.82842712474619 * x + 2 * Sqrt(x);
deriv_xp = 2 * (0.5 / Sqrt(x));
--------------------------------------------------------------------------------
