int TGnuPlot::AddExpFit(const int& PlotId, const TGpSeriesTy& SeriesTy, const double& FitXOffset, const TStr& Style) {
const TGpSeries& Plot = SeriesV[PlotId];
if(Plot.XYValV.Empty()) return -1;
const TFltKdV& XY = Plot.XYValV;
double A, B, R2, SigA, SigB, Chi2;
// power fit
TFltPrV XYPr;
int s;
for (s = 0; s < XY.Len(); s++) {
if (XY[s].Key-FitXOffset > 0) {
XYPr.Add(TFltPr(XY[s].Key-FitXOffset, XY[s].Dat)); } //!!! skip zero values
}
TSpecFunc::ExpFit(XYPr, A, B, SigA, SigB, Chi2, R2);
TStr Label, StyleStr=Style;
if (FitXOffset == 0) { Label = TStr::Fmt("%.4g exp(%.4g x) R^2:%.2g", A, B, R2); }
else { Label = TStr::Fmt("%.4g exp(%.4g x - %g) R^2:%.2g", A, B, FitXOffset, R2); }
if (StyleStr.Empty()) { StyleStr = "linewidth 3"; }
const int FitId = AddFunc(TStr::Fmt("%f*exp(%f*x-%f)", A, B, FitXOffset),
SeriesTy, Label, StyleStr);
return FitId;
/*SeriesV.Add();
TGpSeries& NewPlot = SeriesV.Last();
TFltKdV& EstXY = NewPlot.XYValV;
for (s = 0; s < XYPr.Len(); s++) {
EstXY.Add(TFltKd(XYPr[s].Val1+FitXOffset, A*exp(B*XYPr[s].Val1)));
}
NewPlot.SeriesTy = SeriesTy;
if (Style.Empty()) { NewPlot.WithStyle = "linewidth 3"; }
else { NewPlot.WithStyle = Style; }
return SeriesV.Len() - 1;*/
}
int TGnuPlot::AddErrBar(const TFltPrV& XYValV, const TFltV& DeltaYV, const TStr& Label) {
TFltKdV XYFltValV(XYValV.Len(), 0);
for (int i = 0; i < XYValV.Len(); i++) {
XYFltValV.Add(TFltKd(XYValV[i].Val1, XYValV[i].Val2));
}
return AddErrBar(XYFltValV, DeltaYV, Label);
}
int TGnuPlot::AddLogFit(const int& PlotId, const TGpSeriesTy& SeriesTy, const TStr& Style) {
const TGpSeries& Plot = SeriesV[PlotId];
if(Plot.XYValV.Empty()) return -1;
const TFltKdV& XY = Plot.XYValV;
double A, B, R2, SigA, SigB, Chi2;
// power fit
TFltPrV XYPr;
int s;
for (s = 0; s < XY.Len(); s++) {
if (XY[s].Key > 0) {
XYPr.Add(TFltPr(XY[s].Key, XY[s].Dat)); } //!!! skip zero values
}
TSpecFunc::LogFit(XYPr, A, B, SigA, SigB, Chi2, R2);
TStr StyleStr=Style;
if (StyleStr.Empty()) { StyleStr = "linewidth 3"; }
const int FitId = AddFunc(TStr::Fmt("%f+%f*log(x)", A, B),
SeriesTy, TStr::Fmt("%.4g + %.4g log(x) R^2:%.2g", A, B, R2), StyleStr);
return FitId;
/*SeriesV.Add();
TGpSeries& NewPlot = SeriesV.Last();
TFltKdV& EstXY = NewPlot.XYValV;
for (s = 0; s < XYPr.Len(); s++) {
EstXY.Add(TFltKd(XYPr[s].Val1, A+B*log((double)XYPr[s].Val1)));
}
NewPlot.Label = TStr::Fmt("%.4g + %.4g log(x) R^2:%.2g", A, B, R2);
NewPlot.SeriesTy = SeriesTy;
if (Style.Empty()) { NewPlot.WithStyle = "linewidth 3"; }
else { NewPlot.WithStyle = Style; }
return SeriesV.Len() - 1;*/
}
double CalcEffDiam(const TFltPrV& DistNbrsCdfV, const double& Percentile) {
TIntFltKdV KdV(DistNbrsCdfV.Len(), 0);
for (int i = 0; i < DistNbrsCdfV.Len(); i++) {
KdV.Add(TIntFltKd(int(DistNbrsCdfV[i].Val1()), DistNbrsCdfV[i].Val2));
}
return CalcEffDiam(KdV, Percentile);
}
int TGnuPlot::AddPlot(const TFltPrV& XYValV, const TGpSeriesTy& SeriesTy, const TStr& Label, const TStr& Style) {
TFltKdV XYFltValV(XYValV.Len(), 0);
for (int i = 0; i < XYValV.Len(); i++) {
XYFltValV.Add(TFltKd(XYValV[i].Val1, XYValV[i].Val2));
}
return AddPlot(XYFltValV, SeriesTy, Label, Style);
}
void TSirSR2Model::SetMediaBlogV(const TFltPrV& _MediaV, const TFltPrV& _BlogV) {
IAssert(_MediaV.Len() == _BlogV.Len());
MediaV.Clr(false); BlogV.Clr(false);
for (int i = 0; i < _MediaV.Len(); i++) {
MediaV.Add(_MediaV[i].Val2);
BlogV.Add(_BlogV[i].Val2);
}
}
void TGUtil::Normalize(TFltPrV& PdfV) {
double Sum = 0.0;
for (int i = 0; i < PdfV.Len(); i++) {
Sum += PdfV[i].Val2; }
if (Sum <= 0.0) { return; }
for (int i = 0; i < PdfV.Len(); i++) {
PdfV[i].Val2 /= Sum; }
}
void TGStatVec::GetValV(const TGStatVal& XVal, const TGStatVal& YVal, TFltPrV& ValV) const {
ValV.Gen(Len(), 0);
double x;
for (int t = 0; t < Len(); t++) {
if (XVal == gsvTime) { x = t+1; }
else { x = At(t)->GetVal(XVal); }
ValV.Add(TFltPr(x, At(t)->GetVal(YVal)));
}
}
// Test GetClustCf (Distribution and Closed and Open)
TEST(triad, TestGetClustCfDistCO) {
const int ExpClosedTr = 3; // Expected closed triads
const int ExpOpenTr = 9; // Expected open triads
// Test TUNGraph
PUNGraph GraphTUN = TriadGetTestTUNGraph();
TFltPrV DegToCCfV;
int64 ClosedTr = 0;
int64 OpenTr = 0;
TSnap::GetClustCf(GraphTUN, DegToCCfV, ClosedTr, OpenTr);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
// TNGraph should be treated as TUNGraph for calculations
PNGraph GraphTN = TriadGetTestTNGraph();
DegToCCfV.Clr();
ClosedTr = 0;
OpenTr = 0;
TSnap::GetClustCf(GraphTN, DegToCCfV, ClosedTr, OpenTr);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
// TNEGraph is not treated the same! Be careful with multigraphs
PNEGraph GraphTNE = TriadGetTestTNEGraph();
DegToCCfV.Clr();
ClosedTr = 0;
OpenTr = 0;
TSnap::GetClustCf(GraphTNE, DegToCCfV, ClosedTr, OpenTr);
for (TFltPr *Pair = DegToCCfV.BegI(); Pair < DegToCCfV.EndI(); Pair++) {
double Diff = Pair->Val2 - 5.0/9.0; // Used for case 4
Diff = (Diff < 0) ? -1.0*Diff : Diff; // Used for case 4
switch ((int) Pair->Val1) {
case 2:
EXPECT_EQ(1.0, Pair->Val2);
break;
case 4:
EXPECT_GT(0.00001, Diff); // Due to floats being imprecise
break;
case 7:
EXPECT_EQ(2.0/3.0, Pair->Val2);
break;
case 15:
EXPECT_EQ(0.3, Pair->Val2);
break;
default:
ASSERT_FALSE(true); // Shouldn't have degrees other than listed
break;
}
}
EXPECT_EQ(ExpClosedTr, ClosedTr);
EXPECT_EQ(ExpOpenTr, OpenTr);
}
// Inverse participation ratio: normalize EigVec to have L2=1 and then I=sum_k EigVec[i]^4
// see Spectra of "real-world" graphs: Beyond the semicircle law by Farkas, Derenyi, Barabasi and Vicsek
void PlotInvParticipRat(const PUNGraph& Graph, const int& MaxEigVecs, const int& TimeLimit, const TStr& FNmPref, TStr DescStr) {
TFltPrV EigIprV;
GetInvParticipRat(Graph, MaxEigVecs, TimeLimit, EigIprV);
if (DescStr.Empty()) { DescStr = FNmPref; }
if (EigIprV.Empty()) { DescStr+=". FAIL"; EigIprV.Add(TFltPr(-1,-1)); return; }
TGnuPlot::PlotValV(EigIprV, "eigIPR."+FNmPref, TStr::Fmt("%s. G(%d, %d). Largest eig val = %f (%d values)",
DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges(), EigIprV.Last().Val1(), EigIprV.Len()),
"Eigenvalue", "Inverse Participation Ratio of corresponding Eigenvector", gpsLog10Y, false, gpwPoints);
}
int TGnuPlot::AddErrBar(const TFltPrV& XYValV, const TFltV& DeltaV, const TStr& DatLabel, const TStr& ErrLabel) {
TFltKdV XYFltValV(XYValV.Len(), 0);
for (int i = 0; i < XYValV.Len(); i++) {
XYFltValV.Add(TFltKd(XYValV[i].Val1, XYValV[i].Val2));
}
const int PlotId = AddPlot(XYFltValV, gpwLinesPoints, DatLabel);
AddErrBar(XYFltValV, DeltaV, ErrLabel);
return PlotId;
}
void TGnuPlot::MakeExpBins(const TFltPrV& XYValV, TFltPrV& ExpXYValV, const double& BinFactor, const double& MinYVal) {
TFltKdV KdV(XYValV.Len(), 0), OutV;
for (int i = 0; i < XYValV.Len(); i++) {
KdV.Add(TFltKd(XYValV[i].Val1, XYValV[i].Val2)); }
KdV.Sort();
TGnuPlot::MakeExpBins(KdV, OutV, BinFactor, MinYVal);
ExpXYValV.Gen(OutV.Len(), 0);
for (int i = 0; i < OutV.Len(); i++) {
ExpXYValV.Add(TFltPr(OutV[i].Key, OutV[i].Dat)); }
}
void GetNEFromAccDistr(const TFltPrV& deg, int& nodes, int& edges){
double nodesD = deg[0].Val2.Val, edgesD = 0;
for (int i = 0; i < deg.Len(); i++){
if (i == deg.Len()-1)
edgesD += deg[i].Val1.Val * deg[i].Val2.Val;
else edgesD += deg[i].Val1.Val * (deg[i].Val2.Val - deg[i+1].Val2.Val);
}
nodes = static_cast<int>(nodesD);
edges = static_cast<int>(edgesD);
// edges /= 2; as Deg = inDeg + outDeg
}
void TFfGGen::PlotFireSize(const TStr& FNmPref, const TStr& DescStr) {
TGnuPlot GnuPlot("fs."+FNmPref, TStr::Fmt("%s. Fire size. G(%d, %d)",
DescStr.CStr(), Graph->GetNodes(), Graph->GetEdges()));
GnuPlot.SetXYLabel("Vertex id (iterations)", "Fire size (node out-degree)");
TFltPrV IdToOutDegV;
for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
IdToOutDegV.Add(TFltPr(NI.GetId(), NI.GetOutDeg())); }
IdToOutDegV.Sort();
GnuPlot.AddPlot(IdToOutDegV, gpwImpulses, "Node out-degree");
GnuPlot.SavePng();
}
// Test GetClustCf (Distribution and Closed and Open)
TEST(triad, TestGetClustCfDistCO) {
const int expected_closed = 3; // Expected closed triads
const int expected_open = 9; // Expected open triads
// Test TUNGraph
PUNGraph Graph_TUNGraph = TriadGetTestTUNGraph();
TFltPrV DegToCCfV;
int64 closed = 0, open = 0;
TSnap::GetClustCf(Graph_TUNGraph, DegToCCfV, closed, open);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(expected_closed, closed);
EXPECT_EQ(expected_open, open);
// TNGraph should be treated as TUNGraph for calculations
PNGraph Graph_TNGraph = TriadGetTestTNGraph();
DegToCCfV.Clr();
closed = 0, open = 0;
TSnap::GetClustCf(Graph_TNGraph, DegToCCfV, closed, open);
TestDegToCCfVector(DegToCCfV);
EXPECT_EQ(expected_closed, closed);
EXPECT_EQ(expected_open, open);
// TNEGraph is not treated the same! Be careful with multigraphs
PNEGraph Graph_TNEGraph = TriadGetTestTNEGraph();
DegToCCfV.Clr();
closed = 0, open = 0;
TSnap::GetClustCf(Graph_TNEGraph, DegToCCfV, closed, open);
for (TFltPr *pair = DegToCCfV.BegI(); pair < DegToCCfV.EndI(); pair++) {
double diff = pair->Val2 - 5.0/9.0; // Used for case 4
diff = (diff < 0) ? -1.0*diff : diff; // Used for case 4
switch ((int) pair->Val1) {
case 2:
EXPECT_EQ(1.0, pair->Val2);
break;
case 4:
EXPECT_GT(0.00001, diff); // Due to floats being imprecise
break;
case 7:
EXPECT_EQ(2.0/3.0, pair->Val2);
break;
case 15:
EXPECT_EQ(0.3, pair->Val2);
break;
default:
ASSERT_FALSE(true); // Shouldn't have degrees other than listed
break;
}
}
EXPECT_EQ(expected_closed, closed);
EXPECT_EQ(expected_open, open);
}
void GetCumDistr(const TFltPrV& nonCum, TFltPrV& res){
for (int i = nonCum.Len() - 1; i >=0; i--){
TFlt count;
if (i == nonCum.Len() - 1)
count = nonCum[i].Val2.Val;
else
count = nonCum[i].Val2.Val + res[res.Len()-1].Val2.Val;
TFltPr val(nonCum[i].Val1, count);
res.Add(val);
}
res.Sort();
}
void plotScatterLengthOfEachCascade(THash<TUInt,TSecTmV>& c1, THash<TUInt,TSecTmV>& c2)
{
printf("\n\nPlotting ...\n");
TFltPrV plotdata;
for(int q=0;q<c1.Len();q++)
{
TFltPr elem;
elem.Val1 = c1[q].Len();
elem.Val2 = c2[q].Len();
plotdata.Add(elem);
}
Tools::plotScatter(plotdata, "TwitterUrlsOverContents", "Urls on Twitter", "Contents on Twitter");
}
void plotScatterLengthOfEachCascade(THash<TStr,CascadeElementV>& quotes, THash<TUInt,TSecTmV>& twitter, char* name)
{
printf("\n\nPlotting ...\n");
TFltPrV plotdata;
for(int q=0;q<quotes.Len();q++)
{
TFltPr elem;
elem.Val1 = quotes[q].Len();
elem.Val2 = twitter[q].Len();
plotdata.Add(elem);
}
Tools::plotScatter(plotdata, name, "Blogs/News", TStr::Fmt("%s on Twitter",name).CStr());
}
void plotParitialDegDistribution(const PNGraph& graph, std::vector<int>& nodeList) {
std::map<int, int> inDegDistMap;
std::map<int, int> outDegDistMap;
for (int i = 0; i < nodeList.size(); ++i) {
int curNodeId = nodeList[i];
if (!graph->IsNode(curNodeId)) continue;
TNGraph::TNodeI ni = graph->GetNI(curNodeId);
int curNodeInDeg = ni.GetInDeg();
if (inDegDistMap.find(curNodeInDeg) == inDegDistMap.end()) {
inDegDistMap.insert(std::pair<int, int>(curNodeInDeg, 0));
}
inDegDistMap[curNodeInDeg]++;
int curNodeOutDeg = ni.GetOutDeg();
if (outDegDistMap.find(curNodeOutDeg) == outDegDistMap.end()) {
outDegDistMap.insert(std::pair<int, int>(curNodeOutDeg, 0));
}
outDegDistMap[curNodeOutDeg]++;
}
TFltPrV inDegDist;
for (std::map<int, int>::iterator itr = inDegDistMap.begin(); itr != inDegDistMap.end(); itr++) {
inDegDist.Add(TFltPr(itr->first, itr->second));
}
TFltPrV outDegDist;
for (std::map<int, int>::iterator itr = outDegDistMap.begin(); itr != outDegDistMap.end(); itr++) {
outDegDist.Add(TFltPr(itr->first, itr->second));
}
TGnuPlot plot1("inDegDistParitial", "");
plot1.AddPlot(inDegDist, gpwPoints, "");
plot1.SetScale(gpsLog10XY);
plot1.SavePng();
TGnuPlot plot2("outDegDistParitial", "");
plot2.AddPlot(outDegDist, gpwPoints, "");
plot2.SetScale(gpsLog10XY);
plot2.SavePng();
TGnuPlot plot3("DegDistParitial", "");
plot3.AddCmd("set key right top");
plot3.AddPlot(inDegDist, gpwPoints, "In Degree");
plot3.AddPlot(outDegDist, gpwPoints, "Out Degree");
plot3.SetScale(gpsLog10XY);
plot3.SavePng();
}
void GenKron(const TStr& Args, TKronMtx& FitMtx, TFltPrV& KronDegAvgIn, TFltPrV& KronDegAvgOut){
Env = TEnv(Args, TNotify::NullNotify);
TExeTm ExecTime;
// number of Kronecker graphs to generate
const TInt NKron = Env.GetIfArgPrefixInt("-n:", 1, "Number of generated Kronecker graphs");
// iterations of Kronecker product
const TInt NIter = Env.GetIfArgPrefixInt("-i:", 10, "Iterations of Kronecker product");
// is graph directed?
TStr IsDir = Env.GetIfArgPrefixStr("-isdir:", "false", "Produce directed graph (true, false)");
TFlt ExpectedNodes = FitMtx.GetNodes(NIter), ExpectedEdges = FitMtx.GetEdges(NIter);
TFile << "Kronecker nodes: " << ExpectedNodes << ", expected Kronecker edges: " << ExpectedEdges << endl;
double Sec = 0.0;
int AvgMaxOutDeg = 0, AvgMaxInDeg = 0, MinMaxOutDeg = 0, MaxMaxOutDeg = 0, MinMaxInDeg = 0, MaxMaxInDeg = 0;
bool Dir = IsDir == "true" ? true : false;
for (int i = 0; i < NKron; i++){
ExecTime.Tick();
PNGraph Kron = TKronMtx::GenFastKronecker(FitMtx, NIter, Dir, 0);
Sec += ExecTime.GetSecs();
printf("Calculating maximum degree...\n");
int MaxOutDeg = GetMaxMinDeg(Kron, IsDir, "false", "true"), MaxInDeg = GetMaxMinDeg(Kron, IsDir, "true", "true");
CompareDeg(i, MaxOutDeg, MinMaxOutDeg, MaxMaxOutDeg, AvgMaxOutDeg);
CompareDeg(i, MaxInDeg, MinMaxInDeg, MaxMaxInDeg, AvgMaxInDeg);
//printf("Nodes count: %d, nodes with non-zero degree %d, edges count %d\n max deg = %d\n", kron->GetNodes(), TSnap::CntNonZNodes(kron), kron->GetEdges(), MaxDeg);
if (i == NKron - 1){
//TFile << "Clustering coefficient: " << TSnap::GetClustCf(kron) << endl;
//TSnap::PlotClustCf(kron,"kronSingle");
//TSnap::PlotHops(kron, "kronSingle");
TFile << "Maximum output degree in kron graph: " << "from " << MinMaxOutDeg << " to " << MaxMaxOutDeg << " (average: " << (double)AvgMaxOutDeg / (double)NKron << ")" << endl;
TFile << "Maximum input degree in kron graph: " << "from " << MinMaxInDeg << " to " << MaxMaxInDeg << " (average: " << (double)AvgMaxInDeg / (double)NKron << ")" << endl;
}
AddDegreesStat(KronDegAvgIn, Kron, true);
AddDegreesStat(KronDegAvgOut, Kron, false);
}
Sec /= NKron;
GetAvgDegreeStat(KronDegAvgIn, NKron);
GetAvgDegreeStat(KronDegAvgOut, NKron);
KronDegAvgIn.Sort();
KronDegAvgOut.Sort();
TFile << "Average time of generation of Kronecker product: " << Sec << endl;
}
void getSampledDistance(const PNGraph& graph, std::vector<int> srcIds, std::vector<int> dstIds, int sampleSize, TFltPrV& ret) {
std::random_shuffle(srcIds.begin(), srcIds.end());
std::random_shuffle(dstIds.begin(), dstIds.end());
int distance[20];
for (int i = 0; i < 20; distance[i++] = 0);
int sampleCount = 0;
for (int i = 0; i < sampleSize; ) {
int srcNodeId = srcIds[rand() % srcIds.size()];
int dstNodeId = dstIds[rand() % dstIds.size()];
if (!graph->IsNode(srcNodeId)) continue;
if (!graph->IsNode(dstNodeId)) continue;
int shortDist = TSnap::GetShortPath(graph, srcNodeId, dstNodeId, true);
distance[shortDist]++;
sampleCount++;
printIntArray(distance, 20);
++i;
}
for (int i = 0; i < 20; ++i) {
ret.Add(TFltPr(i, distance[i]));
}
}
double CalcAvgDiamPdf(const TFltPrV& DistNbrsPdfV) {
double Paths=0, SumLen=0;
for (int i = 0; i < DistNbrsPdfV.Len(); i++) {
SumLen += DistNbrsPdfV[i].Val1 * DistNbrsPdfV[i].Val2;
Paths += DistNbrsPdfV[i].Val2;
}
return SumLen/Paths;
}
// CHECK
void ExpBinning(const TFltPrV& deg, TFltPrV& degSparse, const int& BinRadix){
TFlt maxDeg(deg[deg.Len()-1].Val1.Val), minDeg(deg[0].Val1.Val);
bool maxPowerReached = false;
// idx - index of border, previdx - index of previous border
int power = 0, previdx = 0, idx, binSize;
TFltPr val;
double binBorder = 0.0;
while (binBorder <= minDeg)
binBorder = pow(static_cast<double>(BinRadix), power++);
TFltPr v(minDeg, deg[0].Val2.Val);
degSparse.Add(v);
bool isExact = false;
while (!maxPowerReached){
if (binBorder >= maxDeg){
// when last element of deg was previous bin border
if (previdx == deg.Len() - 1)
break;
// if we have another elements
binBorder = maxDeg;
maxPowerReached = true;
}
// find next element
idx = FindVal1Elem(deg, binBorder, isExact);
// if bin size == 0
if (previdx + 1 == idx && !isExact)
continue;
if (!isExact)
idx = idx - 1;
double sum = 0.0;
binSize = idx - previdx;
for (int i = previdx + 1; i <= idx; i++){
sum += deg[i].Val2.Val;
}
sum /= binSize;
// if prevBinBorder was the smallest degree, it can be more than binBorder / BinRadix
double SumBinBorder = previdx > 0 ? binBorder + static_cast<double>(binBorder) / BinRadix : binBorder + static_cast<double>(minDeg);
double avgDeg = SumBinBorder / 2.0;
val.Val1 = avgDeg; val.Val2 = sum;
degSparse.Add(val);
previdx = idx;
binBorder = pow(static_cast<double>(BinRadix), power++);
}
}
void GetNodesEdgesCountFromDegDistr(const TFltPrV& deg, int& nodes, int& edges){
double nodesD = 0, edgesD = 0;
for (int i = 0; i < deg.Len(); i++){
nodesD += deg[i].Val2.Val;
edgesD += deg[i].Val1.Val * deg[i].Val2.Val;
}
nodes = static_cast<int>(nodesD);
edges = static_cast<int>(edgesD);
// edges /= 2; as Deg = inDeg + outDeg
}
void TGStat::AvgGStat(const TGStatV& GStatV, const bool& ClipAt1) {
if (GStatV.Empty()) return;
Time = GStatV[0]->Time;
GraphNm = GStatV[0]->GraphNm;
// values
for (int statVal = 0; statVal > gsvMx; statVal++) {
const TGStatVal GStatVal = TGStatVal(statVal);
TMom Mom;
for (int i = 0; i < GStatV.Len(); i++) {
if (GStatV[i]->HasVal(GStatVal)) {
Mom.Add(GStatV[i]->GetVal(GStatVal)); }
}
Mom.Def();
if (Mom.IsUsable()) {
IAssert(Mom.GetVals() == GStatV.Len()); // all must have the value
SetVal(GStatVal, Mom.GetMean());
}
}
// distributions
for (int distr = gsdUndef; distr < gsdMx; distr++) {
const TGStatDistr GStatDistr = TGStatDistr(distr);
THash<TFlt, TFlt> ValToSumH;
int DistrCnt = 0;
for (int i = 0; i < GStatV.Len(); i++) {
if (GStatV[i]->HasDistr(GStatDistr)) {
const TFltPrV& D = GStatV[i]->GetDistr(GStatDistr);
for (int d = 0; d < D.Len(); d++) {
ValToSumH.AddDat(D[d].Val1) += D[d].Val2; }
DistrCnt++;
}
}
IAssert(DistrCnt==0 || DistrCnt==GStatV.Len()); // all must have distribution
TFltPrV AvgStatV;
ValToSumH.GetKeyDatPrV(AvgStatV); AvgStatV.Sort();
for (int i = 0; i < AvgStatV.Len(); i++) {
AvgStatV[i].Val2 /= double(DistrCnt);
if (ClipAt1 && AvgStatV[i].Val2 < 1) { AvgStatV[i].Val2 = 1; }
}
SetDistr(GStatDistr, AvgStatV);
}
}
// Helper: Testing Degree to Clustering Coefficient Distribution
void TestDegToCCfVector(TFltPrV& DegToCCfV) {
for (TFltPr *Pair = DegToCCfV.BegI(); Pair < DegToCCfV.EndI(); Pair++) {
switch ((int) Pair->Val1) {
case 1:
EXPECT_EQ(0.0, Pair->Val2);
break;
case 2:
EXPECT_EQ(1.0, Pair->Val2);
break;
case 3:
EXPECT_EQ(2.0/3.0, Pair->Val2);
break;
case 5:
EXPECT_EQ(0.3, Pair->Val2);
break;
default:
ASSERT_FALSE(true); // Shouldn't have degrees other than listed
break;
}
}
}
int FindVal1Elem(const TFltPrV& vec, const TFlt& elem, bool& isExact){
for (int i = 0; i < vec.Len(); i++){
if (vec[i].Val1.Val == elem){
isExact = true;
return i;
}
if (vec[i].Val1.Val > elem){
return i-1;
}
}
return false;
}
// linear fit on log-log scales{%
int TGnuPlot::AddPwrFit1(const int& PlotId, const TGpSeriesTy& SeriesTy, const TStr& Style) {
if (PlotId < 0 || PlotId >= SeriesV.Len()) return -1;
const TGpSeries& Plot = SeriesV[PlotId];
if(Plot.XYValV.Empty()) return -1;
const TFltKdV& XY = Plot.XYValV;
double A, B, R2, SigA, SigB, Chi2, MinY = TFlt::Mx, MinX = TFlt::Mx;
// power fit
TFltPrV XYPr;
int s;
for (s = 0; s < XY.Len(); s++) {
if (XY[s].Key > 0) {
XYPr.Add(TFltPr(XY[s].Key, XY[s].Dat)); //!!! skip zero values
MinX = TMath::Mn(MinX, XY[s].Key());
MinY = TMath::Mn(MinY, XY[s].Dat());
}
}
MinY = TMath::Mn(1.0, MinY);
TSpecFunc::PowerFit(XYPr, A, B, SigA, SigB, Chi2, R2);
TStr StyleStr=Style;
if (StyleStr.Empty()) { StyleStr = "linewidth 3"; }
const int FitId = AddFunc(TStr::Fmt("%f*x**%f", A, B),
SeriesTy, TStr::Fmt("%.1g * x^{%.4g} R^2:%.2g", A, B, R2), StyleStr);
return FitId;
/*SeriesV.Add();
TGpSeries& NewPlot = SeriesV.Last();
const int FitId = SeriesV.Len() - 1;
NewPlot.DataFNm = ;
TFltKdV& EstXY = NewPlot.XYValV;
for (s = 0; s < XYPr.Len(); s++) {
const double YVal = A*pow(XYPr[s].Val1(), B);
if (YVal < MinY) continue;
EstXY.Add(TFltKd(XYPr[s].Val1, YVal));
}
NewPlot.Label = ;
NewPlot.SeriesTy = SeriesTy;
if (Style.Empty()) { NewPlot.WithStyle = "linewidth 3"; }
else { NewPlot.WithStyle = Style; }
//if (MinX < 5.0) MinX = 5.0;
//AddPwrFit2(PlotId, SeriesTy, MinX);*/
}
void GetInvParticipRat(const PUNGraph& Graph, int MaxEigVecs, int TimeLimit, TFltPrV& EigValIprV) {
TUNGraphMtx GraphMtx(Graph);
TFltVV EigVecVV;
TFltV EigValV;
TExeTm ExeTm;
if (MaxEigVecs<=1) { MaxEigVecs=1000; }
int EigVecs = TMath::Mn(Graph->GetNodes(), MaxEigVecs);
printf("start %d vecs...", EigVecs);
try {
TSparseSVD::Lanczos2(GraphMtx, EigVecs, TimeLimit, ssotFull, EigValV, EigVecVV, false);
} catch(...) {
printf("\n ***EXCEPTION: TRIED %d GOT %d values** \n", EigVecs, EigValV.Len()); }
printf(" ***TRIED %d GOT %d values in %s\n", EigVecs, EigValV.Len(), ExeTm.GetStr());
TFltV EigVec;
EigValIprV.Clr();
if (EigValV.Empty()) { return; }
for (int v = 0; v < EigVecVV.GetCols(); v++) {
EigVecVV.GetCol(v, EigVec);
EigValIprV.Add(TFltPr(EigValV[v], GetInvParticipRat(EigVec)));
}
EigValIprV.Sort();
}
// get degrees from current and add it to degrees
void AddDegreeStat(const TFltPrV& current, TFltPrV& degrees, TIntPrV& samples){
for (int j = 0; j < current.Len(); j++){
const TFltPr& elem = current[j];
const double& deg = elem.Val1.Val, &nodesCount = elem.Val2.Val;
bool wasFound = false;
// silly search
for (int k = 0; k < degrees.Len(); k++){
if (degrees[k].Val1.Val == deg){
degrees[k].Val2.Val += nodesCount;
samples[k].Val2.Val++;
wasFound = true; break;
}
}
if (!wasFound){
TFlt d(deg), n(nodesCount);
TFltPr val(d,n);
degrees.Add(val);
TInt di(static_cast<int>(deg));
TIntPr valI(di, 1);
samples.Add(valI);
}
}
}