public static Vector <double> Iterate(Hypergraph H, Vector <double> vec, int v_init, double dt, double alpha)
{
var dv = H.T(vec, v_init, alpha);
var res = vec;
res -= dv * dt;
return(res);
}
public static Vector <double> Simulate(Hypergraph H, Vector <double> vec, int v_init, double dt, double T, double alpha)
{
var cur_time = 0.0;
while (cur_time < T)
{
var next_time = Math.Min(cur_time + dt, T);
vec = Iterate(H, vec, v_init, next_time - cur_time, alpha);
cur_time = next_time;
}
return(vec);
}
public static Hypergraph Open(string fn)
{
var fs = new FileStream(fn, FileMode.Open);
var sr = new StreamReader(fs);
var edges = new List <List <int> >();
var weights = new List <double>();
int vertex_num = 0;
for (string line; (line = sr.ReadLine()) != null;)
{
var words = line.Split();
var edge = new List <int>();
int i = 0;
foreach (var word in words)
{
if (i < words.Length - 1)
{
int v = int.Parse(word);
edge.Add(v);
if (v >= vertex_num)
{
vertex_num = v + 1;
}
i++;
}
}
edges.Add(edge);
weights.Add(double.Parse(words.Last()));
}
var H = new Hypergraph();
H.edges = edges;
H.weights = weights;
for (int v = 0; v < vertex_num; v++)
{
H.incident_edges.Add(new List <int>());
}
for (int i = 0; i < edges.Count; i++)
{
var edge = edges[i];
foreach (var v in edge)
{
H.incident_edges[v].Add(i);
}
H.ID.Add(edge, i);
H.ID_rev.Add(i, edge);
}
fs.Close();
return(H);
}
public static Hypergraph RandomHypergraph(int n, int m, int k)
{
var H = new Hypergraph();
for (int i = 0; i < m; i++)
{
var edge = new List <int>();
for (int j = 0; j < k; j++)
{
int v = (int)(Util.Xor128() % n);
edge.Add(v);
}
edge = edge.Distinct().ToList();
H.AddEdge(edge);
}
return(H);
}
public static Vector <double> Simulate_round(Hypergraph H, Vector <double> vec, int v_init, double dt, double T, double alpha)
{
var active_edges = new List <List <int> >();
var active = new List <int>(new int[H.m]);
foreach (var e in H.incident_edges[v_init])
{
active_edges.Add(H.ID_rev[e]);
active[e] = 1;
}
var cur_time = 0.0;
while (cur_time < T)
{
var next_time = Math.Min(cur_time + dt, T);
vec = Iterate_round(H, vec, v_init, next_time - cur_time, alpha, active_edges, active);
cur_time = next_time;
}
return(vec);
}
public static Vector <double> Iterate_round(Hypergraph H, Vector <double> vec, int v_init, double dt, double alpha, List <List <int> > active_edges, List <int> active)
{
var dv = H.T_round(vec, v_init, alpha, active_edges);
var res = vec;
res -= dv * dt;
for (int i = 0; i < H.n; i++)
{
if (res[i] < 1e-5)
{
res[i] = 0;
}
}
var new_active_edges = new List <int>();
for (int i = 0; i < H.n; i++)
{
if (vec[i] == 0 && res[i] != 0)
{
foreach (var f in H.incident_edges[i])
{
if (active[f] == 0)
{
new_active_edges.Add(f);
active[f] = 1;
}
}
}
}
foreach (var e in new_active_edges)
{
active_edges.Add(H.ID_rev[e]);
}
return(res);
}
// for Proposed_local
public static void Proposed_local(string fn, int v_init)
{
var H = Hypergraph.Open(fn);
var time = new System.Diagnostics.Stopwatch();
time.Start();
int n = H.n;
int m = H.m;
const double eps = 0.9;
const double dt = 1.0;
const double T = 30.0;
var A_cand = new List <double>();
for (int i = 0; i <= Math.Log(n * m) / Math.Log(1 + eps); i++)
{
A_cand.Add(Math.Pow(1 + eps, i) / (n * m));
}
var edge_size = new Dictionary <int, int>();
for (int eid = 0; eid < H.m; eid++)
{
edge_size.Add(eid, H.ID_rev[eid].Count());
}
double min_conductance = double.MaxValue;
foreach (double alpha in A_cand)
{
var vec = CreateVector.Dense <double>(n);
vec[v_init] = 1.0;
vec = Hypergraph.Simulate(H, vec, v_init, dt, T, alpha);
for (int i = 0; i < n; i++)
{
vec[i] /= H.w_Degree(i);
}
int[] index = Enumerable.Range(0, n).ToArray <int>();
Array.Sort <int>(index, (a, b) => vec[a].CompareTo(vec[b]));
Array.Reverse(index);
double vol_V = 0;
for (int i = 0; i < n; i++)
{
vol_V += H.w_Degree(i);
}
var num_contained_nodes = new Dictionary <int, int>();
for (int eid = 0; eid < H.m; eid++)
{
num_contained_nodes.Add(eid, 0);
}
double cut_val = 0;
double vol_S = 0;
double conductance = double.MaxValue;
int best_index = -1;
foreach (int i in index)
{
vol_S += H.w_Degree(i);
if (vol_S <= vol_V / 10.0)
{
foreach (var e in H.incident_edges[i])
{
if (num_contained_nodes[e] == 0)
{
cut_val += H.weights[e];
}
if (num_contained_nodes[e] == edge_size[e] - 1)
{
cut_val -= H.weights[e];
}
num_contained_nodes[e] += 1;
}
conductance = cut_val / Math.Min(vol_S, vol_V - vol_S);
if (conductance < min_conductance)
{
min_conductance = conductance;
best_index = i;
}
}
else
{
break;
}
}
}
time.Stop();
TimeSpan ts = time.Elapsed;
Console.WriteLine("conductance: " + min_conductance);
Console.WriteLine("time(s): " + time.ElapsedMilliseconds / 1000.0);
}
