OrderedPointND.hh

Go to the documentation of this file.

#ifndef NPSTAT_ORDEREDPOINTND_HH_
#define NPSTAT_ORDEREDPOINTND_HH_
 
/*!
// \file OrderedPointND.hh
//
// \brief Multidimensional points which can be sorted according to
//        multiple sorting criteria
//
// Author: I. Volobouev
//
// September 2010
*/
 
#include <vector>
 
#include "npstat/nm/PointDimensionality.hh"
 
namespace npstat {
    template <typename Point> class OrderedPointND;
 
    template <typename Point>
    bool operator==(const OrderedPointND<Point>& l,
                    const OrderedPointND<Point>& r);
 
    template <typename Point>
    bool operator!=(const OrderedPointND<Point>& l,
                    const OrderedPointND<Point>& r);
 
    /**
    // Multivariate point which can remember its sequence number according to
    // multiple sorting criteria. These points can be used, for example, to
    // build composite distributions (i.e., modeled by copula and marginals).
    //
    // Template parameter class Point must be subscriptable. It must also
    // publish "value_type" typedef (std::array is a good candidate).
    */
    template <class Point>
    class OrderedPointND
    {
    public:
        typedef typename Point::value_type value_type;
        enum {dim_size = PointDimensionality<Point>::dim_size};
 
        /** Default constructor will invoke the default Point constructor */
        OrderedPointND();
 
        /** Constructor from the underlying point */
        OrderedPointND(const Point& point);
 
        /** Costructor from a data array for the underlying point */
        template <typename Num2>
        OrderedPointND(const Num2* data, unsigned dataLen);
 
        /**
        // Costructor from a flat data array and a set of indices
        // into this array
        */
        template <typename Num2>
        OrderedPointND(const Num2* data, const unsigned* indices,
                       unsigned lenIndices);
 
        /**
        // Constructor from the underlying point and its numbers in
        // several sorted sequences
        */
        OrderedPointND(const Point& point, const unsigned long *number,
                       unsigned lenNumber);
        //@{
        /** Examine object properties */
        inline const Point& point() const {return point_;}
        inline const value_type* coords() const {return &point_[0];}
        inline const unsigned long* number() const {return number_;}
        inline unsigned dim() const {return dim_size;}
        inline unsigned size() const {return dim_size;}
        //@}
 
        /** Non-const subscripting */
        inline value_type& operator[](unsigned i) {return point_[i];}
 
        /** Const subscripting */
        inline const value_type& operator[](unsigned i) const
            {return point_[i];}
 
        /** Set point number according to sorting criterion i */
        void setNumber(unsigned i, unsigned long value);
 
        /** Get point number according to sorting criterion i */
        unsigned long getNumber(unsigned i) const;
 
        friend bool operator==<>(const OrderedPointND&, const OrderedPointND&);
        friend bool operator!=<>(const OrderedPointND&, const OrderedPointND&);
 
    private:
        void clearNumber();
 
        Point point_;
        unsigned long number_[dim_size];
    };
 
    /**
    // Fill a vector of ordered points using unordered points
    // (but do not order them yet). Note that the output vector
    // is _not_ cleared before filling. Class Point1 should be
    // subscriptable.
    //
    // Parameters "dimsToUse" and "nDimsToUse" specify how
    // dimensions of Point2 should be constructed out of
    // those in Point1.
    */
    template <class Point1, class Point2>
    void fillOrderedPoints(const std::vector<Point1>& data,
                           const unsigned* dimsToUse, unsigned nDimsToUse,
                           std::vector<OrderedPointND<Point2> >* out);
 
    /**
    // Fill a vector of ordered points using flat data.
    // Flat data is divided into chunks "stride" elements
    // long. Then numbers are picked up from these chunks
    // according to "dimsToUse" and "nDimsToUse" arguments.
    */
    template <typename Num2, class Point>
    void fillOrderedFromFlat(const std::vector<Num2>& data, unsigned stride,
                             const unsigned* dimsToUse, unsigned nDimsToUse,
                             std::vector<OrderedPointND<Point> >* out);
 
    /** Fill a vector of points using flat data */
    template <typename Num2, class Point>
    void fillPointsFromFlat(const std::vector<Num2>& data, unsigned stride,
                            const unsigned* dimsToUse, unsigned nDimsToUse,
                            std::vector<Point>* out);
 
    /** Fill a flat vector from another flat vector */
    template <typename Num1, typename Num2>
    void fillFlatFromFlat(const std::vector<Num1>& data, unsigned stride,
                          const unsigned* dimsToUse, unsigned nDimsToUse,
                          std::vector<Num2>* out);
 
#ifdef SWIG
    template <class Point>
    inline std::vector<OrderedPointND<Point> >*
    makeOrderedPoints(const std::vector<Point>& data)
    {
        std::vector<OrderedPointND<Point> >* opoints =
            new std::vector<OrderedPointND<Point> >();
        const unsigned long sz = data.size();
        opoints->reserve(sz);
        for (unsigned long i=0; i<sz; ++i)
            opoints->emplace_back(data[i]);
        return opoints;
    }
 
    template <typename Num2, class Point>
    inline std::vector<OrderedPointND<Point> >*
    makeOrderedFromFlat(const std::vector<Num2>& data, unsigned stride,
                        const unsigned* dimsToUse, unsigned nDimsToUse)
    {
        std::vector<OrderedPointND<Point> >* result =
            new std::vector<OrderedPointND<Point> >();
        fillOrderedFromFlat(data, stride, dimsToUse, nDimsToUse, result);
        return result;
    }
 
    template <typename Num2, class Point>
    inline std::vector<Point>*
    makePointsFromFlat(const std::vector<Num2>& data, unsigned stride,
                       const unsigned* dimsToUse, unsigned nDimsToUse)
    {
        std::vector<Point>* result = new std::vector<Point>();
        fillPointsFromFlat(data, stride, dimsToUse, nDimsToUse, result);
        return result;
    }
 
    template <class Vec>
    inline Vec*
    makeFlatFromFlat(const Vec& data, unsigned stride,
                     const unsigned* dimsToUse, unsigned nDimsToUse)
    {
        Vec* result = new Vec();
        fillFlatFromFlat(data, stride, dimsToUse, nDimsToUse, result);
        return result;
    }
#endif // SWIG
}
 
#include "npstat/stat/OrderedPointND.icc"
 
#endif // NPSTAT_ORDEREDPOINTND_HH_