Ceea ce este în Mathematica sac de instrument?

Unul dintre lucrurile frumoase despre Mathematica notebook interfata este că se poate evalua expresii în orice limbă, nu doar Mathematica. Ca un simplu exemplu, luați în considerare crearea unui nou Shell intrare tip de celule care trece cuprinse expresie pentru sistemul de operare shell pentru evaluare.

În primul rând, să definească o funcție care delegații de evaluare a unui text de comandă a shell-ul extern:

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

Al doilea argument este nevoie și ignorat din motive care vor deveni evidente mai târziu. Următoare, ne-o dorim pentru a crea un stil nou numit Shell:

1. Deschide un caiet nou.
2. Selectați elementul de meniu Format/Editare Stil...
3. În caseta de dialog, alături de Introduceți un nume de stil: de tip "Shell".
4. Selectați celula suportul alături de noul stil.
5. Selectați elementul de meniu Celule/Show Exprimare
6. Suprascrie celula expresie cu Pasul 6 Text având în vedere de mai jos.
7. Încă o dată, selectați elementul de meniu Celule/Show Exprimare
8. A închide caseta de dialog.

Utilizați următoarele celule expresie ca Pasul 6 Text:

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"]

Cele mai multe dintre această expresie a fost copiat direct formă built-in Program de stil. Principalele modificări sunt aceste linii:

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

Evaluatable permite SHIFT+ENTER funcționalități pentru mobil. Evaluarea va chema CellEvaluationFunction de trecere a celulei de conținut și tip de conținut ca argumente (shellEvaluateignoră acest din urmă argument).CellFrameLabels` este doar o subtilitate care las's utilizatorul să identifice că această celulă este neobișnuit.

Cu toate acestea, în loc, acum putem intra și de a evalua o coajă de expresia:

1. În notebook-ul creat în pașii de mai sus, de a crea o celulă goală și selectați celula suport.
2. Selectați elementul de meniu Format/Style/Shell.
3. Tastați un sistem de operare valabilă comanda shell în celulă (de exemplu, 'e' pe Unix sau 'dir' pe Windows).
4. Apăsați SHIFT+ENTER.

Cel mai bine este de a menține acest stil definit într-o situat central stylesheet. În plus, funcțiile de evaluare ca shellEvaluate sunt cel mai bine definite ca resturile folosind DeclarePackage in init.m. Detaliile de ambele dintre aceste activități sunt dincolo de domeniul de aplicare al acestui răspuns.

Cu această funcționalitate, se poate crea notebook-uri care conțin expresii de intrare în orice sintaxa de interes. Funcția de evaluare poate fi scris în pură Mathematica, sau delega oricare sau toate părțile de evaluare a unei agenții externe. Fi conștienți de faptul că există și alte cârlige care se referă la celula de evaluare, ca CellEpilog, CellProlog " și " CellDynamicExpression.

Un model comun implică scrierea de intrare expresia text într-un fișier temporar, compilarea fișierului în unele limbi, care rulează programul și capturarea de ieșire pentru final de afișare în producția de celule. Există o mulțime de detalii pentru a aborda atunci când pun în aplicare o soluție completă de acest gen (cum ar fi captarea mesaje de eroare corespunzător), dar trebuie să apreciez faptul că este posibil nu numai pentru a face lucruri de genul asta, dar practic.

Pe o notă personală, este caracteristici, cum ar fi acest lucru care face notebook interfata centrul de programul meu univers.

Update

Următoarele funcția de helper este util pentru crearea de astfel de celule:

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]
  )

Acesta este utilizat astfel:

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

Acum, dacă shellCell[] este evaluată, celula de intrare va fi șters și înlocuit cu o nouă introducere de celule, care evaluează conținutul său ca o coajă de comandă.

Todd Gayley (Wolfram Research) doar trimite-mi un hack frumos care vă permite să "folie de" built-in functii cu cod arbitrar. Simt că trebuie să împărtășească acest instrument util. Următoarele este Todd's răspunsul meu question.

Un pic de interesant (?) istorie: Care stil de hack pentru "ambalaj" un built-in funcția a fost inventat în jurul 1994 de către Robby Villegas și eu, în mod ironic pentru funcția de Mesaj, într-un pachet numit ErrorHelp care l-am scris pentru Revista Mathematica atunci. Acesta a fost folosit de multe ori, de mai multe persoane, de atunci. L's un pic de un insider's truc, dar cred că's corect să spunem că ea a devenit canonic mod de injectare propriul cod în definirea de un built-in funcția. Își face treaba bine. Puteți, desigur, a pus $inMsg variabilă în orice context doriți.

Unprotect[Message];

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

Protect[Message];

Am'am menționat acest înainte de a, dar instrumentul mi se pare cel mai util este o aplicație de a "Culege" și "Însămânțează" care imita/extinde comportamentul GatherBy:

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

Acest lucru permite-mi să-liste de grup de orice criterii și să le transforme în proces. Cum funcționează este că un criteriu funcția ("f") tag-uri, fiecare element din listă, fiecare element este transformat apoi de un al doilea furnizate de funcție ("g"), și specifice de ieșire este controlată de o a treia funcție ("h"). Funcția " h " acceptă două argumente: un tag și o listă de elemente colectate cu acest tag. Elementele păstreze ordinea inițială, așa că, dacă ați setat `h = #1& atunci veți obține un nesortate "Uniune", ca în exemple pentru a "Culege". Dar, acesta poate fi utilizat pentru prelucrare secundară.

Ca un exemplu de utilitatea sa, I'am lucrat cu Wannier90, care ieșiri spațial dependente Hamiltonian într-un dosar în care fiecare linie este un alt element în matrice, după cum urmează

rx ry rz i j Re[Hij] Im[Hij]

La rândul său, că lista într-un set de matrici, am adunat toate sublistele care conțin aceleași coordonate, se întoarse element de informații într-o regulă (de exemplu, {i,j}-> Re[Hij]+I Im[Hij]), și apoi se întoarse regulile colectate într-un SparseArray toate cu o singură linie:

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

Sincer, acest lucru este meu Elvețian Armata Cuțit, și-l face lucruri complexe foarte simplu. De cele mai multe instrumente sunt oarecum specifice domeniului, așa că am'll, probabil, nu le posta. Cu toate acestea, cele mai multe, dacă nu toate, dintre ele de referință SelectEquivalents.

Edit: nu't complet imita GatherBy în care se pot grupa mai multe niveluri de exprimare la fel de simplu ca GatherBy poate. Cu toate acestea, "Harta" funcționează foarte bine pentru cele mai multe, de ce am nevoie.

Exemplu: @Yaroslav Bulatov a cerut pentru o auto-conținută de exemplu. Aici's unul din cercetarea mea, care a fost mult simplificată. Deci, să's spune ca avem un set de puncte într-un avion

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}}

și ne-am'd dori să reducă numărul de puncte de un set de operații de simetrie. (Pentru curiosi, ne sunt generatoare grup de fiecare punct.) Pentru acest exemplu, să's utilizeze o de patru ori axei de rotație despre axa z

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

Folosind `SelectEquivalents putem grupa de puncte care produc același set de imagini în cadrul acestor operațiuni, adică au're echivalent, folosind următoarele

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}}}

care produce 3 subliste conțin echivalentul puncte. (Notă, "Uniune" este absolut vital aici, întrucât se asigură că aceeași imagine este produs de către fiecare punct. Inițial, am folosit un Fel, dar dacă un punct se află pe o axă de simetrie, este invariantă sub rotația despre care axa a da un plus de imagine de sine. Deci, "Uniune" elimină aceste imagini suplimentare. De asemenea,GatherByar produce același rezultat.) În acest caz, punctele sunt deja într-o formă pe care o voi folosi, dar am nevoie doar de un punct reprezentativ din fiecare grupă și am'd ca un număr de puncte echivalent. De atunci, nu't nevoie pentru a transforma fiecare punct, eu folosesc "Identitate" funcția în poziția a doua. Pentru cea de-a treia funcție, trebuie să fii atent. Primul argument a trecut la acesta va fi imaginile de puncte sub rotații care, pentru moment{0,0,0}este o listă de patru elemente identice, și folosind-o va arunca de pe conta. Cu toate acestea, cel de-al doilea argument este doar o listă cu toate elementele care au ca tag-ul, astfel încât acesta va conține doar{0,0,0}`. În cod,

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}}

Notă, această ultimă etapă poate fi la fel de ușor de realizat prin

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

Dar, este ușor cu acest lucru și mai puțin completă exemplul de mai sus pentru a vedea cum foarte complexe transformări sunt posibile cu un minim de cod.

Aceasta nu este o resursă completă, așa că am'm a aruncat-o aici, în secțiunea răspunsuri, dar am găsit-o foarte util atunci când imaginind viteza de probleme (care, din păcate, este o mare parte din ceea ce de programare Mathematica este de aproximativ).

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};

Utilizare este apoi pur și simplu timeAvg@funcYouWantToTest.

EDIT: Domnule Vrăjitor a oferit o versiune mai simplă care face cu "Arunca" și "Prinde" și este un pic mai ușor pentru a analiza:

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

EDIT: Aici's o versiune de acl (preluat din aici):

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]

Interne'InheritedBlock

Am aflat recent de existența unor astfel de funcție utilă ca Intern'InheritedBlock, de la acest mesaj de Daniel Lichtblau in oficială de știri.

După cum am înțeles, Intern'InheritedBlock vă permite să treacă o copie de o ieșire funcția în interiorul "Bloc" domeniul de aplicare:

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]

Cred că această funcție poate fi foarte util pentru toți cei care au nevoie de a modifica built-in functii temporar!

Comparație cu Bloc

Să ne definim o funcție:

a := Print[b]

Acum am dori să treacă un exemplar din această funcție în "Bloc" domeniul de aplicare. Naiv proces nu da ceea ce ne dorim:

In[2]:= Block[{a = a}, OwnValues[a]]

During evaluation of In[9]:= b

Out[2]= {HoldPattern[a] :> Null}

Acum încercarea de a utiliza întârziată definiție în primul argument de "Bloc" (este un nedocumentate caracteristică prea):

In[3]:= Block[{a := a}, OwnValues[a]]
Block[{a := a}, a]

Out[3]= {HoldPattern[a] :> a}

During evaluation of In[3]:= b

Vom vedea că în acest caz " a "funcționează, dar nu am primit o copie a originalului" a "interiorul" Bloc " domeniul de aplicare.

Acum, să ne încercăm Interne'InheritedBlock:

In[5]:= Internal`InheritedBlock[{a}, OwnValues[a]]

Out[5]= {HoldPattern[a] :> Print[b]}

Avem o copie a originalului definiție " o "interiorul" Bloc "domeniul de aplicare și s-ar putea modifica în mod dorim, fără a afecta global definiție pentru "a"!

Mathematica este un instrument ascuțit, dar se poate reduce cu oarecum netipizat comportament și avalanșe de criptic mesaje de diagnostic. O modalitate de a face cu acest lucru este de a defini funcții în urma acestui idiom:

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

Aceasta este o mulțime de șabloane, pe care am'm frecvent tentați să săriți. Mai ales atunci când prototipuri, care se întâmplă o mulțime în Mathematica. Deci, eu folosesc un macro numit defini care-mi permite să stau disciplinat, cu mult mai puțin limpede.

O utilizare de bază de defini` este ca aceasta:

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

fact[5]

120

Nu't pare mult la prima vedere, dar există unele beneficii ascunse. Primul serviciu care defini oferă este că acesta se aplică în mod automat ClearAll simbolul fiind definit. Acest lucru asigură că nu există resturi de definiții-un eveniment comun în dezvoltarea inițială a funcției.

Cel de-al doilea serviciu este că funcția fiind definit este automat "închis". Prin aceasta vreau să spun că funcția va emite un mesaj și anulare dacă este apelată cu un argument listă care nu este însoțită de unul dintre definițiile:

fact[-1]

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

Aceasta este valoarea principală a define, care prinde foarte frecvente clasă de eroare.

Un alt confort este un mod concis de a specifica atributele pe funcție să fie definită. Las's face funcția Listable:

define[
  fact[0] = 1
; fact[n_ /; n > 0] := n * fact[n-1]
, Listable
]

fact[{3, 5, 8}]

{6, 120, 40320}

În plus față de toate normală atribute, defini acceptă un atribut suplimentar numit "Deschis". Acest lucru previne `defini, de la adăugarea de catch-all eroare de definiție pentru funcția:

define[
  successor[x_ /; x > 0] := x + 1
, Open
]

successor /@ {1, "hi"}

{2, successor["hi"]}

Mai multe atribute pot fi definite pentru o funcție:

define[
  flatHold[x___] := Hold[x]
, {Flat, HoldAll}
]

flatHold[flatHold[1+1, flatHold[2+3]], 4+5]

Hold[1 + 1, 2 + 3, 4 + 5]

Fără alte formalități, aici este definiția de defini:

ClearAll@define
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:{}] :=
  ( ClearAll@name
  ; SetAttributes[name, DeleteCases[attributes, Open]]
  ; If[!MemberQ[attributes, Open]
    , def:name[___] := (Message[define::badargs, name, Defer@def]; Abort[])
    ]
  ; body
  ;
  )
def:define[___] := (Message[define::malformed, Defer@def]; Abort[])

define::badargs = "There is no definition for '``' applicable to ``.";
define::malformed = "Malformed definition: ``";

Expuse sprijină punerea în aplicare nici până-valori, nici curtau, nici modele mai general decât simpla definitie. Rămâne util, cu toate acestea.

Începe fără un notebook gol deschide

Am fost deranjat de a avea Mathematica începe cu un gol caiet deschis. Am putea închide acest notebook cu un script, dar încă flash deschide pentru scurt timp. Hack mea este de a crea un fișier Invizibile.nb` conțin:

Notebook[{},Visible->False]

Și pentru a adăuga acest mi Kernel\init.m :

If[Length[Notebooks["Invisible*"]] > 0, 
  NotebookClose[Notebooks["Invisible*"][[1]]]
]

SetOptions[$FrontEnd,
  Options[$FrontEnd, NotebooksMenu] /. 
    HoldPattern["Invisible.nb" -> {__}] :> Sequence[]
]

Eu acum începe Mathematica prin deschiderea Invizibil.nb

Poate exista un mod mai bun, dar asta mi-a servit bine.

Personalizate Ori " și " FoldList

Ori[f, x] este realizat echivalent cu Ori[f, în Primul rând@x, Restul@x]

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]

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

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

dynamicPartition[l_List, p : {_Integer?NonNegative ..}] :=
  dynP[l, p] /; Length@l >= Tr@p

dynamicPartition[l_List, p : {_Integer?NonNegative ..}, All] :=
  dynP[l, p] ~Append~ Drop[l, Tr@p] /; Length@l >= Tr@p

dynamicPartition[l_List, p : {_Integer?NonNegative ..}, n__ | {n__}] :=
  dynP[l, p] ~Join~ Partition[l ~Drop~ Tr@p, n] /; Length@l >= Tr@p

CreatePalette@
 Column@{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[], 
       ToBoxes@Map[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[], 
       ToBoxes@Map[strip, ImportString[data, "CSV"], {2}]]]]], 
   Button["Table", 
    Module[{data}, data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@ImportString[data, "Table"]]]]]}

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.}  *)

General PDF/EMF export probleme și soluții

1. este complet neașteptate și fără acte, dar Mathematica exporturile și salvează grafică în format PDF și EPS ce utilizează un set de stil definiții care diferă de cea utilizată pentru afișarea Notebook-uri de pe ecran. În mod implicit Notebook-uri sunt afișate pe ecran în "de Lucru" mediu de stil (care este valoarea implicită pentru ScreenStyleEvironment "global" $FrontEnd opțiune) dar sunt tipărite în "Imprimare" stil de mediu (care este valoarea implicită pentruPrintingStyleEnvironment "global" $FrontEndopțiune). Atunci când unul exporturile grafice în formate raster, cum ar fi GIF și PNG sau în format EMF *Mathematica* generează grafice care arata exact cum arata interiorul Notebook-uri. Se pare că la"de Lucru" stil mediu este folosit pentru randare în acest caz. Dar nu este cazul atunci când exportați/salva nimic în format PDF sau EPS formate! În acest caz, `"Imprimare" stil mediu este folosit în mod implicit, care diferă foarte mult de la "Munca" mediu de stil. Mai întâi de toate, la `"Imprimare" stil mediului seturi de Mărire să 80%. În al doilea rând, se folosește propriile valori pentru mărimile de font de stiluri diferite și acest lucru duce la contradicție dimensiunea fontului schimbări în genarated fișier PDF în comparație cu originalul de pe ecran reprezentare. Acesta din urmă poate fi numit FontSize fluctuations care sunt foarte enervant. Dar din fericire acest lucru poate fi evitat prin setarea PrintingStyleEnvironment "global" $FrontEnd opțiunea de a "Working":

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

2. problema comuna cu exportul în format EMF este că cele mai multe dintre programe (nu numai Mathematica) pentru a genera un fișier care pare frumos la dimensiunea implicită, dar devine urât atunci când zoom in. Este pentru că metafișierele sunt eșantionate la rezoluție a ecranului de fidelitate. Calitatea generat fișier EMF poate fi îmbunătățită prin `Mări ' ing original obiect grafic, astfel încât exactitate de prelevare a probelor de grafica originale devine mult mai precis. Compara două fișiere:

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

Dacă introduceți aceste fișiere în Microsoft Word și le-zoom in, veți vedea că primul "o" are dinți de fierăstrău pe ea în timp ce al doilea nu a (testat cu Mathematica 6).

Un alt mod prin ImageResolution a fost sugerat de Chris Degnen (această opțiune nu are efect, cel puțin începând de la Mathematica 8):

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

3. În Mathematica avem trei moduri de a converti grafica în metafile: prin "Export" la "EMF" (recomandat mod: produce metafile cu cea mai bună calitate posibilă), prin Salvare selecție Ca... meniu (produce mult mai mică cifră exactă, nu se recomandă) și prin Edit ► Copie Ca ► Metafile element de meniu (recomand acest traseu).

La cererea publicului, codul pentru a genera top-10 respondenti teren (cu excepția adnotări) folosind DECI API.

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 expresii

Am găsi aceste funcții foarte utile pentru cache de orice expresie. Cel mai interesant lucru aici pentru aceste două funcții este că a avut loc expresia în sine este folosită ca o cheie de hashtable/simbol Cache sau CacheIndex, comparativ cu cele bine-cunoscute memoization în mathematica în cazul în care puteți doar cache-ul rezultat în cazul în care funcția este definită ca f[x_] := f[x] = ... Astfel încât să puteți cache orice parte dintr-un cod, acest lucru este util dacă o funcție este de a fi sunat de mai multe ori, dar doar unele părți din cod nu trebuie să fie recalculate. Pentru a cache o expresie independent de argumentele sale.

SetAttributes[Cache, HoldFirst];
c:Cache[expr_] := c = expr;

Ex: Cache[Pause[5]; 6]
Cache[Pause[5]; 6]

A doua oară expresia returnează 6 fără a aștepta. Pentru a cache o expresie folosind un alias expresie care poate depinde un argument de cache exprimare.

SetAttributes[CacheIndex, HoldRest];
c:CacheIndex[index_,expr_] := c = expr;

Ex: CacheIndex[{"f",2},x=2;y=4;x+y]

Dacă expr nevoie de ceva timp pentru a calcula, este mult mai rapid pentru a evalua {"f",2} de exemplu, pentru a prelua în cache rezultat. Pentru o variație a acestor funcții, în scopul de a avea un localizate cache (de exemplu. memoria cache este automat eliberat din afara Blocului construct) a se vedea acest post https://stackoverflow.com/questions/7781981/avoid-repreated-calls-to-interpolation/7784989#7784989 Ștergerea cache valori

Pentru a șterge memoria cache valori atunci când don't știu numărul de definiții de funcție. Considerăm că definițiile au un Gol undeva în argumentele lor.

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

Pentru a șterge memoria cache valori atunci când știți numărul de definiții de funcție (merge mai repede).

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

Aceasta folosește faptul că definițiile de la o funcție la sfârșitul lor DownValues lista, cache valorile sunt înainte. Folosind simboluri pentru a stoca date și obiect-cum ar fi funcții

De asemenea, aici sunt interesante funcții pentru a utiliza simboluri, cum ar fi obiecte. Este deja bine cunoscut faptul că puteți stoca date în simboluri și a le accesa rapid folosind DownValues

mysymbol["property"]=2;

Puteți accesa lista de chei (sau proprietăți) de un simbol folosind aceste funcții bazate pe ceea ce dreeves prezentate într-un post de pe acest site:

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

Eu folosesc functia asta de mult pentru a afișa toate numerele conținute în DownValues de un simbol:

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

În cele din urmă aici este un mod simplu de a crea un simbol care se comportă ca un obiect în programarea orientată obiect (doar reproduce cele mai de bază comportamentul de OOP dar nu găsi sintaxa 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
  ];

Proprietățile sunt stocate ca DownValues și metode ca și întârziate Upvalues în simbolul creat de Modul în care este returnat. Am găsit sintaxa pentru function2 care este de obicei OO-sintaxa pentru funcții în https://stackoverflow.com/questions/6097071/tree-data-structure-in-mathematica/6097444#6097444. Pentru o listă de tipuri existente de valori, fiecare simbol are, vedea http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html și http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_Misc_4.html. De exemplu, încercați acest lucru

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

Puteți merge mai departe dacă doriți să imite moștenire obiect folosind un pachet numit InheritRules disponibile aici http://library.wolfram.com/infocenter/MathSource/671/ Ai putea stoca, de asemenea, funcția definiție nu în newObject dar într-un tip de simbol, așa că, dacă NewObject revenit tip[newObject] în loc de newObject ai putea defini funcția și function2 astfel de prognoze in afara de NewObject (și nu în interior) și au aceeași utilizare ca și mai înainte.

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

Utilizarea UpValues[tip] pentru a vedea care funcționează și function2 sunt definite în tipul de simbol. Alte idei despre ultima sintaxa sunt introduse aici https://mathematica.stackexchange.com/a/999/66. Versiune îmbunătățită a SelectEquivalents

@rcollyer: Multe mulțumiri pentru a aduce SelectEquivalents la suprafață, l's o funcție uimitoare. Aici este o versiune îmbunătățită a SelectEquivalents enumerate mai sus, cu mai multe posibilități și folosind opțiunile, acest lucru face mai ușor de utilizat.

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[
      {
         tagElement=OptionValue@TagElement,
         transformElement=OptionValue@TransformElement,
         transformResults=OptionValue@TransformResults,
         mapLevel=OptionValue@MapLevel,
         tagPattern=OptionValue@TagPattern,
         finalFunction=OptionValue@FinalFunction
      }
      ,
      finalFunction[
         Reap[
            Map[
               Sow[
                  transformElement@#
                  ,
                  {tagElement@#}
               ]&
               , 
               x
               , 
               {mapLevel}
            ] 
            , 
            tagPattern
            , 
            transformResults
         ][[2]]
      ]
   ];

Aici sunt exemple de modul în care această versiune poate fi folosit: https://stackoverflow.com/questions/6974544/using-mathematica-gather-collect-properly/6987982#6987982 https://stackoverflow.com/questions/8099866/how-would-you-do-a-pivottable-function-in-mathematica/8105565#8105565 https://stackoverflow.com/questions/8178714/mathematica-fast-2d-binning-algorithm/8183307#8183307 Interne De Geantă

Daniel Lichtblau descrie aici un interesant intern structura de date pentru liste tot mai mare. https://stackoverflow.com/questions/6691491/implementing-a-quadtree-in-mathematica/6795762#6795762 Depanare funcții

Aceste două posturi punct de funcții utile pentru depanare: https://stackoverflow.com/questions/6167291/how-to-debug-when-writting-small-or-big-codes-using-mathematica-workbench-mma/6168036#6168036 (Mi) https://stackoverflow.com/questions/5459735/the-clearest-way-to-represent-mathematicas-evaluation-sequence/5527117#5527117 (TraceView) Aici's-o altă funcție în baza Culege și Semăna cu extract de expresii din diferite părți ale unui program și a le stoca într-un simbol.

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

Aici's un exemplu

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*)

Alte resurse

Aici's o listă de link-uri interesante pentru învățare scopul: O colecție de Mathematica resurse de învățare Actualizat aici: https://mathematica.stackexchange.com/a/259/66

Mi funcții de utilitate (am construit în pentru a MUST, care este menționat în întrebare):

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[]    *)
  Most@NestWhileList[f[]&, f[], test];      (*  returns while test is true.   *)
readList[] := doList[read, #=!=EOF&];       (* Slurp list'o'lines from stdin. *)
cat = StringJoin@@(ToString/@{##})&;        (* Like sprintf/strout in C/C++.  *)
system = Run@cat@##&;                       (* 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[Evaluate@lst, 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).   *)

Un truc pe care eu'am utilizat, care vă permite să imite modul cel mai built-in functii de lucru cu argumente proaste (prin trimiterea unui mesaj și apoi revenind la forma întregul unevaluated) exploatează un capriciu de drum Starea funcționează atunci când este utilizat într-un defintion. Dacă " foo " ar trebui să lucreze doar cu un singur argument:

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

Dacă aveți mai multe nevoi complexe de it's ușor să factor în argumentul de validare și generarea de mesaje ca o funcție independentă. Poți face lucruri mai elaborate prin utilizarea de efecte secundare în "Condiție" dincolo de generarea de mesaje, dar, în opinia mea, cele mai multe dintre ele se încadrează în "neglijent hack" categorie și ar trebui să fie evitată dacă este posibil.

De asemenea, în "metaprogram" categorie, dacă aveți un pachetului Mathematica (.m) fișier, puteți utiliza `"HeldExpressions" element pentru a obține toate expresiile în fișierul înfășurat în HoldComplete. Acest lucru face de urmărire lucrurile mult mai ușor decât folosind text-bazat pe căutări. Din păcate, nu's nici o modalitate ușoară de a face același lucru cu un notebook, dar puteți obține toate de intrare expresii folosind ceva de genul următor:

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

În cele din urmă, puteți folosi faptul că "Modulul" emulează lexicale de închidere pentru a crea echivalentul tipuri de referință. Aici's un simplu stiva (care folosește o variantă de "Condiție" truc pentru eroare de manipulare ca un 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 = Last@backing; instance);

  HoldPattern[Push[instance : StackInstance[backing_], new_]] :=
   (backing = {new, backing}; instance);

  HoldPattern[Peek[instance : StackInstance[backing_]]] /;
    ! EmptyQ[instance] || (Message[StackInstance::empty]; False) :=
   First@backing]

Acum puteți să imprimați elementele dintr-o listă în ordine inversă într-un mod inutil de complicate fel!

With[{stack = MakeStack[], list},
 Do[Push[stack, elt], {elt, list}];

 While[!EmptyQ[stack],
  Print[Peek@stack];
  Pop@stack]]

Sistem de imprimare definiții simbol fără context precedat

Anii `contextFreeDefinition [] funcția de mai jos va încerca să imprimați definirea unui simbol fără cel mai comun context precedat. Definiția apoi pot fi copiate la bancul de lucru și formatate pentru lizibilitate (selectați-l, faceți clic dreapta, Sursa -> 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]}, 
    Print@InputForm[FullDefinition[sym]]]])

contextFreeDefinition[sym_Symbol, context_String] := 
 contextFreeDefinition[sym, {context}]

contextFreeDefinition[sym_Symbol] := 
 contextFreeDefinition[sym, commonestContexts[sym]]

withRules[]

Avertisment: Această funcție nu a localiza variabile de același fel " Cu " și "Modulul" nu, ceea ce înseamnă că imbricate localizare constructe câștigat't lucreze cum era de așteptat. withRules[{un -> 1, b -> 2}, Cu[{a=3}, b_ :> b]] va înlocuiți " a " și " b "în imbricate" Cu " și "Normă", în timp ce " Cu " nu't face acest lucru.

Aceasta este o variantă a " Cu " care utilizează reguli în loc de = și :=:

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

Am găsit acest util în timp ce curățarea codul scris în timpul experimentării și localizarea variabile. Ocazional ajung cu parametru liste în formă de {par1 -> 1.1, par2 -> 2.2}. Cu withRules` valorile parametrilor sunt ușor pentru a injecta în codul scris anterior folosind variabile globale.

Utilizare este la fel ca "Cu":

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

Antialiasing grafica 3D

Aceasta este o tehnica foarte simpla pentru a antialias grafica 3D, chiar dacă hardware-ul grafic nu't suport nativ.

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

Aici's un exemplu:

Rețineți că o mare valoare pentru " n " sau o dimensiune mare a imaginii tinde să expune grafică driver bug-uri sau de a introduce artefacte.

Notebook dif funcționalitate

Notebook dif funcționalitate este disponibilă în <<AuthorTools pachetului, și (cel puțin în versiunea 8) în nedocumentateNotebookTools` ` contextul. Acest lucru este un pic GUI pentru diff două notebook-uri care sunt în prezent deschise:

PaletteNotebook@DynamicModule[
  {nb1, nb2}, 
  Dynamic@Column[
    {PopupMenu[Dynamic[nb1], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     PopupMenu[Dynamic[nb2], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     Button["Show differences", 
      CreateDocument@NotebookTools`NotebookDiff[nb1, nb2]]}]
  ]

Recursiv funcții pure (#0) pare a fi unul dintre cele mai întunecate colțuri ale limbii. Aici sunt un cuplu de non-trivial exemple de utilizare a acestora , în cazul în care acest lucru este foarte util (nu că ei nu se poate face fără ea). Următoarele este o destul de concisă și destul de repede, funcția de a găsi componente conectate într-un grafic, având în vedere o listă de muchii specificat ca perechi de noduri:

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[Flatten@lst][[All, 1]], f]];

Ce se întâmplă aici este că avem prima hartă un manechin simbol de pe fiecare nod numere, și apoi configurați-un mod care, având o pereche de noduri {f[5],f[10]}, spune, apoi, f[5]s-ar evalua laf[10]. Recursive pur funcție este utilizată ca o cale de a compresorului (pentru a configura memoization în așa fel încât în loc de lanțuri lungi caf[1]=f[3],f[3]=f[4],f[4]=f[2], ...`, memoized valorile corectate ori de câte ori un nou "rădăcină" de componenta este descoperit. Aceasta oferă o viteză semnificativă-up. Pentru că vom folosi de atribuire, trebuie să fie Geantă, ceea ce face acest construct chiar mai obscur și mai atractiv ). Această funcție este un rezultat al pe și off-line Mathgroup discuție care implică Fred Simons, Szabolcs Horvat, DrMajorBob și subsemnatul. Exemplu:

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>>}}

Este cu siguranță mult mai lent decât un built-in, dar pentru dimensiunea de cod, destul de rapid, încă OMI.

Un alt exemplu: aici este un recursiv realizarea de "Selectați", bazat pe liste legate și recursiv pur funcții:

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

De exemplu,

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}}

Cu toate acestea, este nu în mod corespunzător coada recursiv, și va sufla stiva (accident kernel-ul) mai mare pentru liste. Aici este coada-versiune recursiv:

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]], {}]];

De exemplu,

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}} 

Aceasta este reteta de la Stan Vagon's carte...folositi-l atunci când a construit-in Teren se comporta haotic din cauza lipsei de precizie

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]]]]];

De multe ori am folosi urmatorul truc de Kristjan Kannike's, atunci când am nevoie de "dicționar-ca" comportamentul de 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]

Când rezultatele evaluării sunt confuze, uneori ajută să-și arunce etape de evaluare într-un fișier text

SetAttributes[recordSteps, HoldAll];
recordSteps[expr_] :=
 Block[{$Output = List@OpenWrite["~/temp/msgStream.m"]}, 
  TracePrint[Unevaluated[expr], _?(FreeQ[#, Off] &), 
   TraceInternal -> True];
  Close /@ $Output;
  Thread[Union@
    Cases[ReadList["~/temp/msgStream.m", HoldComplete[Expression]], 
     symb_Symbol /; 
       AtomQ@Unevaluated@symb && 
        Context@Unevaluated@symb === "System`" :> 
      HoldComplete@symb, {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]]

Este posibil pentru a rula MathKernel în modul de lot prin utilizarea fără acte opțiuni de linie de comandă -batchinput " și " - batchoutput:

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

(unde input.m este lot fișier de intrare se termină cu caracterul newline, outputfile.txt este fișierul în care producția va fi redirecționat).

În Mathematica v.>=6 MathKernel a nedocumentate opțiunea de linie de comandă:

-noicon

care controlează dacă MathKernel va fi vizibilă pictograma de pe bara de Activități (cel puțin sub Windows).

FrontEnd (cel puțin din v. 5) a nedocumentate opțiunea de linie de comandă

-b

care dezactivează splash-screen și vă permite să rulați Mathematica Interfață mult mai repede

și opțiunea de

-directlaunch

care dezactivează mecanismul care lansează cea mai recentă Mathematica versiune installed în loc de a lansa versiunea asociat cu .nb fișiere în registry de sistem.

Un alt mod de a face acest lucru, probabil, este:

în Loc lansarea Mathematica.exe binar în directorul de instalare, lansa Mathematica.exe binar în SystemFiles\FrontEnd\Binare\Windows. primul este un lansator simplu program care încearcă din greu să redirecționa cererile pentru deschiderea notebook-uri pentru rularea copii ale interfață de utilizator. Acesta din urmă este interfață de utilizator binar în sine.

Este util să se combine ultima opțiune în linia de comandă cu setarea globală FrontEnd opțiunea VersionedPreferences->Adevărat care dezactivează partajarea de preferințe între diferite Mathematica versiuni instalate:

SetOptions[$FrontEnd, VersionedPreferences -> True]

(Cele de mai sus ar trebui să fie evaluate la cea mai recentă Mathematica versiune instalată.)

În Mathematica 8 acest lucru este controlat în dialog Preferințe, în Sistem panou, sub setarea "de a Crea și de a menține versiune specifice front-end preferences".

Este posibil pentru a obține listă incompletă de opțiuni de linie de comandă de front-end prin utilizarea fără acte cheie -h (codul pentru Windows):

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

oferă:

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

Alte opțiuni includ:

-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

Există și alte potențial utile opțiuni de linie de comandă de MathKernel și FrontEnd? Vă rugăm share dacă știi.

Conexe question.

PutAppend cu PageWidth -> Infinity

În Mathematica utilizarea de PutAppendcomanda este cel mai simplu mod de a menține un jurnal de funcționare fișier cu rezultate din calcule intermediare. Dar se folosește în mod implicitCu->78` setare atunci când exportul expresii într-un fișier și astfel încât nu există nici o garanție că fiecare intermediar de ieșire va avea doar o singură linie în jurnal.

PutAppend nu are nici o opțiune în sine, ci contur și evaluările sale relevă faptul că ea se bazează pe OpenAppend funcția care areCuopțiune și vă permite să schimbați valoarea sa implicită deSetOptions` comanda:

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

Astfel încât să putem obține PutAppend pentru a adăuga doar o linie la un timp de setare:

SetOptions[OpenAppend, PageWidth -> Infinity]

UPDATE

Există o bug a introdus în versiunea 10 (fix în versiunea 11.3): SetOptions nu mai afectează comportamentul de OpenWrite " și " OpenAppend.

O soluție este de a pune în aplicare propria versiune a PutAppend explicit PageWidth -> Infinity opțiune:

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

Rețineți că, de asemenea, poate să-l pună în aplicare prin intermediul WriteString așa cum se arată în acest răspunsul, dar în acest caz va fi necesar să prealabil converti expresia în corespunzătoare InputForm "prin" ToString[expr, InputForm].

Preferata mea hacks sunt mici cod generatoare de macro-uri care vă permit să înlocuiți o grămadă de șabloane standard de comenzi cu unul scurt. Alternativ, puteți crea comenzi pentru deschiderea/crearea de notebook-uri.

Aici este ceea ce am'am fost folosind-o pentru un timp în viața mea de zi cu zi Mathematica flux de lucru. M-am trezit efectuează următoarele mult:

1. Face un notebook privată context, pachet de încărcare(s) de care am nevoie, face autosave.
2. După ce a lucrat cu acest notebook pentru un timp, am'd vrei sa faci ceva arunca zero calcule într-un caiet separat, cu propriile sale private context, având în același timp acces la definițiile am'am fost folosind în "principal" notebook-uri. Pentru că am înființat privat context, acest lucru necesită de a regla manual $ContextPath

Face acest lucru de mână de peste si peste este o durere, asa ca lasa - 's a automatiza! În primul rând, unele de utilitate cod:

(* 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 = Flatten@List@list; 
  If[! MemberQ[ctList, Except[_String]],AppendTo[$ContextPath, #] & /@ ctList, 
   Message[ExposeContexts::badargs]];
  $ContextPath = DeleteDuplicates[$ContextPath];
  $ContextPath]

    Autosave[x:(True|False)] := SetOptions[EvaluationNotebook[],NotebookAutoSave->x];

Acum, las's a crea un macro care's de gând să pună următoarele celule în notebook-uri:

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

Și aici's macro:

MyPrivatize[exposedCtxts : ({__String} | Null) : Null]:=
  SelfDestruct@Module[{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];
      ]
 ]

Acum când am tip MyPrivatize[] se creează privat context și o mulțime mea pachetul standard. Acum las's a crea o comandă care va deschide un nou notebook zero cu propriile sale private context (astfel încât să puteți hack cu wild abandona fără riscul de a periclita definiții), dar are acces la contexte actuale.

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

Misto lucru despre acest lucru este că, din cauza se Autodistruga, atunci când comanda se execută nu lasă nici o urmă în actualul notebook-care este bun, pentru că în caz contrar s-ar crea dezordine.

Pentru un plus de stil de puncte, puteți crea cuvinte cheie declanșează pentru aceste macro-uri folosind InputAutoReplacements, dar am'll las asta ca un exercițiu pentru cititor.

Unul dintre lucrurile care mă deranjează în legătură cu built-in de definire a domeniului evaluării constructelor este că acestea sunt evaluate locale definiții de variabile de la o dată, astfel încât să puteți't scrie, de exemplu,

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

Deci un timp în urmă am venit cu un macro numit WithNest care vă permite să facă acest lucru. Mi se pare la îndemână, deoarece vă permite să păstrați variabilă legăturile locale fără a fi nevoie de a face ceva de genul

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

În final, cel mai bun mod am putea găsi pentru a face acest lucru era de a utiliza un simbol special pentru a face mai ușor pentru a recurse pe lista de legaturi, si am pus-o definiție în propriul său pachet pentru a păstra acest simbol ascuns. Poate cineva are o soluție simplă la această problemă?

Dacă doriți să încercați să-l afară, a pus următorul text într-un fișier numit de Definire a domeniului evaluării.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[List@a,body]]];

SyntaxInformation[WithNest]={"ArgumentsPattern"->{{__},_}};
SetAttributes[WithNest,{HoldAll,Protected}];

End[];

EndPackage[];

Am fost doar în căutarea prin unul din pachetele pentru includerea în acesta, și am găsit niște mesaje care am definit ca face minuni: Debug::<nume>. În mod implicit, acestea sunt oprite, deci don't produc mult deasupra capului. Dar, nu pot gunoi codul meu cu ei, și porniți-le dacă am nevoie să dau seama exact cum un pic de cod se comportă.