COIN-OR::LEMON - Graph Library

Changeset 210:81cfc04531e8 in lemon


Ignore:
Timestamp:
07/13/08 21:09:47 (16 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Children:
211:542dd614cbb4, 212:1ae84dea7d09, 214:60eecd3fe37a, 216:6d7bfcf5b48e
Phase:
public
Message:

Remove long lines (from all but one file)

Files:
14 edited

Legend:

Unmodified
Added
Removed
  • doc/coding_style.dox

    r209 r210  
    9090\subsection cs-loc-var Class and instance member variables, auto variables
    9191
    92 The names of class and instance member variables and auto variables (=variables used locally in methods) should look like the following.
     92The names of class and instance member variables and auto variables
     93(=variables used locally in methods) should look like the following.
    9394
    9495\code
  • doc/groups.dox

    r209 r210  
    228228
    229229\f[ 0 \le f_a \le c_a \f]
    230 \f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv} \qquad \forall u \in V \setminus \{s,t\}\f]
     230\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv}
     231\qquad \forall u \in V \setminus \{s,t\}\f]
    231232\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]
    232233
     
    268269cut is the \f$X\f$ solution of the next optimization problem:
    269270
    270 \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}\sum_{uv\in A, u\in X, v\not\in X}c_{uv}\f]
     271\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
     272\sum_{uv\in A, u\in X, v\not\in X}c_{uv}\f]
    271273
    272274LEMON contains several algorithms related to minimum cut problems:
     
    301303\brief Algorithms for planarity checking, embedding and drawing
    302304
    303 This group describes the algorithms for planarity checking, embedding and drawing.
     305This group describes the algorithms for planarity checking,
     306embedding and drawing.
    304307
    305308\image html planar.png
     
    478481\brief Reading and writing \ref lgf-format "Lemon Graph Format".
    479482
    480 This group describes methods for reading and writing \ref lgf-format "Lemon Graph Format".
     483This group describes methods for reading and writing
     484\ref lgf-format "Lemon Graph Format".
    481485*/
    482486
  • lemon/arg_parser.cc

    r209 r210  
    396396            if(_opts.find(*o)->second.set) ++set;
    397397          if(i->second.mandatory&&!set) {
    398             std::cerr << _command_name
    399                       << ": At least one of the following arguments is mandatory.\n";
     398            std::cerr << _command_name <<
     399              ": At least one of the following arguments is mandatory.\n";
    400400            ok=false;
    401401            for(GroupData::Opts::iterator o=i->second.opts.begin();
     
    404404          }
    405405          if(i->second.only_one&&set>1) {
    406             std::cerr << _command_name
    407                       << ": At most one of the following arguments can be given.\n";
     406            std::cerr << _command_name <<
     407              ": At most one of the following arguments can be given.\n";
    408408            ok=false;
    409409            for(GroupData::Opts::iterator o=i->second.opts.begin();
  • lemon/assert.h

    r209 r210  
    152152///   function.
    153153///   \code
    154 ///     void custom_assert_handler(const char* file, int line, const char* function,
    155 ///                                const char* message, const char* assertion);
     154///     void custom_assert_handler(const char* file, int line,
     155///                                const char* function, const char* message,
     156///                                const char* assertion);
    156157///   \endcode
    157158///   The name of the function should be defined as the \c
     
    186187#  define LEMON_FIXME(msg)                                                \
    187188  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
    188                         ::lemon::_assert_bits::cstringify(msg),                \
     189                        ::lemon::_assert_bits::cstringify(msg),          \
    189190                        static_cast<const char*>(0)))
    190191
     
    241242           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
    242243                                LEMON_FUNCTION_NAME, \
    243                                 ::lemon::_assert_bits::cstringify(msg),        \
     244                                ::lemon::_assert_bits::cstringify(msg),     \
    244245                                #exp), 0)))
    245246#    else
  • lemon/bfs.h

    r209 r210  
    104104
    105105    ///This function instantiates a \ref DistMap.
    106     ///\param G is the digraph, to which we would like to define the \ref DistMap
     106    ///\param G is the digraph, to which we would like to define
     107    ///the \ref DistMap
    107108    static DistMap *createDistMap(const GR &G)
    108109    {
     
    826827
    827828    ///This function instantiates a \ref DistMap.
    828     ///\param g is the digraph, to which we would like to define the \ref DistMap
     829    ///\param g is the digraph, to which we would like to define
     830    ///the \ref DistMap
    829831#ifdef DOXYGEN
    830832    static DistMap *createDistMap(const GR &g)
     
    12001202  /// on every bfs event the \c Visitor class member functions.
    12011203  ///
    1202   /// \tparam _Digraph The digraph type the algorithm runs on. The default value is
     1204  /// \tparam _Digraph The digraph type the algorithm runs on.
     1205  /// The default value is
    12031206  /// \ref ListDigraph. The value of _Digraph is not used directly by Bfs, it
    12041207  /// is only passed to \ref BfsDefaultTraits.
  • lemon/concepts/maps.h

    r209 r210  
    4444      /// The key type of the map.
    4545      typedef K Key;
    46       /// The value type of the map. (The type of objects associated with the keys).
     46      /// \brief The value type of the map.
     47      /// (The type of objects associated with the keys).
    4748      typedef T Value;
    4849
     
    8384      /// The key type of the map.
    8485      typedef K Key;
    85       /// The value type of the map. (The type of objects associated with the keys).
     86      /// \brief The value type of the map.
     87      /// (The type of objects associated with the keys).
    8688      typedef T Value;
    8789
     
    122124      /// The key type of the map.
    123125      typedef K Key;
    124       /// The value type of the map. (The type of objects associated with the keys).
     126      /// \brief The value type of the map.
     127      /// (The type of objects associated with the keys).
    125128      typedef T Value;
    126129
     
    155158      /// The key type of the map.
    156159      typedef K Key;
    157       /// The value type of the map. (The type of objects associated with the keys).
     160      /// \brief The value type of the map.
     161      /// (The type of objects associated with the keys).
    158162      typedef T Value;
    159163      /// The reference type of the map.
  • lemon/dfs.h

    r209 r210  
    106106
    107107    ///This function instantiates a \ref DistMap.
    108     ///\param G is the digraph, to which we would like to define the \ref DistMap
     108    ///\param G is the digraph, to which we would like to define
     109    ///the \ref DistMap
    109110    static DistMap *createDistMap(const GR &G)
    110111    {
     
    809810
    810811    ///This function instantiates a \ref DistMap.
    811     ///\param g is the digraph, to which we would like to define the \ref DistMap
     812    ///\param g is the digraph, to which we would like to define
     813    ///the \ref DistMap
    812814#ifdef DOXYGEN
    813815    static DistMap *createDistMap(const GR &g)
     
    11941196  /// on every dfs event the \c Visitor class member functions.
    11951197  ///
    1196   /// \tparam _Digraph The digraph type the algorithm runs on. The default value is
     1198  /// \tparam _Digraph The digraph type the algorithm runs on.
     1199  /// The default value is
    11971200  /// \ref ListDigraph. The value of _Digraph is not used directly by Dfs, it
    11981201  /// is only passed to \ref DfsDefaultTraits.
  • lemon/dijkstra.h

    r209 r210  
    174174
    175175    ///This function instantiates a \ref DistMap.
    176     ///\param G is the digraph, to which we would like to define the \ref DistMap
     176    ///\param G is the digraph, to which we would like to define
     177    ///the \ref DistMap
    177178    static DistMap *createDistMap(const GR &G)
    178179    {
     
    337338    template <class T>
    338339    struct DefPredMap
    339       : public Dijkstra< Digraph,        LengthMap, DefPredMapTraits<T> > {
    340       typedef Dijkstra< Digraph,        LengthMap, DefPredMapTraits<T> > Create;
     340      : public Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > {
     341      typedef Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > Create;
    341342    };
    342343
     
    373374    template <class T>
    374375    struct DefProcessedMap
    375       : public Dijkstra< Digraph,        LengthMap, DefProcessedMapTraits<T> > {
    376       typedef Dijkstra< Digraph,        LengthMap, DefProcessedMapTraits<T> > Create;
     376      : public Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > {
     377      typedef Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > Create;
    377378    };
    378379
     
    393394    struct DefProcessedMapToBeDefaultMap
    394395      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {
    395       typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> Create;
     396      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits>
     397      Create;
    396398    };
    397399
     
    416418    template <class H, class CR = typename Digraph::template NodeMap<int> >
    417419    struct DefHeap
    418       : public Dijkstra< Digraph,        LengthMap, DefHeapTraits<H, CR> > {
    419       typedef Dijkstra< Digraph,        LengthMap, DefHeapTraits<H, CR> > Create;
     420      : public Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > {
     421      typedef Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > Create;
    420422    };
    421423
     
    441443    template <class H, class CR = typename Digraph::template NodeMap<int> >
    442444    struct DefStandardHeap
    443       : public Dijkstra< Digraph,        LengthMap, DefStandardHeapTraits<H, CR> > {
    444       typedef Dijkstra< Digraph,        LengthMap, DefStandardHeapTraits<H, CR> >
     445      : public Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> > {
     446      typedef Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> >
    445447      Create;
    446448    };
     
    977979
    978980    ///This function instantiates a \ref DistMap.
    979     ///\param g is the digraph, to which we would like to define the \ref DistMap
     981    ///\param g is the digraph, to which we would like to define
     982    ///the \ref DistMap
    980983#ifdef DOXYGEN
    981984    static DistMap *createDistMap(const GR &g)
  • lemon/graph_to_eps.h

    r209 r210  
    143143  ///\param _g  Reference to the graph to be printed.
    144144  ///\param _os Reference to the output stream.
    145   ///\param _os Reference to the output stream. By default it is <tt>std::cout</tt>.
     145  ///\param _os Reference to the output stream.
     146  ///By default it is <tt>std::cout</tt>.
    146147  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os
    147148  ///will be explicitly deallocated by the destructor.
     
    782783    os << "/lb { setlinewidth setrgbcolor newpath moveto\n"
    783784       << "      4 2 roll 1 index 1 index curveto stroke } bind def\n";
    784     os << "/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def\n";
     785    os << "/l { setlinewidth setrgbcolor newpath moveto lineto stroke }"
     786       << " bind def\n";
    785787    //x y r
    786     os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def\n";
     788    os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath }"
     789       << " bind def\n";
    787790    //x y r
    788791    os << "/sq { newpath 2 index 1 index add 2 index 2 index add moveto\n"
     
    812815       << "  newpath 5 index 5 index moveto "
    813816       << "5 index 5 index 5 index 3.01 mul sub\n"
    814        << "  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto\n"
    815        << "  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke\n"
     817       << "  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub"
     818       << " moveto\n"
     819       << "  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto "
     820       << "stroke\n"
    816821       << "  5 index 5 index 5 index c fill\n"
    817822       << "  setrgbcolor " << 1+_nodeBorderQuotient << " div c fill\n"
     
    827832       << "  1 index 1 index 7 index sub moveto\n"
    828833       << "  1 index 1 index lineto\n"
    829        << "  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto\n"
     834       << "  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub"
     835       << " lineto\n"
    830836       << "  stroke\n"
    831837       << "  5 index 5 index 5 index c fill\n"
     
    839845    os << "/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def\n";
    840846    //len w dx_norm dy_norm x1 y1 cr cg cb
    841     os << "/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def\n"
     847    os << "/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx "
     848       << "exch def\n"
    842849       << "       /w exch def /len exch def\n"
    843       //         << "       0.1 setlinewidth x1 y1 moveto dx len mul dy len mul rlineto stroke"
     850      //<< "0.1 setlinewidth x1 y1 moveto dx len mul dy len mul rlineto stroke"
    844851       << "       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto\n"
    845852       << "       len w sub arrl sub dx dy lrl\n"
     
    903910          dim2::Point<double> d(dvec/std::max(l,EPSILON));
    904911           dim2::Point<double> m;
    905 //           m=dim2::Point<double>(mycoords[g.target(*i)]+mycoords[g.source(*i)])/2.0;
     912//           m=dim2::Point<double>(mycoords[g.target(*i)]+
     913//                                 mycoords[g.source(*i)])/2.0;
    906914
    907915//            m=dim2::Point<double>(mycoords[g.source(*i)])+
     
    939947//               t1=0;t2=1;
    940948//               for(int i=0;i<INTERPOL_PREC;++i)
    941 //                 if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape)) t1=(t1+t2)/2;
     949//                 if(isInsideNode(bez((t1+t2)/2)-t,rn,node_shape))
     950//                   t1=(t1+t2)/2;
    942951//                 else t2=(t1+t2)/2;
    943952//               bez=bez.after((t1+t2)/2);
  • lemon/lgf_reader.h

    r209 r210  
    445445  /// The previously read label node map should be passed to the \c
    446446  /// useNodes() functions. Another application of multipass reading when
    447   /// paths are given as a node map or an arc map. It is impossible to read this in
     447  /// paths are given as a node map or an arc map.
     448  /// It is impossible to read this in
    448449  /// a single pass, because the arcs are not constructed when the node
    449450  /// maps are read.
  • lemon/time_measure.h

    r209 r210  
    315315    ///The \ref Timer also counts the number of \ref start()
    316316    ///executions, and is stops only after the same amount (or more)
    317     ///\ref stop() "stop()"s. This can be useful e.g. to compute the running time
     317    ///\ref stop() "stop()"s. This can be useful e.g. to compute
     318    ///the running time
    318319    ///of recursive functions.
    319320    ///
  • test/dijkstra_test.cc

    r209 r210  
    111111    Node u=G.source(e);
    112112    Node v=G.target(e);
    113     check( !dijkstra_test.reached(u) || (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= length[e]),
    114            "dist(target)-dist(source)-arc_length= " << dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
     113    check( !dijkstra_test.reached(u) ||
     114           (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= length[e]),
     115           "dist(target)-dist(source)-arc_length= " <<
     116           dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
    115117  }
    116118
     
    122124      check(u==dijkstra_test.predNode(v),"Wrong tree.");
    123125      check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == length[e],
    124             "Wrong distance! Difference: " << std::abs(dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]));
     126            "Wrong distance! Difference: " <<
     127            std::abs(dijkstra_test.dist(v)-dijkstra_test.dist(u)-length[e]));
    125128    }
    126129  }
  • test/graph_utils_test.cc

    r209 r210  
    9393        Arc con3 = al3(src, trg);
    9494        Arc con4 = findArc(fg, src, trg);
    95         check(con1 == con2 && con2 == con3 && con3 == con4, "Different results.")
     95        check(con1 == con2 && con2 == con3 && con3 == con4,
     96              "Different results.")
    9697        check(con1 != INVALID, "There is no connecting arc.");
    9798        check(fg.source(con1) == src, "Wrong source.");
    9899        check(fg.target(con1) == trg, "Wrong target.");
    99         check(al3(src, trg, con3) == INVALID, "There is more connecting arc.");
    100         check(findArc(fg, src, trg, con4) == INVALID, "There is more connecting arc.");
     100        check(al3(src, trg, con3) == INVALID,
     101              "There is more connecting arc.");
     102        check(findArc(fg, src, trg, con4) == INVALID,
     103              "There is more connecting arc.");
    101104      }
    102105    }
     
    124127      for (ConEdgeIt<Graph> con(graph, src, trg); con != INVALID; ++con) {
    125128        check( (graph.u(con) == src && graph.v(con) == trg) ||
    126                (graph.v(con) == src && graph.u(con) == trg), "Wrong end nodes.");
     129               (graph.v(con) == src && graph.u(con) == trg),
     130               "Wrong end nodes.");
    127131        ++found[con];
    128132        check(found[con] <= 2, "The edge found more than twice.");
  • test/maps_test.cc

    r209 r210  
    104104    map6 = constMap<A,int,10>();
    105105    map7 = constMap<A,Const<int,10> >();
    106     check(map6[A()] == 10 && map7[A()] == 10, "Something is wrong with ConstMap");
     106    check(map6[A()] == 10 && map7[A()] == 10,
     107          "Something is wrong with ConstMap");
    107108  }
    108109
     
    115116
    116117    checkConcept<ReadMap<double,double>, IdentityMap<double> >();
    117     check(identityMap<double>()[1.0] == 1.0 && identityMap<double>()[3.14] == 3.14,
     118    check(identityMap<double>()[1.0] == 1.0 &&
     119          identityMap<double>()[3.14] == 3.14,
    118120          "Something is wrong with IdentityMap");
    119121  }
     
    156158    SparseMap<double, int> map8 = sparseMap(m,10);
    157159
    158     check(map5[1.0] == 0 && map5[3.14] == 0 && map6[1.0] == 10 && map6[3.14] == 10,
     160    check(map5[1.0] == 0 && map5[3.14] == 0 &&
     161          map6[1.0] == 10 && map6[3.14] == 10,
    159162          "Something is wrong with SparseMap");
    160163    map5[1.0] = map6[3.14] = 100;
    161     check(map5[1.0] == 100 && map5[3.14] == 0 && map6[1.0] == 10 && map6[3.14] == 100,
     164    check(map5[1.0] == 100 && map5[3.14] == 0 &&
     165          map6[1.0] == 10 && map6[3.14] == 100,
    162166          "Something is wrong with SparseMap");
    163167  }
     
    172176    SparseMap<double, bool> m1(false); m1[3.14] = true;
    173177    RangeMap<double> m2(2); m2[0] = 3.0; m2[1] = 3.14;
    174     check(!composeMap(m1,m2)[0] && composeMap(m1,m2)[1], "Something is wrong with ComposeMap")
     178    check(!composeMap(m1,m2)[0] && composeMap(m1,m2)[1],
     179          "Something is wrong with ComposeMap")
    175180  }
    176181
     
    197202    MapToFunctor<ReadMap<A,B> > map(ReadMap<A,B>());
    198203
    199     check(functorToMap(&func)[A()] == 3, "Something is wrong with FunctorToMap");
    200     check(mapToFunctor(constMap<A,int>(2))(A()) == 2, "Something is wrong with MapToFunctor");
    201     check(mapToFunctor(functorToMap(&func))(A()) == 3 && mapToFunctor(functorToMap(&func))[A()] == 3,
     204    check(functorToMap(&func)[A()] == 3,
     205          "Something is wrong with FunctorToMap");
     206    check(mapToFunctor(constMap<A,int>(2))(A()) == 2,
     207          "Something is wrong with MapToFunctor");
     208    check(mapToFunctor(functorToMap(&func))(A()) == 3 &&
     209          mapToFunctor(functorToMap(&func))[A()] == 3,
    202210          "Something is wrong with FunctorToMap or MapToFunctor");
    203211    check(functorToMap(mapToFunctor(constMap<A,int>(2)))[A()] == 2,
     
    207215  // ConvertMap
    208216  {
    209     checkConcept<ReadMap<double,double>, ConvertMap<ReadMap<double, int>, double> >();
     217    checkConcept<ReadMap<double,double>,
     218      ConvertMap<ReadMap<double, int>, double> >();
    210219    ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
    211220    ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
     
    225234    ForkMap<SM, RM> map2 = forkMap(m2,m1);
    226235    map2.set(5, 10);
    227     check(m1[1] == -1 && m1[5] == 10 && m2[1] == -1 && m2[5] == 10 && map2[1] == -1 && map2[5] == 10,
     236    check(m1[1] == -1 && m1[5] == 10 && m2[1] == -1 &&
     237          m2[5] == 10 && map2[1] == -1 && map2[5] == 10,
    228238          "Something is wrong with ForkMap");
    229239  }
     
    242252    IdentityMap<int> im;
    243253    ConvertMap<IdentityMap<int>, double> id(im);
    244     check(addMap(c1,id)[0] == 1.0  && addMap(c1,id)[10] == 11.0, "Something is wrong with AddMap");
    245     check(subMap(id,c1)[0] == -1.0 && subMap(id,c1)[10] == 9.0,  "Something is wrong with SubMap");
    246     check(mulMap(id,c2)[0] == 0    && mulMap(id,c2)[2]  == 6.28, "Something is wrong with MulMap");
    247     check(divMap(c2,id)[1] == 3.14 && divMap(c2,id)[2]  == 1.57, "Something is wrong with DivMap");
     254    check(addMap(c1,id)[0] == 1.0  && addMap(c1,id)[10] == 11.0,
     255          "Something is wrong with AddMap");
     256    check(subMap(id,c1)[0] == -1.0 && subMap(id,c1)[10] == 9.0,
     257          "Something is wrong with SubMap");
     258    check(mulMap(id,c2)[0] == 0    && mulMap(id,c2)[2]  == 6.28,
     259          "Something is wrong with MulMap");
     260    check(divMap(c2,id)[1] == 3.14 && divMap(c2,id)[2]  == 1.57,
     261          "Something is wrong with DivMap");
    248262
    249263    checkConcept<DoubleMap, ShiftMap<DoubleMap> >();
     
    257271    check(shiftMap(id, 2.0)[1] == 3.0 && shiftMap(id, 2.0)[10] == 12.0,
    258272          "Something is wrong with ShiftMap");
    259     check(shiftWriteMap(id, 2.0)[1] == 3.0 && shiftWriteMap(id, 2.0)[10] == 12.0,
     273    check(shiftWriteMap(id, 2.0)[1] == 3.0 &&
     274          shiftWriteMap(id, 2.0)[10] == 12.0,
    260275          "Something is wrong with ShiftWriteMap");
    261276    check(scaleMap(id, 2.0)[1] == 2.0 && scaleMap(id, 2.0)[10] == 20.0,
    262277          "Something is wrong with ScaleMap");
    263     check(scaleWriteMap(id, 2.0)[1] == 2.0 && scaleWriteMap(id, 2.0)[10] == 20.0,
     278    check(scaleWriteMap(id, 2.0)[1] == 2.0 &&
     279          scaleWriteMap(id, 2.0)[10] == 20.0,
    264280          "Something is wrong with ScaleWriteMap");
    265281    check(negMap(id)[1] == -1.0 && negMap(id)[-10] == 10.0,
     
    290306    RangeMap<bool> rm(2);
    291307    rm[0] = true; rm[1] = false;
    292     check(andMap(tm,rm)[0] && !andMap(tm,rm)[1] && !andMap(fm,rm)[0] && !andMap(fm,rm)[1],
     308    check(andMap(tm,rm)[0] && !andMap(tm,rm)[1] &&
     309          !andMap(fm,rm)[0] && !andMap(fm,rm)[1],
    293310          "Something is wrong with AndMap");
    294     check(orMap(tm,rm)[0] && orMap(tm,rm)[1] && orMap(fm,rm)[0] && !orMap(fm,rm)[1],
     311    check(orMap(tm,rm)[0] && orMap(tm,rm)[1] &&
     312          orMap(fm,rm)[0] && !orMap(fm,rm)[1],
    295313          "Something is wrong with OrMap");
    296     check(!notMap(rm)[0] && notMap(rm)[1], "Something is wrong with NotMap");
    297     check(!notWriteMap(rm)[0] && notWriteMap(rm)[1], "Something is wrong with NotWriteMap");
     314    check(!notMap(rm)[0] && notMap(rm)[1],
     315          "Something is wrong with NotMap");
     316    check(!notWriteMap(rm)[0] && notWriteMap(rm)[1],
     317          "Something is wrong with NotWriteMap");
    298318
    299319    ConstMap<int, double> cm(2.0);
     
    311331    vec v1;
    312332    vec v2(10);
    313     LoggerBoolMap<std::back_insert_iterator<vec> > map1(std::back_inserter(v1));
     333    LoggerBoolMap<std::back_insert_iterator<vec> >
     334      map1(std::back_inserter(v1));
    314335    LoggerBoolMap<vec::iterator> map2(v2.begin());
    315336    map1.set(10, false);
     
    319340    map1.set(60, true);   map2.set(60, true);
    320341    check(v1.size() == 3 && v2.size() == 10 &&
    321           v1[0]==20 && v1[1]==50 && v1[2]==60 && v2[0]==20 && v2[1]==50 && v2[2]==60,
     342          v1[0]==20 && v1[1]==50 && v1[2]==60 &&
     343          v2[0]==20 && v2[1]==50 && v2[2]==60,
    322344          "Something is wrong with LoggerBoolMap");
    323345
Note: See TracChangeset for help on using the changeset viewer.