bpp-phyl3  3.0.0
bpp::ExtendedFloatEigen< R, C, EigenType > Class Template Reference

#include <Bpp/Phyl/Likelihood/DataFlow/ExtendedFloatEigen.h>

+ Inheritance diagram for bpp::ExtendedFloatEigen< R, C, EigenType >:
+ Collaboration diagram for bpp::ExtendedFloatEigen< R, C, EigenType >:

Classes

class  OwnedExtendedFloat
 

Public Types

using Scalar = ExtendedFloat
 
using RealScalar = double
 

Public Member Functions

 ExtendedFloatEigen (void)
 
 ExtendedFloatEigen (Eigen::DenseBase< MatType > &mat, ExtType exp=0)
 
 ExtendedFloatEigen (MatType &mat, ExtType exp=0)
 
 ExtendedFloatEigen (const Eigen::DenseBase< MatType > &mat, ExtType exp=0)
 
 ExtendedFloatEigen (const Eigen::internal::traits< MatType > &mat, ExtType exp=0)
 
template<class Other >
 ExtendedFloatEigen (const ExtendedFloatEigenBase< Other > &other)
 
 ExtendedFloatEigen (const ExtendedFloatEigen &other)
 
 ExtendedFloatEigen (const MatType &mat, ExtType exp=0)
 
 ExtendedFloatEigen (int rows, int cols)
 
 ExtendedFloatEigen (int cols)
 
virtual ~ExtendedFloatEigen ()
 
ExtendedFloatEigenoperator= (const ExtendedFloatEigen &other)
 
ExtendedFloatEigenoperator= (const MatType &other)
 
template<typename Derived >
Selfoperator= (const ExtendedFloatEigenBase< Derived > &other)
 
virtual const ExtTypeexponent_part () const
 
virtual const MatTypefloat_part () const
 
virtual ExtTypeexponent_part ()
 
virtual MatTypefloat_part ()
 
bool normalize_big () noexcept
 
bool normalize_small ()
 
void normalize () noexcept
 
template<typename T >
std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value||std::is_floating_point< T >::value||std::is_integral< T >::value, Self >::type operator+ (const T &rhs) const
 
template<template< int R2=R, int C2=C > class EigenType2>
Self operator+ (const ExtendedFloatEigen< R, C, EigenType2 > &rhs) const
 
template<typename T >
std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value||std::is_floating_point< T >::value||std::is_integral< T >::value, Self >::type operator- (const T &rhs) const
 
template<int R2 = C, int C2, template< int R3=R2, int C3=C2 > class EigenType2>
ExtendedFloatEigen< R, C2, EigenType > operator* (const ExtendedFloatEigen< R2, C2, EigenType2 > &rhs) const
 
template<typename Derived >
Self operator* (const Eigen::EigenBase< Derived > &rhs) const
 
template<typename T >
std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value||std::is_same< T, ExtendedFloat >::value, Self >::type operator* (const T &fact) const
 
template<typename T >
std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value||std::is_same< T, ExtendedFloat >::value, Self >::type operator/ (const T &fact) const
 
template<typename Derived >
Self operator/ (const ExtendedFloatEigenBase< Derived > &rhs) const
 
template<typename Derived >
ExtendedFloat dot (const ExtendedFloatEigenBase< Derived > &rhs) const
 
template<typename Derived >
ExtendedFloat dot (const Eigen::DenseBase< Derived > &rhs) const
 
template<typename Obj >
ExtendedFloat dot (const Eigen::Ref< Obj > &rhs) const
 
Self operator- () const
 
Self eval () const
 
template<typename T >
std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value, Self & >::type operator*= (const T &rhs)
 
template<typename T >
std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self & >::type operator*= (const T &div)
 
template<typename Derived >
Selfoperator*= (const Eigen::DenseBase< Derived > &div)
 
template<typename Derived >
Selfoperator*= (const ExtendedFloatEigenBase< Derived > &div)
 
template<typename T >
std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value, Self & >::type operator/= (const T &rhs)
 
template<typename T >
std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self & >::type operator/= (const T &div)
 
template<typename T >
std::enable_if< std::is_base_of< ExtendedFloatEigenCore, T >::value||std::is_same< T, ExtendedFloat >::value, Self & >::type operator+= (const T &rhs)
 
template<typename T >
std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self & >::type operator+= (const T &rhs)
 
template<typename T >
std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value, Self & >::type operator-= (const T &rhs)
 
template<typename T >
std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self & >::type operator-= (const T &rhs)
 
Self log () const
 
Self exp () const
 
bool operator== (const Self &rhs) const
 
bool operator!= (const Self &rhs) const
 
void fill (double val)
 
Eigen::Index cols () const
 
Eigen::Index rows () const
 
ExtendedFloatVectorwiseOp< Self, MatType, Eigen::Vertical > colwise ()
 
ExtendedFloatVectorwiseOp< const Self, const MatType, Eigen::Vertical > colwise () const
 
template<typename M = MatType>
std::enable_if< std::is_same< M, EFMatrix< R, C > >::value, ExtendedFloatCol< R, C, EigenType > >::type col (Eigen::Index pos)
 
ExtendedFloatEigen< R, 1, EigenType > col (Eigen::Index col) const
 
template<typename M = MatType>
std::enable_if< std::is_same< M, EFMatrix< R, C > >::value, ExtendedFloatRow< R, C, EigenType > >::type row (Eigen::Index pos)
 
ExtendedFloatVectorwiseOp< Self, MatType, Eigen::Horizontal > rowwise ()
 
ExtendedFloatVectorwiseOp< const Self, const MatType, Eigen::Horizontal > rowwise () const
 
const ExtendedFloatoperator() (Eigen::Index c) const
 
const ExtendedFloatoperator() (Eigen::Index r, Eigen::Index c) const
 
template<typename M = MatType>
std::enable_if< std::is_same< M, EFArray< R, C > >::value, const ExtendedFloat & >::type operator[] (Eigen::Index pos) const
 
const ExtendedFloatsum () const
 
const ExtendedFloatmean () const
 
const ExtendedFloatmaxCoeff (size_t *pos=0) const
 
ExtendedFloatMatrix< C, R > transpose () const
 
void resize (Eigen::Index rows, Eigen::Index cols)
 
void resize (Eigen::Index rows)
 
Eigen::Index size () const
 
ExtendedFloatEigen< R, C, EigenType > & derived ()
 
const ExtendedFloatEigen< R, C, EigenType > & derived () const
 
ExtendedFloatNoAlias< ExtendedFloatEigen< R, C, EigenType > > noalias ()
 

Static Public Member Functions

static Self Zero (Eigen::Index rows, Eigen::Index cols)
 
static Self Zero (Eigen::Index rows)
 
static Self Ones (Eigen::Index rows, Eigen::Index cols)
 
static Self Ones (Eigen::Index rows)
 
static Self Identity (Eigen::Index rows)
 
static Self Constant (Eigen::Index rows, Eigen::Index cols, double value)
 
static Self Constant (Eigen::Index rows, Eigen::Index cols, const ExtendedFloat &value)
 
static Self Constant (Eigen::Index rows, double value)
 
static Self Constant (Eigen::Index rows, const ExtendedFloat &value)
 
template<int R2, int C2>
static ExtendedFloatEigen< R, C2, EigenType > denorm_mul (const Self &lhs, const ExtendedFloatEigen< R2, C2, EigenType > &rhs)
 
template<typename Derived >
static Self denorm_mul (const Self &lhs, const Eigen::EigenBase< Derived > &rhs)
 
template<typename Derived >
static Self denorm_mul (const Eigen::EigenBase< Derived > &lhs, const Self &rhs)
 
template<typename T >
static std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self >::type denorm_mul (const Self &lhs, const T &rhs)
 
static Self denorm_mul (const Self &lhs, const double &rhs)
 
static Self denorm_mul (const Self &lhs, const ExtendedFloat &rhs)
 
template<typename T >
static std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value, Self >::type denorm_div (const Self &lhs, const T &rhs)
 
template<typename Derived >
static Self denorm_div (const Self &lhs, const ExtendedFloatEigenBase< Derived > &rhs)
 
template<typename T >
static std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self >::type denorm_add (const Self &lhs, const T &rhs)
 
template<typename T >
static std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value, Self >::type denorm_add (const Self &lhs, const T &rhs)
 
template<typename T >
static std::enable_if< std::is_same< T, Self >::value||std::is_same< T, ExtendedFloat >::value, Self >::type denorm_sub (const Self &lhs, const T &rhs)
 
template<typename T >
static std::enable_if< std::is_floating_point< T >::value||std::is_integral< T >::value, Self >::type denorm_sub (const Self &lhs, const T &rhs)
 
static Self denorm_pow (const Self &arr, double exp)
 
static Self denorm_pow (const Self &arr, int exp)
 
template<typename CustomNullaryOp >
static Self NullaryExpr (Eigen::Index rows, Eigen::Index cols, const CustomNullaryOp &func)
 

Protected Attributes

MatType mat_
 
ExtType exp_
 
OwnedExtendedFloat EFtmp_
 

Private Types

using ExtType = int
 
using MatType = EigenType< R, C >
 
using RefMatType = Eigen::Ref< EigenType< R, C > >
 
using Self = ExtendedFloatEigen< R, C, EigenType >
 
using Base = ExtendedFloatEigenBase< Self >
 
template<int R2, int C2>
using ExtendedFloatMatrix = ExtendedFloatEigen< R2, C2, EFMatrix >
 
template<int R2, int C2>
using ExtendedFloatArray = ExtendedFloatEigen< R2, C2, EFArray >
 

Private Attributes

ExtendedFloatEigen< R, C, EigenType > & der_
 

Friends

std::ostream & operator<< (std::ostream &out, const Self &ef)
 

Detailed Description

template<int R, int C, template< int R2, int C2 > class EigenType>
class bpp::ExtendedFloatEigen< R, C, EigenType >

Definition at line 67 of file ExtendedFloatEigen.h.

Member Typedef Documentation

◆ Base

template<int R, int C, template< int R2, int C2 > class EigenType>
using bpp::ExtendedFloatEigen< R, C, EigenType >::Base = ExtendedFloatEigenBase<Self>
private

Definition at line 76 of file ExtendedFloatEigen.h.

◆ ExtendedFloatArray

template<int R, int C, template< int R2, int C2 > class EigenType>
template<int R2, int C2>
using bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatArray = ExtendedFloatEigen<R2, C2, EFArray>
private

Definition at line 82 of file ExtendedFloatEigen.h.

◆ ExtendedFloatMatrix

template<int R, int C, template< int R2, int C2 > class EigenType>
template<int R2, int C2>
using bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatMatrix = ExtendedFloatEigen<R2, C2, EFMatrix>
private

Definition at line 79 of file ExtendedFloatEigen.h.

◆ ExtType

template<int R, int C, template< int R2, int C2 > class EigenType>
using bpp::ExtendedFloatEigen< R, C, EigenType >::ExtType = int
private

Definition at line 69 of file ExtendedFloatEigen.h.

◆ MatType

template<int R, int C, template< int R2, int C2 > class EigenType>
using bpp::ExtendedFloatEigen< R, C, EigenType >::MatType = EigenType<R, C>
private

Definition at line 70 of file ExtendedFloatEigen.h.

◆ RealScalar

using bpp::ExtendedFloatEigenBase< ExtendedFloatEigen< R, C, EigenType > >::RealScalar = double
inherited

Definition at line 30 of file ExtendedFloatEigen.h.

◆ RefMatType

template<int R, int C, template< int R2, int C2 > class EigenType>
using bpp::ExtendedFloatEigen< R, C, EigenType >::RefMatType = Eigen::Ref<EigenType<R, C> >
private

Definition at line 72 of file ExtendedFloatEigen.h.

◆ Scalar

using bpp::ExtendedFloatEigenBase< ExtendedFloatEigen< R, C, EigenType > >::Scalar = ExtendedFloat
inherited

Definition at line 29 of file ExtendedFloatEigen.h.

◆ Self

template<int R, int C, template< int R2, int C2 > class EigenType>
using bpp::ExtendedFloatEigen< R, C, EigenType >::Self = ExtendedFloatEigen<R, C, EigenType>
private

Definition at line 74 of file ExtendedFloatEigen.h.

Constructor & Destructor Documentation

◆ ExtendedFloatEigen() [1/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( void  )
inline

Definition at line 119 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [2/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( Eigen::DenseBase< MatType > &  mat,
ExtType  exp = 0 
)
inline

Definition at line 126 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [3/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( MatType mat,
ExtType  exp = 0 
)
inline

Definition at line 134 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [4/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( const Eigen::DenseBase< MatType > &  mat,
ExtType  exp = 0 
)
inline

Definition at line 142 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [5/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( const Eigen::internal::traits< MatType > &  mat,
ExtType  exp = 0 
)
inline

Definition at line 150 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [6/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<class Other >
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( const ExtendedFloatEigenBase< Other > &  other)
inline

Definition at line 159 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [7/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( const ExtendedFloatEigen< R, C, EigenType > &  other)
inline

Definition at line 165 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [8/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( const MatType mat,
ExtType  exp = 0 
)
inline

Definition at line 171 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [9/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( int  rows,
int  cols 
)
inline

Definition at line 179 of file ExtendedFloatEigen.h.

◆ ExtendedFloatEigen() [10/10]

template<int R, int C, template< int R2, int C2 > class EigenType>
bpp::ExtendedFloatEigen< R, C, EigenType >::ExtendedFloatEigen ( int  cols)
inline

Definition at line 185 of file ExtendedFloatEigen.h.

◆ ~ExtendedFloatEigen()

template<int R, int C, template< int R2, int C2 > class EigenType>
virtual bpp::ExtendedFloatEigen< R, C, EigenType >::~ExtendedFloatEigen ( )
inlinevirtual

Definition at line 191 of file ExtendedFloatEigen.h.

Member Function Documentation

◆ col() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatEigen<R, 1, EigenType> bpp::ExtendedFloatEigen< R, C, EigenType >::col ( Eigen::Index  col) const
inline

◆ col() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename M = MatType>
std::enable_if<std::is_same<M, EFMatrix<R, C> >::value, ExtendedFloatCol<R, C, EigenType > >::type bpp::ExtendedFloatEigen< R, C, EigenType >::col ( Eigen::Index  pos)
inline

◆ cols()

◆ colwise() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatVectorwiseOp<Self, MatType, Eigen::Vertical> bpp::ExtendedFloatEigen< R, C, EigenType >::colwise ( )
inline

Definition at line 749 of file ExtendedFloatEigen.h.

◆ colwise() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatVectorwiseOp<const Self, const MatType, Eigen::Vertical> bpp::ExtendedFloatEigen< R, C, EigenType >::colwise ( ) const
inline

Definition at line 754 of file ExtendedFloatEigen.h.

◆ Constant() [1/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Constant ( Eigen::Index  rows,
const ExtendedFloat value 
)
inlinestatic

◆ Constant() [2/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Constant ( Eigen::Index  rows,
double  value 
)
inlinestatic

◆ Constant() [3/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Constant ( Eigen::Index  rows,
Eigen::Index  cols,
const ExtendedFloat value 
)
inlinestatic

◆ Constant() [4/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Constant ( Eigen::Index  rows,
Eigen::Index  cols,
double  value 
)
inlinestatic

◆ denorm_add() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
static std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_add ( const Self lhs,
const T &  rhs 
)
inlinestatic

◆ denorm_add() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
static std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_add ( const Self lhs,
const T &  rhs 
)
inlinestatic

◆ denorm_div() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_div ( const Self lhs,
const ExtendedFloatEigenBase< Derived > &  rhs 
)
inlinestatic

◆ denorm_div() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
static std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_div ( const Self lhs,
const T &  rhs 
)
inlinestatic

◆ denorm_mul() [1/6]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul ( const Eigen::EigenBase< Derived > &  lhs,
const Self rhs 
)
inlinestatic

◆ denorm_mul() [2/6]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul ( const Self lhs,
const double &  rhs 
)
inlinestatic

◆ denorm_mul() [3/6]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul ( const Self lhs,
const Eigen::EigenBase< Derived > &  rhs 
)
inlinestatic

◆ denorm_mul() [4/6]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul ( const Self lhs,
const ExtendedFloat rhs 
)
inlinestatic

◆ denorm_mul() [5/6]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<int R2, int C2>
static ExtendedFloatEigen<R, C2, EigenType> bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul ( const Self lhs,
const ExtendedFloatEigen< R2, C2, EigenType > &  rhs 
)
inlinestatic

◆ denorm_mul() [6/6]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
static std::enable_if< std::is_floating_point<T>::value || std::is_integral<T>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul ( const Self lhs,
const T &  rhs 
)
inlinestatic

◆ denorm_pow() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_pow ( const Self arr,
double  exp 
)
inlinestatic

◆ denorm_pow() [2/2]

◆ denorm_sub() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
static std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_sub ( const Self lhs,
const T &  rhs 
)
inlinestatic

◆ denorm_sub() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
static std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_sub ( const Self lhs,
const T &  rhs 
)
inlinestatic

◆ derived() [1/2]

ExtendedFloatEigen< R, C, EigenType > & bpp::ExtendedFloatEigenBase< ExtendedFloatEigen< R, C, EigenType > >::derived ( )
inlineinherited

Definition at line 35 of file ExtendedFloatEigen.h.

◆ derived() [2/2]

const ExtendedFloatEigen< R, C, EigenType > & bpp::ExtendedFloatEigenBase< ExtendedFloatEigen< R, C, EigenType > >::derived ( ) const
inlineinherited

Definition at line 40 of file ExtendedFloatEigen.h.

◆ dot() [1/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
ExtendedFloat bpp::ExtendedFloatEigen< R, C, EigenType >::dot ( const Eigen::DenseBase< Derived > &  rhs) const
inline

◆ dot() [2/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Obj >
ExtendedFloat bpp::ExtendedFloatEigen< R, C, EigenType >::dot ( const Eigen::Ref< Obj > &  rhs) const
inline

◆ dot() [3/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
ExtendedFloat bpp::ExtendedFloatEigen< R, C, EigenType >::dot ( const ExtendedFloatEigenBase< Derived > &  rhs) const
inline

◆ eval()

template<int R, int C, template< int R2, int C2 > class EigenType>
Self bpp::ExtendedFloatEigen< R, C, EigenType >::eval ( ) const
inline

◆ exp()

◆ exponent_part() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
virtual ExtType& bpp::ExtendedFloatEigen< R, C, EigenType >::exponent_part ( )
inlinevirtual

◆ exponent_part() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
virtual const ExtType& bpp::ExtendedFloatEigen< R, C, EigenType >::exponent_part ( ) const
inlinevirtual

Reimplemented in bpp::ExtendedFloatCol< R, C, EigenType >.

Definition at line 266 of file ExtendedFloatEigen.h.

References bpp::ExtendedFloatEigen< R, C, EigenType >::exp_.

Referenced by bpp::ExtendedFloatEigen< R, C, EigenType >::col(), bpp::numeric::convert(), bpp::copyBppToEigen(), bpp::numeric::cwise(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_add(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_div(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_pow(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_sub(), bpp::ExtendedFloatEigen< R, C, EigenType >::dot(), bpp::ExtendedFloatEigen< R, C, EigenType >::eval(), bpp::ExtendedFloatEigen< R, C, EigenType >::exp(), bpp::ExtendedFloatEigen< R, C, EigenType >::OwnedExtendedFloat::exponent_part(), bpp::ExtendedFloatArrayWrapper< R, C >::exponent_part(), bpp::ExtendedFloatEigen< R, C, EigenType >::fill(), bpp::numeric::isIdentity(), bpp::ExtendedFloatEigen< R, C, EigenType >::log(), bpp::ExtendedFloatEigen< R, C, EigenType >::maxCoeff(), bpp::ExtendedFloatEigen< R, C, EigenType >::mean(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator!=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator()(), bpp::ExtendedFloatArrayWrapper< R, C >::operator*(), bpp::ExtendedFloatArrayWrapper< R, C >::operator*=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator*=(), bpp::ExtendedFloatArrayWrapper< R, C >::operator+=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator+=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator-(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator-=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator/=(), bpp::ExtendedFloatArrayWrapper< R, C >::operator=(), bpp::ExtendedFloatRow< R, C, EigenType >::operator=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator==(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator[](), bpp::ExtendedFloatEigen< R, C, EigenType >::sum(), and bpp::ExtendedFloatEigen< R, C, EigenType >::transpose().

◆ fill()

template<int R, int C, template< int R2, int C2 > class EigenType>
void bpp::ExtendedFloatEigen< R, C, EigenType >::fill ( double  val)
inline

◆ float_part() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
virtual MatType& bpp::ExtendedFloatEigen< R, C, EigenType >::float_part ( )
inlinevirtual

◆ float_part() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
virtual const MatType& bpp::ExtendedFloatEigen< R, C, EigenType >::float_part ( ) const
inlinevirtual

Reimplemented in bpp::ExtendedFloatCol< R, C, EigenType >.

Definition at line 268 of file ExtendedFloatEigen.h.

References bpp::ExtendedFloatEigen< R, C, EigenType >::mat_.

Referenced by bpp::ExtendedFloatEigen< R, C, EigenType >::col(), bpp::ExtendedFloatEigen< R, C, EigenType >::cols(), bpp::numeric::convert(), bpp::copyBppToEigen(), bpp::numeric::cwise(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_add(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_div(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_mul(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_pow(), bpp::ExtendedFloatEigen< R, C, EigenType >::denorm_sub(), bpp::ExtendedFloatEigen< R, C, EigenType >::dot(), bpp::ExtendedFloatEigen< R, C, EigenType >::eval(), bpp::ExtendedFloatEigen< R, C, EigenType >::exp(), bpp::ExtendedFloatEigen< R, C, EigenType >::fill(), bpp::ExtendedFloatArrayWrapper< R, C >::float_part(), bpp::numeric::isIdentity(), bpp::ExtendedFloatEigen< R, C, EigenType >::log(), bpp::ExtendedFloatEigen< R, C, EigenType >::maxCoeff(), bpp::ExtendedFloatEigen< R, C, EigenType >::mean(), bpp::ExtendedFloatEigen< R, C, EigenType >::normalize_big(), bpp::ExtendedFloatEigen< R, C, EigenType >::normalize_small(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator!=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator()(), bpp::ExtendedFloatArrayWrapper< R, C >::operator*(), bpp::ExtendedFloatArrayWrapper< R, C >::operator*=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator*=(), bpp::ExtendedFloatArrayWrapper< R, C >::operator+=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator+=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator-(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator-=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator/=(), bpp::ExtendedFloatArrayWrapper< R, C >::operator=(), bpp::ExtendedFloatRow< R, C, EigenType >::operator=(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator==(), bpp::ExtendedFloatEigen< R, C, EigenType >::operator[](), bpp::ExtendedFloatEigen< R, C, EigenType >::resize(), bpp::ExtendedFloatEigen< R, C, EigenType >::rows(), bpp::ExtendedFloatEigen< R, C, EigenType >::size(), bpp::ExtendedFloatEigen< R, C, EigenType >::sum(), and bpp::ExtendedFloatEigen< R, C, EigenType >::transpose().

◆ Identity()

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Identity ( Eigen::Index  rows)
inlinestatic

◆ log()

template<int R, int C, template< int R2, int C2 > class EigenType>
Self bpp::ExtendedFloatEigen< R, C, EigenType >::log ( ) const
inline

◆ maxCoeff()

◆ mean()

◆ noalias()

ExtendedFloatNoAlias<ExtendedFloatEigen< R, C, EigenType > > bpp::ExtendedFloatEigenBase< ExtendedFloatEigen< R, C, EigenType > >::noalias ( )
inlineinherited

Definition at line 47 of file ExtendedFloatEigen.h.

◆ normalize()

◆ normalize_big()

◆ normalize_small()

◆ NullaryExpr()

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename CustomNullaryOp >
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::NullaryExpr ( Eigen::Index  rows,
Eigen::Index  cols,
const CustomNullaryOp &  func 
)
inlinestatic

◆ Ones() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Ones ( Eigen::Index  rows)
inlinestatic

◆ Ones() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Ones ( Eigen::Index  rows,
Eigen::Index  cols 
)
inlinestatic

◆ operator!=()

template<int R, int C, template< int R2, int C2 > class EigenType>
bool bpp::ExtendedFloatEigen< R, C, EigenType >::operator!= ( const Self rhs) const
inline

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator*() [1/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
Self bpp::ExtendedFloatEigen< R, C, EigenType >::operator* ( const Eigen::EigenBase< Derived > &  rhs) const
inline

◆ operator*() [2/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<int R2 = C, int C2, template< int R3=R2, int C3=C2 > class EigenType2>
ExtendedFloatEigen<R, C2, EigenType> bpp::ExtendedFloatEigen< R, C, EigenType >::operator* ( const ExtendedFloatEigen< R2, C2, EigenType2 > &  rhs) const
inline

◆ operator*() [3/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value || std::is_same<T, ExtendedFloat>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator* ( const T &  fact) const
inline

◆ operator*=() [1/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
Self& bpp::ExtendedFloatEigen< R, C, EigenType >::operator*= ( const Eigen::DenseBase< Derived > &  div)
inline

◆ operator*=() [2/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
Self& bpp::ExtendedFloatEigen< R, C, EigenType >::operator*= ( const ExtendedFloatEigenBase< Derived > &  div)
inline

◆ operator*=() [3/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator*= ( const T &  div)
inline

◆ operator*=() [4/4]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator*= ( const T &  rhs)
inline

◆ operator+() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<template< int R2=R, int C2=C > class EigenType2>
Self bpp::ExtendedFloatEigen< R, C, EigenType >::operator+ ( const ExtendedFloatEigen< R, C, EigenType2 > &  rhs) const
inline

◆ operator+() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value || std::is_floating_point<T>::value || std::is_integral<T>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator+ ( const T &  rhs) const
inline

◆ operator+=() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_base_of<ExtendedFloatEigenCore, T>::value || std::is_same<T, ExtendedFloat>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator+= ( const T &  rhs)
inline

◆ operator+=() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator+= ( const T &  rhs)
inline

◆ operator-() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
Self bpp::ExtendedFloatEigen< R, C, EigenType >::operator- ( ) const
inline

◆ operator-() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value || std::is_floating_point<T>::value || std::is_integral<T>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator- ( const T &  rhs) const
inline

◆ operator-=() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator-= ( const T &  rhs)
inline

◆ operator-=() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator-= ( const T &  rhs)
inline

◆ operator/() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
Self bpp::ExtendedFloatEigen< R, C, EigenType >::operator/ ( const ExtendedFloatEigenBase< Derived > &  rhs) const
inline

◆ operator/() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value || std::is_same<T, ExtendedFloat>::value, Self>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator/ ( const T &  fact) const
inline

◆ operator/=() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_floating_point<T>::value || std::is_integral<T>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator/= ( const T &  div)
inline

◆ operator/=() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename T >
std::enable_if<std::is_same<T, Self>::value || std::is_same<T, ExtendedFloat>::value, Self&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator/= ( const T &  rhs)
inline

◆ operator=() [1/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatEigen& bpp::ExtendedFloatEigen< R, C, EigenType >::operator= ( const ExtendedFloatEigen< R, C, EigenType > &  other)
inline

◆ operator=() [2/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename Derived >
Self& bpp::ExtendedFloatEigen< R, C, EigenType >::operator= ( const ExtendedFloatEigenBase< Derived > &  other)
inline

◆ operator=() [3/3]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatEigen& bpp::ExtendedFloatEigen< R, C, EigenType >::operator= ( const MatType other)
inline

◆ operator==()

template<int R, int C, template< int R2, int C2 > class EigenType>
bool bpp::ExtendedFloatEigen< R, C, EigenType >::operator== ( const Self rhs) const
inline

◆ operator[]()

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename M = MatType>
std::enable_if<std::is_same<M, EFArray<R, C> >::value, const ExtendedFloat&>::type bpp::ExtendedFloatEigen< R, C, EigenType >::operator[] ( Eigen::Index  pos) const
inline

◆ resize() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
void bpp::ExtendedFloatEigen< R, C, EigenType >::resize ( Eigen::Index  rows)
inline

◆ resize() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
void bpp::ExtendedFloatEigen< R, C, EigenType >::resize ( Eigen::Index  rows,
Eigen::Index  cols 
)
inline

◆ row()

template<int R, int C, template< int R2, int C2 > class EigenType>
template<typename M = MatType>
std::enable_if<std::is_same<M, EFMatrix<R, C> >::value, ExtendedFloatRow<R, C, EigenType > >::type bpp::ExtendedFloatEigen< R, C, EigenType >::row ( Eigen::Index  pos)
inline

Definition at line 773 of file ExtendedFloatEigen.h.

◆ rows()

◆ rowwise() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatVectorwiseOp<Self, MatType, Eigen::Horizontal> bpp::ExtendedFloatEigen< R, C, EigenType >::rowwise ( )
inline

Definition at line 778 of file ExtendedFloatEigen.h.

◆ rowwise() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatVectorwiseOp<const Self, const MatType, Eigen::Horizontal> bpp::ExtendedFloatEigen< R, C, EigenType >::rowwise ( ) const
inline

Definition at line 783 of file ExtendedFloatEigen.h.

◆ size()

template<int R, int C, template< int R2, int C2 > class EigenType>
Eigen::Index bpp::ExtendedFloatEigen< R, C, EigenType >::size ( ) const
inline

◆ sum()

◆ transpose()

template<int R, int C, template< int R2, int C2 > class EigenType>
ExtendedFloatMatrix<C, R> bpp::ExtendedFloatEigen< R, C, EigenType >::transpose ( ) const
inline

◆ Zero() [1/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Zero ( Eigen::Index  rows)
inlinestatic

◆ Zero() [2/2]

template<int R, int C, template< int R2, int C2 > class EigenType>
static Self bpp::ExtendedFloatEigen< R, C, EigenType >::Zero ( Eigen::Index  rows,
Eigen::Index  cols 
)
inlinestatic

Friends And Related Function Documentation

◆ operator<<

template<int R, int C, template< int R2, int C2 > class EigenType>
std::ostream& operator<< ( std::ostream &  out,
const Self ef 
)
friend

Definition at line 866 of file ExtendedFloatEigen.h.

Member Data Documentation

◆ der_

ExtendedFloatEigen< R, C, EigenType > & bpp::ExtendedFloatEigenBase< ExtendedFloatEigen< R, C, EigenType > >::der_
privateinherited

Definition at line 26 of file ExtendedFloatEigen.h.

◆ EFtmp_

◆ exp_

◆ mat_

template<int R, int C, template< int R2, int C2 > class EigenType>
MatType bpp::ExtendedFloatEigen< R, C, EigenType >::mat_
protected

The documentation for this class was generated from the following file: