# Changeset 1125

Ignore:
Timestamp:
Feb 22, 2008, 10:31:22 PM (16 years ago)
Message:

fixing Doxygen parsing

Location:
trunk
Files:
25 edited

Unmodified
Removed
• ## trunk/doc/Statistics.doxygen

 r1109 \section Kernel \subsection Polynomial Kernel \subsection polynomial_kernel Polynomial Kernel The polynomial kernel of degree \f$N\f$ is defined as \f$(1+)^N\f$, where \f$\f$ is the linear kernel (usual scalar product). For the weighted \f$(1+)^N\f$ is a proper kernel because taking a proper kernel to the \f$Nth\f$ power yields a new proper kernel (see any good book on SVM). \subsection{Gaussian Kernel} \subsection gaussian_kernel Gaussian Kernel We define the weighted Gaussian kernel as \f$\exp\left(-\frac{\sum w_xw_y(x-y)^2}{\sum w_xw_y}\right)\f$, which fulfills the conditions
• ## trunk/yat/classifier/DataLookup2D.h

 r1088 /// @return sub-Lookup of the DataLookup2D /// /// @Note Returns a dynamically allocated DataLookup2D, which has /// @note Returns a dynamically allocated DataLookup2D, which has /// to be deleted by the caller to avoid memory leaks. /// /// @return sub-Lookup of the DataLookup2D /// /// @Note Returns a dynamically allocated DataLookup2D, which has /// @note Returns a dynamically allocated DataLookup2D, which has /// to be deleted by the caller to avoid memory leaks. ///
• ## trunk/yat/classifier/EnsembleBuilder.h

 r1121 class EnsembleBuilder { public: /** \brief Type of classifier that ensemble is built on. */ typedef Classifier classifier_type; /** Type of container used for storing data e.g. MatrixLookup or KernelLookup */ typedef Data data_type; /// /// @Return classifier /// @return classifier /// const Classifier& classifier(size_t i) const; /// /// @Return Number of classifiers in ensemble /// @return Number of classifiers in ensemble /// u_long size(void) const;
• ## trunk/yat/classifier/Kernel.h

 r1000 /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated Kernel, which has /// @note Returns a dynamically allocated Kernel, which has /// to be deleted by the caller to avoid memory leaks. /// /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated Kernel, which has /// @note Returns a dynamically allocated Kernel, which has /// to be deleted by the caller to avoid memory leaks. ///
• ## trunk/yat/classifier/KernelLookup.h

 r1110 const_iterator; /** 'Read only' iterator intended to iterate over a column */ typedef const_iterator const_column_iterator; /** 'Read only' iterator intended to iterate over a row */ typedef const_iterator const_row_iterator; /// \return data that KernelLookup is built upon. /// /// @Note Returns a dynamically allocated MatrixLookup, which has /// @note Returns a dynamically allocated MatrixLookup, which has /// to be deleted by the caller to avoid memory leaks. /// KernelLookup. \Note Returns a dynamically allocated KernelLookup, which has \note Returns a dynamically allocated KernelLookup, which has to be deleted by the caller to avoid memory leaks. */ this was built from. @Note Returns a dynamically allocated DataLookup2D, which has @note Returns a dynamically allocated DataLookup2D, which has to be deleted by the caller to avoid memory leaks. */ this was built from. @Note Returns a dynamically allocated DataLookup2D, which has @note Returns a dynamically allocated DataLookup2D, which has to be deleted by the caller to avoid memory leaks. */ KernelLookup \Note Returns a dynamically allocated DataLookup2D, which has \note Returns a dynamically allocated DataLookup2D, which has to be deleted by the caller to avoid memory leaks. */ \return sub-Lookup of the DataLookup2D \Note Returns a dynamically allocated DataLookup2D, which has \note Returns a dynamically allocated DataLookup2D, which has to be deleted by the caller to avoid memory leaks. */
• ## trunk/yat/classifier/Kernel_MEV.h

 r1000 /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated Kernel, which has /// @note Returns a dynamically allocated Kernel, which has /// to be deleted by the caller to avoid memory leaks. /// /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated Kernel, which has /// @note Returns a dynamically allocated Kernel, which has /// to be deleted by the caller to avoid memory leaks. ///
• ## trunk/yat/classifier/Kernel_SEV.h

 r1121 /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated Kernel, which has /// @note Returns a dynamically allocated Kernel, which has /// to be deleted by the caller to avoid memory leaks. /// /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated Kernel, which has /// @note Returns a dynamically allocated Kernel, which has /// to be deleted by the caller to avoid memory leaks. ///
• ## trunk/yat/classifier/MatrixLookup.h

 r1121 const_iterator; /** 'Read only' iterator used to iterate over a column */ typedef const_iterator const_column_iterator; /** 'Read only' iterator used to iterate over a row */ typedef const_iterator const_row_iterator; /// undefined. /// /// @Note Returns a dynamically allocated DataLookup2D, which has /// @note Returns a dynamically allocated DataLookup2D, which has /// to be deleted by the caller to avoid memory leaks. ///
• ## trunk/yat/classifier/MatrixLookupWeighted.h

 r1121 const_iterator; /** 'Read only' iterator used to iterate over a column */ typedef const_iterator const_column_iterator; /** 'Read only' iterator used to iterate over a row */ typedef const_iterator const_row_iterator;
• ## trunk/yat/classifier/SVM.h

 r1124 /// /// /// Same as copy constructor. /// SVM* make_classifier(void) const;
• ## trunk/yat/classifier/SubsetGenerator.h

 r1086 { public: /** type of data that is stored in SubsetGenerator */ typedef T value_type;
• ## trunk/yat/classifier/SupervisedClassifier.h

 r1121 /// instatiate (see 'Prototype' in Design Patterns). /// /// @Note Returns a dynamically allocated SupervisedClassifier, which has /// @note Returns a dynamically allocated SupervisedClassifier, which has /// to be deleted by the caller to avoid memory leaks. ///
• ## trunk/yat/statistics/KolmogorovSmirnov.h

 r1003 }; /** \brief output operator */ std::ostream& operator<<(std::ostream&, const KolmogorovSmirnov&);
• ## trunk/yat/statistics/PearsonCorrelation.h

 r1024 correlation is zero (and the data is Gaussian). @Note This function can only be used together with the @note This function can only be used together with the unweighted score.
• ## trunk/yat/utility/Container2DIterator.h

 r1110 { public: /** Tells whether iterator is weighted or not. \see weighted_iterator_tag and unweighted_iterator_tag */ typedef typename Policy::weighted_iterator_type weighted_iterator_type; \param container iterator points to \param row telling which row iterator points to \param colun telling which column iterator points to \param column telling which column iterator points to */ Container2DIterator(Container& container, size_t row, size_t column) /** Whether Container2DIterator is weighted is desiced by Policy. Specialization for Container2DIterator */ template struct weighted_iterator_traits > { /** Whether Container2DIterator is weighted is desiced by Policy. */ typedef typename Policy::weighted_iterator_type type; }; /** Specialization for Container2DIterator */ template struct iterator_traits > {
• ## trunk/yat/utility/IteratorPolicy.h

 r1092 struct IteratorPolicy { /// type returned from function data typedef reference data_type; /// type returned from function weight typedef weight_t weight_type; /** returns unweighted_iterator_tag as Policy is intended to be used in a unweighted iterator */ typedef unweighted_iterator_tag weighted_iterator_type; /** \return c(row, column) */ data_type data(const Container& c, size_t row, size_t column) const { } /** \return same as data */ reference dereference(const Container& c, size_t row, size_t column) const { } /** \return 1.0 */ weight_type weight(const Container& c, size_t row, size_t column) const { struct IteratorPolicyWeighted { /// type returned from function dereference typedef std::pair reference; /// type returned from function data typedef data_t data_type; /// type returned from function weight typedef weight_t weight_type; /// weighted_iterator_tag as Policy is intended for weighted iterators typedef weighted_iterator_tag weighted_iterator_type; /** \return data */ data_type data(const Container& c, size_t row, size_t column) const { } /** \return a pair in of . */ reference dereference(const Container& c, size_t row, size_t column) const { } /** \return weight */ weight_type weight(const Container& c, size_t row, size_t column) const {
• ## trunk/yat/utility/Matrix.h

 r1121 public: /** Mutable iterator that iterates over all elements */ typedef StrideIterator iterator; /** Read-only iterator that iterates over all elements */ typedef StrideIterator const_iterator; /** Mutable iterator that iterates over one column */ typedef StrideIterator column_iterator; /** Read-only iterator that iterates over one column */ typedef StrideIterator const_column_iterator; /** Mutable iterator that iterates over one row */ typedef StrideIterator row_iterator; /** Read-only iterator that iterates over one row */ typedef StrideIterator const_row_iterator;
• ## trunk/yat/utility/OptionArg.h

 r1000 protected: /** \return true if Option is required, i.e., if Option is not found during parsing an exception will be thrown. */ inline bool required(void) const { return required_; }
• ## trunk/yat/utility/OptionHelp.h

 r1000 "h,help" (default) for having both short and long option name \param desc string used in help display \param def default value for switch */ OptionHelp(CommandLine& cmd, std::string name="h,help",
• ## trunk/yat/utility/SmartPtr.h

 r1050 /** SmartPtr is a wrapper around a pointer. Default SmartPtr is set to be owner of pointer, which implies pointer will be deleted in destructor. Pointer can be shared between many SmartPtr, in which case a counter is kept updated in copying and assignment telling how many owners there are. When the counter reaches zero, the pointer is deleted. */ template
• ## trunk/yat/utility/StrideIterator.h

 r1088 /** StrideIterator is weighted if underlying iterator is weighted. Specialization for StrideIterator that calls underlying iterator. */ template struct weighted_iterator_traits > { /** StrideIterator is weighted if underlying iterator is weighted. */ typedef typename weighted_iterator_traits::type type; }; /** Specialization for StrideIterator using iterator_traits with base() */ template struct iterator_traits > { */ double data(StrideIterator iter) const { iterator_traits jojo; return jojo.data(iter.base()); } { return iterator_traits().data(iter.base()); } /** { public: /// type of underlying iterator typedef Iter iterator_type; /// value type typedef typename std::iterator_traits::value_type value_type; /// difference type typedef typename std::iterator_traits::difference_type difference_type; /// reference typedef typename std::iterator_traits::reference reference; /// pointer typedef typename std::iterator_traits::pointer pointer; /// weighted_iterator_tag if iterator is weighted typedef typename yat::utility::weighted_iterator_traits::type w_type; /** */ // Peter, this is ugly hack to provide iteartor to const_iterator Conversion from mutable iterator to const iterator. Only works if underlying iterator is a pointer. */ // Peter, this is ugly hack to provide iterator to const_iterator // for our gsl_iterators - solution? use Boost:iterator_adaptor operator StrideIterator() /** \return pointer */ pointer operator->() const { return &(operator*()); }
• ## trunk/yat/utility/VectorBase.h

 r1120 const double& operator()(size_t i) const; // Peter, remove this one /// \deprecated const double& operator[](size_t i) const; protected: /// pointer to underlying GSL vector const gsl_vector* const_vec_; private: // copy assignment no allowed // copy assignment not allowed const VectorBase& operator=(const VectorBase&); };
• ## trunk/yat/utility/VectorConstView.h

 r1121 modified. \Note that view vectors do not own the underlying data, \note that view vectors do not own the underlying data, and a view is not valid if the vector/matrix owing the data is deallocated.
• ## trunk/yat/utility/VectorMutable.h

 r1120 double& operator()(size_t i); // Peter, remove this one /// \deprecated double& operator[](size_t i); // to allow overload from base class protected: /** pointer to underlying GSL vector. Should always point to same gsl_vector as const_vec_ in base class does. This pointer should by used for mutable operations. Do not use this in const functions; use const_vec_ inherited from BaseVector. */ gsl_vector* vec_; struct proxy { /// pointer to GSL vector keeping everything we need to create a /// new VectorMutable from a proxy. gsl_vector* vec_; }; /** Sort the elements in the VectorMutable. Sort the elements in the VectorMutable \a vec */ void sort(VectorMutable&); void sort(VectorMutable& vec); }}} // of namespace utility, yat, and theplu
• ## trunk/yat/utility/iterator_traits.h

 r1115 /** All iterators default to unweighted type All iterators default to unweighted type. If you want your iterator to behave as weighted, you need to provide a specialization. \see Iterator and StrideIterator template struct weighted_iterator_traits { /** All iterators default to unweighted type */ typedef unweighted_iterator_tag type; }; template struct unweighted_type_and { /** default return weighted_iterator_tag */ typedef weighted_iterator_tag type; }; template <> struct unweighted_type_and { /** return unweighted_iterator_tag */ typedef unweighted_iterator_tag type; }; template struct weighted_if_any2 { private: typedef typename weighted_iterator_traits::type w_type1; typedef typename weighted_iterator_traits::type w_type2; public: /// return unweighted if both are unweighted typedef typename unweighted_type_and::type type; }; template struct weighted_if_any3 { private: typedef typename weighted_if_any2::type tmp; typedef typename weighted_iterator_traits::type w_type3; public: /// return unweighted if all are unweighted typedef typename unweighted_type_and::type type; };
Note: See TracChangeset for help on using the changeset viewer.