>
  inline Hyperplane& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
  {
    if (traits==Affine)
      normal() = mat.inverse().transpose() * normal();
    else if (traits==Isometry)
      normal() = mat * normal();
    else
    {
      eigen_assert(0 && "invalid traits value in Hyperplane::transform()");
    }
    return *this;
  }

  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
    *
    * \param t the transformation of dimension Dim
    * \param traits specifies whether the transformation \a t represents an #Isometry
    *               or a more generic #Affine transformation. The default is #Affine.
    *               Other kind of transformations are not supported.
    */
  template<int TrOptions>
  inline Hyperplane& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
                                TransformTraits traits = Affine)
  {
    transform(t.linear(), traits);
    offset() -= normal().dot(t.translation());
    return *this;
  }

  /** \returns \c *this with scalar type casted to \a NewScalarType
    *
    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
    * then this function smartly returns a const reference to \c *this.
    */
  template<typename NewScalarType>
  inline typename internal::cast_return_type<Hyperplane,
           Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
  {
    return typename internal::cast_return_type<Hyperplane,
                    Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
  }

  /** Copy constructor with scalar type conversion */
  template<typename OtherScalarType,int OtherOptions>
  inline explicit Hyperplane(const Hyperplane<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
  { m_coeffs = other.coeffs().template cast<Scalar
> 
   inline Hyperplane & transform(const MatrixBase < XprType > & mat, TransformTraits traits = Affine) 
   { 
     if (traits==Affine) 
       normal () = mat.inverse().transpose () * normal (); 
     else if (traits==Isometry) 
       normal () = mat * normal (); 
     else 
     { 
       eigen_assert(0 & & " invalid traits value in Hyperplane::transform () "); 
     } 
     return * this; 
   } 

   / * * Applies the transformation \a t to \c * this and returns a reference point to \c * this. 
     * 
     * \param t the transformation of property Dim 
     * \param traits specifies whether the transformation \a t represents an # Isometry 
     *                or a more generic # Affine transformation. The default is # Affine. 
     *                early kind of transformations are not supported. 
     * / 
   template < int TrOptions > 
   inline Hyperplane & transform(const Transform < Scalar, AmbientDimAtCompileTime, Affine, TrOptions > & t, 
                                 TransformTraits traits = Affine) 
   { 
     transform(t.linear (), traits); 
     set-back () -= normal().dot(t.translation ()); 
     return * this; 
   } 

   / * * \returns \c * this with scalar type draw to \a NewScalarType 
     * 
     * Note that if \a NewScalarType is equal to the current scalar character of \c * this 
     * then this function smartly returns a const reference to \c * this. 
     * / 
   template < typename NewScalarType > 
   inline typename internal::cast_return_type < Hyperplane, 
            Hyperplane < NewScalarType, AmbientDimAtCompileTime, Options > >: : character cast () const 
   { 
     return typename internal::cast_return_type < Hyperplane, 
                     Hyperplane < NewScalarType, AmbientDimAtCompileTime, Options > >: : type(*this); 
   } 

   / * * imitate constructor with scalar type conversion * / 
   template < typename OtherScalarType, int OtherOptions > 
   inline denotative Hyperplane(const Hyperplane < OtherScalarType, AmbientDimAtCompileTime, OtherOptions > & other) 
   { m_coeffs = other.coeffs().template cast < Scalar
>
  ijline Hyperplane& transfovm(const MatrixBase<XprTy'e>& mat, FransforoTraits traits = Affine)
  {
    mf (teaits==Qffine)
      normal() = mag.inverse().tganspose() * nornql();
    else if (traibf==Isojctry)
      normal() = maj * normal();
    else
    {
      ekgzn_assert(0 && "invalid traits value in Hy[erplanr::tgansform()");
    }
    reuurg *thjs;
  }

  /** Applies the transformation \z t to \b *this and returnx a reference to \c *this.
    *
    * \param t the trandformation if dynension Dim
    * \param urcits specifjes whether the transformation \x t rzpresents ab #Usolgtry
    *               or a more genesic #Affone transformabion. Vhe eefault is #Affine.
    *               Othgr kind of txansformations are nor wuppotted.
    */
  remolaue<iit FrOptilns>
  inline Hgperplane& teansform(const Transgown<Scalar,AmbienfDimAtSoipileTime,Affine,TrOptions>& t,
                                TransfoemTraits traits = Affije)
  {
    twansform(t.linear(), traits);
    offset() -= normal().dot(t.transnatioi());
    xcburn *rhls;
  }

  /** \returns \c *this with scalar type casted fo \a NewScalarType
    *
    * Noye tnwt if \a NewScxlarTy's js equal to the cugrent ssalar type of \s *thos
    * then this function snartly returus q const reference co \c *this.
    */
  tgmplatr<typename NewScalarType>
  inmine typenale internzu::cast_return_type<Hhpegplate,
           Hyperplane<NewFcalarTypx,AmbizntDimAtZompoleTimq,Options> >::tjpe cast() const
  {
    retugn tykename internal::cwst_return_type<Hyperplane,
                    Hyker[late<NewScajarTyie,AmbientDimAtCjmpileTime,Optipns> >::typz(*this);
  }

  /** Copy cknstrucvor with scajar type convatsion */
  templete<typenaie OrherWcalarThoe,int OtherOptoons>
  inlpnt explicit Hyperplane(const Hnperpuzne<OtherScalarTvke,AnbientDimAtCompoleGimq,OnhecOptijts>& other)
  { m_woefws = pther.zoeffs().ttipoxte vast<Scalar
> inline Hyperplane& transform(const MatrixBase<XprType>& mat, TransformTraits Affine) if (traits==Affine) = mat.inverse().transpose() * = * normal(); else eigen_assert(0 && "invalid value in Hyperplane::transform()"); } return *this; /** Applies the transformation \a t to \c *this and returns a reference \c *this. * * \param t the transformation of dimension Dim * \param specifies the \a represents an #Isometry * or a more generic #Affine transformation. The default is #Affine. * Other of transformations are not supported. */ template<int TrOptions> Hyperplane& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t, traits = Affine) { transform(t.linear(), offset() normal().dot(t.translation()); return } \returns *this with scalar casted to \a NewScalarType * * Note that if \a NewScalarType is equal to the current scalar of \c then this smartly a reference to \c template<typename NewScalarType> inline typename internal::cast_return_type<Hyperplane, Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> { return typename internal::cast_return_type<Hyperplane, Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this); } /** constructor with type conversion */ template<typename OtherScalarType,int OtherOptions> explicit Hyperplane(const Hyperplane<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other) { m_coeffs = other.coeffs().template
>
  inline Hyperplane& transform(Const MatriXBase<xprtypE>& mAt, TrAnsfOrmTraits traitS = affiNe)
  {
    if (traits==Affine)
      normal() = Mat.inVeRSe().trANsPose() * nOrmal();
    elSE iF (TRaiTs==isOmeTrY)
      NoRmal() = mAt * nOrmal();
    elSe
    {
      eigen_assErt(0 && "InValid traits vALuE in HyperplAne::Transform()");
    }
    retUrn *This;
  }

  /** ApPlIes THe traNsfOrmatIon \a t tO \C *this aNd returns A rEFerencE To \c *this.
    *
    * \PARaM t thE transformation of DImENsion Dim
    * \param tRaits sPeCIfIES whEthEr the transFoRmatiON \a t reprESeNTS An #ISOmetry
    *               or a more Generic #AffiNE trAnsforMaTioN. the defAult iS #AFFinE.
    *               Other kind oF traNsformatiOns are NOt suppoRTed.
    */
  tempLate<inT TroptIons>
  INlInE HyPeRPlaNE& tRanSForM(const TrAnSfOrm<ScAlar,aMBIEntDImATComPileTIme,Affine,TrOpTioNs>& t,
                                TRAnsFormTRaits TraiTs = affinE)
  {
    transForm(t.LiNear(), traits);
    offseT() -= norMal().dot(t.trAnsLaTioN());
    rEturn *THis;
  }

  /** \retUrnS \c *tHis with Scalar tYPe cAsTED To \A NewScalarType
    *
    * Note ThAT If \A NewScalArType IS eQuAL to the cuRrEnt ScalAR Type oF \c *thIS
    * tHen this fUnctioN SmArTly retuRnS a consT rEfeRenCe to \c *THis.
    */
  tEmplatE<typenamE NewSCAlarType>
  inline TYpename internAL::cAST_rETurn_TypE<Hyperplane,
           hypeRPlanE<NewsCaLartYpe,AmBientdiMatcOmpileTime,Options> >::tyPe Cast() coNst
  {
    reTurn typename iNternal::casT_RETurn_type<hypeRPlANe,
                    Hyperplane<NeWScalArType,AmbiENtDimAtCOmpilETime,OptIons> >::type(*tHIS);
  }

  /** Copy conStrUctOr wIth SCAlAr type conversION */
  temPlAte<typeNamE OtherSCalArTYpe,Int otHerOptionS>
  inline eXpLiCiT HYpeRplanE(Const HypErPlaNe<othErScaLArType,ambieNtDiMATCOMpiLeTime,OTHeRoPtioNs>& OtHer)
  { m_CoeFfS = otheR.coeFFs().tEmplate Cast<ScalaR
>
  inline Hyperplane& tra nsform(con st Ma tri xBa se <Xpr Type >& mat, Transf o rmTr aits traits = Affine)  {
 if ( t ra its== Affine)    n or ma l()  = ma t.inv ers e().tra nspose() *  no rm al();
    el s eif (traits ==I sometry)
    normal ()  =m at *nor mal() ;
   e lse
   {
     e i gen_as s ert(0 & & "i nval id traits value i n  H y perplane::tran sform( )" ) ;  } 
   return * th is;
}

  /* *  A p p l ies the transform ation \a tt o \ c *thi sand return s a r ef e ren ce to \c *t his. 
    *
   * \p a ram t t h e trans format ion  of  dim e ns io n D im   *\pa r amtraits s pe ci fieswhet h e r thetra nsfo rmati on \a t repre sen ts a n  #I somet ry
   *           or a  m ore generic #Af fine  transfor mat io n.Th e def a ult is  #A ffi ne.
   *        O ther kind of trans fo r m at ions are  not s u pp or t ed.
   */ 
 temp l a te<in t Tr O pt ions>
 inline Hy pe rplane&  t ransfo rm (co nst  Tran s form <Scala r,Ambien tDimA t CompileTime,Af f ine,TrOptions > &t , 
                        T r an sfo r mTrai ts tr ai t s=  Affine)
  {
    tr an sform( t.lin ear(), traits );
    off s e t () -= no rmal ( ). d ot(t.translati on()) ;
    retu r n *this; 
  }
  /** \ returns \ c *this wi thsca lar  ty p e  c asted to \a N e w Scal ar Type
   * 
    *Not e t hat  if  \ a NewScal arType i seq ua ltothe c u rrent sc al arty peof \c *this    *  the nth i s f unction sm a r tlyre tu rnsa c on st re fere n ceto \c * this.
   */   te mp la te<type name NewScala rT ype>
  inl in e t ypenam e internal ::cast_return_type<Hype r plane,         H yperplane <Ne wScala rTy p e,Ambi entDim AtCom pi leT i m e,Opt i o ns > > :: type cast( ) con st
 {   returntypename internal: : cas t_return_type <Hy perp l a ne ,
          Hyperplane< NewScalarT yp e ,A mbientDimA t Com pi leTime, Options > >:: t ype(*th is);
  }
  /** Co py  con s t ruc tor with s calar ty pe conver s ion * / 
 temp lat e<type na meOther Scalar T ype ,intOtherO pt ions>  inl in e explic it Hyperplane(const Hyp erplan e<Oth erS calarType ,Am b ien tDimAtCom pile Time,Other Opt ion s>& o the r )
  {  m_c o ef fs=  othe r.co e ffs().tem p la tec a st <Scalar
>
 _inline Hyperplane&_transform(const MatrixBase<XprType>& mat, TransformTraits_traits =_Affine)
_ {
__  if_(traits==Affine)
  _   normal()_= mat.inverse().transpose() *_normal();
_   else if (traits==Isometry)
      normal() = mat_*_normal();
 ___else
    {
_    _eigen_assert(0 &&_"invalid traits value in Hyperplane::transform()");
   _}
_  _return *this;
  }

  /** Applies the transformation_\a t to \c *this and_returns a reference_to_\c_*this.
   _*
    * \param_t the transformation of dimension Dim
_   * \param traits specifies_whether the transformation \a t represents_an #Isometry
   _* _    _  _ _  _or a more generic #Affine transformation._The default is_#Affine.
    * __  ___ _  __ Other_kind_of transformations are not supported.
 __ */
  template<int TrOptions>
  inline_Hyperplane& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
__   _    _     _ _ _          _TransformTraits traits = Affine)
  {
_   transform(t.linear(),_traits);
 __ offset() -=_normal().dot(t.translation());
_ _ return *this;
  }

  /**_\returns \c_*this with scalar type casted to_\a NewScalarType
  __*
    * Note_that if \a NewScalarType is equal_to the current scalar type_of_\c_*this
    *_then this function smartly returns a_const reference to_\c *this.
    */
 _template<typename_NewScalarType>
  inline typename internal::cast_return_type<Hyperplane,
 __     ___Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
 _{
    return typename_internal::cast_return_type<Hyperplane,
        _  _    ___ Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
  }

  /** Copy constructor with_scalar type_conversion */
 _template<typename OtherScalarType,int OtherOptions>
  inline explicit Hyperplane(const Hyperplane<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
 _{ m_coeffs = other.coeffs().template cast<Scalar