genmodel 0.0.30 → 0.0.31

data/ext/Genmodel/GraphTools.cpp

@@ -49,6 +49,11 @@ vector<vector<size_t> > GmGraph::GetCliqueCover()
             ++(node_depth[dc[i]]);
         size_t depth = 1;
         
+        // Find a mximal clique containing the current edge curr_e
+        // The clique C is maximal in the sense that there is no clique C'
+        // strictly containing C (and mot in the sense that is the largest clique
+        // containing curr_e)
+        
         while(next_n != -1 && depth < e*e)
         {
             //printf("1-Add %ld (depth %ld)\n", next_n, depth);

data/ext/Genmodel/HyperGraph.cpp

@@ -0,0 +1,400 @@
+/*
+ * HyperGraph.cpp
+ *
+ *  Created on: 2011-03-17
+ *      Author: mbouchard
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "HyperGraph.h"
+
+void checkbound(uint i, uint ub);
+
+int HyperGraph::SetQty(uint n, uint e)
+{
+	hnodes.resize(n);
+	hnodes.assign(n, HyperGen(0.0));
+
+	hedges.resize(n);
+	hedges.assign(n, HyperGen(0.0));
+
+	hn = n;
+	he = e;
+
+	return 0;
+}
+
+int HyperGraph::SetTopologicalOrder()
+{
+    vector<bool> nvis;
+	nvis.resize(hn, false);
+	vector<uint> nnext;
+    
+	list<uint> tocheck;
+	for(uint i = 0; i < hn; i++)
+		tocheck.push_back(i);
+    
+	uint nodecount = 0;
+    
+	layers.push_back(vector<uint>());
+	list<uint>::iterator it;
+	for(it = tocheck.begin(); it != tocheck.end();)
+	{
+		if(hnodes[*it].dout == 0)
+		{
+			layers.back().push_back(*it);
+			nvis[*it] = true;
+			nodecount++;
+			it = tocheck.erase(it);
+		}
+		else
+			it++;
+	}
+    
+	uint iter = 0;
+	is_cyclic = false;
+    
+	while(!tocheck.empty() && iter < hn)
+	{
+		layers.push_back(vector<uint>());
+        
+		vector<bool> tempvis;
+		tempvis.resize(hn, true);
+        
+		for(it = tocheck.begin(); it != tocheck.end();)
+		{
+			uint in = *it;
+            
+			for(uint j = 0; j < hnodes[in].dout; j++)
+			{
+				uint ie = hnodes[in].all[hnodes[in].out[j]];
+				for(uint k = 0; k < hedges[ie].dout; k++)
+				{
+					uint inn = hedges[ie].all[hedges[ie].out[k]];
+					if(!nvis[inn])
+						tempvis[in] = false;
+				}
+			}
+			if(tempvis[in])
+			{
+				nnext.push_back(in);
+				layers.back().push_back(in);
+				it = tocheck.erase(it);
+				nodecount++;
+			}
+			else
+				it++;
+		}
+		if(nnext.empty())
+		{
+			is_cyclic = true;
+			break;
+		}
+        
+		for(uint i = 0; i < (uint)(nnext.size()); i++)
+			nvis[nnext[i]] = true;
+		nnext.clear();
+        
+		iter++;
+	}
+	if(iter > he)
+        is_cyclic = true;
+    
+    order.clear();
+    order.resize(hn, 0);
+    uint index = 0;
+    for(uint i = 0; i < layers.size(); ++i)
+		for(uint j = 0; j < layers[i].size(); ++j, ++index)
+            order[index] = layers[i][j];
+    
+    return 0;
+}
+
+int HyperGraph::PairNodeAndEdge(uint ni, uint ei, double t, bool force)
+{
+	if(!force && t == 0.0)
+		return 0;
+
+	checkbound(ei, he);
+	checkbound(ni, hn);
+	hedges[ei].all.push_back(ni);
+	hedges[ei].tau.push_back(t);
+	hedges[ei].dall++;
+	hnodes[ni].all.push_back(ei);
+	hnodes[ni].tau.push_back(t);
+	hnodes[ni].dall++;
+
+	if(t < 0)
+	{
+		hedges[ei].in.push_back(hedges[ei].dall-1);
+		hedges[ei].din++;
+		hnodes[ni].out.push_back(hnodes[ni].dall-1);
+		hnodes[ni].dout++;
+	}
+	else
+	{
+		hedges[ei].out.push_back(hedges[ei].dall-1);
+		hedges[ei].dout++;
+		hnodes[ni].in.push_back(hnodes[ni].dall-1);
+		hnodes[ni].din++;
+	}
+
+	return 0;
+}
+
+int AddGens(uint nq, vector<HyperGen>* vhg, uint* cq)
+{
+	if(nq == 1)
+		vhg->push_back(HyperGen(0.0));
+	else
+		vhg->resize(*cq+nq, HyperGen(0.0));
+	(*cq)+=nq;
+	return 0;
+}
+
+int SetGenVal(uint i, double nval, vector<HyperGen>* vhg, uint s)
+{
+	checkbound(i, s);
+	(*vhg)[i].val = nval;
+	return 0;
+}
+
+int SetGenUb(uint i, double nub, vector<HyperGen>* vhg, uint s)
+{
+	checkbound(i, s);
+	(*vhg)[i].ub = nub;
+	return 0;
+}
+
+int SetGenLb(uint i, double nlb, vector<HyperGen>* vhg, uint s)
+{
+	checkbound(i, s);
+	(*vhg)[i].lb = nlb;
+	return 0;
+}
+
+int SetGenName(uint i, string name, vector<HyperGen>* vhg, uint s)
+{
+	checkbound(i, s);
+	(*vhg)[i].name = name;
+	return 0;
+}
+
+int RemoveGen(uint n1, vector<HyperGen>* hv1, vector<HyperGen>* hv2, uint* hq)
+{
+	for(uint i = 0; i < (*hv1)[n1].dall; i++)
+	{
+		uint n2 = (*hv1)[n1].all[i];
+		vector<uint>::iterator ita = (*hv2)[n2].all.begin();
+		vector<double>::iterator itt = (*hv2)[n2].tau.begin();
+		vector<uint>::iterator iti = (*hv2)[n2].in.begin();
+		vector<uint>::iterator ito = (*hv2)[n2].out.begin();
+
+		uint remindex = 0;
+		uint indexcnt = 0;
+		while(ita != (*hv2)[n2].all.end())
+		{
+			if(n1 == *ita)
+			{
+				ita = (*hv2)[n2].all.erase(ita);
+				itt = (*hv2)[n2].tau.erase(itt);
+				remindex=indexcnt;
+			}
+			else
+			{
+				ita++;
+				itt++;
+				indexcnt++;
+			}
+		}
+
+		while(iti != (*hv2)[n2].in.end())
+		{
+			if(remindex == *iti)
+				iti = (*hv2)[n2].in.erase(iti);
+			else
+			{
+				if(*iti > remindex)
+					(*iti)--;
+				iti++;
+			}
+		}
+
+		while(ito != (*hv2)[n2].out.end())
+		{
+			if(remindex == *ito)
+				ito = (*hv2)[n2].out.erase(ito);
+			else
+			{
+				if(*ito > remindex)
+					(*ito)--;
+				ito++;
+			}
+		}
+	}
+
+	vector<HyperGen>::iterator it = hv1->begin();
+	for(uint i = 0; i < n1; i++)
+		it++;
+
+	hv1->erase(it);
+	(*hq)--;
+
+	return 0;
+}
+
+int HyperGraph::AddNodes(uint n)
+{
+	return AddGens(n, &hnodes, &hn);
+}
+
+int HyperGraph::SetNodeVal(uint i, double nval)
+{
+	return SetGenVal(i, nval, &hnodes, hn);
+}
+
+int HyperGraph::SetNodeUb(uint i, double nub)
+{
+	return SetGenUb(i, nub, &hnodes, hn);
+}
+
+int HyperGraph::SetNodeLb(uint i, double nlb)
+{
+	return SetGenLb(i, nlb, &hnodes, hn);
+}
+
+
+int HyperGraph::SetNodeName(uint i, string name)
+{
+	return SetGenName(i, name, &hnodes, hn);
+}
+
+int HyperGraph::AddEdges(uint e)
+{
+	return AddGens(e, &hedges, &he);
+}
+
+int HyperGraph::SetEdgeVal(uint i, double nval)
+{
+	return SetGenVal(i, nval, &hedges, he);
+}
+
+int HyperGraph::SetEdgeUb(uint i, double nub)
+{
+	return SetGenUb(i, nub, &hedges, he);
+}
+
+int HyperGraph::SetEdgeLb(uint i, double nlb)
+{
+	return SetGenLb(i, nlb, &hedges, he);
+}
+
+int HyperGraph::SetEdgeName(uint i, string name)
+{
+	return SetGenName(i, name, &hedges, he);
+}
+
+int HyperGraph::RemoveEdge(uint e)
+{
+	return RemoveGen(e, &hedges, &hnodes, &he);
+}
+int HyperGraph::RemoveNode(uint n)
+{
+	return RemoveGen(n, &hnodes, &hedges, &hn);
+}
+
+int HyperGraph::Clean(vector<bool>& exin, vector<bool>& exout)
+{
+	vector<uint> nstatus;
+	vector<uint> ndin;
+	vector<uint> ndout;
+	for(long i = 0; i < hn; i++)
+	{
+		ndin.push_back(hnodes[i].din);
+		ndout.push_back(hnodes[i].dout);
+	}
+	nstatus.resize(hn, 0);
+	vector<uint> estatus;
+	vector<uint> edin;
+	vector<uint> edout;
+	for(long i = 0; i < he; i++)
+	{
+		edin.push_back(hedges[i].din);
+		edout.push_back(hedges[i].dout);
+	}
+	estatus.resize(he, 0);
+
+	vector<uint> nfinal;
+	for(long i = 0; i < hn; i++)
+		nfinal[i] = i;
+
+
+	uint erem = 1;
+	uint nrem = 1;
+	uint terem = 1;
+	uint tnrem = 1;
+
+//	list<double> rn;
+//	for(long i = 0; i < hn; i++)
+//		rn.push_back(i);
+//	list<double> re;
+//	for(long i = 0; i < he; i++)
+//		re.push_back(i);
+
+	while(erem > 0 || nrem > 0)
+	{
+		erem = 0;
+		nrem = 0;
+		// Analysing nodes
+		for(uint i = 0; i < hn; i++)
+		{
+			if(nstatus[i] > 0)
+				continue;
+			if(ndin[i] == 0 && !exout[i])
+			{
+				nstatus[i] = 1;
+				for(uint j = 0; j < hnodes[i].dout; j++)
+					edin[hnodes[i].all[hnodes[i].out[j]]]--;
+				nrem++;
+				tnrem++;
+			}
+			else if(ndout[i] == 0 && !exin[i])
+			{
+				nstatus[i] = 2;
+				for(uint j = 0; j < hnodes[i].din; j++)
+					edin[hnodes[i].all[hnodes[i].in[j]]]--;
+				nrem++;
+				tnrem++;
+			}
+		}
+
+		// Analysing edges
+		for(uint i = 0; i < he; i++)
+		{
+			if(estatus[i] > 0)
+				continue;
+			if(edin[i] == 0 || edout[i] == 0)
+			{
+				estatus[i] = 1;
+				for(uint j = 0; j < hedges[i].dout; j++)
+					ndin[hedges[i].all[hedges[i].out[j]]]--;
+				for(uint j = 0; j < hedges[i].din; j++)
+					ndout[hedges[i].all[hedges[i].in[j]]]--;
+
+				erem++;
+				terem++;
+			}
+		}
+	}
+
+	//printf("%d nnodes removed, %d edges removed\n", tnrem, terem);
+
+	return 0;
+}
+
+void checkbound(uint i, uint ub)
+{
+	if(i > ub)
+		throw string("HyperGraph : index out of bound");
+}

data/ext/Genmodel/HyperGraph.h

@@ -0,0 +1,90 @@
+/*
+ * HyperGraph.h
+ *
+ *  Created on: 2011-03-17
+ *      Author: mbouchard
+ */
+
+#ifndef HYPERGRAPH_H_
+#define HYPERGRAPH_H_
+
+#include <vector>
+#include <limits>
+#include <string>
+#include <list>
+#include <stdlib.h>
+#define uint unsigned long
+
+using namespace std;
+
+class HyperGen;
+class GenFunction;
+
+class HyperGraph
+{
+public:
+	HyperGraph() {hn=0; he = 0;}
+	~HyperGraph() {}
+	uint hn;
+	uint he;
+
+	int SetQty(uint n, uint e);
+	int AddNodes(uint n);
+	int SetNodeUb(uint i, double nub);
+	int SetNodeLb(uint i, double nlb);
+	int SetNodeVal(uint i, double nval);
+	int SetNodeName(uint i, string name);
+	int SetEdgeUb(uint i, double nub);
+	int SetEdgeLb(uint i, double nlb);
+	int SetEdgeVal(uint i, double nval);
+	int SetEdgeName(uint i, string name);
+    int SetTopologicalOrder();
+	int AddEdges(uint e);
+	int RemoveEdge(uint e);
+	int RemoveNode(uint e);
+	//int Contract();
+	int Clean(vector<bool>& exin, vector<bool>& exout);
+	int PairNodeAndEdge(uint ni, uint ei, double t, bool force = false);
+
+	vector<HyperGen> hnodes;
+	vector<HyperGen> hedges;
+    
+    vector<uint> order;
+    vector<vector<uint> > layers;
+    bool is_cyclic;
+};
+
+class HyperGen
+{
+public:
+	HyperGen() {val = 0.0; dall=0; din=0; dout = 0; ub = numeric_limits<double>::infinity();}
+	HyperGen(double nval) {val = nval; dall=0; din=0; dout = 0; ub = numeric_limits<double>::infinity();}
+	~HyperGen() {}
+	uint dall;
+	uint din;
+	uint dout;
+	// max val x; Ax=b; lb <= x <= ub; min b y + ub c+ + lb c- A'y + c+ - c- = cost
+	double val; // cost for hedges, demand for hnodes
+	double ub;  // ub for hedges, positive complement cost for hnodes
+	double lb;  // lb for hedges, negative complement cost for hnodes
+	string name;
+//	GenFunction* f;
+	vector<uint> all;
+	vector<uint> in;
+	vector<uint> out;
+	vector<double> tau;
+};
+
+/*
+class GenFunction
+{
+public:
+	GenFunction() {};
+	~GenFunction() {};
+	virtual double f(double x) = 0;
+//	virtual double invf(double x) = 0;
+	virtual double auc(double x) = 0;
+};
+*/
+
+#endif /* HYPERGRAPH_H_ */

data/ext/Genmodel/mygraph.cpp

@@ -12,8 +12,8 @@ vector<size_t> myGraph::ie(size_t i)
 {
     vector<size_t> out(incs[i].size());
     map<size_t, size_t>::iterator it;
-    size_t ii;
-    for (it = incs[i].begin(); it != incs[i].end(); ++it)
+    size_t ii = 0;
+    for (it = incs[i].begin(); it != incs[i].end(); ++it, ++ii)
         out[ii] = it->second;
     return out;
 }
@@ -32,8 +32,8 @@ vector<size_t> myGraph::in(size_t i)
 {
     vector<size_t> out(incs[i].size());
     map<size_t, size_t>::iterator it;
-    size_t ii;
-    for (it = incs[i].begin(); it != incs[i].end(); ++it)
+    size_t ii = 0;
+    for (it = incs[i].begin(); it != incs[i].end(); ++it, ++ii)
         out[ii] = it->first;
     return out;
 }
@@ -76,6 +76,8 @@ size_t myGraph::addEdge(size_t i, size_t j)
     else
     {
         edges.push_back(pair<size_t, size_t>(i,j));
+        incs[i][j] = _e;
+        incs[j][i] = _e;
         return _e++;
     }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: genmodel
 version: !ruby/object:Gem::Version
-  version: 0.0.30
+  version: 0.0.31
 platform: ruby
 authors:
 - Mathieu Bouchard
@@ -30,6 +30,8 @@ files:
 - ext/Genmodel/Genmodel.cpp
 - ext/Genmodel/GraphTools.cpp
 - ext/Genmodel/GraphTools.h
+- ext/Genmodel/HyperGraph.cpp
+- ext/Genmodel/HyperGraph.h
 - ext/Genmodel/ProblemReaderOsi.cpp
 - ext/Genmodel/ProblemReaderOsi.h
 - ext/Genmodel/extconf.rb