$ g++ vector.cpp vector_dimension_exception.cpp test.cpp
/usr/bin/ld: Undefined symbols:
trace::vector<double>::magnitude() const
collect2: ld returned 1 exit status

#ifndef _TRACE_VECTOR
#define _TRACE_VECTOR

#include "vector_dimension_exception.h"
#include <vector>

namespace trace
{
  template< typename T>
  class vector : public std::vector< T >
  {
  public:
    T magnitude() const;
    T dot_product(const vector< T > &) const throw(vector_dimension_exception);
  };
}

#endif

#include "vector.h"
#include <cmath>

template< typename T >
T trace::vector< T >::magnitude() const
{
  T squares_sum = 0;
  for (int t = 0; t < this->size(); ++ t)
    squares_sum += std::exp(log((*this)[t]) * 2);
  return std::exp(log(squares_sum) * 1 / 2);
}

template< typename T >
T trace::vector< T >::dot_product(const vector< T > &value) const throw(vector_dimension_exception)
{
  if (this->size() != value.size())
    throw vector_dimension_exception();
  T dot_product = 0;
  for (int t = 0; t < this->size(); ++ t)
    dot_product += this->at(t) * value.at(t);
  return dot_product;
}

#include <iostream>
#include "vector.h"

int main()
{
  trace::vector< double > vector1;
  vector1.push_back(3);
  vector1.push_back(4);
  std::cout << vector1.magnitude() << std::endl;
  trace::vector< double > vector2;
  vector2.push_back(5);
  vector2.push_back(12);
  std::cout << vector2.magnitude() << std::endl;
  return 0;
}

// Warning:  following not fed to a compiler.
//   It may include errors.  It illustrates the idea only

namespace trace
{
    template <typename T> magnitude(const std::vector<T> &, T initialvalue = 0);
}

template<typename T>
T trace::magnitude(const std::vector<T> &v, T initialvalue)
{
    typename std::vector<T>::const_iterator i, end = v.end();
    for (i = v.first(); i != end; ++i)
    {
         // warning:  potential for overflow here.
        initialvalue += (*i) * (*i);
    }
    return std::sqrt(initialvalue);
}

// Warning:  following not fed to a compiler.
//    It may include errors.  It illustrates the idea only

namespace trace
{
    template <typename InputIterator, typename T> magnitude(InputIterator first, InputIterator last, T initialvalue = 0);
}

template<typename InputIterator, typename T>
T trace::magnitude(InputIterator first, InputIterator last, T initialvalue)
{
    // implement the function here in terms of arguments 
    while (first != last)
    {
         // warning:  potential for overflow here.
        initialvalue += (*first) * (*first);
        ++first;
    }
    return std::sqrt(initialvalue);
}

int main()
{
    std::vector<double> x;
      // add some elements to x
    double mag_x = trace::magnitude(x.begin(), x.end());

       // use the first version of the algorithm I gave above

    double mag_x2 = trace::magnitude(x);

    //  I can also do this, if it makes sense, which can't be done with
    //   a derived class

    std::list<double> y;
      // add some elements to y
    double mag_y = trace::magnitude(y.begin(), y.end());

}

    Base *b = new Derived;
    delete b;     // undefined behaviour here

#include <iterator>
#include <stdexcept>
#include <numeric>
#include <cmath>
#include <functional>
#include <algorithm>

namespace trace
{
  template< typename InIter, typename T >
  T length(InIter first, InIter last)
  {
    return std::inner_product< InIter, InIter, T >(first, last, first, 0);
  }
  
  template< typename InIter, typename T >
  T magnitude(InIter first, InIter last)
  {
    return std::sqrt(length< InIter, T >(first, last));
  }
  
  template< typename InIter, typename OutIter, typename T >
  OutIter normalize(InIter first, InIter last, OutIter result)
  {
    return std::transform(first, last, result, std::bind2nd(std::divides< T >(), magnitude< InIter, T >(first, last)));
  }
  
  template< typename InIter1, typename InIter2, typename T >
  T dot_product(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2)
  {
    if (std::distance< InIter1 >(first1, last1) != std::distance< InIter2 >(first2, last2))
      throw std::domain_error("std::distance(first1, last1) != std::distance(first2, last2)");
    return std::inner_product< InIter1, InIter2, T >(first1, last1, first2, 0);
  }
}

typedef trace::dot_product< std::vector< double >::iterator, std::vector< double >::iterator, double > dot_product3d;