int BuildCapacityNetwork(const TStr& InFNm, PNEANet &Net, const int& SrcColId = 0, const int& DstColId = 1, const int& CapColId = 2) {
TSsParser Ss(InFNm, ssfWhiteSep, true, true, true);
TRnd Random;
Net.Clr();
Net = TNEANet::New();
int SrcNId, DstNId, CapVal, EId;
int MaxCap = 0;
while (Ss.Next()) {
if (! Ss.GetInt(SrcColId, SrcNId) || ! Ss.GetInt(DstColId, DstNId)) { continue; }
Ss.GetInt(CapColId, CapVal);
//CapVal = Random.GetUniDevInt(1, 10000);
MaxCap = max(CapVal, MaxCap);
if (! Net->IsNode(SrcNId)) {
Net->AddNode(SrcNId);
}
if (! Net->IsNode(DstNId)) {
Net->AddNode(DstNId);
}
EId = Net->AddEdge(SrcNId, DstNId);
Net->AddIntAttrDatE(EId, CapVal, TSnap::CapAttrName);
}
Net->Defrag();
return MaxCap;
}
int GetMaxFlowIntEK (PNEANet &Net, const int &SrcNId, const int &SnkNId) {
IAssert(Net->IsNode(SrcNId));
IAssert(Net->IsNode(SnkNId));
if (SrcNId == SnkNId) { return 0; }
int CapIndex = Net->GetIntAttrIndE(CapAttrName);
TIntV Flow(Net->GetMxEId());
// Initialize flow values to 0, and make sure capacities are nonnegative
for (TNEANet::TEdgeI EI = Net->BegEI(); EI != Net->EndEI(); EI++) {
IAssert(Net->GetIntAttrIndDatE(EI, CapIndex) >= 0);
Flow[EI.GetId()] = 0;
}
// Return 0 if user attempts to flow from a node to itself.
if (SrcNId == SnkNId) { return 0; }
int MaxFlow = 0, MinAug, CurNId;
while (true) {
TIntV MidToSrcAugV; TIntV MidToSnkAugV;
TIntQ FwdNodeQ; TIntQ BwdNodeQ;
TIntH PredEdgeH; TIntH SuccEdgeH;
MinAug = FindAugV(Net, CapIndex, Flow, FwdNodeQ, PredEdgeH, BwdNodeQ, SuccEdgeH, MidToSrcAugV, MidToSnkAugV, SrcNId, SnkNId);
if (MinAug == 0) { break; }
MaxFlow += MinAug;
CurNId = SrcNId;
for (int i = MidToSrcAugV.Len() - 1; i >= 0; i--) {
int NextEId = MidToSrcAugV[i];
const TNEANet::TEdgeI &EI = Net->GetEI(NextEId);
if (EI.GetSrcNId() == CurNId) {
Flow[NextEId] += MinAug;
CurNId = EI.GetDstNId();
} else {
Flow[NextEId] -= MinAug;
CurNId = EI.GetSrcNId();
}
}
for (int i = 0; i < MidToSnkAugV.Len(); i++) {
int NextEId = MidToSnkAugV[i];
const TNEANet::TEdgeI &EI = Net->GetEI(NextEId);
if (EI.GetSrcNId() == CurNId) {
Flow[NextEId] += MinAug;
CurNId = EI.GetDstNId();
} else {
Flow[NextEId] -= MinAug;
CurNId = EI.GetSrcNId();
}
}
}
return MaxFlow;
}
int GetMaxFlowIntPR (PNEANet &Net, const int& SrcNId, const int& SnkNId) {
IAssert(Net->IsNode(SrcNId));
IAssert(Net->IsNode(SnkNId));
if (SrcNId == SnkNId) { return 0; }
TPRManager PRM(Net);
int MaxLabel = PRM.GetMaxLabel();
TNEANet::TNodeI SrcNI = Net->GetNI(SrcNId);
for (int EdgeN = 0; EdgeN < SrcNI.GetOutDeg(); EdgeN++) {
int EId = SrcNI.GetOutEId(EdgeN);
int OutNId = SrcNI.GetOutNId(EdgeN);
if (OutNId != SrcNId) {
int Capacity = PRM.Capacity(EId);
PRM.Flow(EId) = Capacity;
PRM.Excess(OutNId) = Capacity;
}
}
GlobalRelabel(Net, PRM, SrcNId, SnkNId);
PRM.SetLabel(SrcNId, MaxLabel);
int RelabelCount = 1;
int GRRate = Net->GetNodes();
while (PRM.HasActive()) {
int NId = PRM.PopActive();
const TNEANet::TNodeI &NI = Net->GetNI(NId);
int PrevLabel = MaxLabel;
while (PRM.Excess(NId) > 0 && PRM.Label(NId) <= PrevLabel) {
PrevLabel = PRM.Label(NId);
int NbrNId = PushRelabel(PRM, NId, NI);
if (NbrNId != -1 && NbrNId != SnkNId && PRM.Excess(NbrNId) > 0 && !PRM.IsActive(NbrNId)) {
PRM.PushActive(NbrNId);
}
}
if (PRM.Excess(NId) > 0 && PRM.Label(NId) < MaxLabel) {
PRM.PushActive(NId);
}
if (RelabelCount % GRRate == 0) { GlobalRelabel(Net, PRM, SrcNId, SnkNId); }
}
return PRM.Excess(SnkNId);
}
// Test node, edge creation
TEST(TNEANet, ManipulateNodesEdges) {
int NNodes = 1000;
int NEdges = 100000;
const char *FName = "test.graph.dat";
PNEANet Graph;
PNEANet Graph1;
PNEANet Graph2;
int i;
int n;
int NCount;
int x,y;
int Deg, InDeg, OutDeg;
Graph = TNEANet::New();
EXPECT_EQ(1,Graph->Empty());
// create the nodes
for (i = 0; i < NNodes; i++) {
Graph->AddNode(i);
}
EXPECT_EQ(0,Graph->Empty());
EXPECT_EQ(NNodes,Graph->GetNodes());
// create random edges
NCount = NEdges;
while (NCount > 0) {
x = (long) (drand48() * NNodes);
y = (long) (drand48() * NNodes);
n = Graph->AddEdge(x, y);
NCount--;
}
EXPECT_EQ(NEdges,Graph->GetEdges());
EXPECT_EQ(0,Graph->Empty());
EXPECT_EQ(1,Graph->IsOk());
for (i = 0; i < NNodes; i++) {
EXPECT_EQ(1,Graph->IsNode(i));
}
EXPECT_EQ(0,Graph->IsNode(NNodes));
EXPECT_EQ(0,Graph->IsNode(NNodes+1));
EXPECT_EQ(0,Graph->IsNode(2*NNodes));
// nodes iterator
NCount = 0;
for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
NCount++;
}
EXPECT_EQ(NNodes,NCount);
// edges per node iterator
NCount = 0;
for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
for (int e = 0; e < NI.GetOutDeg(); e++) {
NCount++;
}
}
EXPECT_EQ(NEdges,NCount);
// edges iterator
NCount = 0;
for (TNEANet::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
NCount++;
}
EXPECT_EQ(NEdges,NCount);
// node degree
for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
Deg = NI.GetDeg();
InDeg = NI.GetInDeg();
OutDeg = NI.GetOutDeg();
EXPECT_EQ(Deg,InDeg+OutDeg);
}
// assignment
Graph1 = TNEANet::New();
*Graph1 = *Graph;
EXPECT_EQ(NNodes,Graph1->GetNodes());
EXPECT_EQ(NEdges,Graph1->GetEdges());
EXPECT_EQ(0,Graph1->Empty());
EXPECT_EQ(1,Graph1->IsOk());
// saving and loading
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
}
{
TFIn FIn(FName);
Graph2 = TNEANet::Load(FIn);
}
EXPECT_EQ(NNodes,Graph2->GetNodes());
EXPECT_EQ(NEdges,Graph2->GetEdges());
EXPECT_EQ(0,Graph2->Empty());
EXPECT_EQ(1,Graph2->IsOk());
// remove all the nodes and edges
for (i = 0; i < NNodes; i++) {
n = Graph->GetRndNId();
Graph->DelNode(n);
}
EXPECT_EQ(0,Graph->GetNodes());
EXPECT_EQ(0,Graph->GetEdges());
EXPECT_EQ(1,Graph->IsOk());
EXPECT_EQ(1,Graph->Empty());
Graph1->Clr();
EXPECT_EQ(0,Graph1->GetNodes());
EXPECT_EQ(0,Graph1->GetEdges());
EXPECT_EQ(1,Graph1->IsOk());
EXPECT_EQ(1,Graph1->Empty());
}