Namespaces
namespace	age

namespace	age2

namespace	bindings

namespace	nsga2

namespace	smsemoa

namespace	steady_state_mocma

Classes
class	AGE
	Implements the AGE. More...

class	AGE2
	Implements the AGE2. More...

class	MOCMA
	Implements the generational MO-CMA-ES. More...

class	PAES
	Implements the Pareto-archived evolutionary strategy. More...

class	RealCodedNSGAII
	Implements the NSGA-II. More...

class	SMSEMOA
	Implements the SMS-EMOA. More...

struct	SteadyStateMOCMA
	Implements the \((\mu+1)\)-MO-CMA-ES. More...

struct	unused
	Models an empty chromosome type. More...

struct	PlainTextPrintfFormatProvider
	Implements a printf-like format for plain text log stores. More...

struct	XmlPrintfFormatProvider
	Implements a printf-like format for XML log stores. More...

struct	JsonPrintfFormatProvider
	Implements a printf-like format for JSON log stores. More...

struct	SequenceOfSequenceIteratorTraits
	Helper class of the MultiSequenceIterator, which querys everything needed to deduce the right iterator_facade. More...

struct	DefaultBatch
	default implementation of the Batch which maps it's type on std::vector<T> More...

struct	ArithmeticBatch
	default implementation of the Batch for arithmetic types, which are mapped on shark::blas::vector<T> More...

class	MatrixRowReference
	Wrapper for a matrix row, which offers a conversion operator to to the Vector Type. More...

struct	ItemSerializer
	serializes the object into the archive More...

struct	CreateBatch

struct	resize

struct	MakeRef
	calls get(container,index) on a container. Used as boost fusion functor in the creation of references in the Batch Interface More...

struct	MakeConstRef
	calls get(container,index) on a container. Used as boost fusion functor in the cration of references in the Batch Interface More...

struct	FusionFacade

struct	isFusionFacade

class	SharedContainer
	Shared memory container class with slicing. More...

struct	ElementSort

struct	TransformOneVersusRestLabels

struct	TransformedDataElementTypeFromBatch

struct	TransformedDataElement
	For Data<T> and functor F calculates the result of the resulting elements F(T). More...

class	FusionVectorBatchReference

struct	ADLVector
	Wrapper to enable argument dependent lookup for ublas vectors in shark namespace. More...

class	Scalar
	Wrapper representing a single arithmetic value. More...

struct	InitializerBase
	Expression template as base class for all initializer expressions. More...

class	VectorExpression
	Wrapper for all kinds of vectorexpression which saves the (sparse) vector in the target vector. More...

class	MatrixExpression
	Wrapper for all kinds of matrix expressions which saves the (sparse) matrix row by row in the target vector. More...

class	ParameterizableExpression
	Wrapps a parametrizable Object so that it can be used to initialize or split a vector. More...

class	ParameterizableExpression< T * >
	Wrapps a pointer to a parametrizable Object so that it can be used to initialize or split a vector. More...

class	ParameterizableExpression< T *const >

class	InitializerRange
	Wrapper representing a range of vectors or matrices like std::vector<RealVector> or std::list<SparseRealMatrix>. More...

struct	InitializerEnd
	Marks the end of the initializer list template. More...

class	InitializerNode
	The InitializerNode can initialize a vector on the basis of multiple vector or scalar expressions. More...

class	VectorInitializer
	VectorInitializer takes a Vector and an initialization expression to initialize the vector during destruction. More...

class	VectorSplitter
	VectorSplitter takes a Vector and a mutable initialization expression to split the vector during destruction. More...

class	ConcatenatedModelWrapperBase
	Baseclass for the wrapper which is used to hide the matrix type. More...

class	ConcatenatedModelWrapper
	Internal Wrappertype to connect the output of the first model with the input of the second model. More...

class	ConcatenatedModelList
	When using operator>> to connect more than two models, this type is created. More...

class	LinearModelWrapperBase
	Baseclass of LinearModelWrapper. This class is needed for the type erasure in LinearModel. More...

class	LinearModelWrapper
	Implementation of the Linear Model for specific matrix types. More...

class	NeuronBase
	Baseclass for all Neurons. it defines y=operator(x) for evaluation and derivative(y) for the derivative of the sigmoid. More...

class	MklKernelWrapper
	given a tuple of Inputs (a_1,...a_n) calculates the kernel k(a_N,a_N) for some chosen N More...

class	MklKernelBase

class	SubrangeKernelWrapper
	given two vectors of input x = (x_1,...,x_n), y = (y_1,...,y_n), a subrange 1<=k<l<=n and a kernel k, computes the result of th subrange k((x_k,...x_l),(y_k,...,y_l)) More...

class	SubrangeKernelBase

class	ErrorFunctionWrapper

class	CostBasedErrorFunctionImpl
	Implementation of the Error Function using AbstractCost. More...

class	LossBasedErrorFunctionImpl
	Implementation of the ErrorFunction using AbstractLoss. More...

class	ParallelLossBasedErrorFunctionImpl
	Implementation of the ErrorFunction using AbstractLoss for parallelizable computations. More...

class	FunctionWrapperBase
	Base class for implementations of the Error Function. More...

class	NoisyErrorFunctionWrapper
	Implementation for the NoisyErrorFunction. It hides the Type of the OutputType. More...

class	SparseFFNetErrorWrapper
	Implementation of the SparseFFNetError. More...

class	NoisyErrorFunctionWrapperBase
	Baseclass for the Typewrapper of the Noisy Error Function. More...

class	TypedMultiVariateNormalDistribution
	Implements a multi-variate normal distribution with zero mean. More...

struct	BinarySufficientStatistics

struct	GaussianSufficientStatistics

struct	TruncatedExponentialSufficientStatistics

struct	GibbsSample
	Represents a single sample of the GibbsOperator. More...

struct	MarkovChainSample

Typedefs
typedef std::pair< unsigned int, size_t >	LabelSortPair

Functions
template<class M , class V >
void	swap (MatrixRowReference< M, V > ref1, MatrixRowReference< M, V > ref2)

template<typename T , typename Stream >
void	export_csv (const T &data, Stream &out, const std::string &separator, bool scientific=true, unsigned int fieldwidth=0)

template<typename T , typename Stream >
void	import_csv (T &data, Stream &pre_in, const std::string &separator, const std::string &comment)

template<typename Stream >
void	import_csv (std::vector< unsigned int > &data, Stream &pre_in, const std::string &separator, const std::string &comment)

template<typename Stream >
void	import_csv (std::vector< double > &data, Stream &pre_in, const std::string &separator, const std::string &comment)

template<typename T , typename U , typename Stream >
void	export_csv (const T &input, const U &labels, Stream &out, LabelPosition lp, const std::string &separator, bool scientific=true, unsigned int fieldwidth=0, typename boost::enable_if< boost::is_arithmetic< typename boost::range_value< U >::type > >::type *dummy=0)

template<typename T , typename U , typename Stream >
void	export_csv (const T &input, const U &labels, Stream &out, LabelPosition lp, const std::string &separator, bool scientific=true, unsigned int fieldwidth=0, typename boost::disable_if< boost::is_arithmetic< typename boost::range_value< U >::type > >::type *dummy=0)

template<typename T , typename U , typename Stream >
void	import_csv (T &input, U &labels, Stream &pre_in, LabelPosition lp, const std::string &separator, const std::string &comment, bool allowMissingFeatures=false, bool allowMissingClasses=false, std::map< typename U::value_type, typename U::value_type > const *labelmap=NULL)

template<typename T , typename U , typename Stream >
void	import_csv_regression (T &input, U &labels, Stream &pre_in, LabelPosition lp, const std::string &separator, const std::string &comment, std::size_t noOutputs, bool allowMissingFeatures=false)

template<class I , class L >
CVFolds< LabeledData< I, L > >	createCVSameSizeBalanced (LabeledData< I, L > &set, std::size_t numberOfPartitions, std::vector< std::vector< std::size_t > > members, std::size_t batchSize)
	Version of createCVSameSizeBalanced which works regardless of the label type. More...

template<typename RawValueType >
bool	isSupported (H5T_class_t typeClass, size_t typeSize)
	Check whether and are supported by current implementation. More...

template<typename MatrixType >
void	loadIntoMatrix (MatrixType &data, const std::string &fileName, const std::string &dataSetName)
	Load a dataset in a HDF5 file into a matrix. More...

template<typename MatrixType >
void	loadHDF5Csc (MatrixType &data, const std::string &fileName, const std::vector< std::string > &cscDatasetName)
	load a matrix from HDF5 file in compressed sparse column format More...

template<typename VectorType , typename LabelType >
void	constructLabeledData (LabeledData< VectorType, LabelType > &labeledData, const std::vector< VectorType > &dataBuffer, const std::vector< std::vector< LabelType > > &labelBuffer)
	Construct labeled data from passed in data and label. More...

static bool	cmpLabelSortPair (const LabelSortPair &left, const LabelSortPair &right)

template<class Reference , class Get >
void	swap (FusionVectorBatchReference< Reference, Get > ref1, FusionVectorBatchReference< Reference, Get > ref2)

void	importPGM (const char fileName, unsigned char *ppData, int &sx, int &sy)

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalPanelBlockOperation (MatA const &matA, MatB const &blockStorage, blas::matrix_expression< MatC > &matC, ComputeKernel kernel)
	Optimized implementation of a matrix-matrix operation for a small block matrix (blockStorage) and a bigger Panel matrix (matA). More...

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalBlockPanelOperation (MatA const &blockStorage, MatB const &matB, blas::matrix_expression< MatC > &matC, ComputeKernel kernel)
	Optimized implementation of a vector matrix operations for a small block matrix (blockStorage) and a vector. More...

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalPanelBlockOperation (blas::matrix_expression< MatA > const &matA, blas::matrix_expression< MatB > const &blockStorage, blas::matrix_range< MatC > matC, ComputeKernel kernel)

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalBlockPanelOperation (blas::matrix_expression< MatA > const &blockStorage, blas::matrix_expression< MatB > const &matB, blas::matrix_range< MatC > matC, ComputeKernel kernel)

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalPanelPanelOperation (MatA const &matA, MatB const &matB, MatC &matC, ComputeKernel kernel, blas::row_major_tag)

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalPanelPanelOperation (MatA const &matA, MatB const &matB, MatC &matC, ComputeKernel kernel, blas::column_major_tag)
	performs matrix-matrix multiplication like operations on 2 Panel matrices More...

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalMatrixMatrixOperation (MatA const &matA, MatB const &matB, MatC &matC, ComputeKernel kernel, blas::row_major_tag)
	Performs matrix-matrix multiplication like operations on 2 matrices. More...

template<class MatA , class MatB , class MatC , class ComputeKernel >
void	generalMatrixMatrixOperation (MatA const &matA, MatB const &matB, MatC &matC, ComputeKernel kernel, blas::column_major_tag)
	Performs matrix-matrix multiplication like operations on 2 matrices. More...

template<class MatA , class VecB , class VecC , class ComputeKernel >
void	generalMatrixVectorOperation (MatA const &matA, VecB const &vecB, VecC &vecC, ComputeKernel kernel, blas::column_major_tag, blas::dense_proxy_tag, blas::dense_proxy_tag)
	General matrix-vector multiplication like operation. More...

template<class MatA , class VecB , class VecC , class ComputeKernel >
void	generalMatrixVectorOperation (MatA const &matA, VecB const &vecB, VecC &vecC, ComputeKernel kernel, blas::row_major_tag, blas::dense_proxy_tag, blas::dense_proxy_tag)
	General matrix-vector multiplication like operation. More...

template<class MatA , class MatB , class MatC >
void	fast_prod_dense (blas::matrix_expression< MatA > const &matA, blas::matrix_expression< MatB > const &matB, blas::matrix_expression< MatC > &matC, bool beta, double alpha)

template<class MatA , class MatB , class MatC >
void	fast_prod_detail (blas::matrix_expression< MatA > const &matA, blas::matrix_expression< MatB > const &matB, blas::matrix_expression< MatC > &matC, bool beta, double alpha, boost::mpl::true_)

template<class MatA , class MatB , class MatC >
void	fast_prod_detail (blas::matrix_expression< MatA > const &matA, blas::matrix_expression< MatB > const &matB, blas::matrix_expression< MatC > &matC, bool beta, double alpha, boost::mpl::false_)

template<class MatA , class VecB , class VecC >
void	fast_prod_impl (blas::matrix_expression< MatA > const &matA, blas::vector_expression< VecB > const &vecB, blas::vector_expression< VecC > &vecC, bool beta, double alpha, boost::mpl::true_)

template<class MatA , class VecB , class VecC >
void	fast_prod_impl (blas::matrix_expression< MatA > const &matA, blas::vector_expression< VecB > const &vecB, blas::vector_expression< VecC > &vecC, bool beta, double alpha, boost::mpl::false_)

template<class Sink >
VectorInitializer< Sink, InitializerNode < InitializerEnd, Scalar < const typename Sink::value_type > > >	operator<< (const ADLVector< Sink > &sink, const typename Sink::value_type &value)
	Begins the initialization argument with a vector as first right hand side argument. More...

template<class Sink >
VectorInitializer< Sink &, InitializerNode < InitializerEnd, Scalar < const typename Sink::value_type > > >	operator<< (const ADLVector< Sink & > &sink, const typename Sink::value_type &value)

template<class Sink , class Init >
VectorInitializer< Sink, InitializerNode< Init, Scalar < const typename Sink::value_type > > >	operator, (const VectorInitializer< Sink, Init > &init, const typename Sink::value_type &value)
	Appends a single vector expression c to the expression vec<<a,b -> vec<<a,b,c. More...

template<class Sink , class Init >
VectorInitializer< Sink &, InitializerNode< Init, Scalar< const typename Sink::value_type > > >	operator, (const VectorInitializer< Sink &, Init > &init, const typename Sink::value_type &value)

template<class Sink >
VectorSplitter< Sink, InitializerNode < InitializerEnd, Scalar < typename Sink::value_type > > >	operator>> (const ADLVector< Sink > &sink, typename Sink::value_type &value)
	Appends a single mutable vector expression. More...

template<class Sink >
VectorSplitter< Sink &, InitializerNode < InitializerEnd, Scalar < typename Sink::value_type > > >	operator>> (const ADLVector< Sink & > &sink, typename Sink::value_type &value)

template<class Source , class Init , class Sink >
VectorSplitter< Source, InitializerNode< Init, VectorExpression< Sink & > > >	operator, (const VectorSplitter< Source, Init > &source, shark::blas::vector_expression< Sink > &vec)
	Appends a single mutable vector expression. More...

template<class Source , class Init , class Sink >
VectorSplitter< Source, InitializerNode< Init, Sink > >	operator, (const VectorSplitter< Source, Init > &source, const InitializerBase< Sink > &vec)
	Appends a initialization expression. More...

template<class Source , class Init >
VectorSplitter< Source, InitializerNode< Init, Scalar < typename Source::value_type > > >	operator, (const VectorSplitter< Source, Init > &source, typename Source::value_type &value)
	Operator comma adds another value for splitting. More...

template<class Source , class Init >
VectorSplitter< Source &, InitializerNode< Init, Scalar< typename Source::value_type > > >	operator, (const VectorSplitter< Source &, Init > &source, typename Source::value_type &value)

template<std::size_t L2Size, class MatA , class VecB >
void	sumRows (MatA const &matA, VecB &vecB, blas::column_major_tag)

template<std::size_t L2Size, class MatA , class VecB , class Orientation >
void	sumRows (MatA const &matA, VecB &vecB, Orientation)

template<class Matrix >
void	zero (blas::matrix_expression< Matrix > &mat, boost::mpl::true_)

template<class Vector >
void	zero (blas::vector_expression< Vector > &vec, boost::mpl::true_)

template<class Matrix >
void	zero (blas::matrix_container< Matrix > &mat, boost::mpl::false_)

template<class Vector >
void	zero (blas::vector_container< Vector > &vec, boost::mpl::false_)

template<class Matrix >
void	zero (blas::matrix_expression< Matrix > &mat, boost::mpl::false_)

template<class Vector >
void	zero (blas::vector_expression< Vector > &vec, boost::mpl::false_)

template<class Matrix >
void	ensureSize (blas::matrix_expression< Matrix > &mat, std::size_t rows, std::size_t columns)

template<class Matrix >
void	ensureSize (blas::matrix_container< Matrix > &mat, std::size_t rows, std::size_t columns)

template<class Vector >
void	ensureSize (blas::vector_expression< Vector > &vec, std::size_t size)

template<class Vector >
void	ensureSize (blas::vector_container< Vector > &vec, std::size_t size)

template<class MatT , class VecT , class MatrixTag >
void	solveTriangularSystemInPlace (const blas::matrix_expression< MatT > &A, blas::vector_expression< VecT > &b, SolveAXB, MatrixTag)

template<class MatT , class VecT , class MatrixTag >
void	solveTriangularSystemInPlace (const blas::matrix_expression< MatT > &A, blas::vector_expression< VecT > &b, SolveXAB, MatrixTag)
	solving xA=b is equal to transposing A More...

template<class MatL , class Arg >
void	solveTriangularCholeskyInPlace (blas::matrix_expression< MatL > const &L, Arg &b, SolveAXB)

template<class MatL , class Arg >
void	solveTriangularCholeskyInPlace (blas::matrix_expression< MatL > const &L, Arg &b, SolveXAB)

template<class AverageEnergyGradient , class VectorType , class RBM >
void	evaluateData (AverageEnergyGradient &averageGradient, Data< VectorType > const &data, RBM &rbm)
	function used by gradient approximators to calculate the gradient of the data More...

double	updateLogPartition (double logZn, double E)
	updates the log partition with the Energy of another state More...

template<class RBMType , class Enumeration >
double	logPartitionFunctionImplFactHidden (const RBMType &rbm, Enumeration, double beta)
	Estimates the partition function with factorization over the hidden variables. More...

template<class RBMType , class Enumeration >
double	logPartitionFunctionImplFactVisible (const RBMType &rbm, Enumeration, double beta)
	Estimates the partition function with factorization over the hidden variables. More...

template<class RBMType >
double	logPartitionFunction (const RBMType &rbm, tags::DiscreteSpace, tags::RealSpace, double beta)

template<class RBMType >
double	logPartitionFunction (const RBMType &rbm, tags::RealSpace, tags::DiscreteSpace, double beta)

template<class RBMType >
double	logPartitionFunction (const RBMType &rbm, tags::DiscreteSpace, tags::DiscreteSpace, double beta)

template<class RBMType >
double	logPartitionFunction (const RBMType &rbm, tags::RealSpace, tags::RealSpace, double beta)


herr_t	readHDF5Dataset (hid_t loc_id, const char dset_name, int buffer)

herr_t	readHDF5Dataset (hid_t loc_id, const char dset_name, long buffer)

herr_t	readHDF5Dataset (hid_t loc_id, const char dset_name, float buffer)

herr_t	readHDF5Dataset (hid_t loc_id, const char dset_name, double buffer)


std::size_t	batchPartitioning (std::vector< std::size_t > const &partitionSizes, std::vector< std::size_t > &partitionStart, std::vector< std::size_t > &batchSizes, std::size_t maximumBatchSize)
	Given the sizes of the partition sets and the maximum batch size, computes a good partitioning. More...

template<class T , class T2 >
void	complement (T const &set, std::size_t n, T2 &comp)
	compute the complement of the indices with respect to the set [0,...n[ More...

template<class T >
void	range (size_t size, T &indices)
	compute the index set for the range [0, ..., size[ More...

template<class T >
void	range (size_t size, size_t start, T &indices)
	compute the index set for the range [start, ..., size+start[ More...


void	writePGM (const char fileName, const unsigned char pData, const unsigned int sx, const unsigned int sy)
	Writes a PGM file. More...

Typedef Documentation

typedef std::pair< unsigned int, size_t > shark::detail::LabelSortPair

Definition at line 51 of file Libsvm.h.

Function Documentation

std::size_t shark::detail::batchPartitioning	(	std::vector< std::size_t > const &	partitionSizes,
		std::vector< std::size_t > &	partitionStart,
		std::vector< std::size_t > &	batchSizes,
		std::size_t	maximumBatchSize
	)

inline

Given the sizes of the partition sets and the maximum batch size, computes a good partitioning.

Parameters

partitionSizes	Sizes of the partitions
partitionStart	Index of the starting batch of the partition
batchSizes	Sizes of the batches
maximumBatchSize	The maximum size a batch is allowed to have

Returns: the total number of batches

Definition at line 60 of file Dataset.inl.

References shark::size().

Referenced by shark::createCVIndexed(), shark::createCVSameSize(), createCVSameSizeBalanced(), and shark::repartitionByClass().

static bool shark::detail::cmpLabelSortPair	(	const LabelSortPair &	left,
		const LabelSortPair &	right
	)

static

Definition at line 52 of file Libsvm.h.

Referenced by shark::export_libsvm().

template<class T , class T2 >

void shark::detail::complement	(	T const &	set,
		std::size_t	n,
		T2 &	comp
	)

compute the complement of the indices with respect to the set [0,...n[

Definition at line 454 of file Dataset.inl.

References boost::fusion::copy(), and shark::blas::distance().

Referenced by shark::CVFolds< DatasetType >::CVFolds(), shark::Data< LabelT >::indexedSubset(), shark::LabeledData< InputType, LabelType >::indexedSubset(), and shark::CVFolds< DatasetType >::validation().

template<typename VectorType , typename LabelType >

void shark::detail::constructLabeledData	(	LabeledData< VectorType, LabelType > &	labeledData,
		const std::vector< VectorType > &	dataBuffer,
		const std::vector< std::vector< LabelType > > &	labelBuffer
	)

Construct labeled data from passed in data and label.

Parameters

labeledData	Container storing the loaded data
dataBuffer	The data container will hold
labelBuffer	The label for data inside dataBuffer

Definition at line 239 of file HDF5.h.

References shark::createLabeledDataFromRange(), and THROW_IF().

Referenced by shark::importHDF5().

template<class I , class L >

CVFolds<LabeledData<I,L> > shark::detail::createCVSameSizeBalanced	(	LabeledData< I, L > &	set,
		std::size_t	numberOfPartitions,
		std::vector< std::vector< std::size_t > >	members,
		std::size_t	batchSize
	)

Version of createCVSameSizeBalanced which works regardless of the label type.

This function for every class requires one vector to store the indices of.. todo

Definition at line 121 of file CVDatasetTools.h.

References shark::LabeledData< InputT, LabelT >::batch(), batchPartitioning(), shark::size(), shark::subBatch(), and swap().

Referenced by shark::createCVSameSizeBalanced().

template<class Matrix >

void shark::detail::ensureSize	(	blas::matrix_expression< Matrix > &	mat,
		std::size_t	rows,
		std::size_t	columns
	)

Definition at line 91 of file Tools.h.

References SIZE_CHECK.

Referenced by shark::choleskyDecomposition(), shark::decomposedGeneralInverse(), shark::ensureSize(), shark::detail::ArithmeticBatch< T >::resize(), shark::solveSymmSystem(), shark::solveSystem(), and shark::detail::SubrangeKernelWrapper< InputType >::weightedInputDerivative().

template<class Matrix >

void shark::detail::ensureSize	(	blas::matrix_container< Matrix > &	mat,
		std::size_t	rows,
		std::size_t	columns
	)

Definition at line 96 of file Tools.h.

template<class Vector >

void shark::detail::ensureSize	(	blas::vector_expression< Vector > &	vec,
		std::size_t	size
	)

Definition at line 100 of file Tools.h.

References shark::size(), and SIZE_CHECK.

template<class Vector >

void shark::detail::ensureSize	(	blas::vector_container< Vector > &	vec,
		std::size_t	size
	)

Definition at line 104 of file Tools.h.

template<class AverageEnergyGradient , class VectorType , class RBM >

void shark::detail::evaluateData	(	AverageEnergyGradient &	averageGradient,
		Data< VectorType > const &	data,
		RBM &	rbm
	)

function used by gradient approximators to calculate the gradient of the data

Definition at line 25 of file DataEvaluator.h.

References shark::AverageEnergyGradient< RBM >::addVH(), shark::Data< Type >::batches(), shark::RBM< VisibleLayerT, HiddenLayerT, RngT >::numberOfHN(), and shark::RBM< VisibleLayerT, HiddenLayerT, RngT >::numberOfVN().

Referenced by shark::SingleChainApproximator< MarkovChainType >::evalDerivative(), and shark::MultiChainApproximator< MarkovChainType >::evalDerivative().

template<typename T , typename Stream >

void shark::detail::export_csv	(	const T &	data,
		Stream &	out,
		const std::string &	separator,
		bool	scientific = `true`,
		unsigned int	fieldwidth = `0`
	)

Definition at line 89 of file Csv.h.

References SHARK_CHECK.

Referenced by shark::export_csv().

template<typename T , typename U , typename Stream >

void shark::detail::export_csv	(	const T &	input,
		const U &	labels,
		Stream &	out,
		LabelPosition	lp,
		const std::string &	separator,
		bool	scientific = `true`,
		unsigned int	fieldwidth = `0`,
		typename boost::enable_if< boost::is_arithmetic< typename boost::range_value< U >::type > >::type *	dummy = `0`
	)

Definition at line 380 of file Csv.h.

References shark::FIRST_COLUMN, and SHARK_CHECK.

template<typename T , typename U , typename Stream >

void shark::detail::export_csv	(	const T &	input,
		const U &	labels,
		Stream &	out,
		LabelPosition	lp,
		const std::string &	separator,
		bool	scientific = `true`,
		unsigned int	fieldwidth = `0`,
		typename boost::disable_if< boost::is_arithmetic< typename boost::range_value< U >::type > >::type *	dummy = `0`
	)

Definition at line 424 of file Csv.h.

References shark::FIRST_COLUMN, and SHARK_CHECK.

template<class MatA , class MatB , class MatC >

void shark::detail::fast_prod_dense	(	blas::matrix_expression< MatA > const &	matA,
		blas::matrix_expression< MatB > const &	matB,
		blas::matrix_expression< MatC > &	matC,
		bool	beta,
		double	alpha
	)

Definition at line 49 of file fast_prod_matrix.inl.

References shark::detail::bindings::gemm(), shark::traits::isTransposed(), shark::traits::sameOrientation(), shark::blas::trans(), and shark::zero().

Referenced by fast_prod_detail().

template<class MatA , class MatB , class MatC >

void shark::detail::fast_prod_detail	(	blas::matrix_expression< MatA > const &	matA,
		blas::matrix_expression< MatB > const &	matB,
		blas::matrix_expression< MatC > &	matC,
		bool	beta,
		double	alpha,
		boost::mpl::true_
	)

Definition at line 86 of file fast_prod_matrix.inl.

References shark::blas::axpy_prod(), shark::traits::isColumnMajor(), shark::traits::isRowMajor(), shark::blas::prod(), and shark::zero().

Referenced by shark::fast_prod().

template<class MatA , class MatB , class MatC >

void shark::detail::fast_prod_detail	(	blas::matrix_expression< MatA > const &	matA,
		blas::matrix_expression< MatB > const &	matB,
		blas::matrix_expression< MatC > &	matC,
		bool	beta,
		double	alpha,
		boost::mpl::false_
	)

Definition at line 113 of file fast_prod_matrix.inl.

References fast_prod_dense().

template<class MatA , class VecB , class VecC >

void shark::detail::fast_prod_impl	(	blas::matrix_expression< MatA > const &	matA,
		blas::vector_expression< VecB > const &	vecB,
		blas::vector_expression< VecC > &	vecC,
		bool	beta,
		double	alpha,
		boost::mpl::true_
	)

Definition at line 48 of file fast_prod_vector.inl.

References shark::blas::axpy_prod(), and shark::zero().

Referenced by shark::fast_prod().

template<class MatA , class VecB , class VecC >

void shark::detail::fast_prod_impl	(	blas::matrix_expression< MatA > const &	matA,
		blas::vector_expression< VecB > const &	vecB,
		blas::vector_expression< VecC > &	vecC,
		bool	beta,
		double	alpha,
		boost::mpl::false_
	)

Definition at line 66 of file fast_prod_vector.inl.

References shark::detail::bindings::gemv(), and shark::zero().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalBlockPanelOperation	(	MatA const &	blockStorage,
		MatB const &	matB,
		blas::matrix_expression< MatC > &	matC,
		ComputeKernel	kernel
	)

Optimized implementation of a vector matrix operations for a small block matrix (blockStorage) and a vector.

This function is the main building block for fast bigger matrix matrix operations. In the case of matrix multiplication, it multiplies a block matrix with a panel matrix (currently only a row vector). as A*trans(blockStorage). It is assumed that all matrices are column major and packed. Also blockStorage should fit into L1 cache.

: The compute kernel performs an operation for two elements a_i b_j as kernel(a_i,b_j). The kernel must be very small so that it can be inlined. some kernels which are possible: kernel(a_i,b_j) = a_i*b_j(result in matrix matrix multiplication) kernel(a_i,b_j) = (a_i-b_j)^2 (results in kernel gram matrix for the squared euclidean kernel)

Definition at line 364 of file BlockProducts.h.

References BOOST_STATIC_ASSERT(), SIZE_CHECK, and shark::blas::sum().

Referenced by generalBlockPanelOperation(), generalMatrixMatrixOperation(), and generalPanelPanelOperation().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalBlockPanelOperation	(	blas::matrix_expression< MatA > const &	blockStorage,
		blas::matrix_expression< MatB > const &	matB,
		blas::matrix_range< MatC >	matC,
		ComputeKernel	kernel
	)

inline

Definition at line 406 of file BlockProducts.h.

References generalBlockPanelOperation().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalMatrixMatrixOperation	(	MatA const &	matA,
		MatB const &	matB,
		MatC &	matC,
		ComputeKernel	kernel,
		blas::row_major_tag
	)

Performs matrix-matrix multiplication like operations on 2 matrices.

algorithm as described in Gotos paper "Anatomy of High-Performance Matrix Multiplication" this is the outer layer of the described algorithm. it splits the matrices into panels and than performs Panel-Panel operations repeatedly.This is the version for row_major matrices, which is a bit more optimized than column major.

Definition at line 522 of file BlockProducts.h.

References generalPanelBlockOperation(), generalPanelPanelOperation(), shark::blas::min(), shark::blas::matrix< T, L, A >::size1(), SIZE_CHECK, shark::blas::subrange(), and shark::blas::trans().

Referenced by shark::generalMatrixMatrixOperation().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalMatrixMatrixOperation	(	MatA const &	matA,
		MatB const &	matB,
		MatC &	matC,
		ComputeKernel	kernel,
		blas::column_major_tag
	)

Performs matrix-matrix multiplication like operations on 2 matrices.

algorithm as described in Gotos paper "Anatomy of High-Performance Matrix Multiplication" this is the outer layer of the described algorithm. it splits the matrices into panels and than performs Panel-Panel operations repeatedly. This is the version for column major matrices

Definition at line 572 of file BlockProducts.h.

References generalBlockPanelOperation(), generalPanelPanelOperation(), shark::blas::min(), shark::blas::matrix< T, L, A >::size1(), SIZE_CHECK, shark::blas::subrange(), and shark::blas::trans().

template<class MatA , class VecB , class VecC , class ComputeKernel >

void shark::detail::generalMatrixVectorOperation	(	MatA const &	matA,
		VecB const &	vecB,
		VecC &	vecC,
		ComputeKernel	kernel,
		blas::column_major_tag	,
		blas::dense_proxy_tag	,
		blas::dense_proxy_tag
	)

General matrix-vector multiplication like operation.

The usual scalar multiplication x*y is here replaced by a general kernel, which enables the computation of more complex operations than the matrix-vector product. However this is not as optimized as the fast_prod for the matrix-vector product, at least when ATLAS is used! this is the version for column major matrices. here we compute 4 columns at the same time. This saves memory lookup of a factor of 4.

Definition at line 59 of file BlockMatrixVectorOperation.inl.

References shark::blas::column(), shark::traits::hasDenseLeadingDimension(), shark::traits::matrix_storage(), shark::traits::matrix_stride2(), and SIZE_CHECK.

Referenced by shark::generalMatrixVectorOperation().

template<class MatA , class VecB , class VecC , class ComputeKernel >

void shark::detail::generalMatrixVectorOperation	(	MatA const &	matA,
		VecB const &	vecB,
		VecC &	vecC,
		ComputeKernel	kernel,
		blas::row_major_tag	,
		blas::dense_proxy_tag	,
		blas::dense_proxy_tag
	)

General matrix-vector multiplication like operation.

The usual scalar multiplication x*y is here replaced by a general kernel, which enables the computation of more complex operations than the matrix-vector product. However this is not as optimized as the fast_prod for the matrix-vector product, at least when ATLAS is used! this is the version for row major matrices. here we compute 4 rows at the same time. This saves memory lookup of a factor of 4.

Definition at line 145 of file BlockMatrixVectorOperation.inl.

References shark::traits::hasDenseLeadingDimension(), shark::traits::matrix_storage(), shark::traits::matrix_stride1(), shark::blas::row(), SIZE_CHECK, shark::traits::vector_storage(), and shark::traits::vector_stride().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalPanelBlockOperation	(	MatA const &	matA,
		MatB const &	blockStorage,
		blas::matrix_expression< MatC > &	matC,
		ComputeKernel	kernel
	)

Optimized implementation of a matrix-matrix operation for a small block matrix (blockStorage) and a bigger Panel matrix (matA).

A Panel matrix is a matrix with (in this case) much more rows than columns. This function is the main building block for fast bigger matrix matrix operations. In the case of matrix multiplication, it multiplies a block matrix with a panel matrix (currently only a row vector). as A*trans(blockStorage). It is assumed that all matrices are row major and packed. Also blockStorage should fit into L1 cache.

: The compute kernel performs an operation for two elements a_i b_j as kernel(a_i,b_j). The kernel must be very small so that it can be inlined. some kernels which are possible: kernel(a_i,b_j) = a_i*b_j(result in matrix matrix multiplication) kernel(a_i,b_j) = (a_i-b_j)^2 (results in kernel gram matrix for the squared euclidean kernel)

Definition at line 60 of file BlockProducts.h.

References BOOST_STATIC_ASSERT(), shark::blas::row(), and SIZE_CHECK.

Referenced by generalMatrixMatrixOperation(), generalPanelBlockOperation(), and generalPanelPanelOperation().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalPanelBlockOperation	(	blas::matrix_expression< MatA > const &	matA,
		blas::matrix_expression< MatB > const &	blockStorage,
		blas::matrix_range< MatC >	matC,
		ComputeKernel	kernel
	)

inline

Definition at line 396 of file BlockProducts.h.

References generalPanelBlockOperation().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalPanelPanelOperation	(	MatA const &	matA,
		MatB const &	matB,
		MatC &	matC,
		ComputeKernel	kernel,
		blas::row_major_tag
	)

Definition at line 418 of file BlockProducts.h.

References generalPanelBlockOperation(), shark::traits::hasStorage(), shark::blas::min(), shark::blas::noalias(), shark::blas::matrix< T, L, A >::size2(), SIZE_CHECK, shark::blas::subrange(), and shark::blas::trans().

Referenced by generalMatrixMatrixOperation(), generalPanelPanelOperation(), and shark::generalPanelPanelOperation().

template<class MatA , class MatB , class MatC , class ComputeKernel >

void shark::detail::generalPanelPanelOperation	(	MatA const &	matA,
		MatB const &	matB,
		MatC &	matC,
		ComputeKernel	kernel,
		blas::column_major_tag
	)

performs matrix-matrix multiplication like operations on 2 Panel matrices

algorithm as described in Gotos paper "Anatomy of High-Performance Matrix Multiplication" this is the version for column-major matrices. Goto described it in Fig10 of his algorithm. we generalize it here for arbitrary operations instead of the multiplication. It is also not really optimized to the bitter end, but at least factor 2 faster, than straight forward code.

Definition at line 468 of file BlockProducts.h.

References generalBlockPanelOperation(), generalPanelPanelOperation(), shark::traits::hasStorage(), shark::blas::min(), shark::blas::noalias(), SIZE_CHECK, shark::blas::subrange(), and shark::blas::trans().

template<typename T , typename Stream >

void shark::detail::import_csv	(	T &	data,
		Stream &	pre_in,
		const std::string &	separator,
		const std::string &	comment
	)

Definition at line 123 of file Csv.h.

References boost::fusion::copy(), SHARK_ASSERT, and SHARKEXCEPTION.

Referenced by shark::import_csv(), main(), and shark::string2data().

template<typename Stream >

void shark::detail::import_csv	(	std::vector< unsigned int > &	data,
		Stream &	pre_in,
		const std::string &	separator,
		const std::string &	comment
	)

Definition at line 212 of file Csv.h.

References boost::fusion::copy(), SHARK_ASSERT, and SHARKEXCEPTION.

template<typename Stream >

void shark::detail::import_csv	(	std::vector< double > &	data,
		Stream &	pre_in,
		const std::string &	separator,
		const std::string &	comment
	)

Definition at line 296 of file Csv.h.

References boost::fusion::copy(), SHARK_ASSERT, and SHARKEXCEPTION.

template<typename T , typename U , typename Stream >

void shark::detail::import_csv	(	T &	input,
		U &	labels,
		Stream &	pre_in,
		LabelPosition	lp,
		const std::string &	separator,
		const std::string &	comment,
		bool	allowMissingFeatures = `false`,
		bool	allowMissingClasses = `false`,
		std::map< typename U::value_type, typename U::value_type > const *	labelmap = `NULL`
	)

Definition at line 472 of file Csv.h.

References boost::fusion::copy(), shark::FIRST_COLUMN, shark::blas::max(), shark::blas::min(), SHARK_ASSERT, and SHARKEXCEPTION.

template<typename T , typename U , typename Stream >

void shark::detail::import_csv_regression	(	T &	input,
		U &	labels,
		Stream &	pre_in,
		LabelPosition	lp,
		const std::string &	separator,
		const std::string &	comment,
		std::size_t	noOutputs,
		bool	allowMissingFeatures = `false`
	)

Definition at line 656 of file Csv.h.

References boost::fusion::copy(), shark::FIRST_COLUMN, SHARK_ASSERT, and SHARKEXCEPTION.

Referenced by shark::import_csv().

void shark::detail::importPGM	(	const char *	fileName,
		unsigned char **	ppData,
		int &	sx,
		int &	sy
	)

Definition at line 49 of file Pgm.h.

References SHARKEXCEPTION.

Referenced by shark::importPGM().

template<typename RawValueType >

bool shark::detail::isSupported	(	H5T_class_t	typeClass,
		size_t	typeSize
	)

Check whether and are supported by current implementation.

Definition at line 93 of file HDF5.h.

template<typename MatrixType >

void shark::detail::loadHDF5Csc	(	MatrixType &	data,
		const std::string &	fileName,
		const std::vector< std::string > &	cscDatasetName
	)

load a matrix from HDF5 file in compressed sparse column format

Parameters

data	the container which will hold the output matrix
fileName	the name of HDF5 file
cscDatasetName	dataset names for describing the CSC

Definition at line 193 of file HDF5.h.

References loadIntoMatrix(), and THROW_IF().

Referenced by shark::importHDF5().

template<typename MatrixType >

void shark::detail::loadIntoMatrix	(	MatrixType &	data,
		const std::string &	fileName,
		const std::string &	dataSetName
	)

Load a dataset in a HDF5 file into a matrix.

Parameters

data	in vector of vector format which should support assignment operations
fileName	The name of HDF5 file to be read from
dataSetName	the HDF5 dataset name to access in the HDF5 file

Template Parameters

MatrixType The type of data container which will accept read-in data and should be a 2-dimension matrix

Definition at line 128 of file HDF5.h.

References readHDF5Dataset(), and THROW_IF().

Referenced by shark::importHDF5(), and loadHDF5Csc().

template<class RBMType >

double shark::detail::logPartitionFunction	(	const RBMType &	rbm,
		tags::DiscreteSpace	,
		tags::RealSpace	,
		double	beta
	)

Definition at line 155 of file analytics.h.

References logPartitionFunctionImplFactHidden().

Referenced by shark::logPartitionFunction().

template<class RBMType >

double shark::detail::logPartitionFunction	(	const RBMType &	rbm,
		tags::RealSpace	,
		tags::DiscreteSpace	,
		double	beta
	)

Definition at line 169 of file analytics.h.

References logPartitionFunctionImplFactVisible().

template<class RBMType >

double shark::detail::logPartitionFunction	(	const RBMType &	rbm,
		tags::DiscreteSpace	,
		tags::DiscreteSpace	,
		double	beta
	)

Definition at line 183 of file analytics.h.

References logPartitionFunctionImplFactHidden(), and logPartitionFunctionImplFactVisible().

template<class RBMType >

double shark::detail::logPartitionFunction	(	const RBMType &	rbm,
		tags::RealSpace	,
		tags::RealSpace	,
		double	beta
	)

Definition at line 200 of file analytics.h.

References BOOST_STATIC_ASSERT().

template<class RBMType , class Enumeration >

double shark::detail::logPartitionFunctionImplFactHidden	(	const RBMType &	rbm,
		Enumeration	,
		double	beta
	)

Estimates the partition function with factorization over the hidden variables.

Instead of summing over the unnormalized joint probability of all states of hidden and visible variables this function sums over the unnormalized marginal probability of all states of the visible variables, which is calculated via factorization over the hidden variables.

Enumeration is the state space of the hidden variables.

Parameters

rbm	the RBM
beta	the inverse Temperature of the RBM

Returns: the partition function

Definition at line 76 of file analytics.h.

References shark::blas::min(), shark::blas::row(), and updateLogPartition().

Referenced by logPartitionFunction().

template<class RBMType , class Enumeration >

double shark::detail::logPartitionFunctionImplFactVisible	(	const RBMType &	rbm,
		Enumeration	,
		double	beta
	)

Estimates the partition function with factorization over the hidden variables.

Instead of summing over the unnormalized joint probability of all states of hidden and visible variables this function sums over the unnormalized marginal probability of all states of the hidden variables, which is calculated via factorization over the visible variables.

Enumeration is the state space of the hidden variables.

Parameters

rbm	the RBM
beta	the inverse Temperature of the RBM

Returns: the partition function; the partition function

Definition at line 117 of file analytics.h.

References shark::blas::min(), shark::blas::row(), and updateLogPartition().

Referenced by logPartitionFunction().

template<class Sink , class Init >

VectorInitializer<Sink,InitializerNode<Init,Scalar<const typename Sink::value_type> > > shark::detail::operator,	(	const VectorInitializer< Sink, Init > &	init,
		const typename Sink::value_type &	value
	)

Appends a single vector expression c to the expression vec<<a,b -> vec<<a,b,c.

Appends a initialization expression c to the expression vec<<a,b -> vec<<a,b,c. Operator comma concatenates more vectors and values for initialization.

Special case forsingle values.

Definition at line 429 of file Initialize.h.

References shark::detail::VectorInitializer< VectorExpression, InitExpression >::disable(), shark::detail::VectorInitializer< VectorExpression, InitExpression >::expression(), and shark::detail::VectorInitializer< VectorExpression, InitExpression >::m_vector.

template<class Sink , class Init >

VectorInitializer<Sink&,InitializerNode<Init,Scalar<const typename Sink::value_type> > > shark::detail::operator,	(	const VectorInitializer< Sink &, Init > &	init,
		const typename Sink::value_type &	value
	)

Definition at line 436 of file Initialize.h.

References shark::detail::VectorInitializer< VectorExpression, InitExpression >::disable(), shark::detail::VectorInitializer< VectorExpression, InitExpression >::expression(), and shark::detail::VectorInitializer< VectorExpression, InitExpression >::m_vector.

template<class Source , class Init , class Sink >

VectorSplitter<Source,InitializerNode<Init,VectorExpression<Sink&> > > shark::detail::operator,	(	const VectorSplitter< Source, Init > &	source,
		shark::blas::vector_expression< Sink > &	vec
	)

Appends a single mutable vector expression.

Appends a matrix row. Appends a matrix column. Appends a single vector expression.

Definition at line 528 of file Initialize.h.

References shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::disable(), shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::expression(), and shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::m_vector.

template<class Source , class Init , class Sink >

VectorSplitter<Source,InitializerNode<Init,Sink > > shark::detail::operator,	(	const VectorSplitter< Source, Init > &	source,
		const InitializerBase< Sink > &	vec
	)

Appends a initialization expression.

Definition at line 536 of file Initialize.h.

References shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::disable(), shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::expression(), and shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::m_vector.

template<class Source , class Init >

VectorSplitter<Source,InitializerNode<Init,Scalar<typename Source::value_type> > > shark::detail::operator,	(	const VectorSplitter< Source, Init > &	source,
		typename Source::value_type &	value
	)

Operator comma adds another value for splitting.

Definition at line 545 of file Initialize.h.

References shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::disable(), shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::expression(), and shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::m_vector.

template<class Source , class Init >

VectorSplitter<Source&,InitializerNode<Init,Scalar<typename Source::value_type> > > shark::detail::operator,	(	const VectorSplitter< Source &, Init > &	source,
		typename Source::value_type &	value
	)

Definition at line 552 of file Initialize.h.

References shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::disable(), shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::expression(), and shark::detail::VectorSplitter< VectorExpression, SplittingExpression >::m_vector.

template<class Sink >

VectorInitializer<Sink,InitializerNode<InitializerEnd,Scalar<const typename Sink::value_type> > > shark::detail::operator<<	(	const ADLVector< Sink > &	sink,
		const typename Sink::value_type &	value
	)

Begins the initialization argument with a vector as first right hand side argument.

Begins the initialization argument with a arbitrary source as first right hand side argument. Begins the initialization sequence with a single scalar value.

Definition at line 398 of file Initialize.h.

template<class Sink >

VectorInitializer<Sink&,InitializerNode<InitializerEnd,Scalar<const typename Sink::value_type> > > shark::detail::operator<<	(	const ADLVector< Sink & > &	sink,
		const typename Sink::value_type &	value
	)

Definition at line 404 of file Initialize.h.

template<class Sink >

VectorSplitter<Sink,InitializerNode<InitializerEnd,Scalar<typename Sink::value_type> > > shark::detail::operator>>	(	const ADLVector< Sink > &	sink,
		typename Sink::value_type &	value
	)

Appends a single mutable vector expression.

Appends an arbitrary source. Appends a single variable.

Definition at line 497 of file Initialize.h.

References shark::detail::ADLVector< T >::vector.

template<class Sink >

VectorSplitter<Sink&,InitializerNode<InitializerEnd,Scalar<typename Sink::value_type> > > shark::detail::operator>>	(	const ADLVector< Sink & > &	sink,
		typename Sink::value_type &	value
	)

Definition at line 503 of file Initialize.h.

References shark::detail::ADLVector< T >::vector.

template<class T >

void shark::detail::range	(	size_t	size,
		T &	indices
	)

compute the index set for the range [0, ..., size[

Definition at line 478 of file Dataset.inl.

References shark::size().

Referenced by shark::rangeSubset().

template<class T >

void shark::detail::range	(	size_t	size,
		size_t	start,
		T &	indices
	)

compute the index set for the range [start, ..., size+start[

Definition at line 484 of file Dataset.inl.

References shark::size().

herr_t shark::detail::readHDF5Dataset	(	hid_t	loc_id,
		const char *	dset_name,
		int *	buffer
	)

Overload functions so that complier is able to automatically detect which function to call

Note: Basically there are two ways to add support for other data types: (a) Use other corresponding API H5HTpublic.h if the type is supported(luckily) (b) Use H5LTread_dataset() but need pass in the type_id which are listed at: http://www.hdfgroup.org/HDF5/doc/RM/PredefDTypes.html Need pay special attention to endian.

Definition at line 70 of file HDF5.h.

Referenced by loadIntoMatrix().

herr_t shark::detail::readHDF5Dataset	(	hid_t	loc_id,
		const char *	dset_name,
		long *	buffer
	)

Definition at line 75 of file HDF5.h.

herr_t shark::detail::readHDF5Dataset	(	hid_t	loc_id,
		const char *	dset_name,
		float *	buffer
	)

Definition at line 80 of file HDF5.h.

herr_t shark::detail::readHDF5Dataset	(	hid_t	loc_id,
		const char *	dset_name,
		double *	buffer
	)

Definition at line 85 of file HDF5.h.

template<class MatL , class Arg >

void shark::detail::solveTriangularCholeskyInPlace	(	blas::matrix_expression< MatL > const &	L,
		Arg &	b,
		SolveAXB
	)

Definition at line 66 of file solveTriangular.inl.

References shark::blas::trans().

template<class MatL , class Arg >

void shark::detail::solveTriangularCholeskyInPlace	(	blas::matrix_expression< MatL > const &	L,
		Arg &	b,
		SolveXAB
	)

Definition at line 75 of file solveTriangular.inl.

References shark::blas::trans().

template<class MatT , class VecT , class MatrixTag >

void shark::detail::solveTriangularSystemInPlace	(	const blas::matrix_expression< MatT > &	A,
		blas::vector_expression< VecT > &	b,
		SolveAXB	,
		MatrixTag
	)

Definition at line 45 of file solveTriangular.inl.

Referenced by shark::solveTriangularSystemInPlace().

template<class MatT , class VecT , class MatrixTag >

void shark::detail::solveTriangularSystemInPlace	(	const blas::matrix_expression< MatT > &	A,
		blas::vector_expression< VecT > &	b,
		SolveXAB	,
		MatrixTag
	)

solving xA=b is equal to transposing A

Definition at line 55 of file solveTriangular.inl.

References shark::blas::trans().

template<std::size_t L2Size, class MatA , class VecB >

void shark::detail::sumRows	(	MatA const &	matA,
		VecB &	vecB,
		blas::column_major_tag
	)

Definition at line 42 of file sumMatrix.inl.

References shark::blas::column(), and shark::blas::sum().

template<std::size_t L2Size, class MatA , class VecB , class Orientation >

void shark::detail::sumRows	(	MatA const &	matA,
		VecB &	vecB,
		Orientation
	)

Definition at line 112 of file sumMatrix.inl.

References shark::blas::noalias(), and shark::blas::row().

template<class Reference , class Get >

void shark::detail::swap	(	FusionVectorBatchReference< Reference, Get >	ref1,
		FusionVectorBatchReference< Reference, Get >	ref2
	)

Definition at line 73 of file MKLBatchInterface.h.

References shark::swap().

template<class M , class V >

void shark::detail::swap	(	MatrixRowReference< M, V >	ref1,
		MatrixRowReference< M, V >	ref2
	)

Definition at line 138 of file BatchInterface.h.

Referenced by createCVSameSizeBalanced().

double shark::detail::updateLogPartition	(	double	logZn,
		double	E
	)

inline

updates the log partition with the Energy of another state

Calculating the partition fucntion itself is not easy. Aside from the computational complexity, the partition can easily exceed the maximum value of double. So instead we want to calculate the log partition, which is computationally a bit more complex, but feasible. Let's assume we have n Energies E_1,..., E_n for which we allready computed the partial partition Z_n = exp(-E_1)+...exp(-E_n) given another Energy E we can update this Z_n to Z by Z = Z_n+exp(-E) = exp(-E)*(Z_n*exp(E)+1) and for the logarithmic result it holds: log Z = -E + log(1+exp( log(Z_n)+E))=-E +softPlus(log(Z_n)+E) or equivalently log Z = log(Z_n) + log(1+exp(-log(Z_n)-E)=-log(Z_n) +softPlus(-log(Z_n)-E) which is numerically stable to compute since softPlus(x)->x when x>>0 and softPlus(x)-> 0 when x<<0 however if these edge cases arise, the result will be in this case be max(log Z, -E) since the values are not comparable anymore on the scale of double.

Definition at line 53 of file analytics.h.

References shark::blas::max(), and shark::softPlus().

Referenced by logPartitionFunctionImplFactHidden(), and logPartitionFunctionImplFactVisible().

template<class Matrix >

void shark::detail::zero	(	blas::matrix_expression< Matrix > &	mat,
		boost::mpl::true_
	)

Definition at line 44 of file Tools.h.

Referenced by shark::choleskyDecomposition(), shark::decomposedGeneralInverse(), shark::eigensymm(), shark::RNNet::eval(), shark::RNNet::weightedParameterDerivative(), and shark::zero().

template<class Vector >

void shark::detail::zero	(	blas::vector_expression< Vector > &	vec,
		boost::mpl::true_
	)

Definition at line 58 of file Tools.h.

template<class Matrix >

void shark::detail::zero	(	blas::matrix_container< Matrix > &	mat,
		boost::mpl::false_
	)

Definition at line 70 of file Tools.h.

template<class Vector >

void shark::detail::zero	(	blas::vector_container< Vector > &	vec,
		boost::mpl::false_
	)

Definition at line 74 of file Tools.h.

template<class Matrix >

void shark::detail::zero	(	blas::matrix_expression< Matrix > &	mat,
		boost::mpl::false_
	)

Definition at line 80 of file Tools.h.

References shark::blas::noalias().

template<class Vector >

void shark::detail::zero	(	blas::vector_expression< Vector > &	vec,
		boost::mpl::false_
	)

Definition at line 85 of file Tools.h.

References shark::blas::noalias().

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation