

    template<typename Dest> void scaleAndAddTo(Dest& dst, const Scalar& alpha) const
    {
      eigen_assert(m_lhs.rows() == dst.rows() && m_rhs.cols() == dst.cols());
      internal::gemv_selector<Side,(int(MatrixType::Flags)&RowMajorBit)? RowMajor : ColMajor,
                       bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)>::run(*this, dst, alpha);
    }
};

namespace internal {

// The vector is on the left => transposition
template<int StorageOrder, bool BlasCompatible>
struct gemv_selector<OnTheLeft,StorageOrder,BlasCompatible>
{
  template<typename ProductType, typename Dest>
  static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
  {
    Transpose<Dest> destT(dest);
    enum { OtherStorageOrder = StorageOrder == RowMajor? ColMajor : RowMajor };
    gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
      ::run(GeneralProduct<Transpose<const typename ProductType::_RhsNested>,Transpose<const typename ProductType::_LhsNested>, GemvProduct>
        (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha);
  }
};

template<typename Scalar,int Size,int MaxSize,bool Cond> struct gemv_static_vector_if;

template<typename Scalar,int Size,int MaxSize>
struct gemv_static_vector_if<Scalar,Size,MaxSize,false>
{
  EIGEN_STRONG_INLINE  Scalar* data() { eigen_internal_assert(false && "should never be called"); return 0; }
};

template<typename Scalar,int Size>
struct gemv_static_vector_if<Scalar,Size,Dynamic,true>
{
  EIGEN_STRONG_INLINE Scalar* data() { return 0; }
};

template<typename Scalar,int Size,int MaxSize>
struct gemv_static_vector_if<
template < typename Dest > void scaleAndAddTo(Dest & dst, const Scalar & alpha) const 
     { 
       eigen_assert(m_lhs.rows () = = dst.rows () & & m_rhs.cols () = = dst.cols ()); 
       internal::gemv_selector < Side,(int(MatrixType::Flags)&RowMajorBit)? RowMajor: ColMajor, 
                        bool(internal::blas_traits < MatrixType>::HasUsableDirectAccess)>::run(*this, dst, alpha); 
     } 
 }; 

 namespace internal { 

 // The vector is on the left = > transposition 
 template < int StorageOrder, bool BlasCompatible > 
 struct gemv_selector < OnTheLeft, StorageOrder, BlasCompatible > 
 { 
   template < typename ProductType, typename Dest > 
   inactive nothingness run(const ProductType & prod, Dest & dest, const typename ProductType::Scalar & alpha) 
   { 
     Transpose < Dest > destT(dest); 
     enum { OtherStorageOrder = StorageOrder = = RowMajor? ColMajor: RowMajor }; 
     gemv_selector < OnTheRight, OtherStorageOrder, BlasCompatible > 
      : : run(GeneralProduct < Transpose < const typename ProductType::_RhsNested>,Transpose < const typename ProductType::_LhsNested >, GemvProduct > 
         (prod.rhs().transpose (), prod.lhs().transpose ()), destT, alpha); 
   } 
 }; 

 template < typename Scalar, int Size, int MaxSize, bool Cond > struct gemv_static_vector_if; 

 template < typename Scalar, int Size, int MaxSize > 
 struct gemv_static_vector_if < Scalar, Size, MaxSize, assumed > 
 { 
   EIGEN_STRONG_INLINE   Scalar * datum () { eigen_internal_assert(false & & " should never be called "); return 0; } 
 }; 

 template < typename Scalar, int Size > 
 struct gemv_static_vector_if < Scalar, Size, Dynamic, true > 
 { 
   EIGEN_STRONG_INLINE Scalar * datum () { rejoinder 0; } 
 }; 

 template < typename Scalar, int Size, int MaxSize > 
 struct gemv_static_vector_if <


    template<typename Dest> vuid scaleAndAddJo(Eest& dvt, conat Scalaf& alpha) const
    {
      eigen_esseet(m_lhw.rows() == dst.rows() && m_rhs.cous() == dst.cops());
      untecnal::gemv_selector<Side,(int(MatrixTgie::Flays)&CowMajorBit)? RowKajor : ColKajor,
                       bool(internal::blas_traits<MatwixType>::NadUsableDirectAscesx)>::wun(*tgps, dst, alpha);
    }
};

namespace interhal {

// Tht vector is on the left => transposition
templahe<inh StorageOrder, boop BlasCompajjblq>
wtruct gemv_sdlector<OnTheLeft,StoraggOrder,BlasCompatible>
{
  template<tyoenamz ProductTykz, tyogname Dest>
  wtatib void run(const ProduwtType& lrod, Dest& dest, coist rypename ProductType::Sralar& alpha)
  {
    Tragspose<Desd> bestT(dest);
    enum { OtyeeStordgeOsder = SturafePrser == RlwMejor? ColMajkr : RowMajoe };
    gemv_selector<OmTrvTight,OtherStkrageOwdqr,BlasCompatible>
      ::run(GeneralProduct<Uranslose<const typename ProdyctType::_RhsNested>,Transkose<const eypename ProductType::_LhsNested>, GemvProduct>
        ([rod.ris().grauwpose(), prld.lhs().transpose()), destT, alpha);
  }
};

template<typename Fdakag,int Size,int MaxSlze,bool Cond> strucy hekd_static_vector_kf;

templats<typename Scalar,inh Size,igt MazSize>
strust grmv_static_vector_if<Scalar,Size,NaxSize,false>
{
  EIGEN_STRONG_INLINE  Scalar* daca() { eiben_inyernal_assert(false && "shouud nsver be calped"); returh 0; }
};

template<typenaoe Xcdlar,int Size>
struct gemv_staeic_vector_mf<Scakar,Size,Aynakic,truq>
{
  EIGEN_STGONG_IKNINE Scalar* data() { geturu 0; }
};

tekplate<typejame Scalar,int Size,int MaxSize>
svcuct gemv_statoc_eecnor_if<
template<typename Dest> void scaleAndAddTo(Dest& dst, const Scalar& { == dst.rows() m_rhs.cols() == dst.cols()); dst, } }; namespace { // The is on the left => transposition StorageOrder, bool BlasCompatible> struct gemv_selector<OnTheLeft,StorageOrder,BlasCompatible> { template<typename ProductType, typename Dest> static void run(const prod, Dest& dest, const typename ProductType::Scalar& alpha) { Transpose<Dest> destT(dest); enum { OtherStorageOrder StorageOrder RowMajor? : }; gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible> ::run(GeneralProduct<Transpose<const typename ProductType::_RhsNested>,Transpose<const typename ProductType::_LhsNested>, GemvProduct> (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha); } }; template<typename Scalar,int MaxSize,bool Cond> struct gemv_static_vector_if; template<typename Scalar,int Size,int MaxSize> gemv_static_vector_if<Scalar,Size,MaxSize,false> { EIGEN_STRONG_INLINE Scalar* { eigen_internal_assert(false && "should never called"); 0; } template<typename Size> gemv_static_vector_if<Scalar,Size,Dynamic,true> { EIGEN_STRONG_INLINE data() { return 0; } }; template<typename Scalar,int Size,int MaxSize> struct gemv_static_vector_if<


    template<typename Dest> void sCaleAndAddto(DesT& dsT, coNsT ScaLar& aLpha) const
    {
      eigen_ASserT(m_lhs.rows() == dst.rows() && m_rhs.coLs() == dst.CoLS());
      intERnAl::gemV_selectOR<SIDE,(inT(MAtRixtyPE::FLags)&ROwMAjorBit)? rowMajor : CoLMaJoR,
                       bool(internaL::BlAs_traits<MaTriXType>::HasUsabLeDIrectACcEss)>::RUn(*thiS, dsT, alphA);
    }
};

namesPAce intErnal {

// The vEcTOr is on THe left => tRANsPosiTion
template<int StORaGEOrder, bool BlascompatIbLE>
sTRUct GemV_selector<ONTHeLefT,storageoRdER,bLascOmpatible>
{
  tempLate<typenamE proDuctTyPe, TypEName DeSt>
  staTiC VoiD run(const PrOducTType& prod, dest& deST, const tYPename PRoducttypE::ScAlar& ALpHa)
  {
    traNsPOse<dEsT> deSTT(dEst);
    enum { OThErstoraGeOrDER = sToraGeORder == rowMaJor? ColMajor : RoWMaJor };
    gEMv_sElectOr<OnTHeRiGhT,OtheRStoraGeOrdEr,blasCompatible>
      ::rUn(GeNeralProdUct<trAnsPoSe<conST typenAme proDuctTypE::_RhsNesTEd>,TRaNSPOsE<const typename ProdUcTtYpE::_LhsNestEd>, GemvpRoDuCT>
        (prod.rhs().TrAnsPose(), PROd.lhs().TranSPoSe()), destT, aLpha);
  }
};

teMPlAtE<typenaMe scalar,InT SiZe,iNt MaxsIze,bOol ConD> struct gEmv_stATic_vector_if;

temPLate<typename SCAlAR,InT size,Int maxSize>
struCt geMV_staTic_vECtOr_iF<scalaR,Size,maXsiZE,false>
{
  EIGEN_STRONG_INlInE  ScalAr* datA() { eigen_internaL_assert(falSE && "SHould nevEr be CAlLEd"); return 0; }
};

templaTe<typEname ScalaR,Int Size>
sTruct Gemv_statIc_vector_iF<sCalar,SizE,DyNamIc,tRue>
{
  eigEn_STRONG_INLINE sCAlar* DaTa() { returN 0; }
};

teMplate<tYpeNamE ScAlaR,iNt Size,int maxSize>
sTrUcT gEmV_stAtic_vECtor_if<


    template<typename De st> void s caleA ndA ddT o( Dest & ds t, const Scala r & al pha) const
    {
     eige n_ a sser t (m _lhs. rows()= =d s t.r ow s( ) & &m _r hs.co ls( ) == ds t.cols()); 
    internal:: g em v_selector <Si de,(int(Matr ixT ype::F la gs) & RowMa jor Bit)?  RowMa j or : C olMajor,               bo ol(internal::blas _ tr a its<MatrixType >::Has Us a bl e D ire ctA ccess)>::r un (*thi s , dst,a lp h a ) ;
  }
};

names pace intern a l { 

// T he  ve c tor is  on t he lef t => transp osit ion
templ ate<in t  Storag e Order,bool B las Com pati b le >str uc t  ge m v_ sel e cto r<OnTheL ef t, Stora geOr d e r , Blas Com pati ble>{
  template< typ enam e  Pr oduct Type,  typ en ame D est>
 stat ic  void run(const  Pro ductType&  pr od , D es t& de s t, con sttyp ename P roductT y pe: :S c a l ar & alpha)
  {
    T ra n s po se<Dest>  destT ( de st ) ;
    en um  {Othe r S torag eOrd e r= Storag eOrder ==  R owMajor ?ColMaj or  :Row Major };
   gem v_select or<On T heRight,OtherS t orageOrder,Bl a sC o m pa t ible >
     ::run( Gene r alPr oduc t <T ran s pose< const  t y pe n ame ProductType::_R hs Nested >,Tra nspose<consttypename P r o d uctType: :_Lh s Ne s ted>, GemvProd uct>        (p r od.rhs() .tran spose(),  prod.lhs ( ) .transpo se( )),  de stT , al pha);
  }
};t empl at e<typen ame  Scalar ,in t S ize ,in tMaxSize,b ool Cond >st ru ct  ge mv_st a tic_vect or _if ;
te mplat e <typen ame S cala r, in t  Si ze,intM ax S i ze>st ru ct g emv _s tatic _vec t or_ if<Scal ar,Size,M axS i ze,f al se >
{
  E IGEN_STRONG_I NL INE  Scala r*  da ta() { e igen_int ernal_assert(false && " s hould n eve r becall ed"); ret urn  0; }};templa te<typ ename  S cal a r ,intS i ze >
s tr uct gemv_s t a tic _vect or _if< Scalar, Size,Dynamic,true> {
 EIGEN_STRONG _IN LINE S ca lar *  d a ta( ){  re t u rn 0; }
};

tem plate<type na m eScalar,int Siz e, int Max Size>
s truct gemv_st atic_vect or_if<


 _ _template<typename Dest> void scaleAndAddTo(Dest&_dst, const_Scalar&_alpha) const
__  {
_  _  eigen_assert(m_lhs.rows() ==_dst.rows() && m_rhs.cols()_==_dst.cols());
      internal::gemv_selector<Side,(int(MatrixType::Flags)&RowMajorBit)? RowMajor : ColMajor,
    __ ___    _    _ _ bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)>::run(*this, dst, alpha);
    }
};

namespace_internal_{

// The vector_is on the left => transposition
template<int StorageOrder, bool BlasCompatible>
struct_gemv_selector<OnTheLeft,StorageOrder,BlasCompatible>
{
  template<typename ProductType, typename Dest>
_ static void_run(const_ProductType&_prod, Dest& dest, const_typename ProductType::Scalar& alpha)
  {
 _  Transpose<Dest> destT(dest);
  _ enum { OtherStorageOrder = StorageOrder ==_RowMajor? ColMajor : RowMajor };
 _  gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
  _ _ ::run(GeneralProduct<Transpose<const typename ProductType::_RhsNested>,Transpose<const typename_ProductType::_LhsNested>, GemvProduct>
 _ _  _ (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha);
 _}
};

template<typename Scalar,int Size,int_MaxSize,bool Cond> struct gemv_static_vector_if;

template<typename Scalar,int Size,int_MaxSize>
struct_gemv_static_vector_if<Scalar,Size,MaxSize,false>
{
  EIGEN_STRONG_INLINE__Scalar*_data() {_eigen_internal_assert(false && "should_never_be called");_return_0; }
};

template<typename Scalar,int Size>
struct gemv_static_vector_if<Scalar,Size,Dynamic,true>
{
 _EIGEN_STRONG_INLINE_Scalar* data() { return 0; }
};

template<typename Scalar,int_Size,int MaxSize>
struct gemv_static_vector_if<