¿Previene el reordenamiento en la salida derivada?

A recent post on the Wolfram Blog ofrece la siguiente función para formatear derivados de una manera más tradicional.¿Previene el reordenamiento en la salida derivada?

pdConv[f_] := 
TraditionalForm[ 
    f /. Derivative[inds__][g_][vars__] :> 
    Apply[Defer[D[g[vars], ##]] &, 
    Transpose[{{vars}, {inds}}] /. {{var_, 0} :> 
     Sequence[], {var_, 1} :> {var}}] 
]

Un ejemplo de uso, Dt[d[x, a]] // pdConv da:

enter image description here

sin romper las capacidades generales de pdConv, alguien puede alterar para mantener el orden dado de variables, la producción de la salida se muestra a continuación? (Por supuesto esto es puramente por razones asthetic, haciendo derivaciones más fácil para un ser humano a seguir)

enter image description here

Sospecho que esto será no trivial de implementar --- a menos que alguien sabe de una opción mágica que puede ser Global temporalmente anulado dentro de un Block.

Por lo que vale la pena, estos lo que las preguntas pueden estar relacionadas:

Fuente

2011-12-24 telefunkenvf14

Interesante pregunta. ¿Podría ser un poco más específico cuando diga * el orden dado [de] variables *? –

@ Mr.Wizard - Para aclarar, si f [b, a] es la función alimentada a Dt, me gustaría que la diferenciación total salga como Dt [b] * D [f, b] + Dt [a] * D [f, a], en lugar de ordenar la salida a Dt [a] * D [f, a] + Dt [b] * D [f, b]. (Ustedes parecen haberse dado cuenta de esto a continuación ... no quería dejar su pregunta pendiente). – telefunkenvf14

Probablemente hay una forma más limpia de hacer s, pero si es puramente para fines de presentación , podría hacer algo como

pdConv[f_, vv_] := 
Module[{v}, 
    (HoldForm[ 
     [email protected] 
     TraditionalForm[((f /. Thread[vv -> #]) /. 
      Derivative[inds__][g_][vars__] :> 
      Apply[Defer[D[g[vars], ##]] &, 
      Transpose[{{vars}, {inds}}] /. {{var_, 0} :> 
       Sequence[], {var_, 1} :> {var}}])]] /. 
     Thread[# -> vv]) &@ Table[Unique[v], {Length[vv]}]]

Aquí, el parámetro adicional vv es una lista de las variables en f en el orden en que desea que aparezcan las derivadas parciales. Para utilizar esta función, se haría algo como

pdConv[Dt[d[x, c]], {x, c}]

equations in right order

Básicamente lo que hace esta solución es sustituir temporalmente la lista de variables vv con una lista de variables ficticias que están en el orden lexicográfico derecha, aplique la transformación y luego reemplace las variables ficticias con las variables originales mientras conserva el orden deseado envolviendo la expresión transformada en HoldForm.

Fuente

2011-12-24 12:37:43 Heike

¡Me ganaste! Y probablemente también funcione mejor. –

@ Mr.Wizard Supongo que hay una primera para todo ;-) – Heike

¿Puedo tomar prestada su idea de sustitución e implementarla en mi propio estilo, o preferiría que no? –

Revisado después de ver el método superior de Heike. Con suerte sin romperlo.

ClearAll[pdConv] 

pdConv[order_List][f_] := 
    With[{R = Thread[order -> [email protected]]}, 
    [email protected]@# /. Reverse[R, 2] &[ 
    f /. R /. Derivative[inds__][g_][vars__] :> 
     ([email protected][g[vars], ##] & @@ Pick[{vars}, {inds}, 1])] 
    ]

Uso:

Dt[d[x, a]] // pdConv[{x, a}] 

Dt[d[x, a, c, b]] // pdConv[{x, a, c, b}]

pedido automático para un caso estrecha:

ClearAll[pdConvAuto] 
SetAttributes[pdConvAuto, HoldFirst] 

pdConvAuto[f : [email protected][email protected]__] := 
    With[{R = Thread[{syms} -> [email protected]{syms}]}, 
    [email protected]@# /. Reverse[R, 2] &[ 
    f /. R /. Derivative[inds__][g_][vars__] :> 
     ([email protected][g[vars], ##] & @@ Pick[{vars}, {inds}, 1])] 
    ]

Uso:

Dt[d[x, a, c, b]] // pdConvAuto

Fuente

2011-12-24 12:38:41

¡Eres rápido! Jugaré con eso e informaré. También puede consultar algunos de los otros ejemplos de la publicación de blog de Wolfram (para confirmar que aún funcionan). – telefunkenvf14

Me di cuenta de que Dt[d[x, a, c, b]] ya da salida ordenada, solo a la inversa.Probablemente esté malinterpretando la situación, pero en algunos casos esto parece ser suficiente:

ClearAll[pdConv] 

pdConv[f_] := 
Apply[Plus, [email protected]@#, {2}] &[ 
    Reverse[List @@ f] /. Derivative[inds__][g_][vars__] :> 
    ([email protected][g[vars], ##] & @@ Pick[{vars}, {inds}, 1]) 
    ] 

Dt[d[x, a, r, c, b]] // pdConv

Fuente

2011-12-24 14:42:42

¿Previene el reordenamiento en la salida derivada?

Respuesta

Cuestiones relacionadas