bool Graph::isConnected ()
{
int reachedsize = 0;
for (int v = 0; v < size; v++) { reachedVertices[v] = false; }
std::list<int> *nextVertices = new std::list<int>();
nextVertices->push_back(0);
reachedVertices[0] = true;
reachedsize++;
while (!nextVertices->empty())
{
int currentVertex = nextVertices->front();
nextVertices->pop_front();
Vertices *adjList = adjacencySets[currentVertex];
for (Vertices::iterator it = adjList->begin(); it != adjList->end(); ++it) {
int adjVertex = *it;
if (!reachedVertices[adjVertex]) {
nextVertices->push_back(adjVertex);
reachedVertices[adjVertex] = true;
reachedsize++;
}
}
}
delete nextVertices;
return reachedsize == size;
}
void operatorSinternal(const Mesh& m, Matrix& mat, const Vertices& points, const double& coeff)
{
std::cout << "INTERNAL OPERATOR S..." << std::endl;
for ( Vertices::const_iterator vit = points.begin(); vit != points.end(); ++vit) {
for ( Mesh::const_iterator tit = m.begin(); tit != m.end(); ++tit) {
mat(vit->index(), tit->index()) = _operatorSinternal(*tit, *vit) * coeff;
}
}
}
bool Graph::isConnected (Vertices *V)
{
Vertices *nextVertices = new Vertices();
int reachedsize = 1;
bool first = true;
for (Vertices::iterator it = V->begin(); it != V->end(); ++it)
{
int v = *it;
if (first)
{
nextVertices->insert(v);
reachedVertices[v] = true;
first = false;
}
else { reachedVertices[v] = false; }
}
while (!nextVertices->empty())
{
Vertices::iterator it = nextVertices->end(); --it;
int currentVertex = *it;
nextVertices->erase(it);
Vertices *adjList = adjacencySets[currentVertex];
for (Vertices::iterator it = adjList->begin(); it != adjList->end(); ++it) {
int adjV = *it;
if (V->find(adjV) != V->end())
{
if (!reachedVertices[adjV]) {
reachedVertices[adjV] = true;
reachedsize++;
nextVertices->insert(adjV);
}
}
}
}
delete nextVertices;
return reachedsize == (int) V->size();
}
Vertices *Graph::getAdjacentVertices (int v, int vMax)
{
if (vMax == -1) { vMax = v; }
Vertices *adjVertices = new Vertices();
Vertices *adjSet = adjacencySets[v];
for (Vertices::iterator it = adjSet->begin(); it != adjSet->end(); ++it)
{
int adjV = *it;
if (adjV < vMax) { adjVertices->insert(adjV); }
}
return adjVertices;
}
/** Insert a function into a vertex of the forest, or create a new vertex. The (new) vertex into which the function was
* inserted is either a child of @p parent or a root node. The @p outputs are used to select the vertex into which the
* function is inserted (all functions of a particular vertex produced the same output when run with the same input). */
void insert(SgAsmFunction *func, OutputValues outputs, PartitionForest::Vertex *parent) {
Vertices candidates = parent ? parent->children : vertices_at_level(0);
assert(!contains(candidates, func));
for (Vertices::iterator vi=candidates.begin(); vi!=candidates.end(); ++vi) {
Vertex *vertex = *vi;
if (outputs.size()==vertex->outputs.size() && std::equal(outputs.begin(), outputs.end(), vertex->outputs.begin())) {
vertex->functions.insert(func);
return;
}
}
size_t lno = parent ? parent->get_level() + 1 : 0;
assert(lno<levels.size());
levels[lno].vertices.insert(new Vertex(parent, func, outputs));
}
void Graph::buildDataStructure ()
{
int lastReachedVertex = 0;
while (lastReachedVertex < size)
{
if (!reachedVertices[lastReachedVertex])
{
GraphComponent *component = new GraphComponent(this);
std::list<int> *connectedVertices = new std::list<int>();
std::list<int> *nextVertices = new std::list<int>();
nextVertices->push_back(lastReachedVertex);
reachedVertices[lastReachedVertex] = true;
while (!nextVertices->empty())
{
int vertex = nextVertices->front();
nextVertices->pop_front();
connectedVertices->push_back(vertex);
graphComponents[vertex] = component;
Vertices *adjVertices = getAdjacentVertices(vertex,size);
for (Vertices::iterator it = adjVertices->begin(); it != adjVertices->end(); ++it)
{
int adjVertex = *it;
if (!reachedVertices[adjVertex])
{
nextVertices->push_back(adjVertex);
reachedVertices[adjVertex] = true;
}
}
delete adjVertices;
}
delete nextVertices;
component->setVertices(connectedVertices);
graphComponentSet->insert(component);
delete connectedVertices;
}
lastReachedVertex++;
}
for (GraphComponentSet::iterator it = graphComponentSet->begin(); it != graphComponentSet->end(); ++it)
(*it)->buildDataStructure();
}
/** Dump an entire forest to a DBMS.
*
* FIXME: This should really be using something like ODBC, but ROSE is only configured to use specific DBMS like SQLite3
* or MySQL. Therefore, since we don't need to do any queries, we'll just generate straight SQL as text (the sqlite3x API
* converts all numeric values to text anyway, so there's not really any additional slowdown or loss of precision).
* Therefore, the @p user_name and @p password arguments are unused, and @p server_name is the name of the file to which
* the SQL statements are written. */
void dump(const std::string &server_name, const std::string &user_name, const std::string &password) {
std::ofstream dbc(server_name.c_str());
renumber_vertices();
dump_outputsets(dbc);
dump_inputsets(dbc);
Vertices leaves = get_leaves();
size_t leafnum = 0;
for (Vertices::const_iterator vi=leaves.begin(); vi!=leaves.end(); ++vi, ++leafnum) {
Vertex *vertex = *vi;
const Functions &functions = vertex->get_functions();
dbc <<"insert into simsets (id) values (" <<leafnum <<");\n";
for (Functions::const_iterator fi=functions.begin(); fi!=functions.end(); ++fi)
dbc <<"insert into functions (entry_va, simset_id) values (" <<(*fi)->get_entry_va() <<", " <<leafnum <<");\n";
for (Vertex *v=vertex; v; v=v->parent)
dbc <<"insert into inoutpairs (simset_id, inputset_id, outputset_id) values ("
<<leafnum <<", " <<v->get_level() <<", " <<v->id <<");\n";
}
}
void gnuplot_print_vertices(std::ostream& out, const Vertices& vertices)
{
for (Vertex_iterator it = vertices.begin(); it != vertices.end(); ++it)
out << (*it) << " " << it->unique_id() << endl;
}
void degree_sort(Vertices &R){
set_degrees(R); sort(R.begin(), R.end(), desc_degree);
}
void mcqdyn(int* maxclique, int &sz){
set_degrees(V); sort(V.begin(),V.end(), desc_degree); init_colors(V);
for(int i = 0; i < (int)V.size() + 1; i++) S[i].i1 = S[i].i2 = 0;
expand_dyn(V); sz = (int)QMAX.size();
for(int i = 0; i < (int)QMAX.size(); i++) maxclique[i] = QMAX[i];
}
int main(int argc, char** argv)
{
if(argc != 3)
return usage(argv[0]);
mark_tag vertex_index(1), vertex_x(2), vertex_y(3), vertex_z(4);
sregex tface_re = bos >> *space >> "TFACE" >> *space >> eos;
sregex vertex_re = bos >> *space >> "VRTX"
>> +space >> (vertex_index=+_d)
>> +space >> (vertex_x=+(digit|'-'|'+'|'.'))
>> +space >> (vertex_y=+(digit|'-'|'+'|'.'))
>> +space >> (vertex_z=+(digit|'-'|'+'|'.'))
>> eos;
sregex triangle_re = bos >> *space >> "TRGL"
>> +space >> (s1=+digit)
>> +space >> (s2=+digit)
>> +space >> (s3=+digit)
>> eos;
sregex end_re = bos >> *space >> "END" >> *space >> eos;
std::ifstream input(argv[1]);
std::ofstream output(argv[2]);
if(!input) {
std::cerr << "Cannot read \"" << argv[1] << "\"!\n";
return EXIT_FAILURE;
}
if(!output) {
std::cerr << "Cannot write to \"" << argv[2] << "\"!\n";
return EXIT_FAILURE;
}
std::string line;
std::getline(input, line);
smatch results;
while(input && ! regex_match(line, tface_re)) // search line "TFACE"
{
std::getline(input, line);
}
std::getline(input, line);
while(input && regex_match(line, results, vertex_re)) {
vertices.push_back(boost::make_tuple(results[vertex_x],
results[vertex_y],
results[vertex_z]));
std::getline(input, line);
}
while(input && regex_match(line, results, triangle_re)) {
std::stringstream s;
int i, j, k;
s << results[1] << " " << results[2] << " " << results[3];
s >> i >> j >> k;
faces.push_back(boost::make_tuple(i, j, k));
std::getline(input, line);
}
if(!input || !regex_match(line, end_re))
return incorrect_input("premature end of file!");
output << "OFF " << vertices.size() << " " << faces.size() << " " << "0\n";
for(Vertices::const_iterator vit = vertices.begin(), vend = vertices.end();
vit != vend; ++vit)
output << boost::get<0>(*vit) << " "
<< boost::get<1>(*vit) << " "
<< boost::get<2>(*vit) << "\n";
for(Faces::const_iterator fit = faces.begin(), fend = faces.end();
fit != fend; ++fit)
output << "3 " << boost::get<0>(*fit)
<< " " << boost::get<1>(*fit)
<< " " << boost::get<2>(*fit) << "\n";
if(output)
return EXIT_SUCCESS;
else
return EXIT_FAILURE;
};
void GraphComponent::buildDataStructure ()
{
for (int index = 0; index < size; index++)
{
int firstVertex = vertices[index];
Datatree *tree = new Datatree(firstVertex);
Vertices *firstVertices = new Vertices();
firstVertices->insert(firstVertex);
std::list<TreeToAdd> treeToAddList;
struct TreeToAdd firstTreeToAdd = {tree,0,firstVertices,0};
treeToAddList.push_back(firstTreeToAdd);
while (!treeToAddList.empty())
{
struct TreeToAdd treeToAdd = treeToAddList.front();
Datatree *node = treeToAdd.node;
Vertices *vertices = treeToAdd.vertices;
treeToAddList.pop_front();
if (VERBOSE) {
for (int i = 0; i < VERBOSE_TAB; i++) { std::cout << "..."; }
std::cout << "(" << VERBOSE_TAB << ") CURRENTLY ON NODE ";
node->printVertices();
VERBOSE_TAB++;
}
Vertices *adjVertices = graph->getAdjacentVertices(node->vertex,graph->size);
for (Vertices::iterator it = adjVertices->begin(); it != adjVertices->end(); ++it)
{
int childVertex = *it;
if (order->at(childVertex) >= order->at(firstVertex) && vertices->find(childVertex) == vertices->end())
{
vertices->insert(childVertex);
Datatree *child = node->addChild(childVertex);
Vertices *childVertices = new Vertices(*vertices);
struct TreeToAdd childTreeToAdd = {child,0,childVertices,0};
treeToAddList.push_back(childTreeToAdd);
if (node->wholeSet)
{
datatree->parent = child;
child->wholeSet = true;
node->wholeSet = false;
}
}
}
delete adjVertices;
delete vertices;
if (VERBOSE) { VERBOSE_TAB--; }
}
treeToAddList.clear();
struct TreeToAdd newTreeToAdd = {datatree,tree,new Vertices (),0};
treeToAddList.push_back(newTreeToAdd);
while (!treeToAddList.empty())
{
struct TreeToAdd treeToAdd = treeToAddList.front();
Datatree *node = treeToAdd.node;
Datatree *nodeToAdd = treeToAdd.nodeToAdd;
Vertices *vertices = treeToAdd.vertices;
// Vertices *adjVertices = treeToAdd.adjVertices;
treeToAddList.pop_front();
if (VERBOSE) {
for (int i = 0; i < VERBOSE_TAB; i++) { std::cout << "..."; }
std::cout << "(" << VERBOSE_TAB << ") ADJUSTING NODE ";
node->printVertices(false);
std::cout << " WITH ";
nodeToAdd->printVertices(false);
std::cout << " KNOWING ";
graph->printVertices(vertices);
std::cout << std::endl;
VERBOSE_TAB++;
}
if (vertices->find(nodeToAdd->vertex) == vertices->end())
{
node = node->addChild(nodeToAdd->vertex);
vertices->insert(nodeToAdd->vertex);
}
for (TreesSet::iterator it = nodeToAdd->children->begin(); it != nodeToAdd->children->end(); ++it)
{
Datatree *child = *it;
if (vertices->find(child->vertex) == vertices->end())
{
Vertices *childVertices = new Vertices (*vertices);
struct TreeToAdd childToAdd = {node,child,childVertices,0};
treeToAddList.push_back(childToAdd);
vertices->insert(child->vertex);
}
}
if (nodeToAdd->parent != 0)
{
Vertices *parentVertices = new Vertices (*vertices);
struct TreeToAdd parentToAdd = {node,nodeToAdd->parent,parentVertices,0};
treeToAddList.push_back(parentToAdd);
}
delete vertices;
//delete adjVertices;
if (VERBOSE) { VERBOSE_TAB--; }
}
}
/*
// COMPUTE COMPLEMENTS
datatree->complement = datatree;
for (int index = 0; index < size; index++)
{
TreesList *nodeList = new TreesList();
// ADD NEW COMPLEMENTS TO COMPLEMENT LISTS
nodeList->push_back(datatree);
while (!nodeList->empty())
{
Datatree *node = nodeList->front();
nodeList->pop_front();
node->complementList->push_front(node->complement);
node->complement = 0; // NOT NECESSARY? (TO ERASE)
for (TreesSet::iterator it = node->children->begin(); it != node->children->end(); ++it)
{
if (order->at(child->vertex) < index)
{
nodeList->push_back(child);
}
}
}
// ADD VERTICES WITH INDEX = index
nodeList->push_back(datatree);
while (!nodeList->empty())
{
Datatree *node = nodeList->front();
nodeList->pop_front();
for (TreesSet::iterator it = node->children->begin(); it != node->children->end(); ++it)
{
Datatree *child = *it;
if (order->at(child->vertex) < index)
{
nodeList->push_back(child);
}
if (order->at(child->vertex) == index)
{
TreesList::iterator it2 = node->complementList->begin();
while (child != 0)
{
child->complement = *it2;
child->complement->complement = child;
child = 0;
//if (child->children->size() > 1) { std::cout << "WARNING: several added branches!" << std::endl; }
for (TreesSet::iterator it3 = child->children->begin(); it3 != child->children->end(); ++it3)
{
Datatree *newChild = *it;
if (order->at(newChild->vertex) < index)
{
newChild->complement = *it2;
newChild->complement->complement = newChild;
it2++;
}
}
}
}
}
}
*/
}
