# Changeset 597

Ignore:
Timestamp:
Aug 28, 2006, 3:03:54 PM (16 years ago)
Message:

Fixed comments so they pass without some of the complaits from doxygen. Have not looked at the actual contents of comments

Location:
trunk/c++_tools
Files:
16 edited

Unmodified
Removed
• ## trunk/c++_tools/classifier/ConsensusInputRanker.h

 r592 namespace theplu { class statistics::Score; namespace classifier { /// sub-sets of the data, or the different lists could be different /// because they have are generated using different criteria. Having /// \f$N\f$ lists means each row in the data matrix has \f$N\f$ /// \f$N \f$ lists means each row in the data matrix has \f$N \f$ /// ranks (each corresponding to one list) and a consensus ranked /// list is created by sorting the data rows with respect to their public: /// /// @brief Default constructor #endif é
• ## trunk/c++_tools/classifier/Kernel.h

 r592 ///  @brief Abstract Base Class for Kernels. /// ///  Class taking care of the \f$NxN\f$ kernel matrix, where \f$N\f$ ///  Class taking care of the \f$NxN \f$ kernel matrix, where \f$N \f$ ///  is number of samples. Each element in the Kernel corresponds is ///  the scalar product of the corresponding pair of samples. At the /// /// Calculates the scalar product (using the KernelFunction) /// between vector @a vec and the \f$i\f$th column in the data /// between vector @a vec and the \f$i \f$ th column in the data /// matrix. /// /// /// Calculates the weighted scalar product (using the /// KernelFunction) between vector @a vec and the \f$i\f$th column /// KernelFunction) between vector @a vec and the \f$i \f$ th column /// in the data matrix. Using a weight vector with all elements /// equal to unity yields same result as the non-weighted version
• ## trunk/c++_tools/classifier/KernelLookup.h

 r592 /// /// Creating a Lookup into parts of the Kernel. In the created /// Lookup the element in the \f$i\f$th row in the \f$j\f$th /// Lookup the element in the \f$i \f$ th row in the \f$j \f$ th /// column is identical to the element in row row[i] and columns /// column[j] in the underlying @a kernel. If @a owner is set to /// Contructor building a sub-KernelLookup from a KernelLookup /// defined by row index vector and column index vector. In the /// created Lookup the element in the \f$i\f$th row in the /// \f$j\f$th column is identical to the element in row row[i] and /// created Lookup the element in the \f$i \f$ th row in the /// \f$j \f$ th column is identical to the element in row row[i] and /// columns column[j] in the copied @a kl. The resulting /// KernelLookup is independent of the old KernelLookup, but is /// Function to calculate a new Kernel element using the /// underlying KernelFunction. The value is calulated between @a /// vec and the data vector of the \f$i\f$th sample, in other /// words, the sample corresponding to the \f$i\f$th row or /// \f$i\f$th column. In case KernelLookup is a sub-Kernel and not /// vec and the data vector of the \f$i \f$ th sample, in other /// words, the sample corresponding to the \f$i \f$ th row or /// \f$i \f$ th column. In case KernelLookup is a sub-Kernel and not /// symmetric, the kernel value is calculated between @a vec and /// the data vector corresponding to \f$i\f$th row. /// the data vector corresponding to \f$i \f$ th row. /// inline double element(const DataLookup1D& vec, const size_t i) const
• ## trunk/c++_tools/classifier/KernelWeighted_MEV.h

 r592 /// /// @brief Memory Efficient Kernel Class taking care of the /// \f$NxN\f$ kernel matrix, where \f$N\f$ is number of /// \f$NxN \f$ kernel matrix, where \f$N \f$ is number of /// samples. Type of Kernel is defined by a KernelFunction. This /// Memory Efficient Version (MEV) does not store the kernel matrix /// /// Calculates the scalar product using the weighted /// KernelFunction between data vector @a vec and column \f$i\f$ /// KernelFunction between data vector @a vec and column \f$i \f$ /// in data matrix. For @a vec a vector of unity weights is used. /// /// /// Calculates the scalar product using the weighted /// KernelFunction between data vector @a vec and column \f$i\f$ /// KernelFunction between data vector @a vec and column \f$i \f$ /// in data matrix. For @a vec a vector of unity weights is used. ///
• ## trunk/c++_tools/classifier/KernelWeighted_SEV.h

 r592 ///   @brief Weighted Speed Efficient Kernel /// ///   Class taking care of the \f$NxN\f$ kernel matrix, where ///   \f$N\f$ is number of samples. Type of Kernel is defined by a ///   Class taking care of the \f$NxN \f$ kernel matrix, where ///   \f$N \f$ is number of samples. Type of Kernel is defined by a ///   KernelFunction. This Speed Efficient Version (SEV) calculates ///   the kernel matrix once and the kernel is stored in ///   to a zero weight, which means they will be ignored during all ///   calculations. See KernelFunction for further details on ///   weighted calculations of the Kernel. When \f$N\f$ is large and ///   weighted calculations of the Kernel. When \f$N \f$ is large and ///   the kernel matrix cannot be stored in memory, use ///   KernelWeighted_MEV instead. /// /// Calculates the scalar product using the weighted /// KernelFunction between data vector @a vec and column \f$i\f$ /// KernelFunction between data vector @a vec and column \f$i \f$ /// in data matrix. For @a vec a vector of unity weights is used. /// /// /// Calculates the scalar product using the weighted /// KernelFunction between data vector @a vec and column \f$i\f$ /// KernelFunction between data vector @a vec and column \f$i \f$ /// in data matrix. For @a vec a vector of unity weights is used. ///
• ## trunk/c++_tools/classifier/Kernel_MEV.h

 r592 /// /// @brief Memory Efficient Kernel Class taking care of the ///   \f$NxN\f$ kernel matrix, where \f$N\f$ is number of ///   \f$NxN \f$ kernel matrix, where \f$N \f$ is number of ///   samples. Type of Kernel is defined by a KernelFunction. This ///   Memory Efficient Version (MEV) does not store the kernel /// /// Calculates the scalar product using the KernelFunction between /// data vector @a vec and column \f$i\f$ in data matrix. /// data vector @a vec and column \f$i \f$ in data matrix. /// /// @return kernel element between data @a vec and training sample @a i /// /// Using the KernelFunction this function calculates the scalar /// product between vector @a vec and the column \f$i\f$ in data /// product between vector @a vec and the column \f$i \f$ in data /// matrix. The KernelFunction expects a weight vector for each of /// the two data vectors and as this Kernel is non-weighted each
• ## trunk/c++_tools/classifier/Kernel_SEV.h

 r592 /// ///   @brief Speed Efficient Kernel ///   Class taking care of the \f$NxN\f$ kernel matrix, where ///   \f$N\f$ is number of samples. Type of Kernel is defined by a ///   Class taking care of the \f$NxN \f$ kernel matrix, where ///   \f$N \f$ is number of samples. Type of Kernel is defined by a ///   KernelFunction. This Speed Efficient Version (SEV) calculated ///   the kernel matrix once by construction and the kernel is stored in ///   memory. When \f$N\f$ is large and the kernel matrix cannot be ///   memory. When \f$N \f$ is large and the kernel matrix cannot be ///   stored in memory, use Kernel_MEV instead. /// /// /// Calculates the scalar product using the KernelFunction between /// data vector @a vec and column \f$i\f$ in data matrix. /// data vector @a vec and column \f$i \f$ in data matrix. /// /// @return kernel element between data @a vec and training sample @a i /// /// Using the KernelFunction this function calculates the scalar /// product between vector @a vec and the column \f$i\f$ in data /// product between vector @a vec and the column \f$i \f$ in data /// matrix. The KernelFunction expects a weight vector for each of /// the two data vectors and as this Kernel is non-weighted each
• ## trunk/c++_tools/classifier/MatrixLookupWeighted.h

 r596 /// /// A MatrixLookupWeighted is very similar to a MatrixLookup, but /// contains a pointer to a weight matrix as well meeaning each data /// contains a pointer to a weight matrix as well meaning each data /// element is associated to weight. /// /// A MatrixLookupWeighted can be created directly from a matrix or from an /// other MatrixLookupWeighted. In the latter case, the resulting /// MatrixLookupWeighted is looking directly into the underlying matrix to /// avoid multiple lookups. /// A MatrixLookupWeighted can be created directly from a matrix or /// from an other MatrixLookupWeighted. In the latter case, the /// resulting MatrixLookupWeighted is looking directly into the /// underlying matrix to avoid multiple lookups. /// /// There is a possibility to set the MatrixLookupWeighted as owner /// /// @todo add on weight part /// class MatrixLookupWeighted : public DataLookup2D { const MatrixLookupWeighted* validation_data(const std::vector&, const std::vector&) const; /// /// Access operator /// /// @return weight * data for element \f$i j\f$ /// @return weight * data for element \f$i j\f$ /// inline double operator()(const size_t row, const size_t column) const /// /// The output operator MatrixLookupWeighted /// The output operator MatrixLookupWeighted /// std::ostream& operator<< (std::ostream& s, const MatrixLookupWeighted&);

• ## trunk/c++_tools/statistics/AveragerPair.h

 r593 /// /// \f$\frac{\sum_i (x_i-m_x)(y_i-m_y)}{\sum_i /// (x_i-m_x)^2+\sum_i (y_i-m_y)^2 + n(m_x-m_y)^2}\f$ /// \f$\frac{\sum_i (x_i-m_x)(y_i-m_y)}{\sum_i /// (x_i-m_x)^2+\sum_i (y_i-m_y)^2 + n(m_x-m_y)^2} \f$ /// /// In case of a zero denominator - zero is returned. /// /// \f$\frac{\sum_i (x_i-m_x)(y_i-m_y)}{\sqrt{\sum_i /// (x_i-m_x)^2\sum_i (y_i-m_y)^2}}\f$ /// \f$\frac{\sum_i (x_i-m_x)(y_i-m_y)}{\sqrt{\sum_i /// (x_i-m_x)^2\sum_i (y_i-m_y)^2}} \f$ /// /// @return Pearson correlation coefficient. /// /// Calculating covariance using /// \f$\frac{1}{N}\sum_i (x_i-m_x)(y_i-m_y)\f$, /// where \f$m\f$ is the mean. /// \f$\frac{1}{N}\sum_i (x_i-m_x)(y_i-m_y) \f$, /// where \f$m \f$ is the mean. /// /// @return The covariance. /// /// @return \f$\sum_i (x_i-m_x)(y_i-m_y)\f$ /// @return \f$\sum_i (x_i-m_x)(y_i-m_y) \f$ /// inline double sum_xy_centered(void) const {return xy_-x_.sum_x()*y_.mean();}
• ## trunk/c++_tools/statistics/Pearson.h

 r475 /// /// \f$\frac{\vert \sum_i(x_i-\bar{x})(y_i-\bar{y})\vert /// }{\sqrt{\sum_i (x_i-\bar{x})^2\sum_i (x_i-\bar{x})^2}}\f$. /// }{\sqrt{\sum_i (x_i-\bar{x})^2\sum_i (x_i-\bar{x})^2}} \f$. /// @return Pearson correlation, if absolute=true absolute value /// of Pearson is used. /// /// \f$ \frac{\vert \sum_iw^2_i(x_i-\bar{x})(y_i-\bar{y})\vert } /// {\sqrt{\sum_iw^2_i(x_i-\bar{x})^2\sum_iw^2_i(y_i-\bar{y})^2}}\f$, /// where \f$m_x = \frac{\sum w_ix_i}{\sum w_i}\f$and \f$m_x = /// \frac{\sum w_ix_i}{\sum w_i}\f$. This expression is chosen to /// get a correlation equal to unity when \a x and \a y are /// equal. @return absolute value of weighted version of Pearson /// correlation. /// {\sqrt{\sum_iw^2_i(x_i-\bar{x})^2\sum_iw^2_i(y_i-\bar{y})^2}} /// \f$, where \f$m_x = \frac{\sum w_ix_i}{\sum w_i} \f$ and \f$/// m_x = \frac{\sum w_ix_i}{\sum w_i} \f$. This expression is /// chosen to get a correlation equal to unity when \a x and \a y /// are equal. @return absolute value of weighted version of /// Pearson correlation. /// double score(const classifier::Target& target,

 r589 /// mean, \f$n \f$ is the number of data points and \f$s^2 = /// \frac{ \sum_i (x_i-m_x)^2 + \sum_i (y_i-m_y)^2 }{ n_x + n_y - /// 2 } /// 2 } \f$ /// /// @return t-score if absolute=true absolute value of t-score /// Calculates the weighted t-score, i.e. the ratio between /// difference in mean and standard deviation of this /// difference. \f$t = \frac{ m_x - m_y } { /// \frac{s2}{n_x}+\frac{s2}{n_y} \f$ where \f$m \f$ is the /// difference. \f$t = \frac{ m_x - m_y }{ /// \frac{s2}{n_x}+\frac{s2}{n_y}} \f$ where \f$m \f$ is the /// weighted mean, n is the weighted version of number of data /// points and \f$s2 \f$ is an estimation of the variance \f$s^2 • ## trunk/c++_tools/utility/SVD.h  r420 /// /// Solve the system \f$Ax=b\f$using the decomposition of A. /// Solve the system \f$ Ax=b \f\$ using the decomposition of A. /// /// @note If decompose() has not been run the outcome of the call
Note: See TracChangeset for help on using the changeset viewer.