SNAP Library 6.0, Developer Reference  2020-12-09 16:24:20
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
networkmp.cpp
Go to the documentation of this file.
1 #ifdef GCC_ATOMIC
2 
4 // Attribute Node Edge Network
5 bool TNEANetMP::HasFlag(const TGraphFlag& Flag) const {
6  return HasGraphFlag(TNEANetMP::TNet, Flag);
7 }
8 
9 bool TNEANetMP::TNodeI::IsInNId(const int& NId) const {
10  const TNode& Node = NodeHI.GetDat();
11  for (int edge = 0; edge < Node.GetInDeg(); edge++) {
12  if (NId == Graph->GetEdge(Node.GetInEId(edge)).GetSrcNId())
13  return true;
14  }
15  return false;
16 }
17 
18 bool TNEANetMP::TNodeI::IsOutNId(const int& NId) const {
19  const TNode& Node = NodeHI.GetDat();
20  for (int edge = 0; edge < Node.GetOutDeg(); edge++) {
21  if (NId == Graph->GetEdge(Node.GetOutEId(edge)).GetDstNId())
22  return true;
23  }
24  return false;
25 }
26 
27 void TNEANetMP::AttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) const {
28  Names = TVec<TStr>();
29  while (!NodeHI.IsEnd()) {
30  if (!NodeAttrIsDeleted(NId, NodeHI)) {
31  Names.Add(NodeHI.GetKey());
32  }
33  NodeHI++;
34  }
35 }
36 
37 void TNEANetMP::AttrValueNI(const TInt& NId , TStrIntPrH::TIter NodeHI, TStrV& Values) const {
38  Values = TVec<TStr>();
39  while (!NodeHI.IsEnd()) {
40  if (!NodeAttrIsDeleted(NId, NodeHI)) {
41  Values.Add(GetNodeAttrValue(NId, NodeHI));
42  }
43  NodeHI++;
44  }
45 }
46 
47 void TNEANetMP::IntAttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) const {
48  Names = TVec<TStr>();
49  while (!NodeHI.IsEnd()) {
50  if (NodeHI.GetDat().Val1 == IntType && !NodeAttrIsIntDeleted(NId, NodeHI)) {
51  Names.Add(NodeHI.GetKey());
52  }
53  NodeHI++;
54  }
55 }
56 
57 void TNEANetMP::IntAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TIntV& Values) const {
58  Values = TVec<TInt>();
59  while (!NodeHI.IsEnd()) {
60  if (NodeHI.GetDat().Val1 == IntType && !NodeAttrIsIntDeleted(NId, NodeHI)) {
61  TInt val = this->VecOfIntVecsN.GetVal(NodeHI.GetDat().Val2).GetVal(NodeH.GetKeyId(NId));
62  Values.Add(val);
63  }
64  NodeHI++;
65  }
66 }
67 
68 void TNEANetMP::StrAttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) const {
69  Names = TVec<TStr>();
70  while (!NodeHI.IsEnd()) {
71  if (NodeHI.GetDat().Val1 == StrType && !NodeAttrIsStrDeleted(NId, NodeHI)) {
72  Names.Add(NodeHI.GetKey());
73  }
74  NodeHI++;
75  }
76 }
77 
78 void TNEANetMP::StrAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Values) const {
79  Values = TVec<TStr>();
80  while (!NodeHI.IsEnd()) {
81  if (NodeHI.GetDat().Val1 == StrType && !NodeAttrIsStrDeleted(NId, NodeHI)) {
82  TStr val = this->VecOfStrVecsN.GetVal(NodeHI.GetDat().Val2).GetVal(NodeH.GetKeyId(NId));
83  Values.Add(val);
84  }
85  NodeHI++;
86  }
87 }
88 
89 void TNEANetMP::FltAttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) const {
90  Names = TVec<TStr>();
91  while (!NodeHI.IsEnd()) {
92  if (NodeHI.GetDat().Val1 == FltType && !NodeAttrIsFltDeleted(NId, NodeHI)) {
93  Names.Add(NodeHI.GetKey());
94  }
95  NodeHI++;
96  }
97 }
98 
99 void TNEANetMP::FltAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TFltV& Values) const {
100  Values = TVec<TFlt>();
101  while (!NodeHI.IsEnd()) {
102  if (NodeHI.GetDat().Val1 == FltType && !NodeAttrIsFltDeleted(NId, NodeHI)) {
103  TFlt val = (this->VecOfFltVecsN.GetVal(NodeHI.GetDat().Val2).GetVal(NodeH.GetKeyId(NId)));
104  Values.Add(val);
105  }
106  NodeHI++;
107  }
108 }
109 
110 bool TNEANetMP::NodeAttrIsDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) const {
111  bool IntDel = NodeAttrIsIntDeleted(NId, NodeHI);
112  bool StrDel = NodeAttrIsStrDeleted(NId, NodeHI);
113  bool FltDel = NodeAttrIsFltDeleted(NId, NodeHI);
114  return IntDel || StrDel || FltDel;
115 }
116 
117 bool TNEANetMP::NodeAttrIsIntDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) const {
118  return (NodeHI.GetDat().Val1 == IntType &&
119  GetIntAttrDefaultN(NodeHI.GetKey()) == this->VecOfIntVecsN.GetVal(
120  this->KeyToIndexTypeN.GetDat(NodeHI.GetKey()).Val2).GetVal(NodeH.GetKeyId(NId)));
121 }
122 
123 bool TNEANetMP::NodeAttrIsStrDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) const {
124  return (NodeHI.GetDat().Val1 == StrType &&
125  GetStrAttrDefaultN(NodeHI.GetKey()) == this->VecOfStrVecsN.GetVal(
126  this->KeyToIndexTypeN.GetDat(NodeHI.GetKey()).Val2).GetVal(NodeH.GetKeyId(NId)));
127 }
128 
129 bool TNEANetMP::NodeAttrIsFltDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) const {
130  return (NodeHI.GetDat().Val1 == FltType &&
131  GetFltAttrDefaultN(NodeHI.GetKey()) == this->VecOfFltVecsN.GetVal(
132  this->KeyToIndexTypeN.GetDat(NodeHI.GetKey()).Val2).GetVal(NodeH.GetKeyId(NId)));
133 }
134 
135 TStr TNEANetMP::GetNodeAttrValue(const int& NId, const TStrIntPrH::TIter& NodeHI) const {
136  if (NodeHI.GetDat().Val1 == IntType) {
137  return (this->VecOfIntVecsN.GetVal(
138  this->KeyToIndexTypeN.GetDat(NodeHI.GetKey()).Val2).GetVal(NodeH.GetKeyId(NId))).GetStr();
139  } else if(NodeHI.GetDat().Val1 == StrType) {
140  return this->VecOfStrVecsN.GetVal(
141  this->KeyToIndexTypeN.GetDat(NodeHI.GetKey()).Val2).GetVal(NodeH.GetKeyId(NId));
142  } else if (NodeHI.GetDat().Val1 == FltType) {
143  return (this->VecOfFltVecsN.GetVal(
144  this->KeyToIndexTypeN.GetDat(NodeHI.GetKey()).Val2).GetVal(NodeH.GetKeyId(NId))).GetStr();
145  }
146  return TStr::GetNullStr();
147 }
148 
149 void TNEANetMP::AttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) const {
150  Names = TVec<TStr>();
151  while (!EdgeHI.IsEnd()) {
152  if (!EdgeAttrIsDeleted(EId, EdgeHI)) {
153  Names.Add(EdgeHI.GetKey());
154  }
155  EdgeHI++;
156  }
157 }
158 
159 void TNEANetMP::AttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Values) const {
160  Values = TVec<TStr>();
161  while (!EdgeHI.IsEnd()) {
162  if (!EdgeAttrIsDeleted(EId, EdgeHI)) {
163  Values.Add(GetNodeAttrValue(EId, EdgeHI));
164  }
165  EdgeHI++;
166  }
167 }
168 
169 void TNEANetMP::IntAttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) const {
170  Names = TVec<TStr>();
171  while (!EdgeHI.IsEnd()) {
172  if (EdgeHI.GetDat().Val1 == IntType && !EdgeAttrIsIntDeleted(EId, EdgeHI)) {
173  Names.Add(EdgeHI.GetKey());
174  }
175  EdgeHI++;
176  }
177 }
178 
179 void TNEANetMP::IntAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TIntV& Values) const {
180  Values = TVec<TInt>();
181  while (!EdgeHI.IsEnd()) {
182  if (EdgeHI.GetDat().Val1 == IntType && !EdgeAttrIsIntDeleted(EId, EdgeHI)) {
183  TInt val = (this->VecOfIntVecsE.GetVal(EdgeHI.GetDat().Val2).GetVal(EId));
184  Values.Add(val);
185  }
186  EdgeHI++;
187  }
188 }
189 
190 void TNEANetMP::StrAttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) const {
191  Names = TVec<TStr>();
192  while (!EdgeHI.IsEnd()) {
193  if (EdgeHI.GetDat().Val1 == StrType && !EdgeAttrIsStrDeleted(EId, EdgeHI)) {
194  Names.Add(EdgeHI.GetKey());
195  }
196  EdgeHI++;
197  }
198 }
199 
200 void TNEANetMP::StrAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Values) const {
201  Values = TVec<TStr>();
202  while (!EdgeHI.IsEnd()) {
203  if (EdgeHI.GetDat().Val1 == StrType && !EdgeAttrIsStrDeleted(EId, EdgeHI)) {
204  TStr val = this->VecOfStrVecsE.GetVal(EdgeHI.GetDat().Val2).GetVal(EId);
205  Values.Add(val);
206  }
207  EdgeHI++;
208  }
209 }
210 
211 void TNEANetMP::FltAttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) const {
212  Names = TVec<TStr>();
213  while (!EdgeHI.IsEnd()) {
214  if (EdgeHI.GetDat().Val1 == FltType && !EdgeAttrIsFltDeleted(EId, EdgeHI)) {
215  Names.Add(EdgeHI.GetKey());
216  }
217  EdgeHI++;
218  }
219 }
220 
221 void TNEANetMP::FltAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TFltV& Values) const {
222  Values = TVec<TFlt>();
223  while (!EdgeHI.IsEnd()) {
224  if (EdgeHI.GetDat().Val1 == FltType && !EdgeAttrIsFltDeleted(EId, EdgeHI)) {
225  TFlt val = (this->VecOfFltVecsE.GetVal(EdgeHI.GetDat().Val2).GetVal(EId));
226  Values.Add(val);
227  }
228  EdgeHI++;
229  }
230 }
231 
232 bool TNEANetMP::EdgeAttrIsDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) const {
233  bool IntDel = EdgeAttrIsIntDeleted(EId, EdgeHI);
234  bool StrDel = EdgeAttrIsStrDeleted(EId, EdgeHI);
235  bool FltDel = EdgeAttrIsFltDeleted(EId, EdgeHI);
236  return IntDel || StrDel || FltDel;
237 }
238 
239 bool TNEANetMP::EdgeAttrIsIntDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) const {
240  return (EdgeHI.GetDat().Val1 == IntType &&
241  GetIntAttrDefaultE(EdgeHI.GetKey()) == this->VecOfIntVecsE.GetVal(
242  this->KeyToIndexTypeE.GetDat(EdgeHI.GetKey()).Val2).GetVal(EdgeH.GetKeyId(EId)));
243 }
244 
245 bool TNEANetMP::EdgeAttrIsStrDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) const {
246  return (EdgeHI.GetDat().Val1 == StrType &&
247  GetStrAttrDefaultE(EdgeHI.GetKey()) == this->VecOfStrVecsE.GetVal(
248  this->KeyToIndexTypeE.GetDat(EdgeHI.GetKey()).Val2).GetVal(EdgeH.GetKeyId(EId)));
249 }
250 
251 bool TNEANetMP::EdgeAttrIsFltDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) const {
252  return (EdgeHI.GetDat().Val1 == FltType &&
253  GetFltAttrDefaultE(EdgeHI.GetKey()) == this->VecOfFltVecsE.GetVal(
254  this->KeyToIndexTypeE.GetDat(EdgeHI.GetKey()).Val2).GetVal(EdgeH.GetKeyId(EId)));
255 }
256 
257 TStr TNEANetMP::GetEdgeAttrValue(const int& EId, const TStrIntPrH::TIter& EdgeHI) const {
258  if (EdgeHI.GetDat().Val1 == IntType) {
259  return (this->VecOfIntVecsE.GetVal(
260  this->KeyToIndexTypeE.GetDat(EdgeHI.GetKey()).Val2).GetVal(EdgeH.GetKeyId(EId))).GetStr();
261  } else if(EdgeHI.GetDat().Val1 == StrType) {
262  return this->VecOfStrVecsE.GetVal(
263  this->KeyToIndexTypeE.GetDat(EdgeHI.GetKey()).Val2).GetVal(EdgeH.GetKeyId(EId));
264  } else if (EdgeHI.GetDat().Val1 == FltType) {
265  return (this->VecOfFltVecsE.GetVal(
266  this->KeyToIndexTypeE.GetDat(EdgeHI.GetKey()).Val2).GetVal(EdgeH.GetKeyId(EId))).GetStr();
267  }
268  return TStr::GetNullStr();
269 }
270 
271 int TNEANetMP::AddNode(int NId) {
272  int i;
273  if (NId == -1) {
274  NId = MxNId; MxNId++;
275  } else {
276  IAssertR(!IsNode(NId), TStr::Fmt("NodeId %d already exists", NId));
277  MxNId = TMath::Mx(NId+1, MxNId());
278  }
279  // update attribute columns
280  NodeH.AddDat(NId, TNode(NId));
281  for (i = 0; i < VecOfIntVecsN.Len(); i++) {
282  TVec<TInt>& IntVec = VecOfIntVecsN[i];
283  IntVec.Ins(NodeH.GetKeyId(NId), TInt::Mn);
284  }
285  TVec<TStr> DefIntVec = TVec<TStr>();
286  IntDefaultsN.GetKeyV(DefIntVec);
287  for (i = 0; i < DefIntVec.Len(); i++) {
288  TStr attr = DefIntVec[i];
289  TVec<TInt>& IntVec = VecOfIntVecsN[KeyToIndexTypeN.GetDat(DefIntVec[i]).Val2];
290  IntVec[NodeH.GetKeyId(NId)] = GetIntAttrDefaultN(attr);
291  }
292  for (i = 0; i < VecOfStrVecsN.Len(); i++) {
293  TVec<TStr>& StrVec = VecOfStrVecsN[i];
294  StrVec.Ins(NodeH.GetKeyId(NId), TStr::GetNullStr());
295  }
296  TVec<TStr> DefStrVec = TVec<TStr>();
297  IntDefaultsN.GetKeyV(DefStrVec);
298  for (i = 0; i < DefStrVec.Len(); i++) {
299  TStr attr = DefStrVec[i];
300  TVec<TStr>& StrVec = VecOfStrVecsN[KeyToIndexTypeN.GetDat(DefStrVec[i]).Val2];
301  StrVec[NodeH.GetKeyId(NId)] = GetStrAttrDefaultN(attr);
302  }
303  for (i = 0; i < VecOfFltVecsN.Len(); i++) {
304  TVec<TFlt>& FltVec = VecOfFltVecsN[i];
305  FltVec.Ins(NodeH.GetKeyId(NId), TFlt::Mn);
306  }
307  TVec<TStr> DefFltVec = TVec<TStr>();
308  FltDefaultsN.GetKeyV(DefFltVec);
309  for (i = 0; i < DefFltVec.Len(); i++) {
310  TStr attr = DefFltVec[i];
311  TVec<TFlt>& FltVec = VecOfFltVecsN[KeyToIndexTypeN.GetDat(DefFltVec[i]).Val2];
312  FltVec[NodeH.GetKeyId(NId)] = GetFltAttrDefaultN(attr);
313  }
314  return NId;
315 }
316 
317 // add a node with a list of neighbors
318 // (use TNGraphMP::IsOk to check whether the graph is consistent)
319 void TNEANetMP::AddNodeWithEdges(const TInt& NId, TIntV& InEIdV, TIntV& OutEIdV) {
320  int NodeIdx = abs((NId.GetPrimHashCd()) % Reserved());
321  int NodeKeyId = NodeH.AddKey13(NodeIdx, NId);
322  MxNId = TMath::Mx(NId+1, MxNId());
323  NodeH[NodeKeyId] = TNode(NId);
324  NodeH[NodeKeyId].InEIdV.MoveFrom(InEIdV);
325  NodeH[NodeKeyId].OutEIdV.MoveFrom(OutEIdV);
326 }
327 
328 //void TNEANetMP::DelNode(const int& NId) {
329 // int i;
330 //
331 // const TNode& Node = GetNode(NId);
332 // for (int out = 0; out < Node.GetOutDeg(); out++) {
333 // const int EId = Node.GetOutEId(out);
334 // const TEdge& Edge = GetEdge(EId);
335 // IAssert(Edge.GetSrcNId() == NId);
336 // GetNode(Edge.GetDstNId()).InEIdV.DelIfIn(EId);
337 // // Delete from Edge Attributes
338 // for (i = 0; i < VecOfIntVecsE.Len(); i++) {
339 // TVec<TInt>& IntVec = VecOfIntVecsE[i];
340 // IntVec[EdgeH.GetKeyId(EId)] = TInt::Mn;
341 // }
342 // for (i = 0; i < VecOfStrVecsE.Len(); i++) {
343 // TVec<TStr>& StrVec = VecOfStrVecsE[i];
344 // StrVec[EdgeH.GetKeyId(EId)] = TStr::GetNullStr();
345 // }
346 // for (i = 0; i < VecOfFltVecsE.Len(); i++) {
347 // TVec<TFlt>& FltVec = VecOfFltVecsE[i];
348 // FltVec[EdgeH.GetKeyId(EId)] = TFlt::Mn;
349 // }
350 // EdgeH.DelKey(EId);
351 // }
352 // for (int in = 0; in < Node.GetInDeg(); in++) {
353 // const int EId = Node.GetInEId(in);
354 // const TEdge& Edge = GetEdge(EId);
355 // IAssert(Edge.GetDstNId() == NId);
356 // GetNode(Edge.GetSrcNId()).OutEIdV.DelIfIn(EId);
357 // // Delete from Edge Attributes
358 // for (i = 0; i < VecOfIntVecsE.Len(); i++) {
359 // TVec<TInt>& IntVec = VecOfIntVecsE[i];
360 // IntVec[EdgeH.GetKeyId(EId)] = TInt::Mn;
361 // }
362 // for (i = 0; i < VecOfStrVecsE.Len(); i++) {
363 // TVec<TStr>& StrVec = VecOfStrVecsE[i];
364 // StrVec[EdgeH.GetKeyId(EId)] = TStr::GetNullStr();
365 // }
366 // for (i = 0; i < VecOfFltVecsE.Len(); i++) {
367 // TVec<TFlt>& FltVec = VecOfFltVecsE[i];
368 // FltVec[EdgeH.GetKeyId(EId)] = TFlt::Mn;
369 // }
370 // EdgeH.DelKey(EId);
371 // }
372 //
373 // for (i = 0; i < VecOfIntVecsN.Len(); i++) {
374 // TVec<TInt>& IntVec = VecOfIntVecsN[i];
375 // IntVec[NodeH.GetKeyId(NId)] = TInt::Mn;
376 // }
377 // for (i = 0; i < VecOfStrVecsN.Len(); i++) {
378 // TVec<TStr>& StrVec = VecOfStrVecsN[i];
379 // StrVec[NodeH.GetKeyId(NId)] = TStr::GetNullStr();
380 // }
381 // for (i = 0; i < VecOfFltVecsN.Len(); i++) {
382 // TVec<TFlt>& FltVec = VecOfFltVecsN[i];
383 // FltVec[NodeH.GetKeyId(NId)] = TFlt::Mn;
384 // }
385 // NodeH.DelKey(NId);
386 //}
387 
388 int TNEANetMP::AddEdge(const int& SrcNId, const int& DstNId, int EId) {
389  int i;
390 
391  if (EId == -1) { EId = MxEId; MxEId++; }
392  else { MxEId = TMath::Mx(EId+1, MxEId()); }
393  IAssertR(!IsEdge(EId), TStr::Fmt("EdgeId %d already exists", EId));
394  IAssertR(IsNode(SrcNId) && IsNode(DstNId), TStr::Fmt("%d or %d not a node.", SrcNId, DstNId).CStr());
395  EdgeH.AddDat(EId, TEdge(EId, SrcNId, DstNId));
396  GetNode(SrcNId).OutEIdV.AddSorted(EId);
397  GetNode(DstNId).InEIdV.AddSorted(EId);
398 
399  // update attribute columns
400  for (i = 0; i < VecOfIntVecsE.Len(); i++) {
401  TVec<TInt>& IntVec = VecOfIntVecsE[i];
402  IntVec.Ins(EdgeH.GetKeyId(EId), TInt::Mn);
403  }
404  TVec<TStr> DefIntVec = TVec<TStr>();
405  IntDefaultsE.GetKeyV(DefIntVec);
406  for (i = 0; i < DefIntVec.Len(); i++) {
407  TStr attr = DefIntVec[i];
408  TVec<TInt>& IntVec = VecOfIntVecsE[KeyToIndexTypeE.GetDat(DefIntVec[i]).Val2];
409  IntVec[EdgeH.GetKeyId(EId)] = GetIntAttrDefaultE(attr);
410  }
411 
412  for (i = 0; i < VecOfStrVecsE.Len(); i++) {
413  TVec<TStr>& StrVec = VecOfStrVecsE[i];
414  StrVec.Ins(EdgeH.GetKeyId(EId), TStr::GetNullStr());
415  }
416  TVec<TStr> DefStrVec = TVec<TStr>();
417  IntDefaultsE.GetKeyV(DefStrVec);
418  for (i = 0; i < DefStrVec.Len(); i++) {
419  TStr attr = DefStrVec[i];
420  TVec<TStr>& StrVec = VecOfStrVecsE[KeyToIndexTypeE.GetDat(DefStrVec[i]).Val2];
421  StrVec[EdgeH.GetKeyId(EId)] = GetStrAttrDefaultE(attr);
422  }
423 
424  for (i = 0; i < VecOfFltVecsE.Len(); i++) {
425  TVec<TFlt>& FltVec = VecOfFltVecsE[i];
426  FltVec.Ins(EdgeH.GetKeyId(EId), TFlt::Mn);
427  }
428  TVec<TStr> DefFltVec = TVec<TStr>();
429  FltDefaultsE.GetKeyV(DefFltVec);
430  for (i = 0; i < DefFltVec.Len(); i++) {
431  TStr attr = DefFltVec[i];
432  TVec<TFlt>& FltVec = VecOfFltVecsE[KeyToIndexTypeE.GetDat(DefFltVec[i]).Val2];
433  FltVec[NodeH.GetKeyId(EId)] = GetFltAttrDefaultE(attr);
434  }
435  return EId;
436 }
437 
438 void TNEANetMP::AddEdgeUnchecked(const TInt& EId, const int SrcNId, const int DstNId) {
439  int Idx = abs((EId.GetPrimHashCd()) % ReservedE());
440  int KeyId = EdgeH.AddKey13(Idx, EId);
441  MxEId = TMath::Mx(EId+1, MxEId());
442  EdgeH[KeyId] = TEdge(EId, SrcNId, DstNId);
443 }
444 
445 //void TNEANetMP::DelEdge(const int& EId) {
446 // int i;
447 //
448 // IAssert(IsEdge(EId));
449 // const int SrcNId = GetEdge(EId).GetSrcNId();
450 // const int DstNId = GetEdge(EId).GetDstNId();
451 // GetNode(SrcNId).OutEIdV.DelIfIn(EId);
452 // GetNode(DstNId).InEIdV.DelIfIn(EId);
453 // EdgeH.DelKey(EId);
454 //
455 // for (i = 0; i < VecOfIntVecsE.Len(); i++) {
456 // TVec<TInt>& IntVec = VecOfIntVecsE[i];
457 // IntVec.Ins(EdgeH.GetKeyId(EId), TInt::Mn);
458 // }
459 // for (i = 0; i < VecOfStrVecsE.Len(); i++) {
460 // TVec<TStr>& StrVec = VecOfStrVecsE[i];
461 // StrVec.Ins(EdgeH.GetKeyId(EId), TStr::GetNullStr());
462 // }
463 // for (i = 0; i < VecOfFltVecsE.Len(); i++) {
464 // TVec<TFlt>& FltVec = VecOfFltVecsE[i];
465 // FltVec.Ins(EdgeH.GetKeyId(EId), TFlt::Mn);
466 // }
467 //}
468 
470 //void TNEANetMP::DelEdge(const int& SrcNId, const int& DstNId, const bool& IsDir) {
471 // int EId = 0;
472 // bool Edge = IsEdge(SrcNId, DstNId, EId, IsDir);
473 // IAssert(Edge); // there is at least one edge
474 // while (Edge) {
475 // DelEdge(EId);
476 // Edge = IsEdge(SrcNId, DstNId, EId, IsDir);
477 // }
478 //}
479 
480 bool TNEANetMP::IsEdge(const int& SrcNId, const int& DstNId, int& EId, const bool& IsDir) const {
481  const TNode& SrcNode = GetNode(SrcNId);
482  for (int edge = 0; edge < SrcNode.GetOutDeg(); edge++) {
483  const TEdge& Edge = GetEdge(SrcNode.GetOutEId(edge));
484  if (DstNId == Edge.GetDstNId()) {
485  EId = Edge.GetId();
486  return true;
487  }
488  }
489  if (! IsDir) {
490  for (int edge = 0; edge < SrcNode.GetInDeg(); edge++) {
491  const TEdge& Edge = GetEdge(SrcNode.GetInEId(edge));
492  if (DstNId == Edge.GetSrcNId()) {
493  EId = Edge.GetId();
494  return true;
495  }
496  }
497  }
498  return false;
499 }
500 
501 void TNEANetMP::GetNIdV(TIntV& NIdV) const {
502  NIdV.Gen(GetNodes(), 0);
503  for (int N=NodeH.FFirstKeyId(); NodeH.FNextKeyId(N); ) {
504  NIdV.Add(NodeH.GetKey(N));
505  }
506 }
507 
508 void TNEANetMP::GetEIdV(TIntV& EIdV) const {
509  EIdV.Gen(GetEdges(), 0);
510  for (int E=EdgeH.FFirstKeyId(); EdgeH.FNextKeyId(E); ) {
511  EIdV.Add(EdgeH.GetKey(E));
512  }
513 }
514 
515 void TNEANetMP::Defrag(const bool& OnlyNodeLinks) {
516  #if 0
517  for (int kid = NodeH.FFirstKeyId(); NodeH.FNextKeyId(kid); ) {
518  TNode& Node = NodeH[kid];
519  Node.InEIdV.Pack(); Node.OutEIdV.Pack();
520  }
521  if (! OnlyNodeLinks && ! NodeH.IsKeyIdEqKeyN()) { NodeH.Defrag(); }
522  if (! OnlyNodeLinks && ! EdgeH.IsKeyIdEqKeyN()) { EdgeH.Defrag(); }
523  #endif
524 }
525 
526 bool TNEANetMP::IsOk(const bool& ThrowExcept) const {
527  bool RetVal = true;
528  for (int N = NodeH.FFirstKeyId(); NodeH.FNextKeyId(N); ) {
529  const TNode& Node = NodeH[N];
530  if (! Node.OutEIdV.IsSorted()) {
531  const TStr Msg = TStr::Fmt("Out-edge list of node %d is not sorted.", Node.GetId());
532  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
533  }
534  if (! Node.InEIdV.IsSorted()) {
535  const TStr Msg = TStr::Fmt("In-edge list of node %d is not sorted.", Node.GetId());
536  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
537  }
538  // check out-edge ids
539  int prevEId = -1;
540  for (int e = 0; e < Node.GetOutDeg(); e++) {
541  if (! IsEdge(Node.GetOutEId(e))) {
542  const TStr Msg = TStr::Fmt("Out-edge id %d of node %d does not exist.", Node.GetOutEId(e), Node.GetId());
543  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
544  }
545  if (e > 0 && prevEId == Node.GetOutEId(e)) {
546  const TStr Msg = TStr::Fmt("Node %d has duplidate out-edge id %d.", Node.GetId(), Node.GetOutEId(e));
547  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
548  }
549  prevEId = Node.GetOutEId(e);
550  }
551  // check in-edge ids
552  prevEId = -1;
553  for (int e = 0; e < Node.GetInDeg(); e++) {
554  if (! IsEdge(Node.GetInEId(e))) {
555  const TStr Msg = TStr::Fmt("Out-edge id %d of node %d does not exist.", Node.GetInEId(e), Node.GetId());
556  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
557  }
558  if (e > 0 && prevEId == Node.GetInEId(e)) {
559  const TStr Msg = TStr::Fmt("Node %d has duplidate out-edge id %d.", Node.GetId(), Node.GetInEId(e));
560  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
561  }
562  prevEId = Node.GetInEId(e);
563  }
564  }
565  for (int E = EdgeH.FFirstKeyId(); EdgeH.FNextKeyId(E); ) {
566  const TEdge& Edge = EdgeH[E];
567  if (! IsNode(Edge.GetSrcNId())) {
568  const TStr Msg = TStr::Fmt("Edge %d source node %d does not exist.", Edge.GetId(), Edge.GetSrcNId());
569  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
570  }
571  if (! IsNode(Edge.GetDstNId())) {
572  const TStr Msg = TStr::Fmt("Edge %d destination node %d does not exist.", Edge.GetId(), Edge.GetDstNId());
573  if (ThrowExcept) { EAssertR(false, Msg); } else { ErrNotify(Msg.CStr()); } RetVal=false;
574  }
575  }
576  return RetVal;
577 }
578 
579 void TNEANetMP::Dump(FILE *OutF) const {
580  const int NodePlaces = (int) ceil(log10((double) GetNodes()));
581  const int EdgePlaces = (int) ceil(log10((double) GetEdges()));
582  fprintf(OutF, "-------------------------------------------------\nDirected Node-Edge Network: nodes: %d, edges: %d\n", GetNodes(), GetEdges());
583  for (TNodeI NodeI = BegNI(); NodeI < EndNI(); NodeI++) {
584  fprintf(OutF, " %*d]\n", NodePlaces, NodeI.GetId());
585  // load node attributes
586  TIntV IntAttrN;
587  IntAttrValueNI(NodeI.GetId(), IntAttrN);
588  fprintf(OutF, " nai[%d]", IntAttrN.Len());
589  for (int i = 0; i < IntAttrN.Len(); i++) {
590  fprintf(OutF, " %*i", NodePlaces, IntAttrN[i]()); }
591  TStrV StrAttrN;
592  StrAttrValueNI(NodeI.GetId(), StrAttrN);
593  fprintf(OutF, " nas[%d]", StrAttrN.Len());
594  for (int i = 0; i < StrAttrN.Len(); i++) {
595  fprintf(OutF, " %*s", NodePlaces, StrAttrN[i]()); }
596  TFltV FltAttrN;
597  FltAttrValueNI(NodeI.GetId(), FltAttrN);
598  fprintf(OutF, " naf[%d]", FltAttrN.Len());
599  for (int i = 0; i < FltAttrN.Len(); i++) {
600  fprintf(OutF, " %*f", NodePlaces, FltAttrN[i]()); }
601 
602  fprintf(OutF, " in[%d]", NodeI.GetInDeg());
603  for (int edge = 0; edge < NodeI.GetInDeg(); edge++) {
604  fprintf(OutF, " %*d", EdgePlaces, NodeI.GetInEId(edge)); }
605  fprintf(OutF, "\n");
606  fprintf(OutF, " out[%d]", NodeI.GetOutDeg());
607  for (int edge = 0; edge < NodeI.GetOutDeg(); edge++) {
608  fprintf(OutF, " %*d", EdgePlaces, NodeI.GetOutEId(edge)); }
609  fprintf(OutF, "\n");
610  }
611  for (TEdgeI EdgeI = BegEI(); EdgeI < EndEI(); EdgeI++) {
612  fprintf(OutF, " %*d] %*d -> %*d", EdgePlaces, EdgeI.GetId(), NodePlaces, EdgeI.GetSrcNId(), NodePlaces, EdgeI.GetDstNId());
613 
614  // load edge attributes
615  TIntV IntAttrE;
616  IntAttrValueEI(EdgeI.GetId(), IntAttrE);
617  fprintf(OutF, " eai[%d]", IntAttrE.Len());
618  for (int i = 0; i < IntAttrE.Len(); i++) {
619  fprintf(OutF, " %*i", EdgePlaces, IntAttrE[i]());
620  }
621  TStrV StrAttrE;
622  StrAttrValueEI(EdgeI.GetId(), StrAttrE);
623  fprintf(OutF, " eas[%d]", StrAttrE.Len());
624  for (int i = 0; i < StrAttrE.Len(); i++) {
625  fprintf(OutF, " %*s", EdgePlaces, StrAttrE[i]());
626  }
627  TFltV FltAttrE;
628  FltAttrValueEI(EdgeI.GetId(), FltAttrE);
629  fprintf(OutF, " eaf[%d]", FltAttrE.Len());
630  for (int i = 0; i < FltAttrE.Len(); i++) {
631  fprintf(OutF, " %*f", EdgePlaces, FltAttrE[i]());
632  }
633  fprintf(OutF, "\n");
634  }
635  fprintf(OutF, "\n");
636 }
637 
638 // Attribute related function
639 
640 int TNEANetMP::AddIntAttrDatN(const int& NId, const TInt& value, const TStr& attr) {
641  int i;
642  TInt CurrLen;
643  if (!IsNode(NId)) {
644  // AddNode(NId);
645  return -1;
646  }
647  if (KeyToIndexTypeN.IsKey(attr)) {
649  NewVec[NodeH.GetKeyId(NId)] = value;
650  } else {
651  CurrLen = VecOfIntVecsN.Len();
652  KeyToIndexTypeN.AddDat(attr, TIntPr(IntType, CurrLen));
653  TVec<TInt> NewVec = TVec<TInt>();
654  for (i = 0; i < MxNId; i++) {
655  NewVec.Ins(i, (TInt) TInt::Mn);
656  }
657  NewVec[NodeH.GetKeyId(NId)] = value;
658  VecOfIntVecsN.Add(NewVec);
659  }
660  return 0;
661 }
662 
663 int TNEANetMP::AddStrAttrDatN(const int& NId, const TStr& value, const TStr& attr) {
664  int i;
665  TInt CurrLen;
666  if (!IsNode(NId)) {
667  // AddNode(NId);
668  return -1;
669  }
670  if (KeyToIndexTypeN.IsKey(attr)) {
672  NewVec[NodeH.GetKeyId(NId)] = value;
673  } else {
674  CurrLen = VecOfStrVecsN.Len();
675  KeyToIndexTypeN.AddDat(attr, TIntPr(StrType, CurrLen));
676  TVec<TStr> NewVec = TVec<TStr>();
677  for (i = 0; i < MxNId; i++) {
678  NewVec.Ins(i, (TStr) TStr::GetNullStr() );
679  }
680  NewVec[NodeH.GetKeyId(NId)] = value;
681  VecOfStrVecsN.Add(NewVec);
682  }
683  return 0;
684 }
685 
686 int TNEANetMP::AddFltAttrDatN(const int& NId, const TFlt& value, const TStr& attr) {
687  int i;
688  TInt CurrLen;
689 
690  if (!IsNode(NId)) {
691  // AddNode(NId);
692  return -1;
693  }
694  if (KeyToIndexTypeN.IsKey(attr)) {
696  NewVec[NodeH.GetKeyId(NId)] = value;
697  } else {
698  CurrLen = VecOfFltVecsN.Len();
699  KeyToIndexTypeN.AddDat(attr, TIntPr(FltType, CurrLen));
700  TVec<TFlt> NewVec = TVec<TFlt>();
701  for (i = 0; i < MxNId; i++) {
702  NewVec.Ins(i, GetFltAttrDefaultN(attr));
703  }
704  NewVec[NodeH.GetKeyId(NId)] = value;
705  VecOfFltVecsN.Add(NewVec);
706  }
707  return 0;
708 }
709 
710 
711 int TNEANetMP::AddIntAttrDatE(const int& EId, const TInt& value, const TStr& attr) {
712  int i;
713  TInt CurrLen;
714  if (!IsEdge(EId)) {
715  //AddEdge(EId);
716  return -1;
717  }
718  if (KeyToIndexTypeE.IsKey(attr)) {
720  NewVec[EdgeH.GetKeyId(EId)] = value;
721  } else {
722  CurrLen = VecOfIntVecsE.Len();
723  KeyToIndexTypeE.AddDat(attr, TIntPr(IntType, CurrLen));
724  TVec<TInt> NewVec = TVec<TInt>();
725  for (i = 0; i < MxEId; i++) {
726  NewVec.Ins(i, (TInt) TInt::Mn);
727  }
728  NewVec[EdgeH.GetKeyId(EId)] = value;
729  VecOfIntVecsE.Add(NewVec);
730  }
731  return 0;
732 }
733 
734 
735 int TNEANetMP::AddStrAttrDatE(const int& EId, const TStr& value, const TStr& attr) {
736  int i;
737  TInt CurrLen;
738  if (!IsEdge(EId)) {
739  //AddEdge(EId);
740  return -1;
741  }
742  if (KeyToIndexTypeE.IsKey(attr)) {
744  NewVec[EdgeH.GetKeyId(EId)] = value;
745  } else {
746  CurrLen = VecOfStrVecsE.Len();
747  KeyToIndexTypeE.AddDat(attr, TIntPr(StrType, CurrLen));
748  TVec<TStr> NewVec = TVec<TStr>();
749  for (i = 0; i < MxEId; i++) {
750  NewVec.Ins(i, (TStr) TStr::GetNullStr());
751  }
752  NewVec[EdgeH.GetKeyId(EId)] = value;
753  VecOfStrVecsE.Add(NewVec);
754  }
755  return 0;
756 }
757 
758 int TNEANetMP::AddFltAttrDatE(const int& EId, const TFlt& value, const TStr& attr) {
759  int i;
760  TInt CurrLen;
761 
762  if (!IsEdge(EId)) {
763  //AddEdge(EId);
764  return -1;
765  }
766  if (KeyToIndexTypeE.IsKey(attr)) {
768  NewVec[EdgeH.GetKeyId(EId)] = value;
769  } else {
770  CurrLen = VecOfFltVecsE.Len();
771  KeyToIndexTypeE.AddDat(attr, TIntPr(FltType, CurrLen));
772  TVec<TFlt> NewVec = TVec<TFlt>();
773  for (i = 0; i < MxEId; i++) {
774  NewVec.Ins(i, GetFltAttrDefaultE(attr));
775  }
776  NewVec[EdgeH.GetKeyId(EId)] = value;
777  VecOfFltVecsE.Add(NewVec);
778  }
779  return 0;
780 }
781 
784 }
785 
786 int TNEANetMP::GetFltKeyIdE(const int& EId) {
787  return EdgeH.GetKeyId(EId);
788 }
789 
790 TInt TNEANetMP::GetIntAttrDatN(const int& NId, const TStr& attr) {
792 }
793 
794 TInt TNEANetMP::GetIntAttrIndDatN(const int& NId, const int& index) {
795  return VecOfIntVecsN[index][NodeH.GetKeyId(NId)];
796 }
797 
798 int TNEANetMP::GetIntAttrIndN(const TStr& attr) {
799  return KeyToIndexTypeN.GetDat(attr).Val2.Val;
800 }
801 
802 TStr TNEANetMP::GetStrAttrDatN(const int& NId, const TStr& attr) {
804 }
805 
806 TFlt TNEANetMP::GetFltAttrDatN(const int& NId, const TStr& attr) {
808 }
809 
810 TInt TNEANetMP::GetIntAttrDatE(const int& EId, const TStr& attr) {
812 }
813 
814 TInt TNEANetMP::GetIntAttrIndDatE(const int& EId, const int& index) {
815  return VecOfIntVecsE[index][EdgeH.GetKeyId(EId)];
816 }
817 
818 int TNEANetMP::GetIntAttrIndE(const TStr& attr) {
819  return KeyToIndexTypeE.GetDat(attr).Val2.Val;
820 }
821 
822 TStr TNEANetMP::GetStrAttrDatE(const int& EId, const TStr& attr) {
824 }
825 
826 TFlt TNEANetMP::GetFltAttrDatE(const int& EId, const TStr& attr) {
828 }
829 
830 int TNEANetMP::DelAttrDatN(const int& NId, const TStr& attr) {
831  TInt vecType = KeyToIndexTypeN(attr).Val1;
832  if (vecType == IntType) {
834  } else if (vecType == StrType) {
836  } else if (vecType == FltType) {
838  } else {
839  return -1;
840  }
841  return 0;
842 }
843 
844 int TNEANetMP::DelAttrDatE(const int& EId, const TStr& attr) {
845  // TODO(nkhadke): add error checking
846  TInt vecType = KeyToIndexTypeE(attr).Val1;
847  if (vecType == IntType) {
849  } else if (vecType == StrType) {
851  } else if (vecType == FltType) {
853  } else {
854  return -1;
855  }
856  return 0;
857 }
858 
859 int TNEANetMP::AddIntAttrN(const TStr& attr, TInt defaultValue){
860  int i;
861  TInt CurrLen;
862  TVec<TInt> NewVec;
863  CurrLen = VecOfIntVecsN.Len();
864  KeyToIndexTypeN.AddDat(attr, TIntPr(IntType, CurrLen));
865  NewVec = TVec<TInt>();
866  for (i = 0; i < MxNId; i++) {
867  NewVec.Ins(i, defaultValue);
868  }
869  VecOfIntVecsN.Add(NewVec);
870  if (!IntDefaultsN.IsKey(attr)) {
871  IntDefaultsN.AddDat(attr, defaultValue);
872  } else {
873  return -1;
874  }
875  return 0;
876 }
877 
878 int TNEANetMP::AddStrAttrN(const TStr& attr, TStr defaultValue) {
879  int i;
880  TInt CurrLen;
881  TVec<TStr> NewVec;
882  CurrLen = VecOfStrVecsN.Len();
883  KeyToIndexTypeN.AddDat(attr, TIntPr(StrType, CurrLen));
884  NewVec = TVec<TStr>();
885  for (i = 0; i < MxNId; i++) {
886  NewVec.Ins(i, defaultValue);
887  }
888  VecOfStrVecsN.Add(NewVec);
889  if (!StrDefaultsN.IsKey(attr)) {
890  StrDefaultsN.AddDat(attr, defaultValue);
891  } else {
892  return -1;
893  }
894  return 0;
895 }
896 
897 int TNEANetMP::AddFltAttrN(const TStr& attr, TFlt defaultValue) {
898  // TODO(nkhadke): add error checking
899  int i;
900  TInt CurrLen;
901  TVec<TFlt> NewVec;
902  CurrLen = VecOfStrVecsN.Len();
903  KeyToIndexTypeN.AddDat(attr, TIntPr(FltType, CurrLen));
904  NewVec = TVec<TFlt>();
905  for (i = 0; i < MxNId; i++) {
906  NewVec.Ins(i, defaultValue);
907  }
908  VecOfFltVecsN.Add(NewVec);
909  if (!FltDefaultsN.IsKey(attr)) {
910  FltDefaultsN.AddDat(attr, defaultValue);
911  } else {
912  return -1;
913  }
914  return 0;
915 }
916 
917 int TNEANetMP::AddIntAttrE(const TStr& attr, TInt defaultValue){
918  // TODO(nkhadke): add error checking
919  int i;
920  TInt CurrLen;
921  TVec<TInt> NewVec;
922  CurrLen = VecOfIntVecsE.Len();
923  KeyToIndexTypeE.AddDat(attr, TIntPr(IntType, CurrLen));
924  NewVec = TVec<TInt>();
925  for (i = 0; i < MxEId; i++) {
926  NewVec.Ins(i, defaultValue);
927  }
928  VecOfIntVecsE.Add(NewVec);
929  if (!IntDefaultsE.IsKey(attr)) {
930  IntDefaultsE.AddDat(attr, defaultValue);
931  } else {
932  return -1;
933  }
934  return 0;
935 }
936 
937 int TNEANetMP::AddStrAttrE(const TStr& attr, TStr defaultValue) {
938  int i;
939  TInt CurrLen;
940  TVec<TStr> NewVec;
941  CurrLen = VecOfStrVecsE.Len();
942  KeyToIndexTypeE.AddDat(attr, TIntPr(StrType, CurrLen));
943  NewVec = TVec<TStr>();
944  for (i = 0; i < MxEId; i++) {
945  NewVec.Ins(i, defaultValue);
946  }
947  VecOfStrVecsE.Add(NewVec);
948  if (!StrDefaultsE.IsKey(attr)) {
949  StrDefaultsE.AddDat(attr, defaultValue);
950  } else {
951  return -1;
952  }
953  return 0;
954 }
955 
956 int TNEANetMP::AddFltAttrE(const TStr& attr, TFlt defaultValue) {
957  int i;
958  TInt CurrLen;
959  TVec<TFlt> NewVec;
960  CurrLen = VecOfStrVecsE.Len();
961  KeyToIndexTypeE.AddDat(attr, TIntPr(FltType, CurrLen));
962  NewVec = TVec<TFlt>();
963  for (i = 0; i < MxEId; i++) {
964  NewVec.Ins(i, defaultValue);
965  }
966  VecOfFltVecsE.Add(NewVec);
967  if (!FltDefaultsE.IsKey(attr)) {
968  FltDefaultsE.AddDat(attr, defaultValue);
969  } else {
970  return -1;
971  }
972  return 0;
973 }
974 
975 //int TNEANetMP::DelAttrN(const TStr& attr) {
976 // TInt vecType = KeyToIndexTypeN(attr).Val1;
977 // if (vecType == IntType) {
978 // VecOfIntVecsN[KeyToIndexTypeN.GetDat(attr).Val2] = TVec<TInt>();
979 // if (IntDefaultsN.IsKey(attr)) {
980 // IntDefaultsN.DelKey(attr);
981 // }
982 // } else if (vecType == StrType) {
983 // VecOfStrVecsN[KeyToIndexTypeN.GetDat(attr).Val2] = TVec<TStr>();
984 // if (StrDefaultsN.IsKey(attr)) {
985 // StrDefaultsN.DelKey(attr);
986 // }
987 // } else if (vecType == FltType) {
988 // VecOfFltVecsN[KeyToIndexTypeN.GetDat(attr).Val2] = TVec<TFlt>();
989 // if (FltDefaultsN.IsKey(attr)) {
990 // FltDefaultsN.DelKey(attr);
991 // }
992 // } else {
993 // return -1;
994 // }
995 // KeyToIndexTypeN.DelKey(attr);
996 // return 0;
997 //}
998 
999 //int TNEANetMP::DelAttrE(const TStr& attr) {
1000 // TInt vecType = KeyToIndexTypeE(attr).Val1;
1001 // if (vecType == IntType) {
1002 // VecOfIntVecsE[KeyToIndexTypeE.GetDat(attr).Val2] = TVec<TInt>();
1003 // if (IntDefaultsE.IsKey(attr)) {
1004 // IntDefaultsE.DelKey(attr);
1005 // }
1006 // } else if (vecType == StrType) {
1007 // VecOfStrVecsE[KeyToIndexTypeE.GetDat(attr).Val2] = TVec<TStr>();
1008 // if (StrDefaultsE.IsKey(attr)) {
1009 // StrDefaultsE.DelKey(attr);
1010 // }
1011 // } else if (vecType == FltType) {
1012 // VecOfFltVecsE[KeyToIndexTypeE.GetDat(attr).Val2] = TVec<TFlt>();
1013 // if (FltDefaultsE.IsKey(attr)) {
1014 // FltDefaultsE.DelKey(attr);
1015 // }
1016 // } else {
1017 // return -1;
1018 // }
1019 // KeyToIndexTypeE.DelKey(attr);
1020 // return 0;
1021 //}
1022 
1024  TNode Node = GetNode(NI.GetId());
1025  TIntV OutEIdV = Node.OutEIdV;
1026  TFlt total = 0;
1027  int len = Node.OutEIdV.Len();
1028  for (int i = 0; i < len; i++) {
1029  total += GetFltAttrDatE(Node.OutEIdV[i], attr);
1030  }
1031  return total;
1032 }
1033 
1034 void TNEANetMP::GetWeightOutEdgesV(TFltV& OutWeights, const TFltV& AttrVal) {
1035  for (TEdgeI it = BegEI(); it < EndEI(); it++) {
1036  int EId = it.GetId();
1037  int SrcId = it.GetSrcNId();
1038  OutWeights[SrcId] +=AttrVal[GetFltKeyIdE(EId)];
1039  }
1040 }
1041 
1042 bool TNEANetMP::IsFltAttrE(const TStr& attr) {
1043  return (KeyToIndexTypeE.IsKey(attr) &&
1044  KeyToIndexTypeE.GetDat(attr).Val1 == FltType);
1045 }
1046 
1047 bool TNEANetMP::IsIntAttrE(const TStr& attr) {
1048  return (KeyToIndexTypeE.IsKey(attr) &&
1049  KeyToIndexTypeE.GetDat(attr).Val1 == IntType);
1050 }
1051 
1052 bool TNEANetMP::IsStrAttrE(const TStr& attr) {
1053  return (KeyToIndexTypeE.IsKey(attr) &&
1054  KeyToIndexTypeE.GetDat(attr).Val1 == StrType);
1055 }
1056 
1057 #endif // GCC_ATOMIC
int GetPrimHashCd() const
Definition: dt.h:1171
TPair< TInt, TInt > TIntPr
Definition: ds.h:83
TFlt GetFltAttrDatE(const TEdgeI &EdgeId, const TStr &attr)
Gets the value of flt attr from the edge attr value vector.
Definition: networkmp.h:643
bool IsInNId(const int &NId) const
Tests whether node with ID NId points to the current node.
Definition: networkmp.cpp:9
#define IAssertR(Cond, Reason)
Definition: bd.h:265
int GetId() const
Returns ID of the current node.
Definition: networkmp.h:83
void FltAttrNameNI(const TInt &NId, TStrV &Names) const
Returns a vector of int attr names for node NId.
Definition: networkmp.h:410
int GetNodes() const
Returns the number of nodes in the graph.
Definition: networkmp.h:330
Directed multigraph with node edge attributes.
Definition: networkmp.h:27
void StrAttrValueEI(const TInt &EId, TStrV &Values) const
Returns a vector of attr values for node NId.
Definition: networkmp.h:439
TStrIntPrH KeyToIndexTypeE
Definition: networkmp.h:272
bool IsOutNId(const int &NId) const
Tests whether the current node points to node with ID NId.
Definition: networkmp.cpp:18
static const T & Mx(const T &LVal, const T &RVal)
Definition: xmath.h:32
TInt GetIntAttrDefaultE(const TStr &attribute) const
Get Int edge attribute val. If not a proper attr, return default.
Definition: networkmp.h:260
int GetEdges() const
Returns the number of edges in the graph.
Definition: networkmp.h:497
TVec< TIntV > VecOfIntVecsN
Definition: networkmp.h:277
const TNEANetMP * Graph
Definition: networkmp.h:72
TStr GetStrAttrDefaultN(const TStr &attribute) const
Get Str node attribute val. If not a proper attr, return default.
Definition: networkmp.h:256
bool EdgeAttrIsStrDeleted(const int &EId, const TStrIntPrH::TIter &EdgeHI) const
Definition: networkmp.cpp:245
bool IsOk(const bool &ThrowExcept=true) const
Checks the graph data structure for internal consistency.
Definition: networkmp.cpp:526
TStrIntPrH KeyToIndexTypeN
KeyToIndexType[N|E]: Key->(Type,Index).
Definition: networkmp.h:272
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
int AddIntAttrDatE(const TEdgeI &EdgeId, const TInt &value, const TStr &attr)
Attribute based add function for attr to Int value.
Definition: networkmp.h:606
TVec< TFltV > VecOfFltVecsN
Definition: networkmp.h:279
TEdgeI BegEI() const
Returns an iterator referring to the first edge in the graph.
Definition: networkmp.h:530
void FltAttrNameEI(const TInt &EId, TStrV &Names) const
Returns a vector of int attr names for node NId.
Definition: networkmp.h:443
THashMP< TStr, TStr > StrDefaultsN
Definition: networkmp.h:275
int DelAttrDatN(const TNodeI &NodeId, const TStr &attr)
Deletes the node attribute for NodeId.
Definition: networkmp.h:653
void IntAttrNameNI(const TInt &NId, TStrV &Names) const
Returns a vector of int attr names for node NId.
Definition: networkmp.h:394
int AddIntAttrE(const TStr &attr, TInt defaultValue=TInt::Mn)
Adds a new Int edge attribute to the hashmap.
Definition: networkmp.cpp:917
void GetKeyV(TVec< TKey > &KeyV) const
Definition: hashmp.h:490
TStr GetStrAttrDatE(const TEdgeI &EdgeId, const TStr &attr)
Gets the value of str attr from the edge attr value vector.
Definition: networkmp.h:640
int AddFltAttrDatN(const TNodeI &NodeId, const TFlt &value, const TStr &attr)
Attribute based add function for attr to Flt value.
Definition: networkmp.h:600
TInt MxNId
Definition: networkmp.h:268
void Dump(FILE *OutF=stdout) const
Print the graph in a human readable form to an output stream OutF.
Definition: networkmp.cpp:579
int Reserved() const
Returns the number of nodes reserved in the network.
Definition: networkmp.h:492
const TDat & GetDat(const TKey &Key) const
Definition: hash.h:262
TInt GetIntAttrIndDatN(const TNodeI &NodeId, const int &index)
Gets the value of node int attr specified by the attr index.
Definition: networkmp.h:633
TEdge & GetEdge(const int &EId)
Definition: networkmp.h:250
void StrAttrValueNI(const TInt &NId, TStrV &Values) const
Returns a vector of attr values for node NId.
Definition: networkmp.h:406
const TKey & GetKey() const
Definition: hash.h:80
TSizeTy AddSorted(const TVal &Val, const bool &Asc=true, const TSizeTy &_MxVals=-1)
Adds element Val to a sorted vector.
Definition: ds.h:1117
void ErrNotify(const char *NotifyCStr)
Definition: bd.h:74
TStr GetNodeAttrValue(const int &NId, const TStrIntPrH::TIter &NodeHI) const
Definition: networkmp.cpp:135
Definition: dt.h:1386
bool IsIntAttrE(const TStr &attr)
Definition: networkmp.cpp:1047
THashMP< TStr, TInt > IntDefaultsN
Definition: networkmp.h:274
void AttrNameEI(const TInt &EId, TStrV &Names) const
Returns a vector of attr names for edge EId.
Definition: networkmp.h:419
int GetId() const
Definition: networkmp.h:62
THashMP< TInt, TEdge > EdgeH
Definition: networkmp.h:270
TInt GetIntAttrDefaultN(const TStr &attribute) const
Get Int node attribute val. If not a proper attr, return default.
Definition: networkmp.h:254
TStr GetEdgeAttrValue(const int &EId, const TStrIntPrH::TIter &EdgeHI) const
Definition: networkmp.cpp:257
bool IsStrAttrE(const TStr &attr)
Definition: networkmp.cpp:1052
THashMP< TStr, TStr > StrDefaultsE
Definition: networkmp.h:275
TNodeI EndNI() const
Returns an iterator referring to the past-the-end node in the graph.
Definition: networkmp.h:354
static const int Mn
Definition: dt.h:1141
const TVal & GetVal(const TSizeTy &ValN) const
Returns a reference to the element at position ValN in the vector.
Definition: ds.h:649
TVec< TStrV > VecOfStrVecsE
Definition: networkmp.h:278
int GetIntAttrIndE(const TStr &attr)
Gets the index of the edge attr value vector specified by str attr.
Definition: networkmp.cpp:818
void StrAttrNameEI(const TInt &EId, TStrV &Names) const
Returns a vector of str attr names for node NId.
Definition: networkmp.h:435
const TDat & GetDat() const
Definition: hash.h:81
#define HasGraphFlag(TGraph, Flag)
For quick testing of the properties of the graph/network object (see TGraphFlag). ...
Definition: gbase.h:41
bool IsEnd() const
Tests whether the iterator is pointing to the past-end element.
Definition: hash.h:78
void GetNIdV(TIntV &NIdV) const
Gets a vector IDs of all nodes in the graph.
Definition: networkmp.cpp:501
void IntAttrNameEI(const TInt &EId, TStrV &Names) const
Returns a vector of int attr names for edge EId.
Definition: networkmp.h:427
TInt MxEId
Definition: networkmp.h:268
TNode & GetNode(const int &NId)
Definition: networkmp.h:248
TVec< TFlt > & GetFltAttrVecE(const TStr &attr)
Definition: networkmp.cpp:782
bool IsFltAttrE(const TStr &attr)
Definition: networkmp.cpp:1042
bool NodeAttrIsFltDeleted(const int &NId, const TStrIntPrH::TIter &NodeHI) const
Definition: networkmp.cpp:129
TVec< TIntV > VecOfIntVecsE
Definition: networkmp.h:277
bool NodeAttrIsStrDeleted(const int &NId, const TStrIntPrH::TIter &NodeHI) const
Definition: networkmp.cpp:123
int AddStrAttrN(const TStr &attr, TStr defaultValue=TStr::GetNullStr())
Adds a new Str node attribute to the hashmap.
Definition: networkmp.cpp:878
int GetIntAttrIndN(const TStr &attr)
Gets the index of the node attr value vector specified by str attr.
Definition: networkmp.cpp:798
TFlt GetWeightOutEdges(const TNodeI &NI, const TStr &attr)
Definition: networkmp.cpp:1023
TFlt GetFltAttrDefaultE(const TStr &attribute) const
Get Flt edge attribute val. If not a proper attr, return default.
Definition: networkmp.h:264
bool IsNode(const int &NId) const
If the node of ID NId does not exist the function aborts.
Definition: networkmp.h:350
TStr GetStrAttrDefaultE(const TStr &attribute) const
Get Str edge attribute val. If not a proper attr, return default.
Definition: networkmp.h:262
void GetEIdV(TIntV &EIdV) const
Gets a vector IDs of all edges in the graph.
Definition: networkmp.cpp:508
void FltAttrValueNI(const TInt &NId, TFltV &Values) const
Returns a vector of attr values for node NId.
Definition: networkmp.h:414
int AddStrAttrDatE(const TEdgeI &EdgeId, const TStr &value, const TStr &attr)
Attribute based add function for attr to Str value.
Definition: networkmp.h:611
bool IsKey(const TKey &Key) const
Definition: hashmp.h:191
TInt GetIntAttrIndDatE(const TEdgeI &EdgeId, const int &index)
Gets the value of edge int attr specified by the attr index.
Definition: networkmp.h:649
int GetInDeg() const
Definition: networkmp.h:44
static TStr GetNullStr()
Definition: dt.cpp:1626
bool FNextKeyId(int &KeyId) const
Definition: hashmp.h:484
bool NodeAttrIsIntDeleted(const int &NId, const TStrIntPrH::TIter &NodeHI) const
Definition: networkmp.cpp:117
TFlt GetFltAttrDefaultN(const TStr &attribute) const
Get Flt node attribute val. If not a proper attr, return default.
Definition: networkmp.h:258
THashMP< TStr, TInt > IntDefaultsE
Definition: networkmp.h:274
TStr GetStr() const
Definition: dt.h:681
Node iterator. Only forward iteration (operator++) is supported.
Definition: networkmp.h:68
int GetInEId(const int &EdgeN) const
Definition: networkmp.h:46
int AddEdge(const int &SrcNId, const int &DstNId, int EId=-1)
Adds an edge with ID EId between node IDs SrcNId and DstNId to the graph.
Definition: networkmp.cpp:388
Definition: dt.h:1137
int AddStrAttrDatN(const TNodeI &NodeId, const TStr &value, const TStr &attr)
Attribute based add function for attr to Str value.
Definition: networkmp.h:595
void Ins(const TSizeTy &ValN, const TVal &Val)
Inserts new element Val before the element at position ValN.
Definition: ds.h:1180
void AddNodeWithEdges(const TInt &NId, TIntV &InEIdV, TIntV &OutEIdV)
Adds a node along with its neighbor edges.
Definition: networkmp.cpp:319
int GetSrcNId() const
Definition: networkmp.h:63
Edge iterator. Only forward iteration (operator++) is supported.
Definition: networkmp.h:139
TStr GetStrAttrDatN(const TNodeI &NodeId, const TStr &attr)
Gets the value of str attr from the node attr value vector.
Definition: networkmp.h:624
void AttrNameNI(const TInt &NId, TStrV &Names) const
Returns a vector of attr names for node NId.
Definition: networkmp.h:386
int DelAttrDatE(const TEdgeI &EdgeId, const TStr &attr)
Deletes the edge attribute for NodeId.
Definition: networkmp.h:656
TInt GetIntAttrDatN(const TNodeI &NodeId, const TStr &attr)
Gets the value of int attr from the node attr value vector.
Definition: networkmp.h:620
THashMP< TInt, TNode > NodeH
Definition: networkmp.h:269
TFlt GetFltAttrDatN(const TNodeI &NodeId, const TStr &attr)
Gets the value of flt attr from the node attr value vector.
Definition: networkmp.h:627
TVec< TFltV > VecOfFltVecsE
Definition: networkmp.h:279
TNodeI BegNI() const
Returns an iterator referring to the first node in the graph.
Definition: networkmp.h:352
Definition: dt.h:412
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
bool IsSorted(const bool &Asc=true) const
Checks whether the vector is sorted in ascending (if Asc=true) or descending (if Asc=false) order...
Definition: ds.h:1323
void Pack()
Reduces vector capacity (frees memory) to match its size.
Definition: ds.h:1057
enum TGraphFlag_ TGraphFlag
Graph Flags, used for quick testing of graph types.
bool HasFlag(const TGraphFlag &Flag) const
Allows for run-time checking the type of the graph (see the TGraphFlag for flags).
Definition: networkmp.cpp:5
int GetOutDeg() const
Definition: networkmp.h:45
int AddNode(int NId=-1)
Adds a node of ID NId to the graph.
Definition: networkmp.cpp:271
int FFirstKeyId() const
Definition: hashmp.h:207
int ReservedE() const
Returns the number of edges reserved in the network.
Definition: networkmp.h:494
int AddIntAttrN(const TStr &attr, TInt defaultValue=TInt::Mn)
Adds a new Int node attribute to the hashmap.
Definition: networkmp.cpp:859
#define EAssertR(Cond, MsgStr)
Definition: bd.h:283
TEdgeI EndEI() const
Returns an iterator referring to the past-the-end edge in the graph.
Definition: networkmp.h:532
int AddFltAttrE(const TStr &attr, TFlt defaultValue=TFlt::Mn)
Adds a new Flt edge attribute to the hashmap.
Definition: networkmp.cpp:956
void StrAttrNameNI(const TInt &NId, TStrV &Names) const
Returns a vector of str attr names for node NId.
Definition: networkmp.h:402
TVal1 Val1
Definition: ds.h:34
int AddIntAttrDatN(const TNodeI &NodeId, const TInt &value, const TStr &attr)
Attribute based add function for attr to Int value.
Definition: networkmp.h:590
TVal2 Val2
Definition: ds.h:35
void IntAttrValueEI(const TInt &EId, TIntV &Values) const
Returns a vector of attr values for edge EId.
Definition: networkmp.h:431
void FltAttrValueEI(const TInt &EId, TFltV &Values) const
Returns a vector of attr values for node NId.
Definition: networkmp.h:447
TInt GetIntAttrDatE(const TEdgeI &EdgeId, const TStr &attr)
Gets the value of int attr from the edge attr value vector.
Definition: networkmp.h:637
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:523
THashMP< TStr, TFlt > FltDefaultsE
Definition: networkmp.h:276
void AttrValueNI(const TInt &NId, TStrV &Values) const
Returns a vector of attr values for node NId.
Definition: networkmp.h:390
void AttrValueEI(const TInt &EId, TStrV &Values) const
Returns a vector of attr values for edge EId.
Definition: networkmp.h:423
int AddKey13(const int &Idx, const TKey &Key)
Definition: hashmp.h:358
THashIter NodeHI
Definition: networkmp.h:71
int GetOutEId(const int &EdgeN) const
Definition: networkmp.h:47
bool IsEdge(const int &EId) const
Tests whether an edge with edge ID EId exists in the graph.
Definition: networkmp.h:522
bool NodeAttrIsDeleted(const int &NId, const TStrIntPrH::TIter &NodeHI) const
Definition: networkmp.cpp:110
bool EdgeAttrIsDeleted(const int &EId, const TStrIntPrH::TIter &EdgeHI) const
Definition: networkmp.cpp:232
char * CStr()
Definition: dt.h:479
bool IsKey(const TKey &Key) const
Definition: hash.h:258
int AddStrAttrE(const TStr &attr, TStr defaultValue=TStr::GetNullStr())
Adds a new Str edge attribute to the hashmap.
Definition: networkmp.cpp:937
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:602
TDat & AddDat(const TKey &Key)
Definition: hashmp.h:181
THashMP< TStr, TFlt > FltDefaultsN
Definition: networkmp.h:276
void Defrag(const bool &OnlyNodeLinks=false)
Definition: networkmp.cpp:515
int GetKeyId(const TKey &Key) const
Definition: hashmp.h:459
void IntAttrValueNI(const TInt &NId, TIntV &Values) const
Returns a vector of attr values for node NId.
Definition: networkmp.h:398
bool EdgeAttrIsIntDeleted(const int &EId, const TStrIntPrH::TIter &EdgeHI) const
Definition: networkmp.cpp:239
int AddFltAttrDatE(const TEdgeI &EdgeId, const TFlt &value, const TStr &attr)
Attribute based add function for attr to Flt value.
Definition: networkmp.h:616
TDat & AddDat(const TKey &Key)
Definition: hash.h:238
int GetFltKeyIdE(const int &EId)
Definition: networkmp.cpp:786
TVec< TStrV > VecOfStrVecsN
Definition: networkmp.h:278
void GetWeightOutEdgesV(TFltV &OutWeights, const TFltV &AttrVal)
Definition: networkmp.cpp:1034
int AddFltAttrN(const TStr &attr, TFlt defaultValue=TFlt::Mn)
Adds a new Flt node attribute to the hashmap.
Definition: networkmp.cpp:897
static const double Mn
Definition: dt.h:1390
Vector is a sequence TVal objects representing an array that can change in size.
Definition: ds.h:430
int GetDstNId() const
Definition: networkmp.h:64
bool EdgeAttrIsFltDeleted(const int &EId, const TStrIntPrH::TIter &EdgeHI) const
Definition: networkmp.cpp:251
int GetId() const
Definition: networkmp.h:42
const TKey & GetKey(const int &KeyId) const
Definition: hashmp.h:185
void AddEdgeUnchecked(const TInt &EId, const int SrcNId, const int DstNId)
Adds an edge without checking its adjacent nodes' neighborhood.
Definition: networkmp.cpp:438