1.5 Compiling with Blitz++

1.5.1 Header files

Blitz++ follows an X-windows style convention for header files. All headers are referred to with a prefix of blitz. For example, to use the Array<T,N> class, one needs to include <blitz/array.h> instead of just <array.h>. To make this work, the main Blitz++ directory must be in your include path. For example, if Blitz++ was installed in /software/Blitz++, you will need to compile with -I /software/Blitz++.

If you have root privileges, you may want to put in a symbolic link from the standard include path (e.g. /usr/include/blitz/) to the blitz directory of the distribution. This will allow you to omit the -I ... option when compiling.

1.5.2 Linking to the Blitz++ library

The Blitz++ library file libblitz.a contains a few pieces of global data. You should ensure that the lib subdirectory of the Blitz++ distribution is in your library path (e.g. -L/usr/local/blitz-0.5/lib) and include -lblitz on your command line. If you use math functions, you should also compile with -lm.

1.5.3 An example Makefile

Here is a typical skeletal Makefile for compiling with Blitz++ under gcc:

# Path where Blitz++ is installed
BZDIR = /usr/local/blitz

CXX = g++

# Flags for optimized executables
# CXXFLAGS = -O2 -I$(BZDIR) -ftemplate-depth-30

# Flags for debugging
CXXFLAGS = -ftemplate-depth-30 -g -DBZ_DEBUG -I$(BZDIR)

LDFLAGS =
LIBS = -L$(BZDIR)/lib -lblitz -lm

TARGETS = myprogram1 myprogram2

.SUFFIXES: .o .cpp

.cpp.o:
    $(CXX) $(CXXFLAGS) -c $*.cpp

$(TARGETS):
    $(CXX) $(LDFLAGS) $@.o -o $@ $(LIBS)

all:
    $(TARGETS)

myprogram1:      myprogram1.o
myprogram2:      myprogram2.o

clean:
    -rm -f *.o $(TARGETS)

There are more example makefiles in the examples, testsuite, and benchmarks directories of the distribution.

1.5.4 Explicit instantiation

It is not possible to do explicit instantiation of Blitz++ arrays. If you aren’t familiar with explicit instantiation of templates, then this fact will never bother you.

The reason is that explicit instantiation results in all members of a class template being instantiated. This is not the case for implicit instantiation, in which only required members are instantiated. The Array<T,N> class contains members which are not valid for all types T: for example, the binary AND operation &= is nonsensical if T=float. If you attempt to explicitly instantiate an array class, e.g.

template class Array<float,3>;

then you will be rewarded with many compile errors, due to methods such as &= which are nonsensical for float.

As some consolation, explicit instantiation would not be much help with Blitz++ arrays. The typical use for explicit instantiation is to instantiate all the templates you need in one compilation unit, and turn off implicit instantiation in the others – to avoid duplicate instantiations and reduce compile times. This is only possible if you can predict ahead of time what needs instantiation. Easy for simple templates, but impossible for classes like Array. Almost every line of code you write using Array will cause a different set of things to be implicitly instantiated.