SNAP Library 6.0, User Reference  2020-12-09 16:24:20
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Attributes | List of all members
TKronMtx Class Reference

#include <kronecker.h>

Public Member Functions

 TKronMtx ()
 
 TKronMtx (const int &Dim)
 
 TKronMtx (const TFltV &SeedMatrix)
 
 TKronMtx (const TKronMtx &Kronecker)
 
void SaveTxt (const TStr &OutFNm) const
 
TKronMtx & operator= (const TKronMtx &Kronecker)
 
bool operator== (const TKronMtx &Kronecker) const
 
int GetPrimHashCd () const
 
int GetSecHashCd () const
 
int GetDim () const
 
int Len () const
 
bool Empty () const
 
bool IsProbMtx () const
 
TFltV & GetMtx ()
 
const TFltV & GetMtx () const
 
void SetMtx (const TFltV &ParamV)
 
void SetRndMtx (const int &MtxDim, const double &MinProb=0.0)
 
void PutAllMtx (const double &Val)
 
void GenMtx (const int &Dim)
 
void SetEpsMtx (const double &Eps1, const double &Eps0, const int &Eps1Val=1, const int &Eps0Val=0)
 
void SetForEdges (const int &Nodes, const int &Edges)
 
void AddRndNoise (const double &SDev)
 
TStr GetMtxStr () const
 
const double & At (const int &Row, const int &Col) const
 
double & At (const int &Row, const int &Col)
 
const double & At (const int &ValN) const
 
double & At (const int &ValN)
 
int GetNodes (const int &NIter) const
 
int GetEdges (const int &NIter) const
 
int GetKronIter (const int &Nodes) const
 
int GetNZeroK (const PNGraph &Graph) const
 
double GetEZero (const int &Edges, const int &KronIter) const
 
double GetMtxSum () const
 
double GetRowSum (const int &RowId) const
 
double GetColSum (const int &ColId) const
 
void ToOneMinusMtx ()
 
void GetLLMtx (TKronMtx &LLMtx)
 
void GetProbMtx (TKronMtx &ProbMtx)
 
void Swap (TKronMtx &KronMtx)
 
double GetEdgeProb (int NId1, int NId2, const int &NKronIters) const
 
double GetNoEdgeProb (int NId1, int NId2, const int &NKronIters) const
 
double GetEdgeLL (int NId1, int NId2, const int &NKronIters) const
 
double GetNoEdgeLL (int NId1, int NId2, const int &NKronIters) const
 
double GetApxNoEdgeLL (int NId1, int NId2, const int &NKronIters) const
 
bool IsEdgePlace (int NId1, int NId2, const int &NKronIters, const double &ProbTresh) const
 
double GetEdgeDLL (const int &ParamId, int NId1, int NId2, const int &NKronIters) const
 
double GetNoEdgeDLL (const int &ParamId, int NId1, int NId2, const int &NKronIters) const
 
double GetApxNoEdgeDLL (const int &ParamId, int NId1, int NId2, const int &NKronIters) const
 
double GetEdgeProb (const uint &NId1Sig, const uint &NId2Sig, const int &NIter) const
 
PNGraph GenThreshGraph (const double &Thresh) const
 
PNGraph GenRndGraph (const double &RndFact=1.0) const
 
void Dump (const TStr &MtxNm=TStr(), const bool &Sort=false) const
 

Static Public Member Functions

static uint GetNodeSig (const double &OneProb=0.5)
 
static int GetKronIter (const int &GNodes, const int &SeedMtxSz)
 
static PNGraph GenKronecker (const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
 
static PNGraph GenFastKronecker (const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
 
static PNGraph GenFastKronecker (const TKronMtx &SeedMtx, const int &NIter, const int &Edges, const bool &IsDir, const int &Seed=0)
 
static PNGraph GenDetKronecker (const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir)
 
static void PlotCmpGraphs (const TKronMtx &SeedMtx, const PNGraph &Graph, const TStr &OutFNm, const TStr &Desc)
 
static void PlotCmpGraphs (const TKronMtx &SeedMtx1, const TKronMtx &SeedMtx2, const PNGraph &Graph, const TStr &OutFNm, const TStr &Desc)
 
static void PlotCmpGraphs (const TVec< TKronMtx > &SeedMtxV, const PNGraph &Graph, const TStr &FNmPref, const TStr &Desc)
 
static void KronMul (const TKronMtx &LeftPt, const TKronMtx &RightPt, TKronMtx &OutMtx)
 
static void KronSum (const TKronMtx &LeftPt, const TKronMtx &RightPt, TKronMtx &OutMtx)
 
static void KronPwr (const TKronMtx &KronPt, const int &NIter, TKronMtx &OutMtx)
 
static double GetAvgAbsErr (const TKronMtx &Kron1, const TKronMtx &Kron2)
 
static double GetAvgFroErr (const TKronMtx &Kron1, const TKronMtx &Kron2)
 
static TKronMtx GetMtx (TStr MatlabMtxStr)
 
static TKronMtx GetRndMtx (const int &Dim, const double &MinProb)
 
static TKronMtx GetInitMtx (const int &Dim, const int &Nodes, const int &Edges)
 
static TKronMtx GetInitMtx (const TStr &MtxStr, const int &Dim, const int &Nodes, const int &Edges)
 
static TKronMtx GetMtxFromNm (const TStr &MtxNm)
 
static TKronMtx LoadTxt (const TStr &MtxFNm)
 
static void PutRndSeed (const int &Seed)
 

Static Public Attributes

static const double NInf = -DBL_MAX
 
static TRnd Rnd = TRnd(0)
 

Private Attributes

TInt MtxDim
 
TFltV SeedMtx
 

Detailed Description

Definition at line 11 of file kronecker.h.

Constructor & Destructor Documentation

TKronMtx::TKronMtx ( )
inline

Definition at line 19 of file kronecker.h.

19 : MtxDim(-1), SeedMtx() { }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TKronMtx::TKronMtx ( const int &  Dim)
inline

Definition at line 20 of file kronecker.h.

20 : MtxDim(Dim), SeedMtx(Dim*Dim) { }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TKronMtx::TKronMtx ( const TFltV &  SeedMatrix)

Definition at line 9 of file kronecker.cpp.

9  : SeedMtx(SeedMatrix) {
10  MtxDim = (int) sqrt((double)SeedMatrix.Len());
11  IAssert(MtxDim*MtxDim == SeedMtx.Len());
12 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TKronMtx::TKronMtx ( const TKronMtx &  Kronecker)
inline

Definition at line 22 of file kronecker.h.

22 : MtxDim(Kronecker.MtxDim), SeedMtx(Kronecker.SeedMtx) { }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17

Member Function Documentation

void TKronMtx::AddRndNoise ( const double &  SDev)

Definition at line 69 of file kronecker.cpp.

69  {
70  Dump("before");
71  double NewVal;
72  int c =0;
73  for (int i = 0; i < Len(); i++) {
74  for(c = 0; ((NewVal = At(i)*Rnd.GetNrmDev(1, SDev, 0.8, 1.2)) < 0.01 || NewVal>0.99) && c <1000; c++) { }
75  if (c < 999) { At(i) = NewVal; } else { printf("XXXXX\n"); }
76  }
77  Dump("after");
78 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::Dump
void Dump(const TStr &MtxNm=TStr(), const bool &Sort=false) const
Definition: kronecker.cpp:636
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TRnd::GetNrmDev
double GetNrmDev()
Definition: dt.cpp:63
const double& TKronMtx::At ( const int &  Row,
const int &  Col 
) const
inline

Definition at line 46 of file kronecker.h.

46 { return SeedMtx[MtxDim*Row+Col].Val; }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
double& TKronMtx::At ( const int &  Row,
const int &  Col 
)
inline

Definition at line 47 of file kronecker.h.

47 { return SeedMtx[MtxDim*Row+Col].Val; }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
const double& TKronMtx::At ( const int &  ValN) const
inline

Definition at line 48 of file kronecker.h.

48 { return SeedMtx[ValN].Val; }
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
double& TKronMtx::At ( const int &  ValN)
inline

Definition at line 49 of file kronecker.h.

49 { return SeedMtx[ValN].Val; }
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::Dump ( const TStr &  MtxNm = TStr(),
const bool &  Sort = false 
) const

Definition at line 636 of file kronecker.cpp.

636  {
637  /*printf("%s: %d x %d\n", MtxNm.Empty()?"Mtx":MtxNm.CStr(), GetDim(), GetDim());
638  for (int r = 0; r < GetDim(); r++) {
639  for (int c = 0; c < GetDim(); c++) { printf(" %8.2g", At(r, c)); }
640  printf("\n");
641  }*/
642  if (! MtxNm.Empty()) printf("%s\n", MtxNm.CStr());
643  double Sum=0.0;
644  TFltV ValV = SeedMtx;
645  if (Sort) { ValV.Sort(false); }
646  for (int i = 0; i < ValV.Len(); i++) {
647  printf(" %10.4g", ValV[i]());
648  Sum += ValV[i];
649  if ((i+1) % GetDim() == 0) { printf("\n"); }
650  }
651  printf(" (sum:%.4f)\n", Sum);
652 }
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TVec::Sort
void Sort(const bool &Asc=true)
Sorts the elements of the vector.
Definition: ds.h:1318
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TStr::Empty
bool Empty() const
Definition: dt.h:491
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TStr::CStr
char * CStr()
Definition: dt.h:479
bool TKronMtx::Empty ( ) const
inline

Definition at line 32 of file kronecker.h.

32 { return SeedMtx.Empty(); }
TVec::Empty
bool Empty() const
Tests whether the vector is empty.
Definition: ds.h:570
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
PNGraph TKronMtx::GenDetKronecker ( const TKronMtx &  SeedMtx,
const int &  NIter,
const bool &  IsDir 
)
static

Definition at line 458 of file kronecker.cpp.

458  {
459  const TKronMtx& SeedGraph = SeedMtx;
460  const int NNodes = SeedGraph.GetNodes(NIter);
461  printf(" Deterministic Kronecker: %d nodes, %s...\n", NNodes, IsDir ? "Directed":"UnDirected");
462  PNGraph Graph = TNGraph::New(NNodes, -1);
463  TExeTm ExeTm;
464  int edges = 0;
465  for (int node1 = 0; node1 < NNodes; node1++) { Graph->AddNode(node1); }
466 
467  for (int node1 = 0; node1 < NNodes; node1++) {
468  for (int node2 = 0; node2 < NNodes; node2++) {
469  if (SeedGraph.IsEdgePlace(node1, node2, NIter, Rnd.GetUniDev())) {
470  Graph->AddEdge(node1, node2);
471  edges++;
472  }
473  }
474  if (node1 % 1000 == 0) printf("\r...%dk, %dk", node1/1000, edges/1000);
475  }
476  return Graph;
477 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TExeTm
Definition: tm.h:355
TNGraph::New
static PNGraph New()
Static constructor that returns a pointer to the graph. Call: PNGraph Graph = TNGraph::New().
Definition: graph.h:481
TKronMtx::IsEdgePlace
bool IsEdgePlace(int NId1, int NId2, const int &NKronIters, const double &ProbTresh) const
Definition: kronecker.cpp:196
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TPt
Definition: bd.h:196
TKronMtx::GetNodes
int GetNodes(const int &NIter) const
Definition: kronecker.cpp:119
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
PNGraph TKronMtx::GenFastKronecker ( const TKronMtx &  SeedMtx,
const int &  NIter,
const bool &  IsDir,
const int &  Seed = 0 
)
static

Definition at line 349 of file kronecker.cpp.

349  {
350  const TKronMtx& SeedGraph = SeedMtx;
351  const int MtxDim = SeedGraph.GetDim();
352  const double MtxSum = SeedGraph.GetMtxSum();
353  const int NNodes = SeedGraph.GetNodes(NIter);
354  const int NEdges = SeedGraph.GetEdges(NIter);
355  //const double DiagEdges = NNodes * pow(SeedGraph.At(0,0), double(NIter));
356  //const int NEdges = (int) TMath::Round(((pow(double(SeedGraph.GetMtxSum()), double(NIter)) - DiagEdges) /2.0));
357  printf(" FastKronecker: %d nodes, %d edges, %s...\n", NNodes, NEdges, IsDir ? "Directed":"UnDirected");
358  PNGraph Graph = TNGraph::New(NNodes, -1);
359  TRnd Rnd(Seed);
360  TExeTm ExeTm;
361  // prepare cell probability vector
362  TVec<TFltIntIntTr> ProbToRCPosV; // row, col position
363  double CumProb = 0.0;
364  for (int r = 0; r < MtxDim; r++) {
365  for (int c = 0; c < MtxDim; c++) {
366  const double Prob = SeedGraph.At(r, c);
367  if (Prob > 0.0) {
368  CumProb += Prob;
369  ProbToRCPosV.Add(TFltIntIntTr(CumProb/MtxSum, r, c));
370  }
371  }
372  }
373  // add nodes
374  for (int i = 0; i < NNodes; i++) {
375  Graph->AddNode(i); }
376  // add edges
377  int Rng, Row, Col, Collision=0, n = 0;
378  for (int edges = 0; edges < NEdges; ) {
379  Rng=NNodes; Row=0; Col=0;
380  for (int iter = 0; iter < NIter; iter++) {
381  const double& Prob = Rnd.GetUniDev();
382  n = 0; while(Prob > ProbToRCPosV[n].Val1) { n++; }
383  const int MtxRow = ProbToRCPosV[n].Val2;
384  const int MtxCol = ProbToRCPosV[n].Val3;
385  Rng /= MtxDim;
386  Row += MtxRow * Rng;
387  Col += MtxCol * Rng;
388  }
389  if (! Graph->IsEdge(Row, Col)) { // allow self-loops
390  Graph->AddEdge(Row, Col); edges++;
391  if (! IsDir) {
392  if (Row != Col) Graph->AddEdge(Col, Row);
393  edges++;
394  }
395  } else { Collision++; }
396  //if (edges % 1000 == 0) printf("\r...%dk", edges/1000);
397  }
398  //printf(" %d edges [%s]\n", Graph->GetEdges(), ExeTm.GetTmStr());
399  printf(" collisions: %d (%.4f)\n", Collision, Collision/(double)Graph->GetEdges());
400  return Graph;
401 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TKronMtx::GetEdges
int GetEdges(const int &NIter) const
Definition: kronecker.cpp:123
TExeTm
Definition: tm.h:355
TKronMtx::GetMtxSum
double GetMtxSum() const
Definition: kronecker.cpp:140
TRnd
Definition: dt.h:11
TNGraph::New
static PNGraph New()
Static constructor that returns a pointer to the graph. Call: PNGraph Graph = TNGraph::New().
Definition: graph.h:481
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TPt
Definition: bd.h:196
TKronMtx::GetNodes
int GetNodes(const int &NIter) const
Definition: kronecker.cpp:119
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:602
TFltIntIntTr
TTriple< TFlt, TInt, TInt > TFltIntIntTr
Definition: ds.h:182
TVec
Vector is a sequence TVal objects representing an array that can change in size.
Definition: ds.h:430
PNGraph TKronMtx::GenFastKronecker ( const TKronMtx &  SeedMtx,
const int &  NIter,
const int &  Edges,
const bool &  IsDir,
const int &  Seed = 0 
)
static

Definition at line 404 of file kronecker.cpp.

404  {
405  const TKronMtx& SeedGraph = SeedMtx;
406  const int MtxDim = SeedGraph.GetDim();
407  const double MtxSum = SeedGraph.GetMtxSum();
408  const int NNodes = SeedGraph.GetNodes(NIter);
409  const int NEdges = Edges;
410  //const double DiagEdges = NNodes * pow(SeedGraph.At(0,0), double(NIter));
411  //const int NEdges = (int) TMath::Round(((pow(double(SeedGraph.GetMtxSum()), double(NIter)) - DiagEdges) /2.0));
412  printf(" RMat Kronecker: %d nodes, %d edges, %s...\n", NNodes, NEdges, IsDir ? "Directed":"UnDirected");
413  PNGraph Graph = TNGraph::New(NNodes, -1);
414  TRnd Rnd(Seed);
415  TExeTm ExeTm;
416  // prepare cell probability vector
417  TVec<TFltIntIntTr> ProbToRCPosV; // row, col position
418  double CumProb = 0.0;
419  for (int r = 0; r < MtxDim; r++) {
420  for (int c = 0; c < MtxDim; c++) {
421  const double Prob = SeedGraph.At(r, c);
422  if (Prob > 0.0) {
423  CumProb += Prob;
424  ProbToRCPosV.Add(TFltIntIntTr(CumProb/MtxSum, r, c));
425  }
426  }
427  }
428  // add nodes
429  for (int i = 0; i < NNodes; i++) {
430  Graph->AddNode(i); }
431  // add edges
432  int Rng, Row, Col, Collision=0, n = 0;
433  for (int edges = 0; edges < NEdges; ) {
434  Rng=NNodes; Row=0; Col=0;
435  for (int iter = 0; iter < NIter; iter++) {
436  const double& Prob = Rnd.GetUniDev();
437  n = 0; while(Prob > ProbToRCPosV[n].Val1) { n++; }
438  const int MtxRow = ProbToRCPosV[n].Val2;
439  const int MtxCol = ProbToRCPosV[n].Val3;
440  Rng /= MtxDim;
441  Row += MtxRow * Rng;
442  Col += MtxCol * Rng;
443  }
444  if (! Graph->IsEdge(Row, Col)) { // allow self-loops
445  Graph->AddEdge(Row, Col); edges++;
446  if (! IsDir) {
447  if (Row != Col) Graph->AddEdge(Col, Row);
448  edges++;
449  }
450  } else { Collision++; }
451  //if (edges % 1000 == 0) printf("\r...%dk", edges/1000);
452  }
453  //printf(" %d edges [%s]\n", Graph->GetEdges(), ExeTm.GetTmStr());
454  printf(" collisions: %d (%.4f)\n", Collision, Collision/(double)Graph->GetEdges());
455  return Graph;
456 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TExeTm
Definition: tm.h:355
TKronMtx::GetMtxSum
double GetMtxSum() const
Definition: kronecker.cpp:140
TRnd
Definition: dt.h:11
TNGraph::New
static PNGraph New()
Static constructor that returns a pointer to the graph. Call: PNGraph Graph = TNGraph::New().
Definition: graph.h:481
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TPt
Definition: bd.h:196
TKronMtx::GetNodes
int GetNodes(const int &NIter) const
Definition: kronecker.cpp:119
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:602
TFltIntIntTr
TTriple< TFlt, TInt, TInt > TFltIntIntTr
Definition: ds.h:182
TVec
Vector is a sequence TVal objects representing an array that can change in size.
Definition: ds.h:430
PNGraph TKronMtx::GenKronecker ( const TKronMtx &  SeedMtx,
const int &  NIter,
const bool &  IsDir,
const int &  Seed = 0 
)
static

Definition at line 312 of file kronecker.cpp.

312  {
313  const TKronMtx& SeedGraph = SeedMtx;
314  const int NNodes = SeedGraph.GetNodes(NIter);
315  printf(" Kronecker: %d nodes, %s...\n", NNodes, IsDir ? "Directed":"UnDirected");
316  PNGraph Graph = TNGraph::New(NNodes, -1);
317  TExeTm ExeTm;
318  TRnd Rnd(Seed);
319  int edges = 0;
320  for (int node1 = 0; node1 < NNodes; node1++) {
321  Graph->AddNode(node1); }
322  if (IsDir) {
323  for (int node1 = 0; node1 < NNodes; node1++) {
324  for (int node2 = 0; node2 < NNodes; node2++) {
325  if (SeedGraph.IsEdgePlace(node1, node2, NIter, Rnd.GetUniDev())) {
326  Graph->AddEdge(node1, node2);
327  edges++;
328  }
329  }
330  if (node1 % 1000 == 0) printf("\r...%dk, %dk", node1/1000, edges/1000);
331  }
332  } else {
333  for (int node1 = 0; node1 < NNodes; node1++) {
334  for (int node2 = node1; node2 < NNodes; node2++) {
335  if (SeedGraph.IsEdgePlace(node1, node2, NIter, Rnd.GetUniDev())) {
336  Graph->AddEdge(node1, node2);
337  Graph->AddEdge(node2, node1);
338  edges++;
339  }
340  }
341  if (node1 % 1000 == 0) printf("\r...%dk, %dk", node1/1000, edges/1000);
342  }
343  }
344  printf("\r %d edges [%s]\n", Graph->GetEdges(), ExeTm.GetTmStr());
345  return Graph;
346 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TExeTm
Definition: tm.h:355
TRnd
Definition: dt.h:11
TNGraph::New
static PNGraph New()
Static constructor that returns a pointer to the graph. Call: PNGraph Graph = TNGraph::New().
Definition: graph.h:481
TKronMtx::IsEdgePlace
bool IsEdgePlace(int NId1, int NId2, const int &NKronIters, const double &ProbTresh) const
Definition: kronecker.cpp:196
TExeTm::GetTmStr
const char * GetTmStr() const
Definition: tm.h:370
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TPt
Definition: bd.h:196
TKronMtx::GetNodes
int GetNodes(const int &NIter) const
Definition: kronecker.cpp:119
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::GenMtx ( const int &  Dim)
inline

Definition at line 40 of file kronecker.h.

40 { MtxDim=Dim; SeedMtx.Gen(Dim*Dim); }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:523
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
PNGraph TKronMtx::GenRndGraph ( const double &  RndFact = 1.0) const

Definition at line 295 of file kronecker.cpp.

295  {
296  PNGraph Graph = TNGraph::New();
297  for (int i = 0; i < GetDim(); i++) {
298  Graph->AddNode(i); }
299  for (int r = 0; r < GetDim(); r++) {
300  for (int c = 0; c < GetDim(); c++) {
301  if (RndFact * At(r, c) >= TKronMtx::Rnd.GetUniDev()) { Graph->AddEdge(r, c); }
302  }
303  }
304  return Graph;
305 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TNGraph::New
static PNGraph New()
Static constructor that returns a pointer to the graph. Call: PNGraph Graph = TNGraph::New().
Definition: graph.h:481
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TPt
Definition: bd.h:196
PNGraph TKronMtx::GenThreshGraph ( const double &  Thresh) const

Definition at line 283 of file kronecker.cpp.

283  {
284  PNGraph Graph = TNGraph::New();
285  for (int i = 0; i < GetDim(); i++) {
286  Graph->AddNode(i); }
287  for (int r = 0; r < GetDim(); r++) {
288  for (int c = 0; c < GetDim(); c++) {
289  if (At(r, c) >= Thresh) { Graph->AddEdge(r, c); }
290  }
291  }
292  return Graph;
293 }
TNGraph::New
static PNGraph New()
Static constructor that returns a pointer to the graph. Call: PNGraph Graph = TNGraph::New().
Definition: graph.h:481
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TPt
Definition: bd.h:196
double TKronMtx::GetApxNoEdgeDLL ( const int &  ParamId,
int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 240 of file kronecker.cpp.

240  {
241  const int& ThetaX = ParamId % GetDim();
242  const int& ThetaY = ParamId / GetDim();
243  int ThetaCnt = 0;
244  double DLL = 0;//, LL = 0;
245  for (int level = 0; level < NKronIters; level++) {
246  const int X = NId1 % MtxDim;
247  const int Y = NId2 % MtxDim;
248  const double LVal = At(X, Y); IAssert(LVal > NInf);
249  if (X == ThetaX && Y == ThetaY) {
250  if (ThetaCnt != 0) { DLL += LVal; }
251  ThetaCnt++;
252  } else { DLL += LVal; }
253  //LL += LVal;
254  NId1 /= MtxDim; NId2 /= MtxDim;
255  }
256  //return -ThetaCnt*exp(DLL)*(1.0 + exp(LL)); // -x'/(1+x) WRONG!
257  // deriv = -(ax^(a-1)*y^b..) - a*x^(2a-1)*y^2b..
258  // = - (ax^(a-1)*y^b..) - a*x*(x^(a-1)*y^b..)^2
259  return -ThetaCnt*exp(DLL) - ThetaCnt*exp(At(ThetaX, ThetaY)+2*DLL);
260 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TKronMtx::NInf
static const double NInf
Definition: kronecker.h:13
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
double TKronMtx::GetApxNoEdgeLL ( int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 191 of file kronecker.cpp.

191  {
192  const double EdgeLL = GetEdgeLL(NId1, NId2, NKronIters);
193  return -exp(EdgeLL) - 0.5*exp(2*EdgeLL);
194 }
TKronMtx::GetEdgeLL
double GetEdgeLL(int NId1, int NId2, const int &NKronIters) const
Definition: kronecker.cpp:175
double TKronMtx::GetAvgAbsErr ( const TKronMtx &  Kron1,
const TKronMtx &  Kron2 
)
static

Definition at line 655 of file kronecker.cpp.

655  {
656  TFltV P1 = Kron1.GetMtx();
657  TFltV P2 = Kron2.GetMtx();
658  IAssert(P1.Len() == P2.Len());
659  P1.Sort(); P2.Sort();
660  double delta = 0.0;
661  for (int i = 0; i < P1.Len(); i++) {
662  delta += fabs(P1[i] - P2[i]);
663  }
664  return delta/P1.Len();
665 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TKronMtx::GetMtx
TFltV & GetMtx()
Definition: kronecker.h:35
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TVec::Sort
void Sort(const bool &Asc=true)
Sorts the elements of the vector.
Definition: ds.h:1318
double TKronMtx::GetAvgFroErr ( const TKronMtx &  Kron1,
const TKronMtx &  Kron2 
)
static

Definition at line 668 of file kronecker.cpp.

668  {
669  TFltV P1 = Kron1.GetMtx();
670  TFltV P2 = Kron2.GetMtx();
671  IAssert(P1.Len() == P2.Len());
672  P1.Sort(); P2.Sort();
673  double delta = 0.0;
674  for (int i = 0; i < P1.Len(); i++) {
675  delta += pow(P1[i] - P2[i], 2);
676  }
677  return sqrt(delta/P1.Len());
678 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TKronMtx::GetMtx
TFltV & GetMtx()
Definition: kronecker.h:35
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TVec::Sort
void Sort(const bool &Asc=true)
Sorts the elements of the vector.
Definition: ds.h:1318
double TKronMtx::GetColSum ( const int &  ColId) const

Definition at line 154 of file kronecker.cpp.

154  {
155  double Sum = 0;
156  for (int r = 0; r < GetDim(); r++) {
157  Sum += At(r, ColId); }
158  return Sum;
159 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
int TKronMtx::GetDim ( ) const
inline

Definition at line 30 of file kronecker.h.

30 { return MtxDim; }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
double TKronMtx::GetEdgeDLL ( const int &  ParamId,
int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 207 of file kronecker.cpp.

207  {
208  const int ThetaX = ParamId % GetDim();
209  const int ThetaY = ParamId / GetDim();
210  int ThetaCnt = 0;
211  for (int level = 0; level < NKronIters; level++) {
212  if ((NId1 % MtxDim) == ThetaX && (NId2 % MtxDim) == ThetaY) {
213  ThetaCnt++; }
214  NId1 /= MtxDim; NId2 /= MtxDim;
215  }
216  return double(ThetaCnt) / exp(At(ParamId));
217 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
double TKronMtx::GetEdgeLL ( int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 175 of file kronecker.cpp.

175  {
176  double LL = 0.0;
177  for (int level = 0; level < NKronIters; level++) {
178  const double& LLVal = At(NId1 % MtxDim, NId2 % MtxDim);
179  if (LLVal == NInf) return NInf;
180  LL += LLVal;
181  NId1 /= MtxDim; NId2 /= MtxDim;
182  }
183  return LL;
184 }
TKronMtx::NInf
static const double NInf
Definition: kronecker.h:13
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
double TKronMtx::GetEdgeProb ( int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 161 of file kronecker.cpp.

161  {
162  double Prob = 1.0;
163  for (int level = 0; level < NKronIters; level++) {
164  Prob *= At(NId1 % MtxDim, NId2 % MtxDim);
165  if (Prob == 0.0) { return 0.0; }
166  NId1 /= MtxDim; NId2 /= MtxDim;
167  }
168  return Prob;
169 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
double TKronMtx::GetEdgeProb ( const uint &  NId1Sig,
const uint &  NId2Sig,
const int &  NIter 
) const

Definition at line 271 of file kronecker.cpp.

271  {
272  Assert(GetDim() == 2);
273  double Prob = 1.0;
274  for (int i = 0; i < NIter; i++) {
275  const uint Mask = (1u<<i);
276  const uint Bit1 = NId1Sig & Mask;
277  const uint Bit2 = NId2Sig & Mask;
278  Prob *= At(int(Bit1!=0), int(Bit2!=0));
279  }
280  return Prob;
281 }
uint
unsigned int uint
Definition: bd.h:11
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
Assert
#define Assert(Cond)
Definition: bd.h:251
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
int TKronMtx::GetEdges ( const int &  NIter) const

Definition at line 123 of file kronecker.cpp.

123  {
124  return (int) pow(double(GetMtxSum()), double(NIter));
125 }
TKronMtx::GetMtxSum
double GetMtxSum() const
Definition: kronecker.cpp:140
double TKronMtx::GetEZero ( const int &  Edges,
const int &  KronIter 
) const

Definition at line 136 of file kronecker.cpp.

136  {
137  return pow((double) Edges, 1.0/double(KronIters));
138 }
TKronMtx TKronMtx::GetInitMtx ( const int &  Dim,
const int &  Nodes,
const int &  Edges 
)
static

Definition at line 705 of file kronecker.cpp.

705  {
706  const double MxParam = 0.8+TKronMtx::Rnd.GetUniDev()/5.0;
707  const double MnParam = 0.2-TKronMtx::Rnd.GetUniDev()/5.0;
708  const double Step = (MxParam-MnParam) / (Dim*Dim-1);
709  TFltV ParamV(Dim*Dim);
710  if (Dim == 1) { ParamV.PutAll(0.5); } // random graph
711  else {
712  for (int p = 0; p < ParamV.Len(); p++) {
713  ParamV[p] = MxParam - p*Step; }
714  }
715  //IAssert(ParamV[0]==MxParam && ParamV.Last()==MnParam);
716  TKronMtx Mtx(ParamV);
717  Mtx.SetForEdges(Nodes, Edges);
718  return Mtx;
719 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TKronMtx TKronMtx::GetInitMtx ( const TStr &  MtxStr,
const int &  Dim,
const int &  Nodes,
const int &  Edges 
)
static

Definition at line 721 of file kronecker.cpp.

721  {
722  TKronMtx Mtx(Dim);
723  if (TCh::IsNum(MtxStr[0])) { Mtx = TKronMtx::GetMtx(MtxStr); }
724  else if (MtxStr[0] == 'r') { Mtx = TKronMtx::GetRndMtx(Dim, 0.1); }
725  else if (MtxStr[0] == 'a') {
726  const double Prob = TKronMtx::Rnd.GetUniDev();
727  if (Prob < 0.4) {
728  Mtx = TKronMtx::GetInitMtx(Dim, Nodes, Edges); }
729  else { // interpolate so that there are in the corners 0.9, 0.5, 0.1, 0.5
730  const double Max = 0.9+TKronMtx::Rnd.GetUniDev()/10.0;
731  const double Min = 0.1-TKronMtx::Rnd.GetUniDev()/10.0;
732  const double Med = (Max-Min)/2.0;
733  Mtx.At(0,0) = Max; Mtx.At(0,Dim-1) = Med;
734  Mtx.At(Dim-1, 0) = Med; Mtx.At(Dim-1, Dim-1) = Min;
735  for (int i = 1; i < Dim-1; i++) {
736  Mtx.At(i,i) = Max - double(i)*(Max-Min)/double(Dim-1);
737  Mtx.At(i, 0) = Mtx.At(0, i) = Max - double(i)*(Max-Med)/double(Dim-1);
738  Mtx.At(i, Dim-1) = Mtx.At(Dim-1, i) = Med - double(i)*(Med-Min)/double(Dim-1);
739  }
740  for (int i = 1; i < Dim-1; i++) {
741  for (int j = 1; j < Dim-1; j++) {
742  if (i >= j) { continue; }
743  Mtx.At(i,j) = Mtx.At(j,i) = Mtx.At(i,i) - (j-i)*(Mtx.At(i,i)-Mtx.At(i,Dim-1))/(Dim-i-1);
744  }
745  }
746  Mtx.AddRndNoise(0.1);
747  }
748  } else { FailR("Wrong mtx: matlab str, or random (r), or all (a)"); }
749  Mtx.SetForEdges(Nodes, Edges);
750  return Mtx;
751 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TKronMtx::GetMtx
TFltV & GetMtx()
Definition: kronecker.h:35
TCh::IsNum
static bool IsNum(const char &Ch)
Definition: dt.h:1067
TKronMtx::GetInitMtx
static TKronMtx GetInitMtx(const int &Dim, const int &Nodes, const int &Edges)
Definition: kronecker.cpp:705
FailR
#define FailR(Reason)
Definition: bd.h:240
TKronMtx::GetRndMtx
static TKronMtx GetRndMtx(const int &Dim, const double &MinProb)
Definition: kronecker.cpp:699
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
int TKronMtx::GetKronIter ( const int &  Nodes) const

Definition at line 127 of file kronecker.cpp.

127  {
128  return (int) ceil(log(double(Nodes)) / log(double(GetDim()))); // upper bound
129  //return (int) TMath::Round(log(double(Nodes)) / log(double(GetDim()))); // round to nearest power
130 }
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
int TKronMtx::GetKronIter ( const int &  GNodes,
const int &  SeedMtxSz 
)
static

Definition at line 307 of file kronecker.cpp.

307  {
308  return (int) ceil(log(double(GNodes)) / log(double(SeedMtxSz)));
309 }
void TKronMtx::GetLLMtx ( TKronMtx &  LLMtx)

Definition at line 98 of file kronecker.cpp.

98  {
99  LLMtx.GenMtx(MtxDim);
100  for (int i = 0; i < Len(); i++) {
101  if (At(i) != 0.0) { LLMtx.At(i) = log(At(i)); }
102  else { LLMtx.At(i) = NInf; }
103  }
104 }
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::NInf
static const double NInf
Definition: kronecker.h:13
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GenMtx
void GenMtx(const int &Dim)
Definition: kronecker.h:40
TFltV& TKronMtx::GetMtx ( )
inline

Definition at line 35 of file kronecker.h.

35 { return SeedMtx; }
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
const TFltV& TKronMtx::GetMtx ( ) const
inline

Definition at line 36 of file kronecker.h.

36 { return SeedMtx; }
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TKronMtx TKronMtx::GetMtx ( TStr  MatlabMtxStr)
static

Definition at line 681 of file kronecker.cpp.

681  {
682  TStrV RowStrV, ColStrV;
683  MatlabMtxStr.ChangeChAll(',', ' ');
684  MatlabMtxStr.SplitOnAllCh(';', RowStrV); IAssert(! RowStrV.Empty());
685  RowStrV[0].SplitOnWs(ColStrV); IAssert(! ColStrV.Empty());
686  const int Rows = RowStrV.Len();
687  const int Cols = ColStrV.Len();
688  IAssert(Rows == Cols);
689  TKronMtx Mtx(Rows);
690  for (int r = 0; r < Rows; r++) {
691  RowStrV[r].SplitOnWs(ColStrV);
692  IAssert(ColStrV.Len() == Cols);
693  for (int c = 0; c < Cols; c++) {
694  Mtx.At(r, c) = (double) ColStrV[c].GetFlt(); }
695  }
696  return Mtx;
697 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TStr::ChangeChAll
int ChangeChAll(const char &SrcCh, const char &DstCh)
Definition: dt.cpp:1113
TVec::Empty
bool Empty() const
Tests whether the vector is empty.
Definition: ds.h:570
TStr::SplitOnAllCh
void SplitOnAllCh(const char &SplitCh, TStrV &StrV, const bool &SkipEmpty=true) const
Definition: dt.cpp:926
TKronMtx TKronMtx::GetMtxFromNm ( const TStr &  MtxNm)
static

Definition at line 753 of file kronecker.cpp.

753  {
754  if (MtxNm == "3chain") return TKronMtx::GetMtx("1 1 0; 1 1 1; 0 1 1");
755  else if (MtxNm == "4star") return TKronMtx::GetMtx("1 1 1 1; 1 1 0 0 ; 1 0 1 0; 1 0 0 1");
756  else if (MtxNm == "4chain") return TKronMtx::GetMtx("1 1 0 0; 1 1 1 0 ; 0 1 1 1; 0 0 1 1");
757  else if (MtxNm == "4square") return TKronMtx::GetMtx("1 1 0 1; 1 1 1 0 ; 0 1 1 1; 1 0 1 1");
758  else if (MtxNm == "5star") return TKronMtx::GetMtx("1 1 1 1 1; 1 1 0 0 0; 1 0 1 0 0; 1 0 0 1 0; 1 0 0 0 1");
759  else if (MtxNm == "6star") return TKronMtx::GetMtx("1 1 1 1 1 1; 1 1 0 0 0 0; 1 0 1 0 0 0; 1 0 0 1 0 0; 1 0 0 0 1 0; 1 0 0 0 0 1");
760  else if (MtxNm == "7star") return TKronMtx::GetMtx("1 1 1 1 1 1 1; 1 1 0 0 0 0 0; 1 0 1 0 0 0 0; 1 0 0 1 0 0 0; 1 0 0 0 1 0 0; 1 0 0 0 0 1 0; 1 0 0 0 0 0 1");
761  else if (MtxNm == "5burst") return TKronMtx::GetMtx("1 1 1 1 0; 1 1 0 0 0; 1 0 1 0 0; 1 0 0 1 1; 0 0 0 1 1");
762  else if (MtxNm == "7burst") return TKronMtx::GetMtx("1 0 0 1 0 0 0; 0 1 0 1 0 0 0; 0 0 1 1 0 0 0; 1 1 1 1 1 0 0; 0 0 0 1 1 1 1; 0 0 0 0 1 1 0; 0 0 0 0 1 0 1");
763  else if (MtxNm == "7cross") return TKronMtx::GetMtx("1 0 0 1 0 0 0; 0 1 0 1 0 0 0; 0 0 1 1 0 0 0; 1 1 1 1 1 0 0; 0 0 0 1 1 1 0; 0 0 0 0 1 1 1; 0 0 0 0 0 1 1");
764  FailR(TStr::Fmt("Unknow matrix: '%s'", MtxNm.CStr()).CStr());
765  return TKronMtx();
766 }
TKronMtx::GetMtx
TFltV & GetMtx()
Definition: kronecker.h:35
FailR
#define FailR(Reason)
Definition: bd.h:240
TStr::Fmt
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
TStr::CStr
char * CStr()
Definition: dt.h:479
TKronMtx::TKronMtx
TKronMtx()
Definition: kronecker.h:19
TStr TKronMtx::GetMtxStr ( ) const

Definition at line 80 of file kronecker.cpp.

80  {
81  TChA ChA("[");
82  for (int i = 0; i < Len(); i++) {
83  ChA += TStr::Fmt("%g", At(i));
84  if ((i+1)%GetDim()==0 && (i+1<Len())) { ChA += "; "; }
85  else if (i+1<Len()) { ChA += ", "; }
86  }
87  ChA += "]";
88  return TStr(ChA);
89 }
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TChA
Definition: dt.h:201
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TStr
Definition: dt.h:412
TStr::Fmt
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
double TKronMtx::GetMtxSum ( ) const

Definition at line 140 of file kronecker.cpp.

140  {
141  double Sum = 0;
142  for (int i = 0; i < Len(); i++) {
143  Sum += At(i); }
144  return Sum;
145 }
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
int TKronMtx::GetNodes ( const int &  NIter) const

Definition at line 119 of file kronecker.cpp.

119  {
120  return (int) pow(double(GetDim()), double(NIter));
121 }
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
uint TKronMtx::GetNodeSig ( const double &  OneProb = 0.5)
static

Definition at line 262 of file kronecker.cpp.

262  {
263  uint Sig = 0;
264  for (int i = 0; i < (int)(8*sizeof(uint)); i++) {
265  if (TKronMtx::Rnd.GetUniDev() < OneProb) {
266  Sig |= (1u<<i); }
267  }
268  return Sig;
269 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
uint
unsigned int uint
Definition: bd.h:11
double TKronMtx::GetNoEdgeDLL ( const int &  ParamId,
int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 220 of file kronecker.cpp.

220  {
221  const int& ThetaX = ParamId % GetDim();
222  const int& ThetaY = ParamId / GetDim();
223  int ThetaCnt = 0;
224  double DLL = 0, LL = 0;
225  for (int level = 0; level < NKronIters; level++) {
226  const int X = NId1 % MtxDim;
227  const int Y = NId2 % MtxDim;
228  const double LVal = At(X, Y);
229  if (X == ThetaX && Y == ThetaY) {
230  if (ThetaCnt != 0) { DLL += LVal; }
231  ThetaCnt++;
232  } else { DLL += LVal; }
233  LL += LVal;
234  NId1 /= MtxDim; NId2 /= MtxDim;
235  }
236  return -ThetaCnt*exp(DLL) / (1.0 - exp(LL));
237 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
double TKronMtx::GetNoEdgeLL ( int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 186 of file kronecker.cpp.

186  {
187  return log(1.0 - exp(GetEdgeLL(NId1, NId2, NKronIters)));
188 }
TKronMtx::GetEdgeLL
double GetEdgeLL(int NId1, int NId2, const int &NKronIters) const
Definition: kronecker.cpp:175
double TKronMtx::GetNoEdgeProb ( int  NId1,
int  NId2,
const int &  NKronIters 
) const

Definition at line 171 of file kronecker.cpp.

171  {
172  return 1.0 - GetEdgeProb(NId1, NId2, NKronIters);
173 }
TKronMtx::GetEdgeProb
double GetEdgeProb(int NId1, int NId2, const int &NKronIters) const
Definition: kronecker.cpp:161
int TKronMtx::GetNZeroK ( const PNGraph &  Graph) const

Definition at line 132 of file kronecker.cpp.

132  {
133  return GetNodes(GetKronIter(Graph->GetNodes()));
134 }
TKronMtx::GetKronIter
int GetKronIter(const int &Nodes) const
Definition: kronecker.cpp:127
TKronMtx::GetNodes
int GetNodes(const int &NIter) const
Definition: kronecker.cpp:119
int TKronMtx::GetPrimHashCd ( ) const
inline

Definition at line 26 of file kronecker.h.

26 { return SeedMtx.GetPrimHashCd(); }
TVec::GetPrimHashCd
int GetPrimHashCd() const
Returns primary hash code of the vector. Used by THash.
Definition: ds.h:999
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::GetProbMtx ( TKronMtx &  ProbMtx)

Definition at line 106 of file kronecker.cpp.

106  {
107  ProbMtx.GenMtx(MtxDim);
108  for (int i = 0; i < Len(); i++) {
109  if (At(i) != NInf) { ProbMtx.At(i) = exp(At(i)); }
110  else { ProbMtx.At(i) = 0.0; }
111  }
112 }
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::NInf
static const double NInf
Definition: kronecker.h:13
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::GenMtx
void GenMtx(const int &Dim)
Definition: kronecker.h:40
TKronMtx TKronMtx::GetRndMtx ( const int &  Dim,
const double &  MinProb 
)
static

Definition at line 699 of file kronecker.cpp.

699  {
700  TKronMtx Mtx;
701  Mtx.SetRndMtx(Dim, MinProb);
702  return Mtx;
703 }
TKronMtx::SetRndMtx
void SetRndMtx(const int &MtxDim, const double &MinProb=0.0)
Definition: kronecker.cpp:40
double TKronMtx::GetRowSum ( const int &  RowId) const

Definition at line 147 of file kronecker.cpp.

147  {
148  double Sum = 0;
149  for (int c = 0; c < GetDim(); c++) {
150  Sum += At(RowId, c); }
151  return Sum;
152 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
int TKronMtx::GetSecHashCd ( ) const
inline

Definition at line 27 of file kronecker.h.

27 { return SeedMtx.GetSecHashCd(); }
TVec::GetSecHashCd
int GetSecHashCd() const
Returns secondary hash code of the vector. Used by THash.
Definition: ds.h:1011
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
bool TKronMtx::IsEdgePlace ( int  NId1,
int  NId2,
const int &  NKronIters,
const double &  ProbTresh 
) const

Definition at line 196 of file kronecker.cpp.

196  {
197  double Prob = 1.0;
198  for (int level = 0; level < NKronIters; level++) {
199  Prob *= At(NId1 % MtxDim, NId2 % MtxDim);
200  if (ProbTresh > Prob) { return false; }
201  NId1 /= MtxDim; NId2 /= MtxDim;
202  }
203  return true;
204 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
bool TKronMtx::IsProbMtx ( ) const

Definition at line 33 of file kronecker.cpp.

33  {
34  for (int i = 0; i < Len(); i++) {
35  if (At(i) < 0.0 || At(i) > 1.0) return false;
36  }
37  return true;
38 }
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
void TKronMtx::KronMul ( const TKronMtx &  LeftPt,
const TKronMtx &  RightPt,
TKronMtx &  OutMtx 
)
static

Definition at line 591 of file kronecker.cpp.

591  {
592  const int LDim = Left.GetDim();
593  const int RDim = Right.GetDim();
594  Result.GenMtx(LDim * RDim);
595  for (int r1 = 0; r1 < LDim; r1++) {
596  for (int c1 = 0; c1 < LDim; c1++) {
597  const double& Val = Left.At(r1, c1);
598  for (int r2 = 0; r2 < RDim; r2++) {
599  for (int c2 = 0; c2 < RDim; c2++) {
600  Result.At(r1*RDim+r2, c1*RDim+c2) = Val * Right.At(r2, c2);
601  }
602  }
603  }
604  }
605 }
void TKronMtx::KronPwr ( const TKronMtx &  KronPt,
const int &  NIter,
TKronMtx &  OutMtx 
)
static

Definition at line 626 of file kronecker.cpp.

626  {
627  OutMtx = KronMtx;
628  TKronMtx NewOutMtx;
629  for (int iter = 0; iter < NIter; iter++) {
630  KronMul(OutMtx, KronMtx, NewOutMtx);
631  NewOutMtx.Swap(OutMtx);
632  }
633 
634 }
TKronMtx::KronMul
static void KronMul(const TKronMtx &LeftPt, const TKronMtx &RightPt, TKronMtx &OutMtx)
Definition: kronecker.cpp:591
TKronMtx::Swap
void Swap(TKronMtx &KronMtx)
Definition: kronecker.cpp:114
void TKronMtx::KronSum ( const TKronMtx &  LeftPt,
const TKronMtx &  RightPt,
TKronMtx &  OutMtx 
)
static

Definition at line 607 of file kronecker.cpp.

607  {
608  const int LDim = Left.GetDim();
609  const int RDim = Right.GetDim();
610  Result.GenMtx(LDim * RDim);
611  for (int r1 = 0; r1 < LDim; r1++) {
612  for (int c1 = 0; c1 < LDim; c1++) {
613  const double& Val = Left.At(r1, c1);
614  for (int r2 = 0; r2 < RDim; r2++) {
615  for (int c2 = 0; c2 < RDim; c2++) {
616  if (Val == NInf || Right.At(r2, c2) == NInf) {
617  Result.At(r1*RDim+r2, c1*RDim+c2) = NInf; }
618  else {
619  Result.At(r1*RDim+r2, c1*RDim+c2) = Val + Right.At(r2, c2); }
620  }
621  }
622  }
623  }
624 }
TKronMtx::NInf
static const double NInf
Definition: kronecker.h:13
int TKronMtx::Len ( ) const
inline

Definition at line 31 of file kronecker.h.

31 { return SeedMtx.Len(); }
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
TKronMtx TKronMtx::LoadTxt ( const TStr &  MtxFNm)
static

Definition at line 768 of file kronecker.cpp.

768  {
769  PSs Ss = TSs::LoadTxt(ssfTabSep, MtxFNm);
770  IAssertR(Ss->GetXLen() == Ss->GetYLen(), "Not a square matrix");
771  IAssert(Ss->GetYLen() == Ss->GetXLen());
772  TKronMtx Mtx(Ss->GetYLen());
773  for (int r = 0; r < Ss->GetYLen(); r++) {
774  for (int c = 0; c < Ss->GetXLen(); c++) {
775  Mtx.At(r, c) = (double) Ss->At(c, r).GetFlt(); }
776  }
777  return Mtx;
778 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
IAssertR
#define IAssertR(Cond, Reason)
Definition: bd.h:265
TSs::LoadTxt
static PSs LoadTxt(const TSsFmt &SsFmt, const TStr &FNm, const PNotify &Notify=NULL, const bool &IsExcelEoln=true, const int &MxY=-1, const TIntV &AllowedColNV=TIntV(), const bool &IsQStr=true)
Definition: ss.cpp:100
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
ssfTabSep
Tab separated.
Definition: ss.h:6
TPt
Definition: bd.h:196
TKronMtx & TKronMtx::operator= ( const TKronMtx &  Kronecker)

Definition at line 25 of file kronecker.cpp.

25  {
26  if (this != &Kronecker){
27  MtxDim=Kronecker.MtxDim;
28  SeedMtx=Kronecker.SeedMtx;
29  }
30  return *this;
31 }
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
bool TKronMtx::operator== ( const TKronMtx &  Kronecker) const
inline

Definition at line 25 of file kronecker.h.

25 { return SeedMtx==Kronecker.SeedMtx; }
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::PlotCmpGraphs ( const TKronMtx &  SeedMtx,
const PNGraph &  Graph,
const TStr &  OutFNm,
const TStr &  Desc 
)
static

Definition at line 479 of file kronecker.cpp.

479  {
480  const int KronIters = SeedMtx.GetKronIter(Graph->GetNodes());
481  PNGraph KronG, WccG;
482  const bool FastGen = true;
483  if (FastGen) { KronG = TKronMtx::GenFastKronecker(SeedMtx, KronIters, true, 0); }
484  else { KronG = TKronMtx::GenKronecker(SeedMtx, KronIters, true, 0); }
485  TSnap::DelZeroDegNodes(KronG);
486  WccG = TSnap::GetMxWcc(KronG);
487  const TStr Desc1 = TStr::Fmt("%s", Desc.CStr());
488  TGStatVec GS(tmuNodes, TFSet() | gsdInDeg | gsdOutDeg | gsdWcc | gsdHops | gsdScc | gsdClustCf | gsdSngVec | gsdSngVal);
489  //gsdHops
490  //gsWccHops, gsdSngVal, gsdSngVec, gsdClustCf
491  GS.Add(Graph, TSecTm(1), TStr::Fmt("GRAPH G(%d, %d)", Graph->GetNodes(), Graph->GetEdges()));
492  GS.Add(KronG, TSecTm(2), TStr::Fmt("KRONECKER K(%d, %d)", KronG->GetNodes(), KronG->GetEdges()));
493  GS.Add(WccG, TSecTm(3), TStr::Fmt("KRONECKER wccK(%d, %d)", WccG->GetNodes(), WccG->GetEdges()));
494  const TStr Style = "linewidth 1 pointtype 6 pointsize 1";
495  GS.ImposeDistr(gsdInDeg, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
496  GS.ImposeDistr(gsdInDeg, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
497  GS.ImposeDistr(gsdOutDeg, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
498  GS.ImposeDistr(gsdOutDeg, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
499  GS.ImposeDistr(gsdHops, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
500  GS.ImposeDistr(gsdClustCf, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
501  GS.ImposeDistr(gsdClustCf, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
502  GS.ImposeDistr(gsdSngVal, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
503  GS.ImposeDistr(gsdSngVal, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
504  GS.ImposeDistr(gsdSngVec, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
505  GS.ImposeDistr(gsdSngVec, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
506  GS.ImposeDistr(gsdWcc, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
507  GS.ImposeDistr(gsdWcc, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
508  GS.ImposeDistr(gsdScc, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
509  GS.ImposeDistr(gsdScc, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
510 // typedef enum { distrUndef, distrInDeg, distrOutDeg, distrWcc, distrScc,
511 // distrHops, distrWccHops, distrSngVal, distrSngVec, distrClustCf, distrMx } TGraphDistr;*/
512 }
TKronMtx::GenKronecker
static PNGraph GenKronecker(const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
Definition: kronecker.cpp:312
TKronMtx::GetKronIter
int GetKronIter(const int &Nodes) const
Definition: kronecker.cpp:127
TSnap::GetMxWcc
PGraph GetMxWcc(const PGraph &Graph)
Returns a graph representing the largest weakly connected component on an input Graph.
Definition: cncom.h:452
gsdInDeg
Definition: gstat.h:28
TFSet
Definition: bits.h:119
gsdHops
Definition: gstat.h:29
gsdScc
Definition: gstat.h:28
TGStatVec
Graph Statistics Sequence.
Definition: gstat.h:155
TSnap::DelZeroDegNodes
void DelZeroDegNodes(PGraph &Graph)
Removes all the zero-degree nodes, that isolated nodes, from the graph.
Definition: alg.h:432
tmuNodes
Definition: tm.h:14
TSecTm
Definition: tm.h:81
gsdWcc
Definition: gstat.h:28
TStr
Definition: dt.h:412
TStr::Fmt
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
TPt
Definition: bd.h:196
TStr::CStr
char * CStr()
Definition: dt.h:479
TKronMtx::GenFastKronecker
static PNGraph GenFastKronecker(const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
Definition: kronecker.cpp:349
void TKronMtx::PlotCmpGraphs ( const TKronMtx &  SeedMtx1,
const TKronMtx &  SeedMtx2,
const PNGraph &  Graph,
const TStr &  OutFNm,
const TStr &  Desc 
)
static

!!

Definition at line 514 of file kronecker.cpp.

514  {
515  const int KronIters1 = SeedMtx1.GetKronIter(Graph->GetNodes());
516  const int KronIters2 = SeedMtx2.GetKronIter(Graph->GetNodes());
517  PNGraph KronG1, KronG2;
518  const bool FastGen = true;
519  if (FastGen) {
520  KronG1 = TKronMtx::GenFastKronecker(SeedMtx1, KronIters1, true, 0);
521  KronG2 = TKronMtx::GenFastKronecker(SeedMtx2, KronIters2, false, 0); }
522  else {
523  KronG1 = TKronMtx::GenKronecker(SeedMtx1, KronIters1, true, 0);
524  KronG2 = TKronMtx::GenKronecker(SeedMtx2, KronIters2, true, 0); }
525  TSnap::DelZeroDegNodes(KronG1);
526  TSnap::DelZeroDegNodes(KronG2);
527  const TStr Desc1 = TStr::Fmt("%s", Desc.CStr());
528  TGStatVec GS(tmuNodes, TFSet() | gsdInDeg | gsdOutDeg | gsdWcc | gsdScc | gsdHops | gsdClustCf | gsdSngVec | gsdSngVal | gsdTriadPart);
529  //gsdHops
530  //gsWccHops, gsdSngVal, gsdSngVec, gsdClustCf
531  GS.Add(Graph, TSecTm(1), TStr::Fmt("GRAPH G(%d, %d)", Graph->GetNodes(), Graph->GetEdges()));
532  GS.Add(KronG1, TSecTm(2), TStr::Fmt("KRONECKER1 K(%d, %d) %s", KronG1->GetNodes(), KronG1->GetEdges(), SeedMtx1.GetMtxStr().CStr()));
533  GS.Add(KronG2, TSecTm(3), TStr::Fmt("KRONECKER2 K(%d, %d) %s", KronG2->GetNodes(), KronG2->GetEdges(), SeedMtx2.GetMtxStr().CStr()));
534  const TStr Style = "linewidth 1 pointtype 6 pointsize 1";
535  // raw data
536  GS.ImposeDistr(gsdInDeg, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
537  GS.ImposeDistr(gsdOutDeg, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
538  GS.ImposeDistr(gsdHops, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
539  GS.ImposeDistr(gsdClustCf, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
540  GS.ImposeDistr(gsdSngVal, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
541  GS.ImposeDistr(gsdSngVec, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
542  GS.ImposeDistr(gsdWcc, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
543  GS.ImposeDistr(gsdScc, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
544  GS.ImposeDistr(gsdTriadPart, FNmPref, Desc1, false, false, gpwLinesPoints, Style);
545  // smooth
546  GS.ImposeDistr(gsdInDeg, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
547  GS.ImposeDistr(gsdOutDeg, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
548  GS.ImposeDistr(gsdClustCf, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
549  GS.ImposeDistr(gsdScc, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
550  GS.ImposeDistr(gsdWcc, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
551  GS.ImposeDistr(gsdSngVec, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
552  GS.ImposeDistr(gsdSngVal, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
553  GS.ImposeDistr(gsdTriadPart, FNmPref+"-B", Desc1, true, false, gpwLinesPoints, Style);
554 }
TKronMtx::GenKronecker
static PNGraph GenKronecker(const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
Definition: kronecker.cpp:312
TKronMtx::GetKronIter
int GetKronIter(const int &Nodes) const
Definition: kronecker.cpp:127
gsdInDeg
Definition: gstat.h:28
TFSet
Definition: bits.h:119
TKronMtx::GetMtxStr
TStr GetMtxStr() const
Definition: kronecker.cpp:80
gsdHops
Definition: gstat.h:29
gsdScc
Definition: gstat.h:28
TGStatVec
Graph Statistics Sequence.
Definition: gstat.h:155
TSnap::DelZeroDegNodes
void DelZeroDegNodes(PGraph &Graph)
Removes all the zero-degree nodes, that isolated nodes, from the graph.
Definition: alg.h:432
tmuNodes
Definition: tm.h:14
TSecTm
Definition: tm.h:81
gsdWcc
Definition: gstat.h:28
TStr
Definition: dt.h:412
TStr::Fmt
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
TPt
Definition: bd.h:196
TStr::CStr
char * CStr()
Definition: dt.h:479
TKronMtx::GenFastKronecker
static PNGraph GenFastKronecker(const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
Definition: kronecker.cpp:349
void TKronMtx::PlotCmpGraphs ( const TVec< TKronMtx > &  SeedMtxV,
const PNGraph &  Graph,
const TStr &  FNmPref,
const TStr &  Desc 
)
static

Definition at line 556 of file kronecker.cpp.

556  {
557  const TStr Desc1 = TStr::Fmt("%s", Desc.CStr());
558  TGStatVec GS(tmuNodes, TFSet() | gsdInDeg | gsdOutDeg | gsdWcc | gsdScc | gsdHops | gsdClustCf | gsdSngVec | gsdSngVal);
559  GS.Add(Graph, TSecTm(1), TStr::Fmt("GRAPH G(%d, %d)", Graph->GetNodes(), Graph->GetEdges()));
560  //gsdHops
561  //gsWccHops, gsdSngVal, gsdSngVec, gsdClustCf
562  for (int m = 0; m < SeedMtxV.Len(); m++) {
563  const int KronIters = SeedMtxV[m].GetKronIter(Graph->GetNodes());
564  PNGraph KronG1 = TKronMtx::GenFastKronecker(SeedMtxV[m], KronIters, true, 0);
565  printf("*** K(%d, %d) n0=%d\n", KronG1->GetNodes(), KronG1->GetEdges(), SeedMtxV[m].GetDim());
566  TSnap::DelZeroDegNodes(KronG1);
567  printf(" del zero deg K(%d, %d) n0=%d\n", KronG1->GetNodes(), KronG1->GetEdges(), m);
568  GS.Add(KronG1, TSecTm(m+2), TStr::Fmt("K(%d, %d) n0^k=%d n0=%d", KronG1->GetNodes(), KronG1->GetEdges(), SeedMtxV[m].GetNZeroK(Graph), SeedMtxV[m].GetDim()));
569  // plot after each Kronecker is done
570  const TStr Style = "linewidth 1 pointtype 6 pointsize 1";
571  GS.ImposeDistr(gsdInDeg, FNmPref, Desc1, false, false, gpwLines, Style);
572  GS.ImposeDistr(gsdInDeg, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
573  GS.ImposeDistr(gsdOutDeg, FNmPref, Desc1, false, false, gpwLines, Style);
574  GS.ImposeDistr(gsdOutDeg, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
575  GS.ImposeDistr(gsdHops, FNmPref, Desc1, false, false, gpwLines, Style);
576  GS.ImposeDistr(gsdClustCf, FNmPref, Desc1, false, false, gpwLines, Style);
577  GS.ImposeDistr(gsdClustCf, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
578  GS.ImposeDistr(gsdSngVal, FNmPref, Desc1, false, false, gpwLines, Style);
579  GS.ImposeDistr(gsdSngVal, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
580  GS.ImposeDistr(gsdSngVec, FNmPref, Desc1, false, false, gpwLines, Style);
581  GS.ImposeDistr(gsdSngVec, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
582  GS.ImposeDistr(gsdWcc, FNmPref, Desc1, false, false, gpwLines, Style);
583  GS.ImposeDistr(gsdWcc, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
584  GS.ImposeDistr(gsdScc, FNmPref, Desc1, false, false, gpwLines, Style);
585  GS.ImposeDistr(gsdScc, FNmPref+"-B", Desc1, true, false, gpwLines, Style);
586  }
587  // typedef enum { distrUndef, distrInDeg, distrOutDeg, distrWcc, distrScc,
588  // distrHops, distrWccHops, distrSngVal, distrSngVec, distrClustCf, distrMx } TGraphDistr;*/
589 }
gsdInDeg
Definition: gstat.h:28
TFSet
Definition: bits.h:119
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
gsdHops
Definition: gstat.h:29
gsdScc
Definition: gstat.h:28
TGStatVec
Graph Statistics Sequence.
Definition: gstat.h:155
TSnap::DelZeroDegNodes
void DelZeroDegNodes(PGraph &Graph)
Removes all the zero-degree nodes, that isolated nodes, from the graph.
Definition: alg.h:432
tmuNodes
Definition: tm.h:14
TSecTm
Definition: tm.h:81
gsdWcc
Definition: gstat.h:28
TStr
Definition: dt.h:412
TStr::Fmt
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
TPt
Definition: bd.h:196
TStr::CStr
char * CStr()
Definition: dt.h:479
TKronMtx::GenFastKronecker
static PNGraph GenFastKronecker(const TKronMtx &SeedMtx, const int &NIter, const bool &IsDir, const int &Seed=0)
Definition: kronecker.cpp:349
void TKronMtx::PutAllMtx ( const double &  Val)
inline

Definition at line 39 of file kronecker.h.

39 { SeedMtx.PutAll(Val); }
TVec::PutAll
void PutAll(const TVal &Val)
Sets all elements of the vector to value Val.
Definition: ds.h:1229
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
static void TKronMtx::PutRndSeed ( const int &  Seed)
inlinestatic

Definition at line 108 of file kronecker.h.

108 { TKronMtx::Rnd.PutSeed(Seed); }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TRnd::PutSeed
void PutSeed(const int &_Seed)
Definition: dt.cpp:18
void TKronMtx::SaveTxt ( const TStr &  OutFNm) const

Definition at line 14 of file kronecker.cpp.

14  {
15  FILE *F = fopen(OutFNm.CStr(), "wt");
16  for (int i = 0; i < GetDim(); i++) {
17  for (int j = 0; j < GetDim(); j++) {
18  if (j > 0) fprintf(F, "\t");
19  fprintf(F, "%f", At(i,j)); }
20  fprintf(F, "\n");
21  }
22  fclose(F);
23 }
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
TKronMtx::GetDim
int GetDim() const
Definition: kronecker.h:30
TStr::CStr
char * CStr()
Definition: dt.h:479
void TKronMtx::SetEpsMtx ( const double &  Eps1,
const double &  Eps0,
const int &  Eps1Val = 1,
const int &  Eps0Val = 0 
)

Definition at line 50 of file kronecker.cpp.

50  {
51  for (int i = 0; i < Len(); i++) {
52  double& Val = At(i);
53  if (Val == Eps1Val) Val = double(Eps1);
54  else if (Val == Eps0Val) Val = double(Eps0);
55  }
56 }
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
void TKronMtx::SetForEdges ( const int &  Nodes,
const int &  Edges 
)

Definition at line 59 of file kronecker.cpp.

59  {
60  const int KronIter = GetKronIter(Nodes);
61  const double EZero = pow((double) Edges, 1.0/double(KronIter));
62  const double Factor = EZero / GetMtxSum();
63  for (int i = 0; i < Len(); i++) {
64  At(i) *= Factor;
65  if (At(i) > 1) { At(i) = 1; }
66  }
67 }
TKronMtx::GetMtxSum
double GetMtxSum() const
Definition: kronecker.cpp:140
TKronMtx::GetKronIter
int GetKronIter(const int &Nodes) const
Definition: kronecker.cpp:127
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46
void TKronMtx::SetMtx ( const TFltV &  ParamV)
inline

Definition at line 37 of file kronecker.h.

37 { SeedMtx = ParamV; }
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::SetRndMtx ( const int &  MtxDim,
const double &  MinProb = 0.0 
)

Definition at line 40 of file kronecker.cpp.

40  {
41  MtxDim = PrmMtxDim;
42  SeedMtx.Gen(MtxDim*MtxDim);
43  for (int p = 0; p < SeedMtx.Len(); p++) {
44  do {
45  SeedMtx[p] = TKronMtx::Rnd.GetUniDev();
46  } while (SeedMtx[p] < MinProb);
47  }
48 }
TKronMtx::Rnd
static TRnd Rnd
Definition: kronecker.h:14
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:523
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::Swap ( TKronMtx &  KronMtx)

Definition at line 114 of file kronecker.cpp.

114  {
115  ::Swap(MtxDim, KronMtx.MtxDim);
116  SeedMtx.Swap(KronMtx.SeedMtx);
117 }
TKronMtx::Swap
void Swap(TKronMtx &KronMtx)
Definition: kronecker.cpp:114
TKronMtx::MtxDim
TInt MtxDim
Definition: kronecker.h:16
TVec::Swap
void Swap(TVec< TVal, TSizeTy > &Vec)
Swaps the contents of the vector with Vec.
Definition: ds.h:1101
TKronMtx::SeedMtx
TFltV SeedMtx
Definition: kronecker.h:17
void TKronMtx::ToOneMinusMtx ( )

Definition at line 91 of file kronecker.cpp.

91  {
92  for (int i = 0; i < Len(); i++) {
93  IAssert(At(i) >= 0.0 && At(i) <= 1.0);
94  At(i) = 1.0 - At(i);
95  }
96 }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TKronMtx::Len
int Len() const
Definition: kronecker.h:31
TKronMtx::At
const double & At(const int &Row, const int &Col) const
Definition: kronecker.h:46

Member Data Documentation

TInt TKronMtx::MtxDim
private

Definition at line 16 of file kronecker.h.

const double TKronMtx::NInf = -DBL_MAX
static

Definition at line 13 of file kronecker.h.

TRnd TKronMtx::Rnd = TRnd(0)
static

Definition at line 14 of file kronecker.h.

TFltV TKronMtx::SeedMtx
private

Definition at line 17 of file kronecker.h.

The documentation for this class was generated from the following files: