Changeset 966


Ignore:
Timestamp:
Oct 11, 2007, 7:01:01 PM (14 years ago)
Author:
Peter
Message:

fixing some doxygen warnings

Location:
trunk/yat
Files:
2 added
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/yat/classifier/DataLookup1D.h

    r882 r966  
    5050  public:
    5151
     52    /// 'Read Only' iterator
    5253    typedef utility::Iterator<const double, const classifier::DataLookup1D>
    5354    const_iterator;
     
    9899
    99100    /**
     101       \return 'Read Only' iterator to first element.
    100102     */
    101103    const_iterator begin() const;
    102104
    103105    /**
     106       \return 'Read Only' iterator to end of DataLookup1D.
    104107     */
    105108    const_iterator end() const;
  • trunk/yat/classifier/DataLookupWeighted1D.h

    r890 r966  
    4747  public:
    4848   
     49    /// 'Read Only' Iterator
    4950    typedef utility::IteratorWeighted<const double, const classifier::DataLookupWeighted1D>
    5051    const_iterator;
     
    7778
    7879    /**
     80       \return 'Read Only' iterator to beginning of DataLookupWeighted1D.
    7981     */
    8082    const_iterator begin() const;
     
    8688   
    8789    /**
     90       \return 'Read Only' iterator to end of DataLookupWeighted1D.
    8891     */
    8992    const_iterator end() const;
  • trunk/yat/classifier/MatrixLookup.h

    r916 r966  
    7575    ///
    7676    /// Constructor creating a lookup into the entire @a matrix.
     77    /// \param matrix underlying matrix
    7778    /// @param own if true MatrixLookup owns its underlying @a matrix
    7879    ///
  • trunk/yat/classifier/SVM.h

    r964 r966  
    8787    /// large C means the training will be focused on getting samples
    8888    /// correctly classified, with risk for overfitting and poor
    89     /// generalisation. A too small C will result in a training where
     89    /// generalisation. A too small C will result in a training in which
    9090    /// misclassifications are not penalized. C is weighted with
    9191    /// respect to the size, so \f$ n_+C_+ = n_-C_- \f$, meaning a
     
    106106    long int max_epochs(void) const;
    107107   
    108     /*
     108    /**
    109109      \brief set maximal number of epochs in training
    110110    */
  • trunk/yat/classifier/SVindex.h

    r865 r966  
    3737namespace classifier { 
    3838
    39 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    40   /// @internal Class keeping track of which samples are support vectors and
     39  ///
     40  /// Internal Class keeping track of which samples are support vectors and
    4141  /// not. The first nof_sv elements in the vector are indices of the
    4242  /// support vectors
     
    4646
    4747  public:
    48     //Default Contructor
     48    ///Default Contructor
    4949    SVindex();
    5050
    51     //
     51    /// Constructor
    5252    SVindex(const size_t);
    5353
    54     // @return index_first
     54    /// @return index_first
    5555    size_t index_first(void) const;
    5656
    57     // @return index_second
     57    /// @return index_second
    5858    size_t index_second(void) const;
    5959
    60     // synch the object against alpha
     60    /// synch the object against alpha
    6161    void init(const utility::vector& alpha, const double);
    6262
    63     // @return nof support vectors
     63    /// @return nof support vectors
    6464    size_t nof_sv(void) const;
    6565
    66     // making first to an nsv. If already sv, nothing happens.
     66    /// making first to an nsv. If already sv, nothing happens.
    6767    void nsv_first(void);
    6868
    69     // making second to an nsv. If already sv, nothing happens.
     69    /// making second to an nsv. If already sv, nothing happens.
    7070    void nsv_second(void);   
    7171
    72     // randomizes the nsv part of vector and sets index_first to
    73     // nof_sv_ (the first nsv)
     72    /// randomizes the nsv part of vector and sets index_first to
     73    /// nof_sv_ (the first nsv)
    7474    void shuffle(void);
    7575
    76     // @return nof samples
     76    /// @return nof samples
    7777    size_t size(void) const;
    7878
    79     // making first to a sv. If already sv, nothing happens.
     79    /// making first to a sv. If already sv, nothing happens.
    8080    void sv_first(void);
    8181
    82     // making second to a sv. If already sv, nothing happens.
     82    /// making second to a sv. If already sv, nothing happens.
    8383    void sv_second(void);
    8484
    85     //
    86     void update_first(const size_t);
     85    /// set index_first to \a i
     86    void update_first(const size_t i);
    8787
    88     //
    89     void update_second(const size_t);
     88    /// set index_second to \a i
     89    void update_second(const size_t i);
    9090
    91     // @return value_first
     91    /// @return value_first
    9292    size_t value_first(void) const;
    9393
    94     // @return const ref value_second
     94    /// @return value_second
    9595    size_t value_second(void) const;
    9696
     97    /// \return index \a i (if i<nof_sv() index is sv)
    9798    size_t operator()(size_t i) const;
    9899
     
    106107   
    107108  };
    108 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
    109109
    110110}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/Sampler.h

    r865 r966  
    4747    ///
    4848    /// @param target used to balance partitions
    49     /// @param Number of partitions
     49    /// @param N Number of partitions
    5050    ///
    5151    Sampler(const Target& target, size_t N);
  • trunk/yat/random/random.h

    r865 r966  
    321321       underlying RNG.
    322322
    323        \throw GSL_error if \an is larger than the range of the
     323       \throw GSL_error if \a n is larger than the range of the
    324324       underlying generator.
    325325    */
  • trunk/yat/statistics/AUC.h

    r865 r966  
    5151  public:
    5252    ///
    53     ///
    54     ///
     53    /// \brief Defaul Constructor
     54    /// \param absolute if true max(AUC, 1-AUC) is used
     55    ///
    5556    AUC(bool absolute=true);
    5657
  • trunk/yat/statistics/SAMScore.h

    r865 r966  
    5757    ///
    5858    /// @param s0 \f$ s_0 \f$ is a fudge factor
     59    /// @param absolute if true max(score, -score) is used
    5960    ///
    6061    SAMScore(const double s0, bool absolute=true);
  • trunk/yat/statistics/Score.h

    r865 r966  
    118118    /// is wanted.
    119119    ///
    120     /// @a value and @weight are copied to utility::vector and the
     120    /// \a value and \a weight are copied to utility::vector and the
    121121    /// corresponding operator is called. If speed is important this
    122122    /// operator should be implemented in inherited class to avoid
  • trunk/yat/statistics/VectorFunction.h

    r865 r966  
    3636  struct VectorFunction
    3737  {
     38    /**
     39       \brief Destructor
     40     */
    3841    virtual ~VectorFunction();
     42
     43    /**
     44       \brief abstract interface
     45     */
    3946    virtual double operator()(const std::vector<double>&) const=0;
    4047  };
     
    8996  };
    9097
    91 
     98  /**
     99     Functor that picks Nth smalles element in a vector.
     100   */
    92101  class Nth_Element : public VectorFunction
    93102  {
  • trunk/yat/statistics/euclidean_vector_distance.h

    r937 r966  
    2323    : public vector_distance_tag
    2424  {
     25    /// \brief tag for euclidean distance
    2526    typedef euclidean_vector_distance_tag distance;
    2627  };
  • trunk/yat/statistics/pearson_vector_distance.h

    r937 r966  
    2222    : public vector_distance_tag
    2323  {
     24    /// \brief tag for pearson distance
    2425    typedef pearson_vector_distance_tag distance;
    2526  };
  • trunk/yat/statistics/tScore.h

    r865 r966  
    8080       2 } \f$
    8181       
     82       \param target Target defining the two groups
     83       \param value Vector with data points on which calculation is based
    8284       @param dof double pointer in which approximation of degrees of
    8385       freedom is returned: pos.n()+neg.n()-2. See AveragerWeighted.
     
    100102       } \f$. See AveragerWeighted for details.
    101103       
     104       \param target Target defining the two groups
     105       \param value Vector with values/weights on which calculation is based
    102106       @param dof double pointer in which approximation of degrees of
    103107       freedom is returned: pos.n()+neg.n()-2. See AveragerWeighted.
     
    154158       + n_y - 2 } \f$. See AveragerWeighted for details.
    155159     
     160       \param target Target defining the two groups
     161       \param value Vector with data values on which calculation is based
     162       \param weight Vector with weight associated to \a value
    156163       @param dof double pointer in which approximation of degrees of
    157164       freedom is returned: pos.n()+neg.n()-2. See AveragerWeighted.
  • trunk/yat/statistics/vector_distance.h

    r958 r966  
    1818  /// For each measure to calculate distances between containers
    1919  /// with random access iterators one should provide a struct
    20   /// which inherits from vector_distance_tag and provides a "label" for
     20  /// that inherits from vector_distance_tag and provides a "label" for
    2121  /// the distance measure.
    2222  ///
    2323  struct vector_distance_tag {
     24    /// tag defining distance measure
    2425    typedef vector_distance_tag distance;
    2526  };
     
    3637  template <class T>
    3738  struct vector_distance_traits {
     39    /// \return distance type
    3840    typedef typename T::distance distance;
    3941  };
  • trunk/yat/utility/Iterator.h

    r936 r966  
    157157       \brief Equality operator
    158158
    159        \return True if \a lhs and \rhs are pointing to same element
     159       \return True if \a lhs and \a rhs are pointing to same element
    160160     */
    161161    friend bool operator==(const Iterator<return_type, Container>& lhs,
     
    166166       \brief Non-equality operator
    167167
    168        \return False if \a lhs and \rhs are pointing to same element
     168       \return False if \a lhs and \a rhs are pointing to same element
    169169     */
    170170    friend bool operator!=(const Iterator<return_type, Container>& lhs,
  • trunk/yat/utility/TypeInfo.h

    r872 r966  
    4747       @brief Constructor
    4848    */
     49    // For convenience we allow implicit conversion from type_info to
     50    // TypeInfo.
    4951    TypeInfo(const std::type_info&);
    5052
    5153    /**
     54       \return stored type_info
    5255     */
    5356    const std::type_info& get(void) const;
  • trunk/yat/utility/iterator_traits.h

    r958 r966  
    3131namespace utility {
    3232
    33   /*
     33  /**
    3434    Struct to be used to make compile-time decision that Iterator is
    3535    unweighted, which is the default.
     
    3939  };
    4040   
    41   /*
     41  /**
    4242    Struct to be used to make compile-time decision that Iterator is
    4343    weighted. Some algorithms come in also in a weighted version in
     
    4949  };
    5050
    51   // All iterators should default to unweighted type ...
     51  /// All iterators should default to unweighted type ...
    5252  template <class T>
    5353  struct weighted_iterator_traits {
     
    5555  };
    5656
    57   // but specialized to return weighted type for some things
     57  /// but specialized to return weighted type for some things
    5858  //
    5959  // if you add a new weighted iterator, add a new specialization like
     
    6666
    6767
    68   /*
     68  /**
    6969    Metafunction that works on a pair weighted-unweighted types and
    7070    return weighted_type. The metafunction is specialized for
     
    7676  };
    7777
    78   /*
     78  /**
    7979    Specialization that sets type to be unweighted when both arguments
    8080    are unweighted
     
    8585  };
    8686
    87   /*
     87  /**
    8888    struct used to determine if a pair of iterators should be treated
    8989    as weighted. If both iterators are unweighted, type is set to
     
    9797  };
    9898
    99   /*
     99  /**
    100100    Same as weighted_iterator_traits2 but for 3 arguments.
    101101   */
     
    107107  };
    108108
    109   // check (at compile time) that iterator is unweighted.
     109  /// check (at compile time) that iterator is unweighted.
    110110  inline void check_iterator_is_unweighted(unweighted_type x){}
     111
     112  /**
     113     check (at compile time) that iterator \a iter is unweighted. This
     114     function is strictly not needed, but exists only for convenience.
     115   */
    111116  template <class Iter>
    112117  void check_iterator_is_unweighted(Iter iter)
     
    116121
    117122
    118   /*
     123  /**
    119124    Function to be used to make compile-time decision how to return
    120125    data from an iterator separating two cases: weighted and
     
    130135                                weighted_iterator_traits<Iter>::type()); }
    131136
     137  /**
     138     \return data for weighted iterator
     139   */
    132140  template <class Iter>
    133141  double iterator_traits_data(Iter i, weighted_type)
    134142  { return i.data(); }
    135143
     144  /**
     145     \return data for unweighted data
     146   */
    136147  template <class Iter>
    137148  double iterator_traits_data(Iter i, unweighted_type)
    138149  { return *i; }
    139150
    140   /*
     151  /**
    141152    Function to be used to make compile-time decision how to return
    142153    data from an iterator separating two cases: weighted and
     
    153164                                  weighted_iterator_traits<Iter>::type()); }
    154165
     166  /**
     167     \return weight for weighted iterator
     168   */
    155169  template <class Iter>
    156170  double iterator_traits_weight(Iter i, weighted_type)
    157171  { return i.weight(); }
    158172
     173  /**
     174     \return weight for unweighted iterator
     175   */
    159176  template <class Iter>
    160177  double iterator_traits_weight(Iter i, unweighted_type)
  • trunk/yat/utility/utility.h

    r917 r966  
    5050  /**
    5151     @return true if string \a s fulfills regular expression \verbatim
    52      ^\w* \endverbatim \a other \verbaim \w*$ \endverbatim (case
     52     ^\w* \endverbatim \a other \verbatim \w*$ \endverbatim (case
    5353     insensitive)
    5454  */
  • trunk/yat/utility/vector.h

    r899 r966  
    8888  public:
    8989
     90    /// \brief vector::iterator
    9091    typedef Iterator<double&, vector> iterator;
     92    /// \brief vector::const_iterator
    9193    typedef Iterator<const double, const vector> const_iterator;
    9294
     
    219221
    220222    /**
     223       \return mutable iterator to start of vector
    221224     */
    222225    iterator begin(void);
    223226
    224227    /**
     228       \return read-only iterator to start of vector
    225229     */
    226230    const_iterator begin(void) const;
     
    243247
    244248    /**
     249       \return mutable iterator to end of vector
    245250     */
    246251    iterator end(void);
    247252
    248253    /**
     254       \return read-only iterator to end of vector
    249255     */
    250256    const_iterator end(void) const;
  • trunk/yat/utility/yat_assert.h

    r936 r966  
    3030namespace utility {
    3131
     32  /**
     33     \brief yat_assert is similar to assert in std.
     34
     35     If YAT_DEBUG is enabled and \a assertion is false, and exception
     36     X is thrown using constructor X(\a msg ).
     37   */
    3238  template<class X> inline void yat_assert(bool assertion, std::string msg="")
    3339#ifdef YAT_DEBUG
Note: See TracChangeset for help on using the changeset viewer.