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
Begin["test`"] will simply add the current context to the context stack, and then change it to
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
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.
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
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];
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
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.