FM / functional

/usr/include/boost/accumulators/numeric/functional/

/usr/include/boost/accumulators/numeric/functional

Name	Size	Mode	Actions
complex.hpp	2316	0644	edit dl rm
valarray.hpp	15612	0644	edit dl rm
vector.hpp	12790	0644	edit dl rm

Edit: /usr/include/boost/accumulators/numeric/functional/complex.hpp (2316B)

#ifndef BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006
#define BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006

#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
# error Include this file before boost/accumulators/numeric/functional.hpp
#endif

#include <complex>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/typeof/std/complex.hpp>
#include <boost/accumulators/numeric/functional_fwd.hpp>

namespace boost { namespace numeric { namespace operators
{
    // So that the stats compile when Sample type is std::complex
    template<typename T, typename U>
    typename
        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)
    {
        // BUGBUG promote result to typeof(T()*u) ?
        return ri *= static_cast<T>(u);
    }

template<typename T, typename U>
    typename
        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)
    {
        // BUGBUG promote result to typeof(T()*u) ?
        return ri /= static_cast<T>(u);
    }

}}} // namespace boost::numeric::operators

namespace boost { namespace numeric
{
    namespace detail
    {
        template<typename T>
        struct one_complex
        {
            static std::complex<T> const value;
        };

template<typename T>
        std::complex<T> const one_complex<T>::value
          = std::complex<T>(numeric::one<T>::value, numeric::one<T>::value);
    }

/// INTERNAL ONLY
    ///
    template<typename T>
    struct one<std::complex<T> >
      : detail::one_complex<T>
    {
        typedef one type;
        typedef std::complex<T> value_type;
        operator value_type const & () const
        {
            return detail::one_complex<T>::value;
        }
    };

}} // namespace boost::numeric

#endif

/////////////////////////////////////////////////////////////////////////////// /// \file complex.hpp /// // Copyright 2005 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006 #define BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006 #ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED # error Include this file before boost/accumulators/numeric/functional.hpp #endif #include #include #include #include #include #include namespace boost { namespace numeric { namespace operators { // So that the stats compile when Sample type is std::complex template typename disable_if< mpl::or_, is_same, U> > , std::complex >::type operator *(std::complex ri, U const &u) { // BUGBUG promote result to typeof(T()*u) ? return ri *= static_cast(u); } template typename disable_if< mpl::or_, is_same, U> > , std::complex >::type operator /(std::complex ri, U const &u) { // BUGBUG promote result to typeof(T()*u) ? return ri /= static_cast(u); } }}} // namespace boost::numeric::operators namespace boost { namespace numeric { namespace detail { template struct one_complex { static std::complex const value; }; template std::complex const one_complex::value = std::complex(numeric::one::value, numeric::one::value); } /// INTERNAL ONLY /// template struct one > : detail::one_complex { typedef one type; typedef std::complex value_type; operator value_type const & () const { return detail::one_complex::value; } }; }} // namespace boost::numeric #endif