Changeset 1125 for trunk/yat


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

fixing Doxygen parsing

Location:
trunk/yat
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/yat/classifier/DataLookup2D.h

    r1088 r1125  
    129129    /// @return sub-Lookup of the DataLookup2D
    130130    ///
    131     /// @Note Returns a dynamically allocated DataLookup2D, which has
     131    /// @note Returns a dynamically allocated DataLookup2D, which has
    132132    /// to be deleted by the caller to avoid memory leaks.
    133133    ///
    … …  
    138138    /// @return sub-Lookup of the DataLookup2D
    139139    ///
    140     /// @Note Returns a dynamically allocated DataLookup2D, which has
     140    /// @note Returns a dynamically allocated DataLookup2D, which has
    141141    /// to be deleted by the caller to avoid memory leaks.
    142142    ///

  • trunk/yat/classifier/EnsembleBuilder.h

    r1121 r1125  
    4545  class EnsembleBuilder
    4646  {
    47  
    4847  public:
     48    /**
     49       \brief Type of classifier that ensemble is built on.
     50     */
    4951    typedef Classifier classifier_type;
     52
     53    /**
     54       Type of container used for storing data e.g. MatrixLookup or KernelLookup
     55     */
    5056    typedef Data data_type;
    5157
    … …  
    7278
    7379    ///
    74     /// @Return classifier
     80    /// @return classifier
    7581    ///
    7682    const Classifier& classifier(size_t i) const;
    7783     
    7884    ///
    79     /// @Return Number of classifiers in ensemble
     85    /// @return Number of classifiers in ensemble
    8086    ///
    8187    u_long size(void) const;

  • trunk/yat/classifier/Kernel.h

    r1000 r1125  
    132132    /// instatiate (see 'Prototype' in Design Patterns).
    133133    ///
    134     /// @Note Returns a dynamically allocated Kernel, which has
     134    /// @note Returns a dynamically allocated Kernel, which has
    135135    /// to be deleted by the caller to avoid memory leaks.
    136136    ///
    … …  
    143143    /// instatiate (see 'Prototype' in Design Patterns).
    144144    ///
    145     /// @Note Returns a dynamically allocated Kernel, which has
     145    /// @note Returns a dynamically allocated Kernel, which has
    146146    /// to be deleted by the caller to avoid memory leaks.
    147147    ///

  • trunk/yat/classifier/KernelLookup.h

    r1110 r1125  
    7676    const_iterator;
    7777
     78    /**
     79       'Read only' iterator intended to iterate over a column
     80     */
    7881    typedef const_iterator const_column_iterator;
     82
     83    /**
     84       'Read only' iterator intended to iterate over a row
     85     */
    7986    typedef const_iterator const_row_iterator;
    8087
    … …  
    198205    /// \return data that KernelLookup is built upon.
    199206    ///
    200     /// @Note Returns a dynamically allocated MatrixLookup, which has
     207    /// @note Returns a dynamically allocated MatrixLookup, which has
    201208    /// to be deleted by the caller to avoid memory leaks.
    202209    ///
    … …  
    243250       KernelLookup.
    244251
    245        \Note Returns a dynamically allocated KernelLookup, which has
     252       \note Returns a dynamically allocated KernelLookup, which has
    246253       to be deleted by the caller to avoid memory leaks.
    247254    */
    … …  
    258265       this was built from.
    259266   
    260        @Note Returns a dynamically allocated DataLookup2D, which has
     267       @note Returns a dynamically allocated DataLookup2D, which has
    261268       to be deleted by the caller to avoid memory leaks.
    262269    */
    … …  
    273280       this was built from.
    274281   
    275        @Note Returns a dynamically allocated DataLookup2D, which has
     282       @note Returns a dynamically allocated DataLookup2D, which has
    276283       to be deleted by the caller to avoid memory leaks.
    277284    */
    … …  
    285292       KernelLookup
    286293   
    287        \Note Returns a dynamically allocated DataLookup2D, which has
     294       \note Returns a dynamically allocated DataLookup2D, which has
    288295       to be deleted by the caller to avoid memory leaks.
    289296    */
    … …  
    298305       \return sub-Lookup of the DataLookup2D
    299306   
    300        \Note Returns a dynamically allocated DataLookup2D, which has
     307       \note Returns a dynamically allocated DataLookup2D, which has
    301308       to be deleted by the caller to avoid memory leaks.
    302309    */

  • trunk/yat/classifier/Kernel_MEV.h

    r1000 r1125  
    8989    /// instatiate (see 'Prototype' in Design Patterns).
    9090    ///
    91     /// @Note Returns a dynamically allocated Kernel, which has
     91    /// @note Returns a dynamically allocated Kernel, which has
    9292    /// to be deleted by the caller to avoid memory leaks.
    9393    ///
    … …  
    101101    /// instatiate (see 'Prototype' in Design Patterns).
    102102    ///
    103     /// @Note Returns a dynamically allocated Kernel, which has
     103    /// @note Returns a dynamically allocated Kernel, which has
    104104    /// to be deleted by the caller to avoid memory leaks.
    105105    ///

  • trunk/yat/classifier/Kernel_SEV.h

    r1121 r1125  
    7878    /// instatiate (see 'Prototype' in Design Patterns).
    7979    ///
    80     /// @Note Returns a dynamically allocated Kernel, which has
     80    /// @note Returns a dynamically allocated Kernel, which has
    8181    /// to be deleted by the caller to avoid memory leaks.
    8282    ///
    … …  
    9090    /// instatiate (see 'Prototype' in Design Patterns).
    9191    ///
    92     /// @Note Returns a dynamically allocated Kernel, which has
     92    /// @note Returns a dynamically allocated Kernel, which has
    9393    /// to be deleted by the caller to avoid memory leaks.
    9494    ///

  • trunk/yat/classifier/MatrixLookup.h

    r1121 r1125  
    7979    const_iterator;
    8080
     81    /**
     82       'Read only' iterator used to iterate over a column
     83     */
    8184    typedef const_iterator const_column_iterator;
     85
     86    /**
     87       'Read only' iterator used to iterate over a row
     88     */
    8289    typedef const_iterator const_row_iterator;
    8390
    … …  
    286293    /// undefined.
    287294    ///
    288     /// @Note Returns a dynamically allocated DataLookup2D, which has
     295    /// @note Returns a dynamically allocated DataLookup2D, which has
    289296    /// to be deleted by the caller to avoid memory leaks.
    290297    ///

  • trunk/yat/classifier/MatrixLookupWeighted.h

    r1121 r1125  
    8080    const_iterator;
    8181
     82    /**
     83       'Read only' iterator used to iterate over a column
     84     */
    8285    typedef const_iterator const_column_iterator;
     86
     87    /**
     88       'Read only' iterator used to iterate over a row
     89     */
    8390    typedef const_iterator const_row_iterator;
    8491

  • trunk/yat/classifier/SVM.h

    r1124 r1125  
    7878
    7979    ///
    80     ///
     80    /// Same as copy constructor.
    8181    ///
    8282    SVM* make_classifier(void) const;

  • trunk/yat/classifier/SubsetGenerator.h

    r1086 r1125  
    5252  {
    5353  public:
     54    /**
     55       type of data that is stored in SubsetGenerator
     56     */
    5457    typedef T value_type;
    5558

  • trunk/yat/classifier/SupervisedClassifier.h

    r1121 r1125  
    7171    /// instatiate (see 'Prototype' in Design Patterns).
    7272    ///
    73     /// @Note Returns a dynamically allocated SupervisedClassifier, which has
     73    /// @note Returns a dynamically allocated SupervisedClassifier, which has
    7474    /// to be deleted by the caller to avoid memory leaks.
    7575    ///

  • trunk/yat/statistics/KolmogorovSmirnov.h

    r1003 r1125  
    9090  };
    9191
     92  /**
     93     \brief output operator
     94   */
    9295  std::ostream& operator<<(std::ostream&, const KolmogorovSmirnov&);
    9396

  • trunk/yat/statistics/PearsonCorrelation.h

    r1024 r1125  
    9292       correlation is zero (and the data is Gaussian).
    9393       
    94        @Note This function can only be used together with the
     94       @note This function can only be used together with the
    9595       unweighted score.
    9696       

  • trunk/yat/utility/Container2DIterator.h

    r1110 r1125  
    4848  {
    4949  public:
     50    /**
     51       Tells whether iterator is weighted or not.
     52
     53       \see weighted_iterator_tag and unweighted_iterator_tag
     54     */
    5055    typedef typename Policy::weighted_iterator_type weighted_iterator_type;
    5156
    … …  
    6469       \param container iterator points to
    6570       \param row telling which row iterator points to
    66        \param colun telling which column iterator points to
     71       \param column telling which column iterator points to
    6772    */
    6873    Container2DIterator(Container& container, size_t row, size_t column)
    … …  
    267272
    268273  /**
    269      Whether Container2DIterator is weighted is desiced by Policy.
     274     Specialization for Container2DIterator
    270275   */
    271276  template<typename A, typename B, typename C, typename D, typename Policy>
    272277  struct weighted_iterator_traits<Container2DIterator<A, B, C, D, Policy> > {
     278    /**
     279       Whether Container2DIterator is weighted is desiced by Policy.
     280    */
    273281    typedef typename Policy::weighted_iterator_type type;
    274282  };
    275283
     284  /**
     285     Specialization for Container2DIterator
     286   */
    276287  template<typename A, typename B, typename C, typename D, typename E>
    277288  struct iterator_traits<Container2DIterator<A, B, C, D, E> > {

  • trunk/yat/utility/IteratorPolicy.h

    r1092 r1125  
    3737  struct IteratorPolicy
    3838  {
     39    /// type returned from function data
    3940    typedef reference data_type;
     41    /// type returned from function weight
    4042    typedef weight_t weight_type;
     43    /**
     44       returns unweighted_iterator_tag as Policy is intended to be
     45       used in a unweighted iterator
     46    */
    4147    typedef unweighted_iterator_tag weighted_iterator_type;
    4248
     49    /**
     50       \return c(row, column)
     51     */
    4352    data_type data(const Container& c, size_t row, size_t column) const
    4453    {
    … …  
    4655    }
    4756
     57    /**
     58       \return same as data
     59    */
    4860    reference dereference(const Container& c, size_t row, size_t column) const
    4961    {
    … …  
    5163    }
    5264
     65    /**
     66       \return 1.0
     67    */
    5368    weight_type weight(const Container& c, size_t row, size_t column) const
    5469    {
    … …  
    6580  struct IteratorPolicyWeighted
    6681  {
     82    /// type returned from function dereference
    6783    typedef std::pair<data_t, weight_t> reference;
     84    /// type returned from function data
    6885    typedef data_t data_type;
     86    /// type returned from function weight
    6987    typedef weight_t weight_type;
     88    /// weighted_iterator_tag as Policy is intended for weighted iterators
    7089    typedef weighted_iterator_tag weighted_iterator_type;
    7190
     91    /**
     92       \return data
     93    */
    7294    data_type data(const Container& c, size_t row, size_t column) const
    7395    {
    … …  
    7597    }
    7698
     99    /**
     100       \return a pair in of <data, weight>.
     101    */
    77102    reference dereference(const Container& c, size_t row, size_t column) const
    78103    {
    … …  
    80105    }
    81106
     107    /**
     108       \return weight
     109    */
    82110    weight_type weight(const Container& c, size_t row, size_t column) const
    83111    {

  • trunk/yat/utility/Matrix.h

    r1121 r1125  
    6666  public:
    6767    /**
     68       Mutable iterator that iterates over all elements
    6869     */
    6970    typedef StrideIterator<double*> iterator;
    7071
    7172    /**
     73       Read-only iterator that iterates over all elements
    7274     */
    7375    typedef StrideIterator<const double*> const_iterator;
    7476
    7577    /**
     78       Mutable iterator that iterates over one column
    7679     */
    7780    typedef StrideIterator<double*> column_iterator;
    7881
    7982    /**
     83       Read-only iterator that iterates over one column
    8084     */
    8185    typedef StrideIterator<const double*> const_column_iterator;
    8286
    8387    /**
     88       Mutable iterator that iterates over one row
    8489     */
    8590    typedef StrideIterator<double*> row_iterator;
    8691
    8792    /**
     93       Read-only iterator that iterates over one row
    8894     */
    8995    typedef StrideIterator<const double*> const_row_iterator;

  • trunk/yat/utility/OptionArg.h

    r1000 r1125  
    7070
    7171  protected:
     72    /**
     73       \return true if Option is required, i.e., if Option is not
     74       found during parsing an exception will be thrown.
     75     */
    7276    inline bool required(void) const { return required_; }
    7377

  • trunk/yat/utility/OptionHelp.h

    r1000 r1125  
    5050       "h,help" (default) for having both short and long option name
    5151       \param desc string used in help display
    52        \param def default value for switch
    5352    */
    5453    OptionHelp(CommandLine& cmd, std::string name="h,help",

  • trunk/yat/utility/SmartPtr.h

    r1050 r1125  
    3232
    3333  /**
     34     SmartPtr is a wrapper around a pointer. Default SmartPtr is set
     35     to be owner of pointer, which implies pointer will be deleted in
     36     destructor. Pointer can be shared between many SmartPtr, in which
     37     case a counter is kept updated in copying and assignment telling
     38     how many owners there are. When the counter reaches zero, the
     39     pointer is deleted.
    3440  */
    3541  template<typename T>

  • trunk/yat/utility/StrideIterator.h

    r1088 r1125  
    3939
    4040  /**
    41      StrideIterator is weighted if underlying iterator is weighted.
     41     Specialization for StrideIterator that calls underlying iterator.
    4242   */
    4343  template <typename Iter>
    4444  struct weighted_iterator_traits<StrideIterator<Iter> > {
     45    /**
     46       StrideIterator is weighted if underlying iterator is weighted.
     47    */
    4548    typedef typename weighted_iterator_traits<Iter>::type type;
    4649  };
    4750
     51  /**
     52     Specialization for StrideIterator using iterator_traits with base()
     53   */
    4854  template <class Iter>
    4955  struct iterator_traits<StrideIterator<Iter> > {
    … …  
    5258    */
    5359    double data(StrideIterator<Iter> iter) const
    54     { iterator_traits<Iter> jojo;
    55       return jojo.data(iter.base()); }
     60    { return iterator_traits<Iter>().data(iter.base()); }
    5661
    5762    /**
    … …  
    8085  {
    8186  public:
     87    /// type of underlying iterator
    8288    typedef Iter iterator_type;
     89    /// value type
    8390    typedef typename std::iterator_traits<Iter>::value_type value_type;
     91    /// difference type
    8492    typedef typename std::iterator_traits<Iter>::difference_type difference_type;
     93    /// reference
    8594    typedef typename std::iterator_traits<Iter>::reference reference;
     95    /// pointer
    8696    typedef typename std::iterator_traits<Iter>::pointer pointer;
     97    /// weighted_iterator_tag if iterator is weighted
    8798    typedef typename yat::utility::weighted_iterator_traits<Iter>::type w_type;
    8899
    … …  
    95106   
    96107    /**
    97      */
    98     // Peter, this is ugly hack to provide iteartor to const_iterator
     108       Conversion from mutable iterator to const iterator. Only works
     109       if underlying iterator is a pointer.
     110     */
     111    // Peter, this is ugly hack to provide iterator to const_iterator
    99112    // for our gsl_iterators - solution? use Boost:iterator_adaptor
    100113    operator StrideIterator<const value_type*>()
    … …  
    118131
    119132    /**
     133       \return pointer
    120134     */
    121135    pointer operator->() const { return &(operator*()); }

  • trunk/yat/utility/VectorBase.h

    r1120 r1125  
    119119    const double& operator()(size_t i) const;
    120120    // Peter, remove this one
     121    /// \deprecated
    121122    const double& operator[](size_t i) const;
    122123
    … …  
    153154
    154155  protected:
     156    /// pointer to underlying GSL vector
    155157    const gsl_vector* const_vec_;
    156158
    157159  private:
    158     // copy assignment no allowed
     160    // copy assignment not allowed
    159161    const VectorBase& operator=(const VectorBase&);
    160162  };

  • trunk/yat/utility/VectorConstView.h

    r1121 r1125  
    5050     modified.
    5151
    52      \Note that view vectors do not own the underlying data,
     52     \note that view vectors do not own the underlying data,
    5353     and a view is not valid if the vector/matrix owing the data is
    5454     deallocated.

  • trunk/yat/utility/VectorMutable.h

    r1120 r1125  
    160160    double& operator()(size_t i);
    161161    // Peter, remove this one
     162    /// \deprecated
    162163    double& operator[](size_t i);
    163164    // to allow overload from base class
    … …  
    210211
    211212  protected:
     213    /**
     214       pointer to underlying GSL vector. Should always point to same
     215       gsl_vector as const_vec_ in base class does. This pointer should
     216       by used for mutable operations. Do not use this in const
     217       functions; use const_vec_ inherited from BaseVector.
     218     */
    212219    gsl_vector* vec_;
    213220
    … …  
    227234    struct proxy
    228235    {
     236      /// pointer to GSL vector keeping everything we need to create a
     237      /// new VectorMutable from a proxy.
    229238      gsl_vector* vec_;
    230239    };
    … …  
    247256
    248257  /**
    249      Sort the elements in the VectorMutable.
     258     Sort the elements in the VectorMutable \a vec
    250259  */
    251   void sort(VectorMutable&);
     260  void sort(VectorMutable& vec);
    252261
    253262}}} // of namespace utility, yat, and theplu

  • trunk/yat/utility/iterator_traits.h

    r1115 r1125  
    4444
    4545  /**
    46       All iterators default to unweighted type
     46      All iterators default to unweighted type. If you want your
     47      iterator to behave as weighted, you need to provide a
     48      specialization.
    4749
    4850      \see Iterator and StrideIterator
    … …  
    5052  template <class T>
    5153  struct weighted_iterator_traits {
     54  /**
     55      All iterators default to unweighted type
     56  */
    5257    typedef unweighted_iterator_tag type;
    5358  };
    … …  
    6065  template <class T1, class T2>
    6166  struct unweighted_type_and {
     67    /**
     68       default return weighted_iterator_tag
     69     */
    6270    typedef weighted_iterator_tag type;
    6371  };
    … …  
    6977  template <>
    7078  struct unweighted_type_and<unweighted_iterator_tag, unweighted_iterator_tag> {
     79    /**
     80       return unweighted_iterator_tag
     81     */
    7182    typedef unweighted_iterator_tag type;
    7283  };
    … …  
    7990  template <class T1, class T2>
    8091  struct weighted_if_any2 {
     92  private:
    8193    typedef typename weighted_iterator_traits<T1>::type w_type1;
    8294    typedef typename weighted_iterator_traits<T2>::type w_type2;
     95  public:
     96    /// return unweighted if both are unweighted
    8397    typedef typename unweighted_type_and<w_type1, w_type2>::type type;
    8498  };
    … …  
    89103  template <class T1, class T2, class T3>
    90104  struct weighted_if_any3 {
     105  private:
    91106    typedef typename weighted_if_any2<T1, T2>::type tmp;
    92107    typedef typename weighted_iterator_traits<T3>::type w_type3;
     108  public:
     109    /// return unweighted if all are unweighted
    93110    typedef typename unweighted_type_and<tmp, w_type3>::type type;
    94111  };
Note: See TracChangeset for help on using the changeset viewer.