Mathematica: Glossary of Technologies

The Wolfram Technology Guide is a glossary of important and often unique Mathematica technologies, relating them to practical advantages for users. This summary page gives definitions and explanations for each technology. Clicking any title will give you the full entry for that technology, with graphical examples.

Check back. More definitions and examples are being added.

64-Bit Computing
Traditionally, operating systems have been 32-bit: able only to provide unique addresses for less than 2³² bytes, or about 4.3GB of memory. Instead, new operating system releases from all major vendors now enable 64-bit addressing--making the memory limit 2⁶⁴ bytes, or about 18,000,000,000GB, although current hardware will only support a lower limit such as 2⁴².

Mathematica 5.2 pioneered all-platform support for 64-bit technical computing--implementing 64-bit memory addressing and 64-bit long-number partitioning. This first reflects Wolfram Research's leading porting capabilities as well as a commitment to delivering rapid support for the latest computing technology.

These enhancements make Mathematica the ideal platform for solving large problems:

	Its 64-bit support means that there's effectively no memory barrier.
	Long numbers are now broken into 64-bit rather than 32-bit lengths for processing, enabling better performance.
	Sparse and packed array technology introduced in Mathematica 4, 5.0, and 5.1 made computations highly memory efficient.
	Computational speed-ups beginning with Mathematica 5 have improved some calculation times as much as 1000-fold.
	Optional grid versions of Mathematica are available to distribute computations in parallel over multiple processors or computers.

Adaptive Plot Refinement (APR)
Adaptive plot refinement (APR) fine-tunes graphics plotted in Mathematica. The result is improved smoothness, better intelligibility, and a reduction of artifacts compared with standard graphics programs.

When plotting a function, Mathematica automatically analyzes that function to make sure the image is smooth and easy to understand while preserving as much information as possible. Techniques used include adaptive resampling and automatic selection of optimal plot ranges, as well as system-wide support of regions and discontinuous functions.

Automatic Algorithm Selection (AAS)
Automatic algorithm selection (AAS) is the underlying technology that enables Mathematica to select and apply the best algorithm(s) for a given task.

System-wide implementation of AAS is unique to Mathematica and a key distinguishing feature: other technical computing systems make the user specify a single algorithm (not just the task) by hand, often from a confusing array of possibilities. Get the selection wrong and your computation could fail or, worse still, produce an inaccurate answer.

That's why AAS capabilities are crucial for enabling users to get reliable results quickly--even without a specialist's algorithmic knowledge. And for the specialist, Mathematica's ability to perform AAS mid-calculation can optimize a computation beyond what could be manually selected.

Mathematica pioneered AAS in its first release in 1988. Since then, the range of available and implemented algorithms, the sophistication of selection, and the number of functions for which AAS operates have all greatly increased.

Autovectorizing
Autovectorizing is the capability of an operation to apply automatically to an entire vector, matrix or array--rather than just a single element.

Autovectorizing operations are common in Mathematica--both for built-in capabilities and as an attribute for user specified functions.

Operating on all the data at once reduces the number of top-level calls to Mathematica, replacing them with optimized internal routines. This optimization includes the use of CPU-specific vector capabilities where available.

A further benefit of autovectorizing is cleaner, easier-to-read problem specification.

Common Subexpression Detection and Collection
Before evaluating a large expression, Mathematica often tries to identify common subexpressions, which it collects and caches in linear time to avoid repeated work and improve accuracy. This technique can significantly cut both the computation time and the memory footprint for large, complex computations. Note that numerical-precision control is implemented to work with common subexpression collection and caching.

Document-Centered Interface (DCI)
Mathematica notebooks are today's most sophisticated manifestation of the document-centered approach to user interfaces and are a departure from the normal dialog-box-based approach. With a document-centered interface (DCI) approach, control elements, their associated specifications, and structural information all reside together inside the document itself alongside the user data--text, typeset math, graphics, interface elements, programs, and so forth.

As well as providing an optimized, highly interactive environment for performing and presenting technical work, the notebook structure has proved ideal as a superset container for technical information, a hub for an individual's or group's technical knowledge.

Most application software separates users from developers. With the DCI approach this is no longer necessary: users working on a problem are automatically creating a notebook document that is itself an application to utilize in solving similar problems in the future.

Dynamic Type Detection (DTD)
Dynamic type detection (DTD) is the technology by which Mathematica's functions automatically analyze the input given to them and act accordingly.

For example, Mathematica's multiplication operator is overloaded to handle both symbolic and numeric input with intelligent coercion for mixed types. It detects and multiplies symbolic variables, real and complex numbers, integers, vectors, matrices, tensors, and many other objects without requiring users to do explicit typing, or to remember different function names that apply to different types.

Dynamic Type Switching (DTS)
Computations in purely numerical systems often fail because their number representation is insufficient for the task--for example when IEEE floating-point overflow or underflow occurs, or when complex numbers appear in a floating-point computation.

With dynamic type switching (DTS), Mathematica detects these problems and switches number systems without user interaction. Mathematica can therefore often return accurate results in situations where non-Mathematica, numerical-only systems fail.

An example of DTS is found when using the numerical differential equation solver NDSolve. An initially real solution might become complex during the calculation, automatically triggering Mathematica's just-in-time (JIT) compiler to recompile optimized byte code.

Event Detection and Event Localization
Event detection enables differential equations to be solved differently in different regions, with boundaries between regions determined dynamically by features of the solutions obtained. This feature's flexibility is a unique capability of Mathematica.

Typical applications include:

	Modeling hybrid systems with physical constraints where an event triggers swapping between different regimes
	Solving only until some logical or functional condition is satisfied
	Collecting samples of solutions at particular events, or for Poincaré sections

Expression-Based Document Generation (EBDG)
Every Mathematica notebook is itself a Mathematica expression--in other words, a program. This means that Mathematica can generate and manipulate all aspects of a notebook programmatically.

Expression-based document generation (EBDG) is a unique Mathematica architecture that--combined with capabilities such as publication-quality typesetting, spell checking, and import and export options--makes Mathematica ideally suited for automatic report generation, on-the-fly creation of customized quotes for customers, and even fully dynamic websites (using webMathematica).

Extended-Precision Computation (EPC)
Mathematica's extended-precision computation (EPC) supports almost any length of integer and precision of real or complex numbers--unlike non-Mathematica, numerical-only systems, which work to machine precision or around 16 digits.

As well as being required for high-precision answers, EPC is often a crucial factor in achieving accurate low-precision answers because intermediate computation stages can drain precision--sometimes dramatically. Complementing EPC, precision tracking is also built into Mathematica.

gigaNumerics
gigaNumerics is the unique set of evolving Mathematica technologies that deliver high-speed numerical computations. Because of Mathematica's generality and accuracy checking, numerical calculations would normally have suffered speed penalties because a number of extra operations have to occur each time a calculation is executed.

In fact, Mathematica now regularly outperforms specialist numerical systems. This is achieved by using the most modern algorithms--often developed by Wolfram Research--and an unique set of technologies, including automatic algorithm selection, precompilation, packed arrays, processor optimization, symbolic preprocessing, and vectorization. For even higher performance, gridMathematica delivers an optimized parallel Mathematica environment for modern supercomputers.

Interior Point Method
The interior point method is an advanced optimization technique pioneered as a built-in feature in general technical computing by Wolfram Research.

In general, the inclusion of state-of-the art advanced solvers, coupled with Mathematica's packed-array technology and automatic algorithm selection, lets users tackle much larger problems than with other packages--efficiently and with more accurate results.

Interpolating Objects
Mathematica is unique in returning the results of numerical superfunctions (e.g. NDSolve) as symbolic functions representing the interpolation through ordinates taken--the interpolating object. This is in contrast to purely numerical systems, which return an unprocessed list of numbers.

Interpolating objects make results easily and immediately usable: for example, plotting, differentiating, or finding a specific value (whether or not it was picked for evaluation during the computation) can all be performed with a result as if it were any built-in mathematical function.

MathML
The MathML standard for describing mathematical expressions, adopted by the World Wide Web Consortium (W3C), is based on key ideas from Wolfram Research's typesetting technology. This close relationship between the web's markup standard and Mathematica's internal representation put Mathematica in a unique position. As a result, a full-featured authoring and evaluation environment for documents with MathML expressions is fully integrated into the flexible, extensible technical document authoring system built into Mathematica, Mathematica CalcCenter, and Publicon.

Why did the W3C drafting committee turn to Mathematica's box structure as the starting point? Wolfram Research had done many years of research into the representation, interpretation, and display of mathematical expressions as part of the development process of Mathematica. That effort gave us a thorough understanding of the difficult issues involved in fully integrating presentation and evaluation within a single environment.

Multicore Support
Multicore chips have more than one CPU core; multiple-processor computers have more than one CPU chip. Both are being introduced by manufacturers to speed up tasks by splitting threads or processes among different processors so that they can be performed in parallel.

Mathematica supports threading of numerical linear algebra across multiple-CPU or multicore computers.

In addition, Mathematica's notebook front end is a separate process from its computational kernel, allowing them to run on separate cores or CPUs. This gives a responsive interface even when the kernel core is under full load.

gridMathematica, Mathematica Personal Grid Edition, and the Mathematica application Parallel Computing Toolkit are options that let users tie together multiple computers, each containing one or several CPUs and/or cores.

Notebook Document
In 1988 Wolfram Research invented the notebook document. Unlike other documents, notebooks are live--combining interactive typeset inputs and outputs, 2D and 3D graphics, calculations, Mathematica programs, text, and other elements.

Mathematica notebooks are automatically reformatted for screen or printout--optimizing fonts and layout for each medium. Mathematica provides hundreds of options that allow users to give notebooks any desired look and generate full publication-quality documents.

Notebooks are the ideal hub for all of an individual's or group's technical work, able to encompass the structure of almost any file or data format, and with import and export capability for over 70.

Numerical-Precision Control--Specified Input Mode
Numerical-precision control (NPC) is fundamental to Mathematica's handling of numerical computations, ensuring unrivaled trustworthiness of numerical results.

In specified input mode, you give Mathematica input to a certain precision, and Mathematica adjusts subsequent computations to preserve as much precision as possible. At the end, digits are only displayed that can be justified given the input precision and the sequence of computations performed. For certain computations the output precision exceeds the input precision.

Without precision control, even simple numerical computations can return vastly inaccurate results. NPC technology uses advanced heuristics and precision tracking--switching to higher-precision computations, adjusting the step size in iterative computations, or changing algorithms on the fly when it expects a different approach to give a more accurate answer.

Numerical-Precision Control--Specified Output Mode
Numerical-precision control (NPC) is fundamental to Mathematica's handling of numerical computations, ensuring unrivaled trustworthiness of numerical results.

In specified output mode, you specify the output precision and Mathematica automatically adjusts the working precision through the computation sequence to reach this precision, assuming the input precision was sufficient for this to be possible. Note that working precision needed during a calculation is often much greater than that justifiable at the end. In many cases, Mathematica automatically takes this into account, stepping up precision mid-calculation where necessary.

This technology is unique to Wolfram Research, with key algorithms developed in-house.

Numerical-Precision Tracking (NPT)
Any numerical package or programming language can give numerical results up to machine precision, but only Mathematica will also automatically track and communicate how many digits of the result are accurate--using numerical-precision tracking (NPT) technology. This gives almost complete protection from numerical errors, be they round-off errors or from badly conditioned systems.

Packed Arrays
Packed arrays are the unique Mathematica technology used to seamlessly integrate compacted arrays and optimized computations that include them. Computations to be performed on machine-precision matrices and arrays are analyzed to decide whether packing them into a specialized format will improve the performance of the computation. This process of analysis and application occurs transparently, with outputs presented the same way regardless of which methodology Mathematica chooses.

Mathematica automatically compiles complicated functions that will be repeatedly applied to such packed arrays. This lets Mathematica perform large-scale linear algebra computations as fast as or faster than specialized numerical systems.

Piecewise Functions
Mathematica 5.1 introduced the unique capability of system-wide support for piecewise functions--functions with different definitions for different regions. More than 100 enhancements to solving, calculus, and other capabilities were added for fully automatic handling of piecewise functions.

Piecewise functionality is of wide-ranging importance across a number of different fields, including many areas of engineering (particularly hybrid systems) and education.

Processor Optimization
Processor optimization involves utilizing compilers and libraries specialized for specific processors to improve performance. Wolfram Research's industry-leading release engineering, and its extensive work with hardware vendors, usually equip Mathematica users first with support and optimization for the latest processors. Mathematica is the leading system for frontier research, so leading deployment on the latest hardware is a key goal for Wolfram Research.

Selective Method Override
Setting a selective method override in a Mathematica function means manually narrowing down how Mathematica should carry out the computation to a particular method or class of algorithms, though not its order or sub-algorithm. This is a halfway point between letting Mathematica automatically select the best option using AAS or manually specifying everything.

For example, ExplicitRungeKutta is a selective method override specifiable in the numerical differential equation solver NDSolve. Choosing it enables all the different orders of Runge-Kutta methods to be utilized under AAS control but prevents the use of other methods, such as Adams or BDF.

Semantic-Faithful Typesetting (SFT)
Semantic-faithful typesetting (SFT) combines the elegance of traditional mathematical typography with the precision of a computer language. SFT is unique to Mathematica and its capabilities are immediately apparent: expressions input in a fully typeset form can be evaluated, evaluations are automatically typeset--and can then subsequently be edited, re-evaluated, exported, and so forth.

Delivering SFT is nontrivial (it required seven years of Wolfram Research development) because some mathematical notation is ambiguous, there are many cases where one mathematical meaning has multiple representations, and because of the complexity of working with expressions from a standard keyboard. Other difficult issues include line-breaking, subexpression selection and evaluation, and heuristic conversion from traditional non-semantic typesetting systems such as TeX.

Interactive, evaluatable, publication-quality typesetting is available in all Wolfram Research products, including Mathematica, Mathematica CalcCenter, Publicon, Mathematical Explorer, A New Kind of Science Explorer, and more.

Serializable Objects
A serializable object is one that can be converted into a string of characters and recreated by reading that string back. Almost all objects in Mathematica are serializable--expressions, programs, graphics, typeset mathematics, user interface elements, even complete notebooks. That's because all these Mathematica objects are represented in a uniform way by symbolic expressions; and, being represented in a textual form, symbolic expressions are serializable.

Most aspects of Mathematica have been serializable since its introduction in 1988, but the concept has recently become widely acknowledged with serializable Java and C# objects. Because objects are serializable, MathLink can transmit them to other Mathematica processes--the basis of gridMathematica.

Significance Arithmetic
Significance arithmetic, a basis for Mathematica's high-precision arithmetic, is a powerful technique that offers many advantages over fixed precision (such as the floating-point or integer arithmetic used by purely numerical technical software).

It not only keeps track of numerical results, but also uses error propagation to track their accuracy. In this way, numerical computations can carry accuracy and precision information with them, returning in the end a numerical quantity together with its estimated uncertainty.

This means that with Mathematica, unlike other software, you always get both a numerical result and the knowledge of to how many digits it is correct.

Sparse Arrays
Sparse arrays are those in which most of the elements (sparse matrices, or vectors, or tensors) are zero or--more generally--a common value.

Mathematica's SparseArray technology offers a uniquely efficient way to store and manipulate large sparse objects. In fact, Mathematica can perform very-large-scale linear algebra operations at higher speeds--and with smaller memory footprints--than specialized numerical systems can.

Subsystem Autoseparation
In some cases it is advantageous to split a system of differential equations into subsystems so that each can be solved with the most appropriate method, symbolic or numeric. When you manually specify a splitting method and composition, Mathematica automatically splits the equations and recombines them for you.

Mathematica is unique among mainstream technical computing systems in supporting such separation.

Symbolically Enhanced Numeric Computing
Symbolically enhanced numeric computing is the ability of Mathematica to apply symbolic transformations automatically to an ostensibly numerical computation to optimize computation time and accuracy--or to make it directly computable at all.

Often a numerical algorithm requires a particular form of expression with which to operate. In non-Mathematica systems, that specific form must be input to enable computation; with symbolically enhanced numeric computing, Mathematica automatically transforms the provided expression to reach this required form. The benefit of this approach is crucial for ease of use: it enables a wide range of problems to be input without a user's (sometimes complex) pencil-and-paper transformation beforehand.

Additionally, this intelligent expression transformation cuts unnecessary computations by getting expressions into the easiest-to-evaluate form, sometimes even avoiding a failure of the computation where the untransformed expression would have exhibited numerical instability.

Mathematica is unique in being equipped to take this approach because of its mixed symbolic-numeric architecture and the range of its symbolic transformation capabilities.

SymbolicXML
SymbolicXML is Mathematica's lossless representation of XML documents.

Mathematica is naturally suited to representing and working with XML, given its tree structure and uniform expression model. But it is SymbolicXML that makes the process of working with XML documents seamless--enabling automated import and export, and providing a representation that is straightforward to work with within Mathematica.

As well as being the most comprehensive solution for analyzing data contained in XML documents, Mathematica is commonly used for working with XML documents themselves because of its highly developed rule-based transformation language.

Task-Oriented Superfunctions (TOSF)
Mathematica's task-oriented superfunctions (TOSF) each subsume the functionality of a large number of algorithm-based functions in non-Mathematica systems.

Unlike all other computation systems, Mathematica's functions are "task-oriented"--named by which task they perform, not which algorithm(s) they use to perform them.

This distinction particularly affects high-level, multistage, multialgorithm tasks, handled by "superfunctions" in Mathematica. Take numerical differential equation solving as an example. In Mathematica, NDSolve is all you need to use. Applying this TOSF analyzes your equation and decides (unless you set an override) which of its dozens of algorithms and controller methods to deploy to get you an accurate answer quickly--sometimes switching mid-calculation for further optimization.

By contrast, non-Mathematica computation systems make you analyze your equation manually to determine which function to apply--e.g., where in Mathematica you use NDSolve, in Matlab you must choose among ode45, ode23, ode113, ode15s, bvp4c, pdepe, and so on. Get the selection wrong and your computation could run inefficiently, fail altogether, or, worse still, produce an inaccurate answer. And there's no switching mid-calculation.

Another crucial benefit of the TOSF approach is future-proofing: algorithmic innovations enable TOSF to perform better without the form of the input or output being affected. Compatibility is therefore maintained while having the latest computational technology under the skin.

Transparent Auto-Compilation (TAC)
When carrying out large repetitive numerical computations, either requested by the user directly--for example creating a table--or implicitly--solving a differential equation numerically--Mathematica automatically generates optimized byte code to speed up the computations, a process known as just-in-time compilation.

The instructions created are chosen to be close to those found in the machine code of a typical computer, and can thus be executed quickly. For large expressions, compilation can speed up execution by a factor of 20 or more. Many Mathematica functions, for example NIntegrate, use compilation by default, while others, for example the Table command, invoke compilation dynamically, based on the type and complexity of the expression evaluated and the number of evaluations requested.

Uniform Expression Model
Mathematica handles many different kinds of concepts: mathematical formulas, lists, and graphics, to name just a few. Although they often look very different, Mathematica represents all of these in one uniform way--as expressions.

This uniform expression model is a crucial unifying principle in Mathematica. The fact that every object in Mathematica has the same underlying structure makes it possible for Mathematica to cover so many areas with a comparatively small number of basic operations, and for each function (whether built-in or user defined) to be so powerful.

For example, there's no need for a special graphics manipulation language in Mathematica: the uniform expression model means that like every other kind of expression, graphics can be manipulated by "standard" expression manipulation functions. In a non-Mathematica system, graphics would have a different representation type from numerical quantities, so without special adaptation would need their own set of operations for manipulation.

Universal Database Connectivity (UDC)
Universal database connectivity (UDC) is the capability for interactive I/O with almost all databases, including Oracle, Access, MySQL, and Microsoft SQLServer.

Mathematica's combination of computational and language abilities makes it uniquely suitable for operating at a high level with data. Moreover, UDC has been built in ever since Mathematica 5.1--a first among technical computation systems.

Web Services
Web services technology provides programmatic interfaces that are used for application-to-application communication over the web--allowing users to integrate their applications with data and functionality provided from varying platforms and languages.

Mathematica was the first technical software to be fully integrated with web services, enabling users to call web services from Mathematica in a completely transparent way. This makes the whole universe of existing and future web services an automatic extension to the Mathematica environment.