void TGStat::TakeSpectral(const PNGraph& Graph, TFSet StatFSet, int _TakeSngVals) {
if (_TakeSngVals == -1) { _TakeSngVals = TakeSngVals; }
// singular values, vectors
if (StatFSet.In(gsdSngVal)) {
const int SngVals = TMath::Mn(_TakeSngVals, Graph->GetNodes()/2);
TFltV SngValV1;
TSnap::GetSngVals(Graph, SngVals, SngValV1);
SngValV1.Sort(false);
TFltPrV& SngValV = DistrStatH.AddDat(gsdSngVal);
SngValV.Gen(SngValV1.Len(), 0);
for (int i = 0; i < SngValV1.Len(); i++) {
SngValV.Add(TFltPr(i+1, SngValV1[i]));
}
}
if (StatFSet.In(gsdSngVec)) {
TFltV LeftV, RightV;
TSnap::GetSngVec(Graph, LeftV, RightV);
LeftV.Sort(false);
TFltPrV& SngVec = DistrStatH.AddDat(gsdSngVec);
SngVec.Gen(LeftV.Len(), 0);
for (int i = 0; i < TMath::Mn(Kilo(10), LeftV.Len()/2); i++) {
if (LeftV[i] > 0) { SngVec.Add(TFltPr(i+1, LeftV[i])); }
}
}
}
void TGStatVec::PlotAllVsX(const TGStatVal& XVal, const TStr& OutFNm, TStr Desc, const TGpScaleTy& Scale, const bool& PowerFit) const {
const TFSet SkipStat = TFSet() | gsvFullDiamDev | gsvEffDiamDev | gsvEffWccDiamDev | gsvFullWccDiamDev;
for (int stat = gsvNone; stat < gsvMx; stat++) {
const TGStatVal Stat = TGStatVal(stat);
if (SkipStat.In(Stat)) { continue; }
if (Last()->HasVal(Stat) && Last()->HasVal(XVal) && Stat!=XVal) {
Plot(XVal, Stat, OutFNm, Desc, Scale, PowerFit);
}
}
}
void TGStat::TakeStat(const PNGraph& Graph, const TSecTm& _Time, TFSet StatFSet, const TStr& GraphName) {
printf("\n===TakeStat: G(%u, %u)\n", Graph->GetNodes(), Graph->GetEdges());
TExeTm ExeTm, FullTm;
Time = _Time;
GraphNm = GraphName;
if (StatFSet.In(gsvNone)) { return; }
TakeBasicStat(Graph, false);
TakeDiam(Graph, StatFSet, false);
if (StatFSet.In(gsdWcc) || StatFSet.In(gsdWccHops) || StatFSet.In(gsvFullDiam) || StatFSet.In(gsvEffWccDiam)) {
PNGraph WccGraph = TSnap::GetMxWcc(Graph);
TakeBasicStat(WccGraph, true);
TakeDiam(WccGraph, StatFSet, true);
}
// degrees
TakeDegDistr(Graph, StatFSet);
// components
TakeConnComp(Graph, StatFSet);
// spectral
TakeSpectral(Graph, StatFSet, -1);
// clustering coeffient
if (StatFSet.In(gsdClustCf) || StatFSet.In(gsvClustCf)) {
TakeClustCf(Graph); }
if (StatFSet.In(gsdTriadPart)) {
TakeTriadPart(Graph); }
printf(" [%s]\n", FullTm.GetTmStr());
}
bool TLxSymStr::IsSep(const TLxSym& PrevSym, const TLxSym& Sym){
static TFSet SepPrevSymSet=TFSet()|
syUndef|syColon|syDColon|syEq|
syLParen|syRParen|syLBracket|syRBracket|syLBrace|syRBrace|
syEoln|syEof;
static TFSet SepSymSet=TFSet()|
syPeriod|syComma|syColon|syDColon|sySemicolon|
syEq|
syExclamation|syQuestion|
syLParen|syRParen|syLBracket|syRBracket|syLBrace|syRBrace|
syEoln|syEof;
return !SepPrevSymSet.In(PrevSym) && !SepSymSet.In(Sym);
}
void TGStat::Plot(const TFSet& FSet, const TStr& FNmPref, TStr Desc, bool PowerFit) const {
for (int d = gsdUndef; d < gsdMx; d++) {
const TGStatDistr Distr = TGStatDistr(d);
if (! FSet.In(Distr)) { continue; }
Plot(Distr, FNmPref, Desc, PowerFit);
}
}
TWixExpLxSym TWixExpLx::GetSym(const TFSet& Expect){
Str.Clr();
while (ChDef.IsSpace(Ch)){GetCh();}
if (Expect.In(wesyNum)){
if (!ChDef.IsNum(Ch)){throw EWixExp("Number expected.");}
Sym=wesyNum;
do {Str.AddCh(Ch); GetCh();} while (ChDef.IsNum(Ch));
} else {
switch (ChDef.GetChTy(Ch)){
case welctAlpha:
case welctNum:
do {Str.AddCh(Ch); GetCh();} while (ChDef.IsAlNum(Ch));
if (Str=="OR"){Sym=wesyOr;}
else if (Str=="AND"){Sym=wesyAnd;}
else if (Str=="NOT"){Sym=wesyNot;}
else {Sym=wesyWord;}
break;
case welctSym:
Str.AddCh(Ch);
switch (Ch){
case ':': Sym=wesyColon; break;
case '(': Sym=wesyLParen; break;
case ')': Sym=wesyRParen; break;
case '|': Sym=wesyOr; break;
case '&': Sym=wesyAnd; break;
case '!': Sym=wesyNot; break;
case '+': Sym=wesyIncl; break;
case '-': Sym=wesyExcl; break;
case '*': Sym=wesyWCard; break;
default: Sym=wesySSym;
}
GetCh();
break;
case welctEof: Sym=wesyEof; break;
default: Sym=wesyUndef; GetCh();
}
}
if ((!Expect.In(Sym))&&(!Expect.Empty())){
if (Sym==wesyEof){
throw EWixExp("Unexpected end of expression.");
} else {
throw EWixExp("Unexpected symbol.");
}
}
return Sym;
}
/////////////////////////////////////////////////
// Lexical-Input
TILx::TILx(const PSIn& _SIn, const TFSet& OptSet, const TLxChDefTy& ChDefTy):
ChDef(TLxChDef::GetChDef(ChDefTy)),
SIn(_SIn), RSIn(*SIn),
PrevCh(' '), Ch(' '), LnN(0), LnChN(0-1), ChN(0-1),
PrevSymStStack(), RwStrH(50),
IsCmtAlw(false), IsRetEoln(false), IsSigNum(false),
IsUniStr(false), IsCsSens(false), IsExcept(false),
IsTabSep(false), IsList(false),
Sym(syUndef),
Str(), UcStr(), CmtStr(),
Bool(false), Int(0), Flt(0),
SymLnN(-1), SymLnChN(-1), SymChN(-1){
for (int Opt=0; Opt<iloMx; Opt++){
if (OptSet.In(Opt)){SetOpt(Opt, true);}}
}
TLxSym TILx::GetSym(const TFSet& Expect){
CmtStr.Clr();
if (!PrevSymStStack.Empty()){
// symbols already on the stack
PrevSymStStack.Top().Restore(*this); PrevSymStStack.Pop();
} else
if (Expect.In(syLn)){
// symbol is the whole line string
if (Ch==TCh::EofCh){
Sym=syEof;
} else {
Str.Clr();
if (IsBof()){GetCh();}
while (!ChDef->IsTerm(Ch)){Str.AddCh(Ch); GetCh();}
bool _IsRetEoln=IsRetEoln; IsRetEoln=true;
GetSym(TFSet()|syEoln|syEof); Sym=syLn;
IsRetEoln=_IsRetEoln;
}
} else
if (IsTabSep){
// symbol is between tab characters
if (IsBof()){GetCh();}
if (Ch==TCh::TabCh){ // tab character
Sym=syTab; GetCh();
} else
if (ChDef->IsTerm(Ch)){ // eoln & eof characters
bool _IsRetEoln=IsRetEoln; IsRetEoln=true; IsTabSep=false;
GetSym(TFSet()|syEoln|syEof);
IsRetEoln=_IsRetEoln; IsTabSep=true;
} else {
Str.Clr();
while ((!ChDef->IsTerm(Ch))&&(Ch!=TCh::TabCh)){
Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
Sym=syStr; QuoteP=false;
}
} else {
// usual symbol
while (ChDef->IsSpace(Ch)){GetCh();}
SymLnN=LnN; SymLnChN=LnChN; SymChN=ChN;
if (ChDef->IsAlpha(Ch)){
if (IsUniStr){Sym=syStr;} else {Sym=syIdStr;}
Str.Clr(); UcStr.Clr(); QuoteP=false;
do {Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch));}
while (ChDef->IsAlNum(GetCh()));
if (!RwStrH.Empty()){
TStr RwStr=Str; if (!IsCsSens){RwStr=UcStr;}
int SymKeyId=RwStrH.GetKeyId(RwStr);
if (SymKeyId!=-1){Sym=TLxSym(int(RwStrH[SymKeyId]));}
}
if (Expect.In(syBool)){
Sym=syBool; IAssert(TBool::IsValStr(Str));
Bool=TBool::GetValFromStr(Str);
}
} else
if ((Ch=='"')||(Ch=='\'')){
if (IsUniStr){Sym=syStr;} else {Sym=syQStr;}
Str.Clr(); UcStr.Clr(); QuoteP=true; QuoteCh=Ch;
GetCh();
forever{
while ((Ch!=QuoteCh)&&(Ch!='\\')&&(Ch!=TCh::EofCh)){
Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh();}
if (Ch==TCh::EofCh){
Sym=syUndef; break;
} else if (Ch==QuoteCh){
GetCh(); break;
} else {
GetCh();
switch (Ch){
case '"': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case '\\': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case '\'': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case '/': Str.AddCh(Ch); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case 'b': Str.AddCh('\b'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case 'f': Str.AddCh('\f'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case 'n': Str.AddCh('\n'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case 'r': Str.AddCh('\r'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case 't': Str.AddCh('\t'); UcStr.AddCh(ChDef->GetUc(Ch)); GetCh(); break;
case 'u': {
// unicode character, represented using 4 hexadecimal digits
GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
int UChCd = TCh::GetHex(Ch);
GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
UChCd = 16 * UChCd + TCh::GetHex(Ch);
GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
UChCd = 16 * UChCd + TCh::GetHex(Ch);
GetCh(); EAssertR(TCh::IsHex(Ch), "Invalid hexadecimal digit in unicode escape");
UChCd = 16 * UChCd + TCh::GetHex(Ch);
// get as UTF8 encoded characters
TUnicode::EncodeUtf8(UChCd, Str);
TUnicode::EncodeUtf8(UChCd, UcStr); }
GetCh(); break;
default: Sym=syUndef; break;
}
if (Sym==syUndef){
throw PExcept(new TExcept("Invalid Escape Sequence in Quoted String"));}
}
}
} else
if ((ChDef->IsNum(Ch))||(IsSigNum&&((Ch=='+')||(Ch=='-')))){
Str.Clr(); bool IntP=true;
do {Str.AddCh(Ch);} while (ChDef->IsNum(GetCh()));
if (Expect.In(syFlt)){
if (Ch=='.'){
Str.AddCh(Ch); IntP=false;
while (ChDef->IsNum(GetCh())){Str.AddCh(Ch);}
}
if ((Ch=='e')||(Ch=='E')){
Str.AddCh(Ch); GetCh(); IntP=false;
if ((Ch=='+')||(Ch=='-')){Str.AddCh(Ch); GetCh();}
while (ChDef->IsNum(Ch)){Str.AddCh(Ch); GetCh();}
}
}
UcStr=Str;
if (IntP&&(Expect.In(syInt))){
Sym=syInt; Int=atoi(Str.CStr());
} else {
Sym=syFlt; Flt=atof(Str.CStr());
}
} else
if ((Ch==TCh::CrCh)||(Ch==TCh::LfCh)){
Sym=syEoln;
if (Ch==TCh::CrCh){if (GetCh()==TCh::LfCh){GetCh();}} else
if (Ch==TCh::LfCh){if (GetCh()==TCh::CrCh){GetCh();}}
LnN++; LnChN=0; if (!IsRetEoln){GetSym(Expect);}
} else
if (Ch=='/'){
GetCh();
if ((IsCmtAlw)&&(Ch=='/')){
TChA _CmtStr;
do {_CmtStr+=GetCh();} while (!ChDef->IsTerm(Ch));
_CmtStr.Pop(); _CmtStr.Trunc();
if (Ch==TCh::CrCh){
if (GetCh()==TCh::LfCh){GetCh();}
} else
if (Ch==TCh::LfCh){
if (GetCh()==TCh::CrCh){GetCh();}
}
if (IsRetEoln){Sym=syEoln;} else {GetSym(Expect);}
CmtStr=_CmtStr;
} else
if (Ch=='*'){
TChA _CmtStr;
do {
while (GetCh()!='*'){_CmtStr+=Ch;}
_CmtStr+=GetCh();
} while (Ch!='/');
_CmtStr.Pop(); _CmtStr.Pop(); _CmtStr.Trunc();
GetCh(); GetSym(Expect);
CmtStr=_CmtStr;
} else {
Sym=sySlash;
}
} else
if (Ch==TCh::EofCh){
Sym=syEof;
} else {
switch (Ch){
case '.':
if (GetCh()=='.'){Sym=syDPeriod; GetCh();}
else {Sym=syPeriod;} break;
case ',': Sym=syComma; GetCh(); break;
case ':':
if (GetCh()==':'){Sym=syDColon; GetCh();}
else {Sym=syColon;} break;
case ';': Sym=sySemicolon; GetCh(); break;
case '+': Sym=syPlus; GetCh(); break;
case '-': Sym=syMinus; GetCh(); break;
case '*': Sym=syAsterisk; GetCh(); break;
case '/': Sym=sySlash; GetCh(); break;
case '%': Sym=syPercent; GetCh(); break;
case '!': Sym=syExclamation; GetCh(); break;
case '|': Sym=syVBar; GetCh(); break;
case '&': Sym=syAmpersand; GetCh(); break;
case '=': Sym=syEq; GetCh(); break;
case '<':
GetCh();
if (Ch=='='){Sym=syLEq; GetCh();}
else if (Ch=='>'){Sym=syNEq; GetCh();}
else {Sym=syLss;} break;
case '>':
if (GetCh()=='='){Sym=syGEq; GetCh();}
else {Sym=syGtr;} break;
case '?': Sym=syQuestion; GetCh(); break;
case '#':
if (IsCmtAlw){
TChA _CmtStr;
do {_CmtStr+=GetCh();} while (!ChDef->IsTerm(Ch));
_CmtStr.Pop(); _CmtStr.Trunc();
if (Ch==TCh::CrCh){
if (GetCh()==TCh::LfCh){GetCh();}
} else
if (Ch==TCh::LfCh){
if (GetCh()==TCh::CrCh){GetCh();}
}
if (IsRetEoln){Sym=syEoln;} else {GetSym(Expect);}
CmtStr=_CmtStr;
} else {
Sym=syHash; GetCh();
}
break;
case '(': Sym=syLParen; GetCh(); break;
case ')': Sym=syRParen; GetCh(); break;
case '[': Sym=syLBracket; GetCh(); break;
case ']': Sym=syRBracket; GetCh(); break;
case '{': Sym=syLBrace; GetCh(); break;
case '}': Sym=syRBrace; GetCh(); break;
default: Sym=syUndef; GetCh(); break;
}
}
}
TSqlDmLxSym TSqlDmLx::GetSym(const TFSet& Expect){
if (!PrevSymStStack.Empty()){
// symbols already on the stack
PrevSymStStack.Top().Restore(*this); PrevSymStStack.Pop();
} else {
// usual symbol
while (ChDef.IsSpace(Ch)){GetCh();}
SymLnN=LnN; SymLnChN=LnChN; SymChN=ChN;
if (ChDef.IsAlpha(Ch)){ // name
Str.Clr(); UcStr.Clr();
do {Str.AddCh(Ch); UcStr.AddCh(ChDef.GetUc(Ch));}
while (ChDef.IsAlNum(GetCh()));
Sym=TSqlDmLxSymStr::GetRwSym(UcStr);
if (Sym==dsyUndef){Sym=dsyName;}
} else
if (Ch=='['){ // bracketed name
Str.Clr(); UcStr.Clr(); GetCh();
while ((Ch!=']')&&(Ch!=TCh::EofCh)){
Str.AddCh(Ch); UcStr.AddCh(ChDef.GetUc(Ch)); GetCh();}
if (Ch==TCh::EofCh){Sym=dsyUndef;}
else {Sym=dsyName; GetCh();}
} else
if (Ch=='\''){ // string in single quotes
Str.Clr(); UcStr.Clr(); GetCh();
while ((Ch!='\'')&&(Ch!=TCh::EofCh)){
Str.AddCh(Ch); UcStr.AddCh(ChDef.GetUc(Ch)); GetCh();}
if (Ch==TCh::EofCh){Sym=dsyUndef;}
else {Sym=dsyStr; GetCh();}
} else
if (ChDef.IsNum(Ch)){ // integer or float
Str.Clr();
do {Str.AddCh(Ch);} while (ChDef.IsNum(GetCh()));
if (Ch=='.'){
Str.AddCh(Ch);
while (ChDef.IsNum(GetCh())){Str.AddCh(Ch);}
}
if ((Ch=='e')||(Ch=='E')){
Str.AddCh(Ch); GetCh();
if ((Ch=='+')||(Ch=='-')){Str.AddCh(Ch); GetCh();}
while (ChDef.IsNum(Ch)){Str.AddCh(Ch); GetCh();}
}
UcStr=Str;
if (Expect.In(syFlt)){Sym=dsyFlt; Flt=atof(Str.CStr());}
else {Sym=dsyInt; Int=atoi(Str.CStr());}
} else
if (Ch=='/'){ // slash or // commenatry or /* */ commentary
GetCh();
if (Ch=='/'){
do {GetCh();} while (!ChDef.IsEof(Ch));
if (Ch==TCh::CrCh){
if (GetCh()==TCh::LfCh){GetCh();}
} else
if (Ch==TCh::LfCh){
if (GetCh()==TCh::CrCh){GetCh();}
}
GetSym(Expect);
} else
if (Ch=='*'){
do {while (GetCh()!='*'){}} while (GetCh()!='/');
GetCh(); GetSym(Expect);
} else {
Sym=dsySlash;
}
} else
if (Ch=='-'){ // minus or -- commenatry
GetCh();
if (Ch=='-'){
do {GetCh();} while (!ChDef.IsEof(Ch));
if (Ch==TCh::CrCh){
if (GetCh()==TCh::LfCh){GetCh();}
} else
if (Ch==TCh::LfCh){
if (GetCh()==TCh::CrCh){GetCh();}
}
GetSym(Expect);
} else {
Sym=dsyMinus;
}
} else
if (Ch==TCh::EofCh){ // end-of-file
Sym=dsyEof;
} else { // other symbols
switch (Ch){
case ',': Sym=dsyComma; GetCh(); break;
case '.':
if (ChDef.IsNum(GetCh())){
PutCh('.'); PutCh('0'); return GetSym(Expect);}
else {Sym=dsyPeriod;}
break;
case ';': Sym=dsySemicolon; GetCh(); break;
case '<':
GetCh();
if (Ch=='='){Sym=dsyLEq; GetCh();}
else if (Ch=='>'){Sym=dsyNEq; GetCh();}
else {Sym=dsyLss;} break;
case '=': Sym=dsyEq; GetCh(); break;
case '>':
if (GetCh()=='='){Sym=dsyGEq; GetCh();}
else {Sym=dsyGtr;} break;
case '+': Sym=dsyPlus; GetCh(); break;
case '-': Sym=dsyMinus; GetCh(); break;
case '*': Sym=dsyAsterisk; GetCh(); break;
case '/': Sym=dsySlash; GetCh(); break;
case '(': Sym=dsyLParen; GetCh(); break;
case ')': Sym=dsyRParen; GetCh(); break;
case '{': Sym=dsyLBrace; GetCh(); break;
case '}': Sym=dsyRBrace; GetCh(); break;
default: Sym=dsyUndef; GetCh(); break;
}
}
}
if ((!Expect.In(Sym))&&(!Expect.Empty())){
TStr MsgStr=
TStr("Unexpected symbol (")+Str+") ["+GetFPosStr()+"]";
throw TExcept::Throw(MsgStr);
}
return Sym;
}
TTqlLxSym TTqlLx::GetSym(const TFSet& Expect){
Str.Clr();
while (ChDef.IsSpace(Ch)){GetCh();}
if (Expect.In(tsyNum)){
if (!ChDef.IsNum(Ch)){throw ETql("Number expected.");}
Sym=tsyNum;
do {Str.AddCh(Ch); GetCh();} while (ChDef.IsNum(Ch));
} else {
switch (ChDef.GetChTy(Ch)){
case tlcAlpha:
case tlcNum:
do {Str.AddCh(Ch); GetCh();} while (ChDef.IsAlNum(Ch));
if (Str=="OR"){Sym=tsyOr;}
else if (Str=="AND"){Sym=tsyAnd;}
else if (Str=="NOT"){Sym=tsyNot;}
else {Sym=tsyWord;}
break;
case tlcSym:
Str.AddCh(Ch);
switch (Ch){
case '\"': Sym=tsyDQuote; GetCh(); break;
case ':': Sym=tsyColon; GetCh(); break;
case '(': Sym=tsyLParen; GetCh(); break;
case ')': Sym=tsyRParen; GetCh(); break;
case '[': Sym=tsyLBracket; GetCh(); break;
case ']': Sym=tsyRBracket; GetCh(); break;
case '|': Sym=tsyOr; GetCh(); break;
case '&': Sym=tsyAnd; GetCh(); break;
case '!': Sym=tsyNot; GetCh(); break;
case '+': Sym=tsyIncl; GetCh(); break;
case '-': Sym=tsyExcl; GetCh(); break;
case '#': Sym=tsyTitle; GetCh(); break;
case '*': Sym=tsyWCard; GetCh(); break;
case '<':
GetCh();
if (Ch=='='){Sym=tsyLEq; GetCh();}
else if (Ch=='>'){Sym=tsyNEq; GetCh();}
else {Sym=tsyLss;}
break;
case '=': Sym=tsyEq; GetCh(); break;
case '>':
GetCh();
if (Ch=='='){Sym=tsyGEq; GetCh();}
else {Sym=tsyGtr;}
break;
default: Sym=tsySSym; GetCh();
}
break;
case tlcEof: Sym=tsyEof; break;
default: Sym=tsyUndef; GetCh();
}
}
if ((!Expect.In(Sym))&&(!Expect.Empty())){
if (Sym==tsyEof){
throw ETql("Unexpected end of expression.");
} else {
throw ETql("Unexpected symbol.");
}
}
return Sym;
}
