Changes in / [373:7d7d9debb29a:375:b1ef32ab39f3] in lemon1.0
 Location:
 lemon
 Files:

 4 edited
Legend:
 Unmodified
 Added
 Removed

lemon/lgf_reader.h
r327 r374 391 391 class DigraphReader; 392 392 393 /// \brief Return a \ref DigraphReader class394 ///395 /// This function just returns a \ref DigraphReader class.396 /// \relates DigraphReader397 393 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); 408 396 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); 419 398 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); 424 400 425 401 /// \ingroup lemon_io … … 585 561 private: 586 562 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); 593 570 594 571 DigraphReader(DigraphReader& other) … … 1211 1188 }; 1212 1189 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 1213 1221 template <typename Graph> 1214 1222 class GraphReader; 1215 1216 /// \brief Return a \ref GraphReader class 1217 /// 1218 /// This function just returns a \ref GraphReader class. 1219 /// \relates GraphReader 1223 1220 1224 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); 1230 1227 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); 1240 1229 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); 1245 1231 1246 1232 /// \ingroup lemon_io … … 1369 1355 1370 1356 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); 1375 1363 1376 1364 GraphReader(GraphReader& other) … … 2040 2028 2041 2029 }; 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 } 2042 2060 2043 2061 class SectionReader; 
lemon/lgf_writer.h
r327 r374 351 351 class DigraphWriter; 352 352 353 /// \brief Return a \ref DigraphWriter class354 ///355 /// This function just returns a \ref DigraphWriter class.356 /// \relates DigraphWriter357 353 template <typename Digraph> 358 354 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); 368 356 template <typename Digraph> 369 357 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 379 360 template <typename Digraph> 380 361 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 385 364 386 365 /// \ingroup lemon_io … … 527 506 private: 528 507 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); 535 517 536 518 DigraphWriter(DigraphWriter& other) … … 934 916 }; 935 917 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 936 951 template <typename Graph> 937 952 class GraphWriter; 938 953 939 /// \brief Return a \ref GraphWriter class940 ///941 /// This function just returns a \ref GraphWriter class.942 /// \relates GraphWriter943 954 template <typename Graph> 944 955 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); 954 957 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); 964 959 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); 969 961 970 962 /// \ingroup lemon_io … … 1082 1074 private: 1083 1075 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 1091 1086 GraphWriter(GraphWriter& other) 1092 1087 : _os(other._os), local_os(other.local_os), _graph(other._graph), … … 1534 1529 /// @} 1535 1530 }; 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 } 1536 1562 1537 1563 class SectionWriter; 
lemon/path.h
r317 r374 930 930 931 931 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 { 935 934 static void copy(Target& target, const Source& source) { 936 935 target.clear(); … … 942 941 943 942 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 { 945 953 static void copy(Target& target, const Source& source) { 946 954 target.clear(); … … 952 960 953 961 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> { 963 963 static void copy(Target& target, const Source& source) { 964 964 target.clear(); 965 965 target.buildRev(source); 966 966 } 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 } 967 983 }; 968 984 
lemon/random.h
r368 r374 345 345 }; 346 346 347 template <typename Result, int exp , bool pos = (exp >= 0)>347 template <typename Result, int exp> 348 348 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> {359 349 static const Result multiplier() { 360 350 Result res = ShiftMultiplier<Result, exp / 2>::multiplier(); … … 366 356 367 357 template <typename Result> 368 struct ShiftMultiplier<Result, 0 , true> {358 struct ShiftMultiplier<Result, 0> { 369 359 static const Result multiplier() { 370 360 return static_cast<Result>(1.0); … … 373 363 374 364 template <typename Result> 375 struct ShiftMultiplier<Result, 20, true> {365 struct ShiftMultiplier<Result, 20> { 376 366 static const Result multiplier() { 377 367 return static_cast<Result>(1.0/1048576.0); … … 380 370 381 371 template <typename Result> 382 struct ShiftMultiplier<Result, 32, true> {372 struct ShiftMultiplier<Result, 32> { 383 373 static const Result multiplier() { 384 return static_cast<Result>(1.0/42 4967296.0);374 return static_cast<Result>(1.0/4294967296.0); 385 375 } 386 376 }; 387 377 388 378 template <typename Result> 389 struct ShiftMultiplier<Result, 53, true> {379 struct ShiftMultiplier<Result, 53> { 390 380 static const Result multiplier() { 391 381 return static_cast<Result>(1.0/9007199254740992.0); … … 394 384 395 385 template <typename Result> 396 struct ShiftMultiplier<Result, 64, true> {386 struct ShiftMultiplier<Result, 64> { 397 387 static const Result multiplier() { 398 388 return static_cast<Result>(1.0/18446744073709551616.0); … … 414 404 415 405 static Result convert(RandomCore<Word>& rnd) { 416 return Shifting<Result,  shift rest>::406 return Shifting<Result, shift + rest>:: 417 407 shift(static_cast<Result>(rnd() >> (bits  rest))); 418 408 } … … 424 414 425 415 static Result convert(RandomCore<Word>& rnd) { 426 return Shifting<Result,  shift bits>::416 return Shifting<Result, shift + bits>:: 427 417 shift(static_cast<Result>(rnd())) + 428 418 RealConversion<Result, Word, restbits, shift + bits>::
Note: See TracChangeset
for help on using the changeset viewer.