Predictive Engineering and Computational Sciences. Data Structures and Generic Programming. Roy H. Stogner. The University of Texas at Austin

Transcription

1 PECOS Predictive Engineering and Computational Sciences Data Structures and Generic Programming Roy H. Stogner The University of Texas at Austin November 16, 2012 Stogner Data Structures November 16, / 36

2 Outline 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

3 Computational Complexity 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

4 Computational Complexity Algorithm Scalability Algorithms Input data Series of constant-expense instructions Floating-point operations outweigh integer logic Cache misses outweigh floating-point operations Parallel communication outweighs cache misses... Output data Examples Flag the 10% of N e finite elements with greatest estimated error Do an in-place LU decomposition of a N N dense matrix Stogner Data Structures November 16, / 36

5 Computational Complexity Algorithm Scalability Asymptotic Algorithm Cost Quantify input data size Quantify processor count for parallel algorithms Quantify input norms for iterative numerics Algorithm operation counts are a function of input data sizes Examples N M matrix multiply with M-vector bi A ij x i NM multiplies, (N 1)M adds Bubble sort list of N values Iterate through list Swap any unsorted adjacent pairs Quit when no unsorted pairs found Up to N(N 1) iterations, swaps Stogner Data Structures November 16, / 36

6 Computational Complexity Best-, Average-, Worst-case; Amortized Examples Bubble sort List reverse-sorted: N(N 1) iterations, N(N 1) swaps List already sorted: N 1 iterations, 0 swaps List sorted except first entry: 2(N 1) iterations, < N swaps Appending to a memory-contiguous array Into pre-reserved memory: 1 memory set Requiring new memory: 1 block allocation (of size N + 1), N copies How might we build an array one element at a time with fewer than N(N 1) copies? Stogner Data Structures November 16, / 36

7 Computational Complexity Best-, Average-, Worst-case; Amortized Examples Bubble sort List reverse-sorted: N(N 1) iterations, N(N 1) swaps List already sorted: N 1 iterations, 0 swaps List sorted except first entry: 2(N 1) iterations, < N swaps Appending to a memory-contiguous array Into pre-reserved memory: 1 memory set Requiring new memory: 1 block allocation (of size N + 1), N copies How might we build an array one element at a time with fewer than N(N 1) copies? Block-Allocating Append If pre-reserved memory remains, use it. Otherwise, block allocate 2N memory: for N copies, 1 new element, N 1 pre-reserved slots Stogner Data Structures November 16, / 36

8 Computational Complexity Best-case, Worst-case, Amortized Amortized Block-Allocating Append If pre-reserved memory remains, use it. Otherwise, block allocate 2N memory: for N copies, 1 new element, N 1 reserved slots When the array is of length N with 2 i < N 2 i+1 : N 2 i elements have never been copied 2 i 1 elements have been copied once 2 i 2 elements have been copied twice...etcetera... For fewer than N total copies. Worst-case append cost: N copies, 1 set Amortized append cost: 1 copy, 1 set Stogner Data Structures November 16, / 36

9 Computational Complexity Big-O Notation Cost is some function f(n) of data size. As N goes to infinity, only the highest order components of f matter. Many factors (CPU, language, compiler) multiply performance by a constant, so we ignore constants too. If there exists some constant M and size N 0 such that f(n) M g(n) N > N 0 Then we say f is O (g), of the order of g. Examples Dense LU decomposition is O ( N 3) Balanced octree search is O (log N) General sorting is O (N log N) Stogner Data Structures November 16, / 36

10 Data Structures 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

11 Data Structures Containers Arrays are fast at some things: O (1) lookup by index O (1) amortized append And slow at others: O (N) insert O (N) search by value And incapable of others: lookup by key Stogner Data Structures November 16, / 36

12 Data Structures Container Operations Find the cardinality of the container Iterate from one entry to the next Iterate from one entry to the previous Erase an entry or entries Swap two containers Sequences Push or pop an entry at the front or back Insert an entry at a specific point Special Containers Map from indices to values Map from keys to values Find/count value(s) by index, key, value bound Stogner Data Structures November 16, / 36

13 Data Structures Arrays Contiguous memory, iterate by incrementing pointers, Possible Implementation vectorfloat { float *vectorstart; float *vectorend; int sizereserved; Start pointers point to the front element, or to NULL End pointers point one past the back element Increasing size may require reallocation, invalidate iterators Adding memory before the start would create a deque Stogner Data Structures November 16, / 36

14 Data Structures Lists What if we don t need random-access, but we do need fast inserts? Use scattered memory, iterate by following pointers Possible Implementation listfloatentry { float data; listfloatentry* next; Inserting requires redirecting two next pointers Insertion doesn t invalidate iterators Adding a previous pointer would create a doubly-linked list Deleting requires redirecting the next entry s previous pointer and the previous entry s next pointer Deletion only invalidates iterators pointing to the deleted entry Stogner Data Structures November 16, / 36

15 Data Structures Binary Trees Instead of connecting entries in a single chain, connect them in a sorted tree NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL Iteration ascends/descends tree Sequence can be automatically sorted! If tree is automatically balanced: Insertion, deletion, search are O (log N) Stogner Data Structures November 16, / 36

16 Data Structures Sets, Multisets Binary trees (among other options) make it easy to implement an ordered set (with unique elements) or multiset (with potentially multiple copies of elements): Items are sorted upon inserting Duplicates can be cheaply omitted or retained upon inserting Unions, intersections, set differences are cheaper after sorting Examples Collect set of all Nodes connected to local Elements Take union of sets of boundary ids located on multiple processors Stogner Data Structures November 16, / 36

17 Data Structures Maps, Multimaps Definition Take a set of pairs of key, value data. Define sorting operation to be a comparison of keys Duplicate keys can be cheaply omitted or retained upon insertion With C++ operator overloading this gives us a structure that looks like an array, but isn t limited to integer keys or dense storage phone_number["john Smith"] = " "; Examples Multimap of all boundary ids associated with each Finite Element side Map from degree of freedom indices to hanging node constraint equations Stogner Data Structures November 16, / 36

18 Data Structures Hash Tables Instead of storing a pointer, calculate an index from a hash of some key data. Store a pointer to a list (usually empty) of keys at each index value. keys John Smith Lisa Smith Sandra Dee hash function buckets : : Insertion, Deletion, Search average O (1) cost Only unordered iteration is possible Storing key/value pairs in a hash table, with only keys considered by the hash function, gives us unordered maps, multimaps. Stogner Data Structures November 16, / 36

19 Template Programming 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

20 Template Programming Cut and Paste Code Example VectorFloat { float dot(const VectorFloat& v) const { float r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; float* data; Stogner Data Structures November 16, / 36

21 Template Programming Cut and Paste Code Example VectorFloat { float dot(const VectorFloat& v) const { float r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; float* data; VectorDouble { Stogner Data Structures November 16, / 36

22 Template Programming Cut and Paste Code Example VectorFloat { float dot(const VectorFloat& v) const { float r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; float* data; VectorDouble { VectorComplexDouble { Stogner Data Structures November 16, / 36

23 Template Programming Cut and Paste Code Example VectorFloat { float dot(const VectorFloat& v) const { float r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; float* data; VectorDouble { VectorComplexDouble { VectorTendonitis { Stogner Data Structures November 16, / 36

24 Template Programming Cut and Paste Code Example VectorFloat { float dot(const VectorFloat& v) const { float r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; float* data; VectorDouble { VectorComplexDouble { VectorTendonitis { Never ever do this. Stogner Data Structures November 16, / 36

25 Template Programming Data Type Independence: Object Oriented Programming Example Create an abstract interface Number { virtual Number& operator+=(const Number& n) = 0; // Pure virtual Stogner Data Structures November 16, / 36

26 Template Programming Data Type Independence: Object Oriented Programming Example Number { virtual Number& operator+=(const Number& n) = 0; // Pure virtual Create an abstract interface Derive concrete subes from it FloatNumber : public Number { DoubleNumber : public Number { Stogner Data Structures November 16, / 36

27 Template Programming Data Type Independence: Object Oriented Programming Example Number { virtual Number& operator+=(const Number& n) = 0; // Pure virtual FloatNumber : public Number { virtual Number& operator+=(const Number& n) { datum += n.data(); return *this; } float datum; Create an abstract interface Derive concrete subes from it Implement the interface s functions in each sub Stogner Data Structures November 16, / 36

28 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { virtual Number& operator+=(const Number& n) { datum += n.data(); return *this; } float datum; Create an abstract interface Derive concrete subes from it Implement the interface s functions in each sub Hold pointers or references to the base VectorNumber { Number** data; Stogner Data Structures November 16, / 36

29 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Create an abstract interface Derive concrete subes from it Implement the interface s functions in each sub Hold pointers or references to the base Write code to use the interface Stogner Data Structures November 16, / 36

30 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Stogner Data Structures November 16, / 36

31 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Stogner Data Structures November 16, / 36

32 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Works correctly Stogner Data Structures November 16, / 36

33 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Works correctly Defines concept relations Number is an Abstract Base Class FloatNumber is-a Number Stogner Data Structures November 16, / 36

34 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Works correctly Defines concept relations Number is an Abstract Base Class FloatNumber is-a Number Heterogenous containers! data[0] can be double, data[1] can be complex... Stogner Data Structures November 16, / 36

35 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Works correctly Defines concept relations Number is an Abstract Base Class FloatNumber is-a Number Heterogenous containers! data[0] can be double, data[1] can be complex... Disadvantages: Stogner Data Structures November 16, / 36

36 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Works correctly Defines concept relations Number is an Abstract Base Class FloatNumber is-a Number Heterogenous containers! data[0] can be double, data[1] can be complex... Disadvantages: Can require shim es A float isn t a FloatNumber! Stogner Data Structures November 16, / 36

37 Template Programming Data Type Independence: Object Oriented Programming Example Number { FloatNumber : public Number { VectorNumber { Number dot(const VectorNumber& v) const { Number r = 0; for(int i = 0; i!= size; ++i) r += (*data)[i] * v[i]; return r; } Number** data; Advantages: Works correctly Defines concept relations Number is an Abstract Base Class FloatNumber is-a Number Heterogenous containers! data[0] can be double, data[1] can be complex... Disadvantages: Can require shim es A float isn t a FloatNumber! Slow as hell Fragmented dynamic memory Virtual function calls for every FLOP! Stogner Data Structures November 16, / 36

38 Template Programming Data Type Independence: Generic Programming Template arguments can be data types Example template <typename T> Stogner Data Structures November 16, / 36

39 Template Programming Data Type Independence: Generic Programming Example Template arguments can be data types Class data members can depend on template argument template <typename T> NumericVector { T* data; Stogner Data Structures November 16, / 36

40 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; Template arguments can be data types Class data members can depend on template argument Class methods can depend on template argument Stogner Data Structures November 16, / 36

41 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; Template arguments can be data types Class data members can depend on template argument Class methods can depend on template argument Templated es can be instantiated with plain data types NumericVector<float> floatvec; Stogner Data Structures November 16, / 36

42 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; Template arguments can be data types Class data members can depend on template argument Class methods can depend on template argument Templated es can be instantiated with plain data types... or with other instantiated templated types Stogner Data Structures November 16, / 36

43 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Template arguments can be data types Class data members can depend on template argument Class methods can depend on template argument Templated es can be instantiated with plain data types... or with other instantiated templated types... or with other instantiations of themselves! Stogner Data Structures November 16, / 36

44 Template Programming Data Type Independence: Generic Programming Example Advantages template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Stogner Data Structures November 16, / 36

45 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; Advantages Works with existing types NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Stogner Data Structures November 16, / 36

46 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; Advantages Works with existing types Functions can be inlined, not just virtual NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Stogner Data Structures November 16, / 36

47 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; Advantages Works with existing types Functions can be inlined, not just virtual Intermediate calculation types can be implicit NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Stogner Data Structures November 16, / 36

48 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Advantages Works with existing types Functions can be inlined, not just virtual Intermediate calculation types can be implicit Disadvantages Makes assumptions about input types Is that NumericVector operator* an element by element multiplication or a dot product? Stogner Data Structures November 16, / 36

49 Template Programming Data Type Independence: Generic Programming Example template <typename T> NumericVector { T dot(const NumericVector<T>& v) const { T r = 0; for(int i = 0; i!= size; ++i) r += data[i] * v[i]; return r; T* data; NumericVector<float> floatvec; NumericVector<complex<double> > complexdoublevec; NumericVector<NumericVector<float> > floatmatrix; Advantages Works with existing types Functions can be inlined, not just virtual Intermediate calculation types can be implicit Disadvantages Makes assumptions about input types Is that NumericVector operator* an element by element multiplication or a dot product? Functions are undefined until instantiation Compile-time bugs go undetected until triggered Stogner Data Structures November 16, / 36

50 Standard Template Library 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

51 Standard Template Library STL Containers What s better than reusing your own code instead of rewriting it? Stogner Data Structures November 16, / 36

52 Standard Template Library STL Containers What s better than reusing your own code instead of rewriting it? Using someone else s code instead of rewriting it. #include <list> #include <set> #include <vector> #include <unordered_map> // C++11 using namespace std; typedef list< pair< double, map< string, NumericVector<Number> >>> solution_history_type; Stogner Data Structures November 16, / 36

53 Standard Template Library STL Container Operations Operator overloading makes vectors, maps look like arrays. Class methods give access to more advanced operations. vector<float> weights(12, 1.0); // Creates a dozen 1.0 values weights[5] *= 2; // Doubles the sixth value weights.resize(24, 0.0); // Let s make that two dozen, // with new entries zero map<elem *, double> err; // Any data can be a key err[my_element] = 1e-6; for (auto i = err.begin(); i!= err.end; ++i) *i = 1.0; // Not a simple pointer dereference if (err.find(other_element) == err.end()) I_found_it = false; // Search without inserting Stogner Data Structures November 16, / 36

54 Generic Algorithms 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

55 Generic Algorithms Duck Typing So we can duct tape our templated type to any type T that behaves like we expect math to behave? Is that safe? Stogner Data Structures November 16, / 36

56 Generic Algorithms Duck Typing So we can duct tape our templated type to any type T that behaves like we expect math to behave? Is that safe? If it walks like a duck, quacks like a duck, looks like a duck, it must be a duck. Stogner Data Structures November 16, / 36

57 Generic Algorithms Concepts Container types may be very different Each exposes homologous methods under the same names begin(), end() of containers ++,, ==, etc. operators on iterators Containers may support different Concepts Is it a sequence? Does it associate keys and values? Iterators may support different Concepts Can you increment it? Can you also decrement it? Can you read from it? Can you write to it? Algorithms support any containers and iterators that implement the required concepts. User-defined data structures work as soon as they support the right semantics Stogner Data Structures November 16, / 36

58 Generic Algorithms Iterators Iterator types already discussed: vector::iterator increments a pointer map::iterator walks a tree More complicated iterator types: istream::iterator reads from terminal, file, network, etc. ostream::iterator writes to any of the above reverse iterator goes backwards instead of forwards mesh inserter iterator adds Node, Elem, or Point objects to a Mesh (not in the STL, but works with it as an Output Iterator) Stogner Data Structures November 16, / 36

59 Generic Algorithms Ranges Containers and subsets of containers can be specified as ranges, pairs of iterators. First iterator identifies first item in range Second iterator identifies one past last item in range. First==Last for empty ranges. Simple examples my_set.insert(my_list.begin(), my_list.end()); iter = find(my_vec.begin(), my_vec.end(), element); Stogner Data Structures November 16, / 36

60 Generic Algorithms Algorithms find was our first generic algorithm: linear search through any range (and so through any container). template <typename Iter, typename Value> Iter find (Iter first, Iter last, Value v) { while (first!= last && *first!= v) first++; return first; } STL includes this and others: sort(vec.begin(), vec.end()); copy (vec.begin(), vec.end(), ostream_iterator<int>(cout, "\n" cout << accumulate(values.begin(), values.end(), 0.0); vec.erase(remove(vec.begin(), vec.end(), 1), myvec.end()); Stogner Data Structures November 16, / 36

61 Generic Algorithms Functors Defining functions and/or objects which behave like functions can add meat to the standard algorithms. Predicates define whether or not a value meets some user-specified condition: bool is_positive (int val) { return (v > 0); } int number_of_positives = count_if(vec.begin(), vec.end(), is_ Examples Predicate iterators: libmesh elements begin() becomes active elements begin() or local elements begin() or active local elements begin() after adding tests for finite element refinement and partitioning Selective operations: remove if() strips elements from a range based on a predicate test Stogner Data Structures November 16, / 36

62 Generic Algorithms Functors Functors can modify data as well, transforming input ranges to output ranges (in place if requested): transform(text.begin(), text.end(), text.begin(), tolower); Replacing iteration and loop bodies with algorithms and functors adds more flexibility: Singlethreaded code can be compiler-optimized Template specialization / function overloading Multithreaded code can take functors and ranges Intel Threaded Building Blocks Stogner Data Structures November 16, / 36

63 Choosing Data Structures 1 Computational Complexity 2 Data Structures 3 Template Programming 4 Standard Template Library 5 Generic Algorithms 6 Choosing Data Structures Stogner Data Structures November 16, / 36

64 Choosing Data Structures What the STL Won t Tell You Complexity Constants // N set insertions, each O(log(N_unique)) or better set sorted_set(vec.begin(), vec.end()); // O(N log(n)) sorting algorithm sort(vec.begin(), vec.end()); // O(N) renumbering and erasure vec.erase(unique(vec.begin(), vec.end() Which is faster? Are further sort/insert operations needed? Search operations? Is the ratio N unique /N bounded below? Will a partial sort do? Stogner Data Structures November 16, / 36

65 Choosing Data Structures What the STL Won t Tell You Complexity Constants What compiler are you using? Optimization level? Debugging level? C++11 move constructors, unordered set? STL can be optimized.. What processor are you using? How important is vectorization? How bad are cache misses? What data are you using? O (f(n)) is less critical for small N Worst-case hash table, unbalanced tree performance is atrocious In hot spots, use typedef & template specializations to enable easy switching between containers; benchmark each! Stogner Data Structures November 16, / 36

66 Choosing Data Structures What the STL Won t Do For You Multidimensional Data Structures Multi-dimensional arrays vector<vector<t> > fakes a[i][j] Poorer cache locality? Individually resizeable rows?? Eigen, Boost, Blitz++, etc. third-party options Graphs Boost, GTL, VTGL, CGTL? General Trees B-tree, other logical structures Quadtree, Octree, etc. spatial structures Non-general Container Methods vector isn t a numeric data type valarray numeric containers aren t STL-conforming Sub container types? STL containers have non-virtual destructors Stogner Data Structures November 16, / 36