Creating and maintaining a mathematical and statistical library that is
accurate requires a greater degree of communication than might be the
case for other components. It is important that developers follow
guidelines laid down by the community to ensure that the code they create
can be successfully maintained by others.
Developers are asked to comply with the following development guidelines.
Code that does not comply with the guidelines including the word must
will not be committed. Our aim will be to fix all of the exceptions to the
"should" guidelines prior to a release.
- Start by reviewing the overall objectives stated in the
proposal upon which the project is
- Download the Commons Math source code. Follow the instructions
under the heading "Repository Checkout" on the
Git at the ASF page.
The git url for the current development sources of Commons Math
for anonymous read-only access and
(where apacheid should be replaced by each committer Apache ID) for committers
- Like most commons components, Commons Math uses Apache Maven as our
build tool. The sources can also be built using Ant (a working
Ant build.xml is included in the top level project directory).
To build Commons Math using Maven, you can follow the instructions for
project with Maven. Launch Maven from the top-level directory
in the checkout of Commons Math trunk. No special setup is required,
except that currently to build the site (i.e. to execute Maven's
"site" goal), you may need to increase the default memory allocation
(e.g. export MAVEN_OPTS=-Xmx512m) before launching
- Have a look at the new features that users and developers have requested
Math Wish List Wiki Page.
- Be sure to join the commons-dev and commons-user
email lists and use them appropriately (make sure the string
"[math]" starts the Subject line of all your postings).
Make any proposals here where the group can comment on them.
Setup an account on JIRA and use it to submit patches and
identify bugs. Read the
directions for submitting bugs and search the database to
determine if an issue exists or has already been dealt with.
Commons Math Issue Tracking Page for more information on how to
search for or submit bugs or enhancement requests.
Generating patches: The requested format for generating patches is
the Unified Diff format, which can be easily generated using the git
client or various IDEs.
Run this command from the top-level project directory (where pom.xml
Contributing ideas and code
Follow the steps below when making suggestions for additions or
enhancements to Commons Math. This will make it easier for the community
to comment on your ideas and for the committers to keep track of them.
Thanks in advance!
- Start with a post to the commons-dev mailing list, with [math] at
the beginning of the subject line, followed by a good, short title
describing the new feature or enhancement. For example, "[math]
Principal Components Analysis." The body of the post should include each
of the following items (but be as brief as possible):
- A concise description of the new feature / enhancement
- References to definitions and algorithms. Using standard
definitions and algorithms makes communication much easier and will
greatly increase the chances that we will accept the code / idea
- Some indication of why the addition / enhancement is practically
- Assuming a generally favorable response to the idea on commons-dev,
the next step is to add an entry to the
List corresponding to the idea. Include a reference to the
- Create a JIRA ticket using the the feature title as the short
description. Incorporate feedback from the initial posting in the
description. Add a reference to the JIRA ticket to the WishList entry.
- Submit code as attachments to the JIRA ticket. Please use one
ticket for each feature, adding multiple patches to the ticket
as necessary. Use the git diff command to generate your patches as
diffs. Please do not submit modified copies of existing java files. Be
patient (but not too patient) with committers reviewing
patches. Post a *nudge* message to commons-dev with a reference to the
ticket if a patch goes more than a few days with no comment or commit.
Commons Math follows Code
Conventions for the Java Programming Language. As part of the maven
build process, style checking is performed using the Checkstyle plugin,
using the properties specified in checkstyle.xml.
Committed code should generate no Checkstyle errors. One thing
that Checkstyle will complain about is tabs included in the source code.
Please make sure to set your IDE or editor to use spaces instead of tabs.
Committers should configure the
git repository or global settings with
The first two settings define the identity and mail of the committer.
The third setting deals with line endings to achieve consistency
in line endings. Windows users should configure this setting to
(thus forcing git to convert CR/LF line endings
in the workspace while maintaining LF only line endings in the repository)
while OS X and Linux users should configure it to
(thus forcing git to only strip accidental CR/LF when committing into
the repository, but never when cheking out files from the repository). See Customizing
Git - Git Configuration
in the git book for explanation about how to
configure these settings and more.
Committed code must include full javadoc.
All component contracts must be fully specified in the javadoc class,
interface or method comments, including specification of acceptable ranges
of values, exceptions or special return values.
External references or full statements of definitions for all mathematical
terms used in component documentation must be provided.
Commons math javadoc generation now supports embedded LaTeX formulas via the
embed mathematical expressions formatted in LaTeX in javadoc, simply surround
the expression to be formatted with either \( and \) for inline
formulas, or \[ and \] to have the formula appear on a separate line.
For example, \(a^2 + b^2 = c^2\) will render an in-line formula
saying that (a, b, c) is Pythagorean triplet. Using \[ and \] on
the ends will render the same formula on a separate line. See the MathJax
and LaTex documentation for details on how to represent formulas and
escape special characters.
Implementations should use standard algorithms and
references or full descriptions of all algorithms should be
Additions and enhancements should include updates to the User
Exceptions generated by Commons Math are all unchecked.
All public methods advertise all exceptions that they can generate.
Exceptions must be documented in both javadoc and method signatures
and the documentation in the javadoc must include full description
of the conditions under which exceptions are thrown.
Methods should fully specify parameter preconditions required for
successful activation. When preconditions are violated, a
MathIllegalArgumentException should be thrown. Subclasses of
MathIllegalArgumentException may be used to represent common parameter
contract violations (for example, NoBracketingException). Exception
messages must contain sufficient information on parameter values to
determine the exact precondition failure.
Exceptions generated by Commons Math make sense without knowing
implementation details other than those stated in the public API.
For example, a NoBracketingException makes sense thrown by a solver that
has a precondition requiring that initial points bracket a root. This
exception does not make sense, however, thrown by an inverse cumulative
MathIllegalArgumentException should only be thrown in situations
where preconditions can be exhaustively provided so that what arguments
are "illegal" can be specified fully to the caller. Domain-specific
exceptions need to be defined for cases where failures cannot be
attributed to parameter precondition violation. For example, the exact
domain of successful activation of a solver or quadrature method may be
impossible to specify because of numerical properties of the method.
If a solver fails to find a root or a quadrature method fails to converge
for a given set of parameters, unless those parameters violate the
advertised preconditions it is not appropriate to throw
State information included in exception messages must be available
in exception properties - i.e., successful handling or reporting of
Commons Math exceptions must not require parsing exception messages.
Committed code must include unit tests.
Unit tests should provide full path coverage.
Unit tests should verify all boundary conditions specified in
interface contracts, including verification that exceptions are thrown or
special values (e.g. Double.NaN, Double.Infinity) are returned as
Licensing and copyright
All new source file submissions must include the Apache Software
License in a comment that begins the file
All contributions must comply with the terms of the Apache
Patches must be accompanied by a clear reference to a "source"
- if code has been "ported" from another language, clearly state the
source of the original implementation. If the "expression" of a given
algorithm is derivative, please note the original source (textbook,
References to source materials covered by restrictive proprietary
licenses should be avoided. In particular, contributions should not
implement or include references to algorithms in
Numerical Recipes (NR).
Any questions about copyright or patent issues should be raised on
the commons-dev mailing list before contributing or committing code.
Here is a list of relevant materials. Much of the discussion surrounding
the development of this component will refer to the various sources
listed below, and frequently the Javadoc for a particular class or
interface will link to a definition contained in these documents.