GSFUtils Namespace Reference

Dynamic array fullfilling alignment requirements. More...

Classes
struct	AlignedDynArray
	A wrapper around std::aligned_alloc. More...
struct	Component1D
	struct representing 1D component More...
struct	Merge
	struct representing an array or the merges. More...

Typedefs
using	Component1DArray = AlignedDynArray< Component1D, GSFConstants::alignment >
using	MergeArray = std::vector< Merge >

Functions
MergeArray	findMerges (Component1DArray &&componentsIn, const int reducedSize)
	Return which components need to be merged. More...

Detailed Description

Dynamic array fullfilling alignment requirements.

Author

Anthony Morley, Christos Anastopoulos

Typedef Documentation

Component1DArray

using GSFUtils::Component1DArray = typedef AlignedDynArray<Component1D, GSFConstants::alignment>

Definition at line 37 of file KLGaussianMixtureReduction.h.

MergeArray

using GSFUtils::MergeArray = typedef std::vector<Merge>

Definition at line 47 of file KLGaussianMixtureReduction.h.

Function Documentation

findMerges()

MergeArray GSFUtils::findMerges	(	Component1DArray &&	componentsIn,
		const int	reducedSize
	)

Return which components need to be merged.

Find the order in which the components need to be merged.

Returns an MergeArray with the merges (To,From). The index of the merged From is always smaller than the To (RHS is smaller than LHS)

Component1DArray : Array of simplified 1D components used to calculate the merge order using q/p.

reducedSize The size we want to reduce the mixture to. Needs to be smaller than the numComponents of the componentsIn array

Definition at line 305 of file KLGaussianMixtureReduction.cxx.

{
  const int n = componentsIn.size();
  int nn = n * (n - 1) / 2;
  int nnpadded = vAlgs::numPadded<STRIDEForKL>(nn);
  Component1DArray components(std::move(componentsIn));
  // Based on the inputSize n allocate enough space for the pairwise distances
  AlignedDynArray<float, GSFConstants::alignment> distances(nnpadded, std::numeric_limits<float>::max());
  // initial distance calculation
  calculateAllDistances(components.buffer(), distances.buffer(), n);
  // As we merge keep track where things moved
  AlignedDynArray<int, GSFConstants::alignment> mergingIndex(n);
  std::iota(mergingIndex.begin(), mergingIndex.end(), 0);
  // Result to be returned
  MergeArray result{};
  result.reserve(n);
  int numberOfComponentsLeft = n;
  // merge loop
  while (numberOfComponentsLeft > reducedSize) {
    // find pair with minimum distance
    const int minIndex = KLReductionFMV::vIdxOfMin(distances.buffer(), nnpadded);
    const triangularToIJ conversion = convert(minIndex);
    int  minTo = conversion.I;
    int  minFrom = conversion.J;
    // This is the convention we had so retained.
    if (mergingIndex[minTo] < mergingIndex[minFrom]) {
      std::swap(minTo, minFrom);
    }
    // prepare what to return
    const int  miniToreturn = mergingIndex[minTo];
    const int  minjToreturn = mergingIndex[minFrom];
    result.push_back({ miniToreturn, minjToreturn });
    // Combine
    combine(components[minTo], components[minFrom]);
    // update distances
    numberOfComponentsLeft = updateDistances(components.buffer(),
                                             mergingIndex.buffer(),
                                             distances.buffer(),
                                             minFrom,
                                             minTo,
                                             numberOfComponentsLeft);
 
    // number of remaining distances padded
    nn = (numberOfComponentsLeft - 1) * numberOfComponentsLeft / 2;
    nnpadded = numDistances(nn, distances.buffer());
  } // end of merge while
  return result;
}