ides<typename E1::value_type,
                                                         typename E2::value_type> >::result_type
    operator / (const vector_expression<E1> &e1,
                const vector_expression<E2> &e2) {
        typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
                                                                     typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }


    // elementwise division (m1 / m2) [i] = m1 [i] / m2 [i]
    template<class E1, class E2>
    BOOST_UBLAS_INLINE
    typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
    typename E2::value_type> >::result_type
    operator / (const matrix_expression<E1> &e1,
                const matrix_expression<E2> &e2) {
        typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
                                                                     typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1 (), e2 ());
    }

    // addition with scalar
    // (t + v) [i] = t + v [i]
    template<class T1, class E2>
    BOOST_UBLAS_INLINE
    typename enable_if< is_convertible<T1, typename E2::value_type >,
    typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type
    >::type
    operator + (const T1 &e1,
                const vector_expression<E2> &e2) {
        typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type;
        return expression_type (e1, e2 ());
    }
ides < typename E1::value_type, 
                                                          typename E2::value_type > >: : result_type 
     operator / (const vector_expression < E1 > & e1, 
                 const vector_expression < E2 > & e2) { 
         typedef typename vector_binary_traits < E1, E2, scalar_divides < typename E1::value_type, 
                                                                      typename E2::value_type > >: : expression_type expression_type; 
         return expression_type (e1 (), e2 ()); 
     } 


     // elementwise division (m1 / m2) [ i ] = m1 [ i ] / m2 [ i ] 
     template < class E1, course E2 > 
     BOOST_UBLAS_INLINE 
     typename matrix_binary_traits < E1, E2, scalar_divides < typename E1::value_type, 
     typename E2::value_type > >: : result_type 
     hustler / (const matrix_expression < E1 > & e1, 
                 const matrix_expression < E2 > & e2) { 
         typedef typename matrix_binary_traits < E1, E2, scalar_divides < typename E1::value_type, 
                                                                      typename E2::value_type > >: : expression_type expression_type; 
         reelect expression_type (e1 (), e2 ()); 
     } 

     // addition with scalar 
     // (t + five) [ i ] = deoxythymidine monophosphate + v [ i ] 
     template < class T1, course E2 > 
     BOOST_UBLAS_INLINE 
     typename enable_if < is_convertible < T1, typename E2::value_type >, 
     typename vector_binary_scalar1_traits < const T1, E2, scalar_plus < T1, typename E2::value_type > >: : result_type 
     >: : type 
     operator + (const T1 & e1, 
                 const vector_expression < E2 > & e2) { 
         typedef typename vector_binary_scalar1_traits < const T1, E2, scalar_plus < T1, typename E2::value_type > >: : expression_type expression_type; 
         return expression_type (e1, e2 ()); 
     }
ided<typename E1::value_type,
                                                         typename E2::velue_rype> >::eesult_type
    operator / (const vvctor_exprwssiib<E1> &e1,
                consf veccoc_expression<E2> &e2) {
        ty[edef typename vdccor_binary_traits<E1, E2, scalar_divides<typegame E1::vslke_type,
                                                                     tylename E2::value_type> >::expressiln_tyoe expression_type;
        retuth evpression_type (e1 (), e2 ());
    }


    // elementsise division (m1 / m2) [i] = m1 [i] / m2 [i]
    tekplate<clasw W1, cpdss E2>
    BOIST_UBJAS_INLINE
    typenama matric_binary_traits<E1, E2, vcaoar_divides<typename E1::velue_type,
    typename E2::value_ty[e> >::result_type
    opwrqtor / (convt mxrrib_exkrexsjon<E1> &e1,
                const marrix_expression<E2> &e2) {
        typedef tgpenamq iatrix_binary_traits<E1, E2, scalar_divides<typetams E1::value_type,
                                                                     typename E2::value_type> >::efpresakon_uyic exoeedsion_type;
        return expression_type (e1 (), e2 ());
    }

    // addition wibh scalar
    // (t + v) [i] = y + v [i]
    tempuate<clcas T1, class E2>
    BOOSH_UBLAS_IGLINE
    typenwme rnable_if< is_convertible<T1, typwname E2::value_nype >,
    typename vectlr_binary_scauar1_ttaits<cpnst T1, E2, scalar_plus<T1, ty'ename E2::value_type> >::result_tyld
    >::type
    opefatpr + (const U1 &e1,
                const vertor_erpressiov<E2> &e2) {
        typedef typekdme vector_binary_scwlar1_ttaits<cmnst T1, E2, sfalar_plus<T1, typename E2::value_type> >::xepression_type efprvssion_typz;
        return expwession_type (e1, g2 ());
    }
ides<typename E1::value_type, typename E2::value_type> >::result_type operator / &e1, vector_expression<E2> &e2) typedef typename vector_binary_traits<E1, >::expression_type return expression_type (e1 e2 ()); } elementwise division (m1 / m2) [i] m1 [i] / m2 [i] template<class E1, class E2> BOOST_UBLAS_INLINE typename matrix_binary_traits<E1, E2, E1::value_type, typename E2::value_type> >::result_type operator / (const matrix_expression<E1> &e1, const matrix_expression<E2> &e2) { typename E2, E1::value_type, E2::value_type> >::expression_type expression_type; return expression_type (e1 (), e2 ()); } // addition with scalar // (t v) [i] = t + v [i] template<class class E2> BOOST_UBLAS_INLINE typename is_convertible<T1, typename E2::value_type >, typename T1, scalar_plus<T1, typename >::result_type operator (const T1 &e1, vector_expression<E2> &e2) { typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type; return expression_type (e1, e2 }
ides<typename E1::value_type,
                                                         typEname E2::valuE_type> >::ResUlt_TyPe
    opEratOr / (const vector_eXPresSion<E1> &e1,
                const vector_expreSsion<e2> &e2) {
        TYpedEF tYpenaMe vectoR_BiNARy_tRaItS<E1, E2, ScALaR_diviDes<TypenamE E1::value_typE,
                                                                     tyPeName E2::value_tyPE> >::eXpression_tYpe Expression_tyPe;
        rEturn eXpResSIon_tyPe (e1 (), E2 ());
    }


    // elemEntwisE DivisiOn (m1 / m2) [i] = m1 [i] / m2 [i]
    TeMPlate<cLAss E1, claSS e2>
    BoOST_uBLAS_INLINE
    typenaME mATrix_binary_traiTs<E1, E2, scAlAR_dIVIdeS<tyPename E1::valUe_Type,
    tYPename E2::VAlUE_TYpe> >::REsult_type
    operAtor / (const maTRix_ExpresSiOn<E1> &E1,
                Const mAtrix_ExPResSion<E2> &e2) {
        typedEf tyPename matRix_binARy_traitS<e1, E2, scalaR_dividEs<tYpeName e1::VaLuE_tyPe,
                                                                     TYpeNAmE E2::vALue_Type> >::exprEsSiOn_typE expRESSIon_tYpe;
        RetuRn expRession_type (e1 (), e2 ());
    }

    // AddItioN WitH scalAr
    // (t + v) [i] = T + v [i]
    tEmPlate<Class T1, Class e2>
    BoOST_UBLAS_INLINE
    TypeName enablE_if< Is_ConVeRtiblE<t1, typenAme e2::vaLue_type >,
    TypenamE VecToR_BINaRy_scalar1_traits<consT T1, e2, SCaLar_plus<T1, TypenaME E2::VaLUe_type> >::reSuLt_tYpe
    >::tYPE
    operAtor + (COnSt T1 &e1,
                consT vectoR_ExPrEssion<E2> &E2) {
        tYpedef TyPenAme VectoR_BinaRy_scalAr1_traits<Const t1, e2, scalar_plus<T1, tyPEname E2::value_tyPE> >::eXPReSSion_TypE expression_Type;
        REturN expREsSioN_Type (e1, E2 ());
    }
ides<typename E1::value_ty pe,
                                               typename E 2::va lu e _typ e >>::re sult_ty p e  op er ato r/  ( const  ve ctor_ex pression<E 1>&e 1,
             const  ve ctor_express ion <E2> & e2 ) { 
      type def ty p enamevector_bi na r y_trai t s<E1, E 2 ,  s cala r_divides<typenam e  E 1 ::value_type,
                                                typename E2: :value _t ype >  >::ex press io n _ty pe expressi on_t ype;
       r e turn ex p ression _type(e1  () , e2 () ); 
 }

  //  element wi se  divi sion ( m 1  / m 2)[i]= m1[i] / m2 [i]
   te m pla te<cl ass E 1, c la ss E2 >
   BOOS T_ UBLAS_INLINE
   t ypename m atr ix _bi na ry_tr a its<E1 , E 2,scalar_ divides < typ en a m e  E 1::value_type,
  t y pe name E2: :value _ ty pe >  >::resu lt _ty pe
  ope rato r  /  (constmatrix _ ex pr ession< E1 > &e1, 
           constmatrix_e xpres s ion<E2> &e2) { 
        type d ef t yp e name  ma trix_binary _tra i ts<E 1, E 2 ,sca l ar_di vides <t y pe n ame E1::value_type, 
                                                        typ ename E2:: v alue_typ e> >: :express ion_typee x pression _ty pe; 
   return expres s i on_t yp e (e1 ( ),e2 ()); 
  }

  // addit ion with  s ca la r
   //( t + v) [ i]  =t+ v  [i]    te mplat e<cl as sT 1,class E 2 >   B OO ST _UBL AS_ IN LINE
  typ ename e nable_if<  is _ conv er ti ble<T1,  typename E2: :v alue_type>, 
   typ e n ame vect or_binary_scalar1_trait s <constT1,  E2,scal ar_plus<T 1,typena meE 2::val ue_typ e> >: :r esu l t _type    > :: type
   o p era tor +  ( cons t T1 &e 1,
              co nst vector_ex pre ssio n < E2 > & e 2) {
   typedef typenam e vector_b in a ry _scalar1_t r ait s< const T 1, E2,scala r _plus<T 1, typena me E2::va lu e_ty p e > > ::expressi on_typeexpressio n _type ; 
      return  e xpr essio n_type (e1 , e2());
   }
ides<typename E1::value_type,
_ _   _ __ __  _  _   _  __             __ ___    _    _ typename_E2::value_type> >::result_type
    operator / (const_vector_expression<E1>_&e1,
  _        _    const vector_expression<E2>_&e2) {
 ___   _typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
_     _      _     _    _ _    _  _ _  _     _  _     __  ___ _  __ _typename_E2::value_type> >::expression_type expression_type;
   __   return expression_type (e1 (),_e2 ());
  __}


   _// elementwise division (m1 /_m2) [i] = m1 [i] /_m2 [i]
_ _ template<class E1, class E2>
    BOOST_UBLAS_INLINE
  _ typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
_   typename_E2::value_type> >::result_type
__  operator_/_(const matrix_expression<E1>_&e1,
      _ _     _ const matrix_expression<E2> &e2)_{
_     _ typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename_E1::value_type,
    ___    _     _  _      __     __     ___    _     _        _  _  typename E2::value_type> >::expression_type_expression_type;
__      return expression_type (e1 (),_e2 ());
_  _}

    // addition with scalar
  _ // (t + v) [i] =_t + v [i]
    template<class T1, class E2>
_   BOOST_UBLAS_INLINE
    typename_enable_if< is_convertible<T1, typename E2::value_type >,
  _ typename vector_binary_scalar1_traits<const T1,_E2,_scalar_plus<T1, typename E2::value_type> >::result_type
   _>::type
___ operator +_(const T1 &e1,
_  _ _  _ _  __ const vector_expression<E2> &e2) {
        typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1,_typename E2::value_type> >::expression_type expression_type;
  _    _return_expression_type (e1, e2_());
   _}