void TBowFl::SaveCpdToLnDocTxt(const TStr& InCpdFNm, const TStr& OutLnDocFNm){
TFOut FOut(OutLnDocFNm); FILE* fOut=FOut.GetFileId();
PSIn CpDocSIn=TCpDoc::FFirstCpd(InCpdFNm); PCpDoc CpDoc; int Docs=0;
printf("Saving '%s' to '%s' ...\n", InCpdFNm.CStr(), OutLnDocFNm.CStr());
while (TCpDoc::FNextCpd(CpDocSIn, CpDoc)){
Docs++; if (Docs%100==0){printf("%d Docs\r", Docs);}
// get document-name
TStr DocNm=CpDoc->GetDocNm();
DocNm=TStr::GetFNmStr(DocNm);
DocNm.ChangeChAll(' ', '_');
// get document-categories
TStrV CatNmV;
for (int CatN=0; CatN<CpDoc->GetCats(); CatN++){
CatNmV.Add(CpDoc->GetCatNm(CatN));}
// get document-contents
TChA DocChA=CpDoc->GetTxtStr();
DocChA.ChangeCh('\r', ' ');
DocChA.ChangeCh('\n', ' ');
// save document
fprintf(fOut, "%s", DocNm.CStr());
for (int CatN=0; CatN<CatNmV.Len(); CatN++){
fprintf(fOut, " !%s", CatNmV[CatN].CStr());}
fprintf(fOut, " %s\n", DocChA.CStr());
}
printf("%d Docs\nDone.\n", Docs);
}
void TRSet::SaveXml(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "<RSet>\n");
// fixed fields
if (!GetUrlStr().Empty()){
fprintf(fOut, " <Url>%s</Url>\n", TXmlLx::GetXmlStrFromPlainStr(GetUrlStr()).CStr());}
if (!GetNextUrlStr().Empty()){
fprintf(fOut, " <NextUrl>%s</NextUrl>\n", TXmlLx::GetXmlStrFromPlainStr(GetNextUrlStr()).CStr());}
if (!GetQueryStr().Empty()){
fprintf(fOut, " <Query>%s</Query>\n", TXmlLx::GetXmlStrFromPlainStr(GetQueryStr()).CStr());}
if (GetAllHits()!=-1){
fprintf(fOut, " <AllHits>%d</AllHits>\n", GetAllHits());}
// hits
fprintf(fOut, " <Hits Size=\"%d\">\n", GetHits());
for (int HitN=0; HitN<GetHits(); HitN++){
TStr HitUrlStr; TStr HitTitleStr; TStr HitSrcNm; TStr HitCtxStr;
GetHit(HitN, HitUrlStr, HitTitleStr, HitSrcNm, HitCtxStr);
fprintf(fOut, " <Hit Num=\"%d\">\n", 1+HitN);
fprintf(fOut, " <Url>%s</Url>\n", TXmlLx::GetXmlStrFromPlainStr(HitUrlStr).CStr());
fprintf(fOut, " <Title>%s</Title>\n", TXmlLx::GetXmlStrFromPlainStr(HitTitleStr).CStr());
if (!HitSrcNm.Empty()){
fprintf(fOut, " <Source>%s</Source>\n", TXmlLx::GetXmlStrFromPlainStr(HitSrcNm).CStr());}
fprintf(fOut, " <Snippet>%s</Snippet>\n", TXmlLx::GetXmlStrFromPlainStr(HitCtxStr).CStr());
fprintf(fOut, " </Hit>\n");
}
fprintf(fOut, " </Hits>\n");
fprintf(fOut, "</RSet>");
}
void TNetInfBs::SaveCascades(const TStr& OutFNm) {
TFOut FOut(OutFNm);
// write nodes to file
for (TNGraph::TNodeI NI = GroundTruth->BegNI(); NI < GroundTruth->EndNI(); NI++) {
FOut.PutStr(TStr::Fmt("%d,%d\r\n", NI.GetId(), NI.GetId())); // nodes
}
FOut.PutStr("\r\n");
// write cascades to file
for (int i=0; i<CascV.Len(); i++) {
TCascade &C = CascV[i];
int j = 0;
for (THash<TInt, THitInfo>::TIter NI = C.NIdHitH.BegI(); NI < C.NIdHitH.EndI(); NI++, j++) {
if (j > 0)
FOut.PutStr(TStr::Fmt(",%d,%f", NI.GetDat().NId.Val, NI.GetDat().Tm.Val));
else
FOut.PutStr(TStr::Fmt("%d,%f", NI.GetDat().NId.Val, NI.GetDat().Tm.Val));
}
if (C.Len() >= 1)
FOut.PutStr(TStr::Fmt("\r\n"));
}
}
void TNGramBs::SaveTxt(const TStr& FNm, const bool& SortP) const {
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
if (SortP){
int NGrams=GetNGrams(); TStr NGramStr; int NGramFq;
TIntPrV FqNGramIdPrV(GetNGrams(), 0);
for (int NGramId=0; NGramId<NGrams; NGramId++){
GetNGramStrFq(NGramId, NGramStr, NGramFq);
if (NGramFq!=-1){
FqNGramIdPrV.Add(TIntPr(NGramFq, NGramId));}
}
FqNGramIdPrV.Sort(false);
for (int NGramN=0; NGramN<FqNGramIdPrV.Len(); NGramN++){
int NGramFq=FqNGramIdPrV[NGramN].Val1;
int NGramId=FqNGramIdPrV[NGramN].Val2;
GetNGramStrFq(NGramId, NGramStr, NGramFq);
fprintf(fOut, "'%s': %d\n", NGramStr.CStr(), NGramFq);
}
} else {
int NGrams=GetNGrams(); TStr NGramStr; int NGramFq;
for (int NGramId=0; NGramId<NGrams; NGramId++){
GetNGramStrFq(NGramId, NGramStr, NGramFq);
if (NGramFq!=-1){
fprintf(fOut, "'%s': %d\n", NGramStr.CStr(), NGramFq);}
}
}
}
void TGreedyAlg::saveCascades(const TStr& casacdesFilename) {
TFOut FOut(casacdesFilename);
// write nodes to file
for (TKColourNet::TNodeI NI = groundTruthGraph->BegNI(); NI < groundTruthGraph->EndNI(); NI++) {
FOut.PutStr(TStr::Fmt("%d,%d\r\n", NI.GetId(), NI.GetId()));
}
FOut.PutStr("\r\n");
// write cascades to file
for (int i = 0; i < cascadeV.Len(); i++) {
TCascade &C = cascadeV[i];
int j = 0;
for (THash<TInt, THitInfo>::TIter NI = C.NIdHitH.BegI(); NI < C.NIdHitH.EndI(); NI++, j++) {
if (j > 0)
FOut.PutStr(TStr::Fmt(";%d,%f", NI.GetDat().NId.Val, NI.GetDat().Tm.Val));
else
FOut.PutStr(TStr::Fmt("%d,%f", NI.GetDat().NId.Val, NI.GetDat().Tm.Val));
}
if (C.Len() >= 1)
FOut.PutStr(TStr::Fmt("\r\n"));
}
}
void TGreedyAlg::saveOutputAdjacencyMatrix(const TStr& outputNetworkFilename) {
TFOut FOut(outputNetworkFilename);
// create adjacency matrix
const int noNodes = outputGraph->GetNodes();
TFltVV AdjMtx(noNodes, noNodes);
TIntH NodeIdH;
for (TKColourNet::TNodeI NI = outputGraph->BegNI(); NI < outputGraph->EndNI(); NI++) {
NodeIdH.AddKey(NI.GetId());
}
for (TKColourNet::TNodeI NI = outputGraph->BegNI(); NI < outputGraph->EndNI(); NI++) {
const int NodeId = NodeIdH.GetKeyId(NI.GetId());
for (int e = 0; e < NI.GetOutDeg(); e++) {
const int DstNId = NodeIdH.GetKeyId(NI.GetOutNId(e));
// no self edges
if (NodeId != DstNId) {
AdjMtx.At(NodeId, DstNId) = 1;
}
}
}
for (int row = 0; row < AdjMtx.GetRows(); row++) {
for (int col = 0; col < AdjMtx.GetCols(); col++) {
FOut.PutStr(TStr::Fmt("%d,", (int) AdjMtx.At(row, col)));
}
FOut.PutStr("\r\n");
}
// printf("Saved Adjacency matrix with : noRows = %d, noCols = %d\n", AdjMtx.GetRows(), AdjMtx.GetCols());
}
void TGreedyAlg::saveGroundTruth(const TStr& networkFilename) {
TFOut FOut(networkFilename);
// write nodes to file
for (TKColourNet::TNodeI NI = groundTruthGraph->BegNI(); NI < groundTruthGraph->EndNI(); NI++) {
FOut.PutStr(TStr::Fmt("%d,%d,", NI.GetId(), NI.GetId()));
FOut.PutStr(NI.GetDat().getColour());
FOut.PutStr(TStr::Fmt("\r\n"));
}
FOut.PutStr("\r\n");
// write edges to file (not allowing self loops in the network)
for (TKColourNet::TEdgeI EI = groundTruthGraph->BegEI(); EI < groundTruthGraph->EndEI(); EI++) {
// not allowing self loops
if (EI.GetSrcNId() != EI.GetDstNId()) {
FOut.PutStr(TStr::Fmt("%d,%d,", EI.GetSrcNId(), EI.GetDstNId()));
TKColourNet::TNodeI srcNI = groundTruthGraph->GetNI(EI.GetSrcNId());
TKColourNet::TNodeI dstNI = groundTruthGraph->GetNI(EI.GetDstNId());
int srcNodeColourId = srcNI.GetDat().getColourId();
int dstNodeColourId = dstNI.GetDat().getColourId();
FOut.PutStr(getEdgeColourTransitionInfo(srcNodeColourId, dstNodeColourId));
FOut.PutStr(TStr::Fmt("\r\n"));
}
}
}
void WriteOutput(TStr& OutFile, TIntFltVH& EmbeddingsHV, TVVec<TInt, int64>& WalksVV,
bool& OutputWalks) {
TFOut FOut(OutFile);
if (OutputWalks) {
for (int64 i = 0; i < WalksVV.GetXDim(); i++) {
for (int64 j = 0; j < WalksVV.GetYDim(); j++) {
FOut.PutInt(WalksVV(i,j));
if(j+1==WalksVV.GetYDim()) {
FOut.PutLn();
} else {
FOut.PutCh(' ');
}
}
}
return;
}
bool First = 1;
for (int i = EmbeddingsHV.FFirstKeyId(); EmbeddingsHV.FNextKeyId(i);) {
if (First) {
FOut.PutInt(EmbeddingsHV.Len());
FOut.PutCh(' ');
FOut.PutInt(EmbeddingsHV[i].Len());
FOut.PutLn();
First = 0;
}
FOut.PutInt(EmbeddingsHV.GetKey(i));
for (int64 j = 0; j < EmbeddingsHV[i].Len(); j++) {
FOut.PutCh(' ');
FOut.PutFlt(EmbeddingsHV[i][j]);
}
FOut.PutLn();
}
}
// Test node, edge creation
TEST(TCrossNet, ManipulateNodesEdges) {
int NNodes = 1000;
int NEdges = 100000;
const char *FName = "test.graph.dat";
TCrossNet Graph;
TCrossNet Graph1;
TCrossNet Graph2;
int n;
int NCount;
int x,y;
Graph = TCrossNet();
EXPECT_EQ(0,Graph.GetEdges());
// create random edges
NCount = NEdges;
while (NCount > 0) {
x = (long) (drand48() * NNodes);
y = (long) (drand48() * NNodes);
n = Graph.AddEdge(x, y);
NCount--;
}
EXPECT_EQ(NEdges,Graph.GetEdges());
// edges iterator
NCount = 0;
for (TCrossNet::TCrossEdgeI EI = Graph.BegEdgeI(); EI < Graph.EndEdgeI(); EI++) {
NCount++;
}
EXPECT_EQ(NEdges,NCount);
// assignment
Graph1 = Graph;
EXPECT_EQ(NEdges,Graph1.GetEdges());
// saving and loading
{
TFOut FOut(FName);
Graph.Save(FOut);
FOut.Flush();
}
{
TFIn FIn(FName);
Graph2 = TCrossNet(FIn);
}
EXPECT_EQ(NEdges,Graph2.GetEdges());
/*Graph1.Clr(); //TODO implement
EXPECT_EQ(0,Graph1.GetNodes());
EXPECT_EQ(0,Graph1.GetEdges());
EXPECT_EQ(1,Graph1.IsOk());
EXPECT_EQ(1,Graph1.Empty());*/
}
void TNytNGramBs::SaveTxt(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
int NGrams=TermStrVH.Len();
for (int NGramId=0; NGramId<NGrams; NGramId++){
TStr NGramStr=GetNGramStr(NGramId);
fprintf(fOut, "%d\t%s\n", NGramId, NGramStr.CStr());
}
}
void TGgSchBs::SaveXml(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "<GgSchBs>\n");
for (int RefN=0; RefN<GetRefs(); RefN++){
PGgSchRef Ref=GetRef(RefN);
Ref->SaveXml(fOut, 1+RefN);
}
fprintf(fOut, "</GgSchBs>");
}
void TRSet::SaveXml(const TStr& FNm, const PRSet& RSet){
if (RSet.Empty()){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "<RSets>\n");
fprintf(fOut, " <Error/>\n");
fprintf(fOut, "</RSets>");
} else {
RSet->SaveXml(FNm);
}
}
void TGgSchRSet::SaveXml(const TStr& FNm, const PGgSchRSet& GgSchRSet){
if (GgSchRSet.Empty()){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "<GgSchRSets>\n");
fprintf(fOut, " <Error/>\n");
fprintf(fOut, "</GgSchRSets>");
} else {
GgSchRSet->SaveXml(FNm);
}
}
/////////////////////////////////////////////////
// Translation-Corpus
void TTransCorpus::CleanTmx(const TStr& InTmxFNm, const TStr& OutXmlFNm) {
TFIn FIn(InTmxFNm); TFOut FOut(OutXmlFNm);
TStr ChStr; bool InTagP = false;
while (!FIn.Eof()) {
ChStr = TStr::GetChStr(FIn.GetCh());
if (ChStr == "<") { InTagP = true; FOut.PutStr(ChStr); }
else if (ChStr == ">") { InTagP = false; FOut.PutStr(ChStr); }
else if (!InTagP && ChStr != "\n" && ChStr != "\r") {
FOut.PutStr(TXmlDoc::GetXmlStr(ChStr));
} else { FOut.PutStr(ChStr); }
}
}
void TPlBs::SaveTxt(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
for (int RelId=0; RelId<GetRels(); RelId++){
for (int TupN=0; TupN<GetRelTups(RelId); TupN++){
int TupId=GetRelTupId(RelId, TupN);
PPlTup Tup=GetTup(TupId);
TStr TupStr=Tup->GetStr(this);
fprintf(fOut, "%s.\n", TupStr.CStr());
}
if (RelId+1<GetRels()){fprintf(fOut, "\n");}
}
}
/////////////////////////////////////////////////
// Light-Weight-Ontology
void TLwOnto::SaveTxt(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "===LwOnto-Begin======================\n");
GetLangBs()->SaveTxt(fOut);
fprintf(fOut, "\n");
GetTermTypeBs()->SaveTxt(fOut);
fprintf(fOut, "\n");
GetLinkTypeBs()->SaveTxt(fOut);
fprintf(fOut, "\n");
GetTermBs()->SaveTxt(fOut);
fprintf(fOut, "===LwOnto-End========================\n");
}
void TCycBs::SaveTxt(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
for (int VId=0; VId<GetVIds(); VId++){
TStr VNm=GetVNm(VId);
TCycVrtx& Vrtx=GetVrtx(VId);
TStr FlagStr=Vrtx.GetFlagStr();
fprintf(fOut, "(%d) %s - %s\n", VId, VNm.CStr(), FlagStr.CStr());
for (int EdgeN=0; EdgeN<Vrtx.GetEdges(); EdgeN++){
TCycEdge& Edge=Vrtx.GetEdge(EdgeN);
TStr RelNm=GetVNm(Edge.GetRelId());
TStr DstVNm=GetVNm(Edge.GetDstVId());
fprintf(fOut, " %d. [%s] --> %s\n", 1+EdgeN, RelNm.CStr(), DstVNm.CStr());
}
}
}
int main(int argc, char *argv[]) {
TDocBase *DocBase = new TDocBase;
TChA Url = TChA("http://www.newyorktimes.com/news_story");
TSecTm Date = TSecTm::GetCurTm();
TChA Content = TChA("foo bar foo foo");
TVec<TChA> Links;
Links.Add(TChA("http://www.google.com"));
Links.Add(TChA("http://www.yahoo.com"));
DocBase->AddDoc(Url, Date, Content, Links);
printf("Number of documents: %d\n", DocBase->Len());
TDoc t;
DocBase->GetDoc(0, t);
TStr tUrl;
t.GetUrl(tUrl);
printf("URL: %s\n", tUrl.CStr());
TStrV l;
t.GetLinks(l);
printf("Link1: %s\n", l[0].CStr());
printf("Link2: %s\n", l[1].CStr());
{ TFOut FOut("tmp.bin"); DocBase->Save(FOut); }
printf("Save data successfully\n");
delete DocBase;
TFIn FIn("tmp.bin");
printf("Load data successfully\n");
TDocBase *DocBase2 = new TDocBase;
DocBase2->Load(FIn);
printf("Number of documents: %d\n", DocBase2->Len());
TDoc t2;
DocBase2->GetDoc(0, t2);
TStr t2Url;
t2.GetUrl(t2Url);
printf("URL: %s\n", t2Url.CStr());
t2.GetLinks(l);
printf("Link1: %s\n", l[0].CStr());
printf("Link2: %s\n", l[1].CStr());
delete DocBase2;
return 0;
}
int main(int argc, char* argv[]) {
typedef PNGraph PGraph; // directed graph
printf("Creating graph for wikiTalk\n");
PGraph graph = TSnap::LoadEdgeList<PGraph>("data/wiki-Talk.txt", 0, 1);
IAssert(graph->IsOk());
printf("Graph (%d, %d)\n", graph->GetNodes(), graph->GetEdges());
printf("Getting max scc\n");
PGraph maxScc = TSnap::GetMxScc(graph);
printf("Scc (%d, %d)\n", maxScc->GetNodes(), maxScc->GetEdges());
TFOut FOut("data/wikiTalk_scc.graph");
maxScc->Save(FOut);
return 0;
}
/////////////////////////////////////////////////
// Light-Weight-Ontology-Grounding
void TLwOntoGround::SaveTxt(const TStr& FNm){
// shortcuts
PLwTermBs TermBs=LwOnto->GetTermBs();
// save data
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "===LwOnto-Begin======================\n");
for (int TermN=0; TermN<TermBs->GetTerms(); TermN++){
int TermId=TermBs->GetTermId(TermN);
TStr TermNm=TermBs->GetTerm(TermId)->GetTermNm();
fprintf(fOut, "TermId:%d TermNm:'%s'", TermId, TermNm.CStr());
if (TermIdToConceptSpVH.IsKey(TermId)){
PBowSpV ConceptSpV=TermIdToConceptSpVH.GetDat(TermId);
TStr ConceptSpVStr=ConceptSpV->GetStr(BowDocBs, 15, 0.66);
fprintf(fOut, " ConceptSpV:%s", ConceptSpVStr.CStr());
}
fprintf(fOut, "\n");
}
}
void TCycBs::SaveTaxonomyTxt(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
for (int VId=0; VId<GetVIds(); VId++){
printf("%d/%d (%.1f%%)\r", 1+VId, GetVIds(), 100.0*(1+VId)/GetVIds());
//if (VId>10){break;}
// upper taxonomy
{int Lev=0;
TIntIntH VIdToLevH; VIdToLevH.AddDat(VId, Lev);
TIntPrV UpRelIdVIdPrV; UpRelIdVIdPrV.Add(TIntPr(-1, VId));
_SaveTaxonomyTxt(fOut, Lev+1, UpRelIdVIdPrV, VIdToLevH);}
// lower taxonomy
{int Lev=0;
TIntIntH VIdToLevH; VIdToLevH.AddDat(VId, Lev);
TIntPrV UpRelIdVIdPrV; UpRelIdVIdPrV.Add(TIntPr(-1, VId));
_SaveTaxonomyTxt(fOut, Lev-1, UpRelIdVIdPrV, VIdToLevH);}
}
printf("\n");
}
void TGgSchRSet::SaveXml(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
fprintf(fOut, "<RSet>\n");
// fixed fields
if (!GetUrlStr().Empty()){
fprintf(fOut, " <Url>%s</Url>\n", TXmlLx::GetXmlStrFromPlainStr(GetUrlStr()).CStr());}
if (!GetNextUrlStr().Empty()){
fprintf(fOut, " <NextUrl>%s</NextUrl>\n", TXmlLx::GetXmlStrFromPlainStr(GetNextUrlStr()).CStr());}
if (!GetQueryStr().Empty()){
fprintf(fOut, " <Query>%s</Query>\n", TXmlLx::GetXmlStrFromPlainStr(GetQueryStr()).CStr());}
if (GetAllHits()!=-1){
fprintf(fOut, " <AllHits>%d</AllHits>\n", GetAllHits());}
// hits
fprintf(fOut, " <Hits Size=\"%d\">\n", GetHits());
for (int HitN=0; HitN<GetHits(); HitN++){
PGgSchRef Ref=GetHit(HitN);
Ref->SaveXml(fOut, 1+HitN);
}
fprintf(fOut, " </Hits>\n");
fprintf(fOut, "</RSet>");
}
void TNetInfBs::SaveGroundTruth(const TStr& OutFNm) {
TFOut FOut(OutFNm);
// write nodes to file
for (TNGraph::TNodeI NI = GroundTruth->BegNI(); NI < GroundTruth->EndNI(); NI++) {
FOut.PutStr(TStr::Fmt("%d,%d\r\n", NI.GetId(), NI.GetId())); // nodes
}
FOut.PutStr("\r\n");
// write edges to file (not allowing self loops in the network)
for (TNGraph::TEdgeI EI = GroundTruth->BegEI(); EI < GroundTruth->EndEI(); EI++) {
// not allowing self loops in the Kronecker network
if (EI.GetSrcNId() != EI.GetDstNId()) {
if (Alphas.IsKey(TIntPr(EI.GetSrcNId(), EI.GetDstNId())))
FOut.PutStr(TStr::Fmt("%d,%d,%f\r\n", EI.GetSrcNId(), EI.GetDstNId(), Alphas.GetDat(TIntPr(EI.GetSrcNId(), EI.GetDstNId())).Val));
else
FOut.PutStr(TStr::Fmt("%d,%d,1\r\n", EI.GetSrcNId(), EI.GetDstNId()));
}
}
}
void TWnBs::SaveTxt(const TStr& FNm){
TFOut FOut(FNm); FILE* fOut=FOut.GetFileId();
for (int SynSetP=0; SynSetP<GetSynSets(); SynSetP++){
fprintf(fOut, "=====================================\n");
SaveTxtSynSet(SynSetP, fOut);
SaveTxtRel(wrtHypernym, SynSetP, true, fOut);
SaveTxtRel(wrtInstance, SynSetP, false, fOut);
SaveTxtRel(wrtEntailment, SynSetP, false, fOut);
SaveTxtRel(wrtSimilar, SynSetP, false, fOut);
SaveTxtRel(wrtMemberMeronym, SynSetP, false, fOut);
SaveTxtRel(wrtSubstanceMeronym, SynSetP, false, fOut);
SaveTxtRel(wrtPartMeronym, SynSetP, false, fOut);
SaveTxtRel(wrtDerivation, SynSetP, false, fOut);
SaveTxtRel(wrtClass, SynSetP, false, fOut);
SaveTxtRel(wrtCause, SynSetP, false, fOut);
SaveTxtRel(wrtVerbGroup, SynSetP, false, fOut);
SaveTxtRel(wrtAttribute, SynSetP, false, fOut);
SaveTxtRel(wrtAntonym, SynSetP, false, fOut);
SaveTxtRel(wrtAdditionalInfo, SynSetP, false, fOut);
SaveTxtRel(wrtParticiple, SynSetP, false, fOut);
SaveTxtRel(wrtPosRel, SynSetP, false, fOut);
fprintf(fOut, "=====================================\n\n");
}
}
TWebPgFetchPersist::~TWebPgFetchPersist() {
if (SaveFName != "") {
TFOut FOut(SaveFName);
Save(FOut);
}
}
// Test node, edge creation
void ManipulateNodesEdges() {
int NNodes = 10000;
int NEdges = 100000;
const char *FName = "test.graph";
PUNGraph Graph;
PUNGraph Graph1;
PUNGraph Graph2;
int i;
int n;
int NCount;
int ECount1;
int ECount2;
int x,y;
bool t;
Graph = TUNGraph::New();
t = Graph->Empty();
// create the nodes
for (i = 0; i < NNodes; i++) {
Graph->AddNode(i);
}
t = Graph->Empty();
n = Graph->GetNodes();
// create random edges
NCount = NEdges;
while (NCount > 0) {
x = (long) (drand48() * NNodes);
y = (long) (drand48() * NNodes);
// Graph->GetEdges() is not correct for the loops (x == y),
// skip the loops in this test
if (x != y && !Graph->IsEdge(x,y)) {
n = Graph->AddEdge(x, y);
NCount--;
}
}
PrintGStats("ManipulateNodesEdges:Graph",Graph);
// get all the nodes
NCount = 0;
for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
NCount++;
}
// get all the edges for all the nodes
ECount1 = 0;
for (TUNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
for (int e = 0; e < NI.GetOutDeg(); e++) {
ECount1++;
}
}
ECount1 /= 2;
// get all the edges directly
ECount2 = 0;
for (TUNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
ECount2++;
}
printf("graph ManipulateNodesEdges:Graph, nodes %d, edges1 %d, edges2 %d\n",
NCount, ECount1, ECount2);
// assignment
Graph1 = TUNGraph::New();
*Graph1 = *Graph;
PrintGStats("ManipulateNodesEdges:Graph1",Graph1);
// save the graph
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
}
// load the graph
{
TFIn FIn(FName);
Graph2 = TUNGraph::Load(FIn);
}
PrintGStats("ManipulateNodesEdges:Graph2",Graph2);
// remove all the nodes and edges
for (i = 0; i < NNodes; i++) {
n = Graph->GetRndNId();
Graph->DelNode(n);
}
PrintGStats("ManipulateNodesEdges:Graph",Graph);
Graph1->Clr();
PrintGStats("ManipulateNodesEdges:Graph1",Graph1);
}
// Test node attribute functionality
void ManipulateNodeEdgeAttributes() {
int NNodes = 1000;
int NEdges = 1000;
const char *FName = "demo.graph.dat";
PNEANet Graph;
PNEANet Graph1;
int i;
int x, y;
bool t;
Graph = TNEANet::New();
t = Graph->Empty();
// create the nodes
for (i = 0; i < NNodes; i++) {
Graph->AddNode(i);
}
// create the edges
for (i = 0; i < NEdges; i++) {
x = rand() % NNodes;
y = rand() % NNodes;
Graph->AddEdge(x, y, i);
}
// create attributes and fill all nodes
TStr attr1 = "str";
TStr attr2 = "int";
TStr attr3 = "float";
TStr attr4 = "default";
// Test vertical int iterator for node 3, 50, 700, 900
// Check if we can set defaults to 0 for Int data.
Graph->AddIntAttrN(attr2, 0);
Graph->AddIntAttrDatN(3, 3*2, attr2);
Graph->AddIntAttrDatN(50, 50*2, attr2);
Graph->AddIntAttrDatN(700, 700*2, attr2);
Graph->AddIntAttrDatN(900, 900*2, attr2);
int NodeId = 0;
for (TNEANet::TAIntI NI = Graph->BegNAIntI(attr2);
NI < Graph->EndNAIntI(attr2); NI++) {
// Check if defaults are now 0.
if (NI.GetDat()() != 0) {
printf("Attribute: %s, Node: %i, Val: %i\n", attr2(), NodeId, NI.GetDat()());
NodeId++;
}
}
// Test vertical flt iterator for node 3, 50, 700, 900
Graph->AddFltAttrDatN(5, 3.41, attr3);
Graph->AddFltAttrDatN(50, 2.718, attr3);
Graph->AddFltAttrDatN(300, 150.0, attr3);
Graph->AddFltAttrDatN(653, 653, attr3);
NodeId = 0;
for (TNEANet::TAFltI NI = Graph->BegNAFltI(attr3);
NI < Graph->EndNAFltI(attr3); NI++) {
if (NI.GetDat() != TFlt::Mn) {
printf("Attribute: %s, Node: %i, Val: %f\n", attr3(), NodeId, NI.GetDat()());
NodeId++;
}
}
// Test vertical str iterator for node 3, 50, 700, 900
Graph->AddStrAttrDatN(10, "abc", attr1);
Graph->AddStrAttrDatN(20, "def", attr1);
Graph->AddStrAttrDatN(400, "ghi", attr1);
// this does not show since ""=null
Graph->AddStrAttrDatN(455, "", attr1);
NodeId = 0;
for (TNEANet::TAStrI NI = Graph->BegNAStrI(attr1);
NI < Graph->EndNAStrI(attr1); NI++) {
if (NI.GetDat() != TStr::GetNullStr()) {
printf("Attribute: %s, Node: %i, Val: %s\n", attr1(), NodeId, NI.GetDat()());
NodeId++;
}
}
// Test vertical iterator over many types (must skip default/deleted attr)
int NId = 55;
Graph->AddStrAttrDatN(NId, "aaa", attr1);
Graph->AddIntAttrDatN(NId, 3*2, attr2);
Graph->AddFltAttrDatN(NId, 3.41, attr3);
Graph->AddStrAttrDatN(80, "dont appear", attr4); // should not show up
TStrV NIdAttrName;
Graph->AttrNameNI(NId, NIdAttrName);
int AttrLen = NIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node: %i, Attr: %s\n", NId, NIdAttrName[i]());
}
Graph->DelAttrDatN(NId, attr2);
Graph->AttrNameNI(NId, NIdAttrName);
AttrLen = NIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node (no int) : %i, Attr: %s\n", NId, NIdAttrName[i]());
}
Graph->AddIntAttrDatN(NId, 3*2, attr2);
Graph->DelAttrN(attr1);
Graph->AttrNameNI(NId, NIdAttrName);
AttrLen = NIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node (no str) : %i, Attr: %s\n", NId, NIdAttrName[i]());
}
TStrV NIdAttrValue;
Graph->AttrValueNI(NId, NIdAttrValue);
AttrLen = NIdAttrValue.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Node (no str) : %i, Attr_Val: %s\n", NId, NIdAttrValue[i]());
}
for (i = 0; i <NNodes; i++) {
Graph->AddIntAttrDatN(i, 70, attr2);
}
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
}
{
TFIn FIn(FName);
Graph1 = TNEANet::Load(FIn);
}
int total = 0;
for (TNEANet::TAIntI NI = Graph1->BegNAIntI(attr2);
NI < Graph1->EndNAIntI(attr2); NI++) {
total += NI.GetDat();
}
printf("Average: %i (should be 70)\n", total/NNodes);
Graph1->Clr();
// Test vertical int iterator for edge
Graph->AddIntAttrDatE(3, 3*2, attr2);
Graph->AddIntAttrDatE(55, 55*2, attr2);
Graph->AddIntAttrDatE(705, 705*2, attr2);
Graph->AddIntAttrDatE(905, 905*2, attr2);
int EdgeId = 0;
for (TNEANet::TAIntI EI = Graph->BegEAIntI(attr2);
EI < Graph->EndEAIntI(attr2); EI++) {
if (EI.GetDat() != TInt::Mn) {
printf("E Attribute: %s, Edge: %i, Val: %i\n", attr2(), EdgeId, EI.GetDat()());
EdgeId++;
}
}
// Test vertical flt iterator for edge
Graph->AddFltAttrE(attr3, 0.00);
Graph->AddFltAttrDatE(5, 4.41, attr3);
Graph->AddFltAttrDatE(50, 3.718, attr3);
Graph->AddFltAttrDatE(300, 151.0, attr3);
Graph->AddFltAttrDatE(653, 654, attr3);
EdgeId = 0;
for (TNEANet::TAFltI EI = Graph->BegEAFltI(attr3);
EI < Graph->EndEAFltI(attr3); EI++) {
// Check if defaults are set to 0.
if (EI.GetDat() != 0.00) {
printf("E Attribute: %s, Edge: %i, Val: %f\n", attr3(), EdgeId, EI.GetDat()());
EdgeId++;
}
}
// Test vertical str iterator for edge
Graph->AddStrAttrDatE(10, "abc", attr1);
Graph->AddStrAttrDatE(20, "def", attr1);
Graph->AddStrAttrDatE(400, "ghi", attr1);
// this does not show since ""=null
Graph->AddStrAttrDatE(455, "", attr1);
EdgeId = 0;
for (TNEANet::TAStrI EI = Graph->BegEAStrI(attr1);
EI < Graph->EndEAStrI(attr1); EI++) {
if (EI.GetDat() != TStr::GetNullStr()) {
printf("E Attribute: %s, Edge: %i, Val: %s\n", attr1(), EdgeId, EI.GetDat()());
EdgeId++;
}
}
// Test vertical iterator over many types (must skip default/deleted attr)
int EId = 55;
Graph->AddStrAttrDatE(EId, "aaa", attr1);
Graph->AddIntAttrDatE(EId, 3*2, attr2);
Graph->AddFltAttrDatE(EId, 3.41, attr3);
Graph->AddStrAttrDatE(80, "dont appear", attr4); // should not show up
TStrV EIdAttrName;
Graph->AttrNameEI(EId, EIdAttrName);
AttrLen = EIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge: %i, Attr: %s\n", EId, EIdAttrName[i]());
}
Graph->DelAttrDatE(EId, attr2);
Graph->AttrNameEI(EId, EIdAttrName);
AttrLen = EIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge (no int) : %i, Attr: %s\n", EId, EIdAttrName[i]());
}
Graph->AddIntAttrDatE(EId, 3*2, attr2);
Graph->DelAttrE(attr1);
Graph->AttrNameEI(EId, EIdAttrName);
AttrLen = EIdAttrName.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge (no str) : %i, Attr: %s\n", EId, EIdAttrName[i]());
}
TStrV EIdAttrValue;
Graph->AttrValueEI(EId, EIdAttrValue);
AttrLen = EIdAttrValue.Len();
for (int i = 0; i < AttrLen; i++) {
printf("Vertical Edge (no str) : %i, Attr_Val: %s\n", EId, EIdAttrValue[i]());
}
for (i = 0; i <NEdges; i++) {
Graph->AddIntAttrDatE(i, 70, attr2);
}
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
Graph->Clr();
}
{
TFIn FIn(FName);
Graph1 = TNEANet::Load(FIn);
}
total = 0;
for (TNEANet::TAIntI EI = Graph1->BegNAIntI(attr2);
EI < Graph1->EndNAIntI(attr2); EI++) {
total += EI.GetDat();
}
printf("Average: %i (should be 70)\n", total/NEdges);
//Graph1->Dump();
Graph1->Clr();
}
// Test node, edge creation
TEST(TNodeEdgeNet, ManipulateNodesEdges) {
int NNodes = 10000;
int NEdges = 100000;
const char *FName = "test.net";
TPt <TNodeEdgeNet<TInt, TInt> > Net;
TPt <TNodeEdgeNet<TInt, TInt> > Net1;
TPt <TNodeEdgeNet<TInt, TInt> > Net2;
int i;
int n;
int NCount;
int x,y;
int Deg, InDeg, OutDeg;
Net = TNodeEdgeNet<TInt, TInt>::New();
EXPECT_EQ(1,Net->Empty());
// create the nodes
for (i = 0; i < NNodes; i++) {
Net->AddNode(i);
}
EXPECT_EQ(0,Net->Empty());
EXPECT_EQ(NNodes,Net->GetNodes());
// create random edges
NCount = NEdges;
while (NCount > 0) {
x = (long) (drand48() * NNodes);
y = (long) (drand48() * NNodes);
n = Net->AddEdge(x, y);
NCount--;
}
EXPECT_EQ(NEdges,Net->GetEdges());
EXPECT_EQ(0,Net->Empty());
EXPECT_EQ(1,Net->IsOk());
for (i = 0; i < NNodes; i++) {
EXPECT_EQ(1,Net->IsNode(i));
}
EXPECT_EQ(0,Net->IsNode(NNodes));
EXPECT_EQ(0,Net->IsNode(NNodes+1));
EXPECT_EQ(0,Net->IsNode(2*NNodes));
// nodes iterator
NCount = 0;
for (TNodeEdgeNet<TInt, TInt>::TNodeI NI = Net->BegNI(); NI < Net->EndNI(); NI++) {
NCount++;
}
EXPECT_EQ(NNodes,NCount);
// edges per node iterator
NCount = 0;
for (TNodeEdgeNet<TInt, TInt>::TNodeI NI = Net->BegNI(); NI < Net->EndNI(); NI++) {
for (int e = 0; e < NI.GetOutDeg(); e++) {
NCount++;
}
}
EXPECT_EQ(NEdges,NCount);
// edges iterator
NCount = 0;
for (TNodeEdgeNet<TInt, TInt>::TEdgeI EI = Net->BegEI(); EI < Net->EndEI(); EI++) {
NCount++;
}
EXPECT_EQ(NEdges,NCount);
// node degree
for (TNodeEdgeNet<TInt, TInt>::TNodeI NI = Net->BegNI(); NI < Net->EndNI(); NI++) {
Deg = NI.GetDeg();
InDeg = NI.GetInDeg();
OutDeg = NI.GetOutDeg();
EXPECT_EQ(Deg,InDeg+OutDeg);
}
// assignment
Net1 = TNodeEdgeNet<TInt, TInt>::New();
*Net1 = *Net;
EXPECT_EQ(NNodes,Net1->GetNodes());
EXPECT_EQ(NEdges,Net1->GetEdges());
EXPECT_EQ(0,Net1->Empty());
EXPECT_EQ(1,Net1->IsOk());
// saving and loading
{
TFOut FOut(FName);
Net->Save(FOut);
FOut.Flush();
}
{
TFIn FIn(FName);
Net2 = TNodeEdgeNet<TInt, TInt>::Load(FIn);
}
EXPECT_EQ(NNodes,Net2->GetNodes());
EXPECT_EQ(NEdges,Net2->GetEdges());
EXPECT_EQ(0,Net2->Empty());
EXPECT_EQ(1,Net2->IsOk());
// remove all the nodes and edges
for (i = 0; i < NNodes; i++) {
n = Net->GetRndNId();
Net->DelNode(n);
}
EXPECT_EQ(0,Net->GetNodes());
EXPECT_EQ(0,Net->GetEdges());
EXPECT_EQ(1,Net->IsOk());
EXPECT_EQ(1,Net->Empty());
Net1->Clr();
EXPECT_EQ(0,Net1->GetNodes());
EXPECT_EQ(0,Net1->GetEdges());
EXPECT_EQ(1,Net1->IsOk());
EXPECT_EQ(1,Net1->Empty());
}
// Test node, edge creation
void ManipulateNodesEdges() {
int NNodes = 1000;
int NEdges = 100000;
const char *FName = "demo.graph.dat";
PNEANet Graph;
PNEANet Graph1;
PNEANet Graph2;
int i;
int n;
int NCount;
int ECount1;
int ECount2;
int x,y;
bool t;
Graph = TNEANet::New();
t = Graph->Empty();
// create the nodes
for (i = 0; i < NNodes; i++) {
Graph->AddNode(i);
}
n = Graph->GetNodes();
t = Graph->Empty();
// create random edges
NCount = NEdges;
while (NCount > 0) {
x = rand() % NNodes;
y = rand() % NNodes;
n = Graph->AddEdge(x, y);
NCount--;
}
PrintGStats("ManipulateNodesEdges:Graph",Graph);
// get all the nodes
NCount = 0;
for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
NCount++;
}
// get all the edges for all the nodes
ECount1 = 0;
for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
for (int e = 0; e < NI.GetOutDeg(); e++) {
ECount1++;
}
}
// get all the edges directly
ECount2 = 0;
for (TNEANet::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
ECount2++;
}
printf("graph ManipulateNodesEdges:Graph, nodes %d, edges1 %d, edges2 %d\n",
NCount, ECount1, ECount2);
// assignment
Graph1 = TNEANet::New();
*Graph1 = *Graph;
PrintGStats("ManipulateNodesEdges:Graph1",Graph1);
// save the graph
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
}
// load the graph
{
TFIn FIn(FName);
Graph2 = TNEANet::Load(FIn);
}
PrintGStats("ManipulateNodesEdges:Graph2",Graph2);
// remove all the nodes and edges
for (i = 0; i < NNodes; i++) {
n = Graph->GetRndNId();
Graph->DelNode(n);
}
PrintGStats("ManipulateNodesEdges:Graph",Graph);
Graph1->Clr();
PrintGStats("ManipulateNodesEdges:Graph1",Graph1);
}
// Test node, edge creation
TEST(TNGraph, ManipulateNodesEdges) {
int NNodes = 10000;
int NEdges = 100000;
const char *FName = "test.graph.dat";
PNGraph Graph;
PNGraph Graph1;
PNGraph Graph2;
int i;
int n;
int NCount;
int x,y;
int Deg, InDeg, OutDeg;
Graph = TNGraph::New();
EXPECT_EQ(1,Graph->Empty());
// create the nodes
for (i = 0; i < NNodes; i++) {
Graph->AddNode(i);
}
EXPECT_EQ(0,Graph->Empty());
EXPECT_EQ(NNodes,Graph->GetNodes());
// create random edges
NCount = NEdges;
while (NCount > 0) {
x = (long) (drand48() * NNodes);
y = (long) (drand48() * NNodes);
// Graph->GetEdges() is not correct for the loops (x == y),
// skip the loops in this test
if (x != y && !Graph->IsEdge(x,y)) {
n = Graph->AddEdge(x, y);
NCount--;
}
}
EXPECT_EQ(NEdges,Graph->GetEdges());
EXPECT_EQ(0,Graph->Empty());
EXPECT_EQ(1,Graph->IsOk());
for (i = 0; i < NNodes; i++) {
EXPECT_EQ(1,Graph->IsNode(i));
}
EXPECT_EQ(0,Graph->IsNode(NNodes));
EXPECT_EQ(0,Graph->IsNode(NNodes+1));
EXPECT_EQ(0,Graph->IsNode(2*NNodes));
// nodes iterator
NCount = 0;
for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
NCount++;
}
EXPECT_EQ(NNodes,NCount);
// edges per node iterator
NCount = 0;
for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
for (int e = 0; e < NI.GetOutDeg(); e++) {
NCount++;
}
}
EXPECT_EQ(NEdges,NCount);
// edges iterator
NCount = 0;
for (TNGraph::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) {
NCount++;
}
EXPECT_EQ(NEdges,NCount);
// node degree
for (TNGraph::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) {
Deg = NI.GetDeg();
InDeg = NI.GetInDeg();
OutDeg = NI.GetOutDeg();
EXPECT_EQ(Deg,InDeg+OutDeg);
}
// assignment
Graph1 = TNGraph::New();
*Graph1 = *Graph;
EXPECT_EQ(NNodes,Graph1->GetNodes());
EXPECT_EQ(NEdges,Graph1->GetEdges());
EXPECT_EQ(0,Graph1->Empty());
EXPECT_EQ(1,Graph1->IsOk());
// saving and loading
{
TFOut FOut(FName);
Graph->Save(FOut);
FOut.Flush();
}
{
TFIn FIn(FName);
Graph2 = TNGraph::Load(FIn);
}
EXPECT_EQ(NNodes,Graph2->GetNodes());
EXPECT_EQ(NEdges,Graph2->GetEdges());
EXPECT_EQ(0,Graph2->Empty());
EXPECT_EQ(1,Graph2->IsOk());
// remove all the nodes and edges
for (i = 0; i < NNodes; i++) {
n = Graph->GetRndNId();
Graph->DelNode(n);
}
EXPECT_EQ(0,Graph->GetNodes());
EXPECT_EQ(0,Graph->GetEdges());
EXPECT_EQ(1,Graph->IsOk());
EXPECT_EQ(1,Graph->Empty());
Graph1->Clr();
EXPECT_EQ(0,Graph1->GetNodes());
EXPECT_EQ(0,Graph1->GetEdges());
EXPECT_EQ(1,Graph1->IsOk());
EXPECT_EQ(1,Graph1->Empty());
}
