[Math] Merge TDataPoint*.h and TDataPoint*.icc files

There is no need to split up this short header file in two pieces.

Inlining the function definitions makes the code easier to change and
need less boilerplate code related to templates.

Author: guitargeek

math/mathcore/inc/Math/TDataPoint.h

@@ -13,58 +13,118 @@
 #ifndef ROOT_Math_TDataPoint
 #define ROOT_Math_TDataPoint
 
-//ROOT include(s)
+// ROOT include(s)
 #include "RtypesCore.h"
 
+#include <cassert>
+#include <math.h>
 
-namespace ROOT
-{
-namespace Math
-{
+/// \brief class representing a data point
+///
+/// This class can be used for describing data points in a high-dimensional space.
+/// The (positive) dimension is specified by the first template parameter. The second
+/// template parameter can be used to tweak the precision of the stored coordinates. By
+/// default all coordinates are stored with 4 byte float precision. In addition to the
+/// coordinates a weight can be assigned to each data point allowing the representation
+/// of fields in high dimensions.
+/// Basic functionality for accessing/modifying the coordinates/weight are provided
+/// as well as a comparison method and the basic euclidean metric.
 
+namespace ROOT {
+namespace Math {
 
-template<unsigned int K,typename _val_type = float>
-class TDataPoint
-{
+template <unsigned int K, typename _val_type = float>
+class TDataPoint {
 public:
    typedef _val_type value_type;
    enum {
-      kDimension = K //the dimensionality of this data point
+      kDimension = K // the dimensionality of this data point
    };
-   static UInt_t Dimension() {return kDimension;}
-   TDataPoint();
-#ifndef __MAKECINT__
-   template<typename _coord_typ>
-   TDataPoint(const _coord_typ* pData,_val_type fWeight = 1);
-#endif
-   //virtual ~TDataPoint() {}
+   static UInt_t Dimension() { return kDimension; }
+   /// standard constructor
+   /// sets the weight to 1 and initialises all coordinates with 0
+   TDataPoint()
+   {
+      // at least one dimension
+      assert(kDimension > 0);
+
+      for (UInt_t k = 0; k < K; ++k)
+         m_vCoordinates[k] = 0;
+   }
 #ifndef __MAKECINT__
-   template<typename _val>
-   value_type   Distance(const TDataPoint<K,_val>& rPoint) const;
+   /// constructor initialising the data point from an array
+   ///
+   /// Input: pData   - array with kDimension coordinates
+   ///        fWeight - weight (default = 1)
+   template <typename _coord_typ>
+   TDataPoint(const _coord_typ *pData, _val_type fWeight = 1)
+   {
+      // at least one dimension
+      assert(kDimension > 0);
+      // fill coordinates
+      for (unsigned int i = 0; i < kDimension; ++i)
+         m_vCoordinates[i] = pData[i];
+   }
+   /// euclidean distance
+   ///
+   /// returns the euclidean distance to the given data point
+   ///
+   /// Input: rPoint - data point of same dimensionality
+   template <typename _val>
+   value_type Distance(const TDataPoint<K, _val> &rPoint) const
+   {
+      _val_type fDist2 = 0;
+      for (unsigned int i = 0; i < kDimension; ++i)
+         fDist2 += pow(GetCoordinate(i) - rPoint.GetCoordinate(i), 2);
+
+      return sqrt(fDist2);
+   }
 #endif
-   value_type   GetCoordinate(unsigned int iAxis) const;
-   value_type   GetWeight() const {return m_fWeight;}
-   Bool_t       Less(TDataPoint& rPoint,unsigned int iAxis) const;
-   void         SetCoordinate(unsigned int iAxis,_val_type fValue);
-   void         SetWeight(float fWeight) {m_fWeight = fWeight;}
+   /// returns the coordinate at the given axis
+   ///
+   /// Input: iAxis - axis in the range of [0...kDimension-1]
+   value_type GetCoordinate(unsigned int iAxis) const
+   {
+      assert(iAxis < kDimension);
+      return m_vCoordinates[iAxis];
+   }
+   value_type GetWeight() const { return m_fWeight; }
+   /// compares two points at a given axis
+   ///
+   ///  returns: this_point.at(iAxis) < rPoint.at(iAxis)
+   ///
+   /// Input: rPoint - second point to compare to (of same dimensionality)
+   ///        iAxis  - axis in the range of [0...kDimension-1]
+   Bool_t Less(TDataPoint &rPoint, unsigned int iAxis) const
+   {
+      assert(iAxis < kDimension);
+      return (m_vCoordinates[iAxis] < rPoint.GetCoordinate(iAxis));
+   }
+   /// sets the coordinate along one axis
+   ///
+   /// Input: iAxis  - axis in the range of [0...kDimension-1]
+   ///        fValue - new coordinate
+   void SetCoordinate(unsigned int iAxis, _val_type fValue)
+   {
+      assert(iAxis < kDimension);
+      m_vCoordinates[iAxis] = fValue;
+   }
+   void SetWeight(float fWeight) { m_fWeight = fWeight; }
 
 private:
-   value_type   m_vCoordinates[K]; ///< coordinates
-   value_type   m_fWeight;         ///< weight at this point
+   value_type m_vCoordinates[K]; ///< coordinates
+   value_type m_fWeight = 1;     ///< weight at this point
 };
 
 // some typedef definitions
-typedef TDataPoint<1,Float_t>  TDataPoint1F;
-typedef TDataPoint<2,Float_t>  TDataPoint2F;
-typedef TDataPoint<3,Float_t>  TDataPoint3F;
-typedef TDataPoint<1,Double_t> TDataPoint1D;
-typedef TDataPoint<2,Double_t> TDataPoint2D;
-typedef TDataPoint<3,Double_t> TDataPoint3D;
-
-}//namespace Math
-}//namespace ROOT
-
-#include "Math/TDataPoint.icc"
+typedef TDataPoint<1, Float_t> TDataPoint1F;
+typedef TDataPoint<2, Float_t> TDataPoint2F;
+typedef TDataPoint<3, Float_t> TDataPoint3F;
+typedef TDataPoint<1, Double_t> TDataPoint1D;
+typedef TDataPoint<2, Double_t> TDataPoint2D;
+typedef TDataPoint<3, Double_t> TDataPoint3D;
 
+} // namespace Math
+} // namespace ROOT
 
 #endif // ROOT_Math_TDataPoint

math/mathcore/inc/Math/TDataPointN.h

@@ -10,65 +10,90 @@
 // Header file for TDataPointN class
 //
 
-
 #ifndef ROOT_Math_TDataPointN
 #define ROOT_Math_TDataPointN
 
-//STL include(s)
+// STL include(s)
 #include <cassert>
 
-//ROOT include(s)
+// ROOT include(s)
 #include "RtypesCore.h"
 
-namespace ROOT
-{
-namespace Math
-{
-
+namespace ROOT {
+namespace Math {
 
-template<typename _val_type = float>
-class TDataPointN
-{
+template <typename _val_type = float>
+class TDataPointN {
 private:
    static UInt_t kDimension;
 
 public:
    typedef _val_type value_type;
 
-   static UInt_t Dimension() {return kDimension;}
-   static void SetDimension(UInt_t dim) {assert(dim>0);kDimension=dim;}
-
-   TDataPointN();
+   static UInt_t Dimension() { return kDimension; }
+   static void SetDimension(UInt_t dim)
+   {
+      assert(dim > 0);
+      kDimension = dim;
+   }
+
+   TDataPointN()
+   {
+      m_vCoordinates = new _val_type[kDimension];
+      for (UInt_t k = 0; k < kDimension; ++k)
+         m_vCoordinates[k] = 0;
+   }
 #ifndef __MAKECINT__
-   template<typename _coord_typ>
-   TDataPointN(const _coord_typ* pData,value_type fWeight = 1);
-   template<typename _val>
-   TDataPointN(const TDataPointN<_val>&);
+   template <typename _coord_typ>
+   TDataPointN(const _coord_typ *pData, value_type fWeight = 1)
+   {
+      // fill coordinates
+      m_vCoordinates = new _val_type[kDimension];
+      for (unsigned int i = 0; i < kDimension; ++i)
+         m_vCoordinates[i] = pData[i];
+   }
+   TDataPointN(TDataPointN const &) = delete;
 #endif
-   virtual ~TDataPointN();
+   virtual ~TDataPointN() { delete[] m_vCoordinates; }
 
 #ifndef __MAKECINT__
-   template<typename _val>
-   _val_type   Distance(const TDataPointN<_val>& rPoint) const;
+   template <typename _val>
+   _val_type Distance(const TDataPointN<_val> &rPoint) const
+   {
+      _val_type fDist2 = 0;
+      for (unsigned int i = 0; i < kDimension; ++i)
+         fDist2 += pow(GetCoordinate(i) - rPoint.GetCoordinate(i), 2);
+
+      return sqrt(fDist2);
+   }
 #endif
-   _val_type   GetCoordinate(unsigned int iAxis) const;
-   _val_type   GetWeight() const {return m_fWeight;}
-   bool        Less(TDataPointN& rPoint,unsigned int iAxis) const;
-   void        SetCoordinate(unsigned int iAxis,value_type fValue);
-   void        SetWeight(float fWeight) {m_fWeight = fWeight;}
+   _val_type GetCoordinate(unsigned int iAxis) const
+   {
+      assert(iAxis < kDimension);
+      return m_vCoordinates[iAxis];
+   }
+   _val_type GetWeight() const { return m_fWeight; }
+   bool Less(TDataPointN &rPoint, unsigned int iAxis) const
+   {
+      assert(iAxis < kDimension);
+      return (m_vCoordinates[iAxis] < rPoint.GetCoordinate(iAxis));
+   }
+   void SetCoordinate(unsigned int iAxis, value_type fValue)
+   {
+      assert(iAxis < kDimension);
+      m_vCoordinates[iAxis] = fValue;
+   }
+   void SetWeight(float fWeight) { m_fWeight = fWeight; }
 
 private:
-   value_type*   m_vCoordinates;
-   value_type    m_fWeight;
+   value_type *m_vCoordinates = nullptr;
+   value_type m_fWeight = 1;
 };
 
 template <typename _val_type>
 UInt_t TDataPointN<_val_type>::kDimension = 0;
 
-}//namespace Math
-}//namespace ROOT
-
-
-#include "TDataPointN.icc"
+} // namespace Math
+} // namespace ROOT
 
 #endif // ROOT_Math_TDataPointN