Définir une fonction qui prend une autre fonction comme argumentSalut
J'essaie de définir une fonction qui calcule l'erreur de supposer la linéarité dans une région d'une autre fonction.
Ma fonction doit effectuer les opérations suivantes :
- Acceptez 3 entrées, la fonction non linéaire (de préférence juste un nom de fonction défini ailleurs, f(x)), le centre de la région (xi) et la demi-largeur de la région étudiée (delta).
- Générer la pente et l'ordonnée à l'origine de la fonction linéaire asymptote en xi, Lin(x).
- Générer une fonction d'erreur err(x) = Lin(x) - f(x), err(xi) = 0 par définition.
- Intégrez err(x), de xi-delta à xi+delta, et divisez par 2*delta, pour trouver l'erreur moyenne dans la région.
- Utilisez l'erreur moyenne pour calculer l'écart type de l'erreur dans la région (implique également l'intégration)
En essayant de faire cela, je me heurte à trois problèmes:
- Comment puis-je faire en sorte que Function-function dans jsl accepte une autre fonction en entrée?
- Comment obtenir la fonction Derivative pour différencier un argument de fonction, fourni par le nom de la fonction, par exemple Derivative(f(x),x) ?
- Comment faire en sorte que jsl intègre une fonction dans certaines régions ? Je ne trouve pas de fonction intégrée pour le faire.
J'espère que certains pourront aider.
Re : Définir une fonction qui prend une autre fonction comme argumentJuste un FYI à quiconque suivait ce post. Le support JMP a fourni une autre méthode pour obtenir l'expression à partir d'une fonction déjà définie. C'est une alternative à Capture Log( Show(func) );
funcExpr = Parse( "Expr(" || Char( Name Expr( func ) ) || ")" );
innerf = Arg( Arg( funcExpr, 1 ), 2 );
Re : Définir une fonction qui prend une autre fonction comme argumentJe pense que vos suggestions m'ont aidé sur le chemin.
Entre-temps, j'ai changé d'avis sur ce que je veux que la fonction fasse.
Mais voici ce que j'ai obtenu jusqu'à présent :
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);
);Je prends une expression comme argument par opposition à une fonction, mais vous avez fourni une solution pour cela. Il n'est tout simplement pas encore mis en œuvre.
Merci!
Re : Définir une fonction qui prend une autre fonction comme argumentNote du blogueur pour info
JMP 14 a un nouvel objet appelé Fonction personnalisée, avec des messages utiles. J'ai demandé un message Get Expr comme amélioration. Je ne pense pas que cela s'applique à votre demande, cependant, il serait plus simple d'obtenir la fonction : func << Get Function, au lieu des 2 étapes avec LogCapture(show(func)) etc...
Re : Définir une fonction qui prend une autre fonction comme argumentJesper,
Je sais que vous aimeriez trouver Derivative( f(x), x), cependant, la fonction Derivative symbolique JMP nécessite que le premier argument soit une expression.Il pourrait être plus facile de vous aider, si vous expliquez comment vous voulez que cela fonctionne. Je suppose que vous voulez créer votre propre fonction ou application qui a 3 arguments et vous avez mentionné f(x), mais où et comment f(x) est-il lu ou défini ?
Les expressions et fonctions JMP essaient d'évaluer immédiatement.Copiez ce bloc de code suivant dans une fenêtre de script, cliquez avec le bouton droit pour afficher le journal intégré, puis mettez en surbrillance et exécutez les segments de code et examinez les résultats dans le journal. C'est ainsi que fonctionnent les fonctions et les expressions JMP.
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)
Ainsi, la seule méthode que je connaisse pour utiliser la fonction intégrée Derivative() est de faire du premier argument une expression.
Votre question a soulevé une question intéressante, comment JSL peut-il extraire l'argument de l'expression (le dernier argument) d'une fonction utilisateur déjà définie.Peut-être que d'autres blogueurs experts ont une meilleure solution. Ou peut-être s'agit-il d'un élément de la liste de souhaits indiquant qu'une future version de JMP fournit une fonction ou un message qui extrait l'expression d'une fonction définie par l'utilisateur.
Le bloc de code suivant montre une méthode pour extraire l'expression d'une fonction définie par l'utilisateur.
Alors, faites savoir au blog comment la fonction est lue (créée) et vous obtiendrez peut-être une solution plus acceptable. Par exemple, si votre application invite l'utilisateur à saisir une fonction dans une zone de texte, il peut être plus simple de travailler avec du texte.
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));
Re : Définir une fonction qui prend une autre fonction comme argumentOh, et j'utilise JMP 14
Re : Définir une fonction qui prend une autre fonction comme argumentMerci pour votre réponse.
La fonction Integrate a résolu un de mes problèmes.
Peut-être que je ne comprends pas tout dans votre code, mais je n'arrive toujours pas à ce que jsl me donne la dérivée d'une fonction nommée. En d'autres termes, je veux der1=der2 dans le code :
func = Function({x},x^2);
der1 = Derivative(x^2,x);
der2 = Derivative(func(x),x);Il doit y avoir un moyen d'y parvenir.
De plus, votre code alimente la fonction Jesper et expression , pas la fonction nom à la fonction Jesper. Comment puis-je faire cela? Idéalement, la fonction Jesper devrait accepter les deux, c'est-à-dire Jesper(x^2) = Jesper(func(x))
Re : Définir une fonction qui prend une autre fonction comme argumentJesper,
Vous n'avez pas mentionné la version de JMP que vous utilisez. JMP 12 et les versions ultérieures disposent à la fois des fonctionsintegrate() et des fonctions symboliques derivative().
Ci-joint un exemple. Il ne crée pas la formule linéaire asymptotique juste une simple linéaire. Mais le but de ce script est de démontrer la syntaxe.Pour référencer des formules symboliques, elles doivent être des expressions.Dans tehscripting Index, vous devriez rechercher :
- Substitute(), NameExpr, EvalInsert(), Parse(), Simplify() et
- bien sûr, Integrate(), Derivative(). Remarque pour la fonction d'intégration, utilisez un vide (point) pour spécifier l'infini.
Les résultats des scénarios de test sont écrits dans la fenêtre Journal et affichés dans la deuxième fenêtre de code.
Vous devriez poster votre version finale. Cela ressemble à une fonction cool.
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) );
);Les résultats de ces 3 formules sont
/*:
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));
--------------------------------------------------------------------------------
