Rendimento in Mathematica

Question

Si può fare qualcosa come la dichiarazione di rendimento di Python in Mathematica, al fine di creare generatori? Vedi per es. here per il concetto.

Aggiornamento Ecco un esempio di ciò che intendo, a iterare su tutte le permutazioni, utilizzando solo O (n) Spazio: (Algoritmo come nel libro algoritmi di Sedgewick):

gen[f_, n_] := Module[{id = -1, val = Table[Null, {n}], visit}, 
    visit[k_] := Module[{t}, 
    id++; If[k != 0, val[[k]] = id]; 
    If[id == n, f[val]]; 
    Do[If[val[[t]] == Null, visit[t]], {t, 1, n}]; 
    id--; val[[k]] = Null;]; 
    visit[0]; 
    ] 

Poi chiamare lo come:

gen[Print,3], la stampa di tutti i 6 permutazioni di lunghezza 3.

Answer 1

Come ho detto in precedenza, utilizzando Compile verrà assegnato un codice più veloce. Utilizzando un algoritmo dal fxtbook, il seguente codice genera una prossima partizione ordinamento lessicografico:

PermutationIterator[f_, n_Integer?Positive, nextFunc_] := 
Module[{this = Range[n]}, 
    While[this =!= {-1}, f[this]; this = nextFunc[n, this]];] 

Il codice seguente presuppone che gestiscono la versione 8:

ClearAll[cfNextPartition]; 
cfNextPartition[target : "MVM" | "C"] := 
    cfNextPartition[target] = 
    Compile[{{n, _Integer}, {this, _Integer, 1}}, 
    Module[{i = n, j = n, ni, next = this, r, s}, 
    While[Part[next, --i] > Part[next, i + 1], 
     If[i == 1, i = 0; Break[]]]; 
    If[i == 0, {-1}, ni = Part[next, i]; 
     While[ni > Part[next, j], --j]; 
     next[[i]] = Part[next, j]; next[[j]] = ni; 
     r = n; s = i + 1; 
     While[r > s, ni = Part[next, r]; next[[r]] = Part[next, s]; 
     next[[s]] = ni; --r; ++s]; 
     next 
     ]], RuntimeOptions -> "Speed", CompilationTarget -> target 
    ]; 

Poi

In[75]:= Reap[PermutationIterator[Sow, 4, cfNextPartition["C"]]][[2, 
    1]] === Permutations[Range[4]] 

Out[75]= True 

Questo è chiaramente migliore nelle prestazioni rispetto alla funzione originale gen.

In[83]:= gen[dummy, 9] // Timing 

Out[83]= {26.067, Null} 

In[84]:= PermutationIterator[dummy, 9, cfNextPartition["C"]] // Timing 

Out[84]= {1.03, Null} 

mezzo della macchina virtuale di Mathematica non è molto più lento:

In[85]:= PermutationIterator[dummy, 9, 
    cfNextPartition["MVM"]] // Timing 

Out[85]= {1.154, Null} 

Naturalmente questo non è neanche lontanamente implementazione del codice C, ma fornisce un notevole velocità-up su codice puro di livello superiore.

Answer 2

probabilmente dire la questione di essere più generale, ma l'esempio di iterare su permutatio ns come indicato sulla pagina si collega a sembra essere integrata in Mathematica:

Scan[Print, Permutations[{1, 2, 3}]] 

Il Print non ci può essere sostituito con qualsiasi funzione.