comparison DEPENDENCIES/generic/include/boost/math/octonion.hpp @ 16:2665513ce2d3

Add boost headers

+//    boost octonion.hpp header file
+
+//  (C) Copyright Hubert Holin 2001.
+//  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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+
+#ifndef BOOST_OCTONION_HPP
+#define BOOST_OCTONION_HPP
+
+#include <boost/math/quaternion.hpp>
+
+
+namespace boost
+{
+    namespace math
+    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+        // gcc 2.95.x uses expression templates for valarray calculations, but
+        // the result is not conforming. We need BOOST_GET_VALARRAY to get an
+        // actual valarray result when we need to call a member function
+    #define    BOOST_GET_VALARRAY(T,x)    ::std::valarray<T>(x)
+        // gcc 2.95.x has an "std::ios" class that is similar to 
+        // "std::ios_base", so we just use a #define
+    #define    BOOST_IOS_BASE    ::std::ios
+        // gcc 2.x ignores function scope using declarations,
+        // put them in the scope of the enclosing namespace instead:
+        using    ::std::valarray;
+        using    ::std::sqrt;
+        using    ::std::cos;
+        using    ::std::sin;
+        using    ::std::exp;
+        using    ::std::cosh;
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+    
+#define    BOOST_OCTONION_ACCESSOR_GENERATOR(type)                      \
+            type                        real() const                    \
+            {                                                           \
+                return(a);                                              \
+            }                                                           \
+                                                                        \
+            octonion<type>                unreal() const                \
+            {                                                           \
+                return( octonion<type>(static_cast<type>(0),b,c,d,e,f,g,h));   \
+            }                                                           \
+                                                                        \
+            type                            R_component_1() const       \
+            {                                                           \
+                return(a);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_2() const       \
+            {                                                           \
+                return(b);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_3() const       \
+            {                                                           \
+                return(c);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_4() const       \
+            {                                                           \
+                return(d);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_5() const       \
+            {                                                           \
+                return(e);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_6() const       \
+            {                                                           \
+                return(f);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_7() const       \
+            {                                                           \
+                return(g);                                              \
+            }                                                           \
+                                                                        \
+            type                            R_component_8() const       \
+            {                                                           \
+                return(h);                                              \
+            }                                                           \
+                                                                        \
+            ::std::complex<type>            C_component_1() const       \
+            {                                                           \
+                return(::std::complex<type>(a,b));                      \
+            }                                                           \
+                                                                        \
+            ::std::complex<type>            C_component_2() const       \
+            {                                                           \
+                return(::std::complex<type>(c,d));                      \
+            }                                                           \
+                                                                        \
+            ::std::complex<type>            C_component_3() const       \
+            {                                                           \
+                return(::std::complex<type>(e,f));                      \
+            }                                                           \
+                                                                        \
+            ::std::complex<type>            C_component_4() const       \
+            {                                                           \
+                return(::std::complex<type>(g,h));                      \
+            }                                                           \
+                                                                        \
+            ::boost::math::quaternion<type>    H_component_1() const    \
+            {                                                           \
+                return(::boost::math::quaternion<type>(a,b,c,d));       \
+            }                                                           \
+                                                                        \
+            ::boost::math::quaternion<type>    H_component_2() const    \
+            {                                                           \
+                return(::boost::math::quaternion<type>(e,f,g,h));       \
+            }
+        
+    
+#define    BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(type)                                         \
+            template<typename X>                                                                    \
+            octonion<type> &        operator = (octonion<X> const & a_affecter)                     \
+            {                                                                                       \
+                a = static_cast<type>(a_affecter.R_component_1());                                  \
+                b = static_cast<type>(a_affecter.R_component_2());                                  \
+                c = static_cast<type>(a_affecter.R_component_3());                                  \
+                d = static_cast<type>(a_affecter.R_component_4());                                  \
+                e = static_cast<type>(a_affecter.R_component_5());                                  \
+                f = static_cast<type>(a_affecter.R_component_6());                                  \
+                g = static_cast<type>(a_affecter.R_component_7());                                  \
+                h = static_cast<type>(a_affecter.R_component_8());                                  \
+                                                                                                    \
+                return(*this);                                                                      \
+            }                                                                                       \
+                                                                                                    \
+            octonion<type> &        operator = (octonion<type> const & a_affecter)                  \
+            {                                                                                       \
+                a = a_affecter.a;                                                                   \
+                b = a_affecter.b;                                                                   \
+                c = a_affecter.c;                                                                   \
+                d = a_affecter.d;                                                                   \
+                e = a_affecter.e;                                                                   \
+                f = a_affecter.f;                                                                   \
+                g = a_affecter.g;                                                                   \
+                h = a_affecter.h;                                                                   \
+                                                                                                    \
+                return(*this);                                                                      \
+            }                                                                                       \
+                                                                                                    \
+            octonion<type> &        operator = (type const & a_affecter)                            \
+            {                                                                                       \
+                a = a_affecter;                                                                     \
+                                                                                                    \
+                b = c = d = e = f= g = h = static_cast<type>(0);                                    \
+                                                                                                    \
+                return(*this);                                                                      \
+            }                                                                                       \
+                                                                                                    \
+            octonion<type> &        operator = (::std::complex<type> const & a_affecter)            \
+            {                                                                                       \
+                a = a_affecter.real();                                                              \
+                b = a_affecter.imag();                                                              \
+                                                                                                    \
+                c = d = e = f = g = h = static_cast<type>(0);                                       \
+                                                                                                    \
+                return(*this);                                                                      \
+            }                                                                                       \
+                                                                                                    \
+            octonion<type> &        operator = (::boost::math::quaternion<type> const & a_affecter) \
+            {                                                                                       \
+                a = a_affecter.R_component_1();                                                     \
+                b = a_affecter.R_component_2();                                                     \
+                c = a_affecter.R_component_3();                                                     \
+                d = a_affecter.R_component_4();                                                     \
+                                                                                                    \
+                e = f = g = h = static_cast<type>(0);                                               \
+                                                                                                    \
+                return(*this);                                                                      \
+            }
+        
+        
+#define    BOOST_OCTONION_MEMBER_DATA_GENERATOR(type) \
+            type    a;                                \
+            type    b;                                \
+            type    c;                                \
+            type    d;                                \
+            type    e;                                \
+            type    f;                                \
+            type    g;                                \
+            type    h;                                \
+        
+        
+        template<typename T>
+        class octonion
+        {
+        public:
+            
+            typedef T value_type;
+            
+            // constructor for O seen as R^8
+            // (also default constructor)
+            
+            explicit                octonion(   T const & requested_a = T(),
+                                                T const & requested_b = T(),
+                                                T const & requested_c = T(),
+                                                T const & requested_d = T(),
+                                                T const & requested_e = T(),
+                                                T const & requested_f = T(),
+                                                T const & requested_g = T(),
+                                                T const & requested_h = T())
+            :   a(requested_a),
+                b(requested_b),
+                c(requested_c),
+                d(requested_d),
+                e(requested_e),
+                f(requested_f),
+                g(requested_g),
+                h(requested_h)
+            {
+                // nothing to do!
+            }
+            
+            
+            // constructor for H seen as C^4
+                
+            explicit                octonion(   ::std::complex<T> const & z0,
+                                                ::std::complex<T> const & z1 = ::std::complex<T>(),
+                                                ::std::complex<T> const & z2 = ::std::complex<T>(),
+                                                ::std::complex<T> const & z3 = ::std::complex<T>())
+            :   a(z0.real()),
+                b(z0.imag()),
+                c(z1.real()),
+                d(z1.imag()),
+                e(z2.real()),
+                f(z2.imag()),
+                g(z3.real()),
+                h(z3.imag())
+            {
+                // nothing to do!
+            }
+            
+            
+            // constructor for O seen as H^2
+                
+            explicit                octonion(   ::boost::math::quaternion<T> const & q0,
+                                                ::boost::math::quaternion<T> const & q1 = ::boost::math::quaternion<T>())
+            :   a(q0.R_component_1()),
+                b(q0.R_component_2()),
+                c(q0.R_component_3()),
+                d(q0.R_component_4()),
+                e(q1.R_component_1()),
+                f(q1.R_component_2()),
+                g(q1.R_component_3()),
+                h(q1.R_component_4())
+            {
+                // nothing to do!
+            }
+            
+            
+            // UNtemplated copy constructor
+            // (this is taken care of by the compiler itself)
+            
+            
+            // templated copy constructor
+            
+            template<typename X>
+            explicit                octonion(octonion<X> const & a_recopier)
+            :   a(static_cast<T>(a_recopier.R_component_1())),
+                b(static_cast<T>(a_recopier.R_component_2())),
+                c(static_cast<T>(a_recopier.R_component_3())),
+                d(static_cast<T>(a_recopier.R_component_4())),
+                e(static_cast<T>(a_recopier.R_component_5())),
+                f(static_cast<T>(a_recopier.R_component_6())),
+                g(static_cast<T>(a_recopier.R_component_7())),
+                h(static_cast<T>(a_recopier.R_component_8()))
+            {
+                // nothing to do!
+            }
+            
+            
+            // destructor
+            // (this is taken care of by the compiler itself)
+            
+            
+            // accessors
+            //
+            // Note:    Like complex number, octonions do have a meaningful notion of "real part",
+            //            but unlike them there is no meaningful notion of "imaginary part".
+            //            Instead there is an "unreal part" which itself is an octonion, and usually
+            //            nothing simpler (as opposed to the complex number case).
+            //            However, for practicallity, there are accessors for the other components
+            //            (these are necessary for the templated copy constructor, for instance).
+            
+            BOOST_OCTONION_ACCESSOR_GENERATOR(T)
+            
+            // assignment operators
+            
+            BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(T)
+            
+            // other assignment-related operators
+            //
+            // NOTE:    Octonion multiplication is *NOT* commutative;
+            //            symbolically, "q *= rhs;" means "q = q * rhs;"
+            //            and "q /= rhs;" means "q = q * inverse_of(rhs);";
+            //            octonion multiplication is also *NOT* associative
+            
+            octonion<T> &            operator += (T const & rhs)
+            {
+                T    at = a + rhs;    // exception guard
+                
+                a = at;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator += (::std::complex<T> const & rhs)
+            {
+                T    at = a + rhs.real();    // exception guard
+                T    bt = b + rhs.imag();    // exception guard
+                
+                a = at; 
+                b = bt;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator += (::boost::math::quaternion<T> const & rhs)
+            {
+                T    at = a + rhs.R_component_1();    // exception guard
+                T    bt = b + rhs.R_component_2();    // exception guard
+                T    ct = c + rhs.R_component_3();    // exception guard
+                T    dt = d + rhs.R_component_4();    // exception guard
+                
+                a = at; 
+                b = bt;
+                c = ct;
+                d = dt;
+                
+                return(*this);
+            }
+            
+            
+            template<typename X>
+            octonion<T> &            operator += (octonion<X> const & rhs)
+            {
+                T    at = a + static_cast<T>(rhs.R_component_1());    // exception guard
+                T    bt = b + static_cast<T>(rhs.R_component_2());    // exception guard
+                T    ct = c + static_cast<T>(rhs.R_component_3());    // exception guard
+                T    dt = d + static_cast<T>(rhs.R_component_4());    // exception guard
+                T    et = e + static_cast<T>(rhs.R_component_5());    // exception guard
+                T    ft = f + static_cast<T>(rhs.R_component_6());    // exception guard
+                T    gt = g + static_cast<T>(rhs.R_component_7());    // exception guard
+                T    ht = h + static_cast<T>(rhs.R_component_8());    // exception guard
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            
+            octonion<T> &            operator -= (T const & rhs)
+            {
+                T    at = a - rhs;    // exception guard
+                
+                a = at;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator -= (::std::complex<T> const & rhs)
+            {
+                T    at = a - rhs.real();    // exception guard
+                T    bt = b - rhs.imag();    // exception guard
+                
+                a = at; 
+                b = bt;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator -= (::boost::math::quaternion<T> const & rhs)
+            {
+                T    at = a - rhs.R_component_1();    // exception guard
+                T    bt = b - rhs.R_component_2();    // exception guard
+                T    ct = c - rhs.R_component_3();    // exception guard
+                T    dt = d - rhs.R_component_4();    // exception guard
+                
+                a = at; 
+                b = bt;
+                c = ct;
+                d = dt;
+                
+                return(*this);
+            }
+            
+            
+            template<typename X>
+            octonion<T> &            operator -= (octonion<X> const & rhs)
+            {
+                T    at = a - static_cast<T>(rhs.R_component_1());    // exception guard
+                T    bt = b - static_cast<T>(rhs.R_component_2());    // exception guard
+                T    ct = c - static_cast<T>(rhs.R_component_3());    // exception guard
+                T    dt = d - static_cast<T>(rhs.R_component_4());    // exception guard
+                T    et = e - static_cast<T>(rhs.R_component_5());    // exception guard
+                T    ft = f - static_cast<T>(rhs.R_component_6());    // exception guard
+                T    gt = g - static_cast<T>(rhs.R_component_7());    // exception guard
+                T    ht = h - static_cast<T>(rhs.R_component_8());    // exception guard
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator *= (T const & rhs)
+            {
+                T    at = a * rhs;    // exception guard
+                T    bt = b * rhs;    // exception guard
+                T    ct = c * rhs;    // exception guard
+                T    dt = d * rhs;    // exception guard
+                T    et = e * rhs;    // exception guard
+                T    ft = f * rhs;    // exception guard
+                T    gt = g * rhs;    // exception guard
+                T    ht = h * rhs;    // exception guard
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator *= (::std::complex<T> const & rhs)
+            {
+                T    ar = rhs.real();
+                T    br = rhs.imag();
+                
+                T    at = +a*ar-b*br;
+                T    bt = +a*br+b*ar;
+                T    ct = +c*ar+d*br;
+                T    dt = -c*br+d*ar;
+                T    et = +e*ar+f*br;
+                T    ft = -e*br+f*ar;
+                T    gt = +g*ar-h*br;
+                T    ht = +g*br+h*ar;
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator *= (::boost::math::quaternion<T> const & rhs)
+            {
+                T    ar = rhs.R_component_1();
+                T    br = rhs.R_component_2();
+                T    cr = rhs.R_component_2();
+                T    dr = rhs.R_component_2();
+                
+                T    at = +a*ar-b*br-c*cr-d*dr;
+                T    bt = +a*br+b*ar+c*dr-d*cr;
+                T    ct = +a*cr-b*dr+c*ar+d*br;
+                T    dt = +a*dr+b*cr-c*br+d*ar;
+                T    et = +e*ar+f*br+g*cr+h*dr;
+                T    ft = -e*br+f*ar-g*dr+h*cr;
+                T    gt = -e*cr+f*dr+g*ar-h*br;
+                T    ht = -e*dr-f*cr+g*br+h*ar;
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            template<typename X>
+            octonion<T> &            operator *= (octonion<X> const & rhs)
+            {
+                T    ar = static_cast<T>(rhs.R_component_1());
+                T    br = static_cast<T>(rhs.R_component_2());
+                T    cr = static_cast<T>(rhs.R_component_3());
+                T    dr = static_cast<T>(rhs.R_component_4());
+                T    er = static_cast<T>(rhs.R_component_5());
+                T    fr = static_cast<T>(rhs.R_component_6());
+                T    gr = static_cast<T>(rhs.R_component_7());
+                T    hr = static_cast<T>(rhs.R_component_8());
+                
+                T    at = +a*ar-b*br-c*cr-d*dr-e*er-f*fr-g*gr-h*hr;
+                T    bt = +a*br+b*ar+c*dr-d*cr+e*fr-f*er-g*hr+h*gr;
+                T    ct = +a*cr-b*dr+c*ar+d*br+e*gr+f*hr-g*er-h*fr;
+                T    dt = +a*dr+b*cr-c*br+d*ar+e*hr-f*gr+g*fr-h*er;
+                T    et = +a*er-b*fr-c*gr-d*hr+e*ar+f*br+g*cr+h*dr;
+                T    ft = +a*fr+b*er-c*hr+d*gr-e*br+f*ar-g*dr+h*cr;
+                T    gt = +a*gr+b*hr+c*er-d*fr-e*cr+f*dr+g*ar-h*br;
+                T    ht = +a*hr-b*gr+c*fr+d*er-e*dr-f*cr+g*br+h*ar;
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator /= (T const & rhs)
+            {
+                T    at = a / rhs;    // exception guard
+                T    bt = b / rhs;    // exception guard
+                T    ct = c / rhs;    // exception guard
+                T    dt = d / rhs;    // exception guard
+                T    et = e / rhs;    // exception guard
+                T    ft = f / rhs;    // exception guard
+                T    gt = g / rhs;    // exception guard
+                T    ht = h / rhs;    // exception guard
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator /= (::std::complex<T> const & rhs)
+            {
+                T    ar = rhs.real();
+                T    br = rhs.imag();
+                
+                T    denominator = ar*ar+br*br;
+                
+                T    at = (+a*ar-b*br)/denominator;
+                T    bt = (-a*br+b*ar)/denominator;
+                T    ct = (+c*ar-d*br)/denominator;
+                T    dt = (+c*br+d*ar)/denominator;
+                T    et = (+e*ar-f*br)/denominator;
+                T    ft = (+e*br+f*ar)/denominator;
+                T    gt = (+g*ar+h*br)/denominator;
+                T    ht = (+g*br+h*ar)/denominator;
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            octonion<T> &            operator /= (::boost::math::quaternion<T> const & rhs)
+            {
+                T    ar = rhs.R_component_1();
+                T    br = rhs.R_component_2();
+                T    cr = rhs.R_component_2();
+                T    dr = rhs.R_component_2();
+                
+                T    denominator = ar*ar+br*br+cr*cr+dr*dr;
+                
+                T    at = (+a*ar+b*br+c*cr+d*dr)/denominator;
+                T    bt = (-a*br+b*ar-c*dr+d*cr)/denominator;
+                T    ct = (-a*cr+b*dr+c*ar-d*br)/denominator;
+                T    dt = (-a*dr-b*cr+c*br+d*ar)/denominator;
+                T    et = (+e*ar-f*br-g*cr-h*dr)/denominator;
+                T    ft = (+e*br+f*ar+g*dr-h*cr)/denominator;
+                T    gt = (+e*cr-f*dr+g*ar+h*br)/denominator;
+                T    ht = (+e*dr+f*cr-g*br+h*ar)/denominator;
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+            template<typename X>
+            octonion<T> &            operator /= (octonion<X> const & rhs)
+            {
+                T    ar = static_cast<T>(rhs.R_component_1());
+                T    br = static_cast<T>(rhs.R_component_2());
+                T    cr = static_cast<T>(rhs.R_component_3());
+                T    dr = static_cast<T>(rhs.R_component_4());
+                T    er = static_cast<T>(rhs.R_component_5());
+                T    fr = static_cast<T>(rhs.R_component_6());
+                T    gr = static_cast<T>(rhs.R_component_7());
+                T    hr = static_cast<T>(rhs.R_component_8());
+                
+                T    denominator = ar*ar+br*br+cr*cr+dr*dr+er*er+fr*fr+gr*gr+hr*hr;
+                
+                T    at = (+a*ar+b*br+c*cr+d*dr+e*er+f*fr+g*gr+h*hr)/denominator;
+                T    bt = (-a*br+b*ar-c*dr+d*cr-e*fr+f*er+g*hr-h*gr)/denominator;
+                T    ct = (-a*cr+b*dr+c*ar-d*br-e*gr-f*hr+g*er+h*fr)/denominator;
+                T    dt = (-a*dr-b*cr+c*br+d*ar-e*hr+f*gr-g*fr+h*er)/denominator;
+                T    et = (-a*er+b*fr+c*gr+d*hr+e*ar-f*br-g*cr-h*dr)/denominator;
+                T    ft = (-a*fr-b*er+c*hr-d*gr+e*br+f*ar+g*dr-h*cr)/denominator;
+                T    gt = (-a*gr-b*hr-c*er+d*fr+e*cr-f*dr+g*ar+h*br)/denominator;
+                T    ht = (-a*hr+b*gr-c*fr-d*er+e*dr+f*cr-g*br+h*ar)/denominator;
+                
+                a = at;
+                b = bt;
+                c = ct;
+                d = dt;
+                e = et;
+                f = ft;
+                g = gt;
+                h = ht;
+                
+                return(*this);
+            }
+            
+            
+        protected:
+            
+            BOOST_OCTONION_MEMBER_DATA_GENERATOR(T)
+            
+            
+        private:
+            
+        };
+        
+        
+        // declaration of octonion specialization
+        
+        template<>    class octonion<float>;
+        template<>    class octonion<double>;
+        template<>    class octonion<long double>;
+        
+        
+        // helper templates for converting copy constructors (declaration)
+        
+        namespace detail
+        {
+            
+            template<   typename T,
+                        typename U
+                    >
+            octonion<T>    octonion_type_converter(octonion<U> const & rhs);
+        }
+        
+        
+        // implementation of octonion specialization
+        
+        
+#define    BOOST_OCTONION_CONSTRUCTOR_GENERATOR(type)                                                                               \
+            explicit                    octonion(   type const & requested_a = static_cast<type>(0),                                \
+                                                    type const & requested_b = static_cast<type>(0),                                \
+                                                    type const & requested_c = static_cast<type>(0),                                \
+                                                    type const & requested_d = static_cast<type>(0),                                \
+                                                    type const & requested_e = static_cast<type>(0),                                \
+                                                    type const & requested_f = static_cast<type>(0),                                \
+                                                    type const & requested_g = static_cast<type>(0),                                \
+                                                    type const & requested_h = static_cast<type>(0))                                \
+            :   a(requested_a),                                                                                                     \
+                b(requested_b),                                                                                                     \
+                c(requested_c),                                                                                                     \
+                d(requested_d),                                                                                                     \
+                e(requested_e),                                                                                                     \
+                f(requested_f),                                                                                                     \
+                g(requested_g),                                                                                                     \
+                h(requested_h)                                                                                                      \
+            {                                                                                                                       \
+            }                                                                                                                       \
+                                                                                                                                    \
+            explicit                    octonion(   ::std::complex<type> const & z0,                                                \
+                                                    ::std::complex<type> const & z1 = ::std::complex<type>(),                       \
+                                                    ::std::complex<type> const & z2 = ::std::complex<type>(),                       \
+                                                    ::std::complex<type> const & z3 = ::std::complex<type>())                       \
+            :   a(z0.real()),                                                                                                       \
+                b(z0.imag()),                                                                                                       \
+                c(z1.real()),                                                                                                       \
+                d(z1.imag()),                                                                                                       \
+                e(z2.real()),                                                                                                       \
+                f(z2.imag()),                                                                                                       \
+                g(z3.real()),                                                                                                       \
+                h(z3.imag())                                                                                                        \
+            {                                                                                                                       \
+            }                                                                                                                       \
+                                                                                                                                    \
+            explicit                    octonion(   ::boost::math::quaternion<type> const & q0,                                     \
+                                                    ::boost::math::quaternion<type> const & q1 = ::boost::math::quaternion<type>()) \
+            :   a(q0.R_component_1()),                                                                                              \
+                b(q0.R_component_2()),                                                                                              \
+                c(q0.R_component_3()),                                                                                              \
+                d(q0.R_component_4()),                                                                                              \
+                e(q1.R_component_1()),                                                                                              \
+                f(q1.R_component_2()),                                                                                              \
+                g(q1.R_component_3()),                                                                                              \
+                h(q1.R_component_4())                                                                                               \
+            {                                                                                                                       \
+            }
+        
+    
+#define    BOOST_OCTONION_MEMBER_ADD_GENERATOR_1(type)                  \
+            octonion<type> &            operator += (type const & rhs)  \
+            {                                                           \
+                a += rhs;                                               \
+                                                                        \
+                return(*this);                                          \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_ADD_GENERATOR_2(type)                                  \
+            octonion<type> &            operator += (::std::complex<type> const & rhs)  \
+            {                                                                           \
+                a += rhs.real();                                                        \
+                b += rhs.imag();                                                        \
+                                                                                        \
+                return(*this);                                                          \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_ADD_GENERATOR_3(type)                                              \
+            octonion<type> &            operator += (::boost::math::quaternion<type> const & rhs)   \
+            {                                                                                       \
+                a += rhs.R_component_1();                                                           \
+                b += rhs.R_component_2();                                                           \
+                c += rhs.R_component_3();                                                           \
+                d += rhs.R_component_4();                                                           \
+                                                                                                    \
+                return(*this);                                                                      \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_ADD_GENERATOR_4(type)                          \
+            template<typename X>                                                \
+            octonion<type> &            operator += (octonion<X> const & rhs)   \
+            {                                                                   \
+                a += static_cast<type>(rhs.R_component_1());                    \
+                b += static_cast<type>(rhs.R_component_2());                    \
+                c += static_cast<type>(rhs.R_component_3());                    \
+                d += static_cast<type>(rhs.R_component_4());                    \
+                e += static_cast<type>(rhs.R_component_5());                    \
+                f += static_cast<type>(rhs.R_component_6());                    \
+                g += static_cast<type>(rhs.R_component_7());                    \
+                h += static_cast<type>(rhs.R_component_8());                    \
+                                                                                \
+                return(*this);                                                  \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_SUB_GENERATOR_1(type)                  \
+            octonion<type> &            operator -= (type const & rhs)  \
+            {                                                           \
+                a -= rhs;                                               \
+                                                                        \
+                return(*this);                                          \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_SUB_GENERATOR_2(type)                                  \
+            octonion<type> &            operator -= (::std::complex<type> const & rhs)  \
+            {                                                                           \
+                a -= rhs.real();                                                        \
+                b -= rhs.imag();                                                        \
+                                                                                        \
+                return(*this);                                                          \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_SUB_GENERATOR_3(type)                                              \
+            octonion<type> &            operator -= (::boost::math::quaternion<type> const & rhs)   \
+            {                                                                                       \
+                a -= rhs.R_component_1();                                                           \
+                b -= rhs.R_component_2();                                                           \
+                c -= rhs.R_component_3();                                                           \
+                d -= rhs.R_component_4();                                                           \
+                                                                                                    \
+                return(*this);                                                                      \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_SUB_GENERATOR_4(type)                        \
+            template<typename X>                                              \
+            octonion<type> &            operator -= (octonion<X> const & rhs) \
+            {                                                                 \
+                a -= static_cast<type>(rhs.R_component_1());                  \
+                b -= static_cast<type>(rhs.R_component_2());                  \
+                c -= static_cast<type>(rhs.R_component_3());                  \
+                d -= static_cast<type>(rhs.R_component_4());                  \
+                e -= static_cast<type>(rhs.R_component_5());                  \
+                f -= static_cast<type>(rhs.R_component_6());                  \
+                g -= static_cast<type>(rhs.R_component_7());                  \
+                h -= static_cast<type>(rhs.R_component_8());                  \
+                                                                              \
+                return(*this);                                                \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_MUL_GENERATOR_1(type)                   \
+            octonion<type> &            operator *= (type const & rhs)   \
+            {                                                            \
+                a *= rhs;                                                \
+                b *= rhs;                                                \
+                c *= rhs;                                                \
+                d *= rhs;                                                \
+                e *= rhs;                                                \
+                f *= rhs;                                                \
+                g *= rhs;                                                \
+                h *= rhs;                                                \
+                                                                         \
+                return(*this);                                           \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_MUL_GENERATOR_2(type)                                  \
+            octonion<type> &            operator *= (::std::complex<type> const & rhs)  \
+            {                                                                           \
+                type    ar = rhs.real();                                                \
+                type    br = rhs.imag();                                                \
+                                                                                        \
+                type    at = +a*ar-b*br;                                                \
+                type    bt = +a*br+b*ar;                                                \
+                type    ct = +c*ar+d*br;                                                \
+                type    dt = -c*br+d*ar;                                                \
+                type    et = +e*ar+f*br;                                                \
+                type    ft = -e*br+f*ar;                                                \
+                type    gt = +g*ar-h*br;                                                \
+                type    ht = +g*br+h*ar;                                                \
+                                                                                        \
+                a = at;                                                                 \
+                b = bt;                                                                 \
+                c = ct;                                                                 \
+                d = dt;                                                                 \
+                e = et;                                                                 \
+                f = ft;                                                                 \
+                g = gt;                                                                 \
+                h = ht;                                                                 \
+                                                                                        \
+                return(*this);                                                          \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_MUL_GENERATOR_3(type)                                                    \
+            octonion<type> &            operator *= (::boost::math::quaternion<type> const & rhs)   \
+            {                                                                                       \
+                type    ar = rhs.R_component_1();                                                   \
+                type    br = rhs.R_component_2();                                                   \
+                type    cr = rhs.R_component_2();                                                   \
+                type    dr = rhs.R_component_2();                                                   \
+                                                                                                    \
+                type    at = +a*ar-b*br-c*cr-d*dr;                                                  \
+                type    bt = +a*br+b*ar+c*dr-d*cr;                                                  \
+                type    ct = +a*cr-b*dr+c*ar+d*br;                                                  \
+                type    dt = +a*dr+b*cr-c*br+d*ar;                                                  \
+                type    et = +e*ar+f*br+g*cr+h*dr;                                                  \
+                type    ft = -e*br+f*ar-g*dr+h*cr;                                                  \
+                type    gt = -e*cr+f*dr+g*ar-h*br;                                                  \
+                type    ht = -e*dr-f*cr+g*br+h*ar;                                                  \
+                                                                                                    \
+                a = at;                                                                             \
+                b = bt;                                                                             \
+                c = ct;                                                                             \
+                d = dt;                                                                             \
+                e = et;                                                                             \
+                f = ft;                                                                             \
+                g = gt;                                                                             \
+                h = ht;                                                                             \
+                                                                                                    \
+                return(*this);                                                                      \
+            }
+    
+#define    BOOST_OCTONION_MEMBER_MUL_GENERATOR_4(type)                          \
+            template<typename X>                                                \
+            octonion<type> &            operator *= (octonion<X> const & rhs)   \
+            {                                                                   \
+                type    ar = static_cast<type>(rhs.R_component_1());            \
+                type    br = static_cast<type>(rhs.R_component_2());            \
+                type    cr = static_cast<type>(rhs.R_component_3());            \
+                type    dr = static_cast<type>(rhs.R_component_4());            \
+                type    er = static_cast<type>(rhs.R_component_5());            \
+                type    fr = static_cast<type>(rhs.R_component_6());            \
+                type    gr = static_cast<type>(rhs.R_component_7());            \
+                type    hr = static_cast<type>(rhs.R_component_8());            \
+                                                                                \
+                type    at = +a*ar-b*br-c*cr-d*dr-e*er-f*fr-g*gr-h*hr;          \
+                type    bt = +a*br+b*ar+c*dr-d*cr+e*fr-f*er-g*hr+h*gr;          \
+                type    ct = +a*cr-b*dr+c*ar+d*br+e*gr+f*hr-g*er-h*fr;          \
+                type    dt = +a*dr+b*cr-c*br+d*ar+e*hr-f*gr+g*fr-h*er;          \
+                type    et = +a*er-b*fr-c*gr-d*hr+e*ar+f*br+g*cr+h*dr;          \
+                type    ft = +a*fr+b*er-c*hr+d*gr-e*br+f*ar-g*dr+h*cr;          \
+                type    gt = +a*gr+b*hr+c*er-d*fr-e*cr+f*dr+g*ar-h*br;          \
+                type    ht = +a*hr-b*gr+c*fr+d*er-e*dr-f*cr+g*br+h*ar;          \
+                                                                                \
+                a = at;                                                         \
+                b = bt;                                                         \
+                c = ct;                                                         \
+                d = dt;                                                         \
+                e = et;                                                         \
+                f = ft;                                                         \
+                g = gt;                                                         \
+                h = ht;                                                         \
+                                                                                \
+                return(*this);                                                  \
+            }
+    
+// There is quite a lot of repetition in the code below. This is intentional.
+// The last conditional block is the normal form, and the others merely
+// consist of workarounds for various compiler deficiencies. Hopefuly, when
+// more compilers are conformant and we can retire support for those that are
+// not, we will be able to remove the clutter. This is makes the situation
+// (painfully) explicit.
+    
+#define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_1(type)                  \
+            octonion<type> &            operator /= (type const & rhs)  \
+            {                                                           \
+                a /= rhs;                                               \
+                b /= rhs;                                               \
+                c /= rhs;                                               \
+                d /= rhs;                                               \
+                                                                        \
+                return(*this);                                          \
+            }
+    
+#if defined(__GNUC__) && (__GNUC__ < 3)
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type)                                              \
+            octonion<type> &            operator /= (::std::complex<type> const & rhs)                  \
+            {                                                                                           \
+                using    ::std::valarray;                                                               \
+                                                                                                        \
+                valarray<type>    tr(2);                                                                \
+                                                                                                        \
+                tr[0] = rhs.real();                                                                     \
+                tr[1] = rhs.imag();                                                                     \
+                                                                                                        \
+                type            mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();  \
+                                                                                                        \
+                tr *= mixam;                                                                            \
+                                                                                                        \
+                valarray<type>    tt(8);                                                                \
+                                                                                                        \
+                tt[0] = +a*tr[0]-b*tr[1];                                                               \
+                tt[1] = -a*tr[1]+b*tr[0];                                                               \
+                tt[2] = +c*tr[0]-d*tr[1];                                                               \
+                tt[3] = +c*tr[1]+d*tr[0];                                                               \
+                tt[4] = +e*tr[0]-f*tr[1];                                                               \
+                tt[5] = +e*tr[1]+f*tr[0];                                                               \
+                tt[6] = +g*tr[0]+h*tr[1];                                                               \
+                tt[7] = +g*tr[1]+h*tr[0];                                                               \
+                                                                                                        \
+                tr *= tr;                                                                               \
+                                                                                                        \
+                tt *= (mixam/tr.sum());                                                                 \
+                                                                                                        \
+                a = tt[0];                                                                              \
+                b = tt[1];                                                                              \
+                c = tt[2];                                                                              \
+                d = tt[3];                                                                              \
+                e = tt[4];                                                                              \
+                f = tt[5];                                                                              \
+                g = tt[6];                                                                              \
+                h = tt[7];                                                                              \
+                                                                                                        \
+                return(*this);                                                                          \
+            }
+#elif    defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type)                              \
+            octonion<type> &            operator /= (::std::complex<type> const & rhs)  \
+            {                                                                           \
+                using    ::std::valarray;                                               \
+                using    ::std::abs;                                                    \
+                                                                                        \
+                valarray<type>    tr(2);                                                \
+                                                                                        \
+                tr[0] = rhs.real();                                                     \
+                tr[1] = rhs.imag();                                                     \
+                                                                                        \
+                type            mixam = static_cast<type>(1)/(abs(tr).max)();           \
+                                                                                        \
+                tr *= mixam;                                                            \
+                                                                                        \
+                valarray<type>    tt(8);                                                \
+                                                                                        \
+                tt[0] = +a*tr[0]-b*tr[1];                                               \
+                tt[1] = -a*tr[1]+b*tr[0];                                               \
+                tt[2] = +c*tr[0]-d*tr[1];                                               \
+                tt[3] = +c*tr[1]+d*tr[0];                                               \
+                tt[4] = +e*tr[0]-f*tr[1];                                               \
+                tt[5] = +e*tr[1]+f*tr[0];                                               \
+                tt[6] = +g*tr[0]+h*tr[1];                                               \
+                tt[7] = +g*tr[1]+h*tr[0];                                               \
+                                                                                        \
+                tr *= tr;                                                               \
+                                                                                        \
+                tt *= (mixam/tr.sum());                                                 \
+                                                                                        \
+                a = tt[0];                                                              \
+                b = tt[1];                                                              \
+                c = tt[2];                                                              \
+                d = tt[3];                                                              \
+                e = tt[4];                                                              \
+                f = tt[5];                                                              \
+                g = tt[6];                                                              \
+                h = tt[7];                                                              \
+                                                                                        \
+                return(*this);                                                          \
+            }
+#else
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type)                              \
+            octonion<type> &            operator /= (::std::complex<type> const & rhs)  \
+            {                                                                           \
+                using    ::std::valarray;                                               \
+                                                                                        \
+                valarray<type>    tr(2);                                                \
+                                                                                        \
+                tr[0] = rhs.real();                                                     \
+                tr[1] = rhs.imag();                                                     \
+                                                                                        \
+                type            mixam = static_cast<type>(1)/(abs(tr).max)();           \
+                                                                                        \
+                tr *= mixam;                                                            \
+                                                                                        \
+                valarray<type>    tt(8);                                                \
+                                                                                        \
+                tt[0] = +a*tr[0]-b*tr[1];                                               \
+                tt[1] = -a*tr[1]+b*tr[0];                                               \
+                tt[2] = +c*tr[0]-d*tr[1];                                               \
+                tt[3] = +c*tr[1]+d*tr[0];                                               \
+                tt[4] = +e*tr[0]-f*tr[1];                                               \
+                tt[5] = +e*tr[1]+f*tr[0];                                               \
+                tt[6] = +g*tr[0]+h*tr[1];                                               \
+                tt[7] = +g*tr[1]+h*tr[0];                                               \
+                                                                                        \
+                tr *= tr;                                                               \
+                                                                                        \
+                tt *= (mixam/tr.sum());                                                 \
+                                                                                        \
+                a = tt[0];                                                              \
+                b = tt[1];                                                              \
+                c = tt[2];                                                              \
+                d = tt[3];                                                              \
+                e = tt[4];                                                              \
+                f = tt[5];                                                              \
+                g = tt[6];                                                              \
+                h = tt[7];                                                              \
+                                                                                        \
+                return(*this);                                                          \
+            }
+#endif    /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
+    
+#if defined(__GNUC__) && (__GNUC__ < 3)
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type)                                           \
+            octonion<type> &            operator /= (::boost::math::quaternion<type> const & rhs)    \
+            {                                                                                        \
+                using    ::std::valarray;                                                            \
+                                                                                                     \
+                valarray<type>    tr(4);                                                             \
+                                                                                                     \
+                tr[0] = static_cast<type>(rhs.R_component_1());                                      \
+                tr[1] = static_cast<type>(rhs.R_component_2());                                      \
+                tr[2] = static_cast<type>(rhs.R_component_3());                                      \
+                tr[3] = static_cast<type>(rhs.R_component_4());                                      \
+                                                                                                     \
+                type           mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();\
+                                                                                                     \
+                tr *= mixam;                                                                         \
+                                                                                                     \
+                valarray<type>    tt(8);                                                             \
+                                                                                                     \
+                tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3];                                            \
+                tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2];                                            \
+                tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1];                                            \
+                tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0];                                            \
+                tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3];                                            \
+                tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2];                                            \
+                tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1];                                            \
+                tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0];                                            \
+                                                                                                     \
+                tr *= tr;                                                                            \
+                                                                                                     \
+                tt *= (mixam/tr.sum());                                                              \
+                                                                                                     \
+                a = tt[0];                                                                           \
+                b = tt[1];                                                                           \
+                c = tt[2];                                                                           \
+                d = tt[3];                                                                           \
+                e = tt[4];                                                                           \
+                f = tt[5];                                                                           \
+                g = tt[6];                                                                           \
+                h = tt[7];                                                                           \
+                                                                                                     \
+                return(*this);                                                                       \
+            }
+#elif    defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type)                                           \
+            octonion<type> &            operator /= (::boost::math::quaternion<type> const & rhs)    \
+            {                                                                                        \
+                using    ::std::valarray;                                                            \
+                using    ::std::abs;                                                                 \
+                                                                                                     \
+                valarray<type>    tr(4);                                                             \
+                                                                                                     \
+                tr[0] = static_cast<type>(rhs.R_component_1());                                      \
+                tr[1] = static_cast<type>(rhs.R_component_2());                                      \
+                tr[2] = static_cast<type>(rhs.R_component_3());                                      \
+                tr[3] = static_cast<type>(rhs.R_component_4());                                      \
+                                                                                                     \
+                type            mixam = static_cast<type>(1)/(abs(tr).max)();                        \
+                                                                                                     \
+                tr *= mixam;                                                                         \
+                                                                                                     \
+                valarray<type>    tt(8);                                                             \
+                                                                                                     \
+                tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3];                                            \
+                tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2];                                            \
+                tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1];                                            \
+                tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0];                                            \
+                tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3];                                            \
+                tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2];                                            \
+                tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1];                                            \
+                tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0];                                            \
+                                                                                                     \
+                tr *= tr;                                                                            \
+                                                                                                     \
+                tt *= (mixam/tr.sum());                                                              \
+                                                                                                     \
+                a = tt[0];                                                                           \
+                b = tt[1];                                                                           \
+                c = tt[2];                                                                           \
+                d = tt[3];                                                                           \
+                e = tt[4];                                                                           \
+                f = tt[5];                                                                           \
+                g = tt[6];                                                                           \
+                h = tt[7];                                                                           \
+                                                                                                     \
+                return(*this);                                                                       \
+            }
+#else
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type)                                           \
+            octonion<type> &            operator /= (::boost::math::quaternion<type> const & rhs)    \
+            {                                                                                        \
+                using    ::std::valarray;                                                            \
+                                                                                                     \
+                valarray<type>    tr(4);                                                             \
+                                                                                                     \
+                tr[0] = static_cast<type>(rhs.R_component_1());                                      \
+                tr[1] = static_cast<type>(rhs.R_component_2());                                      \
+                tr[2] = static_cast<type>(rhs.R_component_3());                                      \
+                tr[3] = static_cast<type>(rhs.R_component_4());                                      \
+                                                                                                     \
+                type            mixam = static_cast<type>(1)/(abs(tr).max)();                        \
+                                                                                                     \
+                tr *= mixam;                                                                         \
+                                                                                                     \
+                valarray<type>    tt(8);                                                             \
+                                                                                                     \
+                tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3];                                            \
+                tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2];                                            \
+                tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1];                                            \
+                tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0];                                            \
+                tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3];                                            \
+                tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2];                                            \
+                tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1];                                            \
+                tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0];                                            \
+                                                                                                     \
+                tr *= tr;                                                                            \
+                                                                                                     \
+                tt *= (mixam/tr.sum());                                                              \
+                                                                                                     \
+                a = tt[0];                                                                           \
+                b = tt[1];                                                                           \
+                c = tt[2];                                                                           \
+                d = tt[3];                                                                           \
+                e = tt[4];                                                                           \
+                f = tt[5];                                                                           \
+                g = tt[6];                                                                           \
+                h = tt[7];                                                                           \
+                                                                                                     \
+                return(*this);                                                                       \
+            }
+#endif    /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
+    
+#if defined(__GNUC__) && (__GNUC__ < 3)
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type)                                           \
+            template<typename X>                                                                     \
+            octonion<type> &            operator /= (octonion<X> const & rhs)                        \
+            {                                                                                        \
+                using    ::std::valarray;                                                            \
+                                                                                                     \
+                valarray<type>    tr(8);                                                             \
+                                                                                                     \
+                tr[0] = static_cast<type>(rhs.R_component_1());                                      \
+                tr[1] = static_cast<type>(rhs.R_component_2());                                      \
+                tr[2] = static_cast<type>(rhs.R_component_3());                                      \
+                tr[3] = static_cast<type>(rhs.R_component_4());                                      \
+                tr[4] = static_cast<type>(rhs.R_component_5());                                      \
+                tr[5] = static_cast<type>(rhs.R_component_6());                                      \
+                tr[6] = static_cast<type>(rhs.R_component_7());                                      \
+                tr[7] = static_cast<type>(rhs.R_component_8());                                      \
+                                                                                                     \
+                type           mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();\
+                                                                                                     \
+                tr *= mixam;                                                                         \
+                                                                                                     \
+                valarray<type>    tt(8);                                                             \
+                                                                                                     \
+                tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7];            \
+                tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6];            \
+                tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5];            \
+                tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4];            \
+                tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3];            \
+                tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2];            \
+                tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1];            \
+                tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0];            \
+                                                                                                     \
+                tr *= tr;                                                                            \
+                                                                                                     \
+                tt *= (mixam/tr.sum());                                                              \
+                                                                                                     \
+                a = tt[0];                                                                           \
+                b = tt[1];                                                                           \
+                c = tt[2];                                                                           \
+                d = tt[3];                                                                           \
+                e = tt[4];                                                                           \
+                f = tt[5];                                                                           \
+                g = tt[6];                                                                           \
+                h = tt[7];                                                                           \
+                                                                                                     \
+                return(*this);                                                                       \
+            }
+#elif    defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type)                                           \
+            template<typename X>                                                                     \
+            octonion<type> &            operator /= (octonion<X> const & rhs)                        \
+            {                                                                                        \
+                using    ::std::valarray;                                                            \
+                using    ::std::abs;                                                                 \
+                                                                                                     \
+                valarray<type>    tr(8);                                                             \
+                                                                                                     \
+                tr[0] = static_cast<type>(rhs.R_component_1());                                      \
+                tr[1] = static_cast<type>(rhs.R_component_2());                                      \
+                tr[2] = static_cast<type>(rhs.R_component_3());                                      \
+                tr[3] = static_cast<type>(rhs.R_component_4());                                      \
+                tr[4] = static_cast<type>(rhs.R_component_5());                                      \
+                tr[5] = static_cast<type>(rhs.R_component_6());                                      \
+                tr[6] = static_cast<type>(rhs.R_component_7());                                      \
+                tr[7] = static_cast<type>(rhs.R_component_8());                                      \
+                                                                                                     \
+                type            mixam = static_cast<type>(1)/(abs(tr).max)();                        \
+                                                                                                     \
+                tr *= mixam;                                                                         \
+                                                                                                     \
+                valarray<type>    tt(8);                                                             \
+                                                                                                     \
+                tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7];            \
+                tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6];            \
+                tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5];            \
+                tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4];            \
+                tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3];            \
+                tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2];            \
+                tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1];            \
+                tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0];            \
+                                                                                                     \
+                tr *= tr;                                                                            \
+                                                                                                     \
+                tt *= (mixam/tr.sum());                                                              \
+                                                                                                     \
+                a = tt[0];                                                                           \
+                b = tt[1];                                                                           \
+                c = tt[2];                                                                           \
+                d = tt[3];                                                                           \
+                e = tt[4];                                                                           \
+                f = tt[5];                                                                           \
+                g = tt[6];                                                                           \
+                h = tt[7];                                                                           \
+                                                                                                     \
+                return(*this);                                                                       \
+            }
+#else
+    #define    BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type)                                           \
+            template<typename X>                                                                     \
+            octonion<type> &            operator /= (octonion<X> const & rhs)                        \
+            {                                                                                        \
+                using    ::std::valarray;                                                            \
+                                                                                                     \
+                valarray<type>    tr(8);                                                             \
+                                                                                                     \
+                tr[0] = static_cast<type>(rhs.R_component_1());                                      \
+                tr[1] = static_cast<type>(rhs.R_component_2());                                      \
+                tr[2] = static_cast<type>(rhs.R_component_3());                                      \
+                tr[3] = static_cast<type>(rhs.R_component_4());                                      \
+                tr[4] = static_cast<type>(rhs.R_component_5());                                      \
+                tr[5] = static_cast<type>(rhs.R_component_6());                                      \
+                tr[6] = static_cast<type>(rhs.R_component_7());                                      \
+                tr[7] = static_cast<type>(rhs.R_component_8());                                      \
+                                                                                                     \
+                type            mixam = static_cast<type>(1)/(abs(tr).max)();                        \
+                                                                                                     \
+                tr *= mixam;                                                                         \
+                                                                                                     \
+                valarray<type>    tt(8);                                                             \
+                                                                                                     \
+                tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7];            \
+                tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6];            \
+                tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5];            \
+                tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4];            \
+                tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3];            \
+                tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2];            \
+                tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1];            \
+                tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0];            \
+                                                                                                     \
+                tr *= tr;                                                                            \
+                                                                                                     \
+                tt *= (mixam/tr.sum());                                                              \
+                                                                                                     \
+                a = tt[0];                                                                           \
+                b = tt[1];                                                                           \
+                c = tt[2];                                                                           \
+                d = tt[3];                                                                           \
+                e = tt[4];                                                                           \
+                f = tt[5];                                                                           \
+                g = tt[6];                                                                           \
+                h = tt[7];                                                                           \
+                                                                                                     \
+                return(*this);                                                                       \
+            }
+#endif    /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
+    
+    
+#define    BOOST_OCTONION_MEMBER_ADD_GENERATOR(type)       \
+        BOOST_OCTONION_MEMBER_ADD_GENERATOR_1(type)        \
+        BOOST_OCTONION_MEMBER_ADD_GENERATOR_2(type)        \
+        BOOST_OCTONION_MEMBER_ADD_GENERATOR_3(type)        \
+        BOOST_OCTONION_MEMBER_ADD_GENERATOR_4(type)
+        
+#define    BOOST_OCTONION_MEMBER_SUB_GENERATOR(type)       \
+        BOOST_OCTONION_MEMBER_SUB_GENERATOR_1(type)        \
+        BOOST_OCTONION_MEMBER_SUB_GENERATOR_2(type)        \
+        BOOST_OCTONION_MEMBER_SUB_GENERATOR_3(type)        \
+        BOOST_OCTONION_MEMBER_SUB_GENERATOR_4(type)
+        
+#define    BOOST_OCTONION_MEMBER_MUL_GENERATOR(type)       \
+        BOOST_OCTONION_MEMBER_MUL_GENERATOR_1(type)        \
+        BOOST_OCTONION_MEMBER_MUL_GENERATOR_2(type)        \
+        BOOST_OCTONION_MEMBER_MUL_GENERATOR_3(type)        \
+        BOOST_OCTONION_MEMBER_MUL_GENERATOR_4(type)
+        
+#define    BOOST_OCTONION_MEMBER_DIV_GENERATOR(type)       \
+        BOOST_OCTONION_MEMBER_DIV_GENERATOR_1(type)        \
+        BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type)        \
+        BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type)        \
+        BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type)
+        
+#define    BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(type) \
+        BOOST_OCTONION_MEMBER_ADD_GENERATOR(type)          \
+        BOOST_OCTONION_MEMBER_SUB_GENERATOR(type)          \
+        BOOST_OCTONION_MEMBER_MUL_GENERATOR(type)          \
+        BOOST_OCTONION_MEMBER_DIV_GENERATOR(type)
+        
+        
+        template<>
+        class octonion<float>
+        {
+        public:
+            
+            typedef float value_type;
+            
+            BOOST_OCTONION_CONSTRUCTOR_GENERATOR(float)
+            
+            // UNtemplated copy constructor
+            // (this is taken care of by the compiler itself)
+            
+            // explicit copy constructors (precision-loosing converters)
+            
+            explicit                    octonion(octonion<double> const & a_recopier)
+            {
+                *this = detail::octonion_type_converter<float, double>(a_recopier);
+            }
+            
+            explicit                    octonion(octonion<long double> const & a_recopier)
+            {
+                *this = detail::octonion_type_converter<float, long double>(a_recopier);
+            }
+            
+            // destructor
+            // (this is taken care of by the compiler itself)
+            
+            // accessors
+            //
+            // Note:    Like complex number, octonions do have a meaningful notion of "real part",
+            //            but unlike them there is no meaningful notion of "imaginary part".
+            //            Instead there is an "unreal part" which itself is an octonion, and usually
+            //            nothing simpler (as opposed to the complex number case).
+            //            However, for practicallity, there are accessors for the other components
+            //            (these are necessary for the templated copy constructor, for instance).
+            
+            BOOST_OCTONION_ACCESSOR_GENERATOR(float)
+            
+            // assignment operators
+            
+            BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(float)
+            
+            // other assignment-related operators
+            //
+            // NOTE:    Octonion multiplication is *NOT* commutative;
+            //            symbolically, "q *= rhs;" means "q = q * rhs;"
+            //            and "q /= rhs;" means "q = q * inverse_of(rhs);";
+            //            octonion multiplication is also *NOT* associative
+            
+            BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(float)
+            
+            
+        protected:
+            
+            BOOST_OCTONION_MEMBER_DATA_GENERATOR(float)
+            
+            
+        private:
+            
+        };
+        
+        
+        template<>
+        class octonion<double>
+        {
+        public:
+            
+            typedef double value_type;
+            
+            BOOST_OCTONION_CONSTRUCTOR_GENERATOR(double)
+            
+            // UNtemplated copy constructor
+            // (this is taken care of by the compiler itself)
+            
+            // converting copy constructor
+            
+            explicit                    octonion(octonion<float> const & a_recopier)
+            {
+                *this = detail::octonion_type_converter<double, float>(a_recopier);
+            }
+            
+            // explicit copy constructors (precision-loosing converters)
+            
+            explicit                    octonion(octonion<long double> const & a_recopier)
+            {
+                *this = detail::octonion_type_converter<double, long double>(a_recopier);
+            }
+            
+            // destructor
+            // (this is taken care of by the compiler itself)
+            
+            // accessors
+            //
+            // Note:    Like complex number, octonions do have a meaningful notion of "real part",
+            //            but unlike them there is no meaningful notion of "imaginary part".
+            //            Instead there is an "unreal part" which itself is an octonion, and usually
+            //            nothing simpler (as opposed to the complex number case).
+            //            However, for practicallity, there are accessors for the other components
+            //            (these are necessary for the templated copy constructor, for instance).
+            
+            BOOST_OCTONION_ACCESSOR_GENERATOR(double)
+            
+            // assignment operators
+            
+            BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(double)
+            
+            // other assignment-related operators
+            //
+            // NOTE:    Octonion multiplication is *NOT* commutative;
+            //            symbolically, "q *= rhs;" means "q = q * rhs;"
+            //            and "q /= rhs;" means "q = q * inverse_of(rhs);";
+            //            octonion multiplication is also *NOT* associative
+            
+            BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(double)
+            
+            
+        protected:
+            
+            BOOST_OCTONION_MEMBER_DATA_GENERATOR(double)
+            
+            
+        private:
+            
+        };
+        
+        
+        template<>
+        class octonion<long double>
+        {
+        public:
+            
+            typedef long double value_type;
+            
+            BOOST_OCTONION_CONSTRUCTOR_GENERATOR(long double)
+            
+            // UNtemplated copy constructor
+            // (this is taken care of by the compiler itself)
+            
+            // converting copy constructor
+            
+            explicit                            octonion(octonion<float> const & a_recopier)
+            {
+                *this = detail::octonion_type_converter<long double, float>(a_recopier);
+            }
+            
+            
+            explicit                            octonion(octonion<double> const & a_recopier)
+            {
+                *this = detail::octonion_type_converter<long double, double>(a_recopier);
+            }
+            
+            
+            // destructor
+            // (this is taken care of by the compiler itself)
+            
+            // accessors
+            //
+            // Note:    Like complex number, octonions do have a meaningful notion of "real part",
+            //            but unlike them there is no meaningful notion of "imaginary part".
+            //            Instead there is an "unreal part" which itself is an octonion, and usually
+            //            nothing simpler (as opposed to the complex number case).
+            //            However, for practicallity, there are accessors for the other components
+            //            (these are necessary for the templated copy constructor, for instance).
+            
+            BOOST_OCTONION_ACCESSOR_GENERATOR(long double)
+            
+            // assignment operators
+            
+            BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR(long double)
+            
+            // other assignment-related operators
+            //
+            // NOTE:    Octonion multiplication is *NOT* commutative;
+            //            symbolically, "q *= rhs;" means "q = q * rhs;"
+            //            and "q /= rhs;" means "q = q * inverse_of(rhs);";
+            //            octonion multiplication is also *NOT* associative
+            
+            BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR(long double)
+            
+            
+        protected:
+            
+            BOOST_OCTONION_MEMBER_DATA_GENERATOR(long double)
+            
+            
+        private:
+            
+        };
+        
+        
+#undef    BOOST_OCTONION_CONSTRUCTOR_GENERATOR
+        
+#undef    BOOST_OCTONION_MEMBER_ALGEBRAIC_GENERATOR
+    
+#undef    BOOST_OCTONION_MEMBER_ADD_GENERATOR
+#undef    BOOST_OCTONION_MEMBER_SUB_GENERATOR
+#undef    BOOST_OCTONION_MEMBER_MUL_GENERATOR
+#undef    BOOST_OCTONION_MEMBER_DIV_GENERATOR
+    
+#undef    BOOST_OCTONION_MEMBER_ADD_GENERATOR_1
+#undef    BOOST_OCTONION_MEMBER_ADD_GENERATOR_2
+#undef    BOOST_OCTONION_MEMBER_ADD_GENERATOR_3
+#undef    BOOST_OCTONION_MEMBER_ADD_GENERATOR_4
+#undef    BOOST_OCTONION_MEMBER_SUB_GENERATOR_1
+#undef    BOOST_OCTONION_MEMBER_SUB_GENERATOR_2
+#undef    BOOST_OCTONION_MEMBER_SUB_GENERATOR_3
+#undef    BOOST_OCTONION_MEMBER_SUB_GENERATOR_4
+#undef    BOOST_OCTONION_MEMBER_MUL_GENERATOR_1
+#undef    BOOST_OCTONION_MEMBER_MUL_GENERATOR_2
+#undef    BOOST_OCTONION_MEMBER_MUL_GENERATOR_3
+#undef    BOOST_OCTONION_MEMBER_MUL_GENERATOR_4
+#undef    BOOST_OCTONION_MEMBER_DIV_GENERATOR_1
+#undef    BOOST_OCTONION_MEMBER_DIV_GENERATOR_2
+#undef    BOOST_OCTONION_MEMBER_DIV_GENERATOR_3
+#undef    BOOST_OCTONION_MEMBER_DIV_GENERATOR_4
+    
+    
+#undef    BOOST_OCTONION_MEMBER_DATA_GENERATOR
+    
+#undef    BOOST_OCTONION_MEMBER_ASSIGNMENT_GENERATOR
+    
+#undef    BOOST_OCTONION_ACCESSOR_GENERATOR
+        
+        
+        // operators
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op) \
+        {                                             \
+            octonion<T>    res(lhs);                  \
+            res op##= rhs;                            \
+            return(res);                              \
+        }
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_1_L(op)                                                                              \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (T const & lhs, octonion<T> const & rhs)                            \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_1_R(op)                                                                              \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (octonion<T> const & lhs, T const & rhs)                            \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_2_L(op)                                                                              \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (::std::complex<T> const & lhs, octonion<T> const & rhs)            \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_2_R(op)                                                                              \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (octonion<T> const & lhs, ::std::complex<T> const & rhs)            \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_3_L(op)                                                                              \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs) \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_3_R(op)                                                                              \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs) \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR_4(op)                                                                                \
+        template<typename T>                                                                                                      \
+        inline octonion<T>                        operator op (octonion<T> const & lhs, octonion<T> const & rhs)                  \
+        BOOST_OCTONION_OPERATOR_GENERATOR_BODY(op)
+        
+#define    BOOST_OCTONION_OPERATOR_GENERATOR(op)     \
+        BOOST_OCTONION_OPERATOR_GENERATOR_1_L(op)    \
+        BOOST_OCTONION_OPERATOR_GENERATOR_1_R(op)    \
+        BOOST_OCTONION_OPERATOR_GENERATOR_2_L(op)    \
+        BOOST_OCTONION_OPERATOR_GENERATOR_2_R(op)    \
+        BOOST_OCTONION_OPERATOR_GENERATOR_3_L(op)    \
+        BOOST_OCTONION_OPERATOR_GENERATOR_3_R(op)    \
+        BOOST_OCTONION_OPERATOR_GENERATOR_4(op)
+        
+        
+        BOOST_OCTONION_OPERATOR_GENERATOR(+)
+        BOOST_OCTONION_OPERATOR_GENERATOR(-)
+        BOOST_OCTONION_OPERATOR_GENERATOR(*)
+        BOOST_OCTONION_OPERATOR_GENERATOR(/)
+        
+        
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR
+        
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_1_L
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_1_R
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_2_L
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_2_R
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_3_L
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_3_R
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_4
+    
+#undef    BOOST_OCTONION_OPERATOR_GENERATOR_BODY
+        
+        
+        template<typename T>
+        inline octonion<T>                        operator + (octonion<T> const & o)
+        {
+            return(o);
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        operator - (octonion<T> const & o)
+        {
+            return(octonion<T>(-o.R_component_1(),-o.R_component_2(),-o.R_component_3(),-o.R_component_4(),-o.R_component_5(),-o.R_component_6(),-o.R_component_7(),-o.R_component_8()));
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (T const & lhs, octonion<T> const & rhs)
+        {
+            return(
+                        (rhs.R_component_1() == lhs)&&
+                        (rhs.R_component_2() == static_cast<T>(0))&&
+                        (rhs.R_component_3() == static_cast<T>(0))&&
+                        (rhs.R_component_4() == static_cast<T>(0))&&
+                        (rhs.R_component_5() == static_cast<T>(0))&&
+                        (rhs.R_component_6() == static_cast<T>(0))&&
+                        (rhs.R_component_7() == static_cast<T>(0))&&
+                        (rhs.R_component_8() == static_cast<T>(0))
+                    );
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (octonion<T> const & lhs, T const & rhs)
+        {
+            return(
+                        (lhs.R_component_1() == rhs)&&
+                        (lhs.R_component_2() == static_cast<T>(0))&&
+                        (lhs.R_component_3() == static_cast<T>(0))&&
+                        (lhs.R_component_4() == static_cast<T>(0))&&
+                        (lhs.R_component_5() == static_cast<T>(0))&&
+                        (lhs.R_component_6() == static_cast<T>(0))&&
+                        (lhs.R_component_7() == static_cast<T>(0))&&
+                        (lhs.R_component_8() == static_cast<T>(0))
+                    );
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (::std::complex<T> const & lhs, octonion<T> const & rhs)
+        {
+            return(
+                        (rhs.R_component_1() == lhs.real())&&
+                        (rhs.R_component_2() == lhs.imag())&&
+                        (rhs.R_component_3() == static_cast<T>(0))&&
+                        (rhs.R_component_4() == static_cast<T>(0))&&
+                        (rhs.R_component_5() == static_cast<T>(0))&&
+                        (rhs.R_component_6() == static_cast<T>(0))&&
+                        (rhs.R_component_7() == static_cast<T>(0))&&
+                        (rhs.R_component_8() == static_cast<T>(0))
+                    );
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (octonion<T> const & lhs, ::std::complex<T> const & rhs)
+        {
+            return(
+                        (lhs.R_component_1() == rhs.real())&&
+                        (lhs.R_component_2() == rhs.imag())&&
+                        (lhs.R_component_3() == static_cast<T>(0))&&
+                        (lhs.R_component_4() == static_cast<T>(0))&&
+                        (lhs.R_component_5() == static_cast<T>(0))&&
+                        (lhs.R_component_6() == static_cast<T>(0))&&
+                        (lhs.R_component_7() == static_cast<T>(0))&&
+                        (lhs.R_component_8() == static_cast<T>(0))
+                    );
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs)
+        {
+            return(
+                        (rhs.R_component_1() == lhs.R_component_1())&&
+                        (rhs.R_component_2() == lhs.R_component_2())&&
+                        (rhs.R_component_3() == lhs.R_component_3())&&
+                        (rhs.R_component_4() == lhs.R_component_4())&&
+                        (rhs.R_component_5() == static_cast<T>(0))&&
+                        (rhs.R_component_6() == static_cast<T>(0))&&
+                        (rhs.R_component_7() == static_cast<T>(0))&&
+                        (rhs.R_component_8() == static_cast<T>(0))
+                    );
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs)
+        {
+            return(
+                        (lhs.R_component_1() == rhs.R_component_1())&&
+                        (lhs.R_component_2() == rhs.R_component_2())&&
+                        (lhs.R_component_3() == rhs.R_component_3())&&
+                        (lhs.R_component_4() == rhs.R_component_4())&&
+                        (lhs.R_component_5() == static_cast<T>(0))&&
+                        (lhs.R_component_6() == static_cast<T>(0))&&
+                        (lhs.R_component_7() == static_cast<T>(0))&&
+                        (lhs.R_component_8() == static_cast<T>(0))
+                    );
+        }
+        
+        
+        template<typename T>
+        inline bool                                operator == (octonion<T> const & lhs, octonion<T> const & rhs)
+        {
+            return(
+                        (rhs.R_component_1() == lhs.R_component_1())&&
+                        (rhs.R_component_2() == lhs.R_component_2())&&
+                        (rhs.R_component_3() == lhs.R_component_3())&&
+                        (rhs.R_component_4() == lhs.R_component_4())&&
+                        (rhs.R_component_5() == lhs.R_component_5())&&
+                        (rhs.R_component_6() == lhs.R_component_6())&&
+                        (rhs.R_component_7() == lhs.R_component_7())&&
+                        (rhs.R_component_8() == lhs.R_component_8())
+                    );
+        }
+        
+        
+#define    BOOST_OCTONION_NOT_EQUAL_GENERATOR \
+        {                                     \
+            return(!(lhs == rhs));            \
+        }
+        
+        template<typename T>
+        inline bool                                operator != (T const & lhs, octonion<T> const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        template<typename T>
+        inline bool                                operator != (octonion<T> const & lhs, T const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        template<typename T>
+        inline bool                                operator != (::std::complex<T> const & lhs, octonion<T> const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        template<typename T>
+        inline bool                                operator != (octonion<T> const & lhs, ::std::complex<T> const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        template<typename T>
+        inline bool                                operator != (::boost::math::quaternion<T> const & lhs, octonion<T> const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        template<typename T>
+        inline bool                                operator != (octonion<T> const & lhs, ::boost::math::quaternion<T> const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        template<typename T>
+        inline bool                                operator != (octonion<T> const & lhs, octonion<T> const & rhs)
+        BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+    #undef    BOOST_OCTONION_NOT_EQUAL_GENERATOR
+        
+        
+        // Note:    the default values in the constructors of the complex and quaternions make for
+        //            a very complex and ambiguous situation; we have made choices to disambiguate.
+        
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+        template<typename T>
+        ::std::istream &                        operator >> (    ::std::istream & is,
+                                                                octonion<T>& o)
+#else
+        template<typename T, typename charT, class traits>
+        ::std::basic_istream<charT,traits> &    operator >> (    ::std::basic_istream<charT,traits> & is,
+                                                                octonion<T> & o)
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+            typedef    char    charT;
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+            
+#ifdef     BOOST_NO_STD_LOCALE
+#else
+            const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc());
+#endif /* BOOST_NO_STD_LOCALE */
+            
+            T    a = T();
+            T    b = T();
+            T    c = T();
+            T    d = T();
+            T    e = T();
+            T    f = T();
+            T    g = T();
+            T    h = T();
+            
+            ::std::complex<T>    u = ::std::complex<T>();
+            ::std::complex<T>    v = ::std::complex<T>();
+            ::std::complex<T>    x = ::std::complex<T>();
+            ::std::complex<T>    y = ::std::complex<T>();
+            
+            ::boost::math::quaternion<T>    p = ::boost::math::quaternion<T>();
+            ::boost::math::quaternion<T>    q = ::boost::math::quaternion<T>();
+            
+            charT    ch = charT();
+            char    cc;
+            
+            is >> ch;                                        // get the first lexeme
+            
+            if    (!is.good())    goto finish;
+            
+#ifdef    BOOST_NO_STD_LOCALE
+            cc = ch;
+#else
+            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+            
+            if    (cc == '(')                            // read "("
+            {
+                is >> ch;                                    // get the second lexeme
+                
+                if    (!is.good())    goto finish;
+                
+#ifdef    BOOST_NO_STD_LOCALE
+                cc = ch;
+#else
+                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                
+                if    (cc == '(')                                // read "(("
+                {
+                    is >> ch;                                    // get the third lexeme
+                    
+                    if    (!is.good())    goto finish;
+                    
+#ifdef    BOOST_NO_STD_LOCALE
+                    cc = ch;
+#else
+                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                        
+                    if    (cc == '(')                                // read "((("
+                    {
+                        is.putback(ch);
+                        
+                        is >> u;                                // read "((u"
+                        
+                        if    (!is.good())    goto finish;
+                        
+                        is >> ch;                                // get the next lexeme
+                        
+                        if    (!is.good())    goto finish;
+                        
+#ifdef    BOOST_NO_STD_LOCALE
+                        cc = ch;
+#else
+                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                        
+                        if        (cc == ')')                        // read "((u)"
+                        {
+                            is >> ch;                                // get the next lexeme
+                            
+                            if    (!is.good())    goto finish;
+                            
+#ifdef    BOOST_NO_STD_LOCALE
+                            cc = ch;
+#else
+                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                            
+                            if        (cc == ')')                        // format: (((a))), (((a,b)))
+                            {
+                                o = octonion<T>(u);
+                            }
+                            else if    (cc == ',')                        // read "((u),"
+                            {
+                                p = ::boost::math::quaternion<T>(u);
+                                
+                                is >> q;                                // read "((u),q"
+                                
+                                if    (!is.good())    goto finish;
+                                
+                                is >> ch;                                // get the next lexeme
+                                
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == ')')                        // format: (((a)),q), (((a,b)),q)
+                                {
+                                    o = octonion<T>(p,q);
+                                }
+                                else                                    // error
+                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                    is.setstate(::std::ios::failbit);
+#else
+                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                }
+                            }
+                            else                                    // error
+                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                is.setstate(::std::ios::failbit);
+#else
+                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                            }
+                        }
+                        else if    (cc ==',')                        // read "((u,"
+                        {
+                            is >> v;                                // read "((u,v"
+                            
+                            if    (!is.good())    goto finish;
+                            
+                            is >> ch;                                // get the next lexeme
+                            
+                            if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                            cc = ch;
+#else
+                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                            
+                            if        (cc == ')')                        // read "((u,v)"
+                            {
+                                p = ::boost::math::quaternion<T>(u,v);
+                                
+                                is >> ch;                                // get the next lexeme
+                                
+                                if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == ')')                        // format: (((a),v)), (((a,b),v))
+                                {
+                                    o = octonion<T>(p);
+                                }
+                                else if    (cc == ',')                        // read "((u,v),"
+                                {
+                                    is >> q;                                // read "(p,q"
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+                                    is >> ch;                                // get the next lexeme
+                                    
+                                    if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                        // format: (((a),v),q), (((a,b),v),q)
+                                    {
+                                        o = octonion<T>(p,q);
+                                    }
+                                    else                                    // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                                else                                    // error
+                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                    is.setstate(::std::ios::failbit);
+#else
+                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                }
+                            }
+                            else                                    // error
+                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                is.setstate(::std::ios::failbit);
+#else
+                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                            }
+                        }
+                        else                                    // error
+                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                            is.setstate(::std::ios::failbit);
+#else
+                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                        }
+                    }
+                    else                                        // read "((a"
+                    {
+                        is.putback(ch);
+                        
+                        is >> a;                                    // we extract the first component
+                        
+                        if    (!is.good())    goto finish;
+                        
+                        is >> ch;                                    // get the next lexeme
+                        
+                        if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                        cc = ch;
+#else
+                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                        
+                        if        (cc == ')')                            // read "((a)"
+                        {
+                            is >> ch;                                    // get the next lexeme
+                            
+                            if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                            cc = ch;
+#else
+                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                            
+                            if        (cc == ')')                            // read "((a))"
+                            {
+                                o = octonion<T>(a);
+                            }
+                            else if    (cc == ',')                            // read "((a),"
+                            {
+                                is >> ch;                                    // get the next lexeme
+                                
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == '(')                            // read "((a),("
+                                {
+                                    is >> ch;                                    // get the next lexeme
+                                    
+                                    if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == '(')                            // read "((a),(("
+                                    {
+                                        is.putback(ch);
+                                        
+                                        is.putback(ch);                                // we backtrack twice, with the same value!
+                                        
+                                        is >> q;                                    // read "((a),q"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                        
+                                        if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "((a),q)"
+                                        {
+                                            p = ::boost::math::quaternion<T>(a);
+                                            
+                                            o = octonion<T>(p,q);
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // read "((a),(c" or "((a),(e"
+                                    {
+                                        is.putback(ch);
+                                        
+                                        is >> c;
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "((a),(c)" (ambiguity resolution)
+                                        {
+                                            is >> ch;                                    // get the next lexeme
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                        // read "((a),(c))"
+                                            {
+                                                o = octonion<T>(a,b,c);
+                                            }
+                                            else if    (cc == ',')                        // read "((a),(c),"
+                                            {
+                                                u = ::std::complex<T>(a);
+                                                
+                                                v = ::std::complex<T>(c);
+                                                
+                                                is >> x;                            // read "((a),(c),x"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                // get the next lexeme
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                        // read "((a),(c),x)"
+                                                {
+                                                    o = octonion<T>(u,v,x);
+                                                }
+                                                else if    (cc == ',')                        // read "((a),(c),x,"
+                                                {
+                                                    is >> y;                                // read "((a),(c),x,y"
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+                                                    is >> ch;                                // get the next lexeme
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                        // read "((a),(c),x,y)"
+                                                    {
+                                                        o = octonion<T>(u,v,x,y);
+                                                    }
+                                                    else                                    // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else                                    // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                    // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else if    (cc == ',')                            // read "((a),(c," or "((a),(e,"
+                                        {
+                                            is >> ch;                                // get the next lexeme
+                                            
+                                            if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == '(')                        // read "((a),(e,(" (ambiguity resolution)
+                                            {
+                                                p = ::boost::math::quaternion<T>(a);
+                                                
+                                                x = ::std::complex<T>(c);                // "c" was actually "e"
+                                                
+                                                is.putback(ch);                            // we can only backtrace once
+                                                
+                                                is >> y;                                // read "((a),(e,y"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                // get the next lexeme
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                        // read "((a),(e,y)"
+                                                {
+                                                    q = ::boost::math::quaternion<T>(x,y);
+                                                    
+                                                    is >> ch;                                // get the next lexeme
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                        // read "((a),(e,y))"
+                                                    {
+                                                        o = octonion<T>(p,q);
+                                                    }
+                                                    else                                    // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else                                    // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                    // read "((a),(c,d" or "((a),(e,f"
+                                            {
+                                                is.putback(ch);
+                                                
+                                                is >> d;
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                // get the next lexeme
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                        // read "((a),(c,d)" (ambiguity resolution)
+                                                {
+                                                    is >> ch;                                // get the next lexeme
+                                                    
+                                                    if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                        // read "((a),(c,d))"
+                                                    {
+                                                        o = octonion<T>(a,b,c,d);
+                                                    }
+                                                    else if    (cc == ',')                        // read "((a),(c,d),"
+                                                    {
+                                                        u = ::std::complex<T>(a);
+                                                        
+                                                        v = ::std::complex<T>(c,d);
+                                                        
+                                                        is >> x;                                // read "((a),(c,d),x"
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+                                                        is >> ch;                                // get the next lexeme
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                        // read "((a),(c,d),x)"
+                                                        {
+                                                            o = octonion<T>(u,v,x);
+                                                        }
+                                                        else if    (cc == ',')                        // read "((a),(c,d),x,"
+                                                        {
+                                                            is >> y;                                // read "((a),(c,d),x,y"
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+                                                            is >> ch;                                // get the next lexeme
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                        // read "((a),(c,d),x,y)"
+                                                            {
+                                                                o = octonion<T>(u,v,x,y);
+                                                            }
+                                                            else                                    // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else                                    // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                    else                                    // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else if    (cc == ',')                        // read "((a),(e,f," (ambiguity resolution)
+                                                {
+                                                    p = ::boost::math::quaternion<T>(a);
+                                                    
+                                                    is >> g;                                // read "((a),(e,f,g" (too late to backtrack)
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+                                                    is >> ch;                                // get the next lexeme
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                        // read "((a),(e,f,g)"
+                                                    {
+                                                        q = ::boost::math::quaternion<T>(c,d,g);        // "c" was actually "e", and "d" was actually "f"
+                                                        
+                                                        is >> ch;                                // get the next lexeme
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                        // read "((a),(e,f,g))"
+                                                        {
+                                                            o = octonion<T>(p,q);
+                                                        }
+                                                        else                                    // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                    else if    (cc == ',')                        // read "((a),(e,f,g,"
+                                                    {
+                                                        is >> h;                                // read "((a),(e,f,g,h"
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+                                                        is >> ch;                                // get the next lexeme
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                        // read "((a),(e,f,g,h)"
+                                                        {
+                                                            q = ::boost::math::quaternion<T>(c,d,g,h);    // "c" was actually "e", and "d" was actually "f"
+                                                            
+                                                            is >> ch;                                // get the next lexeme
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                        // read "((a),(e,f,g,h))"
+                                                            {
+                                                                o = octonion<T>(p,q);
+                                                            }
+                                                            else                                    // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else                                    // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                    else                                    // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else                                    // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                }
+                                else                                        // read "((a),c" (ambiguity resolution)
+                                {
+                                    is.putback(ch);
+                                    
+                                    is >> c;                                    // we extract the third component
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+                                    is >> ch;                                    // get the next lexeme
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "((a),c)"
+                                    {
+                                        o = octonion<T>(a,b,c);
+                                    }
+                                    else if    (cc == ',')                            // read "((a),c,"
+                                    {
+                                        is >> x;                                    // read "((a),c,x"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "((a),c,x)"
+                                        {
+                                            o = octonion<T>(a,b,c,d,x.real(),x.imag());
+                                        }
+                                        else if    (cc == ',')                            // read "((a),c,x,"
+                                        {
+                                            is >> y;if    (!is.good())    goto finish;        // read "((a),c,x,y"
+                                            
+                                            is >> ch;                                    // get the next lexeme
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "((a),c,x,y)"
+                                            {
+                                                o = octonion<T>(a,b,c,d,x.real(),x.imag(),y.real(),y.imag());
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                            }
+                            else                                        // error
+                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                is.setstate(::std::ios::failbit);
+#else
+                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                            }
+                        }
+                        else if    (cc ==',')                            // read "((a,"
+                        {
+                            is >> ch;                                    // get the next lexeme
+                            
+                            if    (!is.good())    goto finish;
+                            
+#ifdef    BOOST_NO_STD_LOCALE
+                            cc = ch;
+#else
+                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                            
+                            if        (cc == '(')                            // read "((a,("
+                            {
+                                u = ::std::complex<T>(a);
+                                
+                                is.putback(ch);                                // can only backtrack so much
+                                
+                                is >> v;                                    // read "((a,v"
+                                
+                                if    (!is.good())    goto finish;
+                                
+                                is >> ch;                                    // get the next lexeme
+                                
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == ')')                            // read "((a,v)"
+                                {
+                                    is >> ch;                                    // get the next lexeme
+                                    
+                                    if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "((a,v))"
+                                    {
+                                        o = octonion<T>(u,v);
+                                    }
+                                    else if    (cc == ',')                            // read "((a,v),"
+                                    {
+                                        p = ::boost::math::quaternion<T>(u,v);
+                                        
+                                        is >> q;                                    // read "((a,v),q"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "((a,v),q)"
+                                        {
+                                            o = octonion<T>(p,q);
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                                else                                        // error
+                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                    is.setstate(::std::ios::failbit);
+#else
+                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                }
+                            }
+                            else
+                            {
+                                is.putback(ch);
+                                
+                                is >> b;                                    // read "((a,b"
+                                
+                                if    (!is.good())    goto finish;
+                                
+                                is >> ch;                                    // get the next lexeme
+                                
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == ')')                            // read "((a,b)"
+                                {
+                                    is >> ch;                                    // get the next lexeme
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "((a,b))"
+                                    {
+                                        o = octonion<T>(a,b);
+                                    }
+                                    else if    (cc == ',')                            // read "((a,b),"
+                                    {
+                                        is >> ch;                                    // get the next lexeme
+                                        
+                                        if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == '(')                            // read "((a,b),("
+                                        {
+                                            is >> ch;                                    // get the next lexeme
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == '(')                            // read "((a,b),(("
+                                            {
+                                                p = ::boost::math::quaternion<T>(a,b);
+                                                
+                                                is.putback(ch);
+                                                
+                                                is.putback(ch);                            // we backtrack twice, with the same value
+                                                
+                                                is >> q;                                // read "((a,b),q"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                    // get the next lexeme
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "((a,b),q)"
+                                                {
+                                                    o = octonion<T>(p,q);
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                        // read "((a,b),(c" or "((a,b),(e"
+                                            {
+                                                is.putback(ch);
+                                                
+                                                is >> c;
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                    // get the next lexeme
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "((a,b),(c)" (ambiguity resolution)
+                                                {
+                                                    is >> ch;                                    // get the next lexeme
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                            // read "((a,b),(c))"
+                                                    {
+                                                        o = octonion<T>(a,b,c);
+                                                    }
+                                                    else if    (cc == ',')                            // read "((a,b),(c),"
+                                                    {
+                                                        u = ::std::complex<T>(a,b);
+                                                        
+                                                        v = ::std::complex<T>(c);
+                                                        
+                                                        is >> x;                                    // read "((a,b),(c),x"
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+                                                        is >> ch;                                    // get the next lexeme
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                            // read "((a,b),(c),x)"
+                                                        {
+                                                            o = octonion<T>(u,v,x);
+                                                        }
+                                                        else if    (cc == ',')                            // read "((a,b),(c),x,"
+                                                        {
+                                                            is >> y;                                    // read "((a,b),(c),x,y"
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+                                                            is >> ch;                                    // get the next lexeme
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                            // read "((a,b),(c),x,y)"
+                                                            {
+                                                                o = octonion<T>(u,v,x,y);
+                                                            }
+                                                            else                                        // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else                                        // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                    else                                        // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else if    (cc == ',')                            // read "((a,b),(c," or "((a,b),(e,"
+                                                {
+                                                    is >> ch;                                    // get the next lexeme
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == '(')                            // read "((a,b),(e,(" (ambiguity resolution)
+                                                    {
+                                                        u = ::std::complex<T>(a,b);
+                                                        
+                                                        x = ::std::complex<T>(c);                    // "c" is actually "e"
+                                                        
+                                                        is.putback(ch);
+                                                        
+                                                        is >> y;                                    // read "((a,b),(e,y"
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+                                                        is >> ch;                                    // get the next lexeme
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                            // read "((a,b),(e,y)"
+                                                        {
+                                                            is >> ch;                                    // get the next lexeme
+                                                            
+                                                            if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                            // read "((a,b),(e,y))"
+                                                            {
+                                                                o = octonion<T>(u,v,x,y);
+                                                            }
+                                                            else                                        // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else                                        // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                    else                                        // read "((a,b),(c,d" or "((a,b),(e,f"
+                                                    {
+                                                        is.putback(ch);
+                                                        
+                                                        is >> d;
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+                                                        is >> ch;                                    // get the next lexeme
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                            // read "((a,b),(c,d)" (ambiguity resolution)
+                                                        {
+                                                            u = ::std::complex<T>(a,b);
+                                                            
+                                                            v = ::std::complex<T>(c,d);
+                                                            
+                                                            is >> ch;                                    // get the next lexeme
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                            // read "((a,b),(c,d))"
+                                                            {
+                                                                o = octonion<T>(u,v);
+                                                            }
+                                                            else if    (cc == ',')                            // read "((a,b),(c,d),"
+                                                            {
+                                                                is >> x;                                    // read "((a,b),(c,d),x
+                                                                
+                                                                if    (!is.good())    goto finish;
+                                                                
+                                                                is >> ch;                                    // get the next lexeme
+                                                                
+                                                                if    (!is.good())    goto finish;
+                                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                                cc = ch;
+#else
+                                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                                
+                                                                if        (cc == ')')                            // read "((a,b),(c,d),x)"
+                                                                {
+                                                                    o = octonion<T>(u,v,x);
+                                                                }
+                                                                else if    (cc == ',')                            // read "((a,b),(c,d),x,"
+                                                                {
+                                                                    is >> y;                                    // read "((a,b),(c,d),x,y"
+                                                                    
+                                                                    if    (!is.good())    goto finish;
+                                                                    
+                                                                    is >> ch;                                    // get the next lexeme
+                                                                    
+                                                                    if    (!is.good())    goto finish;
+                                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                                    cc = ch;
+#else
+                                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                                    
+                                                                    if        (cc == ')')                            // read "((a,b),(c,d),x,y)"
+                                                                    {
+                                                                        o = octonion<T>(u,v,x,y);
+                                                                    }
+                                                                    else                                        // error
+                                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                        is.setstate(::std::ios::failbit);
+#else
+                                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                                    }
+                                                                }
+                                                                else                                        // error
+                                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                    is.setstate(::std::ios::failbit);
+#else
+                                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                                }
+                                                            }
+                                                            else                                        // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else if    (cc == ',')                            // read "((a,b),(e,f," (ambiguity resolution)
+                                                        {
+                                                            p = ::boost::math::quaternion<T>(a,b);                // too late to backtrack
+                                                            
+                                                            is >> g;                                    // read "((a,b),(e,f,g"
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+                                                            is >> ch;                                    // get the next lexeme
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                            // read "((a,b),(e,f,g)"
+                                                            {
+                                                                is >> ch;                                    // get the next lexeme
+                                                                
+                                                                if    (!is.good())    goto finish;
+                                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                                cc = ch;
+#else
+                                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                                
+                                                                if        (cc == ')')                            // read "((a,b),(e,f,g))"
+                                                                {
+                                                                    q = ::boost::math::quaternion<T>(c,d,g);            // "c" is actually "e" and "d" is actually "f"
+                                                                    
+                                                                    o = octonion<T>(p,q);
+                                                                }
+                                                                else                                        // error
+                                                                {
+#if BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                    is.setstate(::std::ios::failbit);
+#else
+                                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                                }
+                                                            }
+                                                            else if    (cc == ',')                            // read "((a,b),(e,f,g,"
+                                                            {
+                                                                is >> h;                                    // read "((a,b),(e,f,g,h"
+                                                                
+                                                                if    (!is.good())    goto finish;
+                                                                
+                                                                is >> ch;                                    // get the next lexeme
+                                                                
+                                                                if    (!is.good())    goto finish;
+                                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                                cc = ch;
+#else
+                                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                                
+                                                                if        (cc == ')')                            // read "((a,b),(e,f,g,h)"
+                                                                {
+                                                                    is >> ch;                                    // get the next lexeme
+                                                                    
+                                                                    if    (!is.good())    goto finish;
+                                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                                    cc = ch;
+#else
+                                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                                    
+                                                                    if        (cc == ')')                            // read ((a,b),(e,f,g,h))"
+                                                                    {
+                                                                        q = ::boost::math::quaternion<T>(c,d,g,h);            // "c" is actually "e" and "d" is actually "f"
+                                                                        
+                                                                        o = octonion<T>(p,q);
+                                                                    }
+                                                                    else                                        // error
+                                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                        is.setstate(::std::ios::failbit);
+#else
+                                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                                    }
+                                                                }
+                                                                else                                        // error
+                                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                    is.setstate(::std::ios::failbit);
+#else
+                                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                                }
+                                                            }
+                                                            else                                        // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else                                        // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                                else if    (cc == ',')                            // read "((a,b,"
+                                {
+                                    is >> c;                                    // read "((a,b,c"
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+                                    is >> ch;                                    // get the next lexeme
+                                                                
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "((a,b,c)"
+                                    {
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "((a,b,c))"
+                                        {
+                                            o = octonion<T>(a,b,c);
+                                        }
+                                        else if    (cc == ',')                            // read "((a,b,c),"
+                                        {
+                                            p = ::boost::math::quaternion<T>(a,b,c);
+                                            
+                                            is >> q;                                    // read "((a,b,c),q"
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "((a,b,c),q)"
+                                            {
+                                                o = octonion<T>(p,q);
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else if    (cc == ',')                            // read "((a,b,c,"
+                                    {
+                                        is >> d;                                    // read "((a,b,c,d"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "((a,b,c,d)"
+                                        {
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "((a,b,c,d))"
+                                            {
+                                                o = octonion<T>(a,b,c,d);
+                                            }
+                                            else if    (cc == ',')                            // read "((a,b,c,d),"
+                                            {
+                                                p = ::boost::math::quaternion<T>(a,b,c,d);
+                                                
+                                                is >> q;                                    // read "((a,b,c,d),q"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                    // get the next lexeme
+                                                                            
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "((a,b,c,d),q)"
+                                                {
+                                                    o = octonion<T>(p,q);
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                                else                                        // error
+                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                    is.setstate(::std::ios::failbit);
+#else
+                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                }
+                            }
+                        }
+                        else                                        // error
+                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                            is.setstate(::std::ios::failbit);
+#else
+                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                        }
+                    }
+                }
+                else                                        // read "(a"
+                {
+                    is.putback(ch);
+                    
+                    is >> a;                                    // we extract the first component
+                    
+                    if    (!is.good())    goto finish;
+                    
+                    is >> ch;                                    // get the next lexeme
+                                                
+                    if    (!is.good())    goto finish;
+                    
+#ifdef    BOOST_NO_STD_LOCALE
+                    cc = ch;
+#else
+                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                    
+                    if        (cc == ')')                            // read "(a)"
+                    {
+                        o = octonion<T>(a);
+                    }
+                    else if    (cc == ',')                            // read "(a,"
+                    {
+                        is >> ch;                                    // get the next lexeme
+                                                    
+                        if    (!is.good())    goto finish;
+                        
+#ifdef    BOOST_NO_STD_LOCALE
+                        cc = ch;
+#else
+                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                        
+                        if        (cc == '(')                            // read "(a,("
+                        {
+                            is >> ch;                                    // get the next lexeme
+                                                        
+                            if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                            cc = ch;
+#else
+                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                            
+                            if        (cc == '(')                            // read "(a,(("
+                            {
+                                p = ::boost::math::quaternion<T>(a);
+                                
+                                is.putback(ch);
+                                
+                                is.putback(ch);                                // we backtrack twice, with the same value
+                                
+                                is >> q;                                    // read "(a,q"
+                                
+                                if    (!is.good())    goto finish;
+                                
+                                is >> ch;                                    // get the next lexeme
+                                                            
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == ')')                            // read "(a,q)"
+                                {
+                                    o = octonion<T>(p,q);
+                                }
+                                else                                        // error
+                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                    is.setstate(::std::ios::failbit);
+#else
+                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                }
+                            }
+                            else                                        // read "(a,(c" or "(a,(e"
+                            {
+                                is.putback(ch);
+                                
+                                is >> c;
+                                
+                                if    (!is.good())    goto finish;
+                                
+                                is >> ch;                                    // get the next lexeme
+                                                            
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == ')')                            // read "(a,(c)" (ambiguity resolution)
+                                {
+                                    is >> ch;                                    // get the next lexeme
+                                                                
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "(a,(c))"
+                                    {
+                                        o = octonion<T>(a,b,c);
+                                    }
+                                    else if    (cc == ',')                            // read "(a,(c),"
+                                    {
+                                        u = ::std::complex<T>(a);
+                                        
+                                        v = ::std::complex<T>(c);
+                                        
+                                        is >> x;                                // read "(a,(c),x"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "(a,(c),x)"
+                                        {
+                                            o = octonion<T>(u,v,x);
+                                        }
+                                        else if    (cc == ',')                            // read "(a,(c),x,"
+                                        {
+                                            is >> y;                                    // read "(a,(c),x,y"
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "(a,(c),x,y)"
+                                            {
+                                                o = octonion<T>(u,v,x,y);
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                                else if    (cc == ',')                            // read "(a,(c," or "(a,(e,"
+                                {
+                                    is >> ch;                                    // get the next lexeme
+                                                                
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == '(')                            // read "(a,(e,(" (ambiguity resolution)
+                                    {
+                                        u = ::std::complex<T>(a);
+                                        
+                                        x = ::std::complex<T>(c);                // "c" is actually "e"
+                                        
+                                        is.putback(ch);                            // we backtrack
+                                        
+                                        is >> y;                                // read "(a,(e,y"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "(a,(e,y)"
+                                        {
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "(a,(e,y))"
+                                            {
+                                                o = octonion<T>(u,v,x,y);
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // read "(a,(c,d" or "(a,(e,f"
+                                    {
+                                        is.putback(ch);
+                                        
+                                        is >> d;
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "(a,(c,d)" (ambiguity resolution)
+                                        {
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "(a,(c,d))"
+                                            {
+                                                o = octonion<T>(a,b,c,d);
+                                            }
+                                            else if    (cc == ',')                            // read "(a,(c,d),"
+                                            {
+                                                u = ::std::complex<T>(a);
+                                                
+                                                v = ::std::complex<T>(c,d);
+                                                
+                                                is >> x;                                // read "(a,(c,d),x"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                    // get the next lexeme
+                                                                            
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "(a,(c,d),x)"
+                                                {
+                                                    o = octonion<T>(u,v,x);
+                                                }
+                                                else if    (cc == ',')                            // read "(a,(c,d),x,"
+                                                {
+                                                    is >> y;                                    // read "(a,(c,d),x,y"
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+                                                    is >> ch;                                    // get the next lexeme
+                                                                                
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                            // read "(a,(c,d),x,y)"
+                                                    {
+                                                        o = octonion<T>(u,v,x,y);
+                                                    }
+                                                    else                                        // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else if    (cc == ',')                            // read "(a,(e,f," (ambiguity resolution)
+                                        {
+                                            p = ::boost::math::quaternion<T>(a);
+                                            
+                                            is >> g;                                    // read "(a,(e,f,g"
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "(a,(e,f,g)"
+                                            {
+                                                is >> ch;                                    // get the next lexeme
+                                                                            
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "(a,(e,f,g))"
+                                                {
+                                                    q = ::boost::math::quaternion<T>(c,d,g);            // "c" is actually "e" and "d" is actually "f"
+                                                    
+                                                    o = octonion<T>(p,q);
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else if    (cc == ',')                            // read "(a,(e,f,g,"
+                                            {
+                                                is >> h;                                    // read "(a,(e,f,g,h"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                    // get the next lexeme
+                                                                            
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "(a,(e,f,g,h)"
+                                                {
+                                                    is >> ch;                                    // get the next lexeme
+                                                                                
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                            // read "(a,(e,f,g,h))"
+                                                    {
+                                                        q = ::boost::math::quaternion<T>(c,d,g,h);            // "c" is actually "e" and "d" is actually "f"
+                                                        
+                                                        o = octonion<T>(p,q);
+                                                    }
+                                                    else                                        // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                }
+                                else                                        // error
+                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                    is.setstate(::std::ios::failbit);
+#else
+                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                }
+                            }
+                        }
+                        else                                        // read "(a,b" or "(a,c" (ambiguity resolution)
+                        {
+                            is.putback(ch);
+                            
+                            is >> b;
+                            
+                            if    (!is.good())    goto finish;
+                            
+                            is >> ch;                                    // get the next lexeme
+                                                        
+                            if    (!is.good())    goto finish;
+                            
+#ifdef    BOOST_NO_STD_LOCALE
+                            cc = ch;
+#else
+                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                            
+                            if        (cc == ')')                            // read "(a,b)" (ambiguity resolution)
+                            {
+                                o = octonion<T>(a,b);
+                            }
+                            else if    (cc == ',')                            // read "(a,b," or "(a,c,"
+                            {
+                                is >> ch;                                    // get the next lexeme
+                                                            
+                                if    (!is.good())    goto finish;
+                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                cc = ch;
+#else
+                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                
+                                if        (cc == '(')                            // read "(a,c,(" (ambiguity resolution)
+                                {
+                                    u = ::std::complex<T>(a);
+                                    
+                                    v = ::std::complex<T>(b);                    // "b" is actually "c"
+                                    
+                                    is.putback(ch);                                // we backtrack
+                                    
+                                    is >> x;                                    // read "(a,c,x"
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+                                    is >> ch;                                    // get the next lexeme
+                                                                
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "(a,c,x)"
+                                    {
+                                        o = octonion<T>(u,v,x);
+                                    }
+                                    else if    (cc == ',')                            // read "(a,c,x,"
+                                    {
+                                        is >> y;                                    // read "(a,c,x,y"                                    // read "(a,c,x"
+                                        
+                                        if    (!is.good())    goto finish;
+                                        
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == ')')                            // read "(a,c,x,y)"
+                                        {
+                                            o = octonion<T>(u,v,x,y);
+                                        }
+                                        else                                        // error
+                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                            is.setstate(::std::ios::failbit);
+#else
+                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                                else                                        // read "(a,b,c" or "(a,c,e"
+                                {
+                                    is.putback(ch);
+                                    
+                                    is >> c;
+                                    
+                                    if    (!is.good())    goto finish;
+                                    
+                                    is >> ch;                                    // get the next lexeme
+                                                                
+                                    if    (!is.good())    goto finish;
+                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                    cc = ch;
+#else
+                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                    
+                                    if        (cc == ')')                            // read "(a,b,c)" (ambiguity resolution)
+                                    {
+                                        o = octonion<T>(a,b,c);
+                                    }
+                                    else if    (cc == ',')                            // read "(a,b,c," or "(a,c,e,"
+                                    {
+                                        is >> ch;                                    // get the next lexeme
+                                                                    
+                                        if    (!is.good())    goto finish;
+                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                        cc = ch;
+#else
+                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                        
+                                        if        (cc == '(')                            // read "(a,c,e,(") (ambiguity resolution)
+                                        {
+                                            u = ::std::complex<T>(a);
+                                            
+                                            v = ::std::complex<T>(b);                    // "b" is actually "c"
+                                            
+                                            x = ::std::complex<T>(c);                    // "c" is actually "e"
+                                            
+                                            is.putback(ch);                                // we backtrack
+                                            
+                                            is >> y;                                    // read "(a,c,e,y"
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "(a,c,e,y)"
+                                            {
+                                                o = octonion<T>(u,v,x,y);
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                        else                                        // read "(a,b,c,d" (ambiguity resolution)
+                                        {
+                                            is.putback(ch);                                // we backtrack
+                                            
+                                            is >> d;
+                                            
+                                            if    (!is.good())    goto finish;
+                                            
+                                            is >> ch;                                    // get the next lexeme
+                                                                        
+                                            if    (!is.good())    goto finish;
+                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                            cc = ch;
+#else
+                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                            
+                                            if        (cc == ')')                            // read "(a,b,c,d)"
+                                            {
+                                                o = octonion<T>(a,b,c,d);
+                                            }
+                                            else if    (cc == ',')                            // read "(a,b,c,d,"
+                                            {
+                                                is >> e;                                    // read "(a,b,c,d,e"
+                                                
+                                                if    (!is.good())    goto finish;
+                                                
+                                                is >> ch;                                    // get the next lexeme
+                                                                            
+                                                if    (!is.good())    goto finish;
+                                                
+#ifdef    BOOST_NO_STD_LOCALE
+                                                cc = ch;
+#else
+                                                cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                
+                                                if        (cc == ')')                            // read "(a,b,c,d,e)"
+                                                {
+                                                    o = octonion<T>(a,b,c,d,e);
+                                                }
+                                                else if    (cc == ',')                            // read "(a,b,c,d,e,"
+                                                {
+                                                    is >> f;                                    // read "(a,b,c,d,e,f"
+                                                    
+                                                    if    (!is.good())    goto finish;
+                                                    
+                                                    is >> ch;                                    // get the next lexeme
+                                                                                
+                                                    if    (!is.good())    goto finish;
+                                                    
+#ifdef    BOOST_NO_STD_LOCALE
+                                                    cc = ch;
+#else
+                                                    cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                    
+                                                    if        (cc == ')')                            // read "(a,b,c,d,e,f)"
+                                                    {
+                                                        o = octonion<T>(a,b,c,d,e,f);
+                                                    }
+                                                    else if    (cc == ',')                            // read "(a,b,c,d,e,f,"
+                                                    {
+                                                        is >> g;                                    // read "(a,b,c,d,e,f,g"                                    // read "(a,b,c,d,e,f"
+                                                        
+                                                        if    (!is.good())    goto finish;
+                                                        
+                                                        is >> ch;                                    // get the next lexeme
+                                                                                    
+                                                        if    (!is.good())    goto finish;
+                                                        
+#ifdef    BOOST_NO_STD_LOCALE
+                                                        cc = ch;
+#else
+                                                        cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                        
+                                                        if        (cc == ')')                            // read "(a,b,c,d,e,f,g)"
+                                                        {
+                                                            o = octonion<T>(a,b,c,d,e,f,g);
+                                                        }
+                                                        else if    (cc == ',')                            // read "(a,b,c,d,e,f,g,"
+                                                        {
+                                                            is >> h;                                    // read "(a,b,c,d,e,f,g,h"                                    // read "(a,b,c,d,e,f,g"                                    // read "(a,b,c,d,e,f"
+                                                            
+                                                            if    (!is.good())    goto finish;
+                                                            
+                                                            is >> ch;                                    // get the next lexeme
+                                                                                        
+                                                            if    (!is.good())    goto finish;
+                                                            
+#ifdef    BOOST_NO_STD_LOCALE
+                                                            cc = ch;
+#else
+                                                            cc = ct.narrow(ch, char());
+#endif /* BOOST_NO_STD_LOCALE */
+                                                            
+                                                            if        (cc == ')')                            // read "(a,b,c,d,e,f,g,h)"
+                                                            {
+                                                                o = octonion<T>(a,b,c,d,e,f,g,h);
+                                                            }
+                                                            else                                        // error
+                                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                                is.setstate(::std::ios::failbit);
+#else
+                                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                            }
+                                                        }
+                                                        else                                        // error
+                                                        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                            is.setstate(::std::ios::failbit);
+#else
+                                                            is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                        }
+                                                    }
+                                                    else                                        // error
+                                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                        is.setstate(::std::ios::failbit);
+#else
+                                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                    }
+                                                }
+                                                else                                        // error
+                                                {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                    is.setstate(::std::ios::failbit);
+#else
+                                                    is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                                }
+                                            }
+                                            else                                        // error
+                                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                                is.setstate(::std::ios::failbit);
+#else
+                                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                            }
+                                        }
+                                    }
+                                    else                                        // error
+                                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                        is.setstate(::std::ios::failbit);
+#else
+                                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                                    }
+                                }
+                            }
+                            else                                        // error
+                            {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                                is.setstate(::std::ios::failbit);
+#else
+                                is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                            }
+                        }
+                    }
+                    else                                        // error
+                    {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+                        is.setstate(::std::ios::failbit);
+#else
+                        is.setstate(::std::ios_base::failbit);
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+                    }
+                }
+            }
+            else                                        // format:    a
+            {
+                is.putback(ch);
+                
+                is >> a;                                    // we extract the first component
+                
+                if    (!is.good())    goto finish;
+                
+                o = octonion<T>(a);
+            }
+            
+            finish:
+            return(is);
+        }
+        
+        
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+        template<typename T>
+        ::std::ostream &                        operator << (    ::std::ostream & os,
+                                                                octonion<T> const & o)
+#else
+        template<typename T, typename charT, class traits>
+        ::std::basic_ostream<charT,traits> &    operator << (    ::std::basic_ostream<charT,traits> & os,
+                                                                octonion<T> const & o)
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+        {
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+            ::std::ostringstream                        s;
+#else
+            ::std::basic_ostringstream<charT,traits>    s;
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+            
+            s.flags(os.flags());
+#ifdef    BOOST_NO_STD_LOCALE
+#else
+            s.imbue(os.getloc());
+#endif /* BOOST_NO_STD_LOCALE */
+            s.precision(os.precision());
+            
+            s << '('    << o.R_component_1() << ','
+                        << o.R_component_2() << ','
+                        << o.R_component_3() << ','
+                        << o.R_component_4() << ','
+                        << o.R_component_5() << ','
+                        << o.R_component_6() << ','
+                        << o.R_component_7() << ','
+                        << o.R_component_8() << ')';
+            
+            return os << s.str();
+        }
+        
+        
+        // values
+        
+        template<typename T>
+        inline T                                real(octonion<T> const & o)
+        {
+            return(o.real());
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        unreal(octonion<T> const & o)
+        {
+            return(o.unreal());
+        }
+        
+        
+#define    BOOST_OCTONION_VALARRAY_LOADER   \
+            using    ::std::valarray;       \
+                                            \
+            valarray<T>    temp(8);         \
+                                            \
+            temp[0] = o.R_component_1();    \
+            temp[1] = o.R_component_2();    \
+            temp[2] = o.R_component_3();    \
+            temp[3] = o.R_component_4();    \
+            temp[4] = o.R_component_5();    \
+            temp[5] = o.R_component_6();    \
+            temp[6] = o.R_component_7();    \
+            temp[7] = o.R_component_8();
+        
+        
+        template<typename T>
+        inline T                                sup(octonion<T> const & o)
+        {
+#ifdef    BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+            using    ::std::abs;
+#endif    /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
+            
+            BOOST_OCTONION_VALARRAY_LOADER
+            
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+            return((BOOST_GET_VALARRAY(T, abs(temp)).max)());
+#else
+            return((abs(temp).max)());
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+        }
+        
+        
+        template<typename T>
+        inline T                                l1(octonion<T> const & o)
+        {
+#ifdef    BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+            using    ::std::abs;
+#endif    /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
+            
+            BOOST_OCTONION_VALARRAY_LOADER
+            
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+            return(BOOST_GET_VALARRAY(T, abs(temp)).sum());
+#else
+            return(abs(temp).sum());
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+        }
+        
+        
+        template<typename T>
+        inline T                                abs(const octonion<T> & o)
+        {
+#ifdef    BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+            using    ::std::abs;
+#endif    /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
+            
+            using    ::std::sqrt;
+            
+            BOOST_OCTONION_VALARRAY_LOADER
+            
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+            T            maxim = (BOOST_GET_VALARRAY(T,abs(temp)).max)();    // overflow protection
+#else
+            T            maxim = (abs(temp).max)();    // overflow protection
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+            
+            if    (maxim == static_cast<T>(0))
+            {
+                return(maxim);
+            }
+            else
+            {
+                T    mixam = static_cast<T>(1)/maxim;    // prefer multiplications over divisions
+                
+                temp *= mixam;
+                
+                temp *= temp;
+                
+                return(maxim*sqrt(temp.sum()));
+            }
+            
+            //return(::std::sqrt(norm(o)));
+        }
+        
+        
+#undef    BOOST_OCTONION_VALARRAY_LOADER
+        
+        
+        // Note:    This is the Cayley norm, not the Euclidian norm...
+        
+        template<typename T>
+        inline T                                norm(octonion<T> const & o)
+        {
+            return(real(o*conj(o)));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        conj(octonion<T> const & o)
+        {
+            return(octonion<T>( +o.R_component_1(),
+                                -o.R_component_2(),
+                                -o.R_component_3(),
+                                -o.R_component_4(),
+                                -o.R_component_5(),
+                                -o.R_component_6(),
+                                -o.R_component_7(),
+                                -o.R_component_8()));
+        }
+        
+        
+        // Note:    There is little point, for the octonions, to introduce the equivalents
+        //            to the complex "arg" and the quaternionic "cylindropolar".
+        
+        
+        template<typename T>
+        inline octonion<T>                        spherical(T const & rho,
+                                                            T const & theta,
+                                                            T const & phi1,
+                                                            T const & phi2,
+                                                            T const & phi3,
+                                                            T const & phi4,
+                                                            T const & phi5,
+                                                            T const & phi6)
+        {
+            using ::std::cos;
+            using ::std::sin;
+            
+            //T    a = cos(theta)*cos(phi1)*cos(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6);
+            //T    b = sin(theta)*cos(phi1)*cos(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6);
+            //T    c = sin(phi1)*cos(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6);
+            //T    d = sin(phi2)*cos(phi3)*cos(phi4)*cos(phi5)*cos(phi6);
+            //T    e = sin(phi3)*cos(phi4)*cos(phi5)*cos(phi6);
+            //T    f = sin(phi4)*cos(phi5)*cos(phi6);
+            //T    g = sin(phi5)*cos(phi6);
+            //T    h = sin(phi6);
+            
+            T    courrant = static_cast<T>(1);
+            
+            T    h = sin(phi6);
+            
+            courrant *= cos(phi6);
+            
+            T    g = sin(phi5)*courrant;
+            
+            courrant *= cos(phi5);
+            
+            T    f = sin(phi4)*courrant;
+            
+            courrant *= cos(phi4);
+            
+            T    e = sin(phi3)*courrant;
+            
+            courrant *= cos(phi3);
+            
+            T    d = sin(phi2)*courrant;
+            
+            courrant *= cos(phi2);
+            
+            T    c = sin(phi1)*courrant;
+            
+            courrant *= cos(phi1);
+            
+            T    b = sin(theta)*courrant;
+            T    a = cos(theta)*courrant;
+            
+            return(rho*octonion<T>(a,b,c,d,e,f,g,h));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        multipolar(T const & rho1,
+                                                             T const & theta1,
+                                                             T const & rho2,
+                                                             T const & theta2,
+                                                             T const & rho3,
+                                                             T const & theta3,
+                                                             T const & rho4,
+                                                             T const & theta4)
+        {
+            using ::std::cos;
+            using ::std::sin;
+            
+            T    a = rho1*cos(theta1);
+            T    b = rho1*sin(theta1);
+            T    c = rho2*cos(theta2);
+            T    d = rho2*sin(theta2);
+            T    e = rho3*cos(theta3);
+            T    f = rho3*sin(theta3);
+            T    g = rho4*cos(theta4);
+            T    h = rho4*sin(theta4);
+            
+            return(octonion<T>(a,b,c,d,e,f,g,h));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        cylindrical(T const & r,
+                                                              T const & angle,
+                                                              T const & h1,
+                                                              T const & h2,
+                                                              T const & h3,
+                                                              T const & h4,
+                                                              T const & h5,
+                                                              T const & h6)
+        {
+            using ::std::cos;
+            using ::std::sin;
+            
+            T    a = r*cos(angle);
+            T    b = r*sin(angle);
+            
+            return(octonion<T>(a,b,h1,h2,h3,h4,h5,h6));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        exp(octonion<T> const & o)
+        {
+            using    ::std::exp;
+            using    ::std::cos;
+            
+            using    ::boost::math::sinc_pi;
+            
+            T    u = exp(real(o));
+            
+            T    z = abs(unreal(o));
+            
+            T    w = sinc_pi(z);
+            
+            return(u*octonion<T>(cos(z),
+                w*o.R_component_2(), w*o.R_component_3(),
+                w*o.R_component_4(), w*o.R_component_5(),
+                w*o.R_component_6(), w*o.R_component_7(),
+                w*o.R_component_8()));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        cos(octonion<T> const & o)
+        {
+            using    ::std::sin;
+            using    ::std::cos;
+            using    ::std::cosh;
+            
+            using    ::boost::math::sinhc_pi;
+            
+            T    z = abs(unreal(o));
+            
+            T    w = -sin(o.real())*sinhc_pi(z);
+            
+            return(octonion<T>(cos(o.real())*cosh(z),
+                w*o.R_component_2(), w*o.R_component_3(),
+                w*o.R_component_4(), w*o.R_component_5(),
+                w*o.R_component_6(), w*o.R_component_7(),
+                w*o.R_component_8()));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        sin(octonion<T> const & o)
+        {
+            using    ::std::sin;
+            using    ::std::cos;
+            using    ::std::cosh;
+            
+            using    ::boost::math::sinhc_pi;
+            
+            T    z = abs(unreal(o));
+            
+            T    w = +cos(o.real())*sinhc_pi(z);
+            
+            return(octonion<T>(sin(o.real())*cosh(z),
+                w*o.R_component_2(), w*o.R_component_3(),
+                w*o.R_component_4(), w*o.R_component_5(),
+                w*o.R_component_6(), w*o.R_component_7(),
+                w*o.R_component_8()));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        tan(octonion<T> const & o)
+        {
+            return(sin(o)/cos(o));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        cosh(octonion<T> const & o)
+        {
+            return((exp(+o)+exp(-o))/static_cast<T>(2));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        sinh(octonion<T> const & o)
+        {
+            return((exp(+o)-exp(-o))/static_cast<T>(2));
+        }
+        
+        
+        template<typename T>
+        inline octonion<T>                        tanh(octonion<T> const & o)
+        {
+            return(sinh(o)/cosh(o));
+        }
+        
+        
+        template<typename T>
+        octonion<T>                                pow(octonion<T> const & o,
+                                                    int n)
+        {
+            if        (n > 1)
+            {
+                int    m = n>>1;
+                
+                octonion<T>    result = pow(o, m);
+                
+                result *= result;
+                
+                if    (n != (m<<1))
+                {
+                    result *= o; // n odd
+                }
+                
+                return(result);
+            }
+            else if    (n == 1)
+            {
+                return(o);
+            }
+            else if    (n == 0)
+            {
+                return(octonion<T>(static_cast<T>(1)));
+            }
+            else    /* n < 0 */
+            {
+                return(pow(octonion<T>(static_cast<T>(1))/o,-n));
+            }
+        }
+        
+        
+        // helper templates for converting copy constructors (definition)
+        
+        namespace detail
+        {
+            
+            template<   typename T,
+                        typename U
+                    >
+            octonion<T>    octonion_type_converter(octonion<U> const & rhs)
+            {
+                return(octonion<T>( static_cast<T>(rhs.R_component_1()),
+                                    static_cast<T>(rhs.R_component_2()),
+                                    static_cast<T>(rhs.R_component_3()),
+                                    static_cast<T>(rhs.R_component_4()),
+                                    static_cast<T>(rhs.R_component_5()),
+                                    static_cast<T>(rhs.R_component_6()),
+                                    static_cast<T>(rhs.R_component_7()),
+                                    static_cast<T>(rhs.R_component_8())));
+            }
+        }
+    }
+}
+
+
+#if    BOOST_WORKAROUND(__GNUC__, < 3)
+    #undef    BOOST_GET_VALARRAY
+#endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
+
+
+#endif /* BOOST_OCTONION_HPP */