void StateGraph::writeDOT(const SubDigraph& T, const ArcList& F, std::ostream& out) const
{
out << "digraph S {" << std::endl;
for (SubNodeIt v(T); v != lemon::INVALID; ++v)
{
out << "\t" << T.id(v) << " [label=\"("
<< _x[v] << "," << _y[v] << ","
<< _xbar[v] << "," << _ybar[v] << ")\"]" << std::endl;
}
for (ArcListIt it = F.begin(); it != F.end(); ++it)
{
Arc st = *it;
Node t = _G.target(st);
out << "\t" << T.id(t) << " [label=\"("
<< _x[t] << "," << _y[t] << ","
<< _xbar[t] << "," << _ybar[t] << ")\",color=red]" << std::endl;
}
for (SubArcIt a(T); a != lemon::INVALID; ++a)
{
out << "\t" << T.id(T.source(a)) << " -> " << T.id(T.target(a)) << std::endl;
}
for (ArcListIt it = F.begin(); it != F.end(); ++it)
{
Arc st = *it;
out << "\t" << _G.id(_G.source(st)) << " -> " << _G.id(_G.target(st)) << " [color=red]" << std::endl;
}
out << "}" << std::endl;
}
bool StateGraph::finalize(const IntPairSet& L,
const StlBoolMatrix& LL,
const SubDigraph& T,
const StlIntMatrix& V)
{
// convert to triples
CnaTripleNodeMap toTriple(_G, CnaTriple(0, 0, 0));
for (SubNodeIt v(T); v != lemon::INVALID; ++v)
{
int x_v = _x[v];
int y_v = _y[v];
int xbar_v = _xbar[v];
int ybar_v = _ybar[v];
toTriple[v]._x = x_v;
toTriple[v]._y = y_v;
toTriple[v]._z = std::max(xbar_v, ybar_v);
}
StateEdgeSet S;
// shortcircuit inner nodes not in LL
for (SubNodeIt v(T); v != lemon::INVALID; ++v)
{
int x_v = _x[v];
int y_v = _y[v];
if (LL[x_v][y_v])
{
// find parent
SubInArcIt a(T, v);
while (a != lemon::INVALID)
{
Node u = T.source(a);
int x_u = _x[u];
int y_u = _y[u];
if (LL[x_u][y_u])
{
S.insert(std::make_pair(toTriple[u], toTriple[v]));
break;
}
else
{
a = SubInArcIt(T, u);
}
}
}
}
_result.insert(S);
return true;
}
bool StateGraph::isValid(const SubDigraph& T) const
{
if (!T.status(_root))
return false;
// at most one mutation edge
int mutCount = 0;
Arc mutationEdge = lemon::INVALID;
for (SubArcIt a_cidj(T); a_cidj != lemon::INVALID; ++a_cidj)
{
if (_type[a_cidj] == MUTATION)
{
++mutCount;
mutationEdge = a_cidj;
}
}
if (mutCount > 1)
return false;
int mut_x = _x[T.source(mutationEdge)];
int mut_y = _y[T.source(mutationEdge)];
// inf sites on copy states
// this boils down to checking that |V_(x,y)| = 1
StlIntMatrix V(_max_x+1, StlIntVector(_max_x+1, 0));
for (SubNodeIt v(T); v != lemon::INVALID; ++v)
{
int x = _x[v];
int y = _y[v];
if (x == mut_x && y == mut_y)
continue;
if (V[x][y] == 0)
{
V[x][y] = 1;
}
else
{
return false;
}
}
return true;
}
void StateGraph::writeDOT(const SubDigraph& T, std::ostream& out) const
{
out << "digraph S {" << std::endl;
for (SubNodeIt v(T); v != lemon::INVALID; ++v)
{
out << "\t" << T.id(v) << " [label=\"("
<< _x[v] << "," << _y[v] << ","
<< _xbar[v] << "," << _ybar[v] << ")\"]" << std::endl;
}
for (SubArcIt a(T); a != lemon::INVALID; ++a)
{
out << "\t" << T.id(T.source(a)) << " -> " << T.id(T.target(a)) << std::endl;
}
out << "}" << std::endl;
}
bool StateGraph::isValid(const SubDigraph& T,
Arc a)
{
Node w = T.target(a);
assert(T.status(T.source(a)));
assert(!T.status(a));
assert(!T.status(w));
T.enable(a);
T.enable(w);
bool res = isValid(T);
T.disable(a);
T.disable(w);
return res;
}
void StateGraph::grow(const IntPairSet& L,
const StlBoolMatrix& LL,
bool includeMutationEdge,
SubDigraph& G,
SubDigraph& T,
ArcList& F,
StlIntMatrix& V,
Arc& mutationEdge)
{
if (isValid(L, LL, T, V) && mutationEdge != lemon::INVALID)
{
// report
finalize(L, LL, T, V);
// writeDOT(T, std::cout);
}
else
{
if (isValid(L, LL, T, V))
{
// report
finalize(L, LL, T, V);
// writeDOT(T, std::cout);
}
ArcList FF;
while (!F.empty())
{
assert(!F.empty());
Arc uv = F.back();
F.pop_back();
Node u = G.source(uv);
Node v = G.target(uv);
int x_v = _x[v];
int y_v = _y[v];
// mutation edge => V[x_v][y_v] == 0
assert(mutationEdge == lemon::INVALID || V[x_v][y_v] == 0);
assert(V[x_v][y_v] <= 1);
// update V
++V[x_v][y_v];
if (_type[uv] == MUTATION)
{
mutationEdge = uv;
}
assert(T.status(u));
assert(!T.status(v));
assert(!T.status(uv));
// add uv to T
T.enable(v);
T.enable(uv);
ArcList newF = F;
// remove arcs from F
for (ArcListNonConstIt it = newF.begin(); it != newF.end();)
{
Arc st = *it;
Node s = T.source(st);
Node t = T.target(st);
int x_t = _x[t];
int y_t = _y[t];
if (v == t || (v != s && x_v == x_t && y_v == y_t) || (mutationEdge == uv && V[x_t][y_t] == 1))
{
assert(T.status(s));
it = newF.erase(it);
}
else
{
++it;
}
}
// push each arc vw where w not in V(T) onto F
for (SubOutArcIt vw(G, v); vw != lemon::INVALID; ++vw)
{
Node w = G.target(vw);
if (T.status(w))
continue;
int x_w = _x[w];
int y_w = _y[w];
if ((includeMutationEdge && mutationEdge == lemon::INVALID && x_v == x_w && y_v == y_w)
|| V[x_w][y_w] == 0)
{
newF.push_back(vw);
}
}
// writeDOT(T, newF, std::cout);
grow(L, LL, includeMutationEdge, G, T, newF, V, mutationEdge);
G.disable(uv);
if (uv == mutationEdge)
{
assert(includeMutationEdge);
mutationEdge = lemon::INVALID;
}
T.disable(uv);
T.disable(v);
--V[x_v][y_v];
FF.push_back(uv);
}
for (ArcListRevIt it = FF.rbegin(); it != FF.rend(); ++it)
{
Arc a = *it;
assert(!G.status(a));
F.push_back(*it);
G.enable(a);
}
}
}
