-
Notifications
You must be signed in to change notification settings - Fork 0
/
Discriminator.h
68 lines (56 loc) · 2.9 KB
/
Discriminator.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <map>
#include "GInvariant.h"
#ifndef DISCRIMINATOR_H
#define DISCRIMINATOR_H
class Taxonomy2;
class DiscriminatorEvaluator;
class DiscriminatorEvalCacheEntry;
typedef std::vector<GInvariant::ptr> GInvariantList;
/**
* A discriminator for k-subsets is a G-invariant function for which the rank (size of codomain)
* is the same size as the number of orbits of k-subsets. The rank of the cartesian product of
* two G-invariant functions over k-subsets is at least as big as the larger of the two, thus this
* is a container representing the Cartesian product of a number of G-invariant functions.
*
* This object should not be created directly. Rather, it should be created from the
* computeNextMatrix function, which guarantees that the discriminator actually discriminates
* between subsets.
*/
class Discriminator : public GInvariant, public boost::enable_shared_from_this<Discriminator> {
typedef std::map<std::vector<unsigned long>, unsigned long> LookupTable;
friend class DiscriminatorEvalCacheEntry;
public:
typedef boost::shared_ptr<Discriminator> ptr;
typedef DiscriminatorEvaluator Evaluator;
Discriminator(const Group& _G, GInvariantList& _functions, const LookupTable& _lookupTable, const std::map<Subset, unsigned long>& _newCache) :
GInvariant(_G), functions(_functions), lookupTable(_lookupTable), newCache(_newCache) {}
virtual ~Discriminator() {}
bool operator==(const Discriminator& rhs) const { return equals(rhs); }
bool operator!=(const Discriminator& rhs) const { return !equals(rhs); }
bool equals(const GInvariant& rhs) const;
std::size_t hash() const;
Evaluator createEvaluator() const;
/**
* Returns the number of possible outputs for this discriminator. This should be equal to
* G.burnside(k) for some value of k. evaluate(B) should, for all B of size k, return a value from
* 0 to numOutputs() - 1.
*/
unsigned long numOutputs() const { return lookupTable.size(); }
GInvariantList getFunctions() const { return functions; }
const GInvariant::ptr getInvariant() const;
unsigned long evaluate(const Subset& B) const;
bool hasCachedResult(const Subset& B) const;
std::deque<GInvariantEvaluationTask> getDependents(const Subset& B) const;
private:
GInvariantList functions;
LookupTable lookupTable; // Should be fully constructed when built
std::map<Subset, unsigned long> newCache; // Starting evaluation cache
};
/* ********************************************************************************************************************* */
// Trait class specializations
template <> struct cachesResults<Discriminator> : public boost::true_type {};
template <> struct isDiscriminator<Discriminator> : public boost::true_type {};
template <> struct isSizeIndependent<Discriminator> : public boost::false_type {};
template <> struct spawnsDependents<Discriminator>: public boost::true_type {};
template <> struct isTrivial<Discriminator> : public boost::false_type {};
#endif