gtl/tests/my_test.cc

0001 /* This software is distributed under the GNU Lesser General Public License */
0002 //==========================================================================
0003 //
0004 //   bellman_ford_test.cpp
0005 //
0006 //==========================================================================
0007 // $Id: bellman_ford_test.cpp,v 1.2 2002/11/07 13:38:37 raitner Exp $
0008
0009 #include <iostream>
0010
0011 #include <GTL/graph.h>
0012 #include <GTL/bellman_ford.h>
0013 #include <GTL/edge_map.h>
0014 #include <GTL/node_map.h>
0015
0016 #ifdef __GTL_MSVCC
0017 #   ifdef _DEBUG
0018 #   define new DEBUG_NEW
0019 #   undef THIS_FILE
0020     static char THIS_FILE[] = __FILE__;
0021 #   endif   // _DEBUG
0022 #endif  // __GTL_MSVCC
0023
0024 class my_graph : public graph {
0025
0026 public:
0027
0028   my_graph() : graph () {}
0029
0030   node new_vertex(int x) {node n=graph::new_node();X[n]=x; return n;}
0031   void new_parton(node s, node t, int p) {edge e=graph::new_edge(s,t) ;P[e]=p;} //; return e;}
0032
0033   void save_node_info_handler (ostream *o, node n) const { *o<<"Value = "<<X[n]<<endl;}
0034   void save_edge_info_handler (ostream *o, edge n) const { *o<<"Value = "<<P[n]<<endl;}
0035
0036   int GetNodeValue(node n) const {return X[n];}
0037   int GetEdgeValue(edge n) const {return P[n];}
0038
0039 private:
0040
0041   node_map<int> X;
0042   edge_map<int> P;
0043
0044 };
0045
0046
0047 class parton {
0048
0049 public:
0050
0051   parton() {};
0052   parton (double mpt, double meta, double mphi, double me, bool mfinal) {pt=mpt;eta=meta;phi=mphi;e=me;final=mfinal;}
0053
0054   bool isFinal() {return final;}
0055
0056   double pt, eta, phi, e;
0057   bool final;
0058 };
0059
0060 class shower : public graph {
0061
0062 public:
0063
0064   shower() : graph() {}
0065
0066   node new_vertex(int x) {node n=graph::new_node();XX[n]=x; return n;}
0067   void new_parton(node s, node t, parton p) {edge e=graph::new_edge(s,t) ;PP[e]=p;} //; return e;}
0068   int GetNodeValue(node n) const {return XX[n];}
0069   void save_edge_info_handler (ostream *o, edge n) const { *o<<"Value = "<<PP[n].pt<<endl;}
0070   double GetEdgeValue(edge n) const {return PP[n].pt;}
0071
0072  private:
0073
0074   node_map<int> XX;
0075   edge_map<parton> PP;
0076
0077 };
0078
0079 int main (int argc, char* argv[])
0080 {
0081     graph G;
0082     G.make_directed();
0083     node n1 = G.new_node();
0084     node n2 = G.new_node();
0085
0086     edge e1 = G.new_edge(n1,n2);
0087
0088
0089     node_map<int> n(G,1);
0090     edge_map<int> e(G,10);
0091
0092     //edge_map<int> e1(n1,n2,10);
0093
0094     //G.save();
0095
0096     my_graph S;
0097
0098     node n11=S.new_vertex(0);
0099     node n22=S.new_vertex(1);
0100     node n33=S.new_vertex(2);
0101     node n44=S.new_vertex(3);
0102     node n55=S.new_vertex(5);
0103
0104     //edge e11=S.new_parton(n11,n22,10);
0105     S.new_parton(n11,n22,10);
0106     S.new_parton(n11,n33,11);
0107     S.new_parton(n33,n44,20);
0108     S.new_parton(n33,n55,21);
0109
0110     //S.save();
0111
0112     graph::node_iterator it, end;
0113
0114     for (it = S.nodes_begin(), end = S.nodes_end(); it != end; ++it)
0115       {
0116     cout<<*it<<" "<<S.GetNodeValue((node) *it)<<endl;
0117       }
0118
0119     graph::edge_iterator it2, end2;
0120
0121     for (it2 = S.edges_begin(), end2 = S.edges_end(); it2 != end2; ++it2)
0122       {
0123     cout<<*it2<<" "<<S.GetEdgeValue((edge) *it2)<<endl;
0124       }
0125
0126     cout<<endl;
0127
0128     shower gS;
0129
0130     node nn11=gS.new_vertex(0);
0131     node nn22=gS.new_vertex(1);
0132     node nn33=gS.new_vertex(1);
0133     node nn44=gS.new_vertex(2);
0134     node nn55=gS.new_vertex(2);
0135
0136     parton p(100,0,0,100,false);
0137
0138     gS.new_parton(nn11,nn22,p);
0139     gS.new_parton(nn11,nn33,parton(200,0,0,200,false));
0140     gS.new_parton(nn33,nn44,parton(50,0,0,50,true));
0141     gS.new_parton(nn33,nn55,parton(150,0,0,150,true));
0142
0143     shower::node_iterator git, gend;
0144
0145     for (git = gS.nodes_begin(), gend = gS.nodes_end(); git != gend; ++git)
0146       {
0147     cout<<*git<<" "<<gS.GetNodeValue(*git)<<endl;
0148       }
0149
0150     shower::edge_iterator git2, gend2;
0151
0152     for (git2 = gS.edges_begin(), gend2 = gS.edges_end(); git2 != gend2; ++git2)
0153       {
0154     cout<<*git2<<" "<<gS.GetEdgeValue(*git2)<<endl;
0155       }
0156
0157     /*
0158     node n1 = G.new_node();
0159     node n2 = G.new_node();
0160     node n3 = G.new_node();
0161     node n4 = G.new_node();
0162     node n5 = G.new_node();
0163     node n6 = G.new_node();
0164
0165     edge e1_2 = G.new_edge(n1, n2);
0166     edge e2_3 = G.new_edge(n2, n3);
0167     edge e1_6 = G.new_edge(n1, n6);
0168     edge e3_6 = G.new_edge(n3, n6);
0169     edge e4_3 = G.new_edge(n4, n3);
0170     edge e6_4 = G.new_edge(n6, n4);
0171     edge e6_5 = G.new_edge(n6, n5);
0172     edge e5_4 = G.new_edge(n5, n4);
0173     edge e5_1 = G.new_edge(n5, n1);
0174
0175     edge_map<double> w(G);
0176     w[e1_2] = 1;
0177     w[e2_3] = 2;
0178     w[e1_6] = 8;
0179     w[e3_6] = 3;
0180     w[e4_3] = 2;
0181     w[e6_4] = 1;
0182     w[e6_5] = 3;
0183     w[e5_4] = 10;
0184     w[e5_1] = 2;
0185
0186     node_map<double> result(G);
0187     result[n1] = 0;
0188     result[n2] = 1;
0189     result[n3] = 3;
0190     result[n4] = 7;
0191     result[n5] = 9;
0192     result[n6] = 6;
0193
0194     node_map<node> preds(G);
0195     preds[n1] = node();
0196     preds[n2] = n1;
0197     preds[n3] = n2;
0198     preds[n4] = n6;
0199     preds[n5] = n6;
0200     preds[n6] = n3;
0201
0202     bellman_ford B;
0203     B.store_preds(true);
0204     B.source(n1);
0205     B.weights(w);
0206
0207     G.save("test.gml");
0208
0209     cout << "Bellman Ford with positive edge weights" << endl;
0210
0211     if (B.check(G) == algorithm::GTL_OK)
0212     {
0213     cout << "check OK" << endl;
0214     }
0215     else
0216     {
0217     cout << "check FAILED" << endl;
0218     exit(1);
0219     }
0220
0221     if (B.run(G) == algorithm::GTL_OK)
0222     {
0223     cout << "run OK" << endl;
0224     }
0225     else
0226     {
0227     cout << "run FAILED" << endl;
0228     exit(1);
0229     }
0230
0231     graph::node_iterator it, end;
0232
0233     for (it = G.nodes_begin(), end = G.nodes_end(); it != end; ++it)
0234     {
0235     if(result[*it] != B.distance(*it))
0236     {
0237         cout << "Distance for node " << *it << " FAILED" << endl;
0238         exit(1);
0239     }
0240     }
0241
0242     cout << "Distances OK" << endl;
0243
0244     for (it = G.nodes_begin(), end = G.nodes_end(); it != end; ++it)
0245     {
0246     if(preds[*it] != B.predecessor_node(*it))
0247     {
0248         cout << "Predecessor for node " << *it << " FAILED" << endl;
0249         exit(1);
0250     }
0251     }
0252
0253     cout << "Predecessors OK" << endl;
0254
0255     if (B.negative_cycle())
0256     {
0257     cout << "Negative Cycle FAILED" << endl;
0258     }
0259     else
0260     {
0261     cout << "Negative Cycle OK" << endl;
0262     }
0263     */
0264 }