Index: /trunk/yat/classifier/Kernel.h
===================================================================
 /trunk/yat/classifier/Kernel.h (revision 748)
+++ /trunk/yat/classifier/Kernel.h (revision 749)
@@ 38,34 +38,35 @@
class MatrixLookupWeighted;
 ///
+ ///
/// @brief Abstract Base Class for Kernels.
///
/// 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
+ /// is number of samples. Each element in the Kernel corresponds to
/// the scalar product of the corresponding pair of samples. At the
/// time being there are two kinds of kernels. Kernel_SEV that is
/// optimized to be fast and Kernel_MEV that is preferable when
/// dealing with many samples and memory might be a
 /// bottleneck. Also there are the corresponding weighted versions
 /// to deal with weights (including missing values). A
+ /// bottleneck. A
/// KernelFunction defines what kind of scalar product the Kernel
/// represents, e.g. a Polynomial Kernel of degree 1 means we are
/// dealing with the ordinary linear scalar product.
///
 /// @note If the KernelFunction is destroyed, the Kernel is no
 /// longer defined.
 ///
 class Kernel
 {

 public:
+ /// @note If the KernelFunction is destroyed, the Kernel is no
+ /// longer defined.
+ ///
+ class Kernel
+ {
+
+ public:
///
 /// Constructor taking the @a data matrix and KernelFunction as
 /// input. Each column in the data matrix corresponds to one
 /// sample and the Kernel matrix is built applying the
 /// KernelFunction on each pair of columns in the data matrix.
+ /// Constructor taking the @a data matrix and KernelFunction as
+ /// input. Each column in the data matrix corresponds to one
+ /// sample and the Kernel matrix is built applying the
+ /// KernelFunction on each pair of columns in the data matrix.
+ /// If @a own is set to true, Kernel is owner of underlying data.
///
 /// @note Can not handle NaNs.
+ /// @note Can not handle NaNs. To deal with missing values use
+ /// constructor taking MatrixLookupWeighted.
///
Kernel(const MatrixLookup& data, const KernelFunction& kf,
@@ 73,11 +74,10 @@
///
 /// Constructor taking the @a data matrix (with weights) and
 /// KernelFunction as
 /// input. Each column in the data matrix corresponds to one
 /// sample and the Kernel matrix is built applying the
 /// KernelFunction on each pair of columns in the data matrix.
 ///
 /// @note Can not handle NaNs.
+ /// Constructor taking the @a data matrix (with weights) and
+ /// KernelFunction as
+ /// input. Each column in the data matrix corresponds to one
+ /// sample and the Kernel matrix is built applying the
+ /// KernelFunction on each pair of columns in the data matrix.
+ /// If @a own is set to true, Kernel is owner of underlying data.
///
Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf,
@@ 86,12 +86,14 @@
///
/// The new kernel is created using selected features @a
 /// index. Kernel will own its underlying data and delete it in
 /// destructor.
+ /// index. Kernel will own its underlying data
///
Kernel(const Kernel& kernel, const std::vector& index);
 ///
 /// Destructor
 ///
+ ///
+ /// @brief Destructor
+ ///
+ /// If Kernel is owner of underlying data and Kernel is the last
+ /// owner, underlying data is deleted.
+ ///
virtual ~Kernel(void);
@@ 99,5 +101,5 @@
/// @return element at position (\a row, \a column) of the Kernel
/// matrix
 ///
+ ///
virtual double operator()(const size_t row, const size_t column) const=0;
@@ 156,5 +158,5 @@
bool weighted(void) const;
 protected:
+ protected:
/// underlying data
const DataLookup2D* data_;
@@ 165,5 +167,5 @@
///
 /// poiter telling how many owners to underlying data
+ /// pointer telling how many owners to underlying data
/// (data_). NULL if this is not an owner.
///
@@ 171,5 +173,5 @@
///
 /// poiter telling how many owners to underlying weights
+ /// pointer telling how many owners to underlying weights
/// (data_w_). NULL if this is not an owner.
///
@@ 184,5 +186,5 @@
const Kernel& operator=(const Kernel&);
 }; // class Kernel
+ }; // class Kernel
}}} // of namespace classifier, yat, and theplu
Index: /trunk/yat/classifier/Kernel_MEV.h
===================================================================
 /trunk/yat/classifier/Kernel_MEV.h (revision 748)
+++ /trunk/yat/classifier/Kernel_MEV.h (revision 749)
@@ 52,5 +52,5 @@
///
/// Constructor taking the data matrix and KernelFunction as
 /// input.Each column in the data matrix corresponds to one
+ /// input. Each column in the data matrix corresponds to one
/// sample. @note Can not handle NaNs.
///
@@ 61,5 +61,5 @@
///
/// Constructor taking the data matrix and KernelFunction as
 /// input.Each column in the data matrix corresponds to one
+ /// input. Each column in the data matrix corresponds to one
/// sample. @note Can not handle NaNs.
///
Index: /trunk/yat/classifier/Kernel_SEV.h
===================================================================
 /trunk/yat/classifier/Kernel_SEV.h (revision 748)
+++ /trunk/yat/classifier/Kernel_SEV.h (revision 749)
@@ 40,5 +40,5 @@
/// 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
+ /// KernelFunction. This Speed Efficient Version (SEV) calculates
/// 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