What are some useful, undocumented Mathematica functions?

Question

There have already been some questions about some undocumented functionality in Mathematica. Such as (please add to these lists!)

• How can one find undocumented options or option values in Mathematica?
• What do these undocumented Style options in Mathematica do?
• Undocumented command-line options

Also, other questions and answers that contained undocumented functions

• Internal`InheritedBlock (also in Exposing Symbols to $ContextPath)
• Internal`Bag (in Implementing a Quadtree in Mathematica) (also here)
• RuleCondition (in Replace inside Held expression)

Along with the "Undocumented (or scarcely documented) Features" segment of the What is in your Mathematica tool bag? question.

Szabolcs also maintains a list of Mathematica tricks which contains a list of "undocumented stuff".

---

So, what undocumented functions do you know and how do you use them? (Added useful information is maybe how you discovered the functions and any version dependence.)

Answer 1

• LongestCommonSequencePositions and LongestCommonSubsequencePositions Their use is analogous to LongestCommon(Sub)sequence but they return the position of the first match instead.

• ClipboardNotebook[] can be used to access the clipboard. NotebookGet@ClipboardNotebook[] will give a Notebook expression with the current contents of the clipboard. I use this for pre-processing data before it is pasted (e.g. in the table paste palette). I am not sure if this can be used for copying at all---I use the Front End's Copy function directly for that (through FrontEndTokenExecute)

• PolynomialForm[] allows changing the order in which polynomial terms are printed by setting the option TraditionalOrder -> True

  In[1]:= PolynomialForm[1+x+x^2, TraditionalOrder->True]
  Out[1]= x^2+x+1
  

• POST request: In version 8 Import has experimental support for the POST HTTP request method. Example usage for uploading an image to imgur:

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

  (Of course you'll need to insert your API key and a properly encoded image, as shown in the answer I linked to above.)

• Internal`Deflatten[] will reconstruct higher dimensional tensor from a flat list. Example:

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

  Warning: If the dimensions passed to it don't match the length of the flat array, this will crash the kernel!

---

• Image capture start/stop IMAQ`StartCamera[] and IMAQ`StopCamera[] start and stop the webcam.

---

• Undocumented interesting contexts to dig through: Internal`, Experimental`, Language`, NotebookTools` (similar to what the AuthorTools package offers), IMAQ` (IMage AQcuisition)

  There are lots of functions in these contexts, generally undocumented, but sometimes with self-explanatory names (e.g. Internal`RealValuedNumericQ seems obvious). Note that these functions might change in later versions. Some of the ones listed by ?Internal`* are even from old versions and no longer work in M- 8.

  Some functions from Language` are described here.

---

• SystemOptions[] The functions to set and read these options are not undocumented, but the options themselves unfortunately are.

  • Experimental`SystemOptionsEditor[] In version 8 this gives a GUI for viewing/setting system options.

  • "TableCompileLength" (and other similar options from the "CompileOptions") section set the length of a Table above which it attempts to compile its argument.

    Example: SystemOptions["CompileOptions" -> "TableCompileLength"] will show that the default value is 250.

  • "SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1}

    Setting this option to 1 will cause repeated entries to be summed up when creating a sparse array. See an example use and explanation here.

    In[1]:= Normal@SparseArray[{2 -> 1, 4 -> 1}]
    Out[1]= {0, 1, 0, 1}
    
    In[2]:= Normal@SparseArray[{2 -> 1, 4 -> 1, 2 -> 1}]
    Out[2]= {0, 1, 0, 1}
    
    In[3]:= SetSystemOptions["SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1}]
    
    In[4]:= Normal@SparseArray[{2 -> 1, 4 -> 1, 2 -> 1}]
    Out[4]= {0, 2, 0, 1}
    

---

This MathGroup thread has some interesting information too.

Answer 2

Thinking about a recent answer made me wonder exactly which functions in Mathematica use Assumptions. You can find the list of System` functions that use that Option by running

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

which (can be more elegantly written using list comprehension and) returns (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"}

You can similarly look for functions that take assumptions that are not in the System` context and the main ones you find are in Names["Developer`*Simplify*"] which are (adding "Developer`" to the context path)

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

These are all specialized simplification routines that are not called by Simplify but are called by FullSimplify. However, sometimes FullSimplify can take too long on large expressions and I can imagine calling these specialized routines would be useful. Here's a simple usage example

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

(The FunctionsWolfram code is described here)

---

Another interesting assumption related context I noticed was Assumptions`. Once again, appending "Assumptions`" to the $ContextPath, Names["Assumptions`*"] returns the functions

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

These contain assumption aware versions of some standard system functions, e.g.

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}

Answer 3

One undocumented function I find useful is Precedence

For example:

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

giving:

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

Precedence is described in a lecture A New Mathematica Programming Style by Kris Carlson available here

Edit

One from about a year ago, which was then considered 'under development', is TableView. I wonder what has happened to it?

For example:

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

giving:

Answer 4

No so much a function as an option...

Problem: You embedd a CDF on a web page but the content is rendered as grey boxes.

Cause: This is a security issue, the same as when you open a notebook with dynamic content from an untrusted path on your computer.

Solution: On your desktop you are asked if you want to enable dynamic content. You press the button and everything in your notebook works. By using the "option" {fullscreen:'true'} an embedded CDF will open in "full screen mode" meaning that the enabled content warning will appear and therefore provide your viewers with the button to enable dynamic content.

Usage:

<script src="http://www.wolfram.com/cdf-player/plugin/v2.1/cdfplugin.js" type="text/javascript">
</script>
<script type="text/javascript">
var cdf = new cdf_plugin();
cdf.embed("http://path.to/myCDF.cdf", 500, 600,{fullscreen:'true'});
</script>

Answer 5

I quite like SequenceLimit[] myself; it is a function that numerically estimates the limit of a sequence by applying the Shanks transformation (as embodied in Wynn's $\varepsilon$ algorithm). The method is a particularly nice generalization of the probably more well-known Aitken $\delta^2$ transformation for accelerating the convergence of a sequence. Another way of looking at it is that if one applies the Shanks transformation to a sequence whose terms correspond to partial sums of a power series, the transformation gives the results corresponding to the diagonal Padé approximants formed from the partial sums.

Enough preamble, and let's see an example. Consider the sequence of iterates to the cosine's fixed point:

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

and let's generate the number for comparison purposes:

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

Compare:

Last[seq]
0.739184399771493638624201453905348

% - dottie
0.000099266556332996968889366231475

with

SequenceLimit[seq]
0.7390851332151606416553149654

% - dottie
2.87775364950904`5.313591998048321*^-24

It can be seen here that applying the Shanks transformation to the sequence of iterates gave a result which had more good digits than any of the iterates themselves. This is the power of the function SequenceLimit[].

As with any powerful tool, however, some care is needed in its use. Consider for instance this example:

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

We have generated here a rather violently divergent sequence of partial sums $\sum\limits_k (-1)^k k!$. One would rightly be wary of trying to derive results from a sequence like this, but SequenceLimit[] manages to do something, even if it does spit out a warning:

SequenceLimit[seq]
    SequenceLimit::seqlim: The general form of the sequence could not be determined, and the result may be incorrect. >>
0.596347362

% - (-E ExpIntegralEi[-1])
0.*10^-10

and in fact the result can be justified through analytic continuation. However, that the algorithm can give unexpected results for divergent sequences is something to be mindful and careful of.