What's New in R&D

Roger Germundsson
Director of R&D, Wolfram Research
Chicago, June 1998

Introduction

Welcome everyone, I'm really happy to see that so many people have travelled to Chicago for this tenth anniversary conference. My name is Roger Germundsson and I am Director of Research and Development at Wolfram Research and as such is deeply involved in the development of new versions of Mathematica as well as application packages and custom products.

We are certainly very excited about all the new and improved features of the upcoming version of Mathematica and several other products. I would like to spend roughly 45 minutes showing you mainly some of the new features and directions of Mathematica, but also some of what we have been up to applications and custom products.

Initialization

Make some demo packages easily available.

SetDirectory[ "D:\\User\\Talks\\UserConference98" ];

Make the Experimental` and Developer` functions available.

<< Experimental`

<< Developer`

Numeric Computation

In numerics the basic theme is to make Mathematica faster and scalable to very large computations as well as round out the feature set. We do in fact have a multi-year program called gigaNumerics that will produce deliverables along these lines for each subsequent Mathematica release and this upcoming version is the first such example.

Packed Array Technology

Packed Array technology, available in this the new version, uses a special efficient representation of tensors (or arrays) of machine numbers and provide quite impressive memory and speed improvements. In essence this recognizes tensors (arrays) of machine numbers as a new (internal) fundamental type, i.e. much like individual machine numbers are made use of whenever possible and thus speeding up operations. This is an example of where we have take a general system like Mathematica and optimize its operation on a special class of expression, something that is much easier then taking a specialized system and try to generalize it. Best of all is that Packed Array technology is completely transparent to the user ... except for the speed improvement.

In fact this is very much in line with what microprocessor manufacturers such as Intel is about to do with MMX2, i.e. recognizing arrays of numbers as a new fundamental data type, although in their case it much less transparent.

Memory and Speed

Let us connect two different kernels a new kernel (red border) and a 3.0 kernel (blue border).

$Version

This a 100,000 element list of integers in the new version as well as in 3.0.

Table[ Random[Integer],  {10^5}] // ByteCount // Timing

As can be seen there is some small performance improvement, but a rather large memory savings, i.e. using a fifth of the memory. We can do the same for real and complex numbers ...

Table[ Random[Real],  {10^5} ] // ByteCount // Timing

Complex tensors ...

Table[ Random[Complex],  {10^5}] // ByteCount // Timing

For other types of operations the speed improvements can be vastly larger then this ....

System Integration

One of the really good features of Packed Arrays is that you typically will not have to know about them at all, i.e. this is all happening under the hood and automatically. In particular most things that you do in Mathematica when dealing tensors of numbers will see performance improvements automatically. These are some more examples:

m  =  Table[Random[], {500},  {500}];

Sin[m]; // Timing

(((m + 1))^100); // Timing

Min[m]; // Timing

However in some case the result of a computation cannot be represented as a tensor of numbers and in those cases Mathematica automatically converts the PackedArray expression to a general expression and the operation just works they way it used to.

In this case Range produces a Packed Array ...

lst  =  Range[10];  PackedArrayQ[ lst ]

... but adding a symbol to it of course means that it no longer is a tensor or numbers.

lst  +  x

PackedArrayQ[ % ]

Some other cases where this happens is when the numbers in the tensor become too big to be able to be represented as machine numbers, i.e. where a C program would normally crash or generate an exception.

Packed Array technology is leading to performance improvements across the system, e.g. graphics, importing and exporting of files and many other areas.

Completing the Features

One frequently needs to get parts of matrix (or general) tensor in order to do some further manipulation. We generalized the basic primitives for this somewhat in the new Mathematica.

Suppose you have a general 3 by 5 matrix.

(m  =  Table[ (Subscript[a, i, j]),  {i, 3},  {j, 5}]) // MatrixForm

Interactively you can already easily pick out submatrices from such a matrix, e.g. row, column or general submatrix. Take now takes several sequence specifications allowing it to deal with this nicely programmatically.

({{(Subscript[a, 1, 3])}, {(Subscript[a, 2, 3])}, {(Subscript[a, 3, 3])}})

Take[m,  All,  {3}]

The new keyword All can also be used in Part. The main difference between Take and Part is that Part lowers the rank, i.e.if you use part to pick out a column you end up with a vector and not a matrix.

Part[m,  All,  3 ]

This picks out a submatrix ...

({{(Subscript[a, 2, 3]), (Subscript[a, 2, 4]), (Subscript[a, 2, 5])}, {(Subscript[a, 3, 3]), (Subscript[a, 3, 4]), (Subscript[a, 3, 5])}})

Take[ m,  {2, 3},  {3, 5} ]

Of course all of this also works smoothly with Packed Arrays ...

m  =  Table[ Random[],  {100},  {100} ];

msub  =  Take[ m,  All,  -20];  Dimensions[ msub ]

PackedArrayQ[ msub ]

... but for larger matrices it is usually more informative to plot them instead of typesetting them or course ...

ListDensityPlot[ msub ];

Just as for graphics there are several data formats in which matrices can be stored. This is the binary MAT format ...

mat  =  Import["Tables/penny.mat"];

ListDensityPlot[ Reverse[Transpose[mat]],  Mesh -> False];

Or if we color it slightly differnently ...

ListDensityPlot[ Reverse[Transpose[mat]],  Mesh -> False,  
        ColorFunction -> 
          (RGBColor[Min[1, 1.25 #], 0.7812 #,  0.4975 #] &)];

Convolution and DFT

Packed Array allows us to do a whole suite of new things in Mathematica without suffering a performance penalty. One example of this includes a new vastly improved discrete Fourier transform as well as its closely related operations convolution and correlation. One reason that we wanted to put these in is also that there are new application technology drivers such as signal processing, control and statistics.

Discrete Fourier Transform

Define some data ...

data  = 
        Table[ Sin[  30.  ((2  Pi n)/200)]  +  
            Random[Real,  {-1/2, 1/2}],  {n,  200} ];

This very much looks like pure noise ...

ListPlot[ data,  PlotJoined  -> True ];

The Fourier transform easily picks out the periodic (sinusoidal) in the noisy data.

ListPlot[ Abs[ Fourier[ data ]],  PlotJoined -> True,  
        PlotRange -> All ];

Works for any dimension and also covers all the different conventions for Fourier transform. For instance the following computes the discrete Fourier transform of a 500 by 500 matrix.

m =  Table[Random[],  {500},  {500} ];

Fourier[ m ]; // Timing

One thing worth noting about this implementation is that there are no restrictions such as having to have a size that is a power of two (as in some earlier algorithms in this field), or a tensor of a particular rank.

Convolution (Correlation)

An operation closely related to the discrete Fourier transform is the convolution of data. One interpretation of this is that is essentially a filter that you apply to your data, e.g. a running average or in the case of matrices as an image operator.

The following uses another new feature that allows you to read a large number of file formats ... in case an image.

ei  =  Import["Images/einstein.jpg" ] // Show;

In order to pick out the data matrix representing the image we need to know how it is represented ...

Short[ InputForm[ ei ],  3 ]

So the the data sits in position 1,1 ...

emat  =  ei[[1, 1]];  Dimensions[emat]

Once we have the data we can apply an image operator ... in this case a pretty randomly chosen one.

Show[
        Graphics[
          Raster[ ListConvolve[
{{1,  1, 1},  
                {1,  -7,  1},  {1,  1, 1}},  emat ]],  
          AspectRatio -> Automatic]];

Mariusz Jankowski is giving a talk at this conference describing an image processing package that contains more full fledged support for various image processing operations.

Very High Precision Numbers

There is much more useful information about how Packed Arrays work and how you get the maximal benefit out them in your programs. Talks given by Rob Knapp and Tom Wickham-Jones at this conference have much more information on this topic.

Packed Arrays deal with tensors containing many numbers, but small precision, i.e. machine precision. But in Mathematica you can just as easily have numbers with very high precision and this is another area that we have put a lot effort into in this release. In particular it is now feasible to work with very high precision numbers in Mathematica. For instance this computes a hundred thousand digits of π.

pi  =  N[ Pi,  (10^5)]; // Timing

And this computes the square of this hundred thousand digit representation of π.

(pi^2); // Timing

In fact this is a good example of algorithm development in Mathematica. The algorithm used to multiply high precision numbers internally uses four different algorithms depending on the precision of the numbers involved with break points that have been optimized for different platforms. These include algorithms such as schoolbook multiplication, Karatsuba multiplication, FFT multiplication and interleaved Karatsuba and FFT multiplication. Well fortunately you don't have to think about all these things ... it just works great. In fact the high precision computations of Mathematica is now probably good enough to do a number of record breaking computations, something usually reserved for a single purpose software.

These are some more examples ...

e  =  N[ E,  (10^5)]; // Timing

N[ Exp[2],  (10^5)]; // Timing

These are the first ten thousand digits of π.

N[ Pi,  (10^4)]

The Structure of Numbers

Being able to compute with very high precision numbers is great, but one reason for doing that is typically that one would like to examine the structure of these numbers. There are several new or vastly improved functions in the new Mathematica that will allow you to do these things.

Digit Expansion

For instance computing the digit expansion in some base for a number ...

RealDigits[ N[1/77,  20],  10,  19 ]

As can be seen from this expansion the sequence generated appears to cyclic. This is true in general for rational numbers and RealDigits will compute the period and represent it exactly, meaning that this is really an infinite digit expansion ...

RealDigits[1/77]

FromDigits also knows how to use this information to get back to the exact number.

FromDigits[ % ]

Here are two examples of plots of digit sequences ...

ListPlot[ 
        First[ RealDigits[ N[3!/(5! + 1),  100],  10,  
            100 ] ],  PlotJoined -> True ];

ListPlot[ First[ RealDigits[Pi, 10,  100]],  
        PlotJoined -> True];

As can be seen the π expansion seems quite random and the rational one is periodic ... The following treats the binary expansion of π as a random walk by interpreting 0 as a command to go down and 1 as command to go up.

ListPlot[ 
FoldList[#1 + #2 &,  0,  
          First[RealDigits[Pi,  2,  1000]] /.  0 -> -1],  
        PlotJoined -> True ];

Continued Fractions

Another type of number representation or number structure is its continued fraction form ...

ContinuedFraction[ Pi,  10 ]

FromContinuedFraction[%]

This rational number is fairly close to π.

N[% - Pi]

For square roots (or quadratic irrationals) the continued fraction expansion becomes periodic ... and again this allows one to in effect compute infinite continued fraction expansions ...

ContinuedFraction[ (Sqrt[77])]

FromContinuedFraction[%]

Bitwise Operations

Another type of structure in numbers concerns its binary representation. This allows one to operate on numbers as if they where bit vectors. Something that is frequently used for low level operations in combinatorial and other programs.

The following inputs numbers and outputs numbers in base two to illustrate the point ... in effect using the first bit vector as what is called a bit mask is programming.

BaseForm[ BitAnd[ 2^^10110,  2^^11111],  2]

One distinct difference with Mathematica of course is that these bitvectors are not of bounded size ... for instance ...

BitOr[ 100!,  200!]

... where

Length[ IntegerDigits[ 200!,  2 ] ]

This computes a truth table for the Xor function ...

Show[
        Graphics[
          Raster[
Table[ 
              BitXor @@ 
Join[
IntegerDigits[i, 2, 7],  
                  IntegerDigits[j, 2, 
                    7]
],  
{i,  0,  
                (2^7) - 1},  {j, 0, (2^7) - 1} ]
], 
          AspectRatio -> Automatic]];

Symbolic Computation

In symbolic (or algebraic) computing we are also focusing on performance, but in many areas we are confronting problems that have no known algorithmic solution ... or in some cases not even a theoretical one. In these cases the primary focus is to increase the scope (or range) of tasks that Mathematica can handle. This is for instance slightly different from numeric computing where there has been more research done. There is also the notion of approximating solution which isn't as clear cut in symbolic computing.

We are now ten years into implementing continuous and discrete mathematics and we will most likely still be at it when we meet ten years from now. These are some of areas where we have made significant progress ...

Simplification with Assumptions

The default assumption in Mathematica is that all variables are arbitrary complex numbers. In many cases it is very convenient to assume that variables belong to some other domain or satisfy some other assumption. This is again something that users have asked from us quite persistently ... we now have a mechanism that allows you to Simplify expressions under certain assumptions.

For instance the following is the well known inequality between geometric and arithmetic means:

Simplify[ (Sqrt[x y]) ≤  ((x + y)/2)]

Well it doesn't Simplify as the inequality has some assumptions on the variables and if we put these in we do indeed get the result we hoped for.

Simplify[ (Sqrt[x y]) ≤  ((x + y)/2),  
      x ≥ 0 ∧ y ≥ 0]

Another example is the following ...

Simplify[ Sqrt[(x^2)] ]

Substituting a few values shows that it cannot be simplified to absolute value of x or x itself ...

%  /.  
      x -> {-1,  1,  I,  -I}

... on the other hand if we restrict ourselves to the real numbers there are simplifications possible

Simplify[ Sqrt[(x^2)],  x ∈ Reals]

And if we restrict ourselves even further ... g

Simplify[ Sqrt[(x^2)],  x ≥ 0]

In general you can have equations, inequalities and domain restrictions as well as logical combinations of these as assumptions. Mathematica knows about the following domains:

{Complexes,  Reals,  Algebraics,  Rationals,  Integers,  Primes,  
        Booleans} // TraditionalForm

If Mathematica can tell that an element belongs to a domain it automatically evaluates to True or False

1/2 ∈ Rationals

(Sqrt[2]) ∈ Rationals

Pi ∈ Algebraics

For instance in this case it is not known whether this statement is True or False ...

E + π ∈ Algebraics

If you give a symbol then it stays unevaluated and can be used as an assumption.

x ∈ Reals

You can use this to keep track of domains of functions ...

Simplify[ Sin[x] ∈ Reals ]

Simplify[ Sin[x] ∈ Reals ,  x ∈ Reals]

There is also some more specialized knowledge about functions ...

Simplify[ Sin[ n π ],  n ∈ Integers ]

Simplify[ Cosh[ x ] ≥ 1,  x ∈ Reals ]

This is some number theory knowledge ...

Simplify[Mod[(a^p), p], p ∈ Primes && a ∈ Integers]

FunctionExpand[ GCD[ a b,  a c ],  
      {a,  b,  c} ∈ Integers ]

Adam Strzebonski will be giving a talk at this conference where you can learn a lot more about this and related functionality ...

Cylindrical Algebraic Decomposition

One of the technologies needed to build a rigorous assumptions mechanism was the ability to manipulate inequalities. In particular we have implemented cylindrical algebraic decomposition (or CAD for short). It computes a triangular or nested structure of the set of inequalities. (This is by the way an example of an Experimental` feature.)

CylindricalAlgebraicDecomposition[ (x^2) + (y^2) ≤ 1, 
      {x, y} ]

There are many things that can be built from having access to this structure such as: optimization, multiple integration, visualization, theorem proving ... etc. This is really an enabling technology ... The following are examples of Experimental` features for the new version, i.e. to enable them you need to do the following:

<< Experimental`

Minimize[ (x^2) + y,  
      (x^2) + (y^2) ≤ 1 ∧ x + y ≥ 1,  {x, y} ]

These are not standard, but will be available.

<< InequalityGraphics.m

InequalityPlot[ 
        (x^2) + (y^2) ≤ 1 ∧ x + y ≤ 1,  {x,  y} ];

InequalityPlot[ Abs[Abs[x] - Abs[y]] ≤ 1,  
        {x, -2, 2},  {y,  -2,  2} ];

InequalityPlot3D[ 
        (x^2) + (y^2) + (z^2) ≤ 1 ∧  
          3  (x^2) + 3  (y^2) ≤  (z^2),  {x, y, z} ];

Or multiple integration ...

<< MultipleIntegration.m

Integrate[ Boole[ (x^2) + (y^2) ≤ 1],  
      {x,  -∞,  ∞},  
      {y,  -∞,  ∞} ]

Integrate[ 
      (x^2) Boole[
          (x^2) + 4  (y^2) ≤  1 ∧ 
            Abs[y] ≤ x],   {y, -∞,  
        ∞} , {x, -∞, ∞}]

InequalityPlot[ 
        (x^2) + 4  (y^2) ≤  1 ∧ Abs[y] ≤ x,  
        {x, y} ];

Quantifier elimination ... (theorem proving)

Resolve[ 
      (Subscript[∀ , x,  (x | a | b) ∈ Reals])(x^2) + a x + b 
          ≥ 0 ]

Integral Transforms

Another very useful tool in both continuous and discrete mathematics as well as in areas such as signal processing are integral transforms. We have reimplemented and extended the LaplaceTransform, FourierTransform and ZTransform and they are now part of the kernel. (There are also the sine and cosine transforms etc.)

LaplaceTransform[ (t^4) (E^t),  t,  s ]

InverseLaplaceTransform[ %,  s,  t]

The Fourier transform poses drives the need to include distributions or generalized functions such as DiracDelta.

FourierTransform[1,  t,  w ]

Integrate[DiracDelta[x] f[x],  {x, -Infinity,  Infinity} ]

This in effect computes the number of zeros of the cosine function in the interval (1,5].

Integrate[DiracDelta[Cos[x]],  {x,  1,  5} ]

So it picks out the number of zeros of the cosine function in the interval given.

Plot[Cos[x],  {x, 1, 5} ];

Similarly there is a companion function to DiracDelta namely UnitStep.

Integrate[ DiracDelta[x], x ]

Plot[ UnitStep[ Cos[5  Pi x]],  {x,  0,  2} ];

There are also the corresponding discrete functions such as KroneckerDelta and DiscreteDelta.

The Z transform is the discrete analog of the Laplace transform it is frequently used in signal processing and control. In combinatorics this is also essentially what is called the generating function ... both concepts are very useful.

ZTransform[ (3^n),  n,  z ]

The inverse Z transform essentially computes a formula for the series expansion of the expression in question ... if you are in electrical engineering or combinatorics these are things you are probably very familiar with.

InverseZTransform[ %,  z,  n]

Special Functions

As you may have seen we are now doing a sequence of posters that display all the special functions of Mathematica and their relations. It is really fascinating to see how these several hundred functions actually fit together. Apart from building posters we have actually also extended the capabilities in dealing with special functions ...

A discrete logarithm function ...

Sum[ 1/n,  {n,  k} ]

This results in a bivariate hypergeometric function ...

Integrate[ (((a (x^3) + b (x^2) + c x + d))^r),  x ]

Other new functions include Struve and some number theoretical ones ... in the lab there are addendums where you can get the full picture.

In order for these functions to be useful however they also need to be integrated into Mathematica properly and for instance there is now more knowledge in the various simplifiers about the structure and relations between variuos special functions. Incidentally FullSimplify and FunctionExpand do use the same knowledge base and hence we can might as well use FunctionExpand.

FunctionExpand[ Zeta'[0] ]

FunctionExpand[ Cos[ π/256]]

Graphics and Sound

There are several talks and question and answer sessions that will provide more information about the new computing features of Mathematica ... another area where we have done some improvements is in graphics. For instance being able to Import and Export graphics or manipulate 3D graphics in real time.

Import and Export

We have already seen one example of graphics Import, but there is a whole range of graphics formats for which you can Import and Export files. Judging from the requests coming to Wolfram Research ... this is definitely heavily requested.

Graphics File Formats

For instance there is even an FAQ written up about how to Import the cat graphics used in the tour. Well here it is in its original format ...

Import["Images/Cat.pgm" ] // Show;

Some other formats include TIFF and JPEG ...

Import[ "Images/Parrot.tif" ] // Show;

Import[ "Images/Ozelot.jpg" ] // Show;

Additional graphics file formats for Import include; BMP, GIF, JPEG, PBM, PNM, PGM, PNG, PPM, PSImage, TIFF and XBitmap

One subtlety to remember when exporting raster images is that the color space available on the computer you export to might not always allow you a lot of freedom.

Animation File Formats

Some file formats such as GIF allows you represent flip book animation. You can Import and Export animations with the Mathematica conversion routines.

Now assume that you wanted to illustrate some phenomena in Mathematica through the use of animation, e.g. in this case the summing of a Fourier series.

animation  
        = 
Table[
Plot[
Evaluate[(∑_(k = 1)^n) Sin[k 2 π t]/(k π)],  
{t,  0,  2},  
            PlotRange -> 
              {-1, 1}
],  
{n,  
            1,  10}
];

Export[ "Fourier.gif",  animation ];

You can also control in which way an animation is controlled such as if it looping at what speed it is displaying and so on.

Export[ "Fourier.gif",  animation,  
        ConversionOptions ->  {"Loop" -> True} ];

Export[ "Fourier.gif",  animation,  
        ConversionOptions ->  
          {"Loop" -> True,  AnimationDisplayTime ->  .1} ];

Sound File Formats

There are also a number of (sampled) sound file formats. The formats supported include; AIFF, AU (or μ law encoding) and WAV

Import["Sounds/EagleLanded.au" ] // Show;

An AIFF file.

Import["Sounds/SmallStep.aiff" ] // Show;

This is a stereo WAV file.

Import[ "Sounds/WindowsNT.wav" ] // Show;

Real Time 3D

Another much requested feature is to be able to manipulate 3D images in real time. In fact there are several products being showed at this conference that accomplishes this feat such as Dynamic Visualizer and Conix 3D Explorer both of which are application packages available from our site. For the upcoming version we have included experimental support for a real time 3D type in Mathematica for Windows platforms. It makes use of OpenGL so any accelerated graphics hardware that support faster OpenGL will also make this real time 3D part faster.

<< RealTime3D`

As you can see it applies smooth shading (or Goroud shading) when being rotated and you can also zoom in and out. This is an experimental feature for Windows right now.

Plot3D[ Sin[x y],  {x, 0,  Pi},  {y,  0,  Pi} ];

Communication

Import and Export

The Import/Export mechanism we saw earlier is more general then just graphics and sound. Some of the additional areas covered include textual and tabular formats, binary formats as well as document formats. In general Import and Export can frequently select the format to apply by looking at the file extension, but you can also explicitly give the format description.

This is the complete list of currently supported formats ...

$ImportFormats

$ExportFormats

Import/Export of Textual Data

These are some examples of using different formats to the same data ...

!! Tables/planets.dat

This assumes that the data is tabular ...

Import["Tables/planets.dat"]

This tells Import to interpret it as a long list ... and in particular convert to numbers when possible.

Import[ "Tables/planets.dat",  "List" ] // InputForm

This interprets the data as a file full of words ... i.e. no attempt is made at converting to numbers.

Import[ "Tables/planets.dat",  "Words" ] // InputForm

Import/Export of Binary Data

In addition to the textual and tabular formats, a lot of data is also available in binary formats. The MAT format that we saw previously is one example and another that seems to be gaining momentum is the hierarchical data format HDF. These formats are all limited in what they can support whereas the Mathematica format MX allows you to deal with any Mathematica expression.

For other binary formats there are the functions BinaryImport and BinaryExport where you can provide a layout pattern for the format.

BinaryImportString[ "Roger", "Byte" .. ]

FromCharacterCode /@ {%}

Export of Documents

Another type of format that Mathematica of course can manipulate is a document. For this version exporting to HTML, TeX and LaTeX has all been completely overhauled and the source code will be available on the distribution for easy customization as there might be particular document conventions that you might want your exported documents to adhere to.

An area where we very much have played a central role is the development of a format for describing mathematics on the web. We where founding members of the W3C working group on this issue and the new standard MathML has just been passed as recommendation from this group. The resulting format is basically an SGML rendition of the corresponding Mathematica box expression.

For instance if you do

ToBoxes[ (((x + y))^2)]

The corresponding MathML expression looks like the following ...

ExportString[ (((x + y))^2),  "HTML",  
      ConversionOptions -> {MathOutput -> "MathML"} ]

Right now this is not supported by any browser companies, but hopefully this will happen in the future. Both Netscape and Microsoft have pledged to support XML of which MathML is intended to be one part.

Java MathLink

Mathematica is a good interactive system, and we are increasingly adding more things like the real time 3D graphics manipulator, but Mathematica is also an excellent communicator. The Import/Export mechanism does this for file communication, but MathLink is the key to live links. There has been quite a few performance improvements to MathLink for this upcoming release, but many people I'm sure will be happy to hear that there is now a Java MathLink API that will be shipping with the new version. This means that we now have C, C++, Java and Visual Basic APIs for MathLink. There also lots of new application packages on their way that take advantage of MathLink.

The talk given by Shawn Sheridan and Kevin Leuthold at this conference is definitely something worth attending for people that want to learn more about MathLink.

Notebook and Interface

The user interface (or really user communication) is part that took a giant leap with version 3.0 and in the upcoming version we solidifying the gains and rounding out the feature set.

Spell Checker, Hyphenation

For instance a very requested feature is a spell checker ... well now we have one ...

The spell checker is based on the industry standard Proximity spell checking engine. The base contains a 100,000 English words with an additional 20,000 word technical dictionary. On top of that we have added 5,000 words of Mathematica related terms. It is also intelligent in its handling of programs, e.g. RationalApproximation is spell checked separately.

In particular there will be separate language dictionaries for a dozen other languages as well as for specific technical fields.

Finally the hyphenation engine used in the new Mathematica is a dictionary based hyphenation engine.

Helper Programs

Another area includs helper programs (or assistants) the are intended to make your interactive use more efficient. For instance the math editor introduced in the 3.0 front end is one such very effective assistant and the real time 3D manipulator shown earlier was another. We have continued to add more of these in the upcoming version and these are some examples:

Unmatched Brackets

Getting your bracketing characters correct in any language is always a little bit of a hurdle. In the new version there is dynamic mechanism that will sit in the background and help you with this task. For instance the following expression contains most of the common bracketing characters:

f[ {a},  "A {string}",  ("paren")]

While you type this in you will see exactly what brackets are still open ... including string characters for instance.

Automatic Replacements

Another type of helper is one that automatically replaces sequences of characters with some expression. These are examples of some default replacements:

a -> b;  a ≥ b;  a ≠ b;

One important aspect is that these things nicely with simple text applications such as email and news, i.e. you can copy and paste between them and still have it come out ok.

You can also add your own easily enough ... this is how you make a subscripted variable ...

Intelligent Indentation

The indentation mechanism is also slightly smarter in the new Mathematica in producing correctly indented code.

foo[x_]  
      := 
Module[
        {temp1,  
          temp2},  
stmt1;  
bar[ 
          arg1,  arg2 ];  
stmt3
]

Inline Cells

Another area of solidifying the gains made by the 3.0 frontend include being able to have arbitrary nesting of different types, e.g. being able to have text in grid boxes. The following is an example of this ...

This is some text ({{Text for first row, (x^2) + (y/x)}, {Text for second row, }}) this some more text.

System & Licensing

Other system wide enhancements include a complete overhaul of the password and licensing code. In particular you will now be able to use floating licenses on all of our supported systems.

Application Packages

Another area that have seen a lot of activity (and much more to come) is in the applications area. These are the currently shipping packages

Over the last year we have updated pretty much all the Wolfram packages to be 3.0 compatible as well as released Scientific Astronomer. A total of 9 new application packages including third party packages. You can meet many of the developers and see demonstrations during the user conference.

Packages/Markets in Development

In addition there are many new packages in the works which should be showing up over the next year and this is a sampling of the areas we are covering. In all these categories we have several new entrants:

■ Signal Processing

■ Control

■ Optimization

■ Mechanics

■ Statistics

■ Finance

These packages are essentially horizontal, i.e. are generically useful in many areas, or vertical, i.e. are focused very much on one area. One vertical area where you can see a more complete picture of our current offering is the Finance vertical web site. There will be many more of these in the future with associated brochures when it makes sense.

MathLink Packages

Another class of packages that fit into several of the categories mentioned are MathLink products, i.e. products that link to or from (or both) Mathematica and another product, e.g. new ones on their way include a highly improved MathLink to Excel. In addition more an more vendors of other software systems are providing links with their products,

Web Packages

MathScript provides a way of distributing applications in limited form over the web. You will see several examples here and at the user conference. In essence this is a link product to the web. (A slight understatement, but you will see more in subsequent presentations.)

Migration Packages

Another (non-commercial) class of packages include the migration packages, that intend to make it easier to move from one of the competing computing systems into Mathematica. The current crop includes packages for: MathCAD, Maple and Matlab.

Custom Products

Over the last year we have developed something called a customizable Mathematica. This allows us to build products with a custom feature set and still be complete products, i.e. they include a custom Mathematica. One consequence of this is that the price point can be more flexible. We are just getting shippable products ready at this end and first ones to come out include:

■ Publicon — A technical publishing solution

■ CalcWiz — A calculus homework solver (first iteration isn't a custom product)

This is new technology so expect a somewhat slow ramp up. There are several additional custom products in works.

Summary

We have some very exciting products coming from Wolfram Research ...