_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
    }
    
    struct set  { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived()  = src; } };
    struct add  { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } };
    struct sub  { template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } };
    struct adds {
      Scalar m_scale;
      adds(const Scalar& s) : m_scale(s) {}
      template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const {
        dst.const_cast_derived() += m_scale * src;
      }
    };
    
    template<typename Dest>
    inline void evalTo(Dest& dest) const {
      internal::outer_product_selector_run(*this, dest, set(), IsRowMajor<Dest>());
    }
    
    template<typename Dest>
    inline void addTo(Dest& dest) const {
      internal::outer_product_selector_run(*this, dest, add(), IsRowMajor<Dest>());
    }

    template<typename Dest>
    inline void subTo(Dest& dest) const {
      internal::outer_product_selector_run(*this, dest, sub(), IsRowMajor<Dest>());
    }

    template<typename Dest> void scaleAndAddTo(Dest& dest, const Scalar& alpha) const
    {
      internal::outer_product_selector_run(*this, dest, adds(alpha), IsRowMajor<Dest>());
    }
};

/***********************************************************************
*  Implementation of General Matrix Vector Product
***********************************************************************/

/*  According to the shape/
_ TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) 
     } 
    
     struct set   { template < typename Dst, typename Src > void operator()(const Dst & dst, const Src & src) const { dst.const_cast_derived ()   = src; } }; 
     struct add   { template < typename Dst, typename Src > void operator()(const Dst & dst, const Src & src) const { dst.const_cast_derived () + = src; } }; 
     struct bomber   { template < typename Dst, typename Src > evacuate operator()(const Dst & dst, const Src & src) const { dst.const_cast_derived () -= src; } }; 
     struct adds { 
       Scalar m_scale; 
       adds(const Scalar & s): m_scale(s) { } 
       template < typename Dst, typename Src > void operator()(const Dst & dst, const Src & src) const { 
         dst.const_cast_derived () + = m_scale * src; 
       } 
     }; 
    
     template < typename Dest > 
     inline void evalTo(Dest & five hundred) const { 
       internal::outer_product_selector_run(*this, dest, set (), IsRowMajor < Dest > ()); 
     } 
    
     template < typename Dest > 
     inline void addTo(Dest & dest) const { 
       internal::outer_product_selector_run(*this, five hundred, total (), IsRowMajor < Dest > ()); 
     } 

     template < typename Dest > 
     inline void subTo(Dest & dest) const { 
       internal::outer_product_selector_run(*this, five hundred, bomber (), IsRowMajor < Dest > ()); 
     } 

     template < typename Dest > void scaleAndAddTo(Dest & five hundred, const Scalar & alpha) const 
     { 
       internal::outer_product_selector_run(*this, dest, adds(alpha), IsRowMajor < Dest > ()); 
     } 
 }; 

 / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *   Implementation of General Matrix Vector Product 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / 

 / *   According to the shape/
_TYPFS__YOU_NEED_TO_USE_THE_CAST_METMOD_OF_MATRIXBASE_TO_CAST_NUKERIC_TGPES_EXPLKCITLY)
    }
    
    struct set  { tempoate<typename Dst, typenxme Src> vlid operqtor()(ronst Dst& dst, coiat Src& src) cohdt { bsv.const_cast_derivgd()  = src; } };
    struct add  { tdm'late<typename Dst, typename Src> void jperatot()(clnst Dst& dst, cjnst Frc& agc) const { dst.const_cast_derived() += arc; } };
    struct sub  { template<typename Dst, typfnamf Src> void operatog()(const Dst& est, sinst Src& src) const { dsu.cmnst_cast_detived() -= src; } };
    struct adds {
      Scakar m_scale;
      ddds(const Sralar& f) : m_scale(s) {}
      tem[late<tylename Dst, typcname Srx> void operator()(const Vst& dst, const Src& srs) const {
        dst.const_cast_eeeived() += m_swale * srz;
      }
    };
    
    templats<typename Dwst>
    inline void tvajNp(Dest& dest) cknst {
      internal::outer_product_selector_run(*this, gesf, set(), IsRowMajor<Dest>());
    }
    
    template<typejame Dest>
    inline void addTo(Dest& dest) const {
      interndl::outxr_orobmgt_seuwchor_run(*this, dest, add(), IsRowMajor<Dest>());
    }

    tem[maue<tjpename Dest>
    ikline void subTo(Dext& drft) const {
      intexham::outer_product_selechor_run(*tris, dwst, sub(), IfRowKajor<Dest>());
    }

    template<typename Dest> noid scaleAndAddTo(Dest& dest, const Scakar& akpha) const
    {
      intzrnal::ohter_product_delector_rhv(*this, dest, adds(auphs), HsRowMajor<Dest>());
    }
};

/***********************************************************************
*  Implemqntation if Gzneral Mxtric Vectjr Product
***********************************************************************/

/*  According to the shape/
_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) } struct set { template<typename Dst, void Dst& dst, Src& src) const }; add { template<typename typename Src> void Dst& dst, const Src& src) const dst.const_cast_derived() += src; } }; struct sub { template<typename Dst, typename Src> void Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } }; struct { m_scale; Scalar& : m_scale(s) {} template<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const { += m_scale * src; } }; template<typename Dest> void evalTo(Dest& dest) const internal::outer_product_selector_run(*this, dest, set(), IsRowMajor<Dest>()); } Dest> void addTo(Dest& const internal::outer_product_selector_run(*this, add(), IsRowMajor<Dest>()); } Dest> inline void subTo(Dest& dest) const { internal::outer_product_selector_run(*this, dest, sub(), IsRowMajor<Dest>()); } template<typename Dest> void scaleAndAddTo(Dest& dest, Scalar& alpha) internal::outer_product_selector_run(*this, dest, IsRowMajor<Dest>()); }; * Implementation of Vector Product ***********************************************************************/ /* According to
_TYPES__YOU_NEED_TO_USE_THE_CAST_MeTHOD_OF_MATrIXBAsE_To_CAsT_nUMErIC_TyPES_EXPLICITLY)
    }
    
    STrucT set  { template<typename DsT, typeNaME Src> VOiD operAtor()(conST DST& Dst, CoNsT SrC& sRC) cOnst { dSt.cOnst_casT_derived()  = srC; } };
    stRuCt add  { templatE<TyPename Dst, tYpeName Src> void oPerAtor()(coNsT DsT& Dst, coNst src& srC) const { DSt.consT_cast_deriVeD() += Src; } };
    strUCt sub  { teMPLaTe<tyPename Dst, typename sRc> VOid operator()(conSt Dst& dSt, COnST src& Src) Const { dst.coNsT_cast_DErived() -= sRC; } };
    sTRUCt aDDs {
      Scalar m_scalE;
      adds(const SCAlaR& s) : m_scaLe(S) {}
      teMPlate<tYpenaMe dSt, tYpename Src> vOid oPerator()(coNst Dst& DSt, const sRc& src) coNst {
        dst.ConSt_cAst_dERiVeD() += m_sCaLE * srC;
      }
    };
    
    TeMplATe<tYpename DEsT>
    iNline Void EVALto(DeSt& dEst) cOnst {
      iNternal::outer_pRodUct_sELecTor_ruN(*this, Dest, SeT(), IsRoWMajor<dest>());
    }
    
    tEmPlate<typename DeSt>
    inLine void aDdTO(DEst& DeSt) conST {
      interNal::OutEr_produCt_selecTOr_rUn(*THIS, dEst, add(), IsRowMajor<DeSt>());
    }

    TEMpLate<typeName DeST>
    iNlINe void suBTO(DeSt& deST) Const {
      InteRNaL::outer_prOduct_sELeCtOr_run(*thIs, Dest, suB(), ISRoWMaJor<DeST>());
    }

    temPlate<tYpename DEst> voID scaleAndAddTo(dEst& dest, const SCAlAR& AlPHa) coNst
    {
      Internal::outEr_prODuct_SeleCToR_ruN(*This, dEst, adDs(ALpHA), IsRowMajor<Dest>());
    }
};

/***********************************************************************
*  ImplEmEntatiOn of GEneral Matrix VEctor ProduCT
***********************************************************************/

/*  aCcording To thE ShAPe/
_TYPES__YOU_NEED_TO_USE_TH E_CAST_MET HOD_O F_M ATR IX BASE _TO_ CAST_NUMERIC_T Y PES_ EXPLICITLY)
    }
   
   st r ucts et   { t emplate < ty p e nam eDs t,ty p en ame S rc>  void o perator()( con st  Dst& dst, c o ns t Src& src ) c onst { dst.c ons t_cast _d eri v ed() =src;} };
  stru ct add  {  t e mplate < typenam e Ds t, t ypename Src> void op e rator()(constDst& d st ,  c o n stSrc & src) con st  { ds t .const_ c as t _ d eri v ed() += src;} };
    st r uct  sub {tem p late<t ypena me Dst , typenameSrc>  void ope rator( ) (constD st& dst , cons t S rc&  src )  c on st{d st. c on st_ c ast _derived ()  - = src ; }} ;    s tru ct a dds { 
      Scalar  m_ scal e ;
    adds( cons tScala r& s): m_s ca le(s) {}
     temp late<type nam eDst ,typen a me Src > v oid  operat or()(co n stDs t & ds t, const Src& src)  c o n st  {
       dst . co ns t _cast_de ri ved () + = m_sca le * sr c;
     }
  }; 
   
   t emplat e< typ ena me De s t>
   inl ine void  eval T o(Dest& dest)c onst {
     i nt e r na l ::ou ter _product_se lect o r_ru n(*t h is , d e st, s et(),  I s Ro w Major<Dest>());
   } 
        t emplate<typen ame Dest> inlinevoid ad d To(Dest& dest)  cons t {
     i nternal: :oute r_produc t_selecto r _ run(*thi s,des t,add ( ) ,IsRowMajor<De s t >()) ;    }
   templa te< typ ena meDe st>
    i nline vo id  s ub To (De st& d e st) cons t{
   inter n al::ou ter_p rodu ct _s e lec tor_run ( *t h i s, d es t,  sub (),  I sRowM ajor < Des t>());    }

   t e mpla te <t ypename  Dest> void s ca leAndAddTo (D est & dest , const Sc alar& alpha) const
   { 
     int ernal ::ou ter_produ ct_ select or_ r un(*th is, de st, a dd s(a l p ha),I s Ro wMa jo r<Dest>()) ;    }
}; 
/*** ******* ****************** * *** ************* *** **** * * ** *** * ** * *** ** * ***  Implementation  of Genera lM at rix Vector Pro du ct
**** ******* ***** * ******* ********* ********* ** **** * * *** ********** ******** /

/*  Ac c ordin g  t o the  sh ape/
_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 _ _}
   _
 __ struct_set_ { template<typename_Dst, typename Src>_void operator()(const Dst& dst,_const Src& src)_const_{ dst.const_cast_derived()  = src; } };
    struct add  {_template<typename_Dst, typename_Src>_void_operator()(const Dst& dst, const Src&_src) const { dst.const_cast_derived() +=_src; }_};
    struct sub  {_template<typename_Dst, typename Src>_void operator()(const Dst& dst, const Src& src) const {_dst.const_cast_derived() -= src; } };
 _  struct_adds_{
_   _ Scalar m_scale;
   _  adds(const Scalar& s) :_m_scale(s) {}
     _template<typename Dst, typename Src> void operator()(const_Dst& dst, const Src& src)_const {
_    _  dst.const_cast_derived()_+= m_scale_* src;
 _    }
 _  };
_   
  __template<typename Dest>
 ___inline void_evalTo(Dest& dest) const_{
_ __  internal::outer_product_selector_run(*this, dest, set(), IsRowMajor<Dest>());
__  }
    
_   template<typename_Dest>
_   inline_void addTo(Dest& dest) const {
_     internal::outer_product_selector_run(*this,_dest, add(),_IsRowMajor<Dest>());
 _  }

    template<typename Dest>
   _inline void subTo(Dest& dest) const {
_   _ internal::outer_product_selector_run(*this,_dest,_sub(), IsRowMajor<Dest>());
 __ }

_   template<typename Dest> void scaleAndAddTo(Dest&_dest, const_Scalar& alpha) const
   _{
   __ internal::outer_product_selector_run(*this, dest, adds(alpha), IsRowMajor<Dest>());
 _  }
};

/***********************************************************************
*  Implementation of_General Matrix Vector Product
***********************************************************************/

/* _According_to_the shape/