00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifndef REFIMENET_FAMILY_H
00034 #define REFIMENET_FAMILY_H
00035
00036 #include <permlib/search/partition/group_refinement.h>
00037 #include <permlib/search/partition/set_stabilize_refinement.h>
00038 #include <permlib/search/partition/set_image_refinement.h>
00039 #include <permlib/search/partition/matrix_refinement2.h>
00040
00041 namespace permlib {
00042 namespace partition {
00043
00045
00048 template<class PERM>
00049 class RefinementFamily {
00050 public:
00051 typedef typename Refinement<PERM>::RefinementPtr RefinementPtr;
00052 typedef boost::shared_ptr<Partition> PartitionPtr;
00053
00055 virtual ~RefinementFamily() {}
00056
00058
00062 virtual std::pair<PartitionPtr,RefinementPtr> apply(Partition& pi) const = 0;
00063 };
00064
00066 template<class PERM,class TRANS>
00067 class GroupRefinementFamily : public RefinementFamily<PERM> {
00068 public:
00069 typedef typename RefinementFamily<PERM>::RefinementPtr RefinementPtr;
00070 typedef typename RefinementFamily<PERM>::PartitionPtr PartitionPtr;
00071
00073 explicit GroupRefinementFamily(const BSGSCore<PERM,TRANS>& bsgs) : m_bsgs(bsgs) {}
00074
00075 virtual std::pair<PartitionPtr,RefinementPtr> apply(Partition& pi) const {
00076 RefinementPtr ref(new GroupRefinement<PERM,TRANS>(m_bsgs));
00077 GroupRefinement<PERM,TRANS> *gref = static_cast<GroupRefinement<PERM,TRANS>*>(ref.get());
00078 bool strictRefinement = gref->initializeAndApply(pi);
00079 if (strictRefinement)
00080 return std::make_pair(PartitionPtr(new Partition(pi)), ref);
00081 else
00082 return std::make_pair(PartitionPtr(), RefinementPtr());
00083 }
00084 private:
00085 const BSGSCore<PERM,TRANS>& m_bsgs;
00086 };
00087
00089 template<class PERM>
00090 class SetStabilizeRefinementFamily : public RefinementFamily<PERM> {
00091 public:
00092 typedef typename RefinementFamily<PERM>::RefinementPtr RefinementPtr;
00093 typedef typename RefinementFamily<PERM>::PartitionPtr PartitionPtr;
00094
00096
00101 template<class InputIterator>
00102 SetStabilizeRefinementFamily(ulong n, InputIterator begin, InputIterator end) : m_n(n), toStab(begin, end)
00103 {}
00104
00105 virtual std::pair<PartitionPtr,RefinementPtr> apply(Partition& pi) const {
00106 RefinementPtr ref(new SetStabilizeRefinement<PERM>(m_n, toStab.begin(), toStab.end()));
00107 SetStabilizeRefinement<PERM> *gref = static_cast<SetStabilizeRefinement<PERM>*>(ref.get());
00108 bool strictRefinement = gref->initializeAndApply(pi);
00109 if (strictRefinement)
00110 return std::make_pair(PartitionPtr(new Partition(pi)), ref);
00111 else
00112 return std::make_pair(PartitionPtr(), RefinementPtr());
00113 }
00114 private:
00115 ulong m_n;
00116 std::vector<ulong> toStab;
00117 };
00118
00120 template<class PERM>
00121 class SetImageRefinementFamily : public RefinementFamily<PERM> {
00122 public:
00123 typedef typename RefinementFamily<PERM>::RefinementPtr RefinementPtr;
00124 typedef typename RefinementFamily<PERM>::PartitionPtr PartitionPtr;
00125
00127
00134 template<class InputIterator>
00135 SetImageRefinementFamily(ulong n, InputIterator begin, InputIterator end, InputIterator beginImg, InputIterator endImg)
00136 : m_n(n), delta(begin, end), phi(beginImg, endImg)
00137 {}
00138
00139 virtual std::pair<PartitionPtr,RefinementPtr> apply(Partition& pi) const {
00140 RefinementPtr ref(new SetImageRefinement<PERM>(m_n, delta.begin(), delta.end(), phi.begin(), phi.end()));
00141 SetImageRefinement<PERM> *gref = static_cast<SetImageRefinement<PERM>*>(ref.get());
00142 bool strictRefinement = gref->initializeAndApply(pi);
00143 if (strictRefinement)
00144 return std::make_pair(PartitionPtr(new Partition(pi)), ref);
00145 else
00146 return std::make_pair(PartitionPtr(), RefinementPtr());
00147 }
00148 private:
00149 ulong m_n;
00150 std::vector<ulong> delta;
00151 std::vector<ulong> phi;
00152 };
00153
00155 template<class PERM,class MATRIX>
00156 class MatrixAutomorphismRefinementFamily : public RefinementFamily<PERM> {
00157 public:
00158 typedef typename RefinementFamily<PERM>::RefinementPtr RefinementPtr;
00159 typedef typename RefinementFamily<PERM>::PartitionPtr PartitionPtr;
00160
00162
00166 MatrixAutomorphismRefinementFamily(ulong n, const MATRIX& matrix) : m_n(n), m_matrix(matrix)
00167 {}
00168
00169 virtual std::pair<PartitionPtr,RefinementPtr> apply(Partition& pi) const {
00170 RefinementPtr ref(new MatrixRefinement2<PERM,MATRIX>(m_n, m_matrix));
00171 MatrixRefinement2<PERM,MATRIX> *gref = static_cast<MatrixRefinement2<PERM,MATRIX>*>(ref.get());
00172 bool strictRefinement = gref->initializeAndApply(pi);
00173 if (strictRefinement)
00174 return std::make_pair(PartitionPtr(new Partition(pi)), ref);
00175 else
00176 return std::make_pair(PartitionPtr(), RefinementPtr());
00177 }
00178 private:
00179 ulong m_n;
00180 const MATRIX& m_matrix;
00181 };
00182
00183 }
00184 }
00185
00186 #endif // -- REFIMENET_FAMILY_H