TNumericUtil Namespace Reference

Classes
class	KahanAccumulator
class	NaiveAccumulator
struct	quadruplet
struct	triplet

Typedefs
template<typename T >
using	PreciseAccumulator = KahanAccumulator< T >
template<typename T >
using	FastAccumulator = NaiveAccumulator< T >
template<typename T >
using	DefaultAccumulator = PreciseAccumulator< T >
typedef triplet< unsigned int >	uintTriplet_t
typedef triplet< int >	intTriplet_t
typedef triplet< float >	floatTriplet_t
typedef triplet< double >	doubleTriplet_t
typedef quadruplet< unsigned int >	uintQuad_t
typedef quadruplet< int >	intQuad_t
typedef quadruplet< float >	floatQuad_t
typedef quadruplet< double >	doubleQuad_t

Functions
template<typename T , class A >
T	sumWith (const std::vector< T > &vals)
template<typename T >
T	sumPrecise (const std::vector< T, std::allocator< T >> &vals)
template<typename T >
T	sumFast (const std::vector< T, std::allocator< T >> &vals)
template<typename T >
T	sumDefault (const std::vector< T, std::allocator< T >> &vals)
void	PermutationGenerator (int n, int k, std::vector< std::vector< int >> &perms, int valbegin=1, int increment=1)
void	CombinationGenerator (int n, int k, std::vector< std::vector< int >> &perms, int valbegin=1, int increment=1)

Typedef Documentation

DefaultAccumulator

template<typename T >

using TNumericUtil::DefaultAccumulator = typedef PreciseAccumulator<T>

Definition at line 55 of file MELAAccumulators.h.

doubleQuad_t

typedef quadruplet<double> TNumericUtil::doubleQuad_t

Definition at line 51 of file TNumericUtil.hh.

doubleTriplet_t

typedef triplet<double> TNumericUtil::doubleTriplet_t

Definition at line 46 of file TNumericUtil.hh.

FastAccumulator

template<typename T >

using TNumericUtil::FastAccumulator = typedef NaiveAccumulator<T>

Definition at line 54 of file MELAAccumulators.h.

floatQuad_t

typedef quadruplet<float> TNumericUtil::floatQuad_t

Definition at line 50 of file TNumericUtil.hh.

floatTriplet_t

typedef triplet<float> TNumericUtil::floatTriplet_t

Definition at line 45 of file TNumericUtil.hh.

intQuad_t

typedef quadruplet<int> TNumericUtil::intQuad_t

Definition at line 49 of file TNumericUtil.hh.

intTriplet_t

typedef triplet<int> TNumericUtil::intTriplet_t

Definition at line 44 of file TNumericUtil.hh.

PreciseAccumulator

template<typename T >

using TNumericUtil::PreciseAccumulator = typedef KahanAccumulator<T>

Definition at line 53 of file MELAAccumulators.h.

uintQuad_t

typedef quadruplet<unsigned int> TNumericUtil::uintQuad_t

Definition at line 48 of file TNumericUtil.hh.

uintTriplet_t

typedef triplet<unsigned int> TNumericUtil::uintTriplet_t

Definition at line 43 of file TNumericUtil.hh.

Function Documentation

CombinationGenerator()

void TNumericUtil::CombinationGenerator	(	int	n,
		int	k,
		std::vector< std::vector< int >> &	perms,
		int	valbegin = 1,
		int	increment = 1
	)

Definition at line 19 of file TNumericUtil.cc.

                                                                                                                  {
  if (n==k && k>0){
    vector<int> d(n);
    iota(d.begin(), d.end(), 1);
    perms.push_back(d);
  }
  else{
    PermutationGenerator(n, k, perms);
    for (auto& perm:perms) sort(perm.begin(), perm.end());
    for (auto ip=perms.begin(); ip!=perms.end(); ip++){
      for (auto jp=perms.rbegin(); (jp.base()-1)!=ip; jp++){
        if (*(ip)==*(jp)) perms.erase(jp.base()-1);
      }
    }
  }
  if (valbegin!=1 || increment!=1){ for (auto& p:perms){ for (auto& pp:p) pp = increment*(pp-1)+valbegin; } }
}

PermutationGenerator()

void TNumericUtil::PermutationGenerator	(	int	n,
		int	k,
		std::vector< std::vector< int >> &	perms,
		int	valbegin = 1,
		int	increment = 1
	)

Definition at line 7 of file TNumericUtil.cc.

                                                                                                                  {
  if (n<=0 || k<=0 || k>n) return;
  vector<int> d(n);
  iota(d.begin(), d.end(), 1);
  do{
    vector<int> aperm;
    for (int i=0; i<k; i++) aperm.push_back(d[i]);
    perms.push_back(aperm);
    reverse(d.begin()+k, d.end());
  } while (next_permutation(d.begin(), d.end()));
  if (valbegin!=1 || increment!=1){ for (auto& p:perms){ for (auto& pp:p) pp = increment*(pp-1)+valbegin; } }
}

sumDefault()

template<typename T >

T TNumericUtil::sumDefault ( const std::vector< T, std::allocator< T >> &  vals )

inline

Definition at line 73 of file MELAAccumulators.h.

                                                                                     {
    T ret = sumWith<T, DefaultAccumulator<T>>(vals);
    return ret;
  }

sumFast()

template<typename T >

T TNumericUtil::sumFast ( const std::vector< T, std::allocator< T >> &  vals )

inline

Definition at line 68 of file MELAAccumulators.h.

                                                                                  {
    T ret = sumWith<T, FastAccumulator<T>>(vals);
    return ret;
  }

sumPrecise()

template<typename T >

T TNumericUtil::sumPrecise ( const std::vector< T, std::allocator< T >> &  vals )

inline

Definition at line 63 of file MELAAccumulators.h.

                                                                                     {
    T ret = sumWith<T, PreciseAccumulator<T>>(vals);
    return ret;
  }

sumWith()

template<typename T , class A >

T TNumericUtil::sumWith ( const std::vector< T > &  vals )

inline

Definition at line 57 of file MELAAccumulators.h.

                                                                          {
    A ret = 0;
    for (const T& v : vals) ret += v;
    return ret;
  }