namespace boost {
  namespace numeric {
    template<typename T> struct default_;
    template<typename T> struct one;
    template<typename T> struct zero;
    template<typename T> struct one_or_default;
    template<typename T> struct zero_or_default;

    static op::plus const & plus;
    static op::minus const & minus;
    static op::multiplies const & multiplies;
    static op::divides const & divides;
    static op::modulus const & modulus;
    static op::greater const & greater;
    static op::greater_equal const & greater_equal;
    static op::less const & less;
    static op::less_equal const & less_equal;
    static op::equal_to const & equal_to;
    static op::not_equal_to const & not_equal_to;
    static op::assign const & assign;
    static op::plus_assign const & plus_assign;
    static op::minus_assign const & minus_assign;
    static op::multiplies_assign const & multiplies_assign;
    static op::divides_assign const & divides_assign;
    static op::modulus_assign const & modulus_assign;
    static op::unary_plus const & unary_plus;
    static op::unary_minus const & unary_minus;
    static op::complement const & complement;
    static op::logical_not const & logical_not;
    static op::min_assign const & min_assign;
    static op::max_assign const & max_assign;
    static op::average const & average;
    static op::as_min const & as_min;
    static op::as_max const & as_max;
    static op::as_zero const & as_zero;
    static op::as_one const & as_one;
    template<typename To, typename From> 
      lazy_disable_if< is_const< From >, mpl::if_< is_same< To, From >, To &, To > >::type 
      promote(From & from);
    template<typename To, typename From> 
      mpl::if_< is_same< To const, From const  >, To const &, To const  >::type 
      promote(From const & from);
    namespace functional {
      template<typename Left, typename Right> struct left_ref;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct plus_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct plus;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct minus_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct minus;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct multiplies_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct multiplies;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct divides_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct divides;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct modulus_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct modulus;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct greater_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct greater;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct greater_equal_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct greater_equal;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct less_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct less;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct less_equal_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct less_equal;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct equal_to_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct equal_to;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct not_equal_to_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct not_equal_to;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct assign_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct assign;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct plus_assign_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct plus_assign;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct minus_assign_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct minus_assign;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct multiplies_assign_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct multiplies_assign;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct divides_assign_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct divides_assign;
      template<typename Left, typename Right, typename EnableIf = void> 
        struct modulus_assign_base;
      template<typename Left, typename Right, 
               typename LeftTag = typename tag<Left>::type, 
               typename RightTag = typename tag<Right>::type> 
        struct modulus_assign;
      template<typename Arg, typename EnableIf = void> struct unary_plus_base;
      template<typename Arg, typename Tag = typename tag<Arg>::type> 
        struct unary_plus;
      template<typename Arg, typename EnableIf = void> struct unary_minus_base;
      template<typename Arg, typename Tag = typename tag<Arg>::type> 
        struct unary_minus;
      template<typename Arg, typename EnableIf = void> struct complement_base;
      template<typename Arg, typename Tag = typename tag<Arg>::type> 
        struct complement;
      template<typename Arg, typename EnableIf = void> struct logical_not_base;
      template<typename Arg, typename Tag = typename tag<Arg>::type> 
        struct logical_not;
      template<typename Left, typename Right, typename EnableIf> 
        struct min_assign_base;
      template<typename Left, typename Right, typename EnableIf> 
        struct max_assign_base;
      template<typename Left, typename Right, typename EnableIf> 
        struct average_base;

      template<typename Left, typename Right> 
        struct average_base<Left, Right, typename enable_if< are_integral< Left, Right > >::type>;

      template<typename To, typename From, typename EnableIf> struct promote_base;

      template<typename ToFrom> struct promote_base<ToFrom, ToFrom, void>;

      template<typename Arg, typename EnableIf> struct as_min_base;

      template<typename Arg> 
        struct as_min_base<Arg, typename enable_if< is_floating_point< Arg > >::type>;

      template<typename Arg, typename EnableIf> struct as_max_base;
      template<typename Arg, typename EnableIf> struct as_zero_base;
      template<typename Arg, typename EnableIf> struct as_one_base;
      template<typename To, typename From, typename ToTag, typename FromTag> 
        struct promote;
      template<typename Left, typename Right, typename LeftTag, 
               typename RightTag> 
        struct min_assign;
      template<typename Left, typename Right, typename LeftTag, 
               typename RightTag> 
        struct max_assign;
      template<typename Left, typename Right, typename LeftTag, 
               typename RightTag> 
        struct average;
      template<typename Arg, typename Tag> struct as_min;
      template<typename Arg, typename Tag> struct as_max;
      template<typename Arg, typename Tag> struct as_zero;
      template<typename Arg, typename Tag> struct as_one;
    }
    namespace op {
      struct plus;
      struct minus;
      struct multiplies;
      struct divides;
      struct modulus;
      struct greater;
      struct greater_equal;
      struct less;
      struct less_equal;
      struct equal_to;
      struct not_equal_to;
      struct assign;
      struct plus_assign;
      struct minus_assign;
      struct multiplies_assign;
      struct divides_assign;
      struct modulus_assign;
      struct unary_plus;
      struct unary_minus;
      struct complement;
      struct logical_not;
      template<typename To> struct promote;
      struct min_assign;
      struct max_assign;
      struct average;
      struct as_min;
      struct as_max;
      struct as_zero;
      struct as_one;
    }
  }
}

namespace boost {
  namespace numeric {
    namespace operators {
      template<typename T, typename U> 
        disable_if< mpl::or_< is_same< T, U >, is_same< std::complex< T >, U > >, std::complex< T > >::type 
        operator*(std::complex< T > ri, U const & u);
      template<typename T, typename U> 
        disable_if< mpl::or_< is_same< T, U >, is_same< std::complex< T >, U > >, std::complex< T > >::type 
        operator/(std::complex< T > ri, U const & u);
    }
  }
}

namespace boost {
  namespace numeric {
    namespace functional {
      template<typename T> struct tag<std::valarray< T >>;
      template<typename Left, typename Right> 
        struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>;
      template<typename Left, typename Right> 
        struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>;
      template<typename Left, typename Right, typename RightTag> 
        struct average<Left, Right, std_valarray_tag, RightTag>;
      template<typename To, typename From> 
        struct promote<To, From, std_valarray_tag, std_valarray_tag>;
      template<typename ToFrom> 
        struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>;
      template<typename From> struct promote<bool, From, void, std_valarray_tag>;
      template<typename From> 
        struct promote<bool const, From, void, std_valarray_tag>;
      template<typename T> struct as_min<T, std_valarray_tag>;
      template<typename T> struct as_max<T, std_valarray_tag>;
      template<typename T> struct as_zero<T, std_valarray_tag>;
      template<typename T> struct as_one<T, std_valarray_tag>;
    }
    namespace operators {
      template<typename Left, typename Right> 
        enable_if< mpl::and_< is_scalar< Right >, mpl::not_< is_same< Left, Right > > >, std::valarray< typename functional::divides< Left, Right >::result_type > >::type 
        operator/(std::valarray< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        enable_if< mpl::and_< is_scalar< Right >, mpl::not_< is_same< Left, Right > > >, std::valarray< typename functional::multiplies< Left, Right >::result_type > >::type 
        operator*(std::valarray< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        disable_if< is_same< Left, Right >, std::valarray< typename functional::plus< Left, Right >::result_type > >::type 
        operator+(std::valarray< Left > const & left, 
                  std::valarray< Right > const & right);
    }
  }
}

namespace boost {
  namespace numeric {
    namespace functional {
      template<typename T, typename Al> struct tag<std::vector< T, Al >>;
      template<typename Left, typename Right> 
        struct min_assign<Left, Right, std_vector_tag, std_vector_tag>;
      template<typename Left, typename Right> 
        struct max_assign<Left, Right, std_vector_tag, std_vector_tag>;
      template<typename Left, typename Right> 
        struct average<Left, Right, std_vector_tag, void>;
      template<typename To, typename From> 
        struct promote<To, From, std_vector_tag, std_vector_tag>;
      template<typename ToFrom> 
        struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>;
      template<typename T> struct as_min<T, std_vector_tag>;
      template<typename T> struct as_max<T, std_vector_tag>;
      template<typename T> struct as_zero<T, std_vector_tag>;
      template<typename T> struct as_one<T, std_vector_tag>;
    }
    namespace operators {
      template<typename Left, typename Right> 
        enable_if< is_scalar< Right >, std::vector< typename functional::divides< Left, Right >::result_type > >::type 
        operator/(std::vector< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::divides< Left, Right >::result_type > 
        operator/(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left, typename Right> 
        enable_if< is_scalar< Right >, std::vector< typename functional::multiplies< Left, Right >::result_type > >::type 
        operator*(std::vector< Left > const & left, Right const & right);
      template<typename Left, typename Right> 
        enable_if< is_scalar< Left >, std::vector< typename functional::multiplies< Left, Right >::result_type > >::type 
        operator*(Left const & left, std::vector< Right > const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::multiplies< Left, Right >::result_type > 
        operator*(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::plus< Left, Right >::result_type > 
        operator+(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left, typename Right> 
        std::vector< typename functional::minus< Left, Right >::result_type > 
        operator-(std::vector< Left > const & left, 
                  std::vector< Right > const & right);
      template<typename Left> 
        std::vector< Left > & 
        operator+=(std::vector< Left > & left, 
                   std::vector< Left > const & right);
      template<typename Arg> 
        std::vector< typename functional::unary_minus< Arg >::result_type > 
        operator-(std::vector< Arg > const & arg);
    }
  }
}