Mathematica: reconstruir una lista anidada arbitraria después de Flatten

Question

¿Cuál es la forma más simple de asignar una lista anidada arbitrariamente funky expr a una función unflatten de modo que expr==unflatten@@Flatten@expr?

motivación: Compile sólo puede manejar matrices completas (algo que acaba de aprender - pero no del mensaje de error), por lo que la idea es utilizar unflatten junto con una versión compilada de la expresión aplanado:

fPrivate=Compile[{x,y},Evaluate@Flatten@expr]; 
f[x_?NumericQ,y_?NumericQ]:=unflatten@@fPrivate[x,y] 

Ejemplo de una solución a un problema menos general: Lo que en realidad lo que necesito hacer es calcular todas las derivadas de una función multivariable renunciado a algún orden. Para este caso, me hackeo mi camino a lo largo de esta manera:

expr=Table[D[x^2 y+y^3,{{x,y},k}],{k,0,2}]; 
unflatten=Module[{f,x,y,a,b,sslot,tt}, 
    tt=Table[D[f[x,y],{{x,y},k}],{k,0,2}] /. 
    {Derivative[a_,b_][_][__]-> x[a,b], f[__]-> x[0,0]}; 
    (Evaluate[tt/.MapIndexed[#1->sslot[#2[[1]]]&, 
      Flatten[tt]]/. sslot-> Slot]&) ] 

Out[1]= {x^2 y + y^3, {2 x y, x^2 + 3 y^2}, {{2 y, 2 x}, {2 x, 6 y}}} 
Out[2]= {#1, {#2, #3}, {{#4, #5}, {#5, #7}}} & 

Esto funciona, pero no es ni elegante ni general.

Editar: Aquí está la versión "seguridad en el empleo" de la solución proporcionada por aaz:

makeUnflatten[expr_List]:=Module[{i=1}, 
    Function@Evaluate@ReplaceAll[ 
     If[ListQ[#1],Map[#0,#1],i++]&@expr, 
     i_Integer-> Slot[i]]] 

Funciona a las mil maravillas:

In[2]= makeUnflatten[expr] 
Out[2]= {#1,{#2,#3},{{#4,#5},{#6,#7}}}& 

Answer 1

Obviamente necesita guardar algo de información sobre la estructura de la lista, porque Flatten[{a,{b,c}}]==Flatten[{{a,b},c}].

Si ArrayQ[expr], la estructura de lista está dada por Dimensions[expr] y puede reconstruirla con Partition. P.ej.

expr = {{a, b, c}, {d, e, f}}; 
dimensions = Dimensions[expr] 

    {2,3} 

unflatten = Fold[Partition, #1, Reverse[Drop[dimensions, 1]]]&; 
expr == unflatten @ Flatten[expr] 

(. La página Partition hombre tiene en realidad un ejemplo similar llamado unflatten)

---

Si expr no es una matriz, puede intentar esto:

expr = {a, {b, c}}; 
indexes = Module[{i=0}, If[ListQ[#1], Map[#0, #1], ++i]& @expr] 

    {1, {2, 3}} 

slots = indexes /. {i_Integer -> Slot[i]} 

    {#1, {#2, #3}} 

unflatten = Function[Release[slots]] 

    {#1, {#2, #3}} & 

expr == unflatten @@ Flatten[expr] 

Answer 2

No estoy seguro de lo que está tratando para hacer con Compile. Se utiliza cuando desea evaluar expresiones de procedimiento o funcionales muy rápidamente en valores numéricos, por lo que no creo que vaya a ayudar aquí. Si los cálculos repetidos de D [f, ...] están impidiendo su rendimiento, puede precalcularlos y almacenarlos con algo como Table[d[k]=D[f,{{x,y},k}],{k,0,kk}];

Luego simplemente llame a d [k] para obtener la derivada kth.

Answer 3

Sólo quería para actualizar las excelentes soluciones de aaz y Janus. Parece que, al menos en Mathematica 9.0.1.0 en Mac OS X, la asignación (ver la solución de aaz)

{i_Integer -> Slot[i]} 

falla. Sin embargo, si utilizamos

{i_Integer :> Slot[i]} 

, lo conseguimos. Lo mismo vale, por supuesto, para la llamada ReplaceAll en la versión de "seguridad laboral" de Janus.

Para una buena medida, incluyo mi propia función.

unflatten[ex_List, exOriginal_List] := 
    Module[ 
    {indexes, slots, unflat}, 
    indexes = 
    Module[ 
     {i = 0}, 
     If[ListQ[#1], Map[#0, #1], ++i] &@exOriginal 
     ]; 
    slots = indexes /. {i_Integer :> Slot[i]}; 
    unflat = Function[Release[slots]]; 
    unflat @@ ex 
    ]; 

(* example *) 
expr = {a, {b, c}}; 
expr // Flatten // unflatten[#, expr] & 

Podría parecer un poco como una trampa de utilizar la expresión original en la función, pero como señala aaz, necesitamos alguna información de la expresión original. Si bien no lo necesita todo, para tener una única función que puede unflatten, todo es necesario.

Mi aplicación es similar a la de Janus: estoy paralelizando las llamadas a Simplify para un tensor. Usando ParallelTable puedo mejorar significativamente el rendimiento, pero arruino la estructura del tensor en el proceso. Esto me da una forma rápida de reconstruir mi tensor original, simplificado.