Verbeia.com|Mathematica

Mathematica: Our Wish List

• An option to use that nice TeX Computer Modern font instead of Times-like or Courier-like, for the mathematical notation in Mathematica notebooks. (Luci is a font aficionado and bored of Times!) Another good alternative would be the Lucida Math fonts. Type 1 versions of these fonts exist for free; it would be good to map their extended characters instead of using the proprietary MathFonts.

• Even better: math fonts that match nice serif typefaces like Baskerville, Garamond and Caslon.

• Better documentation on Compiling and using .x files instead of standard human-readable packages.

• Currently definitions for a function can be stored as DownValues or UpValues, and the kernel tries user provided definitions before trying built-in definitions. We need a way to give definitions that are considered only when no built-in definitions can be used. The new type of definitions could be called LastDownValues and LastUpValues. Consider this example. One can currently use the following to give Integrate a definition for a class of integrals the kernel currently can’t do.

  Unprotect[Integrate];
Integrate[Sin[Sqrt[x_](a_ x_+ b_)],x_]:=Ersek[a,b,x]

  This definition is stored in DownValues[Integrate] and is considered every time Integrate is used. Instead I want to store the definition someplace called LastDownValues[Integrate]. The definitions stored here would only be considered if the integral could not be done using the built-in Integrate algorithm. This new type of ‘values’ would allow one to add lots of extra definitions for a built-in function without effecting the time of evaluation when a built-in definition can be used.

• A simple way to insert and delete page breaks.

• FullGraphics should be enhanced so it can handle Graphics3D objects.

• A simple way to keep track of what error messages have been disabled with Off[symbol::tag].

• A bivariate normal distribution with a CDF that functions correctly. It is possible that this has been corrected in version 4.1. We hope that this is true and intend to verify the claims when we receive the new version.

• We need a GUI for adding Text, Arrows and other things to Mathematica graphics.  This could be sort of like a drawing utility for Mathematica graphics.

• We have been able to make buttons and palettes since we got version 3.0.  We could also use the capability to make "Dialog Boxes".

The enhancements listed below should be in the kernel or standard packages

• Standard Add-On Packages for statistics rolled into the main kernel (or at least in that faster non-human-readable version of package. If you want to keep the source open, put it somewhere else in the distribution, just don’t slow us down more than necessary!). Should one really have to load a package to use the Mean[] function?

  It is claimed that the statistical operations are much faster in version 4.1. We hope that this is true and intend to verify the claims when we receive the new version.

• The Notation.m package by Jason Harris should be in the kernel or standard packages. The way it is now new users never know it’s there.

• The FilterOptions package is very important.  I think it should be part of the kernel.

• A solution to the problem of shadowed symbols should be part of the kernel.  Two solutions to this problem are posted in MathSource.

• The CleanSlate package should be in the kernel or standard packages. The way it is now new users never know it’s there.

• Plot and similar functions should have a new option (WorkingPrecision).  The default setting could be (WorkingPrecision->16) in which case Plot would work sample a function at machine precision numbers as it currently does.  When the setting (MachinePrecision->50) is used a function would be sampled at arbitrary precision numbers with 50 digits of precision. When the setting (WorkingPrecision->∞) is used a function would be sampled Rational numbers, and the final value will be change to a lower precision number.   Ted Ersek wrote a function called PrecisionPlot that does this and posted it on MathSource. See
  http://www.mathsource.com/Content/Enhancements/Graphics/2D/0209-887
  However, this capability should be accessible with the built-in Plot function.

• Plot and similar functions should have a new option (InitialEvaluation).   The default setting could be
  (InitialEvaluation->True) in which case Plot would work like the modified version of Plot Ted Ersek posted on MathSource.  Using this modified version of Plot one never needs to use Evaluate on the arguments given to Plot.  On the rare occasion where one need to have the Plot function work the way it currently does one could use the setting (InitialEvaluation->False) and Plot will evaluate as it currently does.  The URL for the modified versions of Plot and other functions is
  http://www.mathsource.com/Content/Enhancements/Graphics/General/0209-876

• We need a button or menu selection to delete all graphics and associated output cells in the selected notebook, and another button or menu selection to delete all messages in the selected notebook. This capability is available through a utility palette Ted Ersek sent to MathSource, but something like this should be built-in.

• The segment of code in the next cell is available in the version 4 Help Browser under "Further Examples" for ReplacePart. This is non-trivial and very useful. Hence it should be part of the kernel or a standard package.

  Currently one must use HoldForm or a similar construct to get an output cell that hasn’t completed the standard evaluation process.  In later work one might want to use the "held" result.  Normally the hold must be lifted before anything can be done with the output wrapped in Hold.  We need the capability to stop further evaluation without having something like HoldForm wrapped around the resulting expression.  This is needed so we can have output expressions like those in the cells below without having to use ReleaseHold when the expressions are used later on.

• In version 4.0 we can do the following:
    Part[expr,{All,n}]
  Hopefully this is faster than any other method of doing the same thing.  This is very nice.  It would be nice if this convention was extended to other functions so we could do the following:
    MapAt[expr,{All,n}];
Delete[expr,{All,n}];
Insert[expr,{All,n}];
FlattenAt[expr,{All,n}];
Extract[expr,{All,n}];
ReplacePart[expr,{All,n}];

• The system should post a message in any foreseeable circumstance where one might evaluate a "valid expression",  but get a result that most likely has limited utility.  A a few examples are given below.

• In "The beginner’s guide to Mathematica Version 3", Glynn and Gray use the line in the next cell and get an entirely black graphic.  The authors explain that the option (Mesh->False) is needed to get a useful graphic.  A message explaining why the graphic is all black could be posted when a graphic is drawn with a very dense Mesh.  The way it is now a beginner will have a difficult time figuring out what’s wrong.

• ImplicitPlot uses (AspectRatio->Automatic) by default, and this normally works very well.  However, this default setting causes the cell below to produce a graphic that’s very tall and thin.  In such a situation the kernel could post a message explaining why the graphic is so tall and thin.

• In a similar manner ParametricPlot3D, Graphics3D, and some of the standard packages use the setting
  (BoxRatios->Automatic) by default and this works very well in many cases.  However, the default BoxRatios will produce a very tall and thin graphic if the next cell is evaluated.  To aid the inexperienced user a message could be posted to explain why the graphic isn’t very useful.

• It seems any use of  #, #n, ## , ##n  must be inside the head Function.   Of course one can use the FullForm as in Function[N[#]], or the short hand notation (N[#]&).  Any use of  #, #n, ##, ##n  that isn’t wrapped in Function or associated with an ’&’ character should result in an error message. For example the line in the next cell should produce a message.

• Integrate[1/x, x]  evaluates to Log[x], and this is right.  However, when students learn Calculus they are told
  Integrate[1/x, x] equals Log[Abs[x]].
  The system should have a global parameter of the form ($ddddd) to control which of the above is used.  
  
  When the system is configured to evaluate Integrate[1/x, x]->Log[Abs[x]]
  all other integrals should come out as an entry level student expects.  
  e.g.  Integrate[(2 x + 6 x^2) / (x^2+2 x^3), x] --& Log[Abs[x^2+2 x^3]]
  When configured this way all other evaluation would be performed to comply with principles taught at the entry level.  
  e.g.   {Log[-6.5], ArcSin[6.5]} --& {Log[-6.5], ArcSin[6.5]}   or perhaps {Indeterminate,Indeterminate} instead.
  
  This should make Mathematica much more useful in high school Calculus and many undergraduate courses.

• Certain Graphic functions use the options Mesh and MeshStyle, and other graphic functions use EdgeForm to do the same thing.  All graphics functions should use the same feature to specify what should be used for the edges of polygons.  The options Mesh and MeshStyle are more consistent with the way other things are done in Mathematica.  Any use of EdgeForm should be replaced with the options Mesh, MeshStyle.

• Currently it’s very difficult to change the way tick marks look in graphics.  The "Ticks" option should be separated into several options, so we can easily control the way the tick marks look and the way the number marks are formatted.

• Plot uses a PlotStyle option while ContourPlot uses a ContourStyle option for the same thing.  If that isn’t bad enough ImplicitPlot uses the PlotStyle option when the Solve method is used, but it uses the ContourStyle option when the Contour method is used.  What a mess!  The the ContourStyle option should be replaced with the PlotStyle.

• The functions Equal, Round, Floor, Ceiling, Less, LessEqual, Greater, GreaterEqual, Unequal, Sign, Abs, Conjugate, Re, Im, IntegerPart, FractionalPart, Max, Min should have an option called SimplifyFunction.  The setting of SimplifyFunction would be used when a function can’t decide what the result should be by using numerical approximation.  An example where SimplifyFunction would be needed is given in the next cell.

• Union should have a new option (Sorted).  With the setting (Sorted->True) Union would work the way it does now.  With the setting (Sorted->False) Union would return elements in the order that they started in.  This has been the subject of a long discussion in the MathGroup during July 99.  As part of this discussion Carl Woll posted the following efficient program that does an unsorted union.  It seems natural to have this a part of the built in Union (accessed via an option).

• We could use a built-in function that will perform the necessary algebra to eliminate radicals in the denominator of algebraic numbers.