Main Page

omath is an open computer algebra system. It's under development, and not really in a useful state, but there is a demonstration applet, and lots of ways you can help out!

Status
omath version $$10^{-17}$$ is available now. See the release notes.

Either:
 * 1) Have a look at the example sessions to see what you can do already.
 * 2) Try the applet (you'll need java 1.5 hooked up to your browser).
 * 3) Download the command line interface (including all source code and javadocs), as an executable jar file (instruction).
 * 4) Check out the project from the subversion repository (and get help on hacking omath using Eclipse).
 * 5) Have a look at our jira server, which tracks bugs, issues, and new work.
 * 6) Sign up on the announce@lists.omath.org (low volume version announcements) or dev@lists.omath.org mailing lists.

The roadmap for version $$10^{-16}$$, and later, is in progress, there's a todo list, and then of course there are Dror's omath hopes and dreams.

Project goals
The omath project hopes to provide a free computer algebra system (free as in speech, and as in beer -- free beer is always good), based on similar principles to Mathematica's. In particular, many simple programs written in Mathematica will run on omath. However, it is not a Mathematica emulator; many things you can do in Mathematica will never work in omath, and we intend to (eventually!) provide something much better than Mathematica. Unlike some, we won't try to redefine 'bugs' as 'features'.

If omath succeeds, it will succeed because users of computer algebra systems, like you, will appreciate the value of an open, extensible computer algebra system. There are many ways in which you can contribute right away -- from contributing code to the core (the function definitions and rules which provide a usable environment for doing mathematics), testing and bug reports, editing the wiki, or even hacking the kernel.

Licensing and all that
We haven't really discussed licensing issues much at this point. However, we're committed to making omath as open as possible. We will always welcome (need!) input from the mathematical and computer science communities -- commit access to the source code is yours for the asking, right now. The program will always be available under a free license, and quite possible released to the public domain.

Following the lead of KnotTheory`, which is adopting the MIT license, omath quite likely will too.

Developers
At this point, almost all code has been written by Yossi and Scott (focusing on the parser and the kernel respectively). Dror is providing hosting, planning on writing a user interface, and has some hopes and dreams.

At some point we need to do some recruiting, and contact various people.


 * Alex Gittens (rubberduckie (at-sign) gmail (dot) com) has written a Mathematica parser, and hopefully might be interested in helping out on the parser work. (I wrote him an email recently --Scott 15:53, 28 October 2005 (EDT))
 * Richard Fateman is a CS professor at Berkeley, who long ago wrote MockMMA in Lisp. (The matching code.) He also wrote an amazing, and still relevant review of Mathematica 2.0.
 * Dylan and the other Yossi?

Extending the core
The 'core' provides all the functions you'd expect in a computer algebra package. At present, it's closely modelled on the functions available in Mathematica, although very incomplete. Typical examples include Set, SetDelayed, Table, Apply, Expand, Binomial, CompoundExpression, Cases, Sort and DownValues (all implemented, more or less; follow the links for source code), along with FixedPoint, Integrate, Select and so on (not yet implemented). I'm about to write a tutorial on extending the core, in which we'll walk through the process of implementing some of these functions.

Kernel hacking
I'm beginning to write a tutorial for would be kernel hackers. This is a great place to start if you're interested in how the kernel works, interesting in improving the current kernel, or writing alternative implementations of part of all the kernel. On the other hand, if you'd like to extend the core (the collection of functions available in an omath session) you should look at the core tutorial instead! (Modifying the core is much more straightforward!)

Omath specifications
Unlike some other computer algebra systems, omath (one day) comes with a specification, fully describing the kernel's "evaluation loop", the built in "pattern matcher", and the behaviour of the "rule tables".

Project structure
The omath project is divided into several components


 * omath.org/wiki
 * This wiki, which will (one day) be the home of all the user documentation for omath. At present, it mostly contains notes written by and for active developers.


 * interfaces
 * A collection of java code describing what a 'kernel' should look like, as well as interfaces describing almost everything else; 'expressions', 'rules', 'patterns', and so on. If you'd like to write some code for omath, it wouldn't hurt (but probably isn't necessary) to at least briefly familiarise yourself with these interfaces. In order to help write the 'core' (see below), you'll only need to understand the use of these interfaces, not the particular implementations provided by the Tungsten kernel. This component of omath is relatively stable.


 * core
 * A (huge) collection of code, and tests for that code, implementing the mathematical environment expected by a user of a computer algebra system. Thus the core contains implementations of things like Mathematica's 'Plus', 'SetDelayed', 'Table', 'Cases', 'FixedPoint', and eventually (maybe, one day) things like 'ListPlot', 'SurfacePlot', 'Import', and so on. Extending the core is fairly straightforward; we're putting a lot of work into making it easy for you to help out here. You can write code in either omath, java, or jython, (and perhaps others, if you explain to us how to integrate them!) and there will soon be tutorials and code generation tools to help you out.


 * parser
 * The 'parser', a complicated machine for turning the types of things you expect to be able to type into a computer algebra system, like, which has to be turned into the internal representation (like Mathematica's  )


 * kernel
 * The 'kernel', which maintains tables of definitions, runs the evaluation loop, and provides pattern matching. It's pretty cool :-) The current implementation of the kernel is called Tungsten. (get it?)


 * user interface
 * The only user interface available at the moment is presently kinda 1970s looking; just a 'command line' interface, even if it is wrapped up as an applet, so you can use it over the web. Have a look at the design goals.

External Resources

 * [[Media:Matching-in-flat-theories.pdf|Matching in flat theories]] by Temur Kutsia.
 * A detailed description of Mathematica's flat pattern matching. (But quite technical!) (original link)


 * [[Media:Mathematica-as-a-rewrite-language.pdf|Mathematica as a Rewrite Language]] by Bruno Buchberger.


 * [[Media:On-the-implementation-of-a-rule-based-programming-system-and-some-of-its-applications.pdf|On the implementation of a rule-based programming system and some of its applications]] by Mircea Marin and Temur Kutsia.
 * These people obviously understand Mathematica's pattern matching enumeration system backwards.

MathLink

 * a few lines about the MathLink protocol.
 * A MathLink tutorial.

Legal questions

 * Richard Fateman received a few letters from Wolfram over MockMMA.
 * An interesting thread on USENET sci.math.symbolic quoting the original letter from Wolfram to Fateman over MockMMA. The thread continues with some interesting tidbits:.
 * An epic USENET thread on whether languages can be copyrighted.
 * The wikipedia page on Public Domain.

Other Computer Algebra Programs
(a Rosetta Stone for CASs.)


 * SAGE (GPL)
 * Yacas (GPL)
 * Maxima (GPL)
 * Pari (GPL)
 * GAP (GPL)
 * Axiom (modified BSD)
 * Magma (closed)
 * Reduce (closed)
 * Macsyma (closed)
 * Maple (closed)
 * Mathematica (closed)
 * MathCAD (closed)
 * Derive (closed, window$ only)

Others
Gmp, DoCon, Magnus, MuPAD, Octave, Scilab, Sumit, Macauley2, Singular, Euler

Server tools
We are currently running:
 * Wiki at http://omath.org/wiki
 * SVN repository at http://svn.omath.org
 * You can use this to browse all the source code (and indeed to check it out into eclipse, or your favourite IDE). If you'd like commit access, just introduce yourself!


 * Mailing lists at http://lists.omath.org
 * We have three mailing lists at the moment; dev, announce and commit-log (automatic logging of SVN commits).


 * Jira at http://omath.org/jira/
 * Thanks to Atlassian for the open source license!
 * If you mention a jira issue tag in an svn commit, the revision will automatically get linked to from the issue.
 * Jira is also hooked up to Fisheye, displaying diffs on svn revisions.


 * CruiseControl at http://omath.org:8080/cruisecontrol/
 * (not much use for anything yet -- need to start migrating tests to 'stable')
 * (not in use at all; need to change the port now that Jira is on 8080)

Old stuff
Feel free to delete, refactor, or relocate anything below!

Random things to categorise somewhere

 * JavaView is great; it's free, but not open. If it were open source, it would be exactly what we need. Oh well.
 * Wolfram offers a 15-day saved-disabled trial version of Mathematica, at.

Mathematica parser bugs
a+?"f"+b parses incorrectly as

Notice the strange behaviour of f[x:((y:A)|(z:B))]:=g[{x},{y},{z}] f[A] f[B] The current implementation of the pattern matcher will never be able to reproduce this.

Infinity-Infinity f[Infinity]-f[Infinity]

whoa -- what's this about: Clear[cef] cef[_]:=True Clear[ef] ef[x_]/;cef[x]:=(Print[x];cef[x]=False;ef[x]) t=Table[ef[i],{i,1,5}] t t1 ef[1]

'Local' variables in Block: g[x_]:=Block[{a},a=1+x] g[2] g[x] g[a]