Que contient votre trousse à outils Mathematica?

Question

Nous savons tous que Mathematica est grand, mais il a aussi souvent un manque de fonctionnalités critiques. Ce genre de paquets externes / outils / ressources utilisez-vous avec Mathematica?

Je vais modifier (et inviter quelqu'un d'autre de le faire trop) ce poste principal de prévoir des ressources qui sont axées sur l'applicabilité générale de la recherche scientifique et qui, comme beaucoup de gens que possible seront utiles. N'hésitez pas à apporter quoi que ce soit, même de petits fragments de code (comme je l'ai fait ci-dessous pour un calendrier de routine).

Également, des sans-papiers et de nombreuses fonctionnalités utiles dans Mathematica 7 et au-delà, vous avez trouvé vous-même, ou creusé à partir d'une feuille de papier/site sont la plupart de bienvenue.

Veuillez inclure une brève description ou un commentaire sur pourquoi quelque chose est grande ou quelle utilité qu'il procure. Si vous avez des liens vers des livres sur Amazon avec des liens d'affiliation, veuillez le mentionner, par exemple, en mettant votre nom après le lien.

---

Forfaits:

1. LevelScheme est un package qui élargit considérablement Mathematica de la capacité à produire de la bonne à la recherche de parcelles. - Je l'utiliser si ce n'est pour rien d'autre, pour le bien d'un meilleur contrôle de trame/axes de tiques. Sa dernière version est appelée SciDraw, et sera publié dans le courant de cette année.
2. David Park Presentation Package ($50 - pas de frais pour les mises à jour)
3. Jeremy Michelson de l' grassmannOps paquet fournit des ressources pour faire de l'algèbre et le calcul avec des variables de Grassmann et les opérateurs qui ont non trivial de commutation relations.
4. John Brown GrassmannAlgebra offres et réservez pour le travail avec de Grassmann et les algèbres de Clifford.
5. RISC (Institut de Recherche pour le Calcul Symbolique) a une variété de forfaits pour Mathematica (et autres langues) disponibles pour le téléchargement. En particulier, il est Theorema automatisée pour la démonstration, et la multitude de forfaits pour la symbolique de sommation, les équations aux différences, etc à l' Algorithmique Combinatoire du groupe logiciel page.

Outils:

1. MASH est Daniel Reeves est un excellent script perl essentiellement en fournissant un support des scripts pour Mathematica v7. (Maintenant intégré dans de Mathematica 8 avec l'option du script.)
2. Un alternate Mathematica shell GNU readline d'entrée (à l'aide de python, *nix seulement)

Ressources:

1. Wolfram propre référentiel MathSource a beaucoup de utile si étroit cahiers pour diverses applications. Découvrez également les autres sections telles que

   • Current Documentation,
   • Courseware pour les conférences, les
   • et Demos pour les démos.

2. Le Mathematica Wikibook.

Livres:

1. Mathematica de programmation: une introduction avancée par Leonid Shifrin (web, pdf) est à lire absolument si vous voulez faire quelque chose de plus que Pour les boucles dans Mathematica. Nous avons le plaisir de Leonid lui-même répondre à des questions ici.
2. Quantum Méthodes avec Mathematica par James F. Feagin (amazon)
3. Mathematica, un Livre de Stephen Wolfram (amazon) (web)
4. Schaum du Contour (amazon)
5. Mathematica dans l'Action par Stan Wagon (amazon) - 600 pages de pur exemples et va jusqu'à Mathematica de la version 7. Les techniques de visualisation sont particulièrement bons, vous pouvez voir certains d'entre eux sur l'auteur de l' Demonstrations Page.
6. Mathematica les Fondamentaux de la Programmation par Richard Gaylord (pdf) - Une bonne introduction parfaite à la plupart de ce que vous devez savoir à propos de Mathematica de programmation.
7. Mathematica livre de cuisine par Sal Mangano publié par O'Reilly 2010 832 pages. Écrit dans le bien connu O'Reilly livre de cuisine de style: la Solution du Problème. Pour les intermédiaires.
8. Équations différentielles avec Mathematica, 3ème Ed. Elsevier 2004 Amsterdam par Martha L. Abell, James P. Braselton - 893 pages Pour les débutants, apprendre à résoudre DEs et Mathematica en même temps.

Sans-papiers (ou peu documentées) Caractéristiques:

1. Comment personnaliser Mathematica raccourcis clavier. Voir this question.
2. Comment inspecter les structures et fonctions utilisées par Mathematica propres fonctions. Voir this answer
3. Comment obtenir la Cohérence de la taille pour GraphPlots dans Mathematica? Voir this question.
4. Comment produire des Documents et des Présentations avec Mathematica. Voir this question.

Answer 1

Une des belles choses sur le cahier Mathematica interface est qu'elle permet d'évaluer des expressions dans toutes les langues, pas seulement en Mathematica. Comme simple exemple, envisager la création d'une nouvelle Coque d'entrée type de cellule qui transmet le contenu de l'expression à l'environnement du système d'exploitation à des fins d'évaluation.

Tout d'abord, de définir une fonction que les délégués de l'évaluation d'un texte de commande pour la coque externe:

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

Le deuxième argument est nécessaire et ignorés pour des raisons qui deviendront évidentes plus tard. Ensuite, nous voulons créer un nouveau style appelé Shell:

1. Ouvrez un nouveau carnet de notes.
2. Sélectionnez l'élément de menu Format/Modifier la feuille de style...
3. Dans la boîte de dialogue, à côté Entrez un nom de style: type Shell.
4. Sélectionnez la cellule support à côté du nouveau style.
5. Sélectionnez l'élément de menu Cellules/Afficher l'Expression
6. Remplacer l'expression de la cellule à l' Étape 6 le Texte donné ci-dessous.
7. Encore une fois, sélectionnez l'élément de menu Cellules/Afficher l'Expression
8. Fermer la boîte de dialogue.

Utiliser la cellule suivante de l'expression comme l' Étape 6 du Texte:

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 plupart de cette expression a été copié directement de l'intégré dans le Programme de style. Les principales modifications sont ces lignes:

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

Evaluatable permet à l'MAJ+ENTRÉE de la fonctionnalité de la cellule. L'évaluation fera appel à la CellEvaluationFunction passant le contenu de la cellule et le type de contenu comme arguments (shellEvaluate ignore le dernier argument). CellFrameLabels est juste un concept qui laisse à l'utilisateur d'identifier que cette cellule est inhabituel.

Avec tout cela en place, nous pouvons maintenant saisir et d'évaluer une expression shell:

1. Dans le cahier créé dans les étapes ci-dessus, de créer une cellule vide et sélectionnez la cellule support.
2. Sélectionnez l'élément de menu Format/Style/Shell.
3. Type valide shell du système d'exploitation de commande dans la cellule (par exemple, " ls " sur Unix ou 'dir' sur Windows).
4. Appuyez sur MAJ+ENTRÉE.

Il est préférable de garder ce style défini dans un hôtel de la feuille de style. En outre, l'évaluation des fonctions comme shellEvaluate sont mieux définis comme les talons de l'aide DeclarePackage en init.m. Les détails de ces activités sont au-delà de la portée de cette réponse.

Avec cette fonctionnalité, on peut créer des blocs-notes qui contiennent des expressions entrées dans toute la syntaxe d'intérêt. La fonction d'évaluation peut être écrit dans le plus pur Mathematica, ou déléguer tout ou partie de l'évaluation externe de l'agence. Sachez qu'il existe d'autres crochets qui se rapportent à la cellule d'évaluation, comme CellEpilog, CellProlog et CellDynamicExpression.

Un modèle commun implique l'écriture de l'expression d'entrée de texte dans un fichier temporaire, de la compilation du fichier dans certaines langues, l'exécution du programme et à la capture de la sortie pour écran ultime dans la cellule en sortie. Il y a beaucoup de détails à l'adresse lors de la mise en œuvre d'une solution complète de ce genre (comme la capture des messages d'erreur correctement), mais il faut apprécier le fait qu'il n'est pas possible de faire ce genre de choses, mais pratique.

Sur une note personnelle, c'est cela qui rend l'interface de cahier au centre de mon univers de la programmation.

Mise à jour

La fonction d'assistance suivante est utile pour la création de ces cellules:

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

Il est utilisé ainsi:

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

Maintenant, si shellCell[] est évaluée, la cellule d'entrée sera supprimé et remplacé par une nouvelle cellule d'entrée qui donne son contenu comme une commande shell.

Answer 2

Todd Gayley (Wolfram) il suffit de m'envoyer un joli hack qui permet à "envelopper" les fonctions intégrées de code arbitraire. J'ai l'impression que j'ai à partager cette instrument utile. Voici Todd répondre sur mon question.

Un peu intéressant (?) l'histoire: ce style de hack pour "l'habillage" un fonction intégrée a été inventé autour de 1994 par Robby Villegas et je, ironiquement, pour la fonction de Message, dans un package appelé ErrorHelp que j'ai écrit pour Mathematica, un Journal de l'époque. Il a été utilisé à plusieurs reprises, par beaucoup de gens, depuis. C'est un peu un initié tromper, mais je pense qu'il est juste de dire qu'il est devenu canonique façon d'injecter votre propre code dans la définition d'un haut- fonction. Il fait le travail très bien. Vous pouvez, bien sûr, à mettre l' $inMsg variable dans n'importe quel contexte privé vous le souhaitez.

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

Answer 3

J'ai mentionné cela avant, mais l'outil que je trouve les plus utiles est une application de Reap et Sow qui imite/s'étend le comportement de l' GatherBy:

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

Cela me permet au groupe de listes par les critères et les transformer dans le processus. La façon dont cela fonctionne est que une fonction de critères (f) des balises de chaque élément dans la liste, chaque élément est ensuite transformé par une seconde fonction fournie (g), et la sortie est contrôlée par une troisième fonction (h). La fonction h accepte deux arguments: une étiquette et une liste des éléments recueillis qui ont cette balise. Les éléments conservent leur ordre d'origine, donc si vous définissez h = #1& alors vous obtenez un non triés Union, comme dans les exemples pour Reap. Mais, il peut être utilisé pour la transformation secondaire.

Un exemple de son utilité, j'ai travaillé avec Wannier90 les sorties qui l'spatialement dépendantes Hamiltonien dans un fichier où chaque ligne est un autre élément de la matrice, comme suit

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

Pour transformer cette liste en un ensemble de matrices, je rassemblai toutes les sous-listes qui contiennent les mêmes coordonnées, activé l'élément de l'information en règle (c'est à dire {i,j}-> Re[Hij]+I Im[Hij]), puis tourna le collectées règles en SparseArray tous les avec la un paquebot:

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

Honnêtement, c'est mon Couteau Suisse, et ça rend les choses complexes très simple. La plupart de mes autres outils sont un peu spécifique au domaine, donc je vais probablement de ne pas les poster. Cependant, la plupart, si pas tous, de référence SelectEquivalents.

Edit: il n'est pas complètement imiter GatherBy qu'il ne saurait groupe de plusieurs niveaux de l'expression aussi simplement qu' GatherBy peut. Toutefois, Map fonctionne très bien pour la plupart de ce dont j'ai besoin.

Exemple: @Yaroslav Bulatov a demandé pour lui-même un exemple. Voici une de mes travaux de recherche a été grandement simplifié. Alors, disons que nous avons un ensemble de points dans un plan

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

et nous aimerions réduire le nombre de points par un ensemble d'opérations de symétrie. (Pour les curieux, nous sommes la génération de la petite troupe de chaque point.) Pour cet exemple, nous allons utiliser quatre fois axe de rotation sur l'axe z

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

À l'aide de SelectEquivalents nous pouvons regrouper les points qui produisent le même ensemble d'images dans ces opérations, c'est à dire qu'ils sont l'équivalent, en utilisant les éléments suivants

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

qui produit des 3 sous-listes contenant l'équivalent de points. (Remarque, Union est absolument vital ici qu'il s'assure que la même image est produite par chaque point. A l'origine, j'ai utilisé Sort, mais si un point se trouve sur un axe de symétrie, il est invariante par la rotation autour de l'axe de donner une image supplémentaire de lui-même. Donc, Union élimine ces images supplémentaires. Aussi, GatherBy produirait le même résultat.) Dans ce cas, les points sont déjà dans une forme que je vais utiliser, mais je n'ai besoin que d'un représentant de chaque groupement et je voudrais un comte de l'équivalent de points. Depuis, je n'ai pas besoin de transformer chaque point, j'utilise l' Identity fonction dans la deuxième position. Pour la troisième fonction, nous devons être prudents. Le premier argument passé à il sera les images des points sous les rotations qui, pour le point de {0,0,0} est une liste de quatre éléments identiques, et l'utiliser allait jeter hors de la comte. Cependant, le deuxième argument est juste une liste de tous les éléments qui ont ce tag, alors elle ne contiendra {0,0,0}. Dans le code,

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

Remarque, cette dernière étape peut être réalisé facilement par

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

Mais, c'est facile avec ce et le moins complète de l'exemple ci-dessus pour voir comment les transformations complexes sont possibles avec un minimum de code.

Answer 4

Ce n'est pas un ensemble complet, je vais donc me lancer ici dans la section réponses, mais je l'ai trouvé très utile pour déterminer la vitesse de questions (qui, malheureusement, est une grande partie de ce que Mathematica de programmation).

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'utilisation est alors simplement de l' timeAvg@funcYouWantToTest.

EDIT: M. Assistant a fourni une version plus simple qui élimine Throw et Catch et est un peu plus facile à analyser:

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

EDIT: Voici une version de l'acl (prises à partir d' ici):

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]

Answer 5

Internal`InheritedBlock

J'ai appris récemment l'existence d'une telle fonction utile en tant que Internal`InheritedBlock, à partir de ce message de Daniel Lichtblau officiel de groupes de discussion.

Ce que je comprends, Internal`InheritedBlock permet de passer d'une copie d'un sortant de fonction à l'intérieur de l' Block portée:

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]

Je pense que cette fonction peut être très utile pour tous ceux qui ont besoin de modifier des fonctions intégrées temporairement!

Comparaison avec Bloc

Laissez-nous définir une fonction:

a := Print[b]

Maintenant nous voulons nous transmettre une copie de cette fonction dans l' Block de la portée. La naïveté de l'essai ne donne pas ce que nous voulons:

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

During evaluation of In[9]:= b

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

Maintenant, essayez d'utiliser retardé définition dans le premier argument de l' Block (c'est une fonctionnalité non documentée):

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

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

During evaluation of In[3]:= b

Nous voyons que dans ce cas - a fonctionne, mais nous n'avons pas obtenu une copie de l'original, a à l'intérieur de l' Block de la portée.

Maintenant essayons Internal`InheritedBlock:

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

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

Nous avons obtenu une copie de la définition originale pour a à l'intérieur de l' Block portée et l'on peut le modifier de la façon que nous voulons sans affecter la définition globale pour a!