Obtenir mathematica pour simplifier l'expression à une autre équation

Quelque chose le long de ces lignes est discuté dans le MathGroup poste à

http://forums.wolfram.com/mathgroup/archive/2009/Oct/msg00023.html

(Je vois qu'il a un apocryphe remarque qui est tout à fait pertinente, au moins pour l'auteur de ce post.)

Ici est de savoir comment il pourrait être appliqué dans l'exemple ci-dessus. Pour les fins de la conservation de cette indépendants je le répète, le code de remplacement.

replacementFunction[expr_, rep_, vars_] := 
 Module[{num = Numerator[expr], den = Denominator[expr], 
   hed = Head[expr], base, expon}, 
  If[PolynomialQ[num, vars] && 
    PolynomialQ[den, vars] && ! NumberQ[den], 
   replacementFunction[num, rep, vars]/
    replacementFunction[den, rep, vars], 
   If[hed === Power && Length[expr] == 2, 
    base = replacementFunction[expr[[1]], rep, vars];
    expon = replacementFunction[expr[[2]], rep, vars];
    PolynomialReduce[base^expon, rep, vars][[2]], 
    If[Head[hed] === Symbol && 
      MemberQ[Attributes[hed], NumericFunction], 
     Map[replacementFunction[#, rep, vars] &, expr], 
     PolynomialReduce[expr, rep, vars][[2]]]]]]

Votre exemple est maintenant comme suit. Nous prenons en entrée, et aussi le remplacement. Pour ces derniers, nous avons un équivalent polynôme par compensation des dénominateurs.

kK = a*b*t/((t + f) c*d);
rep = Numerator[Together[p - t/(t + f)]];

Maintenant, nous pouvons invoquer le remplacement. Nous avons la liste des variables qui nous intéressent dans le remplacement, le traitement de " p " comme paramètre. De cette façon, il sera obtenir commandé plus bas que les autres, ce qui signifie le remplacement vais essayer de les supprimer en faveur de 'p'.

In[127]:= replacementFunction[kK, rep, {t, f}]
Out[127]= (a b p)/(c d)

Cette approche a un peu de magie dans la compréhension de ce que devrait être la liste des "variables". Peut-être certains autres tweakage qui pourrait être fait pour l'améliorer. Mais je crois que, en général, il suffit de ne pas inscrire les choses que nous voulons utiliser comme nouveau remplacement est la bonne façon de faire.

Au fil des années il y a eu des variantes de cette idée sur MathGroup. Il est possible que certains autres peuvent être mieux adaptés à l'expression spécifique(s) que vous souhaitez gérer.

--- edit ---

L'idée derrière cela est d'utiliser PolynomialReduce faire algébrique de remplacement. C'est-à-dire, nous n'essayons pas de filtrage mais au lieu d'utiliser polynôme de "canonisation", une méthode. Mais en général, nous ne travaillons pas avec polynôme entrées. Si on applique cette idée de manière récursive sur PolynomialQ arguments à l'intérieur de NumericQ fonctions.

Les versions antérieures de cette idée, avec un peu plus d'explication, peut être trouvé à la note référencée ci-dessous, ainsi que dans les notes, les références (explicatif de la récursivité?).

http://forums.wolfram.com/mathgroup/archive/2006/Aug/msg00283.html

--- fin de l'édition ---

--- edit 2 ---

Comme observé dans la nature, cette approche n'est pas toujours simplifier. Il ne algébrique de remplacement, ce qui implique, sous le capot, une notion de "terme de commande" (en gros, les "choses" sont remplacés par de qui d'autres?") et ainsi de simples variables, il peut s'étendre à plus d'expressions.

Une autre forme de réécriture de termes est syntaxiques remplacement par filtrage, et d'autres réponses de discuter de l'utilisation de cette approche. Il a un autre inconvénient, dans la mesure où la généralité des modèles à prendre en considération peuvent devenir écrasante. Par exemple, que fait-on avec k^2/(w + p^4)^3 lorsque la règle est de remplacer k/(w + p^4) avec q? (Plus précisément, comment reconnaissons-nous cela comme étant équivalent à (k/(w + p^4))^2*1/(w + p^4)?)

Du coup, il faut avoir une idée de ce qui est souhaité et ce que les méthodes pourrait être faisable. Bien sûr, cela est généralement problème spécifique.

Une chose qui se produit est peut-être que vous voulez rechercher et remplacer toutes les fréquentes "compliqué", des expressions plus simples. C'est dénommée commune de la sous-expression de l'élimination (CST). Dans Mathematica, ce qui peut être fait à l'aide d'une fonction appelée Expérimentale'OptimizeExpression[]. Voici plusieurs liens pour MathGroup posts qui traitent de ce.

http://forums.wolfram.com/mathgroup/archive/2009/Jul/msg00138.html

http://forums.wolfram.com/mathgroup/archive/2007/Nov/msg00270.html

http://forums.wolfram.com/mathgroup/archive/2006/Sep/msg00300.html

http://forums.wolfram.com/mathgroup/archive/2005/Jan/msg00387.html

http://forums.wolfram.com/mathgroup/archive/2002/Jan/msg00369.html

Voici un exemple de l'une de ces notes.

InputForm[Experimental`OptimizeExpression[(3 + 3*a^2 + Sqrt[5 + 6*a + 5*a^2] +
      a*(4 + Sqrt[5 + 6*a + 5*a^2]))/6]]

Out[206]//InputForm=
Experimental`OptimizedExpression[Block[{Compile`$1, Compile`$3, Compile`$4, 
   Compile`$5, Compile`$6}, Compile`$1 = a^2; Compile`$3 = 6*a; 
   Compile`$4 = 5*Compile`$1; Compile`$5 = 5 + Compile`$3 + Compile`$4; 
   Compile`$6 = Sqrt[Compile`$5]; (3 + 3*Compile`$1 + Compile`$6 + 
     a*(4 + Compile`$6))/6]]

--- fin edit 2 ---

Daniel Lichtblau

OriginalL'auteur