J>Я когда туда заглядываю, мне сразу закрыть хочется. Такое ощущение, что код был создан авто-генератором каким-то, форматирование неудобное, имена жутко запутанные, структура довольно сложная. Кто-то в этом разбирается? Я уж про буст не говорю, там пока разберешься во всех typedef, ifdef, все ногти перекусаешь

template <class T, class Policy>
inline int iround(const T& v, const Policy& pol)
{
   BOOST_MATH_STD_USING
   T r = boost::math::round(v, pol);
   if((r > (std::numeric_limits<int>::max)()) || (r < (std::numeric_limits<int>::min)()))
      return static_cast<int>(policies::raise_rounding_error("boost::math::iround<%1%>(%1%)", 0, v, 0, pol));
   return static_cast<int>(r);
}
template <class T>
inline int iround(const T& v)
{
   return iround(v, policies::policy<>());
}

template <class T, class TargetType>
inline T raise_rounding_error(
           const char* , 
           const char* , 
           const T& val, 
           const TargetType&,
           const  ::boost::math::policies::rounding_error< ::boost::math::policies::errno_on_error>&)
{
   errno = ERANGE;
   // This may or may not do the right thing, but the user asked for the error
   // to be silent so here we go anyway:
   return std::numeric_limits<T>::is_specialized ? (val > 0 ? (std::numeric_limits<T>::max)() : -(std::numeric_limits<T>::max)()): val;
}

Caution
There is a danger of One-Definition-Rule violations if you add ad-hoc macros to more than one source files: these must be set the same in every translation unit.

template<class _Tp>
class vector
{
public:
  typedef _Tp value_type; // что не так может быть с T, что его меняют на _Tp?

  void push_back(const value_type& __x);  // что не так может быть с x, что его нужно заменять на __x?
};

W>Да пожалуй я тут слишком преувеличил проблему. Хотя при совпадении имён может компилироваться код, который компилироваться не должен — то есть если stl использует имена с __, а программа не использует, то допустить опечатку, приводящую к ложному совпадению будет сложнее

namespace std
{
  namespace aux
  {
    template<class It> void insertion_sort(It i, It j) { ..... }
    template<class It> void quick_sort    (It i, It j) { ..... }
  }

  // интерфейсная функция
  template<class It>
  void sort(It i, It j)
  {
    if(distance(i,j) < some_treshold)
      aux::insertion_sort(i,j);
    else
      aux::quick_sort(i,j);
  }
}

namespace aux // откуда мы знали, что это имя задействовано в STL?
{
  struct bar {...};

  void quick_sort(bar* x, bar* y) // "упорядочим два элемента по-быстрому" - откуда мы знали, что это имя значит что-то иное в std::aux ?
  {
    if(x->key > y->key) { quick_swap(x->key, y->key); quick_swap(x->value, y->value); }
  }
}

К>namespace aux // откуда мы знали, что это имя задействовано в STL?
К>{
К>  struct bar {...};

К>  void quick_sort(bar* x, bar* y) // "упорядочим два элемента по-быстрому" - откуда мы знали, что это имя значит что-то иное в std::aux ?
К>  {
К>    if(x->key > y->key) { quick_swap(x->key, y->key); quick_swap(x->value, y->value); }
К>  }
К>}
К>

К>namespace std
К>{
К>  namespace aux
К>  {
К>    template<class It> void insertion_sort(It i, It j) { ..... }
К>    template<class It> void quick_sort    (It i, It j) { ..... }
К>  }

К>  // интерфейсная функция
К>  template<class It>
К>  void sort(It i, It j)
К>  {
К>    if(distance(i,j) < some_treshold)
К>      aux::insertion_sort(i,j);
К>    else
К>      aux::quick_sort(i,j);
К>  }
К>}
К>

namespace aux // откуда мы знали, что это имя задействовано в STL?
{
  struct bar {...};

  void quick_sort(bar* x, bar* y) // "упорядочим два элемента по-быстрому" - откуда мы знали, что это имя значит что-то иное в std::aux ?
  {
    if(x->key > y->key) { quick_swap(x->key, y->key); quick_swap(x->value, y->value); }
  }
}

namespace std
{
  namespace aux
  {
    template<class It> void quick_sort    (It i, It j) { ..... }
  }

  // интерфейсная функция
  template<class It>
  void sort(It i, It j)
  {
      aux::quick_sort(i,j); // это однозначно std::aux::quick_sort, так как aux продикларирована до и находится внутри
  }
}

  aux::bar* pA = NULL;
  aux::bar* pB = NULL;
  std::sort(pA, pB); // вызовет std::aux::quick_sort

  using namespace std;
  using namespace std::aux;
  ::aux::bar* pA = NULL;
  ::aux::bar* pB = NULL;
  quick_sort(pA, pB); // вызовет ::aux::quick_sort
  quick_sort(NULL, NULL); // вызовет std::aux::quick_sort

#include <cstdio>

namespace aux {
    struct foo {};
    void quick_sort(foo* f1, foo* f2) { printf("user-defined function\n"); }
}

namespace sss {
    namespace aux {
        template<class T> void quick_sort(T i, T j) { printf("standard quick sort\n"); }
        template<class T> void sort_impl(T i, T j) { quick_sort(i,j); } // мы же, якобы, внутри родного неймспейса, - не квалифицируем имя
    }

    template<class T> void sort(T i, T j) { aux::sort_impl(i,j); } // здесь имя квалифицированное, компилятор ищет в нужном пространстве
}

int main() {
    aux::foo p,q;
    sss::sort(&p, &q); // "user-defined function"
}

#include <cstdio>

namespace sss {
    namespace aux {
        template<class T> void quick_sort(T i, T j) { printf("standard quick sort\n"); }
        template<class T> void sort_impl(T i, T j) { quick_sort(i,j); } // мы же, якобы, внутри родного неймспейса, - не квалифицируем имя
    }

    template<class T> void sort(T i, T j) { aux::sort_impl(i,j); } // здесь имя квалифицированное, компилятор ищет в нужном пространстве
}

namespace aux {
    struct foo {};
    void quick_sort(foo* f1, foo* f2) { printf("user-defined function\n"); }
}

int main() {
    aux::foo p,q;
    sss::sort(&p, &q); // "user-defined function"
}