Cosa c’è nella borsa degli attrezzi Mathematica?

Sappiamo tutti che Mathematica è ottima, ma spesso manca anche delle funzionalità critiche. Che tipo di pacchetti / strumenti / risorse esterni usi con Mathematica?

Modificherò (e invito chiunque altro a fare altrettanto) questo post principale per includere risorse che sono focalizzate sull’applicabilità generale nella ricerca scientifica e che troveranno utili quante più persone ansible. Sentiti libero di contribuire con qualsiasi cosa, anche piccoli frammenti di codice (come ho fatto in seguito per una routine di temporizzazione).

Inoltre, le funzionalità non documentate e utili in Mathematica 7 e oltre ti sei ritrovato o sono state benvenute da alcuni documenti / siti.

Si prega di includere una breve descrizione o un commento sul perché qualcosa è big o quale utilità fornisce. Se si collega ai libri su Amazon con link affiliati, si prega di citarli, ad esempio, inserendo il proprio nome dopo il collegamento.


Pacchetti:

  1. LevelScheme è un pacchetto che amplia notevolmente la capacità di Mathematica di produrre grafici di buona qualità. Lo uso se non altro per il molto, molto migliorato controllo sui ticks frame / axes. La sua versione più recente si chiama SciDraw e verrà rilasciata a partire da quest’anno.
  2. Presentation Package del David Park (US $ 50 – nessun addebito per gli aggiornamenti)
  3. Il pacchetto grassmannOps Jeremy Michelson fornisce risorse per fare algebra e calcolo con variabili di Grassmann e operatori che hanno relazioni di commutazione non banali.
  4. Pacchetto e libro di John Brown su GrassmannAlgebra per lavorare con le algebre di Grassmann e Clifford.
  5. RISC (Research Institute for Symbolic Computation) ha una varietà di pacchetti per Mathematica (e altre lingue) disponibili per il download. In particolare, c’è Teorema per la dimostrazione automatica del teorema e la moltitudine di pacchetti per la sumtoria simbolica, equazioni alle differenze, ecc. Nella pagina del software del gruppo Algorithmic Combinatorics .

Utensili:

  1. MASH è l’eccellente script Perl di Daniel Reeves che fornisce essenzialmente supporto per script per Mathematica v7. (Ora integrato in Mathematica 8 con l’opzione -script .)
  2. Una alternate Mathematica shell con un input di readline GNU (usando solo python, * nix)
  3. Il pacchetto ColourMaths ti consente di selezionare visivamente parti di un’espressione e manipolarle. http://www.dbaileyconsultancy.co.uk/colour_maths/colour_maths.html

risorse:

  1. Il repository di Wolfram MathSource ha un sacco di utili taccuini stretti per varie applicazioni. Controlla anche le altre sezioni come

    • Current Documentation ,
    • Courseware per lezioni,
    • e Demos per, beh, demo.
  2. The Mathematica Wikibook .

Libri:

  1. Programmazione Mathematica: un’avanzata introduzione di Leonid Shifrin ( web , pdf ) è una lettura obbligata se si vuole fare qualcosa di più di For loop in Mathematica. Abbiamo il piacere di avere Leonid stesso a rispondere alle domande qui.
  2. Metodi Quantici con Mathematica di James F. Feagin ( amazon )
  3. The Mathematica Book di Stephen Wolfram ( amazon ) ( web )
  4. Schaum’s Outline ( amazon )
  5. Mathematica in Action di Stan Wagon ( amazon ) – 600 pagine di esempi accurati e risalgono alla versione 7. di Mathematica. Le tecniche di visualizzazione sono particolarmente buone, puoi vederne alcune nella Demonstrations Page dell’autore.
  6. Mathematica Programming Fundamentals di Richard Gaylord ( pdf ) – Una buona introduzione concisa alla maggior parte di ciò che è necessario sapere sulla programmazione Mathematica.
  7. Ricette Mathematica di Sal Mangano pubblicate da O’Reilly 2010 832 pagine. – Scritto nel noto stile di libri di ricette O’Reilly: Problema – Soluzione. Per intermedi
  8. Equazioni differenziali con Mathematica, 3a Ed. Elsevier 2004 Amsterdam di Martha L. Abell, James P. Braselton – 893 pagine Per i principianti, impara a risolvere DE e Mathematica allo stesso tempo.

Funzionalità non documentate (o scarsamente documentate):

  1. Come personalizzare le scorciatoie da tastiera di Mathematica. Vedi this question
  2. Come controllare i modelli e le funzioni utilizzate dalle funzioni di Mathematica. Vedi this answer
  3. Come ottenere dimensioni coerenti per GraphPlots in Mathematica? Vedi this question
  4. Come produrre documenti e presentazioni con Mathematica. Vedi this question

Ne ho già parlato in precedenza, ma lo strumento che ritengo più utile è un’applicazione di Reap and Sow che riproduce / estende il comportamento di GatherBy :

 SelectEquivalents[x_List,f_:Identity, g_:Identity, h_:(#2&)]:= Reap[Sow[g[#],{f[#]}]&/@x, _, h][[2]]; 

Ciò mi consente di raggruppare gli elenchi in base a qualsiasi criterio e trasformarli nel processo. Il modo in cui funziona è che una funzione di criteri ( f ) contrassegna ogni elemento nell’elenco, ogni object viene quindi trasformato da una seconda funzione fornita ( g ) e l’output specifico è controllato da una terza funzione ( h ). La funzione h accetta due argomenti: un tag e un elenco degli elementi raccolti che hanno quel tag. Gli oggetti mantengono il loro ordine originale, quindi se imposti h = #1& ottieni un’unione non ordinata, come negli esempi per Reap . Ma può essere usato per l’elaborazione secondaria.

Come esempio della sua utilità, ho lavorato con Wannier90 che emette l’Hamiltoniana dipendente dallo spazio in un file in cui ogni riga è un elemento diverso nella matrice, come segue

 rx ry rz ij Re[Hij] Im[Hij] 

Per trasformare quella lista in un insieme di matrici, ho raccolto tutte le sottoliste che contengono la stessa coordinata, trasformate le informazioni sull’elemento in una regola (cioè {i, j} -> Re [Hij] + I Im [Hij]), e quindi ha trasformato le regole raccolte in un SparseArray con tutte le SparseArray :

 SelectEquivalents[hamlst, #[[;; 3]] &, #[[{4, 5}]] -> (Complex @@ #[[6 ;;]]) &, {#1, SparseArray[#2]} &] 

Onestamente, questo è il mio Swiss Army Knife, e rende le cose complesse molto semplici. Molti dei miei altri strumenti sono in qualche modo specifici del dominio, quindi probabilmente non li posterò. Tuttavia, la maggior parte, se non tutti, di essi fa riferimento a SelectEquivalents .

Modifica : non imita completamente GatherBy in quanto non può raggruppare più livelli dell’espressione come semplicemente GatherBy . Tuttavia, Map funziona perfettamente per la maggior parte di ciò di cui ho bisogno.

Esempio : @Yaroslav Bulatov ha chiesto un esempio autonomo. Ecco uno dei miei studi che è stato notevolmente semplificato. Quindi, diciamo che abbiamo un insieme di punti in un piano

 In[1] := pts = {{-1, -1, 0}, {-1, 0, 0}, {-1, 1, 0}, {0, -1, 0}, {0, 0, 0}, {0, 1, 0}, {1, -1, 0}, {1, 0, 0}, {1, 1, 0}} 

e vorremmo ridurre il numero di punti mediante una serie di operazioni di simmetria. (Per i curiosi, stiamo generando il piccolo gruppo di ciascun punto.) Per questo esempio, utilizziamo un asse di rotazione a quattro pieghe attorno all’asse z

 In[2] := rots = RotationTransform[#, {0, 0, 1}] & /@ (Pi/2 Range[0, 3]); 

Usando SelectEquivalents possiamo raggruppare i punti che producono lo stesso insieme di immagini sotto queste operazioni, cioè sono equivalenti, usando il seguente

 In[3] := SelectEquivalents[ pts, Union[Through[rots[#] ] ]& ] (*<-- Note Union*) Out[3]:= {{{-1, -1, 0}, {-1, 1, 0}, {1, -1, 0}, {1, 1, 0}}, {{-1, 0, 0}, {0, -1, 0}, {0, 1, 0}, {1, 0, 0}}, {{0,0,0}}} 

che produce 3 sottoliste contenenti i punti equivalenti. (Nota, Union è assolutamente vitale qui in quanto assicura che la stessa immagine sia prodotta da ciascun punto.In origine, ho usato Sort , ma se un punto giace su un asse di simmetria, è invariante sotto la rotazione attorno a quell'asse dando un'immagine aggiuntiva Quindi, Union elimina queste immagini extra. Inoltre, GatherBy produrrebbe lo stesso risultato.) In questo caso, i punti sono già in una forma che userò, ma ho bisogno solo di un punto rappresentativo di ogni gruppo e I ' d come un conteggio dei punti equivalenti. Dal momento che non ho bisogno di trasformare ogni punto, io uso la funzione Identity nella seconda posizione. Per la terza funzione, dobbiamo stare attenti. Il primo argomento passato ad esso sarà le immagini dei punti sotto le rotazioni che per il punto {0,0,0} è una lista di quattro elementi identici e il suo utilizzo eliminerebbe il conteggio. Tuttavia, il secondo argomento è solo un elenco di tutti gli elementi che hanno quel tag, quindi conterrà solo {0,0,0} . Nel codice,

 In[4] := SelectEquivalents[pts, Union[Through[rots[#]]]&, #&, {#2[[1]], Length[#2]}& ] Out[4]:= {{{-1, -1, 0}, 4}, {{-1, 0, 0}, 4}, {{0, 0, 0}, 1}} 

Nota, quest'ultima operazione può essere facilmente eseguita da

 In[5] := {#[[1]], Length[#]}& /@ Out[3] 

Ma è facile con questo e l'esempio meno completo sopra vedere come sono possibili trasformazioni molto complesse con un minimo di codice.

Una delle cose belle dell’interfaccia per notebook Mathematica è che può valutare espressioni in qualsiasi lingua, non solo Mathematica. Come semplice esempio, prendere in considerazione la creazione di un nuovo tipo di cella di input Shell che passa l’espressione contenuta alla shell del sistema operativo per la valutazione.

Innanzitutto, definire una funzione che deleghi la valutazione di un comando testuale alla shell esterna:

 shellEvaluate[cmd_, _] := Import["!"~~cmd, "Text"] 

Il secondo argomento è necessario e ignorato per ragioni che diventeranno evidenti in seguito. Successivamente, vogliamo creare un nuovo stile chiamato Shell :

  1. Apri un nuovo taccuino.
  2. Seleziona la voce di menu Formato / Modifica foglio di stile …
  3. Nella finestra di dialogo, accanto a Inserisci un nome di stile: digitare Shell .
  4. Seleziona la parentesi cella accanto al nuovo stile.
  5. Selezionare la voce di menu Cella / Mostra espressione
  6. Sovrascrivi l’espressione della cella con il passaggio 6 Testo di seguito.
  7. Ancora una volta, seleziona la voce di menu Cella / Mostra espressione
  8. Chiudi la finestra di dialogo.

Usa la seguente espressione di cella come testo del passaggio 6 :

 Cell[StyleData["Shell"], CellFrame->{{0, 0}, {0.5, 0.5}}, CellMargins->{{66, 4}, {0, 8}}, Evaluatable->True, StripStyleOnPaste->True, CellEvaluationFunction->shellEvaluate, CellFrameLabels->{{None, "Shell"}, {None, None}}, Hyphenation->False, AutoQuoteCharacters->{}, PasteAutoQuoteCharacters->{}, LanguageCategory->"Formula", ScriptLevel->1, MenuSortingValue->1800, FontFamily->"Courier"] 

La maggior parte di questa espressione è stata copiata direttamente dallo stile del programma integrato. I cambiamenti chiave sono queste righe:

  Evaluatable->True, CellEvaluationFunction->shellEvaluate, CellFrameLabels->{{None, "Shell"}, {None, None}}, 

Evaluatable abilita la funzionalità MAIUSC + INVIO per la cella. La valutazione chiamerà CellEvaluationFunction passando il contenuto della cella e il tipo di contenuto come argomenti ( shellEvaluate ignora l’ultimo argomento). CellFrameLabels è solo un dettaglio che consente all’utente di identificare che questa cella è insolita.

Con tutto questo a posto, ora possiamo inserire e valutare un’espressione di shell:

  1. Nel blocco note creato nei passaggi precedenti, crea una cella vuota e seleziona la parentesi cella.
  2. Seleziona la voce di menu Formato / Stile / Shell .
  3. Digitare un comando di shell del sistema operativo valido nella cella (ad esempio “ls” su Unix o “dir” su Windows).
  4. Premere MAIUSC + INVIO.

È meglio mantenere questo stile definito in un foglio di stile posizionato centralmente. Inoltre, le funzioni di valutazione come shellEvaluate sono meglio definite come stub utilizzando DeclarePackage in init.m I dettagli di entrambe queste attività vanno oltre lo scopo di questa risposta.

Con questa funzionalità, è ansible creare quaderni che contengono espressioni di input in qualsiasi syntax di interesse. La funzione di valutazione può essere scritta in puro Mathematica o debind parte o tutte le parti della valutazione a un’agenzia esterna. Tieni presente che esistono altri hook correlati alla valutazione delle celle, come CellEpilog , CellProlog e CellDynamicExpression .

Un modello comune prevede la scrittura del testo di espressione di input in un file temporaneo, la compilazione del file in una lingua, l’esecuzione del programma e l’acquisizione dell’output per la visualizzazione finale nella cella di output. Ci sono molti dettagli da affrontare quando si implementa una soluzione completa di questo tipo (come catturare correttamente i messaggi di errore), ma bisogna apprezzare il fatto che non è solo ansible fare cose come questa, ma anche pratiche.

In una nota personale, sono caratteristiche come questa che fanno dell’interfaccia del notebook il centro del mio universo di programmazione.

Aggiornare

La seguente funzione di aiuto è utile per creare tali celle:

 evaluatableCell[label_String, evaluationFunction_] := ( CellPrint[ TextCell[ "" , "Program" , Evaluatable -> True , CellEvaluationFunction -> (evaluationFunction[#]&) , CellFrameLabels -> {{None, label}, {None, None}} , CellGroupingRules -> "InputGrouping" ] ] ; SelectionMove[EvaluationNotebook[], All, EvaluationCell] ; NotebookDelete[] ; SelectionMove[EvaluationNotebook[], Next, CellContents] ) 

È usato così:

 shellCell[] := evaluatableCell["shell", Import["!"~~#, "Text"] &] 

Ora, se viene valutato shellCell[] , la cella di input verrà eliminata e sostituita con una nuova cella di input che valuta il suo contenuto come un comando di shell.

Todd Gayley (Wolfram Research) mi ha appena inviato un bel trucco che permette di “avvolgere” funzioni integrate con codice arbitrario. Sento che devo condividere questo utile strumento. Quello che segue è la risposta di Todd alla mia question .

Un po ‘di storia interessante (?): Quel tipo di hack per “avvolgere” una funzione built-in è stato inventato nel 1994 da Robby Villegas e io, ironicamente per la funzione Message, in un pacchetto chiamato ErrorHelp che ho scritto per il Mathematica Journal allora. È stato usato molte volte, da molte persone, da allora. È un trucco un po ‘strano, ma penso sia giusto dire che è diventato il modo canonico di iniettare il proprio codice nella definizione di una funzione integrata. Ottiene il lavoro ben fatto. Puoi, ovviamente, inserire la variabile $ inMsg in qualsiasi contesto privato che desideri.

 Unprotect[Message]; Message[args___] := Block[{$inMsg = True, result}, "some code here"; result = Message[args]; "some code here"; result] /; ! TrueQ[$inMsg] Protect[Message]; 

Questa non è una risorsa completa, quindi la sto lanciando qui nella sezione delle risposte, ma l’ho trovata molto utile per capire i problemi di velocità (che, sfortunatamente, è una parte importante di ciò che riguarda la programmazione Mathematica).

 timeAvg[func_] := Module[ {x = 0, y = 0, timeLimit = 0.1, p, q, iterTimes = Power[10, Range[0, 10]]}, Catch[ If[(x = First[Timing[(y++; Do[func, {#}]);]]) > timeLimit, Throw[{x, y}] ] & /@ iterTimes ] /. {p_, q_} :> p/iterTimes[[q]] ]; Attributes[timeAvg] = {HoldAll}; 

L’utilizzo è quindi semplicemente [email protected] .

EDIT: Mr. Wizard ha fornito una versione più semplice che elimina Throw and Catch ed è un po ‘più facile da analizzare:

 SetAttributes[timeAvg, HoldFirst] timeAvg[func_] := Do[If[# > 0.3, Return[#/5^i]] & @@ Timing @ Do[func, {5^i}] ,{i, 0, 15}] 

EDIT: Ecco una versione da acl (presa da qui ):

 timeIt::usage = "timeIt[expr] gives the time taken to execute expr, \ repeating as many times as necessary to achieve a total time of 1s"; SetAttributes[timeIt, HoldAll] timeIt[expr_] := Module[{t = Timing[expr;][[1]], tries = 1}, While[t < 1., tries *= 2; t = Timing[Do[expr, {tries}];][[1]];]; t/tries] 

Internal`InheritedBlock

Recentemente ho appreso l’esistenza di una funzione così utile come Internal`InheritedBlock , da questo messaggio di Daniel Lichtblau nel newsgroup ufficiale.

Come ho capito, Internal`InheritedBlock consente di passare una copia di una funzione in uscita all’interno dell’ambito del Block :

 In[1]:= Internal`InheritedBlock[{Message}, Print[Attributes[Message]]; Unprotect[Message]; Message[x___]:=Print[{{x},Stack[]}]; Sin[1,1] ] Sin[1,1] During evaluation of In[1]:= {HoldFirst,Protected} During evaluation of In[1]:= {{Sin::argx,Sin,2},{Internal`InheritedBlock,CompoundExpression,Sin,Print,List}} Out[1]= Sin[1,1] During evaluation of In[1]:= Sin::argx: Sin called with 2 arguments; 1 argument is expected. >> Out[2]= Sin[1,1] 

Penso che questa funzione possa essere molto utile per tutti coloro che hanno bisogno di modificare temporaneamente le funzioni integrate!

Confronto con Block

Cerchiamo di definire alcune funzioni:

 a := Print[b] 

Ora vogliamo passare una copia di questa funzione nello scope Block . Il processo ingenuo non dà quello che vogliamo:

 In[2]:= Block[{a = a}, OwnValues[a]] During evaluation of In[9]:= b Out[2]= {HoldPattern[a] :> Null} 

Ora proviamo ad usare la definizione ritardata nel primo argomento di Block (è anche una funzione non documentata):

 In[3]:= Block[{a := a}, OwnValues[a]] Block[{a := a}, a] Out[3]= {HoldPattern[a] :> a} During evaluation of In[3]:= b 

Vediamo che in questo caso funziona ma non abbiamo una copia dell’originale all’interno dell’ambito del Block .

Ora proviamo Internal`InheritedBlock :

 In[5]:= Internal`InheritedBlock[{a}, OwnValues[a]] Out[5]= {HoldPattern[a] :> Print[b]} 

Abbiamo una copia della definizione originale per a interno dell’ambito del Block e possiamo modificarlo nel modo che vogliamo senza influire sulla definizione globale di a !

Mathematica è uno strumento acuto, ma può tagliarti con il suo comportamento un po ‘ non tipizzato e valanghe di messaggi diagnostici criptici. Un modo per affrontare questo è definire le funzioni seguendo questo idioma:

 [email protected] SetAttributes[zot, ...] zot[a_] := ... zot[b_ /; ...] := ... zot[___] := (Message[zot::invalidArguments]; Abort[]) 

Questo è un gran numero di piatti, che sono spesso tentato di saltare. Soprattutto durante la prototipazione, cosa che accade molto in Mathematica. Quindi, io uso una macro chiamata define che mi permette di rimanere disciplinato, con molto meno standard.

Un uso basilare di define è come questo:

 define[ fact[0] = 1 ; fact[n_ /; n > 0] := n * fact[n-1] ] fact[5] 120 

All’inizio non sembra molto, ma ci sono alcuni vantaggi nascosti. Il primo servizio che define fornisce è che applica automaticamente ClearAll al simbolo che si sta definendo. Ciò garantisce che non vi siano definizioni di avanzi – un’occorrenza comune durante lo sviluppo iniziale di una funzione.

Il secondo servizio è che la funzione che viene definita viene automaticamente “chiusa”. Con questo intendo che la funzione emetterà un messaggio e interromperà se viene invocato con un elenco di argomenti che non corrisponde a una delle definizioni:

 fact[-1] define::badargs: There is no definition for 'fact' applicable to fact[-1]. $Aborted 

Questo è il valore primario di define , che cattura una class di errore molto comune.

Un’altra praticità è un modo conciso per specificare gli attributi sulla funzione che si sta definendo. Rendiamo la funzione Listable :

 define[ fact[0] = 1 ; fact[n_ /; n > 0] := n * fact[n-1] , Listable ] fact[{3, 5, 8}] {6, 120, 40320} 

Oltre a tutti gli attributi normali, define accetta un attributo aggiuntivo chiamato Open . Ciò impedisce di define aggiungendo la definizione di errore catch-all alla funzione:

 define[ successor[x_ /; x > 0] := x + 1 , Open ] successor /@ {1, "hi"} {2, successor["hi"]} 

Più attributi possono essere definiti per una funzione:

 define[ flatHold[x___] := Hold[x] , {Flat, HoldAll} ] flatHold[flatHold[1+1, flatHold[2+3]], 4+5] Hold[1 + 1, 2 + 3, 4 + 5] 

Senza ulteriori indugi, ecco la definizione di define :

 [email protected] SetAttributes[define, HoldAll] define[body_, attribute_Symbol] := define[body, {attribute}] define[body:(_Set|_SetDelayed), attributes_List:{}] := define[CompoundExpression[body], attributes] define[body:CompoundExpression[((Set|SetDelayed)[name_Symbol[___], _])..], attributes_List:{}] := ( [email protected] ; SetAttributes[name, DeleteCases[attributes, Open]] ; If[!MemberQ[attributes, Open] , def:name[___] := (Message[define::badargs, name, [email protected]]; Abort[]) ] ; body ; ) def:define[___] := (Message[define::malformsd, [email protected]]; Abort[]) define::badargs = "There is no definition for '``' applicable to ``."; define::malformsd = "Malformsd definition: ``"; 

L’implementazione esposta non supporta né up-value né currying, né pattern più generali della semplice definizione di funzione. Resta comunque utile.

Inizia senza un quaderno vuoto aperto

Sono stato infastidito dall’avere Mathematica che inizia con un taccuino vuoto aperto. Potrei chiudere questo quaderno con una sceneggiatura, ma continuerebbe a lampeggiare brevemente. Il mio hack è creare un file Invisible.nb contenente:

 Notebook[{},Visible->False] 

E aggiungilo al mio Kernel\init.m :

 If[Length[Notebooks["Invisible*"]] > 0, NotebookClose[Notebooks["Invisible*"][[1]]] ] SetOptions[$FrontEnd, Options[$FrontEnd, NotebooksMenu] /. HoldPattern["Invisible.nb" -> {__}] :> Sequence[] ] 

Ora avvio Mathematica aprendo Invisible.nb

Potrebbe esserci un modo migliore, ma questo mi è servito bene.


Fold e FoldList

Fold[f, x] è reso equivalente a Fold[f, [email protected], [email protected]]

Per inciso, credo che questo possa trovare la sua strada in una versione futura di Mathematica.

Sorpresa! Questo è stato implementato, sebbene sia attualmente non documentato. Sono informato che è stato implementato nel 2011 da Oliver Ruebenkoenig, apparentemente non molto tempo dopo che ho postato questo. Grazie Oliver Ruebenkoenig!

 Unprotect[Fold, FoldList] Fold[f_, h_[a_, b__]] := Fold[f, Unevaluated @ a, h @ b] FoldList[f_, h_[a_, b__]] := FoldList[f, Unevaluated @ a, h @ b] (* Faysal's recommendation to modify SyntaxInformation *) SyntaxInformation[Fold] = {"ArgumentsPattern" -> {_, _, _.}}; SyntaxInformation[FoldList] = {"ArgumentsPattern" -> {_, _., {__}}}; Protect[Fold, FoldList] 

Aggiornato per consentire questo:

 SetAttributes[f, HoldAll] Fold[f, Hold[1 + 1, 2/2, 3^3]] 
 f[f[1 + 1, 2/2], 3^3] 

“Partizione dynamic”

Vedi il post # 7512 di Mathematica.SE per una nuova versione di questa funzione.

Spesso voglio partizionare una lista in base a una sequenza di lunghezze.

esempio di pseudo-codice:

partition[{1,2,3,4,5,6}, {2,3,1}]

Uscita: {{1,2}, {3,4,5}, {6}}

Mi sono inventato questo:

 dynP[l_, p_] := MapThread[l[[# ;; #2]] &, {{0} ~Join~ [email protected]# + 1, #} &@[email protected]] 

Che ho poi completato con questo, compreso il test degli argomenti:

 dynamicPartition[l_List, p : {_Integer?NonNegative ..}] := dynP[l, p] /; [email protected] >= [email protected] dynamicPartition[l_List, p : {_Integer?NonNegative ..}, All] := dynP[l, p] ~Append~ Drop[l, [email protected]] /; [email protected] >= [email protected] dynamicPartition[l_List, p : {_Integer?NonNegative ..}, n__ | {n__}] := dynP[l, p] ~Join~ Partition[l ~Drop~ [email protected], n] /; [email protected] >= [email protected] 

Il terzo argomento controlla cosa succede agli elementi oltre la specifica suddivisa.


I trucchi di Mathematica di Szabolcs

Quello che uso più frequentemente è la tavolozza dei dati tabulari Incolla

 [email protected] [email protected]{Button["TSV", Module[{data, strip}, data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]]; strip[s_String] := StringReplace[s, RegularExpression["^\\s*(.*?)\\s*$"] -> "$1"]; strip[e_] := e; If[Head[data] === String, NotebookWrite[InputNotebook[], [email protected][strip, ImportString[data, "TSV"], {2}]]]]], Button["CSV", Module[{data, strip}, data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]]; strip[s_String] := StringReplace[s, RegularExpression["^\\s*(.*?)\\s*$"] -> "$1"]; strip[e_] := e; If[Head[data] === String, NotebookWrite[InputNotebook[], [email protected][strip, ImportString[data, "CSV"], {2}]]]]], Button["Table", Module[{data}, data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]]; If[Head[data] === String, NotebookWrite[InputNotebook[], [email protected][data, "Table"]]]]]} 

Modifica i dati esterni dall’interno di Compile

Recentemente Daniel Lichtblau ha mostrato questo metodo che non avevo mai visto prima. A mio avviso, estende notevolmente l’utilità di Compile

 ll = {2., 3., 4.}; c = Compile[{{x}, {y}}, ll[[1]] = x; y]; c[4.5, 5.6] ll (* Out[1] = 5.6 *) (* Out[2] = {4.5, 3., 4.} *) 

Problemi generali e soluzioni di esportazione PDF / EMF

1) È completamente inatteso e non documentato, ma Mathematica esporta e salva la grafica nei formati PDF ed EPS utilizzando un set di definizioni di stile diverso da quello utilizzato per la visualizzazione di Taccuini sullo schermo. By default Notebooks are displayed on screen in the “Working” style environment (which is default value for the ScreenStyleEvironment global $FrontEnd option) but are printed in the "Printout" style environment (which is default value for the PrintingStyleEnvironment global $FrontEnd option). When one exports graphics in raster formats such as GIF and PNG or in EMF format Mathematica generates graphics that looks exactly like it looks inside Notebook. It seems that the "Working" style environment is used for rendering in this case. But it is not the case when you export/save anything in PDF or EPS formats! In this case the "Printout" style environment is used by default that differs very deeply from the “Working” style environment. First of all, the "Printout" style environment sets Magnification to 80% . Secondly, it uses its own values for the font sizes of different styles and this results in inconsistent font size changes in the genarated PDF file as compared with the original on-screen representation. The latter can be called FontSize fluctuations which are very annoying. But happily this can be avoided by setting the PrintingStyleEnvironment global $FrontEnd option to “Working” :

 SetOptions[$FrontEnd, PrintingStyleEnvironment -> "Working"] 

2) The common problem with exporting to EMF format is that most of programs (not only Mathematica ) generate a file that looks nice at the default size but becomes ugly when you zoom it in. It is because metafiles are sampled at screen resolution fidelity . The quality of the generated EMF file can be enhanced by Magnify ing the original graphical object so that exactness of sampling of the original graphics becomes much more precise. Compare two files:

 graphics1 = [email protected][ ExportString[Style["a", FontFamily -> "Times"], "PDF"], "PDF"]; graphics2 = Magnify[graphics1, 10]; Export["C:\\test1.emf", graphics1] Export["C:\\test2.emf", graphics2] 

If you insert these files into Microsoft Word and zoom them in you will see that the first “a” has sawtooth on it while the second has not (tested with Mathematica 6).

Another way through ImageResolution was suggested by Chris Degnen (this option has effect at least starting from Mathematica 8):

 Export["C:\\test1.emf", graphics1] Export["C:\\test2.emf", graphics1, ImageResolution -> 300] 

3) In Mathematica we have three ways to convert graphics into metafile: via Export to "EMF" (strongly recommended way: produces metafile with highest possible quality), via Save selection As... menu item ( produces much lesser precise figure , not recommended) and via Edit ► Copy As ► Metafile menu item ( I strongly recommend against this route ).

By popular demand, the code to generate the top-10 SO answerers plot (except annotations ) using the SO API .

inserisci la descrizione dell'immagine qui

 getRepChanges[userID_Integer] := Module[{totalChanges}, totalChanges = "total" /. Import["http://api.stackoverflow.com/1.1/users/" <> ToString[userID] <> "/reputation?fromdate=0&pagesize=10&page=1", "JSON"]; Join @@ Table[ "rep_changes" /. Import["http://api.stackoverflow.com/1.1/users/" <> ToString[userID] <> "/reputation?fromdate=0&pagesize=10&page=" <> ToString[page], "JSON"], {page, 1, Ceiling[totalChanges/10]} ] ] topAnswerers = ({"display_name", "user_id"} /. #) & /@ ("user" /. ("top_users" /. Import["http://api.stackoverflow.com/1.1/tags/mathematica/top-\ answerers/all-time", "JSON"])) repChangesTopUsers = Monitor[Table[ repChange = ReleaseHold[(Hold[{DateList[ "on_date" + AbsoluteTime["January 1, 1970"]], "positive_rep" - "negative_rep"}] /. #) & /@ getRepChanges[userID]] // Sort; accRepChange = {repChange[[All, 1]], Accumulate[repChange[[All, 2]]]}\[Transpose], {userID, topAnswerers[[All, 2]]} ], userID]; pl = DateListLogPlot[ Tooltip @@@ Take[({repChangesTopUsers, topAnswerers[[All, 1]]}\[Transpose]), 10], Joined -> True, Mesh -> None, ImageSize -> 1000, PlotRange -> {All, {10, All}}, BaseStyle -> {FontFamily -> "Arial-Bold", FontSize -> 16}, DateTicksFormat -> {"MonthNameShort", " ", "Year"}, GridLines -> {True, None}, FrameLabel -> (Style[#, FontSize -> 18] & /@ {"Date", "Reputation", "Top-10 answerers", ""})] 

Caching expressions

I find these functions very helpful to cache any expression. The interesting thing here for these two functions is that the held expression itself is used as a key of the hashtable/symbol Cache or CacheIndex, compared to the well-known memoization in mathematica where you can only cache result if the function is defined like f[x_] := f[x] = … So you can cache any part of a code, this is useful if a function is to be called several times but just some parts of the code must not be recomputed.

To cache an expression independently of its arguments.

 SetAttributes[Cache, HoldFirst]; c:Cache[expr_] := c = expr; Ex: Cache[Pause[5]; 6] Cache[Pause[5]; 6] 

The second time the expression returns 6 without waiting.

To cache an expression using an alias expression that can depend on an argument of the cached expression.

 SetAttributes[CacheIndex, HoldRest]; c:CacheIndex[index_,expr_] := c = expr; Ex: CacheIndex[{"f",2},x=2;y=4;x+y] 

If expr takes some time to compute, it is much faster to evaluate {“f”,2} for example to retrieve the cached result.

For a variation of these functions in order to have a localized cache (ie. the cache memory is automatically released outside the Block construct) see this post Avoid repeated calls to Interpolation

Deleting cached values

To delete cached values when you don’t know the number of definitions of a function. I consider that definitions have a Blank somewhere in their arguments.

 DeleteCachedValues[f_] := DownValues[f] = Select[DownValues[f], !FreeQ[[email protected]#,Pattern]&]; 

To delete cached values when you know the number of definitions of a function (goes slightly faster).

 DeleteCachedValues[f_,nrules_] := DownValues[f] = Extract[DownValues[f], List /@ Range[-nrules, -1]]; 

This uses the fact that definitions of a function are at the end of their DownValues list, cached values are before.

Using symbols to store data and object-like functions

Also here are interesting functions to use symbols like objects.

It is already well known that you can store data in symbols and quickly access them using DownValues

 mysymbol["property"]=2; 

You can access the list of keys (or properties) of a symbol using these functions based on what dreeves submitted in a post on this site:

 SetAttributes[RemoveHead, {HoldAll}]; RemoveHead[h_[args___]] := {args}; NKeys[symbol_] := RemoveHead @@@ DownValues[symbol(*,Sort->False*)][[All,1]]; Keys[symbol_] := NKeys[symbol] /. {x_} :> x; 

I use this function a lot to display all infos contained in the DownValues of a symbol:

 PrintSymbol[symbol_] := Module[{symbolKeys}, symbolKeys = Keys[symbol]; [email protected][{symbolKeys, symbol /@ symbolKeys}] ]; 

Finally here is a simple way to create a symbol that behaves like an object in object oriented programming (it just reproduces the most basic behaviour of OOP but I find the syntax elegant) :

 Options[NewObject]={y->2}; NewObject[OptionsPattern[]]:= Module[{newObject}, newObject["y"]=OptionValue[y]; function[newObject,x_] ^:= newObject["y"]+x; newObject /: newObject.function2[x_] := 2 newObject["y"]+x; newObject ]; 

Properties are stored as DownValues and methods as delayed Upvalues in the symbol created by Module that is returned. I found the syntax for function2 that is the usual OO-syntax for functions in Tree data structure in Mathematica .

For a list of existing types of values each symbol has, see http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html and http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_Misc_4.html .

For example try this

 x = NewObject[y -> 3]; function[x, 4] x.function2[5] 

You can go further if you want to emulate object inheritance using a package called InheritRules available here http://library.wolfram.com/infocenter/MathSource/671/

You could also store the function definition not in newObject but in a type symbol, so if NewObject returned type[newObject] instead of newObject you could define function and function2 like this outside of NewObject (and not inside) and have the same usage as before.

 function[type[object_], x_] ^:= object["y"] + x; type /: type[object_].function2[x_] := 2 object["y"]+x; 

Use UpValues[type] to see that function and function2 are defined in the type symbol.

Further ideas about this last syntax are introduced here https://mathematica.stackexchange.com/a/999/66 .

Improved version of SelectEquivalents

@rcollyer: Many thanks for bringing SelectEquivalents to the surface, it’s an amazing function. Here is an improved version of SelectEquivalents listed above with more possibilities and using options, this makes it easier to use.

 Options[SelectEquivalents] = { TagElement->Identity, TransformElement->Identity, TransformResults->(#2&) (*#1=tag,#2 list of elements corresponding to tag*), MapLevel->1, TagPattern->_, FinalFunction->Identity }; SelectEquivalents[x_List,OptionsPattern[]] := With[ { [email protected], [email protected], [email protected], [email protected], [email protected], [email protected] } , finalFunction[ Reap[ Map[ Sow[ [email protected]# , {[email protected]#} ]& , x , {mapLevel} ] , tagPattern , transformResults ][[2]] ] ]; 

Here are examples of how this version can be used:

Using Mathematica Gather/Collect properly

How would you do a PivotTable function in Mathematica?

Mathematica fast 2D binning algorithm

Internal`Bag

Daniel Lichtblau describes here an interesting internal data structure for growing lists.

Implementing a Quadtree in Mathematica

Debugging functions

These two posts point to useful functions for debugging:

How to debug when writting small or big codes using Mathematica? workbench? mma debugger? or something else? (ShowIt)

https://stackoverflow.com/questions/5459735/the-clearest-way-to-represent-mathematicas-evaluation-sequence/5527117#5527117 (TraceView)

Here’s another function based on Reap and Sow to extract expressions from different parts of a program and store them in a symbol.

 SetAttributes[ReapTags,HoldFirst]; ReapTags[expr_]:= Module[{elements}, Reap[expr,_,(elements[#1]=#2/.{x_}:>x)&]; elements ]; 

Ecco un esempio

 ftest[]:=((*some code*)Sow[1,"x"];(*some code*)Sow[2,"x"];(*some code*)Sow[3,"y"]); s=ReapTags[ftest[]]; Keys[s] s["x"] PrintSymbol[s] (*Keys and PrintSymbol are defined above*) 

Other resources

Here’s a list of interesting links for learning purpose:

A collection of Mathematica learning resources

Updated here: https://mathematica.stackexchange.com/a/259/66

My utility functions (I have these built in to MASH, which is mentioned in the question):

 pr = WriteString["stdout", ##]&; (* More *) prn = pr[##, "\n"]&; (* convenient *) perr = WriteString["stderr", ##]&; (* print *) perrn = perr[##, "\n"]&; (* statements. *) re = RegularExpression; (* I wish mathematica *) eval = ToExpression[cat[##]]&; (* weren't so damn *) EOF = EndOfFile; (* verbose! *) read[] := InputString[""]; (* Grab a line from stdin. *) doList[f_, test_] := (* Accumulate list of what f[] *) [email protected][f[]&, f[], test]; (* returns while test is true. *) readList[] := doList[read, #=!=EOF&]; (* Slurp list'o'lines from stdin. *) cat = [email protected]@(ToString/@{##})&; (* Like sprintf/strout in C/C++. *) system = [email protected]@##&; (* System call. *) backtick = Import[cat["!", ##], "Text"]&; (* System call; returns stdout. *) slurp = Import[#, "Text"]&; (* Fetch contents of file as str. *) (* ABOVE: mma-scripting related. *) keys[f_, i_:1] := (* BELOW: general utilities. *) DownValues[f, Sort->False][[All,1,1,i]]; (* Keys of a hash/dictionary. *) SetAttributes[each, HoldAll]; (* each[pattern, list, body] *) each[pat_, lst_, bod_] := ReleaseHold[ (* converts pattern to body for *) Hold[Cases[[email protected], pat:>bod];]]; (* each element of list. *) some[f_, l_List] := True === (* Whether f applied to some *) Scan[If[f[#], Return[True]]&, l]; (* element of list is True. *) every[f_, l_List] := Null === (* Similarly, And @@ f/@l *) Scan[If[!f[#], Return[False]]&, l]; (* (but with lazy evaluation). *) 

One trick I’ve used, which allows you to emulate the way most built-in functions work with bad arguments (by sending a message and then returning the whole form unevaluated) exploits a quirk of the way Condition works when used in a defintion. If foo should only work with one argument:

 foo[x_] := x + 1; expr : foo[___] /; (Message[foo::argx, foo, [email protected][expr], 1]; False) := Null; (* never reached *) 

If you have more complex needs, it’s easy to factor out the argument validation and message generation as an independent function. You can do more elaborate things by using side effects in Condition beyond just generating messages, but in my opinion most of them fall into the “sleazy hack” category and should be avoided if possible.

Also, in the “metaprogramming” category, if you have a Mathematica package ( .m ) file, you can use the "HeldExpressions" element to get all the expressions in the file wrapped in HoldComplete . This makes tracking things down much easier than using text-based searches. Unfortunately, there’s no easy way to do the same thing with a notebook, but you can get all the input expressions using something like the following:

 inputExpressionsFromNotebookFile[nb_String] := Cases[Get[nb], Cell[BoxData[boxes_], "Input", ___] :> MakeExpression[StripBoxes[boxes], StandardForm], Infinity] 

Lastly, you can use the fact that Module emulates lexical closures to create the equivalent of reference types. Here’s a simple stack (which uses a variation the Condition trick for error handling as a bonus):

 ClearAll[MakeStack, StackInstance, EmptyQ, Pop, Push, Peek] With[{emptyStack = Unique["empty"]}, Attributes[StackInstance] = HoldFirst; MakeStack[] := Module[{backing = emptyStack}, StackInstance[backing]]; StackInstance::empty = "stack is empty"; EmptyQ[StackInstance[backing_]] := (backing === emptyStack); HoldPattern[ Pop[instance : StackInstance[backing_]]] /; ! EmptyQ[instance] || (Message[StackInstance::empty]; False) := (backing = [email protected]; instance); HoldPattern[Push[instance : StackInstance[backing_], new_]] := (backing = {new, backing}; instance); HoldPattern[Peek[instance : StackInstance[backing_]]] /; ! EmptyQ[instance] || (Message[StackInstance::empty]; False) := [email protected]] 

Now you can print the elements of a list in reverse order in a needlessly convoluted way!

 With[{stack = MakeStack[], list}, Do[Push[stack, elt], {elt, list}]; While[!EmptyQ[stack], Print[[email protected]]; [email protected]]] 

Printing system symbol definitions without context prepended

The contextFreeDefinition[] function below will attempt to print the definition of a symbol without the most common context prepended. The definition then can be copied to Workbench and formatted for readability (select it, right click, Source -> Format)

 Clear[commonestContexts, contextFreeDefinition] commonestContexts[sym_Symbol, n_: 1] := Quiet[ Commonest[ Cases[Level[DownValues[sym], {-1}, HoldComplete], s_Symbol /; FreeQ[$ContextPath, Context[s]] :> Context[s]], n], Commonest::dstlms] contextFreeDefinition::contexts = "Not showing the following contexts: `1`"; contextFreeDefinition[sym_Symbol, contexts_List] := (If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]]; Internal`InheritedBlock[{sym}, ClearAttributes[sym, ReadProtected]; Block[{$ContextPath = Join[$ContextPath, contexts]}, [email protected][FullDefinition[sym]]]]) contextFreeDefinition[sym_Symbol, context_String] := contextFreeDefinition[sym, {context}] contextFreeDefinition[sym_Symbol] := contextFreeDefinition[sym, commonestContexts[sym]] 

withRules[]

Caveat: This function does not localize variables the same way With and Module do, which means that nested localization constructs won’t work as expected. withRules[{a -> 1, b -> 2}, With[{a=3}, b_ :> b]] will replace a and b in the nested With and Rule , while With doesn’t do this.

This is a variant of With that uses rules instead of = and := :

 ClearAll[withRules] SetAttributes[withRules, HoldAll] withRules[rules_, expr_] := Internal`InheritedBlock[ {Rule, RuleDelayed}, SetAttributes[{Rule, RuleDelayed}, HoldFirst]; Unevaluated[expr] /. rules ] 

I found this useful while cleaning up code written during experimentation and localizing variables. Occasionally I end up with parameter lists in the form of {par1 -> 1.1, par2 -> 2.2} . With withRules parameter values are easy to inject into code previously written using global variables.

Usage is just like With :

 withRules[ {a -> 1, b -> 2}, a+b ] 

Antialiasing 3D graphics

This is a very simple technique to antialias 3D graphics even if your graphics hardware doesn’t support it natively.

 antialias[g_, n_: 3] := ImageResize[Rasterize[g, "Image", ImageResolution -> n 72], Scaled[1/n]] 

Ecco un esempio:

Mathematica graphicsMathematica graphics

Note that a large value for n or a large image size tends to expose graphics driver bugs or introduce artefacts.


Notebook diff functionality

Notebook diff functionality is available in the < package, and (at least in version 8) in the undocumented NotebookTools` context. This is a little GUI to diff two notebooks that are currently open:

 [email protected][ {nb1, nb2}, [email protected][ {PopupMenu[Dynamic[nb1], Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], PopupMenu[Dynamic[nb2], Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], Button["Show differences", [email protected]`NotebookDiff[nb1, nb2]]}] ] 

Mathematica graphics

Recursive pure functions ( #0 ) seem to be one of the darker corners of the language. Here are a couple of non-trivial examples of their use , where this is really useful (not that they can not be done without it). The following is a pretty concise and reasonably fast function to find connected components in a graph, given a list of edges specified as pairs of vertices:

 ClearAll[setNew, componentsBFLS]; setNew[x_, x_] := Null; setNew[lhs_, rhs_]:=lhs:=Function[Null, (#1 := #0[##]); #2, HoldFirst][lhs, rhs]; componentsBFLS[lst_List] := Module[{f}, setNew @@@ Map[f, lst, {2}]; GatherBy[Tally[[email protected]][[All, 1]], f]]; 

What happens here is that we first map a dummy symbol on each of the vertex numbers, and then set up a way that, given a pair of vertices {f[5],f[10]} , say, then f[5] would evaluate to f[10] . The recursive pure function is used as a path compressor (to set up memoization in such a way that instead of long chains like f[1]=f[3],f[3]=f[4],f[4]=f[2], ... , memoized values get corrected whenever a new “root” of the component is discovered. This gives a significant speed-up. Because we use assignment, we need it to be HoldAll, which makes this construct even more obscure and more attractive ). This function is a result of on and off-line Mathgroup discussion involving Fred Simons, Szabolcs Horvat, DrMajorBob and yours truly. Esempio:

 In[13]:= largeTest=RandomInteger[{1,80000},{40000,2}]; In[14]:= componentsBFLS[largeTest]//Short//Timing Out[14]= {0.828,{{33686,62711,64315,11760,35384,45604,10212,52552,63986, <<8>>,40962,7294,63002,38018,46533,26503,43515,73143,5932},<<10522>>}} 

It is certainly much slower than a built-in, but for the size of code, quite fast still IMO.

Another example: here is a recursive realization of Select , based on linked lists and recursive pure functions:

 selLLNaive[x_List, test_] := Flatten[If[TrueQ[test[#1]], {#1, If[#2 === {}, {}, #0 @@ #2]}, If[#2 === {}, {}, #0 @@ #2]] & @@ Fold[{#2, #1} &, {}, Reverse[x]]]; 

Per esempio,

 In[5]:= Block[ {$RecursionLimit= Infinity}, selLLNaive[Range[3000],EvenQ]]//Short//Timing Out[5]= {0.047,{2,4,6,8,10,12,14,16,18,20,22,24,26,28,30, <<1470>>,2972,2974,2976,2978,2980,2982,2984,2986,2988,2990, 2992,2994,2996,2998,3000}} 

It is however not properly tail recursive, and will blow the stack (crash the kernel) for larger lists. Here is the tail-recursive version:

 selLLTailRec[x_List, test_] := Flatten[ If[Last[#1] === {}, If[TrueQ[test[First[#1]]], {#2, First[#1]}, #2], (* else *) #0[Last[#1], If[TrueQ[test[First[#1]]], {#2, First[#1]}, #2] ]] &[Fold[{#2, #1} &, {}, Reverse[x]], {}]]; 

Per esempio,

 In[6]:= Block[{$IterationLimit= Infinity}, selLLTailRec[Range[500000],EvenQ]]//Short//Timing Out[6]= {2.39,{2,4,6,8,10,12,14,16,18,20,22, <<249978>>,499980,499982,499984,499986,499988,499990,499992, 499994,499996,499998,500000}} 

This is recipe from Stan Wagon’s book…use it when built-in Plot behaves erratically due to lack of precision

 Options[PrecisePlot] = {PrecisionGoal -> 6}; PrecisePlot[f_, {x_, a_, b_}, opts___] := Module[{g, pg}, pg = PrecisionGoal /. {opts} /. Options[PrecisePlot]; SetAttributes[g, NumericFunction]; g[z_?InexactNumberQ] := Evaluate[f /. x -> z]; Plot[N[g[SetPrecision[y, \[Infinity]]], pg], {y, a, b}, Evaluate[Sequence @@ FilterRules[{opts}, Options[Plot]]]]]; 

I often use the following trick from Kristjan Kannike’s when I need “dictionary-like” behavior from Mathematica’s downvalues

 index[downvalue_, dict_] := (downvalue[[1]] /. HoldPattern[dict[x_]] -> x) // ReleaseHold; value[downvalue_] := downvalue[[-1]]; indices[dict_] := Map[#[[1]] /. {HoldPattern[dict[x_]] -> x} &, DownValues[dict]] // ReleaseHold; values[dict_] := Map[#[[-1]] &, DownValues[dict]]; items[dict_] := Map[{index[#, dict], value[#]} &, DownValues[dict]]; indexQ[dict_, index_] := If[MatchQ[dict[index], HoldPattern[dict[index]]], False, True]; (* Usage example: *) (* Count number of times each subexpression occurs in an expression *) expr = Cos[x + Cos[Cos[x] + Sin[x]]] + Cos[Cos[x] + Sin[x]] Map[(counts[#] = If[indexQ[counts, #], counts[#] + 1, 1]; #) &, expr, Infinity]; items[counts] 

When evaluation results are confusing, sometimes it helps to dump evaluation steps into a text file

 SetAttributes[recordSteps, HoldAll]; recordSteps[expr_] := Block[{$Output = [email protected]["~/temp/msgStream.m"]}, TracePrint[Unevaluated[expr], _?(FreeQ[#, Off] &), TraceInternal -> True]; Close /@ $Output; Thread[[email protected] Cases[ReadList["~/temp/msgStream.m", HoldComplete[Expression]], symb_Symbol /; [email protected]@symb && [email protected]@symb === "System`" :> [email protected], {0, Infinity}, Heads -> True], HoldComplete] ] (* Usage example: *) (* puts steps of evaluation of 1+2+Sin[5]) into ~/temp/msgStream.m *) recordSteps[1+2+Sin[5]] 

It is possible to run MathKernel in batch mode by using undocumented command-line options -batchinput and -batchoutput :

 math -batchinput -batchoutput < input.m > outputfile.txt 

(where input.m is the batch input file ending with the newline character, outputfile.txt is the file to which the output will be redirected).

In Mathematica v.>=6 the MathKernel has undocumented command-line option:

 -noicon 

which controls whether the MathKernel will have visible icon on the Taskbar (at least under Windows).

The FrontEnd (at least from v.5) has undocumented command-line option

 -b 

which disables the splash-screen and allows to run the Mathematica FrontEnd much faster

and option

 -directlaunch 

which disables the mechanism which launches the most recent Mathematica version installed instead of launching the version associated with .nb files in the system registry.

Another way to do this probably is :

Instead of launching the Mathematica.exe binary in the installation directory, launch the Mathematica.exe binary in SystemFiles\FrontEnd\Binaries\Windows. The formsr is a simple launcher program which tries its hardest to redirect requests for opening notebooks to running copies of the user interface. The latter is the user interface binary itself.

It is handy to combine the last command line option with setting global FrontEnd option VersionedPreferences->True which disables sharing of preferences between different Mathematica versions installed :

 SetOptions[$FrontEnd, VersionedPreferences -> True] 

(The above should be evaluated in the most recent Mathematica version installed.)

In Mathematica 8 this is controlled in the Preferences dialog, in the System pane, under the setting “Create and maintain version specific front end preferences” .

It is possible to get incomplete list of command-line options of the FrontEnd by using undocumented key -h (the code for Windows):

 SetDirectory[$InstallationDirectory <> "\\SystemFiles\\FrontEnd\\Binaries\\Windows\\"]; Import["!Mathematica -h", "Text"] 

dà:

 Usage: Mathematica [options] [files] Valid options: -h (--help): prints help message -cleanStart (--cleanStart): removes existing preferences upon startup -clean (--clean): removes existing preferences upon startup -nogui (--nogui): starts in a mode which is initially hidden -server (--server): starts in a mode which disables user interaction -activate (--activate): makes application frontmost upon startup -topDirectory (--topDirectory): specifies the directory to search for resources and initialization files -preferencesDirectory (--preferencesDirectory): specifies the directory to search for user AddOns and preference files -password (--password): specifies the password contents -pwfile (--pwfile): specifies the path for the password file -pwpath (--pwpath): specifies the directory to search for the password file -b (--b): launches without the splash screen -min (--min): launches as minimized 

Other options include:

 -directLaunch: force this FE to start -32: force the 32-bit FE to start -matchingkernel: sets the frontend to use the kernel of matching bitness -Embedding: specifies that this instance is being used to host content out of process 

Are there other potentially useful command-line options of the MathKernel and the FrontEnd? Please share if you know.

Related question .

My favorite hacks are small code-generating macros that allow you to replace a bunch of standard boilerplate commands with one short one. Alternatively, you can create commands for opening/creating notebooks.

Here is what I’ve been using for a while in my day-to-day Mathematica workflow. I found myself performing the following a lot:

  1. Make a notebook have a private context, load package(s) I need, make it autosave.
  2. After working with this notebook for a while, I’d want to do some throw away scratch computations in a separate notebook, with its own private context, while having access to definitions I’ve been using in the “main” notebook. Because I set up the private context, this requires to manually adjust $ContextPath

Doing all this by hand over and over is a pain, so let’s automate! First, some utility code:

 (* Credit goes to Sasha for SelfDestruct[] *) SetAttributes[SelfDestruct, HoldAllComplete]; SelfDestruct[e_] := (If[$FrontEnd =!= $Failed, SelectionMove[EvaluationNotebook[], All, EvaluationCell]; NotebookDelete[]]; e) writeAndEval[nb_,boxExpr_]:=( NotebookWrite[nb, CellGroupData[{Cell[BoxData[boxExpr],"Input"]}]]; SelectionMove[nb, Previous, Cell]; SelectionMove[nb, Next, Cell]; SelectionEvaluate[nb]; ) ExposeContexts::badargs = "Exposed contexts should be given as a list of strings."; ExposeContexts[list___] := Module[{ctList}, ctList = [email protected]@list; If[! MemberQ[ctList, Except[_String]],AppendTo[$ContextPath, #] & /@ ctList, Message[ExposeContexts::badargs]]; $ContextPath = DeleteDuplicates[$ContextPath]; $ContextPath] Autosave[x:(True|False)] := SetOptions[EvaluationNotebook[],NotebookAutoSave->x]; 

Now, let’s create a macro that’s going to put the following cells in the notebook:

 SetOptions[EvaluationNotebook[], CellContext -> Notebook] Needs["LVAutils`"] Autosave[True] 

And here’s the macro:

 MyPrivatize[exposedCtxts : ({__String} | Null) : Null]:= [email protected][{contBox,lvaBox,expCtxtBox,assembledStatements,strList}, contBox = MakeBoxes[SetOptions[EvaluationNotebook[], CellContext -> Notebook]]; lvaBox = MakeBoxes[Needs["LVAutils`"]]; assembledStatements = {lvaBox,MakeBoxes[Autosave[True]],"(*********)"}; assembledStatements = Riffle[assembledStatements,"\[IndentingNewLine]"]//RowBox; writeAndEval[InputNotebook[],contBox]; writeAndEval[InputNotebook[],assembledStatements]; If[exposedCtxts =!= Null, strList = Riffle[("\"" <> # <> "\"") & /@ exposedCtxts, ","]; expCtxtBox = RowBox[{"ExposeContexts", "[", RowBox[{"{", RowBox[strList], "}"}], "]"}]; writeAndEval[InputNotebook[],expCtxtBox]; ] ] 

Now when I type in MyPrivatize[] is creates the private context and loads my standard package. Now let’s create a command that will open a new scratch notebook with its own private context (so that you can hack there with wild abandon without the risk of screwing up the definitions), but has access to your current contexts.

 SpawnScratch[] := [email protected][{nb,boxExpr,strList}, strList = Riffle[("\"" <> # <> "\"") & /@ $ContextPath, ","]; boxExpr = RowBox[{"MyPrivatize", "[", RowBox[{"{", RowBox[strList], "}"}], "]"}]; nb = CreateDocument[]; writeAndEval[nb,boxExpr]; ] 

The cool thing about this is that due to SelfDestruct , when the command runs it leaves no trace in the current notebook — which is good, because otherwise it would just create clutter.

For extra style points, you can create keyword triggers for these macros using InputAutoReplacements , but I’ll leave this as an exercise for the reader.

PutAppend with PageWidth -> Infinity

In Mathematica using of the PutAppend command is the most straightforward way to maintain a running log file with results of intermediate computations. But it uses by default PageWith->78 setting when exporting expressions to a file and so there is no guarantee that every intermediate output will take only one line in the log.

PutAppend does not have any options itself but tracing its evaluations reveals that it is based on the OpenAppend function which has the PageWith option and allows changing its default value by the SetOptions command:

 In[2]:= Trace[x>>>"log.txt",TraceInternal->True] Out[2]= {x>>>log.txt,{OpenAppend[log.txt,CharacterEncoding->PrintableASCII],OutputStream[log.txt,15]},Null} 

So we can get PutAppend to append only one line at a time by setting:

 SetOptions[OpenAppend, PageWidth -> Infinity] 

AGGIORNARE

There is a bug introduced in version 10 (fixed in version 11.3): SetOptions no longer affects the behavior of OpenWrite and OpenAppend .

A workaround is to implement your own version of PutAppend with explicit PageWidth -> Infinity option:

 Clear[myPutAppend] myPutAppend[expr_, pathtofile_String] := (Write[#, expr]; Close[#];) &[OpenAppend[pathtofile, PageWidth -> Infinity]] 

Note that we also may implement it via WriteString as shown in this answer, but in this case it will be necessary to preliminarily convert the expression into the corresponding InputForm via ToString[expr, InputForm] .

I was just looking through one of my packages for inclusion in this, and found some messages that I defined that work wonders: Debug:: . By default, they are turned off, so don’t produce much overhead. But, I can litter my code with them, and turn them on if I need to figure out exactly how a bit of code is behaving.

One of the things that bothers me about the built-in scoping constructs is that they evaluate all of the local variable definitions at once, so you can’t write for example

 With[{a = 5, b = 2 * a}, ... ] 

So a while ago I came up with a macro called WithNest that allows you to do this. I find it handy, since it lets you keep variable bindings local without having to do something like

 Module[{a = 5,b}, b = 2 * a; ... ] 

In the end, the best way I could find to do this was by using a special symbol to make it easier to recurse over the list of bindings, and I put the definition into its own package to keep this symbol hidden. Maybe someone has a simpler solution to this problem?

If you want to try it out, put the following into a file called Scoping.m :

 BeginPackage["Scoping`"]; WithNest::usage= "WithNest[{var1=val1,var2=val2,...},body] works just like With, except that values are evaluated in order and later values have access to earlier ones. For example, val2 can use var1 in its definition."; Begin["`Private`"]; (* Set up a custom symbol that works just like Hold. *) SetAttributes[WithNestHold,HoldAll]; (* The user-facing call. Give a list of bindings and a body that's not our custom symbol, and we start a recursive call by using the custom symbol. *) WithNest[bindings_List,body:Except[_WithNestHold]]:= WithNest[bindings,WithNestHold[body]]; (* Base case of recursive definition *) WithNest[{},WithNestHold[body_]]:=body; WithNest[{bindings___,a_},WithNestHold[body_]]:= WithNest[ {bindings}, WithNestHold[With[[email protected],body]]]; SyntaxInformation[WithNest]={"ArgumentsPattern"->{{__},_}}; SetAttributes[WithNest,{HoldAll,Protected}]; End[]; EndPackage[]; 

This code makes a palette that uploads the selection to Stack Exchange as an image. On Windows, an extra button is provided that gives a more faithful rendering of the selection.

Copy the code into a notebook cell and evaluate. Then pop out the palette from the output, and install it using Palettes -> Install Palette...

If you have any trouble with it, post a comment here. Download the notebook version here .


 Begin["SOUploader`"]; Global`palette = [email protected][{}, Column[{ Button["Upload to SE", With[{img = rasterizeSelection1[]}, If[img === $Failed, Beep[], uploadWithPreview[img]]], Appearance -> "Palette"], If[$OperatingSystem === "Windows", Button["Upload to SE (pp)", With[{img = rasterizeSelection2[]}, If[img === $Failed, Beep[], uploadWithPreview[img]]], Appearance -> "Palette"], [email protected][] ] }], (* Init start *) Initialization :> ( stackImage::httperr = "Server returned respose code: `1`"; stackImage::err = "Server returner error: `1`"; stackImage[g_] := Module[ {getVal, url, client, method, data, partSource, part, entity, code, response, error, result}, getVal[res_, key_String] := With[{k = "var " <> key <> " = "}, StringTrim[ [email protected][ [email protected][res, StringMatchQ[#, k ~~ ___] &], k ~~ v___ ~~ ";" :> v], "'"] ]; data = ExportString[g, "PNG"]; JLink`JavaBlock[ url = "http://stackoverflow.com/upload/image"; client = JLink`JavaNew["org.apache.commons.httpclient.HttpClient"]; method = JLink`JavaNew[ "org.apache.commons.httpclient.methods.PostMethod", url]; partSource = JLink`JavaNew[ "org.apache.commons.httpclient.methods.multipart.\ ByteArrayPartSource", "mmagraphics.png", JLink`MakeJavaObject[data]@toCharArray[]]; part = JLink`JavaNew[ "org.apache.commons.httpclient.methods.multipart.FilePart", "name", partSource]; [email protected]["image/png"]; entity = JLink`JavaNew[ "org.apache.commons.httpclient.methods.multipart.\ MultipartRequestEntity", {part}, me[email protected][]]; [email protected][entity]; code = [email protected][method]; response = [email protected][]; ]; If[code =!= 200, Message[stackImage::httperr, code]; Return[$Failed]]; response = StringTrim /@ StringSplit[response, "\n"]; error = getVal[response, "error"]; result = getVal[response, "result"]; If[StringMatchQ[result, "http*"], result, Message[stackImage::err, error]; $Failed] ]; stackMarkdown[g_] := "![Mathematica graphics](" <> stackImage[g] <> ")"; stackCopyMarkdown[g_] := Module[{nb, markdown}, markdown = Check[stackMarkdown[g], $Failed]; If[markdown =!= $Failed, nb = NotebookCreate[Visible -> False]; NotebookWrite[nb, Cell[markdown, "Text"]]; SelectionMove[nb, All, Notebook]; FrontEndTokenExecute[nb, "Copy"]; NotebookClose[nb]; ] ]; (* Returns available vertical screen space, taking into account screen elements like the taskbar and menu *) screenHeight[] := -Subtract @@ Part[ScreenRectangle /. Options[$FrontEnd, ScreenRectangle], 2]; uploadWithPreview[img_Image] := CreateDialog[ Column[{ Style["Upload image to the Stack Exchange network?", Bold], Pane[ Image[img, Magnification -> 1], {Automatic, Min[screenHeight[] - 140, 1 + ImageDimensions[img][[2]]]}, Scrollbars -> Automatic, AppearanceElements -> {}, ImageMargins -> 0 ], Item[ ChoiceButtons[{"Upload and copy MarkDown"}, \ {stackCopyMarkdown[img]; DialogReturn[]}], Alignment -> Right] }], WindowTitle -> "Upload image to Stack Exchange?" ]; (* Multiplatform, fixed-width version. The default max width is 650 to fit Stack Exchange *) rasterizeSelection1[maxWidth_: 650] := Module[{target, selection, image}, selection = NotebookRead[SelectedNotebook[]]; If[MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]], selection], $Failed, (* There was nothing selected *) target = CreateDocument[{}, WindowSelected -> False, Visible -> False, WindowSize -> maxWidth]; NotebookWrite[target, selection]; image = Rasterize[target, "Image"]; NotebookClose[target]; image ] ]; (* Windows-only pixel perfect version *) rasterizeSelection2[] := If[ MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]], NotebookRead[SelectedNotebook[]]], $Failed, (* There was nothing selected *) Module[{tag}, FrontEndExecute[ FrontEndToken[FrontEnd`SelectedNotebook[], "CopySpecial", "MGF"]]; Catch[ [email protected][] /. r_RasterBox :> Block[{}, Throw[Image[First[r], "Byte", ColorSpace -> "RGB"], tag] /; True]; $Failed, tag ] ] ]; ) (* Init end *) ] End[]; 

I’m sure a lot of people have encountered the situation where they run some stuff, realizing it not only stuck the program, but they also haven’t saved for the last 10 minutes!

MODIFICARE

After suffering from this for some time, I one day found out that one can create auto-save from within the Mathematica code. I think that using such auto-save have helped me a lot in the past, and I always felt that the possibility itself was something that not a lot of people are aware that they can do.

The original code I used is at the bottom. Thanks to the comments I’ve found out that it is problematic, and that it is much better to do it in an alternative way, using ScheduledTask (which will work only in Mathematica 8).

Code for this can be found in this answer from Sjoerd C. de Vries (Since I’m not sure if it’s OK to copy it to here, I’m leaving it as a link only.)


The solution below is using Dynamic . It will save the notebook every 60 seconds, but apparently only if its cell is visible . I’m leaving it here only for completion reasons. (and for users of Mathematica 6 and 7)

/EDIT

To solve it I use this code in the beginning of a notebook:

 Dynamic[Refresh[NotebookSave[]; DateString[], UpdateInterval -> 60]] 

This will save your work every 60 seconds.
I prefer it to NotebookAutoSave[] because it saves before the input is processed, and because some files are more text than input.

I originally found it here: http://en.wikipedia.org/wiki/Talk:Mathematica#Criticisms

Note that once running this line, saving will happen even if you close and re-open your file (as long as dynamic updating is enabled).

Also, since there is no undo in Mathematica , be careful not to delete all your content, since saving will make it irreversible (as a precaution move, I remove this code from every finished notebook)

This one was written by Alberto Di Lullo, (who doesn’t appear to be on Stack Overflow).

CopyToClipboard , for Mathematica 7 (in Mathematica 8 it’s built in)

 CopyToClipboard[expr_] := Module[{nb}, nb = CreateDocument[Null, Visible -> False, WindowSelected -> True]; NotebookWrite[nb, Cell[[email protected]], All]; FrontEndExecute[FrontEndToken[nb, "Copy"]]; [email protected]]; 

Original post: http://forums.wolfram.com/mathgroup/archive/2010/Jun/msg00148.html

I have found this routine useful for copying large real numbers to the clipboard in ordinary decimal form. Eg CopyToClipboard["123456789.12345"]

Cell[[email protected]] neatly removes the quotes.

Remember that The Mathematica Book is also available online at http://reference.wolfram.com/legacy/v5_2/ – though it’s superseded by the current documentation at http://reference.wolfram.com

I find it really useful when developing packages to add this keyboard shortcut to my SystemFiles/FrontEnd/TextResources/Windows/KeyEventTranslations.tr file.

 (* Evaluate Initialization Cells: Real useful for reloading library changes. *) Item[KeyEvent["i", Modifiers -> {Control, Command}], FrontEndExecute[ FrontEndToken[ SelectedNotebook[], "EvaluateInitialization"]]], 

Next for every Packagename.m I make a PackagenameTest.nb notebook for testing and the first 2 cells of the test notebook are set as initialization cells. In the first cell I put

 Needs["PackageManipulations`"] 

to load the very useful PackageManipulations library which was written by Leonid. The second cell contains

 PackageRemove["Packagename`Private`"] PackageRemove["Packagename`"] PackageReload["Packagename`"] 

which all do the actual package reloading. Note the first two lines are there only to Remove all symbols as I like to keep the contexts as clean as possible.

Then the workflow for writing and testing a package becomes something like this.

  1. Save changes to Packagename.m .
  2. Go to PackagenameTest.nb and do CTRL + ALT + i .

This causes the initialization cells to reload the package, which makes testing real simple.

Following function format[expr_] can be used to indent/format unformatted mathematica expressions that spans over a page

 indent[str_String, ob_String, cb_String, delim_String] := Module[{ind, indent, f, tab}, ind = 0; tab = " "; indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i]; f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___]; f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___]; f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___]; f[c_] := c; f /@ [email protected] // StringJoin]; format[expr_] := indent[expr // InputForm // ToString, "[({", "])}", ";"]; (* format[[email protected][{ind, indent, f, tab}, ind = 0; tab = " "; indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i]; f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___]; f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___]; f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___]; f[c_] := c; f /@ [email protected] // StringJoin]] *) 

ref: https://codegolf.stackexchange.com/questions/3088/indent-a-string-using-given-parentheses