Qu'y a-t-il dans votre sac à outils Mathematica? [fermé]

nous savons tous que Mathematica est grand, mais il manque souvent la fonctionnalité critique. Quel type de progiciels / outils / ressources externes utilisez-vous avec Mathematica?

je vais éditer (et inviter n'importe qui d'autre à le faire aussi) ce poste principal pour inclure des ressources qui sont axées sur l'applicabilité générale dans la recherche scientifique et qui autant de gens que possible trouveront utile. N'hésitez pas à contribuer n'importe quoi, même de petits morceaux de code (comme je l'ai fait ci-dessous pour un la routine temporelle).

aussi, les caractéristiques non documentées et utiles dans Mathematica 7 et au-delà que vous avez trouvé vous-même, ou déterré à partir d'un certain papier/site sont les plus bienvenus.

veuillez inclure une brève description ou un commentaire sur la raison pour laquelle quelque chose est grand ou l'utilité qu'il fournit. Si vous liez à des livres sur Amazon avec des liens d'affiliation s'il vous plaît le mentionner, par exemple, en mettant votre nom après le lien.


colis:

  1. LevelScheme est un paquet qui élargit considérablement la capacité de Mathematica à produire de bons tracés. Je l'utilise si ce n'est pas pour autre chose alors pour le contrôle beaucoup, beaucoup amélioré sur les tiques cadre/axes. Sa version la plus récente s'appelle SciDraw, et elle sortira cette année.
  2. David Park's Presentation Package (50 $ US-sans frais pour les mises à jour)
  3. de Jeremy Michelson grassmannOps paquet fournit des ressources pour faire l'algèbre et le calcul avec des variables de Grassmann et les opérateurs qui ont des relations de commutation non trivial.
  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 paquets pour Mathematica (et d'autres langues) disponibles pour le téléchargement. En particulier, il y a Theorema pour le théorème automatique proving, et la multitude de paquets pour la sommation symbolique, équations de différence, etc. à la Algorithmique Combinatoire du groupe logiciel-page .

outils:

  1. MASH est l'excellent script de Daniel Reeves Perl fournissant essentiellement un support de script pour Mathematica v7. (Maintenant intégré à partir de Mathematica 8 avec l'option -script .)
  2. An alternate Mathematica shell avec une entrée GNU readline (utilisant python, *nix seulement)
  3. ColourMaths package vous permet de sélectionner visuellement des parties d'une expression et de les manipuler. http://www.dbaileyconsultancy.co.uk/colour_maths/colour_maths.html

ressources:

  1. Wolfram propre référentiel MathSource est utile si étroit cahiers pour diverses applications. Consultez également les autres sections telles que

  2. The Mathematica Wikibook .

livres:

  1. Mathematica de programmation: une introduction avancée par Leonid Shifrin ( web , pdf ) est un doit lire si vous voulez faire quoi que ce soit de plus que pour boucles dans Mathematica. Nous avons le plaisir d'avoir Leonid lui-même répondant aux questions ici.
  2. Quantum Méthodes avec Mathematica par James F. Feagin ( amazon )
  3. Mathematica, un Livre par Stephen Wolfram ( amazon ) ( web )
  4. Schaum du Plan ( amazon )
  5. Mathematica in Action by Stan Wagon ( amazon ) - 600 pages d'exemples soignés et va Jusqu'à Mathematica version 7. Les techniques de visualisation sont particulièrement bonnes, vous pouvez voir certains d'entre eux sur le Demonstrations Page .
  6. Mathematica Programming Fundamentals by Richard Gaylord ( pdf ) - une bonne introduction concise à la plupart de ce que vous devez savoir sur la programmation Mathematica.
  7. Mathematica livre de cuisine par Sal Mangano publié par O'Reilly 2010 832 pages. - Écrire dans le célèbre Style de Livre De Cuisine O'Reilly: Problème-Solution. 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 débutants, pour apprendre à résoudre des problèmes et Mathematica en même temps.

caractéristiques non documentées (ou peu documentées):

  1. comment personnaliser Mathematica les raccourcis clavier. Voir this question .
  2. Comment inspecter les motifs et les fonctions utilisés par les propres fonctions de Mathematica. Voir this answer
  3. Comment obtenir une taille cohérente pour GraphPlots dans Mathematica? Voir this question .
  4. Comment produire des documents et des présentations avec Mathematica. Voir this question .
141
demandé sur Dr. belisarius 0000-00-00 00:00:00
la source

26 ответов

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

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

cela me permet de grouper les listes par n'importe quel critère et les transformer dans le processus. La façon dont cela fonctionne est qu'une fonction de critères ( f ) marque 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 articles conservent leur ordre d'origine, donc si vous mettez h = #1& alors vous obtenez un non trié Union , comme dans le exemples pour Reap . Mais, il peut être utilisé pour la transformation secondaire.

comme exemple de son utilité, j'ai été travaillant avec Wannier90 qui produit L'Hamiltonien spatialement dépendant dans un fichier où chaque ligne est un élément différent dans la matrice, comme suit

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

pour transformer cette liste en un ensemble de matrices, j'ai rassemblé toutes les sous-listes qui contiennent la même coordonnée, j'ai transformé l'information de l'élément en une règle (i.e. {i,j}-> Re[Hij]+I Im[Hij]), puis j'ai transformé les règles rassemblées en une SparseArray toutes avec la même doublure:

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écifiques au domaine, donc je ne les posterai probablement pas. Toutefois, la plupart d'entre eux, sinon tous, font référence à SelectEquivalents .

Edit : il ne imite pas complètement GatherBy en ce qu'il ne peut pas grouper plusieurs niveaux de l'expression aussi simplement que GatherBy peut. Cependant, Map fonctionne très bien pour la plupart de ce dont j'ai besoin.

exemple : @Yaroslav Bulatov a demandé un exemple complet. Voici une de mes recherches qui a été grandement simplifiée. 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 produisons le petit groupe de chaque point.) Pour cet exemple, utilisons un axe de rotation à quatre axes autour de l'axe z

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

en utilisant SelectEquivalents nous pouvons regrouper les points qui produisent le même ensemble d'images sous ces opérations, c'est-à-dire qu'ils sont équivalents, en utilisant ce qui suit

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 3 sous-listes contenant les points équivalents. (Note, Union est absolument essentiel ici car il assure que la même image est produite par chaque point. À l'origine, j'ai utilisé Sort , mais si un point se trouve sur un axe de symétrie, il est invariant sous la rotation autour de cet axe donnant 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 d'un point représentatif de chaque groupement et je voudrais un compte des points équivalents. Depuis, je n'ai pas besoin de transformer chaque point, j'utilise le Identity fonction dans la deuxième position. Pour la troisième fonction, nous devons être prudents. Le premier argument passé à elle sera les images des points sous les rotations qui pour le point {0,0,0} est une liste de quatre éléments identiques, et en l'utilisant serait jeter hors du compte. Cependant, le deuxième argument est juste une liste de tous les éléments qui ont cette étiquette, donc il ne contiendra que {0,0,0} . En 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}}

Note, cette dernière étape peut tout aussi facilement être accompli par

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

mais, il est facile avec ceci et l'exemple moins complet ci-dessus de voir comment des transformations très complexes sont possibles avec un minimum de code.

27
répondu rcollyer 2017-05-23 15:18:01
la source

L'une des bonnes choses au sujet de L'interface du bloc-notes Mathematica est qu'elle peut évaluer des expressions dans n'importe quelle Langue, pas seulement Mathematica. À titre d'exemple simple, envisagez de créer un nouveau type de cellule d'entrée Shell qui transmet l'expression contenue au shell du système d'exploitation pour évaluation.

tout d'abord, définissez une fonction qui délègue l'évaluation d'une commande textuelle au shell externe:

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

le second argument est nécessaire et ignoré pour des raisons qui apparaîtront plus tard. Ensuite, nous voulons créer un nouveau style appelé Shell :

  1. ouvrir un nouveau carnet.
  2. sélectionnez l'élément de menu Format/Modifier la feuille de style...
  3. dans le dialogue, à côté de entrez un nom de style: type Shell .
  4. sélectionnez la case à côté du nouveau style.
  5. sélectionner l'élément de menu Cell/Show Expression
  6. remplace l'expression de la cellule par Étape 6 texte donnée ci-dessous.
  7. une fois de plus, sélectionnez l'élément de menu Cell/Show Expression
  8. fermez le dialogue.

utilisez la cellule suivante expression comme le Étape 6 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 plus grande partie de cette expression a été copiée directement sous forme de programme style. Les principaux changements sont les suivants:

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

Evaluatable permet la fonctionnalité SHIFT+ENTER pour la cellule. L'évaluation appellera CellEvaluationFunction en passant le contenu de la cellule et le type de contenu comme arguments ( shellEvaluate ignore ce 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 entrer et évaluer une expression shell:

  1. dans le bloc-notes créé dans les étapes ci-dessus, créer une cellule vide et sélectionner le support de la cellule.
  2. sélectionnez l'élément du 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. Press SHIFT+ENTER.

il est préférable de conserver ce style défini dans une feuille de style située au centre. De plus, les fonctions d'évaluation telles que shellEvaluate sont mieux définies comme étant des talons en utilisant Déclarepackage dans init.m . Les détails de ces deux activités dépassent la portée de la présente réponse.

avec cette fonctionnalité, on peut créer des notebooks qui contiennent des expressions d'entrée dans n'importe quelle syntaxe d'intérêt. La fonction d'évaluation peut être écrite en Mathematica pur, ou déléguer une partie ou la totalité de l'évaluation à un organisme externe. Soyez conscient qu'il y a d'autres crochets qui se rapportent à l'évaluation des cellules, comme CellEpilog , CellProlog et CellDynamicExpression .

un modèle commun implique l'écriture de l'expression texte d'entrée à un fichier temporaire, la compilation du fichier dans une certaine langue, l'exécution de la programme et capturer la sortie pour écran ultime dans la cellule en sortie. Il y a beaucoup de détails à régler lors de la mise en œuvre d'une solution complète de ce genre (comme la saisie des messages d'erreur correctement), mais il faut comprendre le fait qu'il est non seulement possible de faire des choses comme ça, mais pratique.

sur une note personnelle, ce sont des fonctionnalités comme celle-ci qui font de l'interface de bloc-notes le centre de mon univers de programmation.

Mise à jour

la fonction d'aide suivante est utile pour créer de telles 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.

55
répondu WReach 2011-12-14 19:56:37
la source

Todd Gayley (Wolfram Research) il suffit de m'envoyer un bon hack qui permet d ' "envelopper" les fonctions intégrées avec du code arbitraire. Je pense que je dois partager cet instrument utile. Ce qui suit est la réponse de Todd sur mon question .

Un peu intéressant (?) histoire: ce style de piratage pour "emballer" un la fonction intégrée a été inventée vers 1994 par Robby Villegas et I, ironiquement pour le Message de fonction, dans un paquet appelé ErrorHelp que j'ai écrit pour le journal de Mathematica à 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' variable $ inMsg dans n'importe quel contexte privé que vous souhaitez.

Unprotect[Message];

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

Protect[Message];
32
répondu Alexey Popkov 2017-05-23 14:47:23
la source

ce n'est pas une ressource complète, donc je la jette ici dans la section des réponses, mais je l'ai trouvé très utile pour comprendre les questions de vitesse (qui, malheureusement, est une grande partie de ce que la programmation Mathematica est au sujet).

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'Usage est alors simplement [email protected] .

EDIT: M. Assistant a fourni une version simplifiée qui fait disparaître les 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 acl (extrait de 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]
24
répondu Timo 2017-05-23 14:54:48
la source

Internal`InheritedBlock

j'ai appris récemment l'existence d'une telle fonction utile comme Internal`InheritedBlock , de ce message de Daniel Lichtblau dans le groupe de discussion officiel.

comme je comprends, Internal`InheritedBlock permet de passer une copie d'une fonction de sortie à l'intérieur du Block domaine d'application:

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 intégré fonctions temporairement!

la Comparaison avec le Bloc

définissons une fonction:

a := Print[b]

nous souhaitons maintenant transmettre une copie de cette fonction dans le champ d'application Block . Le procès naïf 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}

essaie maintenant D'utiliser la définition retardée dans le premier argument de Block (c'est une caractéristique non documentée aussi):

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

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

During evaluation of In[3]:= b

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

essayons maintenant Internal`InheritedBlock :

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

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

nous avons une copie de la définition originale de a à l'intérieur du champ d'application de Block et nous pouvons la modifier comme nous le voulons sans affecter la définition globale de a !

20
répondu Alexey Popkov 2011-08-03 14:06:10
la source

Mathematica est un outil pointu, mais il peut vous couper avec son quelque peu comportement non typé et avalanches de cryptique messages de diagnostic . Une façon de traiter cela est de définir les fonctions en suivant cet idiome:

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

C'est beaucoup de boilerplate, que je suis souvent tenté de sauter. Surtout quand il s'agit de prototypage, ce qui arrive souvent dans Mathematica. Alors, j'utilise une macro appelé define qui me permet de rester discipliné, avec beaucoup moins passe-partout.

un usage de base de define est comme ceci:

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

fact[5]

120

il ne semble pas beaucoup à première vue, mais il ya quelques avantages cachés. Le premier service que define fournit est qu'il applique automatiquement ClearAll au symbole défini. Cela permet de s'assurer qu'il n'y a pas de définitions manquantes -- un phénomène courant au cours de la période initiale. développement d'une fonction.

Le deuxième, c'est que la fonction définie est automatiquement "fermé". Par ceci je veux dire que la fonction émettra un message et annulera s'il est invoqué avec une liste d'arguments qui n'est pas assortie d'une des définitions:

fact[-1]

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

il s'agit de la valeur primaire de define , qui saisit une classe d'erreur très courante.

une autre commodité est une façon concise de préciser attributs sur la fonction définie. Faisons la fonction Listable :

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

fact[{3, 5, 8}]

{6, 120, 40320}

en plus de tous les attributs normaux, define accepte un attribut supplémentaire appelé Open . Cela empêche define d'ajouter la définition d'erreur fourre-tout à la fonction:

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

successor /@ {1, "hi"}

{2, successor["hi"]}

Plusieurs attributs peuvent être définis pour une fonction:

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

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

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

sans plus attendre, voici la définition de 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::malformed, [email protected]]; Abort[])

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

l'implémentation exposée ne supporte ni up-values, ni currying, ni patterns plus généraux que la simple définition de fonction. Elle reste cependant utile.

18
répondu WReach 2017-05-23 14:54:48
la source

Démarrer sans un carnet vierge d'ouvrir

j'ai été ennuyé par avoir Mathematica commencer avec un carnet vide ouvert. Je pourrais fermer ce carnet avec un script, mais il resterait ouvert brièvement. Mon hack est de créer un fichier Invisible.nb contenant:

Notebook[{},Visible->False]

et ajoutez ceci à mon Kernel\init.m :

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

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

je commence maintenant Mathematica en ouvrant Invisible.nb

là peut-être une meilleure façon, mais cela m'a bien servi.


"sur mesure Fold et FoldList

Fold[f, x] est rendu équivalent à Fold[f, [email protected], [email protected]]

incidemment, je crois que cela pourrait trouver son chemin dans une version future de Mathematica.

Surprise! Cette mesure a été mise en œuvre, bien qu'elle le soit actuellement. documentés. J'ai été informé qu'il a été mis en œuvre en 2011 par Oliver Ruebenkoenig, apparemment peu de temps après que j'ai posté ceci. Merci 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]

mis à Jour pour permettre cela:

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

"Partition Dynamique "

Voir Mathematica.SE post # 7512 for a nouvelle version de cette fonction.

souvent je veux diviser une liste selon une séquence de longueurs.

exemple de pseudo-code:

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

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

j'ai trouvé ceci:

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

que j'ai ensuite complété avec ceci, y compris le test d'argument:

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]

le le troisième argument contrôle ce qui arrive aux éléments au-delà de la spécification split.


Szabolc's Mathematica tricks

celui que j'utilise le plus souvent est la palette de données tabulaires en pâte

[email protected]
 [email protected]{Button["TSV", 
    Module[{data, strip}, 
     data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     strip[s_String] := 
      StringReplace[s, RegularExpression["^\s*(.*?)\s*$"] -> ""];
     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*$"] -> ""];
     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"]]]]]}

Modifier les données externes de l'intérieur de Compile

récemment Daniel Lichtblau a montré cette méthode que je n'avais jamais vu avant. À mon avis, il étend considérablement l'utilité de 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.}  *)
16
répondu Mr.Wizard 2017-04-13 15:55:36
la source

Générale PDF/FEM à l'exportation problèmes et solutions

1) c'est complètement inattendu et non documenté, mais Mathematica exporte et sauve des graphiques dans les formats PDF et EPS en utilisant un ensemble de définitions de style qui diffère de celui utilisé pour l'affichage des blocs-notes sur l'écran. Par défaut, les Notebooks sont affichés à l'écran dans l'environnement de style "Working" (qui est la valeur par défaut pour l'option ScreenStyleEvironment global $FrontEnd ) mais sont imprimé dans le "Printout" style de l'environnement (qui est la valeur par défaut pour le PrintingStyleEnvironment global $FrontEnd en option). Quand on exporte des graphiques dans des formats raster tels que GIF et PNG ou dans le format EMF Mathematica génère des graphiques qui ressemble exactement comme il regarde Bloc-notes. Il semble que l'environnement de style "Working" soit utilisé pour le rendu dans ce cas. Mais ce n'est pas le cas lorsque vous exportez/enregistrez quelque chose dans les formats PDF ou EPS! Dans ce cas, le "Printout" style environnement est utilisé par défaut qui diffère très profondément de l'environnement de" travail " style. Tout d'abord, le "Printout" les ensembles d'environnement de style Magnification à 80% . Deuxièmement, il utilise ses propres valeurs pour les tailles de police de différents styles, ce qui entraîne des changements de taille de police incohérents dans le fichier PDF génaré par rapport à la représentation originale à l'écran. Ce dernier peut être appelé FontSize fluctuations qui sont très ennuyeux. Mais heureusement cela peut être évité en mettant le PrintingStyleEnvironment global $FrontEnd option de "travailler" :

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

2 ) le problème commun avec l'exportation au format EMF est que la plupart des programmes (non seulement Mathematica ) générer un fichier qui semble agréable à la taille par défaut, mais devient laid lorsque vous zoomez. C'est parce que metafiles sont échantillonné à la résolution de l'écran fidélité . La qualité du fichier EMF généré peut être améliorée par Magnify ing l'objet graphique original de sorte que l'exactitude de l'échantillonnage des graphiques originaux devient beaucoup plus précise. Comparez deux fichiers:

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

si vous insérez ces fichiers dans Microsoft Word et les zoomer, vous verrez que le premier" a "a scié dessus alors que le second n'a pas (testé avec Mathematica 6).

une Autre façon par le biais de ImageResolution a été suggéré par Chris Degnen (cette option n'a d'effet qu'au moins à partir de Mathematica 8):

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

3) dans Mathematica nous avons trois façons de convertir les graphiques en metafile: via Export à "EMF" (méthode fortement recommandée: produit metafile avec la plus haute qualité possible), via Save selection As... menu article ( produit un chiffre beaucoup moins précis , non recommandé) et via Edit ► Copy As ► Metafile article de menu ( je recommande fortement contre cette route ).

14
répondu Alexey Popkov 2017-05-23 15:02:50
la source

par demande populaire, le code pour générer le Top-10 so answererers parcelle (sauf annotations ) en utilisant le so API .

enter image description here

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", ""})]
13
répondu Sjoerd C. de Vries 2017-05-23 15:02:50
la source
"1519130920 la mise en Cache" expressions

je trouve ces fonctions très utiles pour cacher n'importe quelle expression. La chose intéressante ici pour ces deux fonctions est que l'expression retenue elle-même est utilisée comme clé du Cache de hashtable/symbole ou CacheIndex, par rapport à la memoization bien connue dans mathematica où vous ne pouvez résultat de cache que si la fonction est définie comme f[x_] := f[x] = ... De sorte que vous pouvez mettre en cache une partie d'un code, c'est utile si une fonction doit être appelée plusieurs fois mais seulement quelques parties du code ne doivent pas être recalculées.

pour mettre en cache une expression indépendamment de ses arguments.

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

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

la deuxième fois que l'expression retourne 6 sans attendre.

pour mettre en cache une expression utilisant une expression alias qui peut dépendre d'un argument de l'expression mise en cache.

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

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

si l'expr prend un certain temps à calculer, il est beaucoup plus rapide de évaluer {"f", 2} par exemple pour récupérer le résultat caché.

Pour une variation de ces fonctions afin d'avoir un localisée cache (ie. la mémoire cache est automatiquement libérée en dehors de la construction du bloc) voir ce post éviter les appels répétés à L'Interpolation

suppression des valeurs en cache

pour supprimer les valeurs mises en cache lorsque vous ne connaissez pas le nombre de définitions d'une fonction. Je considère que les définitions ont un blanc quelque part dans leurs arguments.

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

pour supprimer les valeurs mises en cache lorsque vous connaissez le nombre de définitions d'une fonction (va légèrement plus vite).

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

cela utilise le fait que les définitions d'une fonction sont à la fin de leur liste de valeurs inférieures, les valeurs mises en cache sont avant.

utilisation de symboles pour stocker des données et des fonctions apparentées à un objet

voici aussi fonctions intéressantes à utiliser des symboles comme des objets.

il est déjà bien connu que vous pouvez stocker des données dans des symboles et y accéder rapidement en utilisant des valeurs inférieures

mysymbol["property"]=2;

vous pouvez accéder à la liste des clés (ou propriétés) d'un symbole en utilisant ces fonctions basées sur ce que dreeves soumis dans un post sur ce site:

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

j'utilise souvent cette fonction pour afficher toutes les informations contenues dans les valeurs basses d'un symbole:

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

enfin voici une façon simple de créer un symbole qui se comporte comme un objet dans la programmation orientée objet (il reproduit juste le comportement le plus basique de OOP mais je trouve la syntaxe élégante):

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
  ];
Les propriétés

sont stockées en tant que valeurs et méthodes en tant que valeurs ascendantes retardées dans le symbole créé par le Module qui est retourné. J'ai trouvé la syntaxe pour function2 qui est la syntaxe oo habituelle pour les fonctions dans Tree la structure des données dans Mathematica .

pour une liste des types existants de valeurs de chaque symbole, voir http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html et http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_Misc_4.html .

essayez par exemple

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

Vous pouvez aller plus loin si vous souhaitez émuler objet héritage à l'aide d'un paquet appelé Héritrules disponible ici http://library.wolfram.com/infocenter/MathSource/671 /

vous pouvez aussi stocker la définition de la fonction non pas dans newObject mais dans un symbole de type, donc si NewObject renvoie le type [newObject] au lieu de newObject vous pouvez définir la fonction et function2 comme ceci en dehors de NewObject (et pas à l'intérieur) et avoir le même usage qu'avant.

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

Use UpValues[type] pour voir que la fonction et la function2 sont définies dans le symbole de type.

D'autres idées sur cette dernière syntaxe sont présentées ici https://mathematica.stackexchange.com/a/999/66 .

version améliorée de SelectEquivalents

@rcollyer: Merci beaucoup d'avoir ramené quelques équivalents à la surface, c'est une fonction incroyable. Voici une version améliorée de SelectEquivalents énumérés ci-dessus avec plus de possibilités et d'options, il est plus facile à utiliser.

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

Voici des exemples d'utilisation de cette version:

à l'Aide de Mathematica Rassembler/Collecter correctement

comment feriez-vous une fonction pivotable dans Mathematica?

Mathematica rapide 2D binning algorithme

Interne'Bag

Daniel Lichtblau décrit ici une structure de données internes intéressante pour les listes croissantes.

mise en œuvre D'un Quadtree en Mathematica

fonctions de débogage

ces deux messages pointent vers des fonctions utiles pour le débogage:

comment déboguer lors de l'écriture de petits ou grands codes en utilisant Mathematica? workbench? débogueur mma? ou quelque chose d'autre? (ShowIt)

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

Voici une autre fonction basée sur Reap et Sow pour extraire des expressions de différentes parties d'un programme et les stocker dans un symbole.

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

voici un exemple

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

autres ressources

Voici une liste de liens intéressants pour apprendre but:

, Une collection de Mathematica ressources d'apprentissage

mis à jour ici: https://mathematica.stackexchange.com/a/259/66

13
répondu faysou 2017-05-23 15:18:01
la source

mes fonctions Utilitaires (je les ai intégrées à MASH, ce qui est mentionné dans la 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).   *)
12
répondu dreeves 2010-11-18 12:36:29
la source

un truc que j'ai utilisé, qui vous permet d'émuler la façon dont la plupart des fonctions intégrées fonctionnent avec de mauvais arguments (en envoyant un message et en retournant ensuite le formulaire entier non évalué) exploite une bizarrerie de la façon Condition fonctionne lorsqu'il est utilisé dans une définition. Si foo ne devrait fonctionner qu'avec un seul argument:

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

si vous avez des besoins plus complexes, il est facile de prendre en compte la validation de l'argument et la génération du message comme un fonction indépendante. Vous pouvez faire des choses plus élaborées en utilisant des effets secondaires dans Condition au-delà de générer des messages, mais à mon avis la plupart d'entre eux tombent dans la catégorie "sleazy hack" et devrait être évitée si possible.

aussi, dans la catégorie" métaprogrammation", si vous avez un paquet Mathematica ( .m ), vous pouvez utiliser le "HeldExpressions" élément pour obtenir toutes les expressions dans le fichier enveloppé dans HoldComplete . Cela rend il est beaucoup plus facile de retracer les choses que d'utiliser des recherches textuelles. Malheureusement, il n'y a pas de moyen facile de faire la même chose avec un ordinateur portable, mais vous pouvez obtenir toutes les expressions d'entrée en utilisant quelque chose comme ce qui suit:

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

enfin, vous pouvez utiliser le fait que Module émule des fermetures lexicales pour créer l'équivalent des types de référence. Voici une simple pile (qui utilise comme bonus une variation du Condition ):

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

Maintenant, vous pouvez imprimer les éléments d'une liste dans l'ordre inverse dans un inutilement alambiqué!

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

 While[!EmptyQ[stack],
  Print[[email protected]];
  [email protected]]]
11
répondu Pillsy 2011-02-08 19:31:16
la source

symboles du système D'impression définitions sans contexte préprogrammé

la fonction contextFreeDefinition[] ci-dessous tentera d'Imprimer la définition d'un symbole sans le contexte le plus courant. La définition peut alors être copiée sur Workbench et formatée pour la lisibilité (la Sélectionner, clic droit, 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 []

mise en garde: Cette fonction ne localise pas les variables de la même façon que With et Module font, ce qui signifie que les constructions de localisation imbriquées ne fonctionneront pas comme prévu. withRules[{a -> 1, b -> 2}, With[{a=3}, b_ :> b]] va remplacer a et b dans les emboîtés With et Rule , tandis que With ne fait pas cela.

c'est une variante de With qui utilise des règles au lieu de = et := :

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

j'ai trouvé cela utile en nettoyant le code écrit pendant l'expérimentation et en localisant des variables. Parfois je me retrouve avec des listes de paramètres sous la forme de {par1 -> 1.1, par2 -> 2.2} . Avec withRules les valeurs de paramètre sont faciles à injecter dans le code précédemment écrit en utilisant des variables globales.

"1519250920 d'Utilisation" est comme With :

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

Anticrénelage graphiques 3D

C'est un technique très simple pour les graphiques 3D antialias même si votre matériel graphique ne le supporte pas nativement.

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

voici un exemple:

Mathematica graphics Mathematica graphics

notez qu'une grande valeur pour n ou une grande taille d'image a tendance à exposer les bugs du pilote graphique ou à introduire des artefacts.


" Notebook diff functionality

La fonctionnalité

est disponible dans le paquet <<AuthorTools` et (au moins dans la version 8) dans le contexte non documenté NotebookTools` . Ceci est un petit GUI pour distinguer deux carnets qui sont actuellement ouverts:

[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

11
répondu Szabolcs 2012-01-09 13:04:49
la source

fonctions pures récursives ( #0 ) semblent être l'un des coins les plus sombres de la langue. Voici quelques exemples non-triviaux de leur utilisation, où cela est vraiment utile (non pas qu'ils ne peuvent pas être faits sans elle). Ce qui suit est une fonction assez concise et raisonnablement rapide pour trouver des composants connectés dans un graphique, donné une liste des bords spécifiés comme paires de Sommets:

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

ce qui se passe ici est que nous cartographions d'abord un symbole chacun des nombres de vertex, et puis mettre en place une façon que, compte tenu d'une paire de Sommets {f[5],f[10]} , dire, puis f[5] évaluerait à f[10] . La fonction pure récursive est utilisée comme compresseur de chemin (pour configurer la mémoization de telle sorte qu'au lieu de longues chaînes comme f[1]=f[3],f[3]=f[4],f[4]=f[2], ... , les valeurs mémoizées soient corrigées chaque fois qu'une nouvelle "racine" du composant est découverte. Cela donne une vitesse importante. Parce que nous utilisons la mission, nous en avons besoin pour être HoldAll, ce qui rend cette construction même les plus obscures et les plus attractives ). Cette fonction est le résultat d'une discussion de groupe de mathématiques en ligne et hors ligne impliquant Fred Simons, Szabolcs Horvat,DrMajorBob et votre serviteur. Exemple:

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

il est certainement beaucoup plus lent qu'un intégré, mais pour la taille du code, assez rapide encore IMO.

autre exemple: voici une réalisation récursive de Select , basée sur des listes liées et des fonctions pures récursives:

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

par exemple,

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

il n'est cependant pas correctement récursif de queue, et va souffler la pile (planter le noyau) pour des listes plus grandes. Voici la version recursive:

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

par exemple,

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}} 
9
répondu Leonid Shifrin 2011-03-08 18:09:44
la source

c'est une recette du livre de Stan Wagon...utilisez-le lorsque la parcelle intégrée se comporte de façon erratique en raison d'un manque de précision

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

j'utilise souvent l'astuce suivante de Kristjan Kannike quand j'ai besoin de "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]

lorsque les résultats de l'évaluation sont confus, il est parfois utile de transférer les étapes de l'évaluation dans un fichier texte

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]]
8
répondu Yaroslav Bulatov 2010-12-28 08:46:30
la source

il est possible D'exécuter MathKernel en mode discontinu en utilisant options en ligne de commande -batchinput et -batchoutput :

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

(où input.m est le fichier d'entrée par lots se terminant par le caractère newline, outputfile.txt est le fichier vers lequel la sortie sera redirigée).

Dans Mathematica v.>=6, le MathKernel a sans papiers option de ligne de commande:

-noicon

qui contrôle si le MathKernel aura l'icône visible sur la barre des tâches (au moins sous Windows).

le FrontEnd (au moins de v. 5) a l'option de ligne de commande non documentée

-b

qui désactive l'écran de projection et permet d'exécuter le Mathematica FrontEnd beaucoup plus rapide

et option

-directlaunch

qui désactive le mécanisme qui lance le plus récent Mathematica version installée au lieu de lancer la version associée .fichiers nb dans le registre du système.

une autre façon de faire probablement est :

au lieu de lancer le Mathematica.exe binaire dans le répertoire d'installation, lancez le Mathematica.exe binaires SystemFiles\FrontEnd\Binaires\Windows. Le premier est un simple lanceur programme qui tente son plus dur pour demandes de redirection pour l'ouverture notes pour les exemplaires courants de la interface utilisateur. Le dernier est le interface utilisateur binaire lui-même.

il est pratique de combiner la dernière option de ligne de commande avec la définition de L'option frontale globale VersionedPreferences->True qui désactive le partage des préférences entre différents Mathematica versions installées :

SetOptions[$FrontEnd, VersionedPreferences -> True]

(ce qui précède doit être évalué dans la version la plus récente de Mathematica installée.)

dans Mathematica 8 ceci est contrôlé dans la boîte de dialogue Préférences, dans le volet système, sous le paramètre" Créer et maintenir des préférences frontales spécifiques à la version " .

il est possible de obtenez la liste incomplète des options en ligne de commande de L'interface en utilisant la clé non documentée -h (le code pour Windows):

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

donne:

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

autres options:

-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

Existe-t-il d'autres options en ligne de commande potentiellement utiles du MathKernel et du FrontEnd? Merci de partager si vous le savez.

question connexe .

8
répondu Alexey Popkov 2017-05-23 15:10:12
la source

mes hacks préférés sont de petites macros générant du code qui vous permettent de remplacer un tas de commandes standard boilerplate par une courte. Vous pouvez aussi créer des commandes pour ouvrir/créer des notebooks.

voici ce que j'utilise depuis un certain temps dans Mon flux quotidien Mathematica.

  1. Faire un ordinateur portable ont un contexte privé, de charger le package(s) j'ai besoin, rendre la la sauvegarde automatique.
  2. après avoir travaillé avec ce carnet pendant un certain temps, je voudrais faire quelques calculs à jeter dans un carnet séparé, avec son propre contexte privé, tout en ayant accès aux définitions que j'ai utilisé dans le" principal " carnet. Parce que j'ai mis en place le contexte privé, cela nécessite d'ajuster manuellement $ContextPath

faire tout cela à la main est une douleur, alors automatisons! Tout d'abord, un certain code d'utilité:

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

maintenant, créons une macro qui va mettre les cellules suivantes dans le carnet:

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

et voici le 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];
      ]
 ]

maintenant quand je tape MyPrivatize[] est crée le contexte privé et charge mon paquet standard. Maintenant, créons une commande qui ouvrira un nouveau bloc-notes scratch avec son propre contexte privé (de sorte que vous pouvez y pirater avec wild abandon sans le risque de foirer le définitions), mais a accès à vos contextes actuels.

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

la chose cool à ce sujet est qu'en raison de SelfDestruct , lorsque la commande s'exécute, il ne laisse aucune trace dans le carnet de notes actuel-ce qui est bon, parce que sinon il ne ferait que créer du désordre.

pour les points de style supplémentaires, vous pouvez créer des déclencheurs de mots clés pour ces macros en utilisant InputAutoReplacements , mais je vais laisser ceci comme un exercice pour le lecteur.

7
répondu Leo Alekseyev 2011-05-07 02:46:25
la source

PutAppend avec PageWidth -> l'Infini

dans Mathematica l'utilisation de la commande PutAppend est le moyen le plus simple de maintenir un fichier journal courant avec les résultats de calculs intermédiaires. Mais il utilise par défaut le paramètre PageWith->78 lors de l'exportation d'expressions vers un fichier et il n'y a donc aucune garantie que chaque sortie intermédiaire ne prendra qu'une ligne dans le journal.

PutAppend avoir n'importe quelles options elle-même mais en traçant ses évaluations révèle qu'elle est basée sur la fonction OpenAppend qui a l'option PageWith et permet de changer sa valeur par défaut par la commande SetOptions :

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

de sorte que nous pouvons obtenir PutAppend d'ajouter une seule ligne à la fois en définissant:

SetOptions[OpenAppend, PageWidth -> Infinity]

mise à jour

il y a un bug introduit dans la version 10 (corrigé dans la version 11.3): SetOptions n'affecte plus le comportement de OpenWrite et OpenAppend .

une solution est de mettre en œuvre votre propre version de PutAppend avec explicite PageWidth -> Infinity option:

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

notez que nous pouvons également le mettre en œuvre via WriteString comme indiqué dans cette réponse , mais dans ce cas, il sera nécessaire de convertir expression dans le InputForm correspondant via ToString[expr, InputForm] .

7
répondu Alexey Popkov 2018-06-24 09:30:41
la source

j'étais juste en train de regarder à travers un de mes paquets pour l'inclure dans ceci, et j'ai trouvé quelques messages que j'ai définis qui font des merveilles: Debug::<some name> . Par défaut, ils sont désactivés, donc ne produisent pas beaucoup de frais généraux. Mais, je peux polluer mon code avec eux, et les allumer si j'ai besoin de comprendre exactement comment un peu de code se comporte.

6
répondu rcollyer 2010-11-18 07:32:09
la source

une des choses qui me dérange au sujet des constructions intégrées de détermination de la portée est qu'elles évaluent toutes les définitions des variables locales à la fois, de sorte que vous ne pouvez pas écrire par exemple

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

donc il y a un moment j'ai inventé une macro appelée WithNest qui vous permet de faire ceci. Je le trouve pratique, car il vous permet de garder les fixations variables locales sans avoir à faire quelque chose comme

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

à la fin, la meilleure façon que j'ai pu trouver à faire c'était en utilisant un symbole spécial pour le rendre plus facile de revenir sur la liste des reliures, et j'ai mis la définition dans son propre paquet pour garder ce symbole caché. Peut-être que quelqu'un a une solution plus simple à ce problème?

si vous voulez l'essayer, mettez ce qui suit dans un fichier appelé 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[];
6
répondu DGrady 2011-04-17 10:42:17
la source

ce code crée une palette qui télécharge la sélection pour Stack Exchange comme une image. Sur Windows, un bouton supplémentaire est fourni qui donne un rendu plus fidèle de la sélection.

Copiez le code dans une cellule de bloc-notes et évaluez. Puis sortir la palette de la sortie, et l'installer en utilisant Palettes -> Install Palette...

Si vous avez des problèmes avec elle, postez un commentaire ici. Télécharger la version portable ici .


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}, [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[];
5
répondu Szabolcs 2016-02-13 05:08:34
la source

je suis sûr que beaucoup de gens ont rencontré la situation où ils courent quelques trucs, réalisant que non seulement coincé le programme, mais ils ont aussi n'ont pas sauvé pour les 10 dernières minutes!

EDIT

après avoir souffert de cela pendant un certain temps, j'ai un jour découvert que on peut créer auto-save de l'intérieur du Mathematica code. Je pense que l'utilisation d'un tel auto-save ont m'a beaucoup aidé dans le passé, et j'ai toujours pensé que la possibilité elle-même était quelque chose que pas beaucoup de gens sont conscients qu'ils peuvent faire.

le code original que j'ai utilisé est en bas. Grâce aux commentaires, j'ai découvert que c'est problématique, et qu'il est beaucoup mieux de le faire d'une manière alternative, en utilisant ScheduledTask (qui ne fonctionnera que dans Mathematica 8).

Le Code

peut être trouvée dans cette réponse de Sjoerd C. de Vries (Comme je ne suis pas sûr que ce soit correct de le Copier ici, je le laisse comme un lien seulement.)


la solution ci-dessous utilise Dynamic . Il sauvera le carnet toutes les 60 secondes, mais apparemment seulement si sa cellule est visible . Je ne le laisse ici que pour des raisons d'achèvement. (et pour les utilisateurs de Mathematica 6 et 7)

/ EDIT

pour le résoudre j'utilise ce code au début d'un carnet:

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

cela économisera votre travail toutes les 60 secondes.

Je la préfère à NotebookAutoSave[] parce qu'il sauve avant que l'entrée est traitée, et parce que certains fichiers sont plus de texte que d'entrée.

Je l'ai trouvé ici à l'origine: http://en.wikipedia.org/wiki/Talk:Mathematica#Criticisms

notez qu'une fois cette ligne exécutée, l'enregistrement aura lieu même si vous fermez et rouvrez votre fichier (tant que la mise à jour dynamique est activée).

aussi, puisqu'il n'y a pas d'annulation dans Mathematica , faites attention de ne pas supprimer tout votre contenu, car l'économie le rendra irréversible (par précaution je supprime ce code de chaque bloc-notes fini)

4
répondu tsvikas 2017-05-23 14:47:23
la source

celui-ci a été écrit par Alberto Di Lullo, (qui ne semble pas être sur le débordement de la pile).

CopyToClipboard , pour Mathematica 7 (en Mathematica 8 il est construit en)

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

j'ai trouvé cette routine utile pour copier de grands nombres réels au bloc-notes sous forme décimale ordinaire. Par exemple: CopyToClipboard["123456789.12345"]

Cell[[email protected]] supprime soigneusement les guillemets.

4
répondu Chris Degnen 2012-01-02 17:09:22
la source

rappelez-vous que le Livre de Mathematica est également disponible en ligne à http://reference.wolfram.com/legacy/v5_2 / - bien qu'il soit remplacé par la documentation actuelle à http://reference.wolfram.com

3
répondu Bill White 2010-11-18 04:43:47
la source

je trouve qu'il est vraiment utile lors du développement de paquets pour ajouter ce raccourci clavier à mon fichier SystemFiles/FrontEnd/TextResources/Windows/KeyEventTranslations.tr .

(* Evaluate Initialization Cells: Real useful for reloading library changes. *)

Item[KeyEvent["i", Modifiers -> {Control, Command}],
    FrontEndExecute[
        FrontEndToken[
            SelectedNotebook[],
            "EvaluateInitialization"]]],

ensuite pour chaque Packagename.m je fais un PackagenameTest.nb bloc-notes pour le test et les 2 premières cellules du bloc-notes sont définies comme des cellules d'initialisation. Dans la première cellule j'ai mis

Needs["PackageManipulations`"]

pour charger la bibliothèque très utile PackageManipulations qui a été écrit par Leonid. Le la deuxième cellule contient

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

qui font tous le rechargement du paquet. Notez que les deux premières lignes ne sont là que pour Remove tous les symboles que j'aime garder les contextes aussi propres que possible.

alors le flux de travail pour écrire et tester un paquet devient quelque chose comme ça.

  1. Enregistrer les modifications Packagename.m .
  2. passer à PackagenameTest.nb et faire CTRL + ALT + i .

cela provoque les cellules d'initialisation à recharger le paquet, ce qui rend l'essai très simple.

3
répondu nixeagle 2017-05-23 15:18:01
la source

fonction suivante format[expr_] peut être utilisé pour indenter/formater des expressions non formattées mathematica qui s'étendent au-dessus d'une 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

1
répondu Prashant Bhate 2017-04-13 15:38:59
la source

Autres questions sur resources wolfram-mathematica