void debugDisplay(const Subset& SS)
{
std::cout << " " << SS.count() << "\t" << SS.size() << "\t";
for(unsigned int i = 0; i < SS.count(); ++i)
std::cout << SS.pop() << " ";
std::cout << std::endl;
}
bool sameSubset(const Subset &a, const Subset &b)
{
if (a.size() != b.size()) return false;
for (size_t i = 0; i < a.size(); i++)
if (a[i] != b[i]) return false;
return true;
}
/*
Rule II: If B contains more elements than C then S(B) > S(C).
*/
bool validate2(const Subset &x, const Subset &y) {
if(x.size() > y.size())
return (S(x) > S(y));
else if(x.size() < y.size())
return (S(x) < S(y));
else
return false;
}
void load_particle_states(const Subset &s,
const Assignment &ss,
const ParticleStatesTable *pst) {
load_particle_states(s.begin(), s.end(), ss, pst);
if (s.size()!=0) {
s[0]->get_model()->update();
}
}
/*
Rule I: S(B) ≠ S(C); that is, sums of subsets cannot be equal.
*/
bool validate1(const Subset &b, const Subset &c) {
int i, j;
if(S(b) == S(c))
return false;
for(i = 1; i < b.size(); i++)
for(j = 0; j + i < b.size(); j++)
if(b[j] < c[j] && b[j + i] > c[j + i])
return false;
return true;
}
/**
* Compute the Kramer-Mesner matrix.
*
* Precondition: t < k
*/
KramerMesnerMatrix computeKMMatrix(const Group& G, unsigned int t, unsigned int k) {
std::vector<KMBuilderOutput> builderOutputs; // stores the relevant data for k = 2 onwards
Matrix A;
for (int i = 2; i <= k; i++) {
boost::scoped_ptr<KMBuilder> builder;
// Get orbit representatives of (i - 1)-subsets
std::vector<Subset> orbitReps;
if (i == 2) {
// As it is the first time, we have to compute the orbit representatives of singleton subsets...
Subset pointsRemaining = generateX(G.getNumPoints());
while (!pointsRemaining.empty()) {
typedef OrbitSet<Permutation, unsigned long>::const_iterator OrbitSetIterator;
unsigned long point = *(pointsRemaining.begin()); // A new representative...
Subset singletonSet = makeSingletonSet(point); // ...as a set
orbitReps.push_back(singletonSet);
// Compute the orbit of the point, and remove it from the remaining points
OrbitSet<Permutation, unsigned long> orbit = G.orbit(point, Transversal::TrivialAction());
for (OrbitSetIterator it = orbit.begin(); it != orbit.end(); it++) {
pointsRemaining.erase(pointsRemaining.find(*it));
}
}
builder.reset(new KMBuilder(G, i, orbitReps));
} else {
// We get them from what we computed earlier
KMBuilderOutput& input = builderOutputs[i - 3];
orbitReps = input.getNewReps();
builder.reset(new KMBuilder(G, i, orbitReps, input.getPrunerData()));
}
KMBuilderOutput builderOutput = builder->build();
builderOutputs.push_back(builderOutput);
// From the identity that A[t][k] = A[t][s] * A[s][k] / combinat(k - t, k - s) for any s
// between t and k, we get the following:
if (i == t + 1) {
assignMatrix(A, builderOutput.getNewMatrix());
} else if (i > t + 1) {
assignMatrix(A, matrixMultiply(A, builderOutput.getNewMatrix()));
scalarDivide(i - t, A);
}
}
return KramerMesnerMatrix(G, builderOutputs[t - 2].getNewReps(), builderOutputs[k - 2].getNewReps(), A);
}
float TSPProblem::solveTSP()
{
allocateTSPCache_();
//base cases
{
for (unsigned int i=0; i<rows_; i++) {
cache_[i][0] = std::numeric_limits<float>::max();
}
Subset s; s.add(0);
cache_[s.repr()][0] = 0; // from node to itself using exactly itself
}
//meat of the algorithm
for (unsigned int m=2; m <= cities_.size(); m++) { //subset size (including 0)
vector<Subset> subsets;
getSubsets(subsets, m, cities_.size());
for (const Subset& s : subsets) {
for (unsigned int j=1; j<cities_.size(); j++) { //omit start node 0
if (!(s.contains(j))) { // omit stuff not in subset
continue;
}
Subset sprime(s);
sprime.remove(j);
float minval = std::numeric_limits<float>::max();
for (unsigned int k=0; k<cities_.size(); k++) {
if (!(s.contains(k)) || k == j) {
continue;
}
float localCost = cache_[sprime.repr()][k] + distance(cities_[k], cities_[j]);
if (localCost < minval) {
minval = localCost;
}
}
cache_[s.repr()][j] = minval;
}
}
}
//finally find minimum of all paths computed so far
float minval = std::numeric_limits<float>::max();
{
Subset s;
for (unsigned int i=0; i<cities_.size() ; i++) {
s.add(i);
}
for (unsigned int j=1; j < cities_.size(); j++) {
float localCost = cache_[s.repr()][j] + distance(cities_[j], cities_[0]);
if (localCost < minval) {
minval = localCost;
}
}
}
return minval;
}
void draw(const Subset &s) {
int i;
cout << "{";
for(i = 0; i < s.size(); i++) {
cout << s[i];
if(i + 1 != s.size())
cout << ", ";
}
cout << "}";
}
Assignment get_merged_assignment(const Subset &s, const Assignment &ss0,
const Ints &i0, const Assignment &ss1,
const Ints &i1) {
Ints ret(s.size(), -1);
IMP_USAGE_CHECK(ss0.size() == i0.size(),
"The size of the subset and "
<< "the index don't match: " << ss0.size() << " vs "
<< i0.size());
IMP_USAGE_CHECK(ss1.size() == i1.size(),
"The size of the subset and "
<< "the index don't match: " << ss1.size() << " vs "
<< i1.size());
for (unsigned int i = 0; i < i0.size(); ++i) {
ret[i0[i]] = ss0[i];
}
for (unsigned int i = 0; i < i1.size(); ++i) {
ret[i1[i]] = ss1[i];
}
IMP_IF_CHECK(USAGE) {
for (unsigned int i = 0; i < ret.size(); ++i) {
IMP_USAGE_CHECK(ret[i] >= 0, "Not all set");
}
}
return Assignment(ret);
}
Subset MinRepPruner::minRep(const Subset& candidate) {
typedef boost::dynamic_bitset<unsigned long> dset;
dset candidateBitset(G->getNumPoints());
for (Subset::const_iterator it = candidate.begin(); it != candidate.end(); ++it) {
candidateBitset[*it] = true;
}
dset resultBitset = search.lexMin(candidateBitset);
Subset result;
for (dset::size_type i = resultBitset.find_first(); i != dset::npos; i = resultBitset.find_next(i)) {
result.insert(i);
}
return result;
}
Assignment
get_nearest_assignment(const Subset &s,
const algebra::VectorKD &embedding,
ParticleStatesTable *pst) {
Ints ret(s.size());
unsigned int cur=0;
// kind of a hack to get size
for (unsigned int i=0; i< s.size(); ++i) {
unsigned int sz
= pst->get_particle_states(s[i])->get_embedding(0).get_dimension();
algebra::VectorKD cpt(embedding.coordinates_begin()+cur,
embedding.coordinates_begin()+cur+sz);
cur+=sz;
ret[i]= pst->get_particle_states(s[i])->get_nearest_state(cpt);
}
return Assignment(ret);
}
/*
Example:
f({1, 2, 3}, {4}) = true because 4 is not in the other list
f({1, 2, 3}, {2}) = false because 2 is in the other list
*/
bool uniek(const Subset &a, const Subset &b) {
int x, y;
//Init
x = 0;
y = 0;
while(x < a.size() && y < b.size()) {
if(a[x] == b[y])
return false;
if(a[x] < b[y])
x++;
else
y++;
}
return true;
}
display::Geometries get_subset_graph_geometry(const SubsetGraph &ig) {
display::Geometries ret;
SubsetGraphConstVertexName vm = boost::get(boost::vertex_name, ig);
for (std::pair<InteractionGraphTraits::vertex_iterator,
InteractionGraphTraits::vertex_iterator> be =
boost::vertices(ig);
be.first != be.second; ++be.first) {
Subset s = vm[*be.first];
display::Color c = display::get_display_color(*be.first);
for (unsigned int i = 0; i < s.size(); ++i) {
core::XYZ pi(s[i]);
IMP_NEW(display::SphereGeometry, cg,
(algebra::Sphere3D(pi.get_coordinates(), 1)));
cg->set_color(c);
cg->set_name(s.get_name());
ret.push_back(cg.get());
}
}
return ret;
}
algebra::VectorKD get_embedding(const Subset &s,
const Assignment &a,
ParticleStatesTable *pst){
Floats embed;
for (unsigned int i=0; i< s.size(); ++i) {
algebra::VectorKD cur
= pst->get_particle_states(s[i])->get_embedding(a[i]);
embed.insert(embed.end(), cur.coordinates_begin(),
cur.coordinates_end());
}
return embed;
}
RestraintsTemp get_restraints(const Subset &s,
const ParticleStatesTable *pst,
const DependencyGraph &dg,
RestraintSet *rs) {
RestraintsTemp rw= get_restraints(RestraintsTemp(1, rs));
Subset other=pst->get_subset();
ParticlesTemp oms;
std::set_difference(other.begin(), other.end(),
s.begin(), s.end(),
std::back_inserter(oms));
IMP::compatibility::map<Restraint*, int> index
= IMP::base::internal::get_graph_index<Restraint>(dg);
Ints to_remove;
for (unsigned int i=0; i< rw.size(); ++i) {
if (IMP::internal::get_has_ancestor(dg, index[rw[i]], oms)) {
to_remove.push_back(i);
}
}
for (int i=to_remove.size()-1; i >=0; --i) {
rw.erase(rw.begin()+to_remove[i]);
}
return rw;
}
Assignments get_state_clusters(const Subset &subset, const Assignments &states,
ParticleStatesTable *pst, double resolution) {
Vector<Ints> rotated(subset.size(), Ints(states.size(), -1));
for (unsigned int i = 0; i < states.size(); ++i) {
for (unsigned int j = 0; j < states[i].size(); ++j) {
rotated[j][i] = states[i][j];
}
}
for (unsigned int i = 0; i < rotated.size(); ++i) {
std::sort(rotated[i].begin(), rotated[i].end());
rotated[i].erase(std::unique(rotated[i].begin(), rotated[i].end()),
rotated[i].end());
}
Vector<Ints> clustering(states.size());
for (unsigned int i = 0; i < subset.size(); ++i) {
IMP::PointerMember<ParticleStates> ps =
pst->get_particle_states(subset[i]);
Ints c = get_state_clusters(subset[i], ps, rotated[i], resolution);
clustering[i] = c;
}
return filter_states(subset, states, clustering);
}
IMPDOMINOEXPORT CliqueGraph get_clique_graph(const InteractionGraph &cig) {
InteractionGraphConstVertexName pm = boost::get(boost::vertex_name, cig);
typedef Vector<InteractionGraphVertex> Clique;
Vector<Clique> cliques;
internal::maximal_cliques(cig, std::back_inserter(cliques));
for (unsigned int i = 0; i < cliques.size(); ++i) {
/*std::cout << "Clique is ";
for (unsigned int j=0; j< cliques[i].size(); ++j) {
std::cout << cliques[i][j] << " ";
}*/
std::sort(cliques[i].begin(), cliques[i].end());
}
CliqueGraph cg(cliques.size());
CliqueGraphVertexName cm = boost::get(boost::vertex_name, cg);
for (unsigned int i = 0; i < cliques.size(); ++i) {
ParticlesTemp cur;
for (unsigned int j = 0; j < cliques[i].size(); ++j) {
cur.push_back(pm[cliques[i][j]]);
}
Subset ss(cur);
cm[i] = ss;
}
for (unsigned int i = 0; i < cliques.size(); ++i) {
for (unsigned int j = 0; j < i; ++j) {
Subset intersection = get_intersection(cm[i], cm[j]);
if (intersection.size() > 0) {
double minus_weight = intersection.size();
/*std::cout << "edge " << i << " " << j
<< " has weight "
<< -static_cast<int>(intersection.size()) << std::endl;*/
boost::add_edge(i, j, CliqueGraph::edge_property_type(-minus_weight),
cg);
}
}
}
return cg;
}
Ints get_partial_index(const ParticlesTemp &particles,
const Subset &subset, const Subsets &excluded) {
for (unsigned int i=0; i< excluded.size(); ++i) {
bool all=true;
for (unsigned int j=0; j< particles.size(); ++j) {
if (!std::binary_search(excluded[i].begin(), excluded[i].end(),
particles[j])) {
all=false;
break;
}
}
if (all) {
return Ints();
}
}
Ints ret(particles.size(), -1);
for (unsigned int i=0; i< particles.size(); ++i) {
Subset::const_iterator it= std::lower_bound(subset.begin(),
subset.end(), particles[i]);
if (it!= subset.end() && *it == particles[i]) {
ret[i]= it-subset.begin();
}
}
IMP_IF_LOG(VERBOSE) {
IMP_LOG(VERBOSE, "Returning ");
for (unsigned int i=0; i< ret.size(); ++i) {
IMP_LOG(VERBOSE, ret[i] << " ");
}
IMP_LOG(VERBOSE, "for ");
for (unsigned int i=0; i< particles.size(); ++i) {
IMP_LOG(VERBOSE, particles[i]->get_name() << " ");
}
IMP_LOG(VERBOSE, " subset " << subset << std::endl);
}
return ret;
}
RestraintsTemp RestraintCache::get_restraints(const Subset &s,
const Subsets &exclusions) const {
IMP_OBJECT_LOG;
kernel::RestraintsTemp ret;
for (KnownRestraints::const_iterator it = known_restraints_.begin();
it != known_restraints_.end(); ++it) {
if (s.get_contains(it->second)) {
bool excluded = false;
for (unsigned int i = 0; i < exclusions.size(); ++i) {
if (exclusions[i].get_contains(it->second)) {
excluded = true;
break;
}
}
if (!excluded) {
ret.push_back(it->first);
}
}
}
return ret;
}
void gen_subsets(Subsets &s, const Subset &x, int n, int p, int m) {
int i;
Subset x2;
if(x.size() == m) {
s.push_back(x);
//Debug
//draw(x);
//cout << endl;
return;
}
for(i = p; i <= n; i++) {
x2 = x;
x2.push_back(i);
gen_subsets(s, x2, n, i + 1, m);
}
}
bool within(const Subset& other) const {
return other.contains(*this);
}
SubsetGraph get_restraint_graph(ScoringFunctionAdaptor in,
const ParticleStatesTable *pst) {
RestraintsTemp rs =
IMP::create_decomposition(in->create_restraints());
// ScoreStatesTemp ss= get_required_score_states(rs);
SubsetGraph ret(rs.size()); // + ss.size());
IMP_LOG_TERSE("Creating restraint graph on " << rs.size() << " restraints."
<< std::endl);
boost::unordered_map<Particle *, int> map;
SubsetGraphVertexName pm = boost::get(boost::vertex_name, ret);
DependencyGraph dg = get_dependency_graph(rs[0]->get_model());
DependencyGraphVertexIndex index = IMP::get_vertex_index(dg);
/*IMP_IF_LOG(VERBOSE) {
IMP_LOG_VERBOSE( "dependency graph is \n");
IMP::internal::show_as_graphviz(dg, std::cout);
}*/
Subset ps = pst->get_subset();
for (unsigned int i = 0; i < ps.size(); ++i) {
ParticlesTemp t = get_dependent_particles(
ps[i], ParticlesTemp(ps.begin(), ps.end()), dg, index);
for (unsigned int j = 0; j < t.size(); ++j) {
IMP_USAGE_CHECK(map.find(t[j]) == map.end(),
"Currently particles which depend on more "
<< "than one particle "
<< "from the input set are not supported."
<< " Particle \"" << t[j]->get_name()
<< "\" depends on \"" << ps[i]->get_name()
<< "\" and \""
<< ps[map.find(t[j])->second]->get_name() << "\"");
map[t[j]] = i;
}
IMP_IF_LOG(VERBOSE) {
IMP_LOG_VERBOSE("Particle \"" << ps[i]->get_name() << "\" controls ");
for (unsigned int i = 0; i < t.size(); ++i) {
IMP_LOG_VERBOSE("\"" << t[i]->get_name() << "\" ");
}
IMP_LOG_VERBOSE(std::endl);
}
}
for (unsigned int i = 0; i < rs.size(); ++i) {
ParticlesTemp pl = IMP::get_input_particles(rs[i]->get_inputs());
std::sort(pl.begin(), pl.end());
pl.erase(std::unique(pl.begin(), pl.end()), pl.end());
Subset os(pl);
for (unsigned int j = 0; j < pl.size(); ++j) {
pl[j] = ps[map[pl[j]]];
}
std::sort(pl.begin(), pl.end());
pl.erase(std::unique(pl.begin(), pl.end()), pl.end());
Subset s(pl);
IMP_LOG_VERBOSE("Subset for restraint " << rs[i]->get_name() << " is " << s
<< " from " << os << std::endl);
pm[i] = s;
}
/*ScoreStatesTemp ss= get_required_score_states(rs);
for (ScoreStatesTemp::const_iterator it= ss.begin();
it != ss.end(); ++it) {
ParticlesTemp pl= (*it)->get_input_particles();
add_edges(ps, pl, map, *it, ret);
ParticlesTemp opl= (*it)->get_output_particles();
add_edges(ps, opl, map, *it, ret);
}
IMP_INTERNAL_CHECK(boost::num_vertices(ret) == ps.size(),
"Wrong number of vertices "
<< boost::num_vertices(ret)
<< " vs " << ps.size());*/
for (unsigned int i = 0; i < boost::num_vertices(ret); ++i) {
for (unsigned int j = 0; j < i; ++j) {
if (get_intersection(pm[i], pm[j]).size() > 0) {
boost::add_edge(i, j, ret);
IMP_LOG_VERBOSE("Connecting " << rs[i]->get_name() << " with "
<< rs[j]->get_name() << std::endl);
}
}
}
return ret;
}
int S(const Subset &v) {
return accumulate(v.begin(), v.end(), 0);
}
