Was sind einige nützliche, undokumentierte Mathematica-Funktionen?

17 answers
    • LongestCommonSequencePositions und LongestCommonSubsequencePositions Ihre Verwendung ist analog zu LongestCommon(Sub)sequence, aber sie geben stattdessen die Position des ersten Matches zurück.

      Update: Diese sind seit 10.2 dokumentiert.

    • ClipboardNotebook[] < / strong> kann verwendet werden, um auf die Zwischenablage zuzugreifen. NotebookGet@ClipboardNotebook[] gibt einen Ausdruck Notebook mit dem aktuellen Inhalt der Zwischenablage. Ich verwende dies zum Vorverarbeiten von Daten, bevor sie eingefügt werden (z. B. in der Tabelleneinfügungspalette ). Ich bin nicht sicher, ob dies überhaupt zum Kopieren verwendet werden kann - ich verwende dafür direkt die Copy-Funktion des Front-End (über FrontEndTokenExecute)

      Update: Seit Version 8 haben wir einige dokumentierte Zwischenablagefunktionen .

    • PolynomialForm[] ermöglicht das Ändern der Reihenfolge, in der Polynomausdrücke gedruckt werden, indem die Option TraditionalOrder -> True

      <| gesetzt wird >
       In[1]:= PolynomialForm[1+x+x^2, TraditionalOrder->True]
      Out[1]= x^2+x+1
       
    • Postanforderung: In Version 8 hat Import experimentelle Unterstützung für die HTTP-Anforderungsmethode POST . Verwendungsbeispiel für das Hochladen eines Bildes nach imgur :

       Import["http://api.imgur.com/2/upload", "XML", 
             "RequestMethod" -> "POST", 
             "RequestParameters" -> {"key" -> apikey, "image" -> image}]
       

      (Natürlich müssen Sie Ihren API-Schlüssel und ein ordnungsgemäß codiertes Bild einfügen, wie in der Antwort gezeigt, auf die ich oben verlinkt habe.)

      < / li>
    • Internal`Deflatten[] rekonstruiert einen höher dimensionierten Tensor aus einer flachen Liste. Beispiel:

       In[1]:= arr = {{1, 2}, {3, 4}}
      Out[1]= {{1, 2}, {3, 4}}
      
      In[2]:= flatArr = Flatten[arr]
      Out[2]= {1, 2, 3, 4}
      
      In[3]:= Internal`Deflatten[flatArr, Dimensions[arr]]
      Out[3]= {{1, 2}, {3, 4}}
       

      Warnung: Wenn die übergebenen Dimensionen nicht übereinstimmen Die Länge des flachen Arrays führt zum Absturz des Kernels!

      Update: Version 9.0 führte das dokumentierte Äquivalent ein ArrayReshape .


    • Bildobergrenze
    23 May 2017
    marc_s
  • Eine undokumentierte Funktion, die ich für nützlich halte, ist Precedence

    Zum Beispiel:

     {#, Precedence@#} & /@ {Plus, Minus, Times, Power, Apply, Map, Factor,
        Prefix, Postfix, Infix} // TableForm
     

    geben:

     Plus    310.
    Minus   480.
    Times   400.
    Power   590.
    Apply   620.
    Map     620.
    Factor  670.
    Prefix  640.
    Postfix 70.
    Infix   630.
     

    Der Vorrang wird in einer Vorlesung Ein neuer Mathematica-Programmierstil von Kris Carlson ist verfügbar hier

    Bearbeiten

    Einer von vor etwa einem Jahr, der damals als "in Entwicklung" betrachtet wurde, ist TableView. Ich frage mich, was mit ihm passiert ist.

    Zum Beispiel:

     Array[Subscript[a, ##] &, {4, 3}] // TableView
     

    Schenken:

    Was sind einige nützliche, undokumentierte Mathematica-Funktionen?

    In der aktuellen Version 10.3 kann TableView nicht normal arbeiten.

    Was sind einige nützliche, undokumentierte Mathematica-Funktionen?

    10 January 2016
    3 revs, 2 users 94%TomD
  • Im Folgenden wird das Verhalten von Mathematica nach mehr als 24 Stunden simuliert.

     MathLink`CallFrontEnd[FrontEnd`UndocumentedCrashFrontEndPacket[]]
     

    Funktioniert wie angekündigt! : D

    20 January 2014
    rm -rf
  • Beim Nachdenken über eine letzte Antwort habe ich mich gefragt, welche Funktionen in Mathematica genau funktionieren Verwenden Sie Assumptions . Sie finden die Liste der System` -Funktionen, die Option verwenden, indem Sie

     Reap[Do[Quiet[If[Options[Symbol[i], Assumptions]=!={}, Sow[i], Options::optnf]], 
      {i, DeleteCases[Names["System`*"], _?(StringMatchQ[#, "$"~~__] &)]}]][[2, 1]]
     

    ausführen eleganter schreiben Sie mit Listenverständnis und geben Sie (in Version 8)

     {"ContinuedFractionK", "Convolve", "DifferenceDelta", "DifferenceRootReduce", "DifferentialRootReduce", "DirichletTransform", "DiscreteConvolve", "DiscreteRatio", "DiscreteShift", "Expectation", "ExpectedValue", "ExponentialGeneratingFunction", "FinancialBond", "FourierCoefficient", "FourierCosCoefficient", "FourierCosSeries", "FourierCosTransform", "FourierSequenceTransform", "FourierSeries", "FourierSinCoefficient", "FourierSinSeries", "FourierSinTransform", "FourierTransform", "FourierTrigSeries", "FullSimplify", "FunctionExpand", "GeneratingFunction", "Integrate", "InverseFourierCosTransform", "InverseFourierSequenceTransform", "InverseFourierSinTransform", "InverseFourierTransform", "InverseZTransform", "LaplaceTransform", "Limit", "PiecewiseExpand", "PossibleZeroQ", "PowerExpand", "Probability", "ProbabilityDistribution", "Product", "Refine", "Residue", "Series", "SeriesCoefficient", "Simplify", "Sum", "SumConvergence", "TimeValue", "ToRadicals", "TransformedDistribution", "ZTransform"}
     

    Sie können in ähnlicher Weise nach Funktionen suchen, die Annahmen annehmen, die nicht im System` -Kontext liegen, und die wichtigsten, die Sie finden, in Names["Developer`*Simplify*"]. Dies sind (Hinzufügen von "Entwickler" "zum Kontextpfad)

     {"BesselSimplify", "FibonacciSimplify", "GammaSimplify", 
     "HolonomicSimplify", "PolyGammaSimplify", "PolyLogSimplify", 
     "PseudoFunctionsSimplify", "ZetaSimplify"}
     

    Dies sind alles spezielle Vereinfachungsroutinen nicht von Simplify aufgerufen, sondern von FullSimplify. FullSimplify kann jedoch bei großen Ausdrücken manchmal zu lange dauern, und ich kann mir vorstellen, dass das Aufrufen dieser speziellen Routinen nützlich wäre. Hier ist ein einfaches Anwendungsbeispiel:

     In[49]:= FunctionsWolfram["10.08.17.0012.01"] /. Equal -> Subtract // Simplify
             % // Developer`PolyLogSimplify
    
    Out[49]= -Pi^2/6 + Log[1 - z] Log[z] + PolyLog[2, 1 - z] + PolyLog[2, z]
    
    Out[50]= 0
     

    (Der FunctionsWolfram -Code wird beschrieben dabei )


    Ein anderer interessanter Zusammenhang, der mir in Zusammenhang mit der Annahme aufgefallen ist, war Assumptions`. Durch erneutes Anhängen von "Assumptions`" an $ContextPath, Names["Assumptions`*"] werden die Funktionen

     {"AAlgebraicQ", "AAssumedIneqQ", "AAssumedQ", "ABooleanQ", 
    "AComplexQ", "AEvaluate", "AEvenQ", "AImpossibleIneqQ", "AInfSup", 
    "AIntegerQ", "AllAssumptions", "AMathIneqs", "AMod", "ANegative", 
    "ANonNegative", "ANonPositive", "AOddQ", "APositive", "APrimeQ", 
    "ARationalQ", "ARealIfDefinedQ", "ARealQ", "ASign", "AssumedFalse", 
    "AUnequalQ", "AWeakSign", "ImpliesQ"}
     
    <| zurückgegeben >

    Diese enthalten angenommene Versionen einiger Standardsystemfunktionen, z. B.

     In[22]:= Assuming[Element[x, Integers], {IntegerQ[x], AIntegerQ[x]}]
             Assuming[x > 0, {Positive[x], APositive[x]}]
    
    Out[22]= {False, True}
    
    Out[23]= {Positive[x], True}
     
    23 May 2017
    jmbucknall
  • Update

    Seit Version 11.2 ist diese Funktion nun in einen tieferen Kontext eingebettet: NumericalMath`NSequenceLimit[].


    Ich mag SequenceLimit[] selbst ziemlich; Diese Funktion schätzt numerisch die Grenze einer Sequenz durch Anwenden der Shanks-Transformation (wie in Wynns $ \ varepsilon $ -Algorithmus ). Die Methode ist eine besonders schöne Verallgemeinerung der wahrscheinlich bekannteren Aitken $ \ delta ^ 2 $ Transformation zur Beschleunigung der Konvergenz einer Sequenz. Eine andere Betrachtungsweise besteht darin, dass, wenn man die Shanks-Transformation auf eine Sequenz anwendet, deren Terme Teilsummen einer Potenzreihe entsprechen, die Transformation die Ergebnisse ergibt, die der Diagonalen Padé-Approximanten , gebildet aus den Teilsummen.

    Genug Präambel, und lassen Sie uns ein Beispiel sehen. Betrachten Sie die Reihenfolge der Iterationen bis zum Fixpunkt Cosine :

    seq = NestList[Cos, N[1, 30], 20];
     

    und lassen Sie uns die Nummer zu Vergleichszwecken generieren:

    dottie = x /. FindRoot[x == Cos[x], {x, 3/4}, WorkingPrecision -> 40]
    0.7390851332151606416553120876738734040134
     

    Vergleichen Sie:

    Last[seq]
    0.739184399771493638624201453905348
    
    % - dottie
    0.000099266556332996968889366231475
     

    mit

    SequenceLimit[seq]
    0.7390851332151606416553149654
    
    % - dottie
    2.87775364950904`5.313591998048321*^-24
     

    Hier ist zu sehen, dass die Anwendung der Shanks-Transformation auf die Folge von Iteraten zu einem Ergebnis führte, das mehr gute Ziffern als die Iterate selbst hatte. Dies ist die Stärke der Funktion SequenceLimit[].

    Wie bei jedem leistungsstarken Werkzeug ist jedoch bei der Verwendung etwas Sorgfalt geboten. Betrachten Sie zum Beispiel dieses Beispiel:

    seq = N[Accumulate[((-1)^Range[0, 30]) Range[0,30]!], 30];
     

    Wir haben hier eine recht heftig abweichende Folge von Teilsummen $ \ sum generiert \ limits_k (-1) ^ kk! $. Man wäre zu Recht vorsichtig, wenn man versucht, Ergebnisse aus einer Sequenz wie dieser abzuleiten, aber SequenceLimit[] schafft etwas

    25 September 2017
    cringeArundevi

  • Sequenziell With

    Von Kommentar von Daniel Lichtblau Es gibt eine neue undokumentierte Syntax für With wurde irgendwann nach Version 10.1 eingeführt, die Folgendes ermöglicht:

     With[{a = 0}, {a = a + 1}, {a = a + 1}, a]
     
     2
     

    Verzögert With, Block und Module

    Diese Scoping-Konstrukte unterstützen die Verwendung von := in Definitionen, wodurch unausgewertete Ausdrücke verarbeitet werden können.

     With[{x := 2 + 2}, Trace[x]]
    Block[{x := 2 + 2}, Trace[x]]
    Module[{x := 2 + 2}, Trace[x]]
     
     {2 + 2, 4}
    
    {x, 2 + 2, 4}
    
    {x$6064, 2 + 2, 4}
     

    Beispiele:

    • Ich finde das in With am nützlichsten, da es Definitionen in gehaltene Ausdrücke einfügt.
      I commo Verwenden Sie dies nur für die direkte Änderung von DownValues :

        a[1] = Pi;
       a[2] = E;
      
       With[{dv := DownValues[a]},  dv = dv /. {1 -> 3};]
      
        a[3]   (*  out=  π  *)
       
    • Kuba findet es sehr nützlich, um lesbare Controller-Definitionen zu schreiben.

      ZB

       asso = <|"nested" -> <|"key" -> <|
          "spec" -> <|"a" -> 1, "b" ->  0|>
      |>|>|>;
      
      With[{
        a := asso["nested", "key", "spec", "a"],
        b := asso["nested", "key", "spec", "b"]
        },
       DynamicModule[{},
         Column@{
          Slider@Dynamic[a],
          Slider[Dynamic[b, {Automatic, (a = b^2) &}]],
          Dynamic@asso
          }
       ]
      
      ]
       

    Die früheste Stack-Exchange-Nutzung dieses, den ich kann find ist ein Beitrag von Szabolcs .

    Ich habe eine ähnliche Syntax in implementiert meine Funktion listWith , die selbst eine Erweiterung von With ist.

    23 May 2017
    8 revs, 2 users 53%Mr.Wizard
  • Internal`PartitionRagged

    Dieser hat eine Verwendungserklärung!

    Was sind einige nützliche, undokumentierte Mathematica-Funktionen?

     Internal`PartitionRagged[Range[14], {3, 5, 2, 4}]
     
     {{1, 2, 3}, {4, 5, 6, 7, 8}, {9, 10}, {11, 12, 13, 14}}
     

    Beachten Sie, dass Length[list] gleich n1 + ... + nk sein muss.

     (* changed the last 4 to 3 *)
    Internal`PartitionRagged[Range[14], {3, 5, 2, 3}]
     
     Internal`PartitionRagged[Range[14], {3, 5, 2, 3}]
     

    Internal`S1, Internal`S2, Internal`P2

    Ist es möglich, eine Dokumentation dieser häufig verwendeten Funktionen mit Hilfe der Benutzer dieser Community?

    Diese Typen werden nicht häufig verwendet (und werden wahrscheinlich überhaupt nicht verwendet), aber sie sehen wirklich geheimnisvoll aus.

    Nach dem Lesen von dieser -Publikation wurde mir klar, dass es sich bei ihnen um Submethoden handelt PrimePi. p>

     With[{x = 10^9},
      {
        PrimePi[x],
        Internal`S1[x] + Internal`S2[x] + Internal`P2[x] + PrimePi[x^(1/3)] - 1
      }
    ]
     
     {50847534, 50847534}
     

    Internal`Square

     ??Internal`Square
    (* Attributes[Internal`Square] = {Listable, NumericFunction, Protected} *)
     

    Testen Sie es mit einer Liste:

     list = RandomReal[{0, 100}, 10^8];
    
    r1 = list*list; // RepeatedTiming
    (* 0.118 seconds *)
    r2 = list^2; // RepeatedTiming
    (* 0.191 seconds *)
    r3 = Internal`Square[list]; // RepeatedTiming
    (* 0.121 seconds *)
     

    Der Vorteil dieser Funktion scheint zu sein, wenn höhere Potenzen für eine Liste berechnet werden:

     lis = RandomReal[{0, 1}, 10^7];
    
    lis*lis*lis*lis; // RepeatedTiming
    (* 0.55 seconds *)
    lis^4; // RepeatedTiming
    (* 0.21 seconds *)
    Internal`Square @ Internal`Square @ lis; // RepeatedTiming
    (* 0.15 seconds *)
     
    11 May 2015
    5 revs, 2 users 81%Chip Hurst
  • Internal`InheritedBlock

    Internal`Localizedblock

    • < a href = "https://mathematica.stackexchange.com/questions/71881/what-is-the-purpose-of-internallocalizedblock"> Was ist der Zweck von Internal`LocalizedBlock?

    Internal`Bag

    • Bag erstellt einen Ausdrucksbeutel, optional mit voreingestellten Elementen.
    • [li> BagPart erhält Teile eines Ausdrucksbeutels, ähnlich Part für gewöhnliche Ausdrücke. Es kann auch bei den lhs verwendet werden, z. Einen Wert zurücksetzen. StuffBag hängt Elemente an das Ende eines Sacks an.
    • Wir haben auch ein BagLength, das zum Durchlaufen eines Sacks nützlich ist.

    Internal`RationalNoReduce

    31 July 2017
    Peter D
  • System`

    Der Standardwert für den Überhangparameter k (3. Argument) in ListCorrelate ist None.

    Interne Prädikate

    Internal`LinearQ[expr, var] liefert True, wenn expr ein Polynon der Ordnung eins in var ist, und andernfalls False .

    Internal`RealValuedNumberQ[expr] ergibt True, wenn expr eine reelle Zahl ist, und False ansonsten.

    [p> Internal`RealValuedNumericQ[expr] ergibt True, wenn expr eine reelle numerische Größe ist, und False ansonsten.

    Internal`DependsOnQ[expr, form] liefert True, wenn ein Teilausdruck in expr der Form entspricht ( Köpfe ausgenommen) und mathematisch hängt von der Form ab und ergibt andernfalls False. Nimmt ein drittes Argument entgegen (True / False, aber das Verhalten scheint unabhängig von der Wahl zu sein), scheint aber auch Köpfe zu umfassen ( ref )

    Internal`ExceptionFreeQ[expr] ergibt True, wenn expr zu etwas bewertet wird, das Infinity, DirectedInfinity oder Indeterminate und Renditen False ansonsten.

    Internal`FundamentalDiscriminantQ[expr] ergibt True, wenn expr ein grundlegende Diskriminante Integer mit Ausnahme von 1 und False ansonsten.

    Internal`GregorianLeapYearQ[expr] liefert True, wenn der Ausdruck ein ist Ganzzahl, die einem Schaltjahr des Gregorianischen Canlendar entspricht, andernfalls False.

    Internal`LiterallyOccurringQ[expr, form] ergibt True, wenn ein Teilausdruck in expr explizit stimmt mit der Form überein, ignoriert Attributes von Heads, die normalerweise den Pattern Matcher beeinflussen könnten, und liefert andernfalls False.

    Internal`LiterallyAbsentQ[expr, form] liefert True, wenn kein Unterausdruck in vorliegt Ausdruck Übereinstimmungsformular und ergibt False ansonsten.

    Internal`TestIntegerQ[number, form] ergibt {number, True}, wenn number Integer ist, und {number, False} andernfalls.

    Internal`WouldBeNumericQ[expr, {var_1, var_2, ...}] ergibt True, wenn expr eine numerische Größe werden würde, wenn var_i alle numerischen Größen wäre, andernfalls False.

    Internal`PatternFreeQ[expr] ergibt True, wenn expr keine {Alternatives, Blank, BlankNullSequence enthält,BlankSequence, Except, Longest, Optional, OptionsPattern, OrderlessPatternSequence, PatternSequence, Repeated, RepeatedNull, Shortest] und False andernfalls >

    Internal`PatternPresentQ[expr] ergibt True, wenn expr Folgendes enthält: {Alternatives, Blank, BlankNullSequence, BlankSequence, Except, Longest, Optional , OptionsPattern, OrderlessPatternSequence, PatternSequence, Repeated, RepeatedNull, Shortest} und False ansonsten.

    Internal`PolynomialFunctionQ[expr, var] Erträge True wenn expr ein Polynom in var ist und andernfalls False ergibt. Internal PolynomialFunctionQ[expr, {var1, var2,...}] yields True if expr is a polynomial in all var_i, and yields False` andernfalls. ( weitere Informationen )

    Internal`RadicalMemberQ[rad, {poly1, poly2, ...}] prüft, ob rad zu dem Radikal des Polynomialideals gehört, das durch poly1, poly2, ... ( ref )

    Internal`SyntacticNegativeQ[expr] gibt True an, wenn expr ein Minuszeichen vage hat ... muss geklärt werden ( Anwendung )


    < h1> Andere interne

    Internal`BinomialPrimePowerDecomposition[n,m] gibt ein Objekt Internal`FactoredNumber an, das die Liste der Primfaktoren des Binomialkoeffizienten (n, m) zusammen mit ihren Exponenten enthält.

    Internal`ConditionalValueBody[inputHead,{test1, test2, ...},{{msgName1,arg1A,arg1B,...},{msgName2,arg2A,arg2B,...},...},body] wertet jedes test_i nacheinander aus, und wenn Renditen False vorhanden sind, wird sofort die entsprechende inputHead::msgName_i -Nachricht mit den Argumenten arg_iA, ... und kehrt zurück Fail; Andernfalls wird body ausgewertet.

    Internal`CompareNumeric[prec, a, b] gibt -1, 0 oder 1 zurück, je nachdem, ob a kleiner, gleich oder größer als b im Vergleich zur Genauigkeit von a oder b (je nachdem, welcher Wert niedriger ist) minus prec Dezimalstellen der "Toleranz". Dies ist die grundlegende Operation, die Less, Equal, Greater, LessEqual usw. für numerische Typen mit endlicher Genauigkeit zugrunde liegt. ( ref ) ( Weitere Informationen )

    Internal`DiracGammaMatrix[n, "Metric" -> {list of +/-1}, "Basis" -> ("Dirac"/"Chiral")] gibt das nte Dirac-Gammamatrix .

    Internal`ListMin[matrix] gibt Zeilen mit allen größeren Elementen zurück oder gleich Elementen eines anderen entfernt werden. ( ref )

    Internal`Metric ist eine Option für Internal`DiracGammaMatrix.

    Internal`JoinOrFail[list1, list2] gibt die durch Anhängen von list2 an das Ende von list1 gebildete Liste zurück.

    Internal`PerfectPower[integer] gibt die Liste der ganzen Zahlen {n, p} an Ganzzahl ist n ^ p.

    Internal`RiccatiSolve[{a, b}, {q, r}] löst die fortlaufende algebraische Riccati-Gleichung (dies ist eine dokumentierte System -Funktion)

    Internal`DiscreteRiccatiSolve[{a, b}, {q, r}] löst das diskrete t Algebraische Riccati-Gleichung. (Dies ist eine dokumentierte System -Funktion)

    Internal`MakePolynomial[expr] gibt die Form von expr in Bezug auf neue Variablen zurück, sodass expr in den neuen Variablen Polynom ist. ( ref )

    Internal`ToEquivalenceClass[expr, toll] ersetzt die Gleitkommazahlen in expr durch ihre Äquivalenzklassenrepräsentanten gemäß der angegebenen Toleranz toll ( ref ).


    System` Utilities`

    System`Utilities`ExprLookupAdd[expr] speichert expr im Speicher und gibt einen ganzzahligen Schlüssel (nicht in Maschinengröße) zum Abrufen zurück.

    System`Utilities`ExprLookup[integer] gibt den entsprechenden expr zurück, wenn int ein gültiger Integer-Schlüssel ist, und gibt $Failed o zurück

    25 July 2018
    14 revsQuantumDot
  • Eigenschaften für SparseArray und InterpolatingFunction Objekte

    SparseArray Objekte können eine Reihe von Eigenschaften (oder Methoden) akzeptieren, die das effiziente Extrahieren bestimmter Informationen ermöglichen, am häufigsten "AdjacencyLists" oder "NonzeroPositions" als häufig schnellere Alternative zu Position . Ich begann mit dieser Antwort, um sie detailliert darzustellen, aber als sie wuchs, kam ich zu der Überzeugung, dass sie ein eigenes Q & amp; A benötigt, und habe deshalb eine gepostet:

    Ebenso InterpolatingFunction unterstützt auch eine Reihe von Methoden, die ich hier ausführlich beschrieben habe:

    Undokumentierte Parameter

    Für Normal: Gibt es eine Möglichkeit, die Sonderformen zu steuern, die Normal konvertiert?

    Für Return und Break: Gibt es ein Break [] - Äquivalent für Kurzschlüsse in der Tabelle?

    Für Fold und FoldList war die Zwei-Parameter-Syntax vorhanden, in den Versionen 9.0 bis 10.0.1 jedoch nicht dokumentiert: Kürzere Syntax für Fold und FoldList?

    13 April 2017
    5 revsMr.Wizard