Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
  AbstractModel | |
   eval | See |
| boost | |
| fusion | |
 detail | |
 sequence_copy | |
| serialization | |
 tracking_level< shark::TypedFlags< T > > | |
| tracking_level< std::vector< T > > | |
| range_mutable_iterator< shark::blas::matrix< T > > | |
| range_const_iterator< shark::blas::matrix< T > > | |
| range_mutable_iterator< shark::blas::compressed_matrix< T > > | |
| range_const_iterator< shark::blas::compressed_matrix< T > > | |
| range_mutable_iterator< shark::blas::matrix_container< M > > | |
| range_const_iterator< shark::blas::matrix_container< M > > | |
| range_mutable_iterator< shark::blas::matrix_expression< M > > | |
| range_const_iterator< shark::blas::matrix_expression< M > > | |
| range_mutable_iterator< shark::FixedDenseMatrixProxy< T > > | |
| range_const_iterator< shark::FixedDenseMatrixProxy< T > > | |
| General | |
| Internal | |
| json_spirit | |
| internal_ | |
| Error_position | |
| Semantic_actions | |
| Json_grammer | |
| definition | |
| Multi_pass_iters | |
| Stream_reader | |
| Stream_reader_thrower | |
| Null | |
| Value_impl | |
| Pair_impl | |
| Config_vector | |
| Config_map | |
| Generator | |
| shark | AbstractSingleObjectiveOptimizer |
| blas | |
| detail | |
| SquaredScalarDistance | |
| less_pair | |
| less_triple | |
| dimension | |
| dimension_properties | |
| dimension_properties< 1 > | |
| dimension_properties< 2 > | |
| nonassignable_ | |
| nonassignable | |
| noalias_proxy | |
| container_const_reference | Base class of all proxy classes that contain a (redirectable) reference to an immutable object |
| container_reference | Base class of all proxy classes that contain a (redirectable) reference to a mutable object |
| forward_iterator_base | Base class of all forward iterators |
| bidirectional_iterator_base | Base class of all bidirectional iterators |
| random_access_iterator_base | Base class of all random access iterators |
| reverse_iterator_base | Base class of all reverse iterators. (non-MSVC version) |
| reverse_iterator_base1 | 1st base class of all matrix reverse iterators. (non-MSVC version) |
| reverse_iterator_base2 | 2nd base class of all matrix reverse iterators. (non-MSVC version) |
| indexed_iterator | A class iboost::mplementing an indexed random access iterator |
| indexed_const_iterator | A class iboost::mplementing an indexed random access iterator |
| indexed_iterator2 | A class iboost::mplementing an indexed random access iterator of a matrix |
| indexed_iterator1 | A class iboost::mplementing an indexed random access iterator of a matrix |
| indexed_const_iterator2 | A class iboost::mplementing an indexed random access iterator of a matrix |
| indexed_const_iterator1 | A class iboost::mplementing an indexed random access iterator of a matrix |
| matrix_assign_traits | |
| matrix_assign_traits< dense_tag, COMPUTED, packed_random_access_iterator_tag, packed_random_access_iterator_tag > | |
| matrix_assign_traits< dense_tag, false, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_assign_traits< dense_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_assign_traits< dense_proxy_tag, COMPUTED, packed_random_access_iterator_tag, packed_random_access_iterator_tag > | |
| matrix_assign_traits< dense_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_assign_traits< packed_tag, false, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_assign_traits< packed_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_assign_traits< packed_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_assign_traits< sparse_tag, true, dense_random_access_iterator_tag, dense_random_access_iterator_tag > | |
| matrix_assign_traits< sparse_tag, true, packed_random_access_iterator_tag, packed_random_access_iterator_tag > | |
| matrix_assign_traits< sparse_tag, true, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_swap_traits | |
| matrix_swap_traits< dense_proxy_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| matrix_swap_traits< packed_proxy_tag, sparse_bidirectional_iterator_tag, sparse_bidirectional_iterator_tag > | |
| vector_temporary_traits | For the creation of temporary vectors in the assignment of proxies |
| matrix_temporary_traits | For the creation of temporary vectors in the assignment of proxies |
| vector_assign_traits | |
| vector_assign_traits< dense_tag, COMPUTED, packed_random_access_iterator_tag > | |
| vector_assign_traits< dense_tag, false, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< dense_tag, true, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< dense_proxy_tag, COMPUTED, packed_random_access_iterator_tag > | |
| vector_assign_traits< dense_proxy_tag, false, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< dense_proxy_tag, true, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< packed_tag, false, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< packed_tag, true, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< packed_proxy_tag, COMPUTED, sparse_bidirectional_iterator_tag > | |
| vector_assign_traits< sparse_tag, true, dense_random_access_iterator_tag > | |
| vector_assign_traits< sparse_tag, true, packed_random_access_iterator_tag > | |
| vector_assign_traits< sparse_tag, true, sparse_bidirectional_iterator_tag > | |
| vector_swap_traits | |
| vector_swap_traits< dense_proxy_tag, sparse_bidirectional_iterator_tag > | |
| vector_swap_traits< packed_proxy_tag, sparse_bidirectional_iterator_tag > | |
| divide_by_zero | Exception raised when a division by zero occurs |
| internal_logic | Expception raised when some interal errors occurs like computations errors, zeros values where you should not have zeros, etc.. |
| external_logic | |
| bad_argument | |
| bad_size | |
| bad_index | |
| singular | |
| non_real | |
| vector_expression | Base class for Vector Expression models |
| vector_container | Base class for Vector container models |
| matrix_expression | Base class for Matrix Expression models |
| matrix_container | Base class for Matrix container models |
| scalar_identity | |
| scalar_negate | |
| scalar_divide | |
| scalar_multiply1 | |
| scalar_multiply2 | |
| scalar_conj | |
| scalar_conj< std::complex< T > > | |
| scalar_real | |
| scalar_real< std::complex< T > > | |
| scalar_imag | |
| scalar_imag< std::complex< T > > | |
| scalar_abs | |
| scalar_sqr | |
| scalar_sqrt | |
| scalar_abs_sqr | |
| scalar_abs_sqr< std::complex< T > > | |
| scalar_exp | |
| scalar_log | |
| scalar_pow | |
| scalar_tanh | |
| scalar_soft_plus | |
| scalar_sigmoid | |
| scalar_binary_plus | |
| scalar_binary_minus | |
| scalar_binary_multiply | |
| scalar_binary_divide | |
| scalar_binary_safe_divide | |
| scalar_binary_min | |
| scalar_binary_max | |
| scalar_binary_assign_functor | |
| assign_tag | |
| computed_assign_tag | |
| scalar_assign | |
| rebind | |
| scalar_plus_assign | |
| rebind | |
| scalar_minus_assign | |
| rebind | |
| scalar_multiplies_assign | |
| rebind | |
| scalar_divides_assign | |
| rebind | |
| scalar_swap | |
| rebind | |
| vector_fold | |
| vector_inner_prod | |
| matrix_vector_binary_functor | |
| matrix_vector_prod1 | |
| matrix_vector_prod2 | |
| matrix_matrix_binary_functor | |
| matrix_matrix_prod | |
| matrix_scalar_real_unary_functor | |
| matrix_norm_1 | |
| matrix_norm_frobenius | |
| matrix_norm_inf | |
| basic_column_major | |
| basic_row_major | |
| basic_full | |
| unbounded_array | |
| basic_range | |
| const_iterator | |
| vector_reference | |
| matrix_reference | |
| vector_range | A vector referencing a continuous subvector of elements of vector v containing all elements specified by range |
| const_iterator | |
| iterator | |
| matrix_row | Matrox transpose |
| const_iterator | |
| iterator | |
| matrix_column | |
| const_iterator | |
| iterator | |
| matrix_vector_range | |
| const_iterator | |
| iterator | |
| matrix_range | |
| const_iterator1 | |
| const_iterator2 | |
| iterator1 | |
| iterator2 | |
| vector | A dense vector of values of type T |
| compressed_vector | Compressed array based sparse vector |
| const_iterator | |
| iterator | |
| unknown_orientation_tag | |
| row_major_tag | |
| column_major_tag | |
| matrix | A dense matrix of values of type T |
| lower_tag | |
| upper_tag | |
| unit_lower_tag | |
| unit_upper_tag | |
| strict_lower_tag | |
| strict_upper_tag | |
| compressed_matrix | |
| const_iterator1 | |
| const_iterator2 | |
| iterator1 | |
| iterator2 | |
| permutation_matrix | |
| diagonal_matrix | An diagonal matrix with values stored inside a diagonal vector |
| const_iterator1 | |
| const_iterator2 | |
| identity_matrix | An identity matrix with values of type T |
| scalar_matrix | A matrix with all values of type T equal to the same value |
| zero_matrix | A matrix with all values of type T equal to zero |
| vector_matrix_binary | |
| const_iterator1 | |
| const_iterator2 | |
| vector_matrix_binary_traits | |
| matrix_unary1 | Class which allows for matrix transformations |
| const_iterator1 | |
| const_iterator2 | |
| matrix_unary2 | |
| const_iterator1 | |
| const_iterator2 | |
| matrix_unary2_traits | |
| matrix_transpose | |
| matrix_binary | |
| const_iterator1 | |
| const_iterator2 | |
| matrix_vector_binary1 | |
| matrix_vector_binary1_traits | |
| matrix_vector_binary2 | |
| const_iterator | |
| matrix_vector_binary2_traits | |
| matrix_matrix_binary | |
| const_iterator1 | |
| const_iterator2 | |
| matrix_matrix_binary_traits | |
| vector_temporary_traits< matrix_row< M > > | |
| vector_temporary_traits< const matrix_row< M > > | |
| vector_temporary_traits< matrix_column< M > > | |
| vector_temporary_traits< const matrix_column< M > > | |
| vector_temporary_traits< matrix_vector_range< M > > | |
| vector_temporary_traits< const matrix_vector_range< M > > | |
| matrix_temporary_traits< matrix_range< M > > | |
| matrix_temporary_traits< const matrix_range< M > > | |
| vector_temporary_traits< matrix_range< M > > | |
| vector_temporary_traits< const matrix_range< M > > | |
| promote_traits | |
| real_traits | |
| real_traits< std::complex< T > > | |
| unknown_storage_tag | |
| sparse_proxy_tag | |
| sparse_tag | |
| packed_proxy_tag | |
| packed_tag | |
| dense_proxy_tag | |
| dense_tag | |
| storage_restrict_traits | |
| storage_restrict_traits< sparse_tag, dense_proxy_tag > | |
| storage_restrict_traits< sparse_tag, packed_proxy_tag > | |
| storage_restrict_traits< sparse_tag, sparse_proxy_tag > | |
| storage_restrict_traits< packed_tag, dense_proxy_tag > | |
| storage_restrict_traits< packed_tag, packed_proxy_tag > | |
| storage_restrict_traits< packed_tag, sparse_proxy_tag > | |
| storage_restrict_traits< packed_proxy_tag, sparse_proxy_tag > | |
| storage_restrict_traits< dense_tag, dense_proxy_tag > | |
| storage_restrict_traits< dense_tag, packed_proxy_tag > | |
| storage_restrict_traits< dense_tag, sparse_proxy_tag > | |
| storage_restrict_traits< dense_proxy_tag, packed_proxy_tag > | |
| storage_restrict_traits< dense_proxy_tag, sparse_proxy_tag > | |
| sparse_bidirectional_iterator_tag | |
| packed_random_access_iterator_tag | |
| dense_random_access_iterator_tag | |
| iterator_base_traits | |
| iterator_base_traits< std::forward_iterator_tag > | |
| iterator_base | |
| iterator_base_traits< std::bidirectional_iterator_tag > | |
| iterator_base | |
| iterator_base_traits< sparse_bidirectional_iterator_tag > | |
| iterator_base | |
| iterator_base_traits< std::random_access_iterator_tag > | |
| iterator_base | |
| iterator_base_traits< packed_random_access_iterator_tag > | |
| iterator_base | |
| iterator_base_traits< dense_random_access_iterator_tag > | |
| iterator_base | |
| iterator_restrict_traits | |
| iterator_restrict_traits< packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag > | |
| iterator_restrict_traits< sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag > | |
| iterator_restrict_traits< dense_random_access_iterator_tag, sparse_bidirectional_iterator_tag > | |
| iterator_restrict_traits< sparse_bidirectional_iterator_tag, dense_random_access_iterator_tag > | |
| iterator_restrict_traits< dense_random_access_iterator_tag, packed_random_access_iterator_tag > | |
| iterator_restrict_traits< packed_random_access_iterator_tag, dense_random_access_iterator_tag > | |
| scalar_vector | A scalar (i.e. unique value) vector of type T and a given size A scalar (i.e. unique value) vector of type T and a given size. This is a virtual vector in the sense that no memory is allocated for storing the unique value more than once: it still acts like any other vector. However assigning a new value will change all the value at once. vector into a normal vector. It must first be assigned to another normal vector by any suitable means. Its memory footprint is constant |
| zero_vector | A zero vector of type T and a given size A zero vector of type T and a given size. This is a special case of the scalar vector for constant zero value |
| vector_unary | Class which allows for vector transformations |
| vector_binary | |
| const_iterator | |
| vector_temporary_traits< vector_range< V > > | |
| vector_temporary_traits< const vector_range< V > > | |
| cma | |
| Chromosome | Chromosome of the CMA-ES |
| Initializer | Initializer for chromosomes/individuals of the CMA-ES |
| Variator | Implements the mutation operator of the (MO)-CMA |
| cmsa | |
| Chromosome | Chromosome of the CMSA-ES |
| detail | |
| age | |
| age2 | |
| bindings | |
| storage_order | |
| storage_order< blas::row_major_tag > | |
| storage_order< blas::column_major_tag > | |
| uplo_triang | |
| uplo_triang< blas::upper_tag > | |
| uplo_triang< blas::lower_tag > | |
| TriangularTag | |
| TriangularTag< true, false, true > | |
| TriangularTag< false, true, true > | |
| TriangularTag< false, false, true > | |
| TriangularTag< upper, unit, false > | |
| nsga2 | |
| smsemoa | |
| steady_state_mocma | |
| AGE | Implements the AGE |
| AGE2 | Implements the AGE2 |
| MOCMA | Implements the generational MO-CMA-ES |
| PAES | Implements the Pareto-archived evolutionary strategy |
| RealCodedNSGAII | Implements the NSGA-II |
| SMSEMOA | Implements the SMS-EMOA |
| SteadyStateMOCMA | Implements the \((\mu+1)\)-MO-CMA-ES |
| unused | Models an empty chromosome type |
| PlainTextPrintfFormatProvider | Implements a printf-like format for plain text log stores |
| XmlPrintfFormatProvider | Implements a printf-like format for XML log stores |
| JsonPrintfFormatProvider | Implements a printf-like format for JSON log stores |
| SequenceOfSequenceIteratorTraits | Helper class of the MultiSequenceIterator, which querys everything needed to deduce the right iterator_facade |
| DefaultBatch | Default implementation of the Batch which maps it's type on std::vector<T> |
| ArithmeticBatch | Default implementation of the Batch for arithmetic types, which are mapped on shark::blas::vector<T> |
| MatrixRowReference | Wrapper for a matrix row, which offers a conversion operator to to the Vector Type |
| ItemSerializer | Serializes the object into the archive |
| CreateBatch | |
| result | |
| result< CreateBatch(T const &)> | |
| resize | |
| MakeRef | Calls get(container,index) on a container. Used as boost fusion functor in the creation of references in the Batch Interface |
| result | |
| result< MakeRef(T const &)> | |
| MakeConstRef | Calls get(container,index) on a container. Used as boost fusion functor in the cration of references in the Batch Interface |
| result | |
| result< MakeConstRef(T const &)> | |
| FusionFacade | |
| isFusionFacade | |
| SharedContainer | Shared memory container class with slicing |
| ElementSort | |
| TransformOneVersusRestLabels | |
| TransformedDataElementTypeFromBatch | |
| TransformedDataElement | For Data<T> and functor F calculates the result of the resulting elements F(T) |
| FusionVectorBatchReference | |
| ADLVector | Wrapper to enable argument dependent lookup for ublas vectors in shark namespace |
| Scalar | Wrapper representing a single arithmetic value |
| InitializerBase | Expression template as base class for all initializer expressions |
| VectorExpression | Wrapper for all kinds of vectorexpression which saves the (sparse) vector in the target vector |
| MatrixExpression | Wrapper for all kinds of matrix expressions which saves the (sparse) matrix row by row in the target vector |
| ParameterizableExpression | Wrapps a parametrizable Object so that it can be used to initialize or split a vector |
| ParameterizableExpression< T * > | Wrapps a pointer to a parametrizable Object so that it can be used to initialize or split a vector |
| ParameterizableExpression< T *const > | |
| InitializerRange | Wrapper representing a range of vectors or matrices like std::vector<RealVector> or std::list<SparseRealMatrix> |
| InitializerEnd | Marks the end of the initializer list template |
| InitializerNode | The InitializerNode can initialize a vector on the basis of multiple vector or scalar expressions |
| VectorInitializer | VectorInitializer takes a Vector and an initialization expression to initialize the vector during destruction |
| VectorSplitter | VectorSplitter takes a Vector and a mutable initialization expression to split the vector during destruction |
| ConcatenatedModelWrapperBase | Baseclass for the wrapper which is used to hide the matrix type |
| ConcatenatedModelWrapper | Internal Wrappertype to connect the output of the first model with the input of the second model |
| InternalState | |
| ConcatenatedModelList | When using operator>> to connect more than two models, this type is created |
| LinearModelWrapperBase | Baseclass of LinearModelWrapper. This class is needed for the type erasure in LinearModel |
| LinearModelWrapper | Implementation of the Linear Model for specific matrix types |
| NeuronBase | Baseclass for all Neurons. it defines y=operator(x) for evaluation and derivative(y) for the derivative of the sigmoid |
| MklKernelWrapper | Given a tuple of Inputs (a_1,...a_n) calculates the kernel k(a_N,a_N) for some chosen N |
| MklKernelBase | |
| 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)) |
| SubrangeKernelBase | |
| ErrorFunctionWrapper | |
| CostBasedErrorFunctionImpl | Implementation of the Error Function using AbstractCost |
| LossBasedErrorFunctionImpl | Implementation of the ErrorFunction using AbstractLoss |
| ParallelLossBasedErrorFunctionImpl | Implementation of the ErrorFunction using AbstractLoss for parallelizable computations |
| FunctionWrapperBase | Base class for implementations of the Error Function |
| NoisyErrorFunctionWrapper | Implementation for the NoisyErrorFunction. It hides the Type of the OutputType |
| SparseFFNetErrorWrapper | Implementation of the SparseFFNetError |
| NoisyErrorFunctionWrapperBase | Baseclass for the Typewrapper of the Noisy Error Function |
| TypedMultiVariateNormalDistribution | Implements a multi-variate normal distribution with zero mean |
| BinarySufficientStatistics | |
| GaussianSufficientStatistics | |
| TruncatedExponentialSufficientStatistics | |
| GibbsSample | Represents a single sample of the GibbsOperator |
| MarkovChainSample | |
| elitist_cma | |
| Chromosome | Models a chromosome of the elitist (MO-)CMA-ES that encodes strategy parameters |
| Initializer | Initialization operator that initializes individuals and their chromosomes, respectively |
| Updater | Strategy parameter update that implements the strategy parameter update procedure of the \((\mu+1)\)-MO-CMA-ES |
| example | |
| Chromosome | |
| glpk | |
| mocma | |
| moo | |
| Experiment | Single-objective and multi-objective experiments for evolutionary algorithms |
| Options | Options specialization for multi-objective experiments |
| InterruptibleAlgorithmRunner | Executes one trial of a multi-objective optimizer for a given multi-objective fitness function |
| ResultMetaData | Metadata describing actual result data |
| PenalizingEvaluator | Penalizing evaluator for vector-valued objective functions |
| one_plus_one_es | |
| soo | |
| Experiment | Single-objective and multi-objective experiments for evolutionary algorithms |
| FitnessExtractor | Default fitness extractor |
| InterruptibleAlgorithmRunner | Executes one trial of a single-objective optimizer for a given single-objective fitness function |
| ResultMetaData | Metadata describing actual result data |
| PenalizingEvaluator | Penalizing evaluator for scalar objective functions |
| tag | |
| PenalizedFitness | Marks penalized fitness values |
| UnpenalizedFitness | Marks unpenalized fitness values |
| ScaledFitness | Marks scaled fitness values |
| MatingProbability | Marks the mating probability of an individual |
| SelectionProbability | Marks the selection probability of an individual |
| JSONFormat | |
| RawTextFormat | |
| MuKommaLambda | Tags the selection scheme |
| MuPlusLambda | |
| Unary | Tags a unary quality indicator |
| Binary | Tags a binary quality indicator |
| FirstXAxis | Tags the first (left) x-axis of a chart |
| SecondXAxis | Tags the second (right) x-axis of a chart |
| FirstYAxis | Tags the first (bottom) y-axis of a chart |
| SecondYAxis | Tags the second (top) y-axis of a chart |
| cout | Tags the std::cout stream |
| clog | Tags the std::clog stream |
| cerr | Tags the std::cerr stream |
| BuildTypeTag | Tags the build type |
| OpenMpTag | Tags whether OpenMP has been enabled |
| OfficialReleaseTag | Tags official releases of the shark library |
| Input | Tags an input variable to a fuzzy control system |
| Output | Tags an output variable to a fuzzy control system |
| tags | Tags are empty types which can be used as a function argument |
| DiscreteSpace | A Tag for EnumerationSpaces. It tells the Functions, that the space is discrete and can be enumerated |
| RealSpace | A Tag for EnumerationSpaces. It tells the Functions, that the space is real and can't be enumerated |
| test | |
| traits | |
| ExpressionTraitsBase< FixedDenseVectorProxy< T > > | |
| ExpressionTraitsBase< FixedDenseVectorProxy< T > const > | |
| ExpressionTraitsBase< blas::matrix< T, blas::row_major, A > > | |
| ExpressionTraitsBase< blas::matrix< T, blas::row_major, A > const > | |
| ExpressionTraitsBase< blas::matrix< T, blas::column_major, A > > | |
| ExpressionTraitsBase< blas::matrix< T, blas::column_major, A > const > | |
| UnknownStorage | |
| CompressedStorage | |
| DenseStorage | |
| CompressedVectorStorage | |
| CompressedMatrixStorage | |
| ExpressionTraitsBase | |
| DenseTraitsImpl | |
| CompressedTraitsImpl | |
| DenseTraits | |
| CompressedTraits | |
| ExpressionTraitsBase< blas::vector_expression< V > > | |
| ExpressionTraitsBase< blas::vector_expression< V > const > | |
| ExpressionTraitsBase< blas::vector< T, A > > | |
| ExpressionTraitsBase< blas::vector< T, A > const > | |
| Oracle | Abstract base class for oracles |
| OracleOfDelphi | Implements the oracle of Delphi |
| HitchhikersGuideToTheGalaxy | Implements the oracle interface in terms of the answers given by the Hitchhiker's Guide to the Galaxy |
| AbstractMultiObjectiveOptimizer | Base class for abstract multi-objective optimizers for arbitrary search spaces |
| TypeErasedMultiObjectiveOptimizer | Type erasure to integrate Optimizer adhering to the concept of a multi-objective optimizer with the inheritance hierarchy of AbstractOptimizer |
| OptimizerTraits< TypeErasedMultiObjectiveOptimizer< S, O > > | Implements OptimizerTraits for a type erase MOO |
| AbstractOptimizer | An optimizer that optimizes general objective functions |
| AbstractSingleObjectiveOptimizer | Base class for all single objective optimizer |
| OptimizerTraits< detail::AGE > | AGE specialization of optimizer traits |
| OptimizerTraits< detail::AGE2 > | AGE specialization of optimizer traits |
| BoundingBoxCalculator | Calculates the bounding of a d-dimensional point set |
| CMA | Implements the CMA-ES |
| CMSA | Implements the CMSA |
| ElitistCMA | Implements the elitist CMA-ES |
| EvaluationCountStoppingCondition | Maximum number of evaluations stoppping condition |
| ExperimentBase | Single-objective and multi-objective experiments for evolutionary algorithms |
| Options | Collection of an extensible set of options for a multi-objective experiment |
| FrontStore | A store for Pareto-front approximations, for usage with class InterruptibleAlgorithmRunner |
| BaseFastNonDominatedSort | Implements the well-known non-dominated sorting algorithm |
| FitnessComparator | Fitness comparator for the single-objective case |
| IndirectFitnessComparator | Indirect (pointer,iterator) fitness comparator for the single-objective case |
| IdentityFitnessExtractor | Functor that returns its argument without conversion |
| FitnessExtractor | Default fitness extractor |
| CastingFitnessExtractor | Casting fitness extractor |
| GridSearch | Optimize by trying out a grid of configurations |
| NestedGridSearch | Nested grid search |
| PointSearch | Optimize by trying out predefined configurations |
| HypervolumeApproximator | Implements an FPRAS for approximating the volume of a set of high-dimensional objects |
| HypervolumeCalculator | Implementation of the exact hypervolume calculation in m dimensions |
| HypervolumeIndicator | Calculates the hypervolume covered by a set of non-dominated points |
| AdditiveEpsilonIndicator | Given a reference front R and an approximation F, calculates the additive approximation quality of F |
| LocalitySensitiveAdditiveEpsilonIndicator | Binary performance indicator inspired by AGE-I |
| InvertedGenerationalDistance | Inverted generational distance for comparing Pareto-front approximations |
| MultiplicativeEpsilonIndicator | Given a reference front R and an approximation F, calculates the multiplicative approximation quality of F |
| Sampler | Samples a random point |
| BoundingBoxComputer | Calculates bounding boxes |
| VolumeComparator | Compares points based on their contributed volume |
| LeastContributorApproximator | Approximately determines the point of a set contributing the least hypervolume |
| IdentityFitnessExtractor | Returns the supplied argument |
| Point | Models a point and associated information for book-keeping purposes |
| OptimizerTraits< detail::MOCMA< Indicator > > | \((\mu+1)\)-MO-CMA-ES specialization of optimizer traits |
| OnePlusOneES | Implements the (1+1)-ES |
| BitflipMutator | Bitflip mutation operator |
| PolynomialMutator | Polynomial mutation operator |
| GlobalIntermediateRecombination | Recombinates a set of individuals given a weight vector |
| TypedOnePointCrossover | Implements one-point crossover |
| SimulatedBinaryCrossover | Simulated binary crossover operator |
| UniformCrossover | Uniform crossover of arbitrary individuals |
| ApproximatedHypervolumeSelection | Implements an approximated hypervolume selection scheme |
| BinaryTournamentSelection | Implements binary tournament selection with a user-selectable predicate |
| EPTournamentSelection | Selects individuals from the range of parent and offspring individuals |
| IndicatorBasedSelection | Implements the well-known indicator-based selection strategy |
| MaxShareOperator | Assigns the maximum share to every member of the population |
| MinShareOperator | Assigns the minimum share to every member of the population |
| LinearRankingSelection | Implements a fitness-proportional selection scheme that scales the fitness values linearly before carrying out the actual selection |
| RouletteWheelSelection | Fitness-proportional selection operator |
| SteadyStateIndicatorBasedSelection | Steady state (+1) Indicator-based selection strategy for multi-objective selection |
| MaxShareOperator | Assigns the maximum share to every member of the population |
| TournamentSelection | Tournament selection operator |
| UniformRankingSelection | Selects individuals from the range of parent and offspring individuals |
| ParetoDominanceComparator | Implementation of the Pareto-Dominance relation under the assumption of all objectives to be minimized |
| RankShareComparator | Compares two individuals w.r.t. their level of non-dominance and w.r.t. the share they contribute to the front both of them belong to |
| OptimizerTraits< detail::RealCodedNSGAII<> > | NSGA-II specialization of optimizer traits |
| OptimizerTraits< detail::SMSEMOA > | SMS-EMOA specialization of optimizer traits |
| OptimizerTraits< detail::SteadyStateMOCMA< Indicator > > | \((\mu+1)\)-MO-CMA-ES specialization of optimizer traits |
| FitnessTraits | Abstracts extraction of fitness values from individuals |
| QualityIndicatorTraits | Abstracts common properties of unary and binary quality indicators |
| ChromosomeIndex | Explicitly wraps up a chromosome index |
| TypedIndividual | TypedIndividual is a templated class modelling an individual that acts as a candidate solution in an evolutionary algorithm |
| FitnessTraits< TypedIndividual< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > > | Allows for extracting the penalized and unpenalized fitness of arbitrary TypedIndividuals based on fitness traits |
| BFGS | Broyden, Fletcher, Goldfarb, Shannon algorithm for unconstraint optimization |
| CG | Conjugate-gradient method for unconstraint optimization |
| ObjectiveFunctionDerivativeWrapper | A wrapper which wraps the evaluation of a model, given a set of parameters It can be used as glue to use errorfunctions together with the linesearch algorithms of LinAlg |
| IRLS | Iterated Reweightes Least Squares iteratively calculates a newton step and then performs a line search in that direction |
| LBFGS | Limited-Memory Broyden, Fletcher, Goldfarb, Shannon algorithm for unconstrained optimization |
| LineSearch | Wrapper for the linesearch class of functions in the linear algebra library |
| NoisyRprop | Rprop-like algorithm for noisy function evaluations |
| Quickprop | This class offers methods for using the popular heuristic "Quickprop" optimization algorithm |
| QuickpropOriginal | This class offers methods for using the popular heuristic "Quickprop" optimization algorithm |
| RpropMinus | This class offers methods for the usage of the Resilient-Backpropagation-algorithm without weight-backtracking |
| RpropPlus | This class offers methods for the usage of the Resilient-Backpropagation-algorithm with weight-backtracking |
| IRpropPlus | This class offers methods for the usage of the improved Resilient-Backpropagation-algorithm with weight-backtracking |
| IRpropMinus | This class offers methods for the usage of the improved Resilient-Backpropagation-algorithm without weight-backtracking |
| SteepestDescent | Standard steepest descent |
| JaakkolaHeuristic | Jaakkola's heuristic and related quantities for Gaussian kernel selection |
| LP | Linear Program Solver |
| AbstractNearestNeighbors | Interface for Narest Neighbor queries |
| SimpleNearestNeighbors | Brute force optimized nearest neighbor implementation |
| IterativeNNQuery | Iterative nearest neighbors query |
| TreeNearestNeighbors | Nearest Neighbors implementation using binary trees |
| Pegasos | Pegasos solver for linear (binary) support vector machines |
| McPegasos | Pegasos solver for linear multi-class support vector machines |
| MaximumGradientCriterion | Working set selection by maximization of the projected gradient |
| MaximumGainCriterion | Working set selection by maximization of the dual objective gain |
| BoxConstrainedProblem | Quadratic program with box constraints |
| BoxConstrainedShrinkingProblem | Same as BoxConstrainedProblem, but including a shrinking heuristic |
| LRUCache | Implements an LRU-Caching Strategy for arbitrary Cache-Lines |
| QpBoxLinear | Quadratic program solver for box-constrained problems with linear kernel |
| SparseVector | Data structure for sparse vectors |
| QpMcDecomp | Quadratic program solver for multi class SVM problems |
| tExample | Data structure describing one training example |
| tVariable | Data structure describing one variable of the problem |
| QpMcLinear | Generic solver skeleton for linear multi-class SVM problems |
| SparseVector | Data structure for sparse vectors |
| QpMcLinearWW | Solver for the multi-class SVM by Weston & Watkins |
| QpMcLinearLLW | Solver for the multi-class SVM by Lee, Lin & Wahba |
| QpMcLinearATS | Solver for the multi-class SVM with absolute margin and total sum loss |
| QpMcLinearMMR | Solver for the multi-class maximum margin regression SVM |
| QpMcLinearCS | Solver for the multi-class SVM by Crammer & Singer |
| QpMcLinearADM | Solver for the multi-class SVM with absolute margin and discriminative maximum loss |
| QpMcLinearATM | Solver for the multi-class SVM with absolute margin and total maximum loss |
| GeneralQuadraticProblem | Most gneral problem formualtion, needs to be configured by hand |
| BoxedSVMProblem | Boxed problem for alpha in [lower,upper]^n and equality constraints |
| CSVMProblem | Problem formulation for binary C-SVM problems |
| BaseShrinkingProblem | |
| QpSolver | Quadratic program solver |
| QpSparseArray | Specialized container class for multi-class SVM problems |
| Entry | Non-default (non-zero) array entry |
| Row | Data structure describing a row of the sparse array |
| QpStoppingCondition | Stopping conditions for quadratic programming |
| QpSolutionProperties | Properties of the solution of a quadratic program |
| KernelMatrix | Kernel Gram matrix |
| KernelMatrix< blas::compressed_vector< T >, CacheType > | Specialization for sparse vectors which don't have a super ffective lookup |
| RegularizedKernelMatrix | Kernel Gram matrix with modified diagonal |
| ModifiedKernelMatrix | Modified Kernel Gram matrix |
| BlockMatrix2x2 | SVM regression matrix |
| CachedMatrix | Efficient quadratic matrix cache |
| PrecomputedMatrix | Precomputed version of a matrix for quadratic programming |
| ExampleModifiedKernelMatrix | |
| MVPSelectionCriterion | |
| LibSVMSelectionCriterion | |
| HMGSelectionCriterion | |
| SvmProblem | |
| SvmShrinkingProblem | |
| AbstractStoppingCriterion | Base class for stopping criteria of optimization algorithms |
| GeneralizationLoss | The generalization loss calculates the relative increase of the validation error compared to the minimum training error |
| GeneralizationQuotient | SStopping criterion monitoring the quotient of generalization loss and training progress |
| MaxIterations | This stopping criterion stops after a fixed number of iterations |
| TrainingError | This stopping criterion tracks the improvement of the error function of the training error over an interval of iterations |
| TrainingProgress | This stopping criterion tracks the improvement of the training error over an interval of iterations |
| ValidatedStoppingCriterion | Given the current Result set of the optimizer, calculates the validation error using a validation function and hands the results over to the underlying stopping criterion |
| QpConfig | Super class of all support vector machine trainers |
| AbstractSvmTrainer | Super class of all kernelized (non-linear) SVM trainers |
| AbstractLinearSvmTrainer | Super class of all linear SVM trainers |
| AbstractTrainer | Superclass of supervised learning algorithms |
| AbstractUnsupervisedTrainer | Superclass of unsupervised learning algorithms |
| CARTTrainer | Classification And Regression Trees CART |
| TableEntry | Types frequently used |
| CSvmTrainer | Training of C-SVMs for binary classification |
| LinearCSvmTrainer | |
| DistTrainerContainer | Container for known distribution trainers |
| GenericDistTrainer | |
| NormalTrainer | Trainer for normal distribution |
| EpsilonSvmTrainer | Training of Epsilon-SVMs for regression |
| FisherLDA | Fisher's Linear Discriminant Analysis for data compression |
| KernelMeanClassifier | Kernelized mean-classifier |
| LassoRegression | LASSO Regression |
| Entry | Sparse vector entry |
| LDA | Linear Discriminant Analysis (LDA) |
| LinearRegression | Linear Regression |
| McSvmADMTrainer | Training of ADM-SVMs for multi-category classification |
| LinearMcSvmADMTrainer | |
| McSvmATMTrainer | Training of ATM-SVMs for multi-category classification |
| LinearMcSvmATMTrainer | |
| McSvmATSTrainer | Training of ATS-SVMs for multi-category classification |
| LinearMcSvmATSTrainer | |
| McSvmCSTrainer | Training of the multi-category SVM by Crammer and Singer (CS) |
| LinearMcSvmCSTrainer | |
| McSvmLLWTrainer | Training of the multi-category SVM by Lee, Lin and Wahba (LLW) |
| LinearMcSvmLLWTrainer | |
| McSvmMMRTrainer | Training of the maximum margin regression (MMR) multi-category SVM |
| LinearMcSvmMMRTrainer | |
| McSvmOVATrainer | Training of a multi-category SVM by the one-versus-all (OVA) method |
| LinearMcSvmOVATrainer | |
| McSvmWWTrainer | Training of the multi-category SVM by Weston and Watkins (WW) |
| LinearMcSvmWWTrainer | |
| MissingFeatureSvmTrainer | Trainer for binary SVMs natively supporting missing features |
| NBClassifierTrainer | Trainer for naive Bayes classifier |
| NormalizeComponentsUnitInterval | Train a model to normalize the components of a dataset to fit into the unit inverval |
| NormalizeComponentsUnitVariance | Train a linear model to normalize the components of a dataset to unit variance, and optionally to zero mean |
| NormalizeComponentsWhitening | Train a linear model to whiten the data |
| NormalizeKernelUnitVariance | Determine the scaling factor of a ScaledKernel so that it has unit variance in feature space one on a given dataset |
| OneClassSvmTrainer | Training of one-class SVMs |
| OptimizationTrainer | Wrapper for training schemes based on (iterative) optimization |
| PCA | Principal Component Analysis |
| Perceptron | Perceptron online learning algorithm |
| RegularizationNetworkTrainer | Training of a regularization network |
| RFTrainer | Random Forest |
| SigmoidFitRpropNLL | Optimizes the parameters of a sigmoid to fit a validation dataset via backpropagation on the negative log-likelihood |
| SigmoidFitPlatt | Optimizes the parameters of a sigmoid to fit a validation dataset via Platt's method |
| AbstractFeasibleRegion | Models a feasible region |
| Chart | Models an abstract chart |
| Axis | Models an axis and its attributes like its title and its scale |
| Series | Models a series and its underlying data |
| Title | Models the title of a chart |
| TypedFirstOrderDerivative | Encapsulation of the first order derivative information, consisting of the gradient only |
| TypedSecondOrderDerivative | Encapsulation of the second order derivative information, consisting of the gradient and the Hessian |
| Exception | Top-level exception class of the shark library |
| Factory | Implements the factory pattern |
| AbstractFactory | Explicit interface for a factory |
| FactoryRegisterer | Helper structure to allow for automatic registration of types with the factory modelled by the template parameter |
| TypeErasedAbstractFactory | Type erase to ease implementing factories for custom types |
| TypedFlags | Flexible and extensible mechanisms for holding flags |
| TypedFeatureNotAvailableException | Exception indicating the attempt to use a feature which is not supported |
| IConfigurable | Interface that abstracts a configurable component |
| INameable | This class is an interface for all objects which can have a name |
| IParameterizable | Top level interface for everything that holds parameters |
| ISerializable | Abstracts serializing functionality |
| PrintfLogFormatter | A log formatter that relies on externally defined printf-like formats |
| Logger | Implements a generic logging facility |
| AbstractFormatter | Entrypoint for extending the logging framework with custom format handlers |
| AbstractHandler | Entrypoint for extending the logging framework with custom log handlers |
| Record | Models a single log record passed to the logging framework |
| LoggerPool | Singleton that manages named loggers |
| StreamHandlerBase | Implements a generic log handler for arbitrary streams |
| ConsoleHandler | Defines a console handler based on tag dispatching |
| ConsoleHandler< tag::cout > | Template specialization for std::cout |
| ConsoleHandler< tag::clog > | Template specialization for std::clog |
| ConsoleHandler< tag::cerr > | Template specialization for std::cerr |
| HighchartRenderer | Models a renderer that renders charts using the Highcharts JS API (see http://www.highcharts.com) |
| BadStreamException | Thrown if the supplied stream is bad |
| ResultSet | |
| SingleObjectiveResultSet | Result set for single objective algorithm |
| ValidatedSingleObjectiveResultSet | Result set for validated points |
| VectorSpace | Models the concept of a vector space over |
| SharedVector | Vector container prepared for data sharing |
| Shark | Allows for querying compile settings at runtime. Provides the current command line arguments to the rest of the library |
| Version | Models a version according to the major.minor.patch versioning scheme |
| SignalTrap | Class that interferes with signals and allows for a graceful shutdown |
| Singleton | Models a singleton, i.e., enforces a single instance of a class |
| State | Represents the State of an Object |
| EmptyState | Default State of an Object which does not need a State |
| Timer | Timer abstraction with microsecond resolution/// |
| IsVector | IsVector is a traits class evaluating to true if T implements the rquirements of a vector |
| IsVector< blas::vector< T > > | |
| IsVector< blas::compressed_vector< T > > | |
| IsVector< blas::matrix< T > > | |
| IsVector< blas::compressed_matrix< T > > | |
| MultiObjectiveFunctionTraits | Abstract traits specific to a multi-objective function type that are not modeled in interface AbstractObjectiveFunction |
| OptimizerTraits | Abstract traits specific to an optimizer type that are not modeled in interface AbstractOptimizer |
| ConstProxyReference | Sets the type of ProxxyReference |
| ConstProxyReference< blas::vector< T > > | |
| ConstProxyReference< blas::vector< T > const > | |
| ConstProxyReference< blas::compressed_vector< T > > | |
| ConstProxyReference< blas::compressed_vector< T > const > | |
| ConstProxyReference< blas::matrix< T > > | |
| ConstProxyReference< blas::matrix< T > const > | |
| CanBeCalled | Detects whether Functor(Argument) can be called |
| CopyConst | If U is a const Type, than T is also made const |
| CopyConst< T, U const > | |
| IndexedIterator | Creates an Indexed Iterator, an Iterator which also carries index information using index() |
| ProxyIterator | Creates an iterator which reinterpretes an object as a range |
| MultiSequenceIterator | Iterator which iterates of the elements of a nested sequence |
| KeyValuePair | Represents a Key-Value-Pair similar std::pair which is strictly ordered by it's key |
| PairReference< KeyValuePair< Key, Value >, KeyIterator, ValueIterator > | Reference type used by zipKeyValuePair |
| KeyValueRange | |
| ScopedHandle | |
| PairReference | Given a type of pair and two iterators to zip together, returns the reference |
| PairReference< std::pair< T, U >, Iterator1, Iterator2 > | |
| PairIterator | A Pair-Iterator which gives a unified view of two ranges |
| PairRangeType | |
| Batch | Class which helps using different batch types |
| Batch< blas::vector< T > > | Specialization for ublas vectors which should be matrices in batch mode! |
| Batch< shark::blas::compressed_vector< T > > | Specialization for ublas compressed vectors which are compressed matrices in batch mode! |
| CVFolds | |
| DataDistribution | A DataDistribution defines an unsupervised learning problem |
| LabeledDataDistribution | A LabeledDataDistribution defines a supervised learning problem |
| Chessboard | "chess board" problem for binary classification |
| Wave | Noisy sinc function: y = sin(x) / x + noise |
| PamiToy | |
| CircleInSquare | |
| DiagonalWithCircle | |
| Data | Data container |
| UnlabeledData | Data set for unbase_typevised learning |
| LabeledData | Data set for base_typevised learning |
| TransformedData | |
| DataView | Constant time Element-Lookup for Datasets |
| DataPair | The type used to mimic a pair of data |
| PairReference< DataPair< I, L >, InputIterator, LabelIterator > | |
| DataBatchPair | The type used to mimic a pair of data batches |
| Batch< DataPair< InputType, LabelType > > | |
| PairReference< DataBatchPair< InputBatchType, LabelBatchType >, OuterInputBatchIterator, OuterLabelBatchIterator > | |
| Batch< boost::fusion::vector< BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)> > | Default implementation for boost::fusion::vector |
| ImageInformation | Stores name and size of image externally |
| CustomIM | An user defined inference machine |
| FuzzyControlLanguageParser | LL-Parser for the Fuzzy-Control-Language (see IEC 61131-7) |
| FuzzyRelation | A fuzzy relation |
| FuzzySet | Abstract super class for specific fuzzy sets |
| BellFS | FuzzySet with a bell-shaped (Gaussian) membership function |
| ComposedFS | A composed FuzzySet |
| ComposedNDimFS | A composed n-dimensional FuzzySet |
| ConstantFS | FuzzySet with constant membership function |
| CustomizedFS | A FuzzySet with an user defined mambership function |
| GeneralizedBellFS | FuzzySet with a generalized bell-shaped membership function |
| HomogenousNDimFS | A homogenous n-dimensional fuzzy set |
| NonEmptyComponent | Unary predicate taking a shared pointer to Fuzzy set and return it indicating whether the pointer refers to a non-empty component or not |
| InfinityFS | FuzzySet with a step function as membership function |
| NDimFS | Base class for n-dimensional fuzzy sets |
| SigmoidalFS | FuzzySet with sigmoidal membership function |
| SingletonFS | FuzzySet with a single point of positive membership |
| TrapezoidFS | FuzzySet with trapezoid membership function |
| TriangularFS | FuzzySet with triangular membership function |
| Implication | Fuzzy implication |
| InferenceMachine | An inference machine |
| LinguisticTerm | A single linguistic term |
| BellLT | LinguisticTerm with a bell-shaped (Gaussian) membership function |
| ComposedLT | A composed LinguisticTerm |
| ConstantLT | LinguisticTerm with constant membership function |
| CustomizedLT | A LinguisticTerm with an user defined mambership function |
| GeneralizedBellLT | LinguisticTerm with a generalized bell-shaped membership function |
| InfinityLT | LinguisticTerm with a step function as membership function |
| SigmoidalLT | LinguisticTerm with sigmoidal membership function |
| SingletonLT | LinguisticTerm with a single point of positive membership |
| TrapezoidLT | LinguisticTerm with trapezoid membership function |
| TriangularLT | LinguisticTerm with triangular membership function |
| LinguisticVariable | A composite of linguistic terms |
| MamdaniIM | Mamdami inference machine |
| Operators | Operators and connective functions |
| Rule | A rule which is composed of premise and conclusion |
| RuleBase | A composite of rules |
| SugenoIM | Sugeno inference machine |
| SugenoRule | Sugeno rule |
| VectorRepeater | |
| const_iterator1 | |
| const_iterator2 | |
| FixedDenseVectorProxy | |
| FixedDenseMatrixProxy | |
| FixedSparseVectorProxy | |
| const_iterator | |
| ExpressionTraitsBase< FixedSparseVectorProxy< T, I > > | |
| ExpressionTraitsBase< FixedSparseVectorProxy< T, I > const > | |
| Blocking | Partitions the matrix in 4 blocks defined by one splitting point (i,j) |
| ExpressionTraitsBase< blas::compressed_matrix< T, blas::row_major, 0, IA, TA > > | |
| ExpressionTraitsBase< blas::compressed_matrix< T, blas::row_major, 0, IA, TA > const > | |
| ExpressionTraitsBase< blas::compressed_vector< T, IB, IA, TA > > | |
| ExpressionTraitsBase< blas::compressed_vector< T, IB, IA, TA > const > | |
| VectorMatrixTraits | Template which finds for every Vector type the best fitting Matrix |
| SolveAXB | Flag indicating that a system AX=B is to be solved |
| SolveXAB | Flag indicating that a system XA=B is to be solved |
| Upper | Flag indicating that the matrix is Upper triangular |
| UnitUpper | Flag indicating that the matrix is Upper triangular and diagonal elements are to be assumed as 1 |
| Lower | Flag indicating that the matrix is Lower triangular |
| UnitLower | Flag indicating that the matrix is Lower triangular and diagonal elements are to be assumed as 1 |
| AbstractModel | Base class for all Models |
| AbstractClustering | Base class for clustering |
| Centroids | Clusters defined by centroids |
| ClusteringModel | Abstract model with associated clustering object |
| HardClusteringModel | Model for "hard" clustering |
| HierarchicalClustering | Clusters defined by a binary space partitioning tree |
| SoftClusteringModel | Model for "soft" clustering |
| CMACMap | Linear combination of piecewise constant functions |
| ConcatenatedModel | ConcatenatedModel concatenates two models such that the output of the first model is input to the second |
| ThresholdConverter | Convertion of real-valued outputs to classes 0 or 1 |
| ThresholdVectorConverter | Convertion of real-vector outputs to vectors of class labels 0 or 1 |
| ArgMaxConverter | Convertion of real-valued outputs to classes |
| OneHotConverter | Convertion of class indices to a one-hot encoding |
| FFNet | Offers the functions to create and to work with a feed-forward network |
| KalmanFilter | Standard linear Kalman Filter |
| AbstractKernelFunction | Base class of all Kernel functions |
| ARDKernelUnconstrained | Automatic relevance detection kernel for unconstrained parameter optimization |
| CSvmDerivative | This class provides two main member functions for computing the derivative of a C-SVM hypothesis w.r.t. its hyperparameters. The constructor takes a pointer to a KernelExpansion and an SvmTrainer, in the assumption that the former was trained by the latter. It heavily accesses their members to calculate the derivative of the alpha and offset values w.r.t. the SVM hyperparameters, that is, the regularization parameter C and the kernel parameters. This is done in the member function prepareCSvmParameterDerivative called by the constructor. After this initial, heavier computation step, modelCSvmParameterDerivative can be called on an input sample to the SVM model, and the method will yield the derivative of the hypothesis w.r.t. the SVM hyperparameters |
| DiscreteKernel | Kernel on a finite, discrete space |
| GaussianRbfKernel | Gaussian radial basis function kernel |
| KernelExpansion | Linear model in a kernel feature space |
| LinearKernel | Linear Kernel, parameter free |
| MissingFeaturesKernelExpansion | Kernel expansion with missing features support |
| MklKernel | Weighted sum of kernel functions |
| MonomialKernel | Monomial kernel. Calculates \( \left\langle x_1, x_2 \right\rangle^m_exponent \) |
| MultiTaskSample | Aggregation of input data and task index |
| NormalizedKernel | Normalized version of a kernel function |
| PolynomialKernel | Polynomial kernel |
| ProductKernel | Product of kernel functions |
| ScaledKernel | Scaled version of a kernel function |
| SubrangeKernel | Weighted sum of kernel functions |
| WeightedSumKernel | Weighted sum of kernel functions |
| tBase | Structure describing a single m_base kernel |
| LinearClassifier | Basic linear classifier |
| LinearModel | Linear Prediction |
| LinearNorm | Normalizes the (non-negative) input by dividing by the overall sum |
| NBClassifier | Naive Bayes classifier |
| NearestNeighborClassifier | Nearest Neighbor Classifier |
| NearestNeighborRegression | Nearest neighbor regression model |
| LogisticNeuron | Neuron which computes the Logistic (logistic) function with range [0,1] |
| TanhNeuron | Neuron which computes the hyperbolic tangenst with range [-1,1] |
| LinearNeuron | Linear activation Neuron |
| FastSigmoidNeuron | Fast sigmoidal function, which does not need to compute an exponential function |
| Normalizer | "Diagonal" linear model for data normalization |
| OneVersusOneClassifier | One-versus-one Classifier |
| OnlineRNNet | A recurrent neural network regression model optimized for online learning |
| RBFNet | Offers the functions to create and to work with radial basis function networks |
| RecurrentStructure | Offers a basic structure for recurrent networks |
| RNNet | A recurrent neural network regression model that learns with Back Propagation Through Time |
| SigmoidModel | Standard sigmoid function |
| SimpleSigmoidModel | Simple sigmoid function |
| TanhSigmoidModel | Scaled Tanh sigmoid function |
| Softmax | Softmax function |
| SoftNearestNeighborClassifier | SoftNearestNeighborClassifier returns a probabilistic classification by looking at the k nearest neighbors |
| TreeConstruction | Stopping criteria for tree construction |
| BinaryTree | Super class of binary space-partitioning trees |
| CARTClassifier | CART Classifier |
| SplitInfo | |
| KDTree | KD-tree, a binary space-partitioning tree |
| KHCTree | KHC-tree, a binary space-partitioning tree |
| LCTree | LC-tree, a binary space-partitioning tree |
| RFClassifier | Random Forest Classifier |
| AbstractConstraintHandler | Implements the base class for constraint handling |
| AbstractCost | Cost function interface |
| AbstractObjectiveFunction | Super class of all objective functions for optimization and learning |
| Ackley | Convex quadratic benchmark function with single dominant axis |
| Cigar | Convex quadratic benchmark function with single dominant axis |
| CigarDiscus | Convex quadratic benchmark function |
| CIGTAB1 | Multi-objective optimization benchmark function CIGTAB 1 |
| CIGTAB2 | Multi-objective optimization benchmark function CIGTAB 2 |
| DiffPowers | |
| Discus | Convex quadratic benchmark function |
| DTLZ1 | Implements the benchmark function DTLZ1 |
| DTLZ2 | Implements the benchmark function DTLZ2 |
| DTLZ3 | Implements the benchmark function DTLZ3 |
| DTLZ4 | Implements the benchmark function DTLZ4 |
| DTLZ5 | Implements the benchmark function DTLZ5 |
| DTLZ6 | Implements the benchmark function DTLZ6 |
| DTLZ7 | Implements the benchmark function DTLZ7 |
| ELLI1 | Multi-objective optimization benchmark function ELLI1 |
| ELLI2 | Multi-objective optimization benchmark function ELLI2 |
| Ellipsoid | Convex quadratic benchmark function |
| Fonseca | Bi-objective real-valued benchmark function proposed by Fonseca and Flemming |
| GSP | Real-valued benchmark function with two objectives |
| Himmelblau | Multi-modal two-dimensional continuous Himmelblau benchmark function |
| IHR1 | Multi-objective optimization benchmark function IHR1 |
| IHR2 | Multi-objective optimization benchmark function IHR 2 |
| IHR3 | Multi-objective optimization benchmark function IHR3 |
| IHR4 | Multi-objective optimization benchmark function IHR 4 |
| IHR6 | Multi-objective optimization benchmark function IHR 6 |
| LZ1 | Multi-objective optimization benchmark function LZ1 |
| LZ2 | Multi-objective optimization benchmark function LZ2 |
| LZ3 | Multi-objective optimization benchmark function LZ3 |
| LZ4 | Multi-objective optimization benchmark function LZ4 |
| LZ5 | Multi-objective optimization benchmark function LZ5 |
| LZ6 | Multi-objective optimization benchmark function LZ6 |
| LZ7 | Multi-objective optimization benchmark function LZ7 |
| LZ8 | Multi-objective optimization benchmark function LZ8 |
| LZ9 | |
| Rosenbrock | Generalized Rosenbrock benchmark function |
| Sphere | Convex quadratic benchmark function |
| ZDT1 | Multi-objective optimization benchmark function ZDT1 |
| ZDT2 | Multi-objective optimization benchmark function ZDT2 |
| ZDT3 | Multi-objective optimization benchmark function ZDT3 |
| ZDT4 | Multi-objective optimization benchmark function ZDT4 |
| ZDT6 | Multi-objective optimization benchmark function ZDT6 |
| BoxConstraintHandler | |
| CombinedObjectiveFunction | Linear combination of objective functions |
| CrossValidationError | Cross-validation error for selection of hyper-parameters |
| SupervisedObjectiveFunction | Data-dependent objective function for supervised learning |
| UnsupervisedObjectiveFunction | Data-dependent objective function for unsupervised learning |
| DenoisingAutoencoderError | Objective function for unsupervised training of denoising autoencoders |
| ErrorFunction | Objective function for supervised learning |
| KernelTargetAlignment | Kernel Target Alignment - a measure of alignment of a kernel Gram matrix with labels |
| LooError | Leave-one-out error objective function |
| LooErrorCSvm | Leave-one-out error, specifically optimized for C-SVMs |
| AbsoluteLoss | Absolute loss |
| AbstractLoss | Loss function interface |
| CrossEntropy | Error measure for classication tasks that can be used as the objective function for training |
| CrossEntropyIndependent | Error measure for classification tasks of non exclusive attributes that can be used for model training |
| DiscreteLoss | Flexible loss for classification |
| NegativeClassificationLogLikelihood | Negative logarithm of the likelihood of a classification model given labeled data |
| SquaredLoss | Squared loss for regression and classification |
| ZeroOneLoss | 0-1-loss for classification |
| ZeroOneLoss< unsigned int, RealVector > | 0-1-loss for classification |
| NegativeAUC | Negative area under the curve |
| NegativeWilcoxonMannWhitneyStatistic | Negative Wilcoxon-Mann-Whitney statistic |
| NegativeGaussianProcessEvidence | Evidence for model selection of a regularization network/Gaussian process |
| NoisyErrorFunction | Error Function which only uses a random fraction of data |
| RadiusMarginQuotient | Radius margin quotions for binary SVMs |
| Result | |
| OneNormRegularizer | One-norm of the input as an objective function |
| TwoNormRegularizer | Two-norm of the input as an objective function |
| ROC | ROC-Curve - false negatives over false positives |
| SpanBoundCSvm | Approximate version of the span-bound for C-SVMs |
| SparseFFNetError | Error Function for FFNets which should be trained with sparse activation of the hidden neurons |
| SvmLogisticInterpretation | Maximum-likelihood model selection score for binary support vector machines |
| AbstractDistribution | Abstract class for distributions |
| Bernoulli | This class simulates a "Bernoulli trial", which is like a coin toss |
| Binomial | Models a binomial distribution with parameters p and n |
| Cauchy | Cauchy distribution |
| DiffGeometric_distribution | Implements a diff geometric distribution |
| DiffGeometric | Random variable with diff geometric distribution |
| Dirichlet_distribution | Dirichlet distribution |
| Dirichlet | Implements a Dirichlet distribution |
| DiscreteUniform | Implements the discrete uniform distribution |
| Erlang_distribution | Implements an Erlang distribution |
| Erlang | Erlang distributed random variable |
| Gamma_distribution | Gamma distribution |
| Gamma | Gamma distributed random variable |
| Geometric | Implements the geometric distribution |
| BaseRng | Collection of different variate generators for different distributions |
| HyperGeometric_distribution | Hypergeometric distribution |
| HyperGeometric | Random variable with a hypergeometric distribution |
| LogNormal | Implements a log-normal distribution with parameters location m and Scale s |
| NegExponential | Implements the Negative exponential distribution |
| Normal | Implements a univariate normal (Gaussian) distribution |
| Poisson | Implements a Poisson distribution with parameter mean |
| TruncatedExponential_distribution | Boost random suitable distribution for an truncated exponential. See TruncatedExponential for more details |
| TruncatedExponential | Implements a generator for the truncated exponential function |
| Uniform | Implements a continuous uniform distribution |
| Weibull_distribution | Weibull distribution |
| Weibull | Weibull distributed random variable |
| Statistics | Calculate pre-defined statistics given a range of values |
| Histogram | Tags the histogram |
| LowerQuartile | Tags the lower quartile |
| Max | Tags the maximum value |
| Mean | Tags the mean value |
| Median | Tags the median |
| Min | Tags the minimum value |
| NumSamples | Tags the number of samples |
| UnbiasedVariance | Tags the unbiased variance (not implemented) |
| UpperQuartile | Tags the upper quartile |
| Variance | Tags the variance |
| WilcoxonRankSumTest | Wilcoxon rank-sum test / Mann–Whitney U test |
| Element | Stores information about an observation |
| Result | Stores result of Wilcoxon rank-sum test |
| Energy | The Energy function determining the Gibbs distribution of an RBM |
| AverageEnergyGradient | The gradient of the energy averaged over a set of cumulative added samples |
| ContrastiveDivergence | Implements k-step Contrastive Divergence described by Hinton et all. (2006) |
| ExactGradient | |
| MultiChainApproximator | Approximates the gradient by taking samples from an ensemble of Markov chains running in parallel |
| SingleChainApproximator | Approximates the gradient by taking samples from a single Markov chain |
| Batch< detail::BinarySufficientStatistics< VectorType > > | |
| BinaryLayer | Layer of binary units taking values in {0,1} |
| Batch< detail::GaussianSufficientStatistics< VectorType > > | |
| GaussianLayer | A layer of Gaussian neurons |
| Batch< detail::TruncatedExponentialSufficientStatistics< VectorType > > | |
| TruncatedExponentialLayer | A layer of truncated exponential neurons |
| BarsAndStripes | Generates the Bars-And-Stripes problem. In this problem, a 4x4 image has either rows or columns of the same value |
| DistantModes | Creates a set of pattern (each later representing the "center" of a mode) which than are randomly perturbed to create the data set. add reference |
| MNIST | Reads in the famous MNIST data in possibly binarized form. The MNIST database itself is not included in Shark, this class just helps loading it |
| Shifter | Shifter problem |
| RBM | Stub for the RBM class. at the moment it is just a holder of the parameter set and the Energy |
| GibbsOperator | Implements Gibbs Sampling related transition operators for various temperatures |
| Batch< detail::GibbsSample< Statistics > > | |
| Batch< detail::MarkovChainSample< Hidden, Visible > > | |
| MarkovChain | A single Markov chain |
| TemperedMarkovChain | |
| RealSpace | The RealSpace can't be enumerated. Infinite values are just too much |
| TwoStateSpace | The TwoStateSpace is a discrete Space with only two values, for example {0,1} or {-1,1} |
| Producer | Produces normally distributed values and reports them via a probe |
| Consumer | Consumes floating point values via a probe |
| Store | Helper class for storing the most recent value reported from a probe |
| TspTourLength | Calculates the cost of a tour w.r.t. to a cost matrix |
| PartiallyMappedCrossover | Implements partially mapped crossover |
| tag | |
| ExpressionTraits | |
| ExpressionTraitsBase< blas::matrix_column< M > > | |
| ExpressionTraitsBase< blas::matrix_column< M > const > | |
| ExpressionTraitsBase< blas::matrix_expression< M > > | |
| ExpressionTraitsBase< blas::matrix_expression< M > const > | |
| ExpressionTraitsBase< blas::matrix_range< M > > | |
| ExpressionTraitsBase< blas::matrix_range< M > const > | |
| ExpressionTraitsBase< blas::matrix_reference< M > > | |
| ExpressionTraitsBase< blas::matrix_reference< M > const > | |
| ExpressionTraitsBase< blas::matrix_row< M > > | |
| ExpressionTraitsBase< blas::matrix_row< M > const > | |
| ExpressionTraitsBase< blas::matrix_transpose< M > > | |
| ExpressionTraitsBase< blas::matrix_transpose< M > const > | |
| ExpressionTraitsBase< blas::vector_range< V > > | |
| ExpressionTraitsBase< blas::vector_range< V > const > | |
| ExpressionTraitsBase< blas::vector_reference< V > > | |
| ExpressionTraitsBase< blas::vector_reference< V > const > | |
| ExpressionTraitsBase< FixedDenseMatrixProxy< T, O > > | |
| ExpressionTraitsBase< FixedDenseMatrixProxy< T, O > const > | |
| Gaussians | |
| IsCompressed | |
| IsDense | |
| IsSparse | |
| IsUnknownStorage | |
| Orientation | |
| PointerType | |
| TestProblem | |
| UniformPoints |