Generic Algorithms to do grouping

---

Detailed Description

Functions
template<class iterator>
void	TeElemCountingBySlice (iterator begin, iterator end, vector< TeSlice > &result)
	Counts the number of elements, from a general container, per slice of a vector of slices.
template<class iterator>
void	TeGroupByEqualStep (iterator begin, iterator end, int nstep, vector< TeSlice > &result, int precision=0, bool countElements=true)
	Groups a set of elements defined by a range of iterators in nstep groups, using Equal Step algorithm.
template<class iterator>
void	TeGroupByQuantil (iterator begin, iterator end, int nstep, vector< TeSlice > &result, int precision=0, bool countElements=true)
	Groups a set of elements defined by a range of iterators in nstep groups, using Quantil algorithm.
template<class iterator>
void	TeGroupByStdDev (iterator begin, iterator end, double ndev, vector< TeSlice > &result, string &rmean, int precision=0, bool countElements=true)
	Groups a set of elements defined by a range of iterators in ndev groups, using Standanrd deviation algorithm.
TL_DLL void	TeGroupByUniqueValue (vector< string > &vec, TeAttrDataType tipo, vector< TeSlice > &result, int precision)
	Groups a set of elements in a vector of string using Unique Value algorithm.

---

Function Documentation

template<class iterator>

void TeElemCountingBySlice	(	iterator	begin,
		iterator	end,
		vector< TeSlice > &	result
	)			[inline]

Definition at line 249 of file TeGroupingAlgorithms.h.

References TeSlice::count_, TeSlice::from_, and TeSlice::to_.

Referenced by TeQtLegendSource::generateLegends(), TeQtLegendSource::setCell(), TeGroupByEqualStep(), TeGroupByQuantil(), and TeGroupByStdDev().

{
        iterator it;
        double from, to;

        for (unsigned int i = 0; i < result.size(); ++i)
        {
                TeSlice& sl = result[i];
                sl.count_ = 0;
                from = atof(sl.from_.c_str());
                to = atof(sl.to_.c_str());
                for (it = begin; it != end; ++it)
                {
                        if (*it >= from && *it < to)
                                ++sl.count_;
                }
        }
}

template<class iterator>

void TeGroupByEqualStep	(	iterator	begin,
		iterator	end,
		int	nstep,
		vector< TeSlice > &	result,
		int	precision = 0,
		bool	countElements = true
	)			[inline]

Definition at line 94 of file TeGroupingAlgorithms.h.

References TeSlice::count_, TeSlice::from_, MAX, MIN, Te2String(), TeAdjustToPrecision(), TeElemCountingBySlice(), TeMAXFLOAT, and TeSlice::to_.

{
        double  min = TeMAXFLOAT;
        double  max = -TeMAXFLOAT;

        iterator it=begin;
        while(it < end)
        {
                min = MIN(min, *it);
                max = MAX(max, *it);
                it++;
        }
        double slice = (max - min)/double(nstep);
        int ns;
        for (ns=0;ns<nstep;ns++)
        {
                TeSlice ps;
                ps.count_ = 0;
                ps.from_ = Te2String(min+double(ns)*slice, precision);
                ps.to_ = Te2String(min+double(ns+1)*slice, precision);
                result.push_back(ps);
        }
        min = TeAdjustToPrecision(min, precision, true);
        result[0].from_ = Te2String(min, precision);
        max = TeAdjustToPrecision(max, precision);
        result[result.size()-1].to_ = Te2String(max, precision);

        // Set the number of elements for each slice
        if (countElements == true)
                TeElemCountingBySlice(begin, end, result);
}

template<class iterator>

void TeGroupByQuantil	(	iterator	begin,
		iterator	end,
		int	nstep,
		vector< TeSlice > &	result,
		int	precision = 0,
		bool	countElements = true
	)			[inline]

Definition at line 129 of file TeGroupingAlgorithms.h.

References TeSlice::from_, Te2String(), TeAdjustToPrecision(), TeElemCountingBySlice(), and TeSlice::to_.

Referenced by TeTheme::buildGrouping(), and TeExternalTheme::buildGrouping().

{
        sort(begin, end);

        int size = end - begin;
        double  step = (double)size / (double)nstep;

        int     n = 0;
        iterator it = begin;
        while(it < end)
        {
                TeSlice ps;
                ps.from_ = Te2String((*it), precision);
                int p = (int)(step * (double)++n + .5);
                it = begin + p;
                if(it < end)
                        ps.to_ = Te2String((*it), precision);
                else
                        ps.to_ = Te2String(*(it-1), precision);
                result.push_back(ps);
        }
        if(end-begin > 1)
        {
                double min = (*begin);
                double max = (*(end-1));
                min = TeAdjustToPrecision(min, precision, true);
                result[0].from_ = Te2String(min, precision);
                max = TeAdjustToPrecision(max, precision);
                result[result.size()-1].to_ = Te2String(max, precision);
        }

        // Set the number of elements for each slice
        if (countElements == true)
                TeElemCountingBySlice(begin, end, result);
}

template<class iterator>

void TeGroupByStdDev	(	iterator	begin,
		iterator	end,
		double	ndev,
		vector< TeSlice > &	result,
		string &	rmean,
		int	precision = 0,
		bool	countElements = true
	)			[inline]

Definition at line 168 of file TeGroupingAlgorithms.h.

References aux, TeSlice::from_, MAX, MIN, Te2String(), TeAdjustToPrecision(), TeElemCountingBySlice(), TeMAXFLOAT, and TeSlice::to_.

Referenced by TeTheme::buildGrouping(), and TeExternalTheme::buildGrouping().

{
        // Compute mim, max and mean
        double  min = TeMAXFLOAT;
        double  max = -TeMAXFLOAT;
        long double     sum=0.;
        long double     sm2=0.;
        iterator it=begin;
        while(it < end)
        {
                min = MIN(min, *it);
                max = MAX(max, *it);
                sum += (*it);
                sm2 += ((*it) * (*it));
                it++;
        }
        double cont = (double)(end - begin);
        double  mean = (double)(sum/cont);
        long double var = (sm2 / cont) - (mean * mean);
        double  sdev = sqrt(var);

        double  slice = sdev * ndev;

        vector<TeSlice> aux;
        rmean = Te2String(mean, precision);
        double  val = mean;
        while(val-slice > min-slice)
        {
                TeSlice ps;
                double v = val - slice;
                ps.from_ = Te2String(v, precision);
                ps.to_ = Te2String(val, precision);
                aux.push_back(ps);
                val = v;
        }

        std::vector<TeSlice>::reverse_iterator sit;

        for(sit = aux.rbegin(); sit != aux.rend(); ++sit)
        {
                result.push_back(*sit);
        }

        string media = "mean = " + rmean;
        TeSlice ps;
        ps.from_ = media;
        ps.to_.clear();
        result.push_back(ps);
        val = mean;
        while(val+slice < max+slice)
        {
                TeSlice ps;
                double  v = val + slice;
                ps.from_ = Te2String(val, precision);
                ps.to_ = Te2String(v, precision);
                result.push_back(ps);
                val = v;
        }
        if(result.size() > 2)
        {
                if (result[0].from_.find("mean")  == string::npos)
                {
                        min = TeAdjustToPrecision(min, precision, true);
                        result[0].from_ = Te2String(min, precision);
                }
                if (result[result.size()-1].from_.find("mean")  == string::npos)
                {
                        max = TeAdjustToPrecision(max, precision);
                        result[result.size()-1].to_ = Te2String(max, precision);
                }
        }

        // Set the number of elements for each slice
        if (countElements == true)
                TeElemCountingBySlice(begin, end, result);
}

TL_DLL void TeGroupByUniqueValue	(	vector< string > &	vec,
		TeAttrDataType	tipo,
		vector< TeSlice > &	result,
		int	precision
	)

---