Numerical Analysis Objects - NAO 

 As part of this project, we have implemented a set of abstract base classes for objects such as geometrical regions, functions, operators, algorithms and problems. These define how a user interacts with these objects: what information can be obtained, and how the object may be manipulated. On top of this base we have written a class library which contains implementations of some of the more common objects, and a library of Utilities for things such as drawing and printing. We would like you to try it, either by using the algorithms and classes that have already been implemented, or by adding your own, and let us know how well the abstractions apply to your own particular field.

 We have tried to acheive the (utopian) goal of language independance. The Class Library itself is written in C++, but can be used from C++, C and Fortran (via stub routines). An interpretor based on Tcl/Tk and a Visual Programming Language interface are in the works.

What's New? Dec. 18, 2003.

• First off, I'm very pleased with the design, and I think that the objects and interfaces have proven to be useful. I am not happy with the C++ implementation, and have backed off to a strict C implementation. This has no downsides that I can see. I lose the operator overloading, and polymorphism, but can very easily keep the abstraction and data hiding. So "For me it's C!".
• I've given up trying to convince people that we ought to be discussing the design of numerical software. Not many people seem to care. Hey, I can live with that.
• Instead I'm reduced to leading by example. Therefore I'm happy to be able to point you to two exemplars of this design approach - Multifario and NLPAPI. Multifario is a subroutine library for computing manifolds which are solutions of algebraic or two point boundary value problems. NLPAPI is a subroutine library for defining nonlinear optimization problem, with an interface to Lancelot and IPOPT.
• So, take a look, give them a try. If you're still interested in the C++ implementation (and not looking for tools), or if you've got comments, drop me a note.

What's New? Nov. 15, 2002.

• We made a decision some time ago to stop building the C++ library that was the implementation of this scheme. There are just too many non-math things that needed doing to make it useful (like building object databases and language interfaces). There also seems to be a much greater interest in downloading software than in writing it (which is as it should be), so in order to build a sufficient collection of algorithms we were spending a lot of time writing and wrapping algorithms outside our primary research interests. So instead we are using the approach to implement particular algorithms (in our areas of research), and discontinuing the C+ implementation.

 
• Feel free to look through the web pages, and we would still like to hear from you.

• Installation - We've migrated to the GNU Autoconf package. This takes care of a lot of the system dependancies and makes installation a lot easier. There are still some issues with determining which wrapped packages are installed (and where they can be found).

The Makefiles have been collapsed. Everything in one! (Not sure I'm convinced that's a good idea.)
• Newly wrapped packages
• Shewchuk's Triangle package from Netlib (triangle.shar).
• A new wrapper for computing Voronoi diagrams with Steve Fortune's package from Netlib (sweep2).
• Documentation - Updated to include the new subroutines and classes. It's a long slog guys. Still a lot of documentation to write ....
• Interfaces - Data Explorer is now Open Source. The DX interface is still seriously backlevel. DX uses dynamic loading for its modules, and this is causing a problem with the error handling, as the static initialization isn't getting done. We have to figure out how to create modules in a platform independant way. Anyone have any experience with the GNU libtool package?

We're starting to sketch CORBA, Matlab and Java interfaces. The use of SWIG to generate interfaces is also still on the boards, as is a new look at XML/Java for persistance.
• The ugly truth is that there is more to do than people to do it. We're interrupt driven at the moment. So if there's something you want added or fixed, give a yell .
• Want to help? Wrap something! (Children, pets, any old thing.) If you know how to use a package, it's easy. You've already read the documentation, installed the package on your machine, and figured out how to use it. That's the hard part. The rest is just writing a small set of interface routines.

We've got examples to look at, and are willing to help. The wrapper doesn't have to be in C++, C works just as well, Fortran is close (that's an experiment we'd like to see).

Introduction.

Describes the basic philosophy of the NAO Objects: What it is, what it can do.

Object Primer.

An overview of the objects (Geometric Regions, Functions, and Operators) with which NAO defines.

Glossary.

Definitions of some of the concepts and terms used in this documentation.

User's Guide.

Describes how to write, link and run C++, Fortran and C programs, and how to use the Data Explorer visual programming language, and the Interpretor.

Object Programmer's Guide.

Describes how to implement a custom object, and how to provide the different interfaces.

Class Reference and Subroutine Reference.

Describe each of the objects and subroutines, calling sequences and details of how they function.

Examples.

Illustrate the use of various objects.

List of wrapped packages.

Describes non-NAO tools that have been wrapped with NAO interfaces.

Additional information

• Comments, and questions are welcome, and should be directed to mhender@watson.ibm.com.

[Research home page]

 [ IBM home page | Order | Privacy | ContactIBM | Legal ]