COIN-OR::LEMON - Graph Library

Changeset 517:afd134142111 in lemon


Ignore:
Timestamp:
02/20/09 21:36:26 (9 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Message:

Various fixes for compiling on AIX (#211, #212)

Location:
lemon
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • lemon/lgf_reader.h

    r319 r517  
    391391  class DigraphReader; 
    392392 
    393   /// \brief Return a \ref DigraphReader class 
    394   /// 
    395   /// This function just returns a \ref DigraphReader class. 
    396   /// \relates DigraphReader 
    397393  template <typename Digraph> 
    398   DigraphReader<Digraph> digraphReader(Digraph& digraph, 
    399                                        std::istream& is = std::cin) { 
    400     DigraphReader<Digraph> tmp(digraph, is); 
    401     return tmp; 
    402   } 
    403  
    404   /// \brief Return a \ref DigraphReader class 
    405   /// 
    406   /// This function just returns a \ref DigraphReader class. 
    407   /// \relates DigraphReader 
     394  DigraphReader<Digraph> digraphReader(Digraph& digraph,  
     395                                       std::istream& is = std::cin); 
    408396  template <typename Digraph> 
    409   DigraphReader<Digraph> digraphReader(Digraph& digraph, 
    410                                        const std::string& fn) { 
    411     DigraphReader<Digraph> tmp(digraph, fn); 
    412     return tmp; 
    413   } 
    414  
    415   /// \brief Return a \ref DigraphReader class 
    416   /// 
    417   /// This function just returns a \ref DigraphReader class. 
    418   /// \relates DigraphReader 
     397  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn); 
    419398  template <typename Digraph> 
    420   DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) { 
    421     DigraphReader<Digraph> tmp(digraph, fn); 
    422     return tmp; 
    423   } 
     399  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn); 
    424400 
    425401  /// \ingroup lemon_io 
     
    585561  private: 
    586562 
    587     friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph, 
    588                                                   std::istream& is); 
    589     friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph, 
    590                                                   const std::string& fn); 
    591     friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph, 
    592                                                   const char *fn); 
     563    template <typename DGR> 
     564    friend DigraphReader<DGR> digraphReader(DGR& digraph, std::istream& is); 
     565    template <typename DGR> 
     566    friend DigraphReader<DGR> digraphReader(DGR& digraph,  
     567                                            const std::string& fn); 
     568    template <typename DGR> 
     569    friend DigraphReader<DGR> digraphReader(DGR& digraph, const char *fn); 
    593570 
    594571    DigraphReader(DigraphReader& other) 
     
    12111188  }; 
    12121189 
     1190  /// \brief Return a \ref DigraphReader class 
     1191  /// 
     1192  /// This function just returns a \ref DigraphReader class. 
     1193  /// \relates DigraphReader 
     1194  template <typename Digraph> 
     1195  DigraphReader<Digraph> digraphReader(Digraph& digraph, std::istream& is) { 
     1196    DigraphReader<Digraph> tmp(digraph, is); 
     1197    return tmp; 
     1198  } 
     1199 
     1200  /// \brief Return a \ref DigraphReader class 
     1201  /// 
     1202  /// This function just returns a \ref DigraphReader class. 
     1203  /// \relates DigraphReader 
     1204  template <typename Digraph> 
     1205  DigraphReader<Digraph> digraphReader(Digraph& digraph, 
     1206                                       const std::string& fn) { 
     1207    DigraphReader<Digraph> tmp(digraph, fn); 
     1208    return tmp; 
     1209  } 
     1210 
     1211  /// \brief Return a \ref DigraphReader class 
     1212  /// 
     1213  /// This function just returns a \ref DigraphReader class. 
     1214  /// \relates DigraphReader 
     1215  template <typename Digraph> 
     1216  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) { 
     1217    DigraphReader<Digraph> tmp(digraph, fn); 
     1218    return tmp; 
     1219  } 
     1220 
    12131221  template <typename Graph> 
    12141222  class GraphReader; 
    1215  
    1216   /// \brief Return a \ref GraphReader class 
    1217   /// 
    1218   /// This function just returns a \ref GraphReader class. 
    1219   /// \relates GraphReader 
     1223  
    12201224  template <typename Graph> 
    1221   GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) { 
    1222     GraphReader<Graph> tmp(graph, is); 
    1223     return tmp; 
    1224   } 
    1225  
    1226   /// \brief Return a \ref GraphReader class 
    1227   /// 
    1228   /// This function just returns a \ref GraphReader class. 
    1229   /// \relates GraphReader 
     1225  GraphReader<Graph> graphReader(Graph& graph,  
     1226                                 std::istream& is = std::cin); 
    12301227  template <typename Graph> 
    1231   GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) { 
    1232     GraphReader<Graph> tmp(graph, fn); 
    1233     return tmp; 
    1234   } 
    1235  
    1236   /// \brief Return a \ref GraphReader class 
    1237   /// 
    1238   /// This function just returns a \ref GraphReader class. 
    1239   /// \relates GraphReader 
     1228  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn); 
    12401229  template <typename Graph> 
    1241   GraphReader<Graph> graphReader(Graph& graph, const char* fn) { 
    1242     GraphReader<Graph> tmp(graph, fn); 
    1243     return tmp; 
    1244   } 
     1230  GraphReader<Graph> graphReader(Graph& graph, const char *fn); 
    12451231 
    12461232  /// \ingroup lemon_io 
     
    13691355 
    13701356  private: 
    1371     friend GraphReader<Graph> graphReader<>(Graph& graph, std::istream& is); 
    1372     friend GraphReader<Graph> graphReader<>(Graph& graph, 
    1373                                             const std::string& fn); 
    1374     friend GraphReader<Graph> graphReader<>(Graph& graph, const char *fn); 
     1357    template <typename GR> 
     1358    friend GraphReader<GR> graphReader(GR& graph, std::istream& is); 
     1359    template <typename GR> 
     1360    friend GraphReader<GR> graphReader(GR& graph, const std::string& fn);  
     1361    template <typename GR> 
     1362    friend GraphReader<GR> graphReader(GR& graph, const char *fn); 
    13751363 
    13761364    GraphReader(GraphReader& other) 
     
    20402028 
    20412029  }; 
     2030 
     2031  /// \brief Return a \ref GraphReader class 
     2032  /// 
     2033  /// This function just returns a \ref GraphReader class. 
     2034  /// \relates GraphReader 
     2035  template <typename Graph> 
     2036  GraphReader<Graph> graphReader(Graph& graph, std::istream& is) { 
     2037    GraphReader<Graph> tmp(graph, is); 
     2038    return tmp; 
     2039  } 
     2040 
     2041  /// \brief Return a \ref GraphReader class 
     2042  /// 
     2043  /// This function just returns a \ref GraphReader class. 
     2044  /// \relates GraphReader 
     2045  template <typename Graph> 
     2046  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) { 
     2047    GraphReader<Graph> tmp(graph, fn); 
     2048    return tmp; 
     2049  } 
     2050 
     2051  /// \brief Return a \ref GraphReader class 
     2052  /// 
     2053  /// This function just returns a \ref GraphReader class. 
     2054  /// \relates GraphReader 
     2055  template <typename Graph> 
     2056  GraphReader<Graph> graphReader(Graph& graph, const char* fn) { 
     2057    GraphReader<Graph> tmp(graph, fn); 
     2058    return tmp; 
     2059  } 
    20422060 
    20432061  class SectionReader; 
  • lemon/lgf_writer.h

    r319 r517  
    351351  class DigraphWriter; 
    352352 
    353   /// \brief Return a \ref DigraphWriter class 
    354   /// 
    355   /// This function just returns a \ref DigraphWriter class. 
    356   /// \relates DigraphWriter 
    357353  template <typename Digraph> 
    358354  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph, 
    359                                        std::ostream& os = std::cout) { 
    360     DigraphWriter<Digraph> tmp(digraph, os); 
    361     return tmp; 
    362   } 
    363  
    364   /// \brief Return a \ref DigraphWriter class 
    365   /// 
    366   /// This function just returns a \ref DigraphWriter class. 
    367   /// \relates DigraphWriter 
     355                                       std::ostream& os = std::cout); 
    368356  template <typename Digraph> 
    369357  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph, 
    370                                        const std::string& fn) { 
    371     DigraphWriter<Digraph> tmp(digraph, fn); 
    372     return tmp; 
    373   } 
    374  
    375   /// \brief Return a \ref DigraphWriter class 
    376   /// 
    377   /// This function just returns a \ref DigraphWriter class. 
    378   /// \relates DigraphWriter 
     358                                       const std::string& fn); 
     359 
    379360  template <typename Digraph> 
    380361  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph, 
    381                                        const char* fn) { 
    382     DigraphWriter<Digraph> tmp(digraph, fn); 
    383     return tmp; 
    384   } 
     362                                       const char* fn); 
     363 
    385364 
    386365  /// \ingroup lemon_io 
     
    527506  private: 
    528507 
    529     friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph, 
    530                                                   std::ostream& os); 
    531     friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph, 
    532                                                   const std::string& fn); 
    533     friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph, 
    534                                                   const char *fn); 
     508    template <typename DGR> 
     509    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,  
     510                                            std::ostream& os); 
     511    template <typename DGR> 
     512    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph, 
     513                                            const std::string& fn); 
     514    template <typename DGR> 
     515    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph, 
     516                                            const char *fn); 
    535517 
    536518    DigraphWriter(DigraphWriter& other) 
     
    934916  }; 
    935917 
     918  /// \brief Return a \ref DigraphWriter class 
     919  /// 
     920  /// This function just returns a \ref DigraphWriter class. 
     921  /// \relates DigraphWriter 
     922  template <typename Digraph> 
     923  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph, 
     924                                       std::ostream& os) { 
     925    DigraphWriter<Digraph> tmp(digraph, os); 
     926    return tmp; 
     927  } 
     928 
     929  /// \brief Return a \ref DigraphWriter class 
     930  /// 
     931  /// This function just returns a \ref DigraphWriter class. 
     932  /// \relates DigraphWriter 
     933  template <typename Digraph> 
     934  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph, 
     935                                       const std::string& fn) { 
     936    DigraphWriter<Digraph> tmp(digraph, fn); 
     937    return tmp; 
     938  } 
     939 
     940  /// \brief Return a \ref DigraphWriter class 
     941  /// 
     942  /// This function just returns a \ref DigraphWriter class. 
     943  /// \relates DigraphWriter 
     944  template <typename Digraph> 
     945  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph, 
     946                                       const char* fn) { 
     947    DigraphWriter<Digraph> tmp(digraph, fn); 
     948    return tmp; 
     949  } 
     950 
    936951  template <typename Graph> 
    937952  class GraphWriter; 
    938953 
    939   /// \brief Return a \ref GraphWriter class 
    940   /// 
    941   /// This function just returns a \ref GraphWriter class. 
    942   /// \relates GraphWriter 
    943954  template <typename Graph> 
    944955  GraphWriter<Graph> graphWriter(const Graph& graph, 
    945                                  std::ostream& os = std::cout) { 
    946     GraphWriter<Graph> tmp(graph, os); 
    947     return tmp; 
    948   } 
    949  
    950   /// \brief Return a \ref GraphWriter class 
    951   /// 
    952   /// This function just returns a \ref GraphWriter class. 
    953   /// \relates GraphWriter 
     956                                 std::ostream& os = std::cout); 
    954957  template <typename Graph> 
    955   GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) { 
    956     GraphWriter<Graph> tmp(graph, fn); 
    957     return tmp; 
    958   } 
    959  
    960   /// \brief Return a \ref GraphWriter class 
    961   /// 
    962   /// This function just returns a \ref GraphWriter class. 
    963   /// \relates GraphWriter 
     958  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn); 
    964959  template <typename Graph> 
    965   GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) { 
    966     GraphWriter<Graph> tmp(graph, fn); 
    967     return tmp; 
    968   } 
     960  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn); 
    969961 
    970962  /// \ingroup lemon_io 
     
    10821074  private: 
    10831075 
    1084     friend GraphWriter<Graph> graphWriter<>(const Graph& graph, 
    1085                                             std::ostream& os); 
    1086     friend GraphWriter<Graph> graphWriter<>(const Graph& graph, 
    1087                                             const std::string& fn); 
    1088     friend GraphWriter<Graph> graphWriter<>(const Graph& graph, 
    1089                                             const char *fn); 
    1090  
     1076    template <typename GR> 
     1077    friend GraphWriter<GR> graphWriter(const GR& graph, 
     1078                                       std::ostream& os); 
     1079    template <typename GR> 
     1080    friend GraphWriter<GR> graphWriter(const GR& graph, 
     1081                                       const std::string& fn); 
     1082    template <typename GR> 
     1083    friend GraphWriter<GR> graphWriter(const GR& graph, 
     1084                                       const char *fn); 
     1085     
    10911086    GraphWriter(GraphWriter& other) 
    10921087      : _os(other._os), local_os(other.local_os), _graph(other._graph), 
     
    15341529    /// @} 
    15351530  }; 
     1531 
     1532  /// \brief Return a \ref GraphWriter class 
     1533  /// 
     1534  /// This function just returns a \ref GraphWriter class. 
     1535  /// \relates GraphWriter 
     1536  template <typename Graph> 
     1537  GraphWriter<Graph> graphWriter(const Graph& graph, 
     1538                                 std::ostream& os) { 
     1539    GraphWriter<Graph> tmp(graph, os); 
     1540    return tmp; 
     1541  } 
     1542 
     1543  /// \brief Return a \ref GraphWriter class 
     1544  /// 
     1545  /// This function just returns a \ref GraphWriter class. 
     1546  /// \relates GraphWriter 
     1547  template <typename Graph> 
     1548  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) { 
     1549    GraphWriter<Graph> tmp(graph, fn); 
     1550    return tmp; 
     1551  } 
     1552 
     1553  /// \brief Return a \ref GraphWriter class 
     1554  /// 
     1555  /// This function just returns a \ref GraphWriter class. 
     1556  /// \relates GraphWriter 
     1557  template <typename Graph> 
     1558  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) { 
     1559    GraphWriter<Graph> tmp(graph, fn); 
     1560    return tmp; 
     1561  } 
    15361562 
    15371563  class SectionWriter; 
  • lemon/path.h

    r313 r517  
    930930 
    931931    template <typename Target, typename Source, 
    932               bool buildEnable = BuildTagIndicator<Target>::value, 
    933               bool revEnable = RevPathTagIndicator<Source>::value> 
    934     struct PathCopySelector { 
     932              bool buildEnable = BuildTagIndicator<Target>::value> 
     933    struct PathCopySelectorForward { 
    935934      static void copy(Target& target, const Source& source) { 
    936935        target.clear(); 
     
    942941 
    943942    template <typename Target, typename Source> 
    944     struct PathCopySelector<Target, Source, false, true> { 
     943    struct PathCopySelectorForward<Target, Source, true> { 
     944      static void copy(Target& target, const Source& source) { 
     945        target.clear(); 
     946        target.build(source); 
     947      } 
     948    }; 
     949 
     950    template <typename Target, typename Source, 
     951              bool buildEnable = BuildTagIndicator<Target>::value> 
     952    struct PathCopySelectorBackward { 
    945953      static void copy(Target& target, const Source& source) { 
    946954        target.clear(); 
     
    952960 
    953961    template <typename Target, typename Source> 
    954     struct PathCopySelector<Target, Source, true, false> { 
    955       static void copy(Target& target, const Source& source) { 
    956         target.clear(); 
    957         target.build(source); 
    958       } 
    959     }; 
    960  
    961     template <typename Target, typename Source> 
    962     struct PathCopySelector<Target, Source, true, true> { 
     962    struct PathCopySelectorBackward<Target, Source, true> { 
    963963      static void copy(Target& target, const Source& source) { 
    964964        target.clear(); 
    965965        target.buildRev(source); 
    966966      } 
     967    }; 
     968 
     969     
     970    template <typename Target, typename Source, 
     971              bool revEnable = RevPathTagIndicator<Source>::value> 
     972    struct PathCopySelector { 
     973      static void copy(Target& target, const Source& source) { 
     974        PathCopySelectorForward<Target, Source>::copy(target, source); 
     975      }       
     976    }; 
     977 
     978    template <typename Target, typename Source> 
     979    struct PathCopySelector<Target, Source, true> { 
     980      static void copy(Target& target, const Source& source) { 
     981        PathCopySelectorBackward<Target, Source>::copy(target, source); 
     982      }       
    967983    }; 
    968984 
  • lemon/random.h

    r511 r517  
    345345    }; 
    346346 
    347     template <typename Result, int exp, bool pos = (exp >= 0)> 
     347    template <typename Result, int exp> 
    348348    struct ShiftMultiplier { 
    349       static const Result multiplier() { 
    350         Result res = ShiftMultiplier<Result, exp / 2>::multiplier(); 
    351         res *= res; 
    352         if ((exp & 1) == 1) res *= static_cast<Result>(2.0); 
    353         return res; 
    354       } 
    355     }; 
    356  
    357     template <typename Result, int exp> 
    358     struct ShiftMultiplier<Result, exp, false> { 
    359349      static const Result multiplier() { 
    360350        Result res = ShiftMultiplier<Result, exp / 2>::multiplier(); 
     
    366356 
    367357    template <typename Result> 
    368     struct ShiftMultiplier<Result, 0, true> { 
     358    struct ShiftMultiplier<Result, 0> { 
    369359      static const Result multiplier() { 
    370360        return static_cast<Result>(1.0); 
     
    373363 
    374364    template <typename Result> 
    375     struct ShiftMultiplier<Result, -20, true> { 
     365    struct ShiftMultiplier<Result, 20> { 
    376366      static const Result multiplier() { 
    377367        return static_cast<Result>(1.0/1048576.0); 
     
    380370 
    381371    template <typename Result> 
    382     struct ShiftMultiplier<Result, -32, true> { 
     372    struct ShiftMultiplier<Result, 32> { 
    383373      static const Result multiplier() { 
    384         return static_cast<Result>(1.0/424967296.0); 
     374        return static_cast<Result>(1.0/4294967296.0); 
    385375      } 
    386376    }; 
    387377 
    388378    template <typename Result> 
    389     struct ShiftMultiplier<Result, -53, true> { 
     379    struct ShiftMultiplier<Result, 53> { 
    390380      static const Result multiplier() { 
    391381        return static_cast<Result>(1.0/9007199254740992.0); 
     
    394384 
    395385    template <typename Result> 
    396     struct ShiftMultiplier<Result, -64, true> { 
     386    struct ShiftMultiplier<Result, 64> { 
    397387      static const Result multiplier() { 
    398388        return static_cast<Result>(1.0/18446744073709551616.0); 
     
    414404 
    415405      static Result convert(RandomCore<Word>& rnd) { 
    416         return Shifting<Result, - shift - rest>:: 
     406        return Shifting<Result, shift + rest>:: 
    417407          shift(static_cast<Result>(rnd() >> (bits - rest))); 
    418408      } 
     
    424414 
    425415      static Result convert(RandomCore<Word>& rnd) { 
    426         return Shifting<Result, - shift - bits>:: 
     416        return Shifting<Result, shift + bits>:: 
    427417          shift(static_cast<Result>(rnd())) + 
    428418          RealConversion<Result, Word, rest-bits, shift + bits>:: 
Note: See TracChangeset for help on using the changeset viewer.