OR-Tools – informacje o wersji

Na tej stronie znajdują się zmiany w Narzędziach LUB, w tym nowe funkcje, poprawki błędów oraz ulepszenia kodu i procedur instalacji.

Jeśli masz problemy z instalacją narzędzi OR-Tools, zapoznaj się z sekcją Rozwiązywanie problemów w instrukcjach instalacji narzędzi OR-Tools. Jeśli Twojego problemu nie ma na liście, sprawdź problemy na GitHubie lub otwórz nowy, a chętnie Ci pomożemy.

Poniżej znajdziesz informacje o wersji OR-Tools, zaczynając od najnowszej wersji.

Maj 2024 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.10

Udostępniliśmy OR-Tools wersji 9.10. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Informacje o wersji znajdziesz na github

Marzec 2024 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.9

Udostępniliśmy OR-Tools w wersji 9.9. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Informacje o wersji znajdziesz na github

Listopad 2023

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.8

Udostępniliśmy wersję 9.8 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Dodaj Pythona 3.12.
  • Dodanie obsługi Ubuntu 23.10

Rozwiązywanie funkcji liniowych

  • Port ModelBuilder do domeny .Net.
  • Zmień nazwę LogCallback na MbLogCallback, aby uniknąć kolizji z funkcją SAT LogCallback.
  • Interfejs Extend ModelBuilder API:
    • Dodaj ograniczenia dotyczące wskaźników.
    • Dodaj obsługę podpowiedzi.
    • Dodaj klonowanie modelu.

Optymalna funkcja matematyczna

  • Dogłębna refleksja.

Routing

  • Dodaj stan: ROUTING_OPTIMAL.
  • Ustaw plik RoutingModel jako niemożliwy do skopiowania ani przeniesienia.
  • Napraw pętlę nieskończoną w lokalnych operatorach wyszukiwania.
  • Dodaj strukturę wewnętrzną PickupDeliveryPosition.
  • Dodaj metody IsPickup() i IsDelivery().

SB

  • Zmniejsz ilość pamięci dla dużego modelu.
  • Ulepszone wyszukiwanie planowania.
  • dodaj packing_precedences_lns.
  • i poprawić skok wykonalności.
  • optymalizacja liniowa i usprawnienie logowania.
  • Popraw rozwiązanie int_abs, int_mod, int_prod i lin_max.
  • Ulepszanie obsługi Panda
  • Mało błędów.

Historia zmian na GitHubie

Sierpień 2023 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.7

Udostępniliśmy wersję 9.7 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Usuń Centos-8 (EOL).
  • Zrezygnuj z Debiana 10.
  • Upuszczaj fedorę [33, 36] (EOL).
  • Usuń Ubuntu 18.04 LTS (EOL).
  • Drop Python 3.7 (EOL).
  • Wyłącz obsługę netcore3.1 w CMake (EOL).

Pithon konstruktora modeli

  • Zezwalaj na używanie ramek danych i serii Pandas do tworzenia zmiennych.
  • Uzupełnij informacje podczas wpisywania

PDLP

  • różne aktualizacje.

CP-SAT

  • Poprawa wydajności. (feasibility_jump, lin_max)
  • Ulepszone zarządzanie cięciem
  • Nowa instancja robocza celu_shaving_search poświęcona polepszaniu dolnej granicy celu (przy minimalizowaniu)
  • Pisanie adnotacji do pliku cp_model.py w Pythonie
  • Eksperymentalna, częściowa obsługa pand w pliku cp_model.py
  • Eksperymentalni pracownicy korzystający z wyszukiwania lokalnego, którzy naruszają zasady:
    • włączona z parametrami: num_violation_ls:xxx
    • zoptymalizowany pod kątem modelu liniowego (linear, bool_or, bool_and, at_most_one, exactly_one)
    • działa poprawnie z atrybutami lin_max, product, podział;
    • obsługuje no_overlap, łącznie, obwód, trasy
    • wyłączono z powodu no_overlap_2d
    • zalecana liczba instancji roboczych ls: num_workers -> num_violation_ls: (8, 1), (16, 2) (24, 3), (32, 4)

Historia zmian na GitHubie

Marzec 2023 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.6

Udostępniliśmy wersję 9.6 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Dodaj obsługę systemu Fedora 37, 38.
  • Drop Python 3.6 (nieobsługiwany przez protobuf).
  • Upuszczaj Pythona 3.7 w macOS (nie jest obsługiwany przez scipy).
  • Dodaj obsługę net7.0 w CMake (użyj -DUSE_DOTNET_7=ON)
  • Usuń netcore3.1 w pakietach nuget .org

Zależności

  • SCIP v801 -> v803 (uwaga: teraz SCIP korzysta z licencji zgodnej z OSI)
  • 20220623.1 -> 20230105.0
  • Protobuf v21.5 -> v21.12
  • WYŁĄCZ 4.1.1
  • Java JNA 5.11.0 -> 5.12.1

Bazel

  • Dodaj obsługę atrybutu pybind11.
  • Dodaj obsługę otoki Java.

Rozwiązania matematyczne

  • PDLP: otoka dd Pythona.
  • CP-SAT: Poprawa wydajności.
  • GLOP: ulepszenie rozwiązania.
  • ModelBuilder: Python: ulepszenie obsługi numpy.
  • Routing: poprawa skuteczności (wyszukiwanie lokalne)

Znane problemy:

  • CP-SAT: ignorowanie parametru pseudo_costs zwraca nieprawidłowe parametry (patrz #3706).

Listopad 2022 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.5

Udostępniliśmy wersję 9.5 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Dodano obsługę systemu Debian Sid.
  • Dodaj obsługę systemu Fedora 35, 36.
  • Dodanie obsługi Ubuntu 22.10.
  • Dodaj Python 3.6 w macOS.
  • Dodaj obsługę języka Python 3.11.

Aktualizacja zależności

  • Protobuf v19.4 -> v21.5.
  • Rozwiązanie SCIP: v800 -> v801.

CP-SAT

  • Rozwiązuj ulepszenia: max(tablica), ograniczenia logiczne, ograniczenia liniowe.
  • Wyszukiwanie przeplatane powinno być jednocześnie deterministyczne.
  • Cięcie linearne: czyszczenie kwadratowe i cięcia int_prod; przepisywanie potoku cięcia.
  • Model wprowadzania odcisku palca i rozwiązanie (widoczne w logu).
  • Ulepszone planowanie.
  • Typowe poprawki błędów (awarie podczas rozwiązywania problemów, awarie przy cięćach, niemożliwe rozwiązania, model niemożliwy do wykonania w LNS).

GLOP

  • Przyspieszenie przez przepisanie algebry liniowej oraz reguły wyboru tabeli przestawnej.

Rozwiązywanie funkcji liniowych

  • Dodaj knapsack_interface.cc.
  • Przenieś interfejs API model_builder do katalogu linear_solver (nagłówki i przykłady).
  • Dodano obsługę Gurobi 10.

Routing

  • Uwolnienie kilku parserów do obsługi różnych wyzwań związanych z routingiem.

Sierpień 2022 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.4

Udostępniliśmy wersję 9.4 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Platformy

  • Dodaj obsługę Debian-10 (patrz #3029).
  • Dodaj obsługę języka Ubuntu 22.04 LTS (patrz #3276). Uwaga: system nie obsługuje domen .Net 3.1 (patrz dotnet/core#7038).
  • Usunięcie obsługi Ubuntu 21.10.

Inne

  • Podziel archiwum według języków i dodaj konfigurację CMake do pliku C++ (nr 3200).

Wykres

Podziel ortools.graph.pywrapgraph na:

  • ortools.graph.python.linear_sum_assignment.
  • ortools.graph.python.max_flow.
  • ortools.graph.python.min_cost_flow.

Dzięki temu możesz użyć numpy, aby przyspieszyć rozwiązywanie problemów.

CP-SAT

Kilka ulepszeń:

  • harmonogram (propagacja, cięcia, dolne granice).
  • MaxSAT (rozstrzygnięcie, heurystyka oparta na podstawowej).
  • Wydajność MIP (rozwiązanie, cięcia).

Marzec 2022 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.3

Udostępniliśmy wersję 9.3 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Zrezygnuj z obsługi Debian-10.
  • Zrezygnuj z obsługi Ubuntu-16.04.
  • Usuń .NET Framework 4.5.2.

Aktualizacja zależności

  • Dodaj Eigen 3.4.0.
  • Dodaj Google re2 2021-11-01.
  • Protobuf 3.19.1 -> 3.19.4.
  • SCIP 7.0.1 -> v800.

Python

  • Dodaj pybind11.

Funkcje

  • Dodaj PDLP jako eksperyment.
  • Dodaj funkcję MathOpt jako eksperyment.

CP-SAT

  • W celu zachowania spójności zmieniliśmy nazwy kilku interfejsów API, np. LinearExpr.ScalProd. -> LinearExpr.WeightedSum..
  • Dodaj metody AddAtLeastOne/AddAtMostOne/AddExactlyOne.
  • Dodaj AddMultiplicationConstraint(z, x, y) we wszystkich językach.
  • Dodaj AddMultipleCircuit() we wszystkich językach.

C++

  • Wyraźny wektor IntVar(BoolVar).
  • Usunięto funkcję LinearExpr::Add* i zastąpiono ją operatorem, np. LinearExpr +=.
  • Dodaj operatory arytmetyczne dla wyrażenia liniowego.
  • Usunięto LinearExpr::BooleanSum/BooleanScalProd. Użyj pola Sum/WeightedSum.
  • Dodaj zmienną CpModelBuilder::FixVariable(), aby zastąpić domenę zmiennej jedną wartością.

Java

  • Przepisz atrybut LinearExpr i dodaj stopniową klasę montera: LinearExpr.newBuilder().add(x).addSum(<array of variables>).build().
  • Obserwowanie interfejsu API w C++: Circuit, MultipleCircuit, Cumulative, Reservoir, AllowedAssignment i ForbiddenAssignment zwracają teraz specjalistyczną klasę z przyrostowym interfejsem API, aby dodawać nowe zmienne, warunki, żądania...

C

  • Udokumentuj wszystkie metody.
  • Obserwowanie interfejsu API w C++: Circuit, MultipleCircuit, Cumulative, Reservoir, AllowedAssignment i ForbiddenAssignment zwracają teraz specjalistyczną klasę z przyrostowym interfejsem API, aby dodawać nowe zmienne, warunki, żądania...
  • Dodaj klasę LinearExprBuilder, aby stopniowo tworzyć wyrażenia.

System kompilacji

CMake

  • Minimalna wartość CMake to 3,18.

Twórz

  • Teraz użyj wewnętrznie kompilacji opartej na CMake.

Grudzień 2021 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.2

Udostępniliśmy wersję 9.2 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Dodaliśmy obsługę systemu Ubuntu 21:10 (ostatnia wersja krocząca).

Aktualizacja zależności

  • Aktualizacja .Net TFM net5.0 -> net6.0 (potrzebny jest pakiet .Net SDK 6.0 LTS i .Net SDK 3.1 LTS).
  • abseil-cpp 20210324.2 -> 20211102.0.
  • Protobuf 3.18.0 -> 3.19.1
  • Googletest 1.10.0 -> 1.11.0
  • Python: dodaj numpy >= 1.13.3.
  • W systemie macOS kompiluj Coin-OR w -O1, aby uniknąć awarii aplikacji uruchamiających.

Routing

  • Ulepszenia filtrów.
  • Popraw heurystykę pierwszego rozwiązania.
  • Ulepszenie miejsc na przerwy czasowe.

CP-SAT

Zmiany powodujące niezgodność

  • Bazowy bufor protokołu jest niezgodny z poprzednimi wersjami. Każdy przechowywany bufor protokołów trzeba będzie ponownie wygenerować przy użyciu zaktualizowanych interfejsów API kreatora (w językach C++, Python, Java i .NET)
  • W szczególności został wyczyszczony protokół odstępów, ponieważ usunęliśmy stare pola (start, rozmiar i koniec) i zmieniliśmy nazwy nowych (za pomocą _view), tak aby używały nazw usuniętych pól.

Nowe funkcje

  • Ograniczenia all_different, reservoir, modulo, multiplication i division akceptują wyrażenia afiniczne (a * var + b) wszędzie tam, gdzie wymagane były zmienne całkowite.
  • Cel akceptuje współczynniki zmiennoprzecinkowe (zapoznaj się z klasą DoubleLinearExpr w języku C++/Java/.NET. Zobacz przykład knapsack_2d_sat.py w Pythonie).
  • Ograniczenie no_overlap_2d obsługuje opcjonalne odstępy.
  • Interfejs C++ API implementuje operatory + i * do tworzenia wyrażeń.

Ulepszenia

  • Ulepszony kod rozwiązania.
  • Możliwość dokładniejszego sprawdzania modeli.
  • Zmień ograniczenie dotyczące zbiornika.
  • Dodaj cięcia energetyczne do ograniczenia no_overlap_2d.
  • Ulepszone liniowe złagodzenie ograniczeń kodowania (literal implies var == value).

Wycofane i usunięte metody

  • Wycofane wersje C++ BooleanSum i BooleanScalProd. Używaj tylko Sum i ScalProd.
  • Elementy C++ AddLinMinEquality i AddLinMaxEquality zostały usunięte. Używaj tylko AddMinEquality i AddMaxEquality.

Przyszłe niezgodności

  • Kiedyś w przyszłości zmienimy warstwę modelowania Javy tak, aby była bardziej zbliżona do warstwy C++.
  • W warstwie modelowania C++ wektor IntVar(BoolVar var) będzie jawny.
  • Rozważamy zapewnienie zgodności interfejsu API Pythona z PEP 8 (z użyciem nazw snake_case). W takim przypadku udostępnimy plik sed do przeniesienia kodu.

System kompilacji

Bazel

  • Popraw kompilację dla systemu Windows.

CMake

  • Dodaj opcję FETCH_PYTHON_DEPS (domyślnie ON).
  • Dodaj opcjonalną obsługę rozwiązania z GPL (domyślnie -DUSE_GLPK=OFF).

Python

  • Obsługuj liczby całkowite (numpy) w większości interfejsu API CP-SAT.
  • Rozwiąż problem z brakującym elementem __version__.

Wrzesień 2021 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.1

Udostępniliśmy wersję 9.1 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Python: użyj obrazu manylinux2014 (patrz PEP 599).
  • Python: dodanie obsługi systemu Linux aarch64 przy użyciu obrazu manylinux2014_aarch64.
  • .Net: dodaj obsługę .Net 5.0.

Aktualizacja zależności

  • abseil-cpp 20210324.1 -> 20210324.2.
  • Protobuf 3.15.8 -> 3.18.0
  • SCIP 7.0.1 -> master.
  • Googletest 1.8.0 -> 1.10.0
  • python: użycie warning w cp_model.py (patrz #2530).
  • python: absl-py 0,11 -> 0,13.

CMake

  • Minimalna wymagana wersja aplikacji to 3.14 -> 3.15 (patrz #2528).
  • Python: zwiększ minimalną wymaganą wersję 3.14 -> 3.18 (patrz #2774).

Twórz

Kompilacja oparta na modelu „make” została wycofana. Przejdź na CMake lub Bazel, aby kompilować ze źródła.

Java

  • Popraw solidność ładowania biblioteki natywnej (patrz #2742).
  • Naprawianie awarii modułu JVM Garbage Collector podczas usuwania modelu routingu lub rozwiązania ograniczeń (patrz #2091) (patrz #2466).
  • Naprawianie błędu wywołania zwrotnego logowania CP-SAT podczas korzystania z wielu instancji roboczych (patrz #2775).

CP-SAT

  • Zwiększ solidność kodu LNS (patrz #2525).
  • Ulepszenie kodu planowania: nowe metody fabryczne tworzenia przedziałów o stałej wielkości, nowa heurystyka wyszukiwania, ulepszona strategia ustalania stawek i nowe cięcia linearne.
  • Popraw kod routingu: nowe dedykowane sieci LNS.
  • Ulepszanie sprawdzania modelu. Jest teraz bardziej pedantyczna, zwłaszcza w części potencjalnych.
  • Ulepszenie kodu MIP: lepsze rozwiązanie i wiele usprawnień liniowego złagodzenia modeli MIP i CP.
  • Większa różnorodność w wyszukiwarce Jeśli używasz więcej niż 12 instancji roboczych, dodaj instancje robocze dedykowane poprawianiu dolnej granicy celu.
  • Zmień na kod równoległości: domyślnie rozwiązanie będzie używać wszystkich dostępnych rdzeni. Aby określić poziom paralelizmu, użyj właściwości num_search_parameters.
  • Wycofaj: SearchAllSolutions i SolveWithSolutionCallback.
  • Python API: bardziej pedantyczne testy, jeśli używasz var == ... lub var != ... poza wywołaniem model.Add().

Kwiecień 2021 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 9.0

Udostępniliśmy OR-Tools wersji 9.0. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Aktualizacje zależności

  • Plik Abseil-cpp 20200923.3 został zaktualizowany do wersji 20210324.1 LTS.
  • Protobuf 3.15.3 zaktualizowany do wersji 3.15.8.
  • Java: jna-platform 5.5.0 zaktualizowane do 5.8.0

Java

Poprawione błędy

  • Popraw wielowątkowość podczas korzystania z rozwiązania CP-SAT (patrz #1588).
  • Popraw obsługę otoki Pythona w przypadku std::vector&ltstd::string&gt (patrz nr 2453).
  • Przerobienie pomocy CPLEX (patrz #2470).

Znana zmiana powodująca niezgodność

  • Dodaj dostęp rejestratora w językach Python, Java i .Net (patrz #2245).
  • Zastępowanie wszystkich niestandardowych typów Google tymi podanymi w: cstdint.

CP-SAT

  • Metody SearchForAllSolutions(), SearchAllSolutions() i SolveWithSolutionCallback() zostały wycofane. Zamiast nich używaj elementu Solve().
  • Ulepsz obsługę standardowych operatorów Pythona. Może to spowodować uszkodzenie nieprawidłowego istniejącego kodu.

Marzec 2021 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 8.2

Udostępniliśmy wersję 8.2 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Aktualizacje zależności

  • Plik Abseil-cpp 20200923.2 został zaktualizowany do wersji 20200923.3 LTS.
  • Protobuf 3.14.0 do wersji 3.15.3.

Routing

  • Dodano RoutingModel.RegisterTransitMatrix() i RoutingModel.RegisterUnaryTransitVector().
  • Zmień wartość zwrotu produktów RoutingModel.AddVectorDimension() i RoutingModel.AddMatrixDimension() na std::pair&ltint, bool&gt, której int to identyfikator osoby, która ocenia transport publiczny.

Grudzień 2020 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 8.1

Udostępniliśmy wersję 8.1 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Aktualizacje zależności

  • Abseil-cpp 20200923 zaktualizowany do wersji 20200923.2 LTS.
  • Protobuf 3.13.0 (zaktualizowano do 3.14).
  • Dodaj obsługę Gurobi 9.1.0
  • Porzuć zależność GLog (zastępowana przez niestandardową implementację w zależności od flag abseil-cpp)
  • Porzuć zależność GFlag (zastąpiona komponentem flag abseil-cpp)

Poprawione błędy

  • Popraw podwójne zliczanie licencji pływającej Gurobi (zobacz #2227).
  • Napraw kompilację systemu Windows (patrz #2200).

październiku 2020 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 8.0

Udostępniliśmy OR-Tools w wersji 8.0. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Dodano obsługę Pythona 3.9 (#2187).
  • Wycofanie obsługi Pythona 3.5 (#2186) <!-- Oczekiwanie na obsługę pakietu Microsoft dotnet-sdk; możliwe do wygenerowania po opublikowaniu wersji...
    • Dodano obsługę Ubuntu 20.10 (#2188) -->
  • Wycofanie obsługi Ubuntu 16.04 LTS (#2188)
  • Wycofanie obsługi Ubuntu 19.10 (#2188)

Aktualizacje zależności

Znana zmiana powodująca niezgodność

  • Obecnie routing i kod źródłowy CP-SAT korzystają z niektórych funkcji C++17. Uwaga: jeśli udostępniasz własną wersję abseil-cpp, sprawdź, czy została ona również skompilowana przy użyciu protokołu C++17.
  • Podpis MPSolver::CreateSolver został zmieniony. Argument nazwy modelu został usunięty.

CMake

  • Rozwiąż problem z wyłączeniem obsługi SCIP podczas korzystania z -DUSE_SCIP=OFF (patrz #2129).
  • Zintegruj przykłady i przykłady z systemem kompilacji CMake. Uwaga: można wyłączyć za pomocą -DBUILD_SAMPLES=OFF i -DBUILD_EXAMPLES=OFF. uwaga: można wyłączyć dla konkretnego języka za pomocą właściwości -DBUILD_<LANG>_SAMPLES=OFF lub -DBUILD_<LANG>_EXAMPLES=OFF.
    • <LANG> wśród:
    • CXX,
    • PYTHON,
    • JAVA i
    • DOTNET.

Twórz

  • Wymagaj Make >= 4.3 (użycie funkcji eval).
  • Wymagaj CMake >= 3.14 (użycie CMake --verbose).
  • Dodaj opcję wyłączania obsługi SCIP za pomocą -DUSE_SCIP=OFF (patrz nr 2134).
  • Dodaj opcję wyłączania obsługi CLP i CBC za pomocą elementu -DUSE_COINOR=OFF.

Java

  • LUB-Narzędzia generują teraz pakiety Maven (patrz #202).

Poprawione błędy

  • Popraw kompilację C++ i Pythona na FreeBSD (patrz #2126).
  • Naprawianie debugowania kompilacji w systemie Windows (patrz #2077).
  • Naprawianie wieloletniej awarii równolegle na CP-SAT w systemie Windows (patrz #2001, 2019).

Lipiec 2020 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 7.8

Udostępniliśmy wersję 7.8 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Aktualizacje zależności

  • Gurobi 9.0.2 jest teraz wstępnie zintegrowany z gotowymi plikami binarnymi. Wyszuka udostępnione zasoby gurobi 90 w domyślnej ścieżce instalacji instalatorów Gurobi w systemie MAC OS X i Windows lub w katalogu GUROBI_HOME.
  • Standard SCIP 7.0.1 jest teraz zintegrowany z gotowymi plikami binarnymi. Przed użyciem upewnij się, że jest ona zgodna z licencją SCIP.
  • Dodaliśmy obsługę opcjonalnego rozwiązania Xpress Solver w wersji 8.9.0.

Rozwiązywanie funkcji liniowych

  • Dodaliśmy statyczną metodę LinearSolver::CreateSolver(), aby uprościć sprawdzanie obsługi zintegrowanych backendów rozwiązań liniowych. Działa we wszystkich językach.

Poprawione błędy

  • Poprawiono kompilację opartą na CMake na bazie FreeBSD.
  • Naprawiono sortowanie CP-SAT w generowaniu skumulowanego cięcia.
  • Naprawiono wyciek pamięci w rozwiązaniu liniowym w otoce .Net.

cze 2020

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 7.7

Udostępniliśmy wersję 7.7 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Aktualizacje zależności

  • Abseil-cpp b832dce został zaktualizowany do c51510d (LTS 20200225.2).
  • Protobuf 3.11.4 zaktualizowany do 3.12.2.

Nowe funkcje i ulepszenia

  • Rozwiązanie CP-SAT zwraca teraz wartość Optimal zamiast Feasible w modelu spełnienia warunków (tj. bez celu).
  • Dodaliśmy heurystyczną pompy wykonalności ze społeczności MIP.

Poprawione błędy

Usunięto awarię wielowątkowości CP-SAT (patrz #2005).

Kwiecień 2020 roku

Przedstawiamy wersję 7.6 OR-Tools

Udostępniliśmy wersję 7.6 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Nowe funkcje w CP-SAT

Do rozwiązania CP-SAT dodaliśmy te nowe funkcje:

  • Ulepszone zarządzanie płaszczyznami obróbki metali.
  • Narzędzia do debugowania.

Aktualizacje zależności

Kod Abseil-cpp 8ba96a8 został zaktualizowany do wersji b832dce (LTS 20200225).

Poprawione błędy

  • Naprawiliśmy błąd CP-SAT UNSAT w rozwiązaniu problemu (patrz #1908).
  • Poprawiono adres URL pliku swigwin.exe.
  • Poprawiono zarządzanie mapą typów SWIG dla domen Java i .Net.

Styczeń 2020 r.

Przedstawiamy wersję 7.5 OR-Tools

Udostępniliśmy wersję 7.5 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Dodano obsługę Pythona 3.8 (#1719).
  • Usunięto kompilację obsługi ze źródeł w Visual Studio 2017 (#1852).
  • Zaktualizowano obsługę Centos 7 do Centos 8 (#1827).

Aktualizacja zależności

  • protobuf w wersji 3.10.0 (aktualizacja do wersji 3.11.2) (#1829).

Poprawione błędy

Poniższe problemy zostały naprawione w OR-Tools w wersji 7.5 (pełną listę znajdziesz w Milestone w wersji 7.5).

W szczególności:

  • Naprawiono ładowanie montażu. Patrz: #1421.
  • Ujawniono metody GetStartIndex() i GetEndIndex() obiektu RouteIndexManager (#1843).
  • Naprawiliśmy SWIG, aby usuwać uszkodzone metody (#1838, #1276).

październiku 2019 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 7.4

Udostępniliśmy wersję 7.4 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Nowe funkcje i ulepszenia

  • Rozwiązanie CP-SAT sprawdza teraz ograniczenia, które nie obsługują literałów egzekwowania zasad. Jeśli takie ograniczenie ma literał egzekwowania, narzędzie do sprawdzania modelu zwróci błąd przed rozwiązaniem.
  • Lepsze i szybsze wyszukiwanie lokalne w bibliotece tras.
  • Rozwiązanie liniowe obsługuje teraz oprogramowanie innej firmy Xpress-MP. Aby go użyć, musisz ponownie utworzyć narzędzie OR-Tools ze źródła.
  • Architektura pakietu NuGet została całkowicie napisana od nowa. Szczególnie obsługuje teraz platformę .NET Framework >= 4.5.2 na platformach Windows.

Platforma wycofana

zgodnie z informacjami o wersji z lipca 2019 r., OR-Tools nie obsługuje już Pythona 2.7.

Aktualizacja zależności

Protobuf 3.9.0 został zaktualizowany do wersji 3.10.0.

Sierpień 2019 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 7.3

Udostępniliśmy wersję 7.3 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Platforma wycofana

Wycofujemy obsługę Pythona 2.7, aby dostosować ją do przejścia Google na Pythona 3. To będzie ostatnia wersja narzędzi OR-Tools obsługujących Pythona 2.7.

Aktualizacja zależności

Protobuf 3.8.0 został zaktualizowany do wersji 3.9.0.

Poprawione błędy

Poniżej rozwiązaliśmy następujące problemy w wersji 7.3 OR-Tools. (Pełną listę znajdziesz w Kanban w wersji 7.3).

W szczególności:

  • Naprawiony problem z przesyłaniem inicjowania/int64 w Javie (#1448),
  • Naprawiono sprawdzanie końcowe podczas przetwarzania pustych ograniczeń skumulowanych.

Lipiec 2019 r.

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 7.2

Udostępniliśmy wersję 7.2 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany platformy

  • Wycofujemy obsługę Pythona 2.7, aby dostosować ją do przejścia Google na Pythona 3. Wkrótce udostępnimy jeszcze maksymalnie 1 wersję narzędzi LUB obsługujących Pythona 2.7.
  • Ubuntu 18.10 został zaktualizowany do wersji 19.04.
  • W Visual Studio 2019 dodaliśmy obsługę kompilacji ze źródeł.
  • Python 3.5 nie jest już obsługiwany w systemie Windows. Użyj języka Python w wersji 3.6 lub nowszej.

Aktualizacje zależności

  • Obecnie kierujemy reklamy na CBC w wersji 2.10.3.
  • Obecnie kierujemy reklamy na Protobuf w wersji 3.8.0.

CP-SAT

  • Wprowadziliśmy wiele ulepszeń w obszarze wyszukiwania, równoległości i relacji liniowej.
  • Dodano interfejsy API LinearExpr.Sum() i LinearExpr.ScalProd() w Pythonie.
  • Wycofano interfejsy API IntVar[].Sum() i IntVar[].ScalProd() w języku C#.
  • C++: usunięto SolveWithModel(), ponieważ był on duplikatem SolveCpModel().
  • Dodano metody CpModel.addGreaterThan() i CpModel.addLessThan() do interfejsu Java API.

Rozwiązanie liniowe

  • Dodano MPSolver.SetHint() dla Pythona, Javy i C# (obsługiwane przez SCIP i Gurobi).
  • Dodano MPSolver.SetNumThreads() dla Pythona, Javy i C# (obsługiwany przez CBC, Gurobi i SCIP).
  • Ulepszyliśmy obsługę SCIP 6.0.1.

Dokumentacja źródłowa

  • Dodaliśmy podręczniki oparte na doxygen i pdoc3 dla wszystkich języków i wszystkich narzędzi (algorytmy, routing, graf, linear_solver i CP-SAT). Zobacz instrukcje dotyczące instrukcji OR-Tools.
  • Pełną dokumentację na temat C++ (wszystkie produkty) i CP-SAT (C++, Python, Java) znajdziesz
  • Jesteśmy w trakcie eksportowania całej dokumentacji C++ do Pythona i Javy.
  • Brakuje dokumentacji .NET i w najbliższej przyszłości nie mamy rozwiązania, które pozwoliłoby nam to ulepszyć. Zachowajmy go, ponieważ nadal wyświetla dostępny interfejs API.

Maj 2019 roku

Ogłaszamy udostępnienie narzędzi OR-Tools w wersji 7.1

Udostępniliśmy wersję 7.1 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany w wymaganych zależnościach

W OR-Tools w wersji 7.1 pojawiły się nowe i zaktualizowane zależności:

  • glog w wersji 0.3.5 (zaktualizowano do wersji 0.4.0)
  • protobuf w wersji 3.6.1 (aktualizacja do 3.7.1)
  • Cbc 2.9.9 w wersji 2.10.1
  • Cgl 0.59.10 zaktualizowana do 0.60.1
  • Clp 1.16.11 zaktualizowany do 1.77.1
  • Osi 0.107.9 zaktualizowana do 0.108.1
  • CoinUtils 2.10.14 (aktualizacja do 2.11.1).

Zmiany w interfejsie API CP-SAT

W kolejnych sekcjach opisano zmiany w interfejsie CP-SAT API w OR-Tools 7.1.

Tworzenie zmiennych za pomocą domeny

W podanych niżej przykładach pokazujemy, jak utworzyć zmienną liczby całkowitej z domenami nieprzylegającymi do siebie. Zastąpi to usuniętą metodę NewEnumeratedIntVar(). W tym przypadku zmienna x może mieć dowolną z wartości 1, 3, 4 lub 6:

Python

model.NewIntVarFromDomain(cp_model.Domain.FromValues([1, 3, 4, 6]), 'x')

C++

model.NewIntVar(Domain::FromValues({1, 3, 4, 6}));

Java

model.newIntVarFromDomain(Domain.fromValues(new long[] {1, 3, 4, 6}), "x");

C#

model.NewIntVarFromDomain(Domain.FromValues(new long[] {1, 3, 4, 6}), "x");

Zmienne można też tworzyć za pomocą listy przedziałów. Poniżej zmienna x jest ograniczona do wartości 1, 2, 4, 5 lub 6:

Python

model.NewIntVarFromDomain(cp_model.Domain.FromIntervals([[1, 2], [4, 6]]), 'x')

C++

model.NewIntVar(Domain::FromIntervals({ {1, 2}, {4, 6} }));

Java

model.newIntVarFromDomain(Domain.fromIntervals(new long[][] { {1, 2}, {4, 6} }), "x");

C#

model.NewIntVarFromDomain(Domain.FromIntervals(new long[][] { new long[] {1, 2}, new long[] {4, 6} }), "x");

Użycie domeny w wyrażeniu liniowym

Poniższe przykłady pokazują, jak ograniczyć wyrażenie liniowe w domenie, która nie jest sąsiadująca z domeną. W tym przypadku wyrażenie liniowe linear_expr jest zdefiniowane w punktach 5, 6, 8, 9 i 10:

Python

model.AddLinearExpressionInDomain(linear_expr, cp_model.Domain.FromIntervals([(5, 6), (8, 10)]))

C++

model.AddLinearConstraint(linear_expr, Domain::FromIntervals({ {5, 6}, {8, 10} }))

Java

model.addLinearExpressionInDomain(linear_expr, Domain.fromIntervals(new long[][] { {5, 6}, {8, 10} }))

.Net

model.AddLinearExpressionInDomain(linear_expr, Domain.FromIntervals(new long[][] {new long[] {5, 6}, new long[] {8, 10} }));

Korzystanie z pomocników wyrażeń liniowych

W przykładach poniżej pokazujemy, jak używać metod pomocniczych do tworzenia sum i iloczynów skalarnych. Oto przykłady pól x + y == 20 i 4 * x + 2 * y = 56:\

Python

model.Add(x + y == 20)
model.Add(4 * x + 2 * y == 56)

C++

cp_model.AddEquality(LinearExpr::Sum({x, y}), 20);
cp_model.AddEquality(LinearExpr::ScalProd({x, y}, {4, 2}), 56);

Java

model.addEquality(LinearExpr.sum(new IntVar[] {x, y}), 20);
model.addEquality(LinearExpr.scalProd(new IntVar[] {x, y}, new long[] {4, 2}), 56);

.Net

model.Add(x + y == 20);
model.Add(4 * x + 2 * y == 56);

Marzec 2019 r.

Przedstawiamy wersję 7.0 OR-Tools

Udostępniliśmy wersję 7.0 OR-Tools. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zmiany dotyczące obsługiwanych platform

OR-Tools w wersji 7.0 nie obsługuje już następujących platform:

  • Visual C++ 2015
  • Ubuntu 14.04
  • Python 3.4 w systemie Linux

Jeśli używasz jednej z tych platform, możesz zainstalować OR-Tools w wersji 6.10.

Zmiany w wymaganych zależnościach

W OR-Tools w wersji 7.0 pojawiły się nowe i zaktualizowane zależności:

W kolejnych sekcjach opisano nowe funkcje i ulepszenia dostępne w OR-Tools w wersji 7.0.

Nowy menedżer indeksu dla programów do routingu

W OR-Tools w wersji 7.0 programy do wyznaczania tras pojazdów muszą korzystać z nowej wersji RoutingIndexManager. Zapewnia to spójność standardowych indeksów dla lokalizacji z indeksami wewnętrznymi używanymi przez funkcję rozwiązania i pomaga zapobiegać błędom w kodzie.

Nowa wersja RoutingIndexManager wymaga kilku drobnych zmian w programach do wyznaczania tras, które zostały opisane w tych sekcjach:

Uwzględnij/zaimportuj: RoutingIndexManager

W OR-Tools 7.0 programy do routingu w językach C++ i Java muszą zawierać lub importować parametr RoutingIndexManager, jak pokazano w tych przykładach:

C++

#include "ortools/constraint_solver/routing_index_manager.h"

Java

import com.google.ortools.constraintsolver.RoutingIndexManager;

Importy w Pythonie i C# pozostają niezmienione.

Zadeklaruj: RoutingIndexManager

W OR-Tools w wersji 7.0 programy do routingu muszą zadeklarować RoutingIndexManager i utworzyć model routingu, jak pokazano w tych przykładach:

Python

manager = pywrapcp.RoutingIndexManager(num_locations, num_vehicles, depot)
routing = pywrapcp.RoutingModel(manager)

C++

RoutingIndexManager manager(num_locations, num_vehicles, depot);
RoutingModel routing(manager);

Java

RoutingIndexManager manager = new RoutingIndexManager(numLocations, numVehicles, depot);
RoutingModel routing = new RoutingModel(manager);

.Net

RoutingIndexManager manager = new RoutingIndexManager(numLocations, numVehicles, depot);
RoutingModel routing = new RoutingModel(manager);

Argumenty funkcji RoutingIndexManager:

  • Liczba lokalizacji
  • liczbę pojazdów,
  • Indeks (lokalizacja początkowa i końcowa wszystkich pojazdów).

Wywołania zwrotne

W LUB-Tools w wersji 7.0 musisz używać RoutingIndexManager do tworzenia wywołań zwrotnych, np. odległości od użytkownika, które następnie przekazujesz do rozwiązania. Z przykładów poniżej dowiesz się, jak utworzyć wywołanie zwrotne odległości.

Python

    def distance_callback(from_index, to_index):
        """Returns the distance between the two nodes."""
        # Convert from routing variable Index to distance matrix NodeIndex.
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return data["distance_matrix"][from_node][to_node]

    transit_callback_index = routing.RegisterTransitCallback(distance_callback)
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

C++

  const int transit_callback_index = routing.RegisterTransitCallback(
      [&data, &manager](const int64_t from_index,
                        const int64_t to_index) -> int64_t {
        // Convert from routing variable Index to distance matrix NodeIndex.
        const int from_node = manager.IndexToNode(from_index).value();
        const int to_node = manager.IndexToNode(to_index).value();
        return data.distance_matrix[from_node][to_node];
      });
  routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index);

Java

    final int transitCallbackIndex =
        routing.registerTransitCallback((long fromIndex, long toIndex) -> {
          // Convert from routing variable Index to user NodeIndex.
          int fromNode = manager.indexToNode(fromIndex);
          int toNode = manager.indexToNode(toIndex);
          return data.distanceMatrix[fromNode][toNode];
        });
    routing.setArcCostEvaluatorOfAllVehicles(transitCallbackIndex);

.Net

        int transitCallbackIndex = routing.RegisterTransitCallback((long fromIndex, long toIndex) =>
                                                                   {
                                                                       // Convert from routing variable Index to
                                                                       // distance matrix NodeIndex.
                                                                       var fromNode = manager.IndexToNode(fromIndex);
                                                                       var toNode = manager.IndexToNode(toIndex);
                                                                       return data.DistanceMatrix[fromNode, toNode];
                                                                   });
        routing.SetArcCostEvaluatorOfAllVehicles(transitCallbackIndex);

Metoda IndexToNode konwertuje wewnętrzne indeksy lokalizacji używane przez łącznik na standardowe indeksy macierzy odległości.

Zamiast przekazywać wywołanie zwrotne bezpośrednio do rozwiązania, tak jak w poprzednich wersjach, w wersji 7.0 najpierw należy utworzyć odwołanie transit&nbsp;callback&nbsp;index do wywołania zwrotnego i przekazać je do rozwiązania (w tym przypadku za pomocą SetArcCostEvaluatorOfAllVehicles).

Wymiary

W podanych niżej przykładach pokazujemy, jak utworzyć wymiar dotyczący zapotrzebowania i pojemności, który służy do rozwiązywania problemu z wyznaczaniem tras pojazdów.

Python

    def demand_callback(from_index):
        """Returns the demand of the node."""
        # Convert from routing variable Index to demands NodeIndex.
        from_node = manager.IndexToNode(from_index)
        return data["demands"][from_node]

    demand_callback_index = routing.RegisterUnaryTransitCallback(demand_callback)
    routing.AddDimensionWithVehicleCapacity(
        demand_callback_index,
        0,  # null capacity slack
        data["vehicle_capacities"],  # vehicle maximum capacities
        True,  # start cumul to zero
        "Capacity",
    )

C++

  const int demand_callback_index = routing.RegisterUnaryTransitCallback(
      [&data, &manager](const int64_t from_index) -> int64_t {
        // Convert from routing variable Index to demand NodeIndex.
        const int from_node = manager.IndexToNode(from_index).value();
        return data.demands[from_node];
      });
  routing.AddDimensionWithVehicleCapacity(
      demand_callback_index,    // transit callback index
      int64_t{0},               // null capacity slack
      data.vehicle_capacities,  // vehicle maximum capacities
      true,                     // start cumul to zero
      "Capacity");

Java

    final int demandCallbackIndex = routing.registerUnaryTransitCallback((long fromIndex) -> {
      // Convert from routing variable Index to user NodeIndex.
      int fromNode = manager.indexToNode(fromIndex);
      return data.demands[fromNode];
    });
    routing.addDimensionWithVehicleCapacity(demandCallbackIndex, 0, // null capacity slack
        data.vehicleCapacities, // vehicle maximum capacities
        true, // start cumul to zero
        "Capacity");

.Net

        int demandCallbackIndex = routing.RegisterUnaryTransitCallback((long fromIndex) =>
                                                                       {
                                                                           // Convert from routing variable Index to
                                                                           // demand NodeIndex.
                                                                           var fromNode =
                                                                               manager.IndexToNode(fromIndex);
                                                                           return data.Demands[fromNode];
                                                                       });
        routing.AddDimensionWithVehicleCapacity(demandCallbackIndex, 0, // null capacity slack
                                                data.VehicleCapacities, // vehicle maximum capacities
                                                true,                   // start cumul to zero
                                                "Capacity");

Rozwiązania dotyczące drukowania

W OR-Tools w wersji 7.0 musisz użyć RoutingIndexManager, aby wyświetlić w rozwiązaniu trasy pojazdu. Poniższe przykłady pokazują, jak drukować rozwiązania we wszystkich obsługiwanych językach.

Python

def print_solution(manager, routing, solution):
    """Prints solution on console."""
    print(f"Objective: {solution.ObjectiveValue()}")
    index = routing.Start(0)
    plan_output = "Route for vehicle 0:\n"
    route_distance = 0
    while not routing.IsEnd(index):
        plan_output += f" {manager.IndexToNode(index)} ->"
        previous_index = index
        index = solution.Value(routing.NextVar(index))
        route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)
    plan_output += f" {manager.IndexToNode(index)}\n"
    plan_output += f"Distance of the route: {route_distance}m\n"
    print(plan_output)

C++

//! @brief Print the solution
//! @param[in] manager Index manager used.
//! @param[in] routing Routing solver used.
//! @param[in] solution Solution found by the solver.
void PrintSolution(const RoutingIndexManager& manager,
                   const RoutingModel& routing, const Assignment& solution) {
  LOG(INFO) << "Objective: " << solution.ObjectiveValue();
  // Inspect solution.
  int64_t index = routing.Start(0);
  LOG(INFO) << "Route for Vehicle 0:";
  int64_t distance{0};
  std::stringstream route;
  while (!routing.IsEnd(index)) {
    route << manager.IndexToNode(index).value() << " -> ";
    const int64_t previous_index = index;
    index = solution.Value(routing.NextVar(index));
    distance += routing.GetArcCostForVehicle(previous_index, index, int64_t{0});
  }
  LOG(INFO) << route.str() << manager.IndexToNode(index).value();
  LOG(INFO) << "Distance of the route: " << distance << "m";
  LOG(INFO) << "";
  LOG(INFO) << "Advanced usage:";
  LOG(INFO) << "Problem solved in " << routing.solver()->wall_time() << "ms";
}

Java

  /// @brief Print the solution.
  static void printSolution(
      DataModel data, RoutingModel routing, RoutingIndexManager manager, Assignment solution) {
    // Solution cost.
    logger.info("Objective : " + solution.objectiveValue());
    // Inspect solution.
    logger.info("Route for Vehicle 0:");
    long routeDistance = 0;
    String route = "";
    long index = routing.start(0);
    while (!routing.isEnd(index)) {
      route += manager.indexToNode(index) + " -> ";
      long previousIndex = index;
      index = solution.value(routing.nextVar(index));
      routeDistance += routing.getArcCostForVehicle(previousIndex, index, 0);
    }
    route += manager.indexToNode(routing.end(0));
    logger.info(route);
    logger.info("Distance of the route: " + routeDistance + "m");
  }

.Net

    /// <summary>
    ///   Print the solution.
    /// </summary>
    static void PrintSolution(in RoutingModel routing, in RoutingIndexManager manager, in Assignment solution)
    {
        Console.WriteLine("Objective: {0}", solution.ObjectiveValue());
        // Inspect solution.
        Console.WriteLine("Route for Vehicle 0:");
        long routeDistance = 0;
        var index = routing.Start(0);
        while (routing.IsEnd(index) == false)
        {
            Console.Write("{0} -> ", manager.IndexToNode((int)index));
            var previousIndex = index;
            index = solution.Value(routing.NextVar(index));
            routeDistance += routing.GetArcCostForVehicle(previousIndex, index, 0);
        }
        Console.WriteLine("{0}", manager.IndexToNode((int)index));
        Console.WriteLine("Distance of the route: {0}m", routeDistance);
    }

Obsługa VRP w przypadku odbioru i dostawy

OR-Tools w wersji 7.0 pomaga rozwiązywać problemy z trasą pojazdów (VRP) w przypadku odbioru i dostawy, w ramach których celem jest znalezienie najkrótszych tras dla floty pojazdów, które odbierają i dostarczają przedmioty w różnych lokalizacjach. Problem ustawia się podobnie jak w przypadku standardowej VRP, ale dodatkowo określa się parę (i, j) lokalizacji dla każdego produktu, gdzie „i” to miejsce odbioru, a j to miejsce zwrotu. Rozwiązanie do wyznaczania tras zwraca trasy pojazdów tak, aby każda para (i, j), i i j znajdowała się na tej samej trasie, a pojazd odwiedza i przed j.

Przykład rozwiązania tego problemu znajdziesz w artykule Routing pojazdów z odbiorami i dostawami.

Obsługa funkcji lambda

Edytor OR-Tools w wersji 7.0 obsługuje teraz funkcje lambda w językach C# i Javie (oprócz obsługi języka C++ i Pythona, które były już obsługiwane). Funkcje Lambda umożliwiają wygodne definiowanie wywołań zwrotnych w programach routingu. Możesz jednak zdefiniować wywołania zwrotne za pomocą funkcji standardowych, jeśli uważasz, że zwiększa to czytelność kodu.

W powyższych przykładach wywołań zwrotnych w językach C# i Java widać, jak definiować wywołania zwrotne za pomocą funkcji lambda.

listopadzie 2018 r.

Ogłoszenie wydania wersji 6.10

Udostępniliśmy OR-Tools w wersji 6.10. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

W kolejnych sekcjach opisano nowe funkcje i ulepszenia w wersji 6.10.

Uproszczone polecenia do tworzenia i uruchamiania programów

W wersji 6.10 możesz tworzyć i uruchamiać programy, wpisując podane niżej polecenia: 

make run SOURCE=relative/path/to/program.cc
gdzie <var>relative/path/to</var> to ścieżka do katalogu zawierającego program.

Aby utworzyć program bez uruchamiania go, wpisz: 

make build SOURCE=relative/path/to/program.cc
Przeczytaj Wprowadzenie do narzędzi LUB, aby zapoznać się z instrukcjami uruchamiania programów w poszczególnych językach.

Obsługa SCIP 6.0.0

LUB-Tools obsługuje teraz SCIP 6.0.0.

Pliki binarne

Dystrybucje binarne zostały utworzone przy użyciu języka Java JDK 8 (JDK 7 dla Ubuntu 14.04).

Rozwiązania CP-SAT

Aktualizowanie interfejsu API

  • Dodano interfejs API CpModelBuilder w C++ CP-SAT.

Przykłady

Niektóre przykłady zostały przeniesione.

  • Przenieś przykłady społeczności do examples/contrib.
  • Przenieś kilka przykładów do usługi ortools/<var>component</var>/samples (np. ortools/linear_solver/samples/simple_program.java)

Wrzesień 2018 r.

Ogłoszenie wydania wersji 6.9

Udostępniliśmy OR-Tools w wersji 6.9. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Zaktualizowano zależności

  • Protobuf 3.5.1 -> 3.6.1
  • SCIP 4.0 –> 6.0.

Rozwiązania CP-SAT

  • Niezbędne zmiany w interfejsie API – szczegółowe informacje znajdziesz tutaj:
  • Zmień nazwę SolveWithSolutionObserver na SolveWithSolutionCallback w Pythonie.

  • Zmień nazwę NewSolution na OnSolutionCallback w klasie CpSolverSolutionCallback w Pythonie. Poniższy przykład przedstawia nowy sposób tworzenia wywołania zwrotnego rozwiązania w Pythonie. 

    class MySolutionCallback(cp_model.CpSolverSolutionCallback):
def init(self):
cpmodel.CpSolverSolutionCallback.init(self)
self._solution_count = 0
    


    def OnSolutionCallback(self):
print('Solution {}, time = {}s, objective = {}, makespan = {}'.format(
  self.solution_count,
  self.WallTime(),
  self.ObjectiveValue(),
  self.Value(makespan)))
self.solution_count += 1

  • Udostępnij StopSearch dla wywołania zwrotnego rozwiązania w Pythonie, Javie i C#. Dokumentacja znajdziesz tutaj.

  • Udostępnij ModelStats i CpSolverResponseStats w Pythonie, Javie i C#.

  • Ulepsz dokumentację ciągów dokumentów w Pythonie. Dokumentacja znajdziesz tutaj.

  • Aktualizacje implementacji interfejsu rozwiązania i książki kucharskiej w języku Java.

  • Zaimplementuj moduł modulo.

  • Zmień implementację zbiornika: dodaj interfejs API z wartością logiczną, aby określić opcjonalne zdarzenia opróżniania/wypełniania.

Rozwiązywanie funkcji liniowych

  • Udostępnij InterruptSolve w Javie i C#.

Rozwiązanie CP

  • Pokaż reżysera SolutionCollector w C#.

Python

  • Dodaj obsługę języka Python 3.7.
  • Jeśli kompilujesz na podstawie źródła: do wykrywania Pythona preferuj python3, a nie python2.

.NET

  • Dokończ przepisywanie warstwy .NET.
  • Prześlij pakiet Google.OrTools NetStandard 2.0 Nuget zgodny z Runtime IDentifier win-x64, linux-x64 i osx-x64.
  • Prześlij pakiet Nuget Google.OrTools.FSharp.
  • Dodaj plik projektu do wszystkich przykładów .NET.
  • Zaktualizuj wszystkie przykłady skryptów F# (.fsx) do zwykłego projektu F# (.fs).
  • Dokumentację dotyczącą generowania kompilacji pakietu .NET możesz dodać tutaj.

Cynk

  • Dodano obsługę zestawów w płascynku (przy użyciu nosets.mzn).

Opublikowane treści

Lipiec 2018 r.

Ogłoszenie wydania wersji 6.8

Udostępniliśmy OR-Tools w wersji 6.8. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Przedstawiamy rozwiązanie CP-SAT

Rozwiązanie CP-SAT to nowe narzędzie do programowania ograniczeń. Rozwiązanie CP-SAT jest szybsze niż oryginalne rozwiązanie CP-SAT i powinno być preferowane w przypadku problemów z CP.

Jeśli chcesz zobaczyć przykłady zastosowania rozwiązania CP-SAT, w katalogu examples na GitHubie znajdziesz pliki, które mają w nazwie _sat.

Pierwotne rozwiązanie CP będzie nadal działać przez pewien czas, aby obsługiwać istniejący kod, ale zostało wycofane.

Nowe opcje rozwiązania CP-SAT

Nowością w tej wersji są te opcje rozwiązania CP-SAT:

  • Wyszukiwanie w okolicy (LNS): użyj opcji SatParameters.use_lns, aby włączyć LNS.
  • Wyszukiwanie równoległe: użyj opcji SatParameters.num_search_workers, aby włączyć wiele wątków podczas wyszukiwania. Każdy wątek może mieć inne parametry i różne losowe punkty wyjściowe. Maksymalizuje to różnorodność i zwiększa prawdopodobieństwo znalezienia rozwiązań w co najmniej 1 wątku.

Ulepszona wydajność rozwiązań

Ulepszyliśmy wydajność rozwiązań CP-SAT i Glop.

Marzec 2018 r.

Ogłoszenie wydania wersji 6.7

Udostępniliśmy OR-Tools w wersji 6.7. Aby zaktualizować wersję, zapoznaj się z odpowiednią sekcją artykułu Instalacja LUB-Narzędzia.

Zaktualizuj do wymaganych zależności

  • Protobuf 3.5.0 -> 3.5.1

Inne

  • Baza refaktoryzacyjna umożliwiająca przygotowanie integracji abseil-cpp.
  • Korzystanie z usług Travis CI i usługi ciągłej integracji Appveyor (CI).

SB

  • Poprawa wydajności.
  • Ulepsza interfejs Python API.
  • Dodaj interfejs API C# znany jako CpSolver.cs (EKSPERYMENTALNE).

Globus

  • Refaktoryzacja kodu.
  • Poprawa wydajności.

Obsługa CMake (wersja EKSPERYMENTALNA)

  • Dodaj obsługę CMake w języku C++ LUB-Tools.
  • Możliwość tworzenia narzędzi OR-Tools jako samodzielnego projektu CMake.
  • Możliwość włączenia narzędzi OR-Tools w istniejącym projekcie CMake.
  • Dodaj kompilację opartą na operacji LUB-Tools w Pythonie.
  • Wygeneruj pakiet Pythona (koło) za pomocą CMake.

Opublikowane treści

  • Poprawianie ponownej definicji winsock2.h w systemie Windows. Dziękujemy Florent Tollin de Rivarol.
  • Dodaj obsługę języka F# (EKSPERYMENTALNE). Dziękujemy Matthew Moore. Uwaga: ta opcja jest dostępna tylko w przypadku kreatora plików Makefile.
  • Dodaj obsługę standardu .NET (EKSPERYMENTALNE). Dziękujemy Ziad El Malki. Uwaga: ta opcja jest dostępna tylko w przypadku kreatora plików Makefile.

Listopad 2017 r.

Ogłaszamy wydanie wersji 6.6

Udostępniliśmy OR-Tools w wersji 6.6. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Aktualizacje wymaganych zależności

  • Protobuf do wersji 3.3.0 -> 3.5.0.
  • gflag do wersji 2.2.0 -> 2.2.1.
  • CBC 2.9.8 -> 2.9.9
  • Dodaj moduł Pythona 6 (1.10) jako wymaganą zależność od Pythona.

Poprawki błędów

  • Żądanie pull #494 – refaktoryzacja nazw. dodawanie komentarzy do IntelliSense w niektórych edytorach. Dziękujemy Matthew Moore.
  • Żądanie pull #516 Instrukcja dla niezależnego pliku binarnego F#. Dziękujemy Matthew Moore.
  • Zwiększ precyzję w Glop.

Rozwiązania SAT

  • Ulepszenie wewnętrznego rozwiązania do rozwiązywania problemów SAT, naprawienie różnych błędów.
  • Dodaj ograniczenie VRP do rozwiązania SAT połączone z nim.
  • Zmień obserwatora rozwiązania w rozwiązaniach SAT, aby przyjąć CpSolverResponse jako parametr.
  • Usprawnienie wykorzystania Glop w rozwiązaniu SAT Solver.
  • Przyspieszanie połączenia SAT-LP.
  • Dodaj ograniczenie dotyczące rezerwy do formatu protokołu SAT cp_model.

SAT/Python

Przykłady

  • Przepisz plik rcpsp_parser, aby zapisać problem w formacie ProtoBuf.
  • Usprawnienie parsera RCPSP.

Październik 2017 roku

Ogłoszenie wydania wersji 6.5

Udostępniliśmy OR-Tools w wersji 6.5. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Zmiana liczby platform

  • Moduł pypi py3-ortools został scalony z modułem ortools. Jest tam teraz tylko jeden moduł: „ortools”.
  • Głównym formatem tych modułów Pythona są teraz pliki koła. Aby zainstalować OR-Tools dla Pythona z pypi, po prostu uruchom polecenie pip install ortools. Musisz mieć zainstalowaną najnowszą wersję pip (>= 9.0.1). Powinno to spowodować pobranie najnowszej wersji (v6.5).

Błąd został naprawiony

Plik jar protokołu protobuf teraz prawidłowo kompiluje się za pomocą skompilowanych klas.

Nowe przykłady

  • Do katalogu przykładów/fsharp udało się przesłać więcej przykładów f# (jeszcze raz dziękuję za Matthew Moore'a).
  • Uwzględniono również przykłady użycia technologii Java MIP (Dziękuję, Darian).

wrześniu 2017 r.

Ogłoszenie wydania wersji 6.4

Udostępniliśmy OR-Tools w wersji 6.4. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Zmiana liczby platform

  • Moduły Pypi na platformach Linux są teraz dostarczane jako pliki koła za pomocą tagu wielulinux1. Dziękujemy Federico Ficarelli. W związku z tą zmianą wycofaliśmy moduły z systemem Linux wprowadzone w lipcu 2017 r.

Nowe funkcje

  • Ulepszona metoda skalowania używana w GLOP.
  • Naprawiono dodawanie oceniających w bibliotece routingu C#. Dziękujemy DevNamedZed.
  • Popraw wydajność rozwiązania płaskiego cynku w dużych modelach.
  • Domyślnie używaj platformy SAT dla płaskich powierzchni.
  • Zwiększ wydajność metody podstawowej opartej na rozwiązaniach SAT.
  • Napraw błąd w algorytmie przypisywania linearnego, w którym występowały błędy.
  • Dodano przykłady F# w elemencie ortools/examples/fsharp.
  • Usuń sprawdzanie pod kątem pozytywnych kar w bibliotece tras.

Sierpień 2017 r.

Ogłoszenie wydania wersji 6.3

Udostępniliśmy OR-Tools w wersji 6.3. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Nowe pliki do pobrania

Pliki koła zębatego Pythona dla systemu Linux można teraz pobrać ze strony wersji LUB-Tools, wraz z najnowszymi wersjami wszystkich pobranych plików.

Rozpuszczalniki minicynkowe

Ta wersja zawiera ostateczny kod SAT i flaazinc przesłany w ramach wyzwania Minizinc 2017.

Lipiec 2017 r.

Ogłoszenie wydania wersji 6.2

Udostępniliśmy OR-Tools w wersji 6.2. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Zmiana liczby platform

  • Obecnie obsługujemy wiele dystrybucji binarnych systemu Linux (Ubuntu 14.04, 16.04, 17.04, CentOS 7, Debian 9).
  • Moduły Pypi na platformach Linux zawierają teraz tag opisujący dystrybucję (ubuntu-14.04, ubuntu-16.04, ubuntu-17.04, centos-7, debian-9).

Nowe funkcje

Dodaliśmy obsługę Dockera, który umożliwia tworzenie artefaktów systemu Linux. Przejdź do or-tools/tools/docker i sprawdź Makefile, aby zobaczyć możliwe wartości docelowe (make archive, make pypi i make pypi3).

Te polecenia spowodują utworzenie podkatalogu export i dodanie do niego artefaktów binarnych.

Czerwiec 2017 roku

Ogłoszenie wydania wersji 6.1

Udostępniliśmy OR-Tools w wersji 6.1. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Zmiana liczby platform

  • Visual Studio 2017 jest obsługiwane; Visual Studio 2013 nie jest już obsługiwane.
  • Obsługujemy systemy macOS w wersji 10.9 lub nowszej.

Nowe funkcje

Dodaliśmy nowy format protokołu na potrzeby rozwiązania CP-SAT. Zapoznaj się z sekcją ortools/sat/cp_model.proto, aby zdefiniować model, i ortools/sat/cp_model_solver.h, aby rozwiązać problem.

Poprawki błędów

420: naprawiliśmy brakujący atrybut __version__ w modułach Ppypi Pythona na wszystkich platformach.

Maj 2017 r.

Ogłoszenie wydania wersji 6.0

Udostępniliśmy OR-Tools w wersji 6.0. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Nowa struktura katalogów w C++

Zmieniliśmy strukturę źródła/dołączania w narzędziach LUB w C++. Celem jest zapewnienie lepszego opisywania plików z C++ do uwzględnienia. Ma też zaletę ujednolicenia struktur katalogów w C++ i Pythonie.

  • Nazwa zasobu src/ została zmieniona na ortools/.
  • Wszystkie polecenia #include w plikach C++ mają teraz prefiks ortools. #include "constraint/constraint_solver.h" to teraz #include "ortools/constraint/constraint_solver.h".

Nowe funkcje

  • Pomoc techniczna Bazel. Teraz możesz tworzyć narzędzia OR-Tools za pomocą bazela – naszego narzędzia do kompilacji. Działa w systemach Linux i Mac OS X. Po pobraniu Bazel w wersji 0.4.5 lub nowszej zmień katalog na or-tools i utwórz przykłady: bazel build examples/cpp/....

Routing

W bibliotece tras dodaliśmy obsługę przerw w działaniu (np. niedostępności pojazdu z powodu jedzenia lunchu przez kierowców). Ta funkcja jest widoczna w przykładzie cvrptw_with_breaks.cc.

Obsługa SCIP

Otoka rozwiązania liniowego obsługuje teraz SCIP 4.0. Najpierw trzeba stworzyć SCIP, a potem wskazać narzędzia, że będą z nich korzystać. Instrukcje znajdziesz tutaj.

Obsługa GLPK

Zmieniliśmy też sposób korzystania z GLPK. Skorzystaj z tego artykułu.

Czyszczenie

  • Usunęliśmy wszystkie sposoby używania atrybutów hash_map i Hash_set z bazy kodu C++, które zostały wycofane. Zostały one zastąpione elementem unordered_map i unordered_set z pliku STL.
  • Czyszczenie plików Makijaży C# dzięki uprzejmości Michaela Powella.

styczeń 2017 r.

Ogłaszamy wydanie wersji 5.1

Udostępniliśmy OR-Tools w wersji 5.1. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Nowe funkcje

Instaluję

Routing

Wdrożyliśmy algorytm obliczający dolną granicę Held-Karpa dla symetrycznych problemów sprzedawcy. Umożliwia to obliczenie górnej granicy różnicy między kosztem potencjalnie nieoptymalnego rozwiązania a kosztem rozwiązania optymalnego.

  • Do biblioteki routingu pojazdu RoutingModel::SetBreakIntervalsOfVehicle dodaliśmy nową metodę, która umożliwia dodawanie przedziałów break, czyli okresów, w których pojazd nie może wykonywać żadnych zadań (takich jak podróżowanie lub odwiedzanie węzła). Przykład z tą opcją znajdziesz tutaj: cvrptw_with_breaks.cc

Planuję

Rozwiązanie sobotnie

Poprawa skuteczności

  • Rozwiązanie SAT – poprawiona wydajność rozwiązania SAT, zwłaszcza w przypadku ograniczenia skumulowanego.
  • Rozwiązanie Glop – ulepszona niezawodność liczbowa rozwiązania Glop, która obecnie zwraca jeszcze dokładniejsze rozwiązania trudnych problemów liczbowych.
  • Rozwiązanie płaskie
  • Znacznie poprawiona wydajność backendu Sat dla tłumaczenia Flatzinc.
  • Uprościliśmy interfejs C# Flatzinc. Przykład nowego interfejsu znajdziesz na stronie https://github.com/google/or-tools/blob/master/examples/csharp/csfz.cs.

Poprawki błędów

  • Użycie heurystyki PathCheapestArc do wyznaczania tras z 1 pojedynczym pojazdem i ograniczeniami z boku może czasami powodować zbyt długie działanie rozwiązania. Naprawiliśmy to dzięki odpowiedniemu uwzględnianiu ograniczeń bocznych.
  • W języku Java narzędzie do ustalania trasy czasami ulegało awarii podczas rozwiązywania problemów z wyznaczaniem tras pojazdów. Ten błąd został naprawiony w najnowszej wersji.

listopad 2016 r.

Ogłaszamy wydanie wersji 5.0

Opublikowaliśmy OR-Tools w wersji 5.0. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Działające przykłady

  • Wprowadziliśmy cele językowe, które ułatwiają kompilowanie i uruchamianie programów, a także przykłady dołączone do narzędzi LUB.

Sob

FlatZinc

Rozwiązanie do rozwiązywania ograniczeń

Routing

  • Wdrożono funkcję AddAtSolutionCallback, która jest wywołaniem zwrotnym za każdym razem, gdy podczas wyszukiwania zostanie znalezione rozwiązanie.
  • Usunięto konstruktory bez depozytów RoutingModel. Określenie co najmniej jednej stacji w modelu routingu jest teraz obowiązkowe.

Wrzesień 2016 r.

Ogłaszamy udostępnienie wersji 4.4

Udostępniliśmy OR-Tools w wersji 4.4. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Sob

  • Rozszerzony interfejs API do planowania i zmodyfikowane przykłady (weighted_tardiness_sat oraz jobshop_sat) do jego użycia.

Wykres

  • Dodano cechy iteratora do klas Grafu.

Rozkład danych OR-Narzędzia

  • Pakiet Nuget jest ponownie obsługiwany.

sierpniu 2016 r.

Ogłoszenie wydania wersji 4.3

Udostępniliśmy OR-Tools w wersji 4.3. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Rozwiązanie ograniczeń

  • Wdrożono metodę NotBetween, która ogranicza, aby zmienna znajdowała się poza wyznaczonym przedziałem czasu.

routing

  • Dodano analizę modelu, która pozwala sprawdzać obecne ograniczenia NotMember, jak pokazano w tym przykładzie, i używać ich w filtrach wyszukiwania lokalnego.
  • Dodano profilowanie wyszukiwania lokalnego.
  • Rozwiąż problem z przeprowadzkami lokalnymi.

Rozwiązanie liniowe

  • Stałe raportowanie stanu SCIP.

Sob

Globus

  • Poprawiona wydajność dzięki wykorzystaniu rozproszenia na kolejnych etapach obliczeń.

Cynk

  • Naprawiliśmy błędy w wyzwaniu minizinc.

Lp_data

  • Kolejne upraszczanie szablonów w iteracjach.

Rozkład danych OR-Narzędzia

  • Zestawy C# mają teraz domyślnie silne nazwy.
  • Uaktualniono do wersji Protobuf3.0.0.
  • Dodano skrypt w Pythonie, aby sprawdzić zależności archiwów OR-Tools.

lipiec 2016 r.

Ogłoszenie wydania wersji 4.2

Udostępniliśmy OR-Tools w wersji 4.2. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Rozwiązanie ograniczeń (routing)

  • Rozłączenie można teraz zdefiniować za pomocą mocy zbioru, która jest maksymalną liczbą węzłów, które mogą być aktywne w ramach tego odłączenia. Jeśli na przykład dodasz rozłączenie z n węzłami i mocą zbioru równą k, aktywne będzie k węzłów spośród n węzłów. W tym celu możesz użyć nowej definicji obiektu AddDisjunction.
  • Dodaliśmy obsługę wielu dysjuń na węzeł. Na przykład możesz teraz dodać węzeł N1 do wielu dysjencji (D1..Dm). Zwiększa to szanse danej osoby na aktywność w którejkolwiek z nich. Wprowadzono szybszy algorytm wyszukiwania routingu do problemów związanych z różnymi przedziałami czasu.
  • Dodano parametry rozwiązania ograniczeń do kierowania parametrów modelu i log_search do kierowania parametrów wyszukiwania.
  • Lokalny algorytm wyszukiwania działa szybciej przy rozwiązywaniu problemów z niepołączonymi przedziałami czasowymi. Więcej informacji znajdziesz w przykładzie cvrp_disjoint_tw.cc.

Glop (optymalizacja liniowa)

  • Wprowadzono szybszy algorytm prosty.

Rozkład danych OR-Narzędzia

  • Jedno archiwum na platformę, a nie osobne archiwa dla każdego środowiska C++, Java i .Net. Archiwa Pythona są nadal hostowane w pypi.
  • W przypadku języka pypi przeszliśmy na moduły koła (.whl) w systemach Mac OS X i Windows. Wprowadzono schemat numerowania MAJOR.MINOR. Te numery są używane w nazwie archiwów, wersji przechowywanej w bibliotekach udostępnionych w systemie macOS X, modułów Pythona i zespołach .NET. Pierwsza wersja, którą publikujemy, to wersja 4.2 tego schematu.

Czerwiec 2016

Ogłaszamy wprowadzenie wersji v2016-06

udostępniliśmy wersję 2016-06 OR-Tools. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Rozwiązanie do rozwiązywania ograniczeń

  • Usunęliśmy większość wystąpień wywołań zwrotnych (src/base/callback.h) z biblioteki CP.
  • Dodano notMemberCt (zmienna nie może należeć do zbioru przedziałów).

Biblioteka tras

  • ZMIANA NIEZGODNA: aby określić pojemność pojazdów w AddDimensionWithVehicleCapacity, musisz teraz przekazać tablicę (wektor w języku C++), a nie wywołanie zwrotne.

GLOP

  • Zmień wewnętrzną reprezentację macierzy rozproszonej.
  • Poprawa wydajności.

Wykres

  • Przeredaguj algorytmy Dijkstra i Bellmana-Forda, aby zastąpić wywołania zwrotne std::function (C++).
  • Zmień interfejs API innej implementacji wykresu podczas iteracji nad łukami i węzłami.

Sob

  • Usuń nieużywaną metodę podstawową (węzły rozwiązania problemu).
  • Dodano dramatycznego pisarza, aby sprawdzić dowody pod kątem niesatysfakcji.
  • Dodaj procesor wstępny.

Bebop

  • Dodaj nowe okolice.

Przykłady

  • c++: pozbycie się czytnika filelinereader w przykładach.
  • dane: dodanie problemów z planowaniem w jednym komputerze.

Dokumentacja

Kwiecień 2016 roku

Ogłaszamy wprowadzenie wersji v2016-04

udostępniliśmy wersję 2016-04 OR-Tools. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Zaktualizowano zależności

Grudzień 2015 r.

Ogłaszamy wprowadzenie wersji v2015-12

udostępniliśmy wersję 2015-12 OR-Tools. Aby zaktualizować wersję, przeczytaj odpowiednią sekcję instalacji LUB-narzędzi.

Rozwiązanie do rozwiązywania ograniczeń

  • Naruszenie zgodności z wyszukiwaniem w dużej okolicy w rozwiązaniu CP (więcej informacji o nowym interfejsie API znajdziesz w examples/cpp/ls_api.cc, examples/python/pyls_api.py, examples/csharp/csls_api.cs i examples/com/google/ortools/sample/LsApi.java).
  • Wyczyszczono opakowanie Pythona. Obsługuj niestandardowe decyzje w rozwiązaniu CP (aby zobaczyć, jak działa interfejs API, przejdź do sekcji examples/test/test_cp_api.py).
  • Wprowadzono różne poprawki i udoskonalenia.

Wrzesień 2015 r.

Przedstawiamy pierwszą wersję na githubie.

Pliki będą tam przechowywane.

Cynk

  • Dodaliśmy archiwa binarne dla tłumacza Flatzinc (zobacz www.minizinc.org).
  • Zawiera kilka poprawek do wersji używanej w wyzwaniu.