Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

I'm building a package to help me write packages and their documentation. In this post I explained how to make a package and its documentation. In the answer I provided I describe how to build a very simple package. However, I have been looking around the extra packages that come with Mathematica and in some packages I see many .m files. I see this as a good way of dividing the application. Can someone describe the structure of a package?

To do this lets try to make a package out of the next simple functions. Suppose that we have the following in a notebook:

AddTwo::usage = "AddTwo[a, b] returns a+b";
AddThree::usage = "AddTwo[a, b, c] returns a+b+c";
DotTwo::usage = "DotTwo[a, b] returns a*b";
DotThree::usage = "DotTwo[a, b, c] returns a*b*c";
AddTwo[a_, b_] := a + b;
AddThree[a_, b_, c_] := a + b + c;
DotTwo[a_, b_] := a*b;
DotThree[a_, b_, c_] := a*b*c;

I would like to put these functions in a package. They all seem to be very simple arithmetic operations so let us make a package named SimpleArithmetic. This package is perfect to be divided into sections. One for additions and one for products, so we can make "subpackages" Addition and Product. If we follow some of the examples in the Mathematica installation we can create a folder called SimpleArithmetic in say $UserBaseDirectory. Inside SimpleArithmetic we can create two other files Addition.m and Product.m. The code for the additions would be placed in Addition.m and the code for multiplications would be placed in Product.m.

The question now is, how would these files look like? There is also a folder called Kernel which contains Init.m.

Could someone please just explain the best practices to create packages? I've read over the documentation and the whole "context" and "packages" keywords have already confused me. The code in the files I have described would be very appreciated.

share|improve this question

migrated from stackoverflow.com Jul 28 '13 at 6:31

This question came from our site for professional and enthusiast programmers.

There is no simple answer to this. In the Java world there is a tool just to create quality metrics for this topic. Read about it here: clarkware.com/software/JDepend.html. This might give you an idea of the complexity of the subject you touched. –  ndroock1 Jul 9 '11 at 7:15
@ndroock, Is the creation of packages in Mathematica that complicated? So far I can just create a simple package, which is a collection of functions. I might be overthinking things because of the notation <<PackageName'Somethingelse' where the ' is of course `. What exactly does this mean? –  jmlopez Jul 9 '11 at 7:27

4 Answers 4

up vote 56 down vote accepted

Package creation is a large topic indeed. I will still attempt to give a minimal clarification of the encapsulation mechanism behind packages, since in my experience it pays off to understand it.

What constitutes a package

Basically, a piece of Mathematica code (usually containing a number of variable and function definitions), which is placed inside




can be called a package. Usually, however, at least some more structure is present. In particular, to separate interface from implementation, the typical package looks like







Contexts and symbol names

The context here is a namespace. The convention is that context name is a string ending with "`". At any given moment, the value for the current working namespace is stored in the system variable $Context, and can also be queried by calling Context[]. Begin["test`"] will simply add the current context to the context stack, and then change it to "test`", while End[] will exit the current context by making the previous one current.

Every symbol must belong to some context. The system commands belong to the "System`" context, and the default working context for interactive FrontEnd sessions is "Global`". When mma code is parsed, the symbols are given their "true" (long) names, which contain both a symbol name and a context where the symbol is. For example, Map is really System`Map, and if I define a function f[x_]:=x^2 in the FE session, it will be Global`f. For any symbol, one can call Context[symbol] to determine the context where that symbol belongs. To "export" a symbol defined in a package, it is sufficient to simply use it in any way in the "public" part of the package, that is, before "`Private`" or other sub-contexts are entered. Usage messages is just one way to do it, one in principle could just write sym; and the sym would be created in the main package context just the same (although this practice is discouraged).

Every symbol can be referenced by its long name. Using the short name for a symbol is acceptable if the context where it belongs belongs to the list of contexts currently on the search path, stored in a variable $ContextPath. If there is more than one context on the $ContextPath, containing the symbol with the same short name, a symbol search ambiguity arises, which is called shadowing. This problem should be avoided, either by not loading packages with conflicting public (exported) symbols at the same time, or by referring to a symbol by its long name. I discussed this mechanics in slightly more detail in this post.

Contexts can be nested. In particular, the "`Private`" above is a sub-context of the main context someContext. When the package is loaded with Get or Needs,only its main context is added to the $ContextPath. Symbols created in sub-contexts are therefore inaccessible by their short names, which naturally creates the encapsulation mechanism. They can be accessed by their full long names however, which is occasionally handy for debugging.

Storing and loading packages

Packages are stored in files with ".m" extension. It is recommended that the name of the package coincides with the name of the package context. For the system to find a package, it must be placed into some of the locations specified in the system variable $Path. As a quick alternative (useful at the development stage), $Path can be appended with the location of a directory that contains a package.

When the Needs or Get command are called, the package is read into a current context. What is meant by this is that the package is read, parsed and executed, so that the definitions it contains are added to the global rule base. Then, its context name is added to the current $ContextPath. This makes the public symbols in a package accessible within the current working context by their short names. If a package A is loaded by another package B, then generally the public symbols of A will not be accessible in the context C which loads B - if needed, the A package must generally be explicitly loaded into C.

If the package has been loaded once during the work session, its functions can be accessed by their long names even if it is not currently on the $ContextPath. Typically, one would just call Needs again - if the package has been loaded already, Needs does not call Get but merely adds its context name to the $ContextPath. The internal variable $Packages contains a list of currently read in packages.

The case at hand

Here is how a package might look like:


AddTwo::usage = "AddTwo[a, b] returns a+b";
AddThree::usage = "AddThree[a, b, c] returns a+b+c";
TimesTwo::usage = "TimesTwo[a, b] returns a*b";
TimesThree::usage = "TimesThree[a, b, c] returns a*b*c";


plus[args___] := Plus[args];
times[args___] := Times[args]

AddTwo[a_, b_] := plus[a, b];
AddThree[a_, b_, c_] := plus[a, b, c];
TimesTwo[a_, b_] := times[a, b];
TimesThree[a_, b_, c_] := times[a, b, c];


The functions AddTwo, AddThree, TimesTwo,TimesThree are public because these symbols were used in the public part of the package. Their long names would be then SimpleArithmetic`AddTwo, SimpleArithmetic`AddThree, SimpleArithmetic`TimesTwo, SimpleArithmetic`TimesThree. The functions plus and times are private to the package, since they are in the sub-context `Private`, which is not added to the ContextPath when the main package is loaded. Note that this is the only reason they are private. Should I call AppendTo[$ContextPath,SimpleArithmetic`Private`], and they'd become as "public" as the main functions (practice that should of course be discouraged by which should clarify the encapsulation mechanism).

With regards to splitting a package into several packages, this is a normal practice, but usually an individual mma package contains much more functionality than say a typical Java class, more like Java package. So, in the case at hand, I'd not split it until you get a much more functionality in it.

Of course, I only discussed here a very small subset of things related to packages. I will hopefully update this tutorial soon. An excellent reference for writing packages is a book of Roman Maeder "Programming in Mathematica". It is pretty old, but still one of the most (if not the most) useful accounts on the matter.

share|improve this answer
thank you for taking the time to explain this important topic. I think I got this part covered. I'll be waiting for your update. What I really want is to know how to use SimpleArithmetic'Addition' and SimpleArithmetic'Product'. So far I can sort of do this but I always end up messing the links to the documentation I write. I could make everything as part of one whole package (documentation and package works) but I think it is very important to know how add subsidary packages to the application that work with the documentation. –  jmlopez Jul 9 '11 at 9:23
@jmlopez. Mr. Wizard's reply to this question may be of interest –  TomD Jul 9 '11 at 10:49
David Park's reply to this message is also very informative. (A new version of DP's Presentations package for Mma 8 is now available, BTW) –  TomD Jul 9 '11 at 11:00
@TomD, I think David Park's explanation is what I needed. Thank you. –  jmlopez Jul 9 '11 at 14:18
@TomD, I have tested what Park said, I indeed needed this piece of undocumented code in the PacletInfo.m file under Extensions: {"Kernel", "Context"->{"SimpleArithmetic'Addition'","SimpleArithmetic'Product'"}}. Now that that's resolve I can simply things by a lot. –  jmlopez Jul 9 '11 at 14:32

For me, the best way to create packages in based on Maeder's book. That gets things done quickly & semi ... dirtily(!) so that usages work just fine, but there's no fancy documentation center entries. The way to create such a (completely doc. center compatible package is expertly covered here.

On to the question at hand ...

If you think you need to separate functionality, then one approach is (as a template)

BeginPackage["YourPackageDirectory`YourPackageName`", {"YourPackagesDependencys`"}];
(* usages go here *)
Begin ["Private`"];
(* Function definitions go here *)
End[]; (* private *)
(* protect what you want *)

So what you might want to do with your wrapper package is

BeginPackage[`Lopez`SimpleArithmetic`", {"Lopez`Addition`", "Lopez`Multiplication`"}];

You'd then start another package like

AddTwo::usage = "AddTwo[a, b] returns a+b";
AddThree::usage = "AddTwo[a, b, c] returns a+b+c";
AddTwo[a_, b_] := a + b;
AddThree[a_, b_, c_] := a + b + c;

And a third along similar lines called LopezMultiplication`. All packages live in $UserAddOnsDirectory/Lopez which you'll probably need to create.

You use them by loading LopezSimpleArithmetic (Needs["LopezSimpleArithmetic"]`), though you can also load individual packages for debugging.

As another guide, I'd suggest studying source code in the Statistics legacy as a complicated package with many dependencies all seamlessly resolved when you load things. Your mileage may vary.


share|improve this answer
thank you for the comment "expertly covered here". I'm a little confused about the structure of the application. Do you mean to say that we have a directory called "Lopez" which contains m files with names "SimpleArithmetic.m", "Addition.m" and "Multiplication.m"? At this moment I'm not so concerned with dependencies. All I want is to have subsidary packages (Addition and Multiplication) in the main application (SimpleArithmetic). The whole packageDirectory'subdidarypackage' is confusing at this moment. I can't find an actual example in Mathematica that uses this format. –  jmlopez Jul 9 '11 at 9:33
Exactly. And you can find an example that uses this format. As I suggested, the legacy statistics package is a good place to start. Have a look in MultiDescriptiveStatistics.m. This requires StatisticsCommonMultivariateCommon which is in the directory Statistics/Common. –  dwa Jul 9 '11 at 12:30
the problem with this legacy package is that it does not give you the file structure with the documentation. In any case, I think I got the whole file structure straighten up now. I'll be writing up another answer for the whole documentation with the plain installation of Mathematica soon and this question has helped me a lot. –  jmlopez Jul 9 '11 at 14:39

One useful approach might be to use Wolfram Workbench, if you have access to it. Whether you use Workbench or not, a good way to organise your application is to have an overarching package that calls the subsidiary packages. For example, in the large project I am developing at the moment, there is a package for general utilities (data massaging), a package for the main plotting functions (highly customised version of the usual ones), and a package that provides a more general version of one of the plotting functions (DateListBarChart). The general package calls the first two of these, and the general as well as the second package call the third. The general package could be as simple as the following. In fact, this is the main package for my application, with the acronym for my employer changed to XYZ.

(* Mathematica Package *)
(* Created by the Wolfram Workbench May 20, 2010 *)
BeginPackage["XYZ`" ,{"XYZ`DateListBarChart`","XYZ`XYZGraphs`","XYZ`XYZUtilities`"}]
 (* Exported symbols added here with SymbolName::usage *) 
 (* Implementation of the package *)

The way one organises these (for deployment) is, on Mac OS X at least, to put them in /Users/username/Library/Mathematica/Applications/. Inside this would be a folder for your main application name (e.g. XYZ), containing the main package, XYZ.m and any subsidary packages. Documentation and Kernel are subfolders of this folder.

You might find some useful tips in Wolfram's white paper on large projects, available from this page.

share|improve this answer
@Verbeia, I used the Wolfram Workbench to see the directory and file structure but the examples they provided were done in the most simple case. You should check out this link which TomD provided. I hope that updating Java doesn't mess with my plain mathematica installation. That's all I'm using to make the documentation. –  jmlopez Jul 9 '11 at 14:43

Another thing that isn't clear from the documentation. If you want to make a .m file, you need to change the cell properties of anything that you want in it to 'initialisation cell' before you save. Otherwise, the saved module file will have no active content!

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.