For example:

In[1]:= -a b // CForm

Out[1]//CForm= -(a*b)

That looks ugly. I tried to define a new format for Times[-1, v], but this requires unprotecting Times, and led to an infinite recursion when I tried to use it. I finally found a suggestion on how to define whole new format wrappers on the comp.soft-sys.math.mathematica list, in a message posted by Carl Woll (a Wolfram employee). This is how it works:

This assignment marks CCForm (my new formatter) as a format wrapper.

In[2]:= Format[CCForm[expr_], CCForm] := expr

Note that the Out[3] text shows the new formatter name.

In[3]:= 2 + 3 // CCForm

Out[3]//CCForm= CCForm[5]

It’s showing the CCForm wrapper, though, which we don’t want to look at, so we define a top-level format for CCForm that replaces it with its argument.

In[4]:= Format[CCForm[expr_]] := expr

Now, the output looks correct.

In[5]:= 2 + 3 // CCForm

Out[5]//CCForm= 5

The case I’m trying to fix isn’t helped by this. We need to make it produce the CForm.

In[6]:= -a b // CCForm

Out[6]//CCForm= -a b

In[7]:= Format[CCForm[expr_]] := CForm[expr]

In[8]:= -a b // CCForm

Out[8]//CCForm= -(a*b)

We don’t want the result to be evaluated, so we add a HoldForm.

In[9]:= Format[CCForm[expr_]] := HoldForm[CForm[expr]]

In[10]:= -a b // CCForm

Out[10]//CCForm= -(a*b)

Now it’s in CForm, but we still have the parenthesis. I don’t understand just why this works, but making CCForm HoldAll fixes the problem.

In[11]:= SetAttributes[CCForm, HoldAll]

In[12]:= -a b // CCForm

Out[12]//CCForm= -a * b

This also prevents evaluation of the expression being formatted.

In[13]:= 2 + 3 // CCForm

Out[13]//CCForm= 2 + 3

Note that CForm does what I want if it’s made HoldAll.

In[14]:= -a b // CForm

Out[14]//CForm= -(a*b)

In[15]:= SetAttributes[CForm, HoldAll]

In[16]:= -a b // CForm

Out[16]//CForm= -a*b

Although it’s not styled as nicely as the CCForm version, and could mess up existing code, so we won’t do that.

In[17]:= ClearAttributes[CForm, HoldAll]

Now I can use CCForm instead of CForm for the output formatting of my converter, and have nicer-looking results.

After spending some time manually rearranging a closed-form solution to a system of equations, it seemed worthwhile to find a way to hoist common subexpressions into variables. I didn’t find anything useful via Google, as the results were swamped by references to the common compiler “common subexpression elimination” optimization. It looked like it would require data-flow analysis to do this, which would be tedious to write and debug.

Some thought and experimentation suggested that it wouldn’t be all that hard to do a decent job using a straight-forward pattern matching and replacement (especially since I didn’t care how fast this ran), so I created this Mathematica 7 notebook to do just that. The code turned out to be concise, which means “unreadable” in Mathematica. I try to stick to functional style where I can, which is nice mental exercise, but can be hard to read. In the main function, I opted for iteration rather than a purely functional recursion just because it seemed clearer.

It’s always interesting to work on a problem like this in Mathematica. The language is very expressive, but often fails at the “Principle of Least Surprise“. In this case, I kept being tripped up by Mathematica matching non-existant arithmetic functions (Plus, Times, etc.) everywhere in an expression, in an overly-helpful attempt to match arithmetic patterns regardless of commutative or associative expression rearrangements. For future reference, it turns out that using HoldPattern will prevent that behavior.

I created a web page from the Mathematica notebook, but there doesn’t appear to be any way to do that and produce text, rather than pictures of the code. Oh well. Here it is anyway. If you want to see this notebook properly and don’t have Mathematica 7, you can use the free Mathematica Player.

In Mathematica, typing index brackets is clumsy, as one has to type esc-[[-esc then esc-]]-esc. I found a way to modify the Edit menu to add a shortcut for this.
I don’t know how this would be done from non-Macintosh systems, but on Macintosh, you copy the file “/Applications/Mathematica.app/SystemFiles/FrontEnd/TextResources/Macintosh/MenuSetup.tr” (in the Application bundle) into “~/Library/Mathematica/SystemFiles/FrontEnd/TextResources/Macintosh/MenuSetup.tr”. Then, edit it using a plain text editor like BBEdit, or even with Mathematica itself.

In this file, find the line

MenuItem["Matching []", "InsertMatchingBrackets", MenuKey["]", Modifiers->{"Command", "Option"}]],

In the same block of menu items, add this

MenuItem["Matching [LeftDoubleBracket][RightDoubleBracket]",
    FrontEndExecute[{
        FrontEnd`NotebookApply[FrontEnd`InputNotebook[],
            "[LeftDoubleBracket][SelectionPlaceholder][RightDoubleBracket]"]}],
    MenuKey["]", Modifiers->{"Command", "Option", "Control"}]],

You have to restart Mathematica for it to see this change, but now you can wrap index brackets around the selection by typing cmd-opt-ctl-].

This is different from the other “Matching…” insertions, as it wraps the brackets around the selection, or leaves a “placeholder” selected if there was no selection rather than replacing the selection with the insertion. Since I’m used to editors that wrap the selection in this case, I’ve also changed the existing “Matching…” menu items to use this same technique.

This is what I have now:

MenuItem["Matching []",
    FrontEndExecute[{
        FrontEnd`NotebookApply[
            FrontEnd`InputNotebook[],"[[SelectionPlaceholder]]"]}],
    MenuKey["]", Modifiers->{"Command", "Option"}]],
MenuItem["Matching {}",
    FrontEndExecute[{
        FrontEnd`NotebookApply[
            FrontEnd`InputNotebook[],"{[SelectionPlaceholder]}"]}],
    MenuKey["}", Modifiers->{"Command", "Option"}]],
MenuItem["Matching ()",
    FrontEndExecute[{
        FrontEnd`NotebookApply[
            FrontEnd`InputNotebook[],"([SelectionPlaceholder])"]}],
    MenuKey[")", Modifiers->{"Command", "Option"}]],
MenuItem["Matching [LeftDoubleBracket][RightDoubleBracket]",
    FrontEndExecute[{
        FrontEnd`NotebookApply[
            FrontEnd`InputNotebook[],"[LeftDoubleBracket][SelectionPlaceholder][RightDoubleBracket]"]}],
    MenuKey["]", Modifiers->{"Command", "Option", "Control"}]],

These changes should survive minor updates to Mathematica, but it’s best to keep a copy of your file in case some later update replaces it.

Instead of using ArrayPlot to generate the image, I can now do this:

myImage = Image[imageData, ColorSpace->RGBColor]

I still need to specify RGBColor to interpret the alpha channel correctly, but the option to Image is named ColorSpace, instead of the ColorFunction used by ArrayPlot.

Exporting works the same way as before:

Export["~/Desktop/myImage.png", myImage]

Except that now I can directly export a png with alpha. Much simpler overall in the new Mathematica.

imageFunction[x_, y_] :=
 If[BitAnd[x, 1] == BitAnd[y, 1],
  {0, 0, 0, 1},
  {1, 0, 0, 0.01}]

Table then makes a 256 x 128 array of RGBA values from the image function. This is non-square for this example to ensure that the width and height are in the right order later.

imageData = Table[
   imageFunction[x, y],
   {y, 0, 127}, {x, 0, 255}];

ArrayPlot makes the pixel array viewable by converting it into a Graphics. The ColorFunction produces RGBA pixels (the default ignores alpha), PixelConstrained aligns the image to exact pixel boundaries, and ImageSize produces a result that’s exactly the right size.

apic = ArrayPlot[
  imageData,
  ColorFunction -> RGBColor,
  PixelConstrained -> True,
  ImageSize -> Reverse[Take[Dimensions[imageData], 2]]]

This produces the image:

Which is then exported like this:

Export["~/Desktop/APic.tif", apic];

The result is a pixel-perfect file resulting from a raster image defined in Mathematica.