17
$\begingroup$

In the numerical methods literature, many research papers consist of a description of a new algorithmic variation, followed by a few test problems comparing the new method with one or two existing methods. This makes it difficult to determine

  • How the new method would perform on other problems of interest
  • How the new method would compare to yet other existing methods

Of course, both of these questions are usually critical for someone deciding whether to adopt the new method. In order to improve this situation, it seems desirable to, if possible, get people to run a large set of test problems (see this question) with their method and catalog the results in a database for comparison with other methods. A scientist or engineer could then query the database, perhaps indicating what solution/problem characteristics are most important to them (accuracy, efficiency, qualitative properties, etc.), and get a quantitative comparison of the performance of all methods in the database.

I realize that there are many difficulties in implementing this idea (chiefly: getting people to actually run all those problems, and measuring computational cost). But my question is: Does there exist such a database of results? (say in some particular subfield) or has an approach like this been implemented anywhere?

Both of the answers posted so far are about databases of problems. I'm asking about databases of results.

$\endgroup$
9
$\begingroup$

Of the criteria you've specified, I think the closest project that I know of would be the University of Florida sparse matrix collection. People routinely use this data set to compare sparse linear algebra solvers, and you can filter by application, number of nonzeros, dimensions of matrix, and so on with a really nice web interface, MATLAB interface, or Java GUI. I've seen tables of these problems listed in papers along with solver run time comparisons to 4 to 8 linear algebra solvers.

I agree that it would be useful to compile such databases, and furthermore, I think the UF sparse matrix collection approach for compiling the data is an excellent one, and would make a great start for anyone thinking about realizing this idea. Running all of the problems, in practice, doesn't seem like a major difficulty as long as you can get access to all of the solvers; if you have access to the solvers, and a reliable standard reference machine with all of the necessary software installed, then it should be a matter of running a script and collecting the data. The difficulty, in my mind, would be getting people to give you their software, if it isn't open source. If it's commercial, you could buy it, or even possibly get people to donate the software, which is something I know that happens in the optimization community when people are building portable software interfaces for commercial codes, such as in the COIN-OR project. But if it's research software that is neither commercial nor open source, then you need to convince people to buy into the endeavor, and they may not trust a third party to assess their software fairly.

I also know that in optimization, there are downloadable databases of problems (CUTEr comes to mind) and books of test problems for optimization. I have seen people (for instance, I'm specifically thinking of a talk by Ruth Misener at AIChE 2011) compare their optimization solver versus other solvers on databases of problems in presentations; I'm not sure what gets released publicly. I know that there's a tradition in optimization for comparison on a large scale (many solvers, many problems); I just don't think there's an online database available.

Another thing that I think is important is that we distinguish here between methods and software implementations. In scientific computing, we all talk about which methods are faster or slower based on things like computational complexity metrics, or our experiences with various problems. When it comes to measuring computational time quantitatively, however, unless one counts the number of FLOPs in a particular algorithm, one has to implement the algorithm in software and then measure the performance in some way (memory usage, wall clock time of execution, etc.). It makes sense to assess the performance of a method when looking at computational complexity or FLOP counts, because we don't need an implementation to measure such things, but the moment we're interested in actual wall clock run times, talking about methods is only useful as an abstract, colloquial device. (For instance, sparse direct solvers are fast on sufficiently small sparse problems with good fill-reducing heuristics, such as nested dissection.)

I bring up this distinction between methods and software because in such a database, I could also see the possibility of tracking the improvement in software over time. So, for instance, with something like, say, PETSc, or PyCLAW, or whatever software is being tested, it would be interesting to see what problems are affected positively (or negatively!) by upgrades in the software. This could be useful for researchers trying to decide if it's worth any potential costs in money and manpower to upgrade their codes. Another reason such a distinction is important is because a good method can be implemented badly; I think this possibility contributes to the reticence people sometimes have in sharing their research codes. A database of implementations would be able to distinguish between good and bad implementations of the same method (or types of methods).

I think whatever comes of this idea (and I hope something comes of it, and would be willing to contribute after my PhD), it's important to emphasize that distinction between software and methods, because if we're running test problems, we're going to be posting results for software.

$\endgroup$
  • 2
    $\begingroup$ I like your comments very much, and you raise an important point. As I'm sure you're aware, the links you give are to databases of problems, not of results. $\endgroup$ – David Ketcheson Jan 23 '12 at 20:48
  • $\begingroup$ Those were the closest things I could find. I tried hunting around for databases of results, because I think you raise a really important idea, but I couldn't find any. Perhaps this is an important new project? $\endgroup$ – Geoff Oxberry Jan 23 '12 at 21:02
  • $\begingroup$ Thanks; I agree, and these are useful as "closest existing approximations" as you say. I'm indeed considering this (with some others who would lend it more credibility) as a new project. I'm very glad that you're interested! We can discuss it elsewhere, as SE is discussion-averse. $\endgroup$ – David Ketcheson Jan 24 '12 at 6:23
4
$\begingroup$

There has been an attempt to create a list of "difficult" integrals to compute numerically (see papers by Walter Gautschi, Robert Piessens and others) but no formal database.

In the field of ODEs, there is the IVP test set, a test set for Initial Value Problems.

$\endgroup$
  • $\begingroup$ actually I'm asking about databases of computed results, not databases of problems. $\endgroup$ – David Ketcheson Jan 23 '12 at 20:47
  • 1
    $\begingroup$ @DavidKetcheson It contains driver code to automate computing the results yourself. $\endgroup$ – Jed Brown Jan 23 '12 at 23:12
  • $\begingroup$ Great! Although I'd love to see an actual database where results are stored (in addition, of course, to the ability to recompute them), this is the closest thing I've seen to what I was thinking of. $\endgroup$ – David Ketcheson Jan 24 '12 at 6:21
3
$\begingroup$

I'm not familiar with such a database, but I think it would be very difficult to define in a useful way. A better system, in my opinion, is to release the code in a runnable form so that the user can extend to test as comprehensively as they like. In terms of community repositories, the IVP test suite that GertVdE mentions also contains driver code to run several published ODE/DAE solvers on the test problems. In my publications, I try to release the code and all scripts used to create the analyze the output data and create the plots and tables appearing in the paper.

$\endgroup$
  • 1
    $\begingroup$ Small quibble: this is more of a comment than an answer. I appreciate the critical thinking, though. I would like to see people do both. Why make me install and run your code just so that I can plot your results against mine? And then you can claim that I didn't set the right options? Anyway, I (meaning the typical researcher) just won't do it because it's too much work. But if all I had to do was read in a data file, I might be willing. $\endgroup$ – David Ketcheson Jan 24 '12 at 6:17
1
$\begingroup$

The Computational Aeroacoustics Workshop on Benchmark Problems has a similar goal in mind for aeroacoustic problems. They first present a set of benchmark problems ahead of time, and have people solve them using their own methods and compare the results. For example, here's the fourth meeting's proceedings: http://www.archive.org/details/nasa_techdoc_20040182258

Although, from what I can tell they do not compare how efficient their codes are against each other, they mainly look at accuracy.

$\endgroup$
  • $\begingroup$ Interesting! Is there a database of solutions? Or how exactly do they compare results? $\endgroup$ – David Ketcheson Jan 24 '12 at 16:36
  • $\begingroup$ The "database" is in the report I posted. At the very end of the paper there is a section titled "Solution Comparisions." There's only been four meetings for this, and the last one was in 2004. I wish there was more of a push to get these types of things online like you propose. $\endgroup$ – James Custer Jan 24 '12 at 19:07
1
$\begingroup$

Within earthquake modeling there has been several of these sorts of efforts. The ones that come to mind are the dynamic rupture simulation project and the source inversion project (http://eqsource.webfactional.com/wiki/). Both of these provides physical problems to solve and are agnostic (at some level) concerning the methods employed. Really these projects are about getting the domain specific modelers to compare with one another, not really a general set of test problems for every numerical pdes method. But you can compare with others results, and this has revealed a lot of problems with many codes.

One possibility to look at would be the madagascar project, which has been developed within the seismic imaging world but claims to be quite general purpose.

$\endgroup$
  • $\begingroup$ Madagascar is an excellent example. Thank you! $\endgroup$ – Jack Poulson Feb 3 '12 at 15:30

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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