15-864 Coding Tips

In this class, you'll be doing a lot of fairly heavy-duty coding in your language of choice. Since we'd rather you spent time working on the meat of the assignments rather than messing around with library issues, I've constructed this page with some pointers to libraries you may find useful.

General C++

If you're not using these libraries already, you should be. In particular, if you ever catch yourself writing a string class, or allocating an array, or reimplementing quicksort -- well, you're wasing your time.

Standard Template Library: Available for every modern C++ compiler. If you're using Visual Studio v6.0, consider using the STLport implementation, which is considerably better in a number of ways than Microsoft's notoriously broken version (VS.net seems to be better). Documentation can be found here. Particularly useful bits include the vector, string, and map data structures, and the sorting and various binary search algorithms. Note that the hashing algorithms present in the SGI STL (hash_map, hash_set) are not part of the STL standard and therefore not portable. Also, auto_ptrs cannot be used in STL containers!. Use boost smart pointers instead (below). If the STL syntax confuses you, consider taking a look at Scott Meyers' Effective STL.
Boost libraries: Useful stuff that didn't get included in the STL for brevity reasons. The most important bits here are the improved smart_ptr classes, including a container-safe reference-counted pointer and (finally) a proper scoped array. Never leak memory again! I've installed this library in /afs/cs.cmu.edu/academic/class/15864-s04/include so you can just add this to your include path to use it. Note that some of the pieces of this heavily templatized library won't work with Visual Studio 6.0's badly broken compiler; I recommend switching to VS.net if possible.

Numerics

A few libraries that might be helpful.

The VL library: Originally written by CMU's own Andrew Willmott, this library provides convenient small vector classes (3-vectors, 4-vectors) and small matrix classes (3x3 matrices, 4x4 matrices). Documentation is available here. I have installed my own version of this library in /afs/cs.cmu.edu/academic/class/15864-s04/include; the only major differences are
1. My version is entirely contained in the vl namespace. This means that you either need to include the following at the top of your file,
  #include <vl/VLf.h> using namespace vl;
  or else you need to preface function calls and object definitions with vl::, as in vl::Vec3f.
2. My version uses the correct iostream headers (e.g., <iosfwd>) for modern C++ implementations.
Update: I've dropped Win32 and MacOS X versions in /afs/cs/academic/class/15864-s04 also.
Matrix Template Library: Although it can be a pain to get it to compile, this is probably the best free large-matrix (i.e., >3) library available. It can be quite useful for interfacing with e.g. BLAS as it allows you to declare matrices in column-order. Beware, I've recently discovered some odd behavior working with sparse matrices (although the dense matrix stuff is quite solid). Despite the claims on the main page, it is quite slow compared with heavily optimized BLAS implementations (e.g., the Intel MKL). Its main competition appears to be Blitz++, which I have never managed to get to compile. See also the associated Iterative Template Library for solving large sparse systems, but heed my warning about the MTL sparse code.
BLAS: No list of numerical libraries would be complete without this one. These are a collection of Fortran routinges useful for performinc the most basic vector and matrix operations. Although the routines provided may seem quite trivial (dot products, matrix-vector products, etc.), the advantage of switching to BLAS is that you can make huge and instant performance gains by swapping in highly tuned vendor BLAS implementations, such as the Intel Math Kernel Library. There are various free optimized versions as well, including ATLAS and Kazushige Goto's highly efficient implementation (which is in part responsible for the performance of Virginia Tech's Terascale cluster. Those who are turned off by BLAS's moderately obscure Fortran interface can find solace in the (admittedly still complicated) CBLAS extension, which can be found either in its reference implementation or included in the Gnu Scientific Library.
Gnu Scientific Library: A collection of random useful numerical routines. If you feel a need to do some numerical integration or compute zeroes of a cubic, look no further. A lot of these routines duplicate the functionality in the hoary old Numerical Recipes books, with the pretty major advantages of proper 0-based array indexing and the fact that you don't have to enter any code (and the NR folks' license is notoriously restrictive). I've installed the current version of this in /afs/cs/academic/class/15864-s04/include and /afs/cs/academic/class/15864-s04/lib. To use it, just add the appropriate library and include paths and use

-lgsl -lgslcblas

when linking. One caveat: the GSL project used to provide a Windows 2000 precompiled binary on their website. They don't appear to do that any more; while I can't post it on this page for licensing reasons, I've put a version in the course home directory, /afs/cs/academic/class/15864-s04/ for people to use.

Questions? Contact Christopher Twigg.