Versionshinweise zu OR-Tools

Auf dieser Seite werden Änderungen an den OR-Tools aufgeführt, einschließlich neuer Funktionen, Fehlerkorrekturen und Verbesserungen des Codes und der Installationsverfahren.

Wenn bei der Installation von OR-Tools Probleme auftreten, lesen Sie den Abschnitt Fehlerbehebung in der OR-Tools-Installationsanleitung. Wenn Ihr Problem dort nicht aufgeführt ist, sehen Sie unter Probleme auf GitHub nach oder erstellen Sie ein neues. Wir helfen Ihnen dann gern weiter.

Im Folgenden finden Sie die Versionshinweise für OR-Tools, beginnend mit der neuesten Version.

März 2024

Neu: OR-Tools v9.9

Wir haben die Version 9.9 von OR-Tools veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Du findest die Versionshinweise auf GitHub.

November 2023

Neu: OR-Tools v9.8

Wir haben die OR-Tools-Version 9.8 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Fügen Sie Python 3.12 hinzu.
• Unterstützung für Ubuntu 23.10 hinzufügen

Linear Solver

• Port ModelBuilder zu .Net.
• Benennen Sie LogCallback in MbLogCallback um, um Kollisionen mit SAT LogCallback zu vermeiden.
• Erweitern Sie die ModelBuilder API:
  • Fügen Sie Einschränkungen für Indikatoren hinzu.
  • Unterstützung für Hinweise hinzufügen.
  • Fügen Sie das Klonen von Modellen hinzu.

Mathematik aktivieren

• Umfangreiche Überarbeitung.

Routen

• ROUTING_OPTIMAL-Status hinzufügen.
• RoutingModel darf nicht kopierbar oder verschiebbar sein.
• Probleme mit Endlosschleifen bei lokalen Suchoperatoren behoben
• Fügen Sie eine interne PickupDeliveryPosition-Struktur hinzu.
• Fügen Sie die Methoden IsPickup() und IsDelivery() hinzu.

SAT

• Reduzieren Sie den Arbeitsspeicherbedarf für ein großes Modell.
• Verbesserte Planungssuche.
• packing_precedences_lns hinzufügen.
• den Machbarkeitssprung optimieren und beheben.
• lineares Presolve- und Presolve-Logging optimieren.
• Vorauflösung für int_abs, int_mod, int_prod und lin_max verbessern.
• Unterstützung von Panda verbessern
• Wenige Fehlerkorrekturen.

GitHub-Änderungsprotokoll

August 2023

Neu: OR-Tools v9.7

Wir haben die Version 9.7 von OR-Tools veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Lassen Sie Centos-8 (EOL) ab.
• Debian 10 veröffentlichen
• Fedora [33, 36] (EOL) ablegen.
• Löschen Sie Ubuntu 18.04 LTS (EOL).
• Löschen Sie Python 3.7 (EOL).
• netcore3.1-Unterstützung in CMake (EOL) deaktivieren.

Model Builder – Python

• Verwendung von Pandas-DataFrames und -Serien zum Erstellen von Variablen zulassen.
  • siehe Aufgabe
  • siehe bin_packing
• Eingabeinformationen vervollständigen

DLP

• und verschiedene Updates.

CP-SAT

• Leistungsverbesserungen (feasibility_jump, lin_max)
• Schnittmengenmanagement verbessern
• Neuer Worker „object_shaving_search“ zur Verbesserung der Untergrenze des Ziels (beim Minimieren)
• Anmerkungen für Python cp_model.py eingeben
• Experimentelle teilweise Unterstützung für pandas in cp_model.py
  • siehe Aufgabe
  • siehe bin_packing
• Experimentelle Worker basierend auf lokalen Suchverstößen:
  • aktiviert mit Parametern: num_violation_ls:xxx
  • optimiert für lineares Modell (linear, bool_or, bool_and, at_most_one, exactly_one)
  • Funktioniert ordnungsgemäß mit lin_max, product, Division
  • unterstützt no_overlap, Cumulative, circuit, routes
  • deaktiviert mit no_overlap_2d
  • Empfohlene Anzahl von ls-Workern: num_workers -> num_violation_ls: (8, 1), (16, 2) (24, 3), (32, 4)

GitHub-Änderungsprotokoll

März 2023

Neu: OR-Tools v9.6

Wir haben Version 9.6 von OR-Tools veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Unterstützung für Fedora 37, 38 hinzufügen.
• Löschen Sie Python 3.6 (nicht von protobuf unterstützt).
• Legen Sie Python 3.7 unter macOS ab (nicht unterstützt von scipy).
• net7.0-Unterstützung in CMake hinzufügen (-DUSE_DOTNET_7=ON verwenden)
• netcore3.1 in nuget-.org-Paketen ablegen

Abhängigkeiten

• SCIP v801 -> v803 (Hinweis: Für SCIP wird jetzt eine OSI-kompatible Lizenz verwendet.)
• Abseil 20220623.1 -> 20230105.0
• Protokollzwischenspeicher v21.5 -> v21.12
• 4.1.1 WECHSELN
• Java JNA 5.11.0 -> 5.12.1

Bazel

• pybind11-Unterstützung hinzufügen.
• Java-Wrapper-Unterstützung hinzugefügt.

Solver

• PDLP: dd Python-Wrapper.
• CP-SAT: Leistungsverbesserungen.
• GLOP: Vorauflösung optimieren.
• ModelBuilder: Python: Verbesserte NumPy-Unterstützung.
• Weiterleitung: Leistungsverbesserungen (lokale Suche)

Bekannte Probleme:

• CP-SAT: Wenn der Subsolver pseudo_costs ignoriert wird, werden ungültige Parameter zurückgegeben (siehe #3706).

November 2022

Neu: OR-Tools v9.5

Wir haben die OR-Tools-Version 9.5 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Debian Sid-Unterstützung hinzufügen.
• Unterstützung für Fedora 35, 36 hinzufügen.
• Ubuntu 22.10-Support hinzufügen.
• Legen Sie Python 3.6 unter macOS ab.
• Unterstützung für Python 3.11 hinzufügen.

Abhängigkeiten aktualisieren

• Protokollzwischenspeicher v19.4 -> v21.5.
• SCIP Solver v800 -> v801.

CP-SAT

• Vorläufige Verbesserungen: max(array), boolesche Einschränkungen, lineare Einschränkungen.
• Die verschachtelte Suche sollte parallel dazu deterministisch sein.
• Lineare Schnitte: Bereinigung der quadratischen und int_prod-Schnitte; Cut-Pipeline neu schreiben.
• Eingabemodell und Lösung des Fingerabdrucks (im Protokoll sichtbar).
• Verbesserungen bei der Terminplanung.
• Die üblichen Fehlerbehebungen (Absturz während der Vorauflösung, Absturz in Schnitten, nicht durchführbare Lösungen, Modell nicht durchführbar in LNS).

GLOP

• Sie können die Geschwindigkeit erhöhen, indem Sie die lineare Algebra sowie die Drehpunktauswahlregel neu schreiben.

Linear Solver

• Fügen Sie knapsack_interface.cc hinzu.
• Verschieben Sie die model_builder API in das Verzeichnis „linear_solver“ (Header und Beispiele).
• Unterstützung für Gurobi 10 hinzufügen.

Routen

• Geben Sie nur wenige Parser für verschiedene Routingherausforderungen frei.

August 2022

Neu: OR-Tools v9.4

Wir haben die Version 9.4 von OR-Tools veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformen

• Fügen Sie Debian-10-Unterstützung hinzu (siehe #3029).
• Fügen Sie Ubuntu 22.04 LTS-Unterstützung hinzu (siehe #3276). Hinweis: Es wird keine .Net 3.1-Unterstützung angeboten (siehe dotnet/core#7038).
• Entfernen Sie die Unterstützung für Ubuntu 21.10.

Verschiedenes

• Teilen Sie das Archiv nach Sprachen auf und fügen Sie die CMake-Konfiguration in die C++-Datei ein (Nr. 3200).

Grafik

ortools.graph.pywrapgraph aufteilen in:

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

Dies ermöglicht die Verwendung von NumPy, um die Einrichtung der Probleme zu beschleunigen.

CP-SAT

Einige Verbesserungen in Bezug auf:

• Planung (Weitergabe, Schnitte, Untergrenzen)
• MaxSAT (Presolve, Core-based Heuristics).
• MIP-Leistung (Vorauflösung, Schnitte)

März 2022

Neu: OR-Tools v9.3

Wir haben Version 9.3 von OR-Tools veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Debian-10-Support wird eingestellt.
• Unterstützung für Ubuntu 16.04 wird eingestellt.
• Löschen Sie .NET Framework 4.5.2.

Abhängigkeiten aktualisieren

• Fügen Sie Eigenen 3.4.0 hinzu.
• Google re2 2021-11-01 hinzufügen.
• Protokollzwischenspeicher 3.19.1 -> 3.19.4.
• SCIP 7.0.1 -> v800.

Python

• Fügen Sie pybind11 hinzu.

Funktionen

• PDLP als experimentelle Funktion hinzufügen.
• Fügen Sie MathOpt als experimentell hinzu.

CP-SAT

• Aus Konsistenzgründen wurden einige APIs umbenannt, z.B. LinearExpr.ScalProd. -> LinearExpr.WeightedSum..
• Fügen Sie AddAtLeastOne/AddAtMostOne/AddExactlyOne Methoden hinzu.
• Fügen Sie AddMultiplicationConstraint(z, x, y) in allen Sprachen hinzu.
• Fügen Sie AddMultipleCircuit() in allen Sprachen hinzu.

C++

• Expliziter Darsteller IntVar(BoolVar).
• LinearExpr::Add* wurde entfernt und durch den Operator ersetzt, z.B. LinearExpr +=.
• Arithmetische Operatoren in einem linearen Ausdruck hinzufügen
• LinearExpr::BooleanSum/BooleanScalProd wurde entfernt. Verwende Sum/WeightedSum.
• Fügen Sie CpModelBuilder::FixVariable() hinzu, wodurch die Domain der Variablen mit einem einzelnen Wert überschrieben wird.

Java

• Schreiben Sie LinearExpr um und fügen Sie eine inkrementelle Builder-Klasse hinzu: LinearExpr.newBuilder().add(x).addSum(<array of variables>).build().
• Folgen Sie der C++ API: Circuit, MultipleCircuit, Cumulative, Reservoir, AllowedAssignment und ForbiddenAssignment geben jetzt eine spezialisierte Klasse mit inkrementeller API zurück, um neue Variablen, Begriffe, Anforderungen hinzuzufügen...

C

• Dokumentieren Sie alle Methoden.
• Folgen Sie der C++ API: Circuit, MultipleCircuit, Cumulative, Reservoir, AllowedAssignment und ForbiddenAssignment geben jetzt eine spezialisierte Klasse mit inkrementeller API zurück, um neue Variablen, Begriffe, Anforderungen hinzuzufügen...
• Fügen Sie die Klasse LinearExprBuilder hinzu, um Ausdrücke inkrementell zu erstellen.

System entwickeln

CMake

• Mindestens CMake >= 3.18 erforderlich.

Marke

• Verwenden Sie jetzt den CMake-basierten Build intern.

Dezember 2021

Neu: OR-Tools v9.2

Wir haben die OR-Tools-Version 9.2 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Unterstützung für Ubuntu 21:10 (letzter Rolling Release) hinzugefügt.

Abhängigkeiten aktualisieren

• .Net TFM-Update von net5.0 auf net6.0 (.Net SDK 6.0 LTS und .Net SDK 3.1 LTS erforderlich).
• abseil-cpp 20210324.2 -> 20211102.0.
• Protobuf 3.18.0 -> 3.19.1.
• Googletest 1.10.0 -> 1.11.0.
• Python: numpy >= 1.13.3 hinzufügen.
• Kompilieren Sie unter macOS das Coin-OR in -O1, um Abstürze bei Runnern zu vermeiden.

Routen

• Verbesserungen bei Filtern
• Verbessern Sie die Heuristik der ersten Lösung.
• Verbessern Sie die Platzierung von Pausen.

CP-SAT

Nicht abwärtskompatible Änderungen

• Der zugrunde liegende Protokollpuffer ist nicht mit früheren Versionen kompatibel. Jeder gespeicherte Protokollpuffer muss mit den aktualisierten Builder-APIs (in C++, Python, Java und .NET) neu generiert werden.
• Insbesondere der Intervall-Protobuf wurde bereinigt, als wir die alten Felder (start, size und end) entfernt und die neuen Felder mit _view umbenannt haben, um die Namen der entfernten Felder zu verwenden.

Neue Funktionen

• Die Einschränkungen all_different, reservoir, modulo, multiplication und division akzeptieren affine Ausdrücke (a * var + b) überall dort, wo ganzzahlige Variablen erforderlich sind.
• Das Ziel akzeptiert Gleitkommakoeffizienten. Weitere Informationen finden Sie in der Klasse DoubleLinearExpr in C++/Java/.NET und im Beispiel knapsack_2d_sat.py in Python.
• Die Einschränkung no_overlap_2d unterstützt optionale Intervalle.
• Die C++ API implementiert die Operatoren + und *, um Ausdrücke zu erstellen.

Verbesserungen

• Der Presolve-Code wurde verbessert.
• Engere Modellprüfung.
• Reservoirbeschränkung überarbeiten.
• Fügen Sie energiegeladene Schnitte für die Einschränkung „no_overlap_2d“ hinzu.
• Verbesserte lineare Lockerung von Codierungseinschränkungen (literal implies var == value).

Eingestellte und entfernte Methoden

• Die C++-Funktionen BooleanSum und BooleanScalProd wurden verworfen. Verwende einfach Sum und ScalProd.
• Die C++-Dateien AddLinMinEquality und AddLinMaxEquality wurden entfernt. Verwende einfach AddMinEquality und AddMaxEquality.

Zukünftige Inkompatibilitäten

• Wir werden die Java-Modellierungsebene in Zukunft so umschreiben, dass sie näher an der C++-Ebene liegt.
• In der C++-Modellierungsebene wird der ctor „IntVar(BoolVar var)“ explizit angegeben.
• Wir erwägen, die Python API mit PEP 8-konform zu machen (mithilfe von snake_case-Namen). In diesem Fall stellen wir Ihnen eine sed-Datei zur Portierung des Codes zur Verfügung.

System entwickeln

Bazel

• Probleme mit Windows-Build beheben.

CMake

• Fügen Sie die Option FETCH_PYTHON_DEPS hinzu (Standardeinstellung ON).
• Optionale Unterstützung für den GPLK-Rechner hinzufügen (Standardeinstellung -DUSE_GLPK=OFF).

Python

• Unterstützung von numpy-Ganzzahlen in den meisten CP-SAT-APIs.
• Fehlende __version__ korrigieren.

September 2021

Neu: OR-Tools v9.1

Wir haben die OR-Tools-Version 9.1 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Python: Verwenden Sie das Image manylinux2014 (siehe PEP 599).
• Python: Mit dem manylinux2014_aarch64-Image wird jetzt aarch64-Linux unterstützt.
• .Net: .Net 5.0-Unterstützung hinzufügen

Abhängigkeiten aktualisieren

• 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: Verwendung von warning in cp_model.py (siehe #2530).
• python: absl-py 0.11 -> 0.13.

CMake

• Bump-Mindestversion erforderlich 3.14 -> 3.15 (siehe #2528).
• Python: Erforderliche bump-Mindestversion 3.14 -> 3.18 (siehe #2774).

Marke

Der Make-basierte Build wurde verworfen. Migrieren Sie zu CMake oder zu Looker, um Builds aus der Quelle zu erstellen.

Java

• Stabilität des Ladeprogramms für native Bibliothek verbessern (siehe #2742).
• Absturz der JVM Garbage Collector wurde behoben, wenn das Routingmodell oder der Einschränkungslöser verworfen wurde (siehe #2091) (siehe #2466).
• Ein Absturz des CP-SAT-Logging-Callbacks bei Verwendung mehrerer Worker wurde behoben (siehe #2775).

CP-SAT

• Verbessern Sie die Robustheit des LNS-Codes (siehe #2525).
• Verbesserung des Planungscodes: Neue Factory-Methoden zum Erstellen fester Größenintervalle, neue Suchheuristiken, verbesserte Vorauflösung und neue lineare Schnitte
• Routingcode verbessern: Neues dediziertes LNS.
• Verbessern Sie die Modellprüfung. Sie ist jetzt pedantischer, insbesondere bei potenziellen Überläufen.
• MIP-Code verbessern: bessere Presolve- und mehrere Verbesserungen der linearen Lockerung von MIP- und CP-Modellen.
• Höhere Suchvielfalt Wenn Sie mehr als 12 Worker verwenden, fügen Sie Worker hinzu, die speziell für die Verbesserung der Zieluntergrenze vorgesehen sind.
• Wechseln Sie zum Parallelitätscode: Der Solver verwendet jetzt standardmäßig alle verfügbaren Kerne. Verwenden Sie num_search_parameters, um die Parallelitätsstufe anzugeben.
• SearchAllSolutions und SolveWithSolutionCallback werden eingestellt.
• Python API: Stärkere Prüfungen bei Verwendung von var == ... oder var != ... außerhalb eines model.Add()-Aufrufs.

April 2021

OR-Tools v9.0

Wir haben die Version 9.0 von OR-Tools veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierungen von Abhängigkeiten

• Abseil-cpp 20200923.3 wurde auf 20210324.1 LTS aktualisiert.
• Protobuf 3.15.3 wurde auf 3.15.8 aktualisiert.
• Java: jna-platform 5.5.0 auf 5.8.0 aktualisiert

Java

• OR-Tools ist jetzt in Maven Central verfügbar (siehe com.google.ortools:ortools-java).

Fehlerkorrekturen

• Verbessern Sie das Multithreading bei Verwendung des CP-SAT-Resolvers (siehe #1588).
• Die Python-Wrapper-Unterstützung von std::vector&ltstd::string&gt wurde korrigiert (siehe #2453).
• Überarbeiten Sie die CPLEX-Unterstützung (siehe #2470).

Bekannte funktionsgefährdende Änderung

• Fügen Sie den Logger-Zugriff in Python, Java und .Net hinzu (siehe #2245).
• Alle benutzerdefinierten Google-Typen werden durch die in cstdint bereitgestellten ersetzt.

CP-SAT

• Die Methoden SearchForAllSolutions(), SearchAllSolutions() und SolveWithSolutionCallback() wurden eingestellt. Bitte verwende stattdessen Solve().
• Unterstützung von Python-Standardoperatoren verbessern. Dadurch kann vorhandenen Code falsch beschädigt werden.

März 2021

Neu: OR-Tools v8.2

Wir haben die OR-Tools-Version 8.2 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierungen von Abhängigkeiten

• Abseil-cpp 20200923.2 wurde auf 20200923.3 LTS aktualisiert.
• Protobuf 3.14.0 auf 3.15.3 aktualisiert.

Routen

• RoutingModel.RegisterTransitMatrix() und RoutingModel.RegisterUnaryTransitVector() wurden hinzugefügt.
• Ändern Sie die Rückgabe von RoutingModel.AddVectorDimension() und RoutingModel.AddMatrixDimension() in std::pair&ltint, bool&gt, deren int die Evaluator-ID für öffentliche Verkehrsmittel ist.

Dezember 2020

Neu: OR-Tools v8.1

Wir haben die OR-Tools-Version 8.1 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierungen von Abhängigkeiten

• Abseil-cpp 20200923 wurde auf 20200923.2 LTS aktualisiert.
• Protobuf 3.13.0 wurde auf 3.14 aktualisiert.
• Unterstützung für Gurobi 9.1.0 hinzufügen
• GLog-Abhängigkeit löschen (ersetzt durch eine benutzerdefinierte Implementierung abhängig von abseil-cpp-Flags)
• GFlag-Abhängigkeit löschen (ersetzt durch abseil-cpp-Flag-Komponente)

Fehlerkorrekturen

• Doppelte Zählung der Gurobi-Floating-Lizenz wurde korrigiert (siehe #2227).
• Probleme mit Build-Fenstern wurden behoben (siehe #2200).

Oktober 2020

OR-Tools v8.0 demnächst verfügbar

Die Version 8.0 von OR-Tools wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Unterstützung für Python 3.9 hinzugefügt (#2187)
• Keine Unterstützung mehr für Python 3.5 (#2186) <!-- Warten auf Unterstützung von Microsoft dotnet-sdk, kann generiert werden, nachdem der Release veröffentlicht wurde...
  • Unterstützung für Ubuntu 20.10 (#2188) --> hinzugefügt
• Keine Unterstützung mehr für Ubuntu 16.04 LTS (#2188)
• Keine Unterstützung mehr für Ubuntu 19.10 (#2188)

Aktualisierungen von Abhängigkeiten

• Abseil-cpp 20200225.2 wurde auf 20200923 LTS aktualisiert.
• Protobuf 3.12.2 wurde auf 3.13.0 aktualisiert.

Bekannte funktionsgefährdende Änderung

• Jetzt werden für das Routing und den CP-SAT-Quellcode einige C++17-Features verwendet. Warnung: Wenn Sie eine eigene Version von abseil-cpp bereitstellen, prüfen Sie, ob sie auch für C++17 erstellt wurde.
• Die Signatur MPSolver::CreateSolver wurde geändert. Das Argument für den Modellnamen wurde gelöscht.

CMake

• Beheben Sie das Problem, dass die SCIP-Unterstützung bei Verwendung von -DUSE_SCIP=OFF deaktiviert wurde (siehe #2129).
• Binden Sie Beispiele und Beispiele in das Build-System von CMake ein. Hinweis: Kann mit -DBUILD_SAMPLES=OFF und -DBUILD_EXAMPLES=OFF deaktiviert werden. Hinweis: Kann mit -DBUILD_<LANG>_SAMPLES=OFF oder -DBUILD_<LANG>_EXAMPLES=OFF für eine bestimmte Sprache deaktiviert werden.
  • Mit <LANG> aus:
  • CXX,
  • PYTHON,
  • JAVA und
  • DOTNET.

Marke

• Erfordert Make >= 4.3 (Verwendung der Auswert-Funktion).
• Erfordert CMake >= 3.14 (Verwendung der --unten-Option von CMake).
• Fügen Sie eine Option zum Deaktivieren der SCIP-Unterstützung mithilfe von -DUSE_SCIP=OFF hinzu (siehe #2134).
• Fügen Sie eine Option zum Deaktivieren der CLP- und CBC-Unterstützung mithilfe von -DUSE_COINOR=OFF hinzu.

Java

• Mit OR-Tools werden jetzt Maven-Pakete generiert (siehe #202).

Fehlerkorrekturen

• Probleme mit C++ und Python-Builds unter FreeBSD wurden behoben (siehe #2126).
• Der Build bei der Fehlerbehebung in Windows wurde korrigiert (siehe #2077).
• Parallele Problembehebung zu langjährigen Abstürzen unter CP-SAT unter Windows (siehe #2001, #2019).

Juli 2020

Neu: OR-Tools v7.8

Wir haben die OR-Tools-Version 7.8 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierungen von Abhängigkeiten

• Gurobi 9.0.2 ist jetzt in vorgefertigten Binärdateien integriert. Die gemeinsam genutzte Bibliothek von Gurobi 90 wird im Standardinstallationspfad der Gurobi-Installationsprogramme unter MAC OS X und Windows oder im Verzeichnis GUROBI_HOME gesucht.
• SCIP 7.0.1 ist jetzt in vordefinierte Binärprogramme integriert. Achten Sie darauf, dass die SCIP-Lizenz eingehalten wird, bevor Sie sie verwenden.
• Support für den optionalen Xpress Solver 8.9.0 wurde hinzugefügt.

Linear Solver

• Eine statische LinearSolver::CreateSolver()-Methode wurde hinzugefügt, um die Prüfung der Unterstützung für integrierte Linear Solver-Back-Ends zu vereinfachen. Das funktioniert in allen Sprachen.

Fehlerkorrekturen

• Der CMake-basierte Build auf FreeBSD wurde korrigiert.
• Die CP-SAT-Sortierung in der kumulativen Schnittgenerierung wurde korrigiert.
• Speicherleck des Linear Solver im .Net-Wrapper wurde behoben.

Juni 2020

Neu: OR-Tools v7.7

Wir haben die OR-Tools-Version 7.7 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierungen von Abhängigkeiten

• Abseil-cpp b832dce wurde auf c51510d (LTS 20200225.2) aktualisiert.
• Protobuf 3.11.4 auf 3.12.2 aktualisiert.

Neue Funktionen und Verbesserungen

• Der CP-SAT-Resolver gibt in einem Erfüllbarkeitsmodell (d.h. ohne Ziel) jetzt Optimal anstelle von Feasible zurück.
• Die Heuristik der Machbarkeitspumpe aus der MIP-Community wurde hinzugefügt.

Fehlerkorrekturen

Behebung eines CP-SAT-Multithreading-Absturzes (siehe #2005).

April 2020

Neu: OR-Tools v7.6

Wir haben die OR-Tools-Version 7.6 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Neue Funktionen für CP-SAT

Wir haben dem CP-SAT-Rechner die folgenden neuen Funktionen hinzugefügt:

• Verbesserte Verwaltung des Schneidens von Flugzeugen für LPs
• Debugging-Tools

Aktualisierungen von Abhängigkeiten

Abseil-cpp 8ba96a8 wurde auf b832dce (LTS 20200225) aktualisiert.

Fehlerkorrekturen

• Es wurde ein CP-SAT UNSAT-Fehler in der Vorablösung behoben (siehe #1908).
• Die URL „swigwin.exe“ wurde korrigiert.
• Fehler bei der SWIG-Typemap-Verwaltung für Java und .Net behoben.

Januar 2020

Neu: OR-Tools v7.5

Wir haben die OR-Tools-Version 7.5 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Unterstützung für Python 3.8 hinzugefügt (#1719)
• Die Unterstützungskompilierung aus Quellen in Visual Studio 2017 wurde verworfen (#1852).
• Die Unterstützung von Centos 7 auf Centos 8 wurde aktualisiert (#1827).

Abhängigkeitsupdate

• protobuf-Version 3.10.0 auf Version 3.11.2 aktualisiert (#1829).

Fehlerkorrekturen

Die folgenden Probleme wurden in Version 7.5 von OR-Tools behoben. Eine vollständige Liste finden Sie unter Meilensteinversion 7.5.

Wichtig ist insbesondere:

• Korrigierte Assembly wird geladen. Weitere Informationen finden Sie unter #1421.
• die Methoden GetStartIndex() und GetEndIndex() von RouteIndexManager (#1843) offengelegt.
• SWIG wurde korrigiert, um fehlerhafte Methoden zu entfernen (#1838, #1276).

Oktober 2019

Neu: OR-Tools v7.4

Wir haben die OR-Tools-Version 7.4 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Neue Funktionen und Verbesserungen

• Der CP-SAT-Rechner sucht jetzt nach Einschränkungen, die keine Erzwingungsliterale unterstützen. Wenn eine solche Einschränkung ein Erzwingungsliteral hat, gibt die Modellprüfung vor dem Lösen einen Fehler zurück.
• Bessere und schnellere lokale Suche nach der Routenplanungsbibliothek.
• Der Linear Solver unterstützt jetzt die Drittanbieter-Software Xpress-MP. Sie müssen OR-Tools aus dem Quellcode neu erstellen, um es verwenden zu können.
• Die Architektur des NuGet-Pakets wurde komplett neu geschrieben. Insbesondere unterstützt es jetzt das .NET Framework >= 4.5.2 auf Windows-Plattformen.

Eingestellte Plattform

Wie in den Versionshinweisen vom Juli 2019 angekündigt, unterstützt OR-Tools Python 2.7 nicht mehr.

Abhängigkeitsupdate

Protobuf 3.9.0 wurde auf 3.10.0 aktualisiert.

August 2019

Neu: OR-Tools v7.3

Wir haben die OR-Tools-Version 7.3 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Eingestellte Plattform

Im Rahmen des Wechsels von Google zu Python 3 wird die Unterstützung für Python 2.7 eingestellt. Dies ist die letzte Version von OR-Tools, die Python 2.7 unterstützen.

Abhängigkeitsupdate

Protobuf 3.8.0 wurde auf 3.9.0 aktualisiert.

Fehlerkorrekturen

Die folgenden Probleme wurden in Version 7.3 von OR-Tools behoben. Eine vollständige Liste finden Sie unter Kanban v7.3.

Wichtig ist insbesondere:

• Das init/int64-Umwandlungsproblem unter Java wurde behoben (#1448).
• Das Problem mit der Presolve-Prüfung bei der Verarbeitung leerer kumulativer Einschränkungen wurde behoben.

Juli 2019

Neu: OR-Tools v7.2

Wir haben die OR-Tools-Version 7.2 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Plattformänderungen

• Im Rahmen des Wechsels von Google zu Python 3 wird die Unterstützung für Python 2.7 eingestellt. Es wird höchstens eine weitere Version von OR-Tools geben, die Python 2.7 unterstützt.
• Ubuntu 18.10 wurde auf Ubuntu 19.04 aktualisiert.
• Kompilierung aus Quellen in Visual Studio 2019 wird jetzt unterstützt.
• Python 3.5 wird unter Windows nicht mehr unterstützt. Verwenden Sie Python 3.6 oder höher.

Aktualisierungen von Abhängigkeiten

• Wir nehmen jetzt ein Targeting auf CBC 2.10.3 vor.
• Wir zielen jetzt auf Protobuf 3.8.0 ab.

CP-SAT

• Es wurden mehrere Verbesserungen an der Suche, Parallelität und linearen Entspannung vorgenommen.
• LinearExpr.Sum() und LinearExpr.ScalProd() APIs in Python hinzugefügt.
• Die APIs IntVar[].Sum() und IntVar[].ScalProd() in C# wurden verworfen.
• C++: SolveWithModel() entfernt, da es ein Duplikat von SolveCpModel() ist.
• Der Java API wurden die Methoden CpModel.addGreaterThan() und CpModel.addLessThan() hinzugefügt.

Linear Solver

• MPSolver.SetHint() für Python, Java und C# hinzugefügt (unterstützt von SCIP und Gurobi).
• MPSolver.SetNumThreads() für Python, Java und C# hinzugefügt (unterstützt von CBC, Gurobi und SCIP).
• Unterstützung für SCIP 6.0.1 wurde umgeschrieben.

Referenzdokumentation

• Wir haben Doxygen- und pdoc3-basierte Referenzhandbücher für alle Sprachen und Tools (Algorithmen, Routing, Graph, linear_solver und CP-SAT) hinzugefügt. Weitere Informationen finden Sie in den OR-Tools-Referenzhandbüchern.
• Die Referenzdokumentation ist für C++ (alle Produkte) und CP-SAT (C++, Python, Java) vollständig.
• Wir exportieren derzeit die gesamte C++-Dokumentation nach Python und Java.
• Die .NET-Dokumentation fehlt und wir haben auf absehbare Zeit keine Lösung, um dies zu verbessern. Wir haben sie beibehalten, da dort immer noch die verfügbare API angezeigt wird.

Mai 2019

Neu: OR-Tools v7.1

Wir haben die OR-Tools-Version 7.1 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Änderungen an erforderlichen Abhängigkeiten

Für OR-Tools v7.1 bestehen die folgenden neuen und aktualisierten Abhängigkeiten:

• Aktualisierung von glog Version 0.3.5 auf Version 0.4.0
• protobuf-Version 3.6.1 auf Version 3.7.1 aktualisiert
• Cbc 2.9.9 auf 2.10.1 aktualisiert
• Cgl 0.59.10 wurde auf 0.60.1 aktualisiert.
• Clp 1.16.11 wurde auf 1.77.1 aktualisiert.
• Osi 0.107.9 auf 0.108.1 aktualisiert
• CoinUtils 2.10.14 auf 2.11.1 aktualisiert

CP-SAT API-Änderungen

In den folgenden Abschnitten werden Änderungen am CP-SAT-API in OR-Tools 7.1 beschrieben.

• „Domain“ zum Erstellen von Variablen verwenden.
• „Domain“ in einem linearen Ausdruck verwenden.
• Hilfsmittel für lineare Ausdrücke verwenden.

Domain zum Erstellen von Variablen verwenden

Die folgenden Beispiele zeigen, wie eine Ganzzahlvariable mit nicht zusammenhängenden Domains erstellt wird. Dadurch wird die entfernte Methode NewEnumeratedIntVar() ersetzt. In diesem Fall kann die Variable x einen der Werte 1, 3, 4 oder 6 sein:

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");

Variablen können auch mithilfe einer Liste von Intervallen erstellt werden. Unten ist die Variable x auf 1, 2, 4, 5 oder 6 beschränkt:

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");

"Domain" in einem linearen Ausdruck verwenden

Die folgenden Beispiele zeigen, wie ein linearer Ausdruck auf eine nicht zusammenhängende Domain begrenzt wird. Hier wird der lineare Ausdruck linear_expr auf 5, 6, 8, 9 und 10 definiert:

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} }));

Hilfsprogramme für lineare Ausdrücke verwenden

Die folgenden Beispiele zeigen, wie Hilfsmethoden zum Erstellen von Summen und Skalarprodukten verwendet werden. Hier sind Beispiele, in denen x + y == 20 und 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);

März 2019

OR-Tools v7.0

Die Version 7.0 von OR-Tools wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Änderungen an unterstützten Plattformen

Die folgenden Plattformen werden von OR-Tools Version 7.0 nicht mehr unterstützt:

• Visual C++ 2015
• Ubuntu 14.04
• Python 3.4 unter Linux

Wenn Sie eine dieser Plattformen verwenden, können Sie OR-Tools v6.10 trotzdem installieren.

Änderungen an erforderlichen Abhängigkeiten

Für OR-Tools v7.0 bestehen die folgenden neuen und aktualisierten Abhängigkeiten:

• Neu: Abseil-cpp
• gflags 2.2.1 aktualisiert auf 2.2.2

In den folgenden Abschnitten werden die neuen Funktionen und Verbesserungen in OR-Tools 7.0 beschrieben.

• Neuer Indexmanager für Routingprogramme
• Unterstützung für VRPs mit Abholung und Lieferung
• Unterstützung für Lambda-Funktionen in Java und C#

Neuer Indexmanager für Routingprogramme

In OR-Tools Version 7.0 muss für Routenführungsprogramme die neue RoutingIndexManager verwendet werden. So wird sichergestellt, dass die Standardindexe für Standorte mit den internen Indizes des Rechners übereinstimmen und Fehler in Ihrem Code vermieden werden.

Hinweis: Die Standard-Standortindexe sind 0 bis N-1, wobei N für die Anzahl der Standorte (einschließlich des Lagers) steht. Aus technischen Gründen können die internen Standortindexe des Solver außerhalb dieses Bereichs liegen.

Die neue RoutingIndexManager erfordert einige kleinere Änderungen an Routingprogrammen, die in den folgenden Abschnitten beschrieben werden:

• RoutingIndexManager in C++ und Java einschließen oder importieren.
• RoutingIndexManager deklarieren
• Fügen Sie RoutingIndexManager zu Dimensions-Callbacks hinzu.
• Verwenden Sie die RoutingIndexManager, um Lösungen zu drucken.

RoutingIndexManager einschließen/importieren

In OR-Tools 7.0 müssen Routingprogramme in C++ und Java den RoutingIndexManager enthalten oder importieren, wie in den folgenden Beispielen gezeigt:

C++

#include "ortools/constraint_solver/routing_index_manager.h"

Java

import com.google.ortools.constraintsolver.RoutingIndexManager;

Python- und C#-Importe bleiben unverändert.

RoutingIndexManager deklarieren

In OR-Tools Version 7.0 müssen Routingprogramme die RoutingIndexManager deklarieren und das Routingmodell erstellen, wie in den folgenden Beispielen gezeigt:

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);

Die Argumente für RoutingIndexManager sind:

• Anzahl der Standorte
• Anzahl der Fahrzeuge
• Index des Lagers (Start- und Endposition für alle Fahrzeuge)

Hinweis: In früheren Versionen wurden diese Argumente direkt an RoutingModel statt an RoutingIndexManager übergeben.

Callbacks

In Version 7.0 von OR-Tools musst du RoutingIndexManager verwenden, um Callbacks zu erstellen, z. B. den Distanz-Callback, den du dann an den Solver weitergibst. Die folgenden Beispiele zeigen, wie ein Callback für die Entfernung erstellt wird.

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);

Die Methode IndexToNode wandelt die vom Auflöser verwendeten internen Standortindexe in die Standardindizes für die Distanzmatrix um.

Anstatt den Callback wie in früheren Versionen direkt an den Solver zu übergeben, erstellen Sie in Version 7.0 zuerst transit callback index, einen Verweis auf den Callback, und übergeben ihn an den Solver (in diesem Fall durch SetArcCostEvaluatorOfAllVehicles).

Abmessungen

In den folgenden Beispielen wird gezeigt, wie Sie eine Dimension für Anforderungen und Kapazitäten erstellen, um das Routingproblem mit Kapazität für Fahrzeuge zu lösen.

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");

Drucklösungen

In OR-Tools Version 7.0 müssen Sie die RoutingIndexManager verwenden, um die Fahrzeugrouten in einer Lösung anzuzeigen. Die folgenden Beispiele zeigen, wie Lösungen in allen unterstützten Sprachen gedruckt werden.

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);
    }

Unterstützung für VRPs mit Abholung und Lieferung

OR-Tools Version 7.0 unterstützt die Lösung von Fahrzeugroutenproblemen (Vehicle Routing Problem, VRPs) mit Abhol- und Lieferdiensten. Das Ziel besteht darin, die kürzesten Routen für eine Fahrzeugflotte zu finden, die Artikel an verschiedenen Standorten abholen und liefert. Das Problem wird ähnlich wie bei einem standardmäßigen VRP eingerichtet. Zusätzlich geben Sie zusätzlich (i, j) Standorte für jeden Artikel an, wobei i der Abholort und j der Abgabeort ist. Der Routing-Lösungslöser gibt Fahrzeugrouten zurück, bei denen (i, j), i und j sich auf derselben Route befinden und das Fahrzeug i vor j besucht.

Ein Beispiel, mit dem diese Art von Problem gelöst werden kann, finden Sie unter Routenführung mit Fahrzeugen (Pickups und Deliveries).

Unterstützung für Lambda-Funktionen

Die OR-Tools-Version 7.0 unterstützt jetzt Lambda-Funktionen in C# und Java (zusätzlich zu den bereits unterstützten C++ und Python). Lambda-Funktionen bieten eine bequeme Möglichkeit, Callbacks in Routingprogrammen zu definieren. Sie können jedoch Callbacks mit Standardfunktionen definieren, wenn Sie der Meinung sind, dass dies Ihren Code lesbarer macht.

Die obigen C#- und Java-Callback-Beispiele zeigen, wie Callbacks mithilfe von Lambda-Funktionen definiert werden.

November 2018

Ankündigung der Veröffentlichung von Version 6.10

Die OR-Tools-Version 6.10 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

In den folgenden Abschnitten werden die neuen Funktionen und Verbesserungen in Version 6.10 beschrieben.

Vereinfachte Befehle zum Erstellen und Ausführen von Programmen

In Version 6.10 können Sie Programme erstellen und ausführen, indem Sie Befehle wie den folgenden eingeben:

make run SOURCE=relative/path/to/program.cc

, wobei <var>relative/path/to</var> der Pfad zu dem Verzeichnis ist, das das Programm enthält.

Hinweis: Es ist nicht mehr erforderlich, das Makefile zu bearbeiten, um Programme auszuführen.

Wenn Sie ein Programm erstellen möchten, ohne es auszuführen, geben Sie Folgendes ein:

make build SOURCE=relative/path/to/program.cc

Unter Erste Schritte mit OR-Tools finden Sie spezifische Anleitungen zum Ausführen von Programmen nach Sprache.

Unterstützung für SCIP 6.0.0

OR-Tools unterstützt jetzt SCIP 6.0.0.

Binärprogramme

Binärverteilungen wurden mit Java JDK 8 (JDK 7 für Ubuntu 14.04) erstellt.

CP-SAT-Rechner

API aktualisieren

• Fügen Sie die C++ CP-SAT CpModelBuilder API hinzu.

Beispiele

Einige Beispiele wurden verschoben.

• Community-Beispiele zu examples/contrib verschieben.
• Einige Beispiele nach ortools/<var>component</var>/samples verschieben (z.B. ortools/linear_solver/samples/simple_program.java)

September 2018

Ankündigung der Version v6.9

Wir haben die OR-Tools-Version 6.9 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierte Abhängigkeiten

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

CP-SAT-Rechner

• Wichtige Änderungen an der API – alle Details dazu finden Sie hier:
• Benennen Sie SolveWithSolutionObserver in Python in SolveWithSolutionCallback um.

• Benennen Sie NewSolution in der Klasse CpSolverSolutionCallback in Python in OnSolutionCallback um. Das folgende Beispiel zeigt die neue Möglichkeit, einen Lösungs-Callback in Python zu erstellen.

  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

• Geben Sie StopSearch beim Lösungs-Callback in Python, Java und C# frei. Die Dokumentation finden Sie hier.

• Stellen Sie ModelStats und CpSolverResponseStats in Python, Java und C# bereit.

• Die Python-Docstring-Dokumentation wurde verbessert. Die Dokumentation finden Sie hier.

• Updates an der Java-Implementierung der Solver-Schnittstelle und des Kochbuchs.

• Modulo implementieren.

• Implementierung von reservoir ändern: API mit booleschem Wert hinzufügen, um optionale Draining-/Füllereignisse anzugeben.

Linear Solver

• Geben Sie InterruptSolve in Java und C# frei.

CP Solver

• Geben Sie den Regisseur SolutionCollector in C# frei.

Python

• Unterstützung für Python 3.7 hinzufügen.
• Beim Kompilieren aus der Quelle: Bevorzugen Sie bei der Erkennung von Python python3 statt python2.

.NET

• .NET-Ebene vollständig neu schreiben
• Geben Sie ein Google.OrTools NetStandard 2.0 Nuget-Paket an, das mit dem Laufzeit-IDentifier win-x64, linux-x64 und osx-x64 kompatibel ist.
• Stelle ein NuGet-Paket für Google.OrTools.FSharp bereit.
• Fügen Sie eine Projektdatei für alle .NET-Beispiele hinzu.
• Aktualisieren Sie alle F#-Skriptbeispiele (.fsx) in ein reguläres F#-Projekt (.fs).
• Eine Dokumentation zur Generierung von .NET-Paket-Builds finden Sie hier.

Flachzink

• Unterstützung für Sätze in Flatzinc (mit nosets.mzn) hinzugefügt.

Beiträge

• Unterstützung für Binder hinzufügen. Vielen Dank an Kevin Mader.
• Legen Sie DecisionVisitor in Java-Bindungen als Director-Typ fest. Vielen Dank an Jeremy Apthorp.

Juli 2018

Ankündigung der Version v6.8

Die OR-Tools-Version 6.8 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Vorstellung des CP-SAT-Rechners

Der CP-SAT-Rechner ist ein neuer Lösungslöser für die Einschränkungsprogrammierung. Der CP-SAT-Resolver ist schneller als der ursprüngliche CP-Resolver und sollte für CP-Probleme bevorzugt werden.

Beispiele, die den CP-SAT-Resolver verwenden, finden im Verzeichnis examples auf GitHub nach Dateien, deren Namen _sat enthält.

Der ursprüngliche CP-Resolver wird über einen bestimmten Zeitraum weiter bereitgestellt, um vorhandenen Code zu unterstützen. Er wird jedoch nicht mehr unterstützt.

Neue Optionen für den CP-SAT-Rechner

Die folgenden Optionen für den CP-SAT-Resolver sind in dieser Version neu:

• Local Viertel Search (LNS): Verwenden Sie die Option SatParameters.use_lns, um LNS zu aktivieren.
• Parallele Suche: Mit der Option SatParameters.num_search_workers können Sie während einer Suche mehrere Threads aktivieren. Jeder Thread kann unterschiedliche Parameter und unterschiedliche zufällige Werte haben. Dies maximiert die Vielfalt und die Wahrscheinlichkeit, dass mindestens ein Thread Lösungen findet.

Leistungsverbesserungen für Rechner

Wir haben die Leistung der CP-SAT- und Glop-Resolver verbessert.

März 2018

Ankündigung von Version 6.7

Wir haben die OR-Tools-Version 6.7 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Auf erforderliche Abhängigkeiten aktualisieren

• Protobuf 3.5.0 -> 3.5.1.

Verschiedenes

• Refaktorieren Sie die Basis, um die abseil-cpp-Integration vorzubereiten.
• Nutzung von Travis CI- und Appveyor-Diensten für die Continuous Integration (CI).

SAT

• Leistungsverbesserung.
• Verbesserung der Python API.
• Fügen Sie die C# API bzw. CpSolver.cs (EXPERIMENTAL) hinzu.

Globus

• Code-Refaktorierung
• Leistungsverbesserung.

CMake-Support (experimentell)

• C++ OR-Tools CMake-Unterstützung hinzufügen.
• Sie müssen in der Lage sein, OR-Tools als eigenständiges CMake-Projekt zu erstellen.
• Sie müssen in der Lage sein, OR-Tools in ein bestehendes CMake-Projekt zu integrieren.
• Fügen Sie einen CMake-basierten Build mit Python-ODER-Tools hinzu.
• Generieren Sie das Python-Paket (Wheel) mit CMake.

Beiträge

• Probleme mit der winsock2.h-Neudefinition in den Fenstern wurden behoben. Vielen Dank an Florent Tollin de Rivarol.
• F#-Unterstützung (experimentell) hinzufügen. Vielen Dank an Matthew Moore. Hinweis: nur mit dem Makefile Builder verfügbar.
• Fügen Sie den .NET-Standardsupport (experimentell) hinzu. Danke an Ziad El Malki. Hinweis: nur mit dem Makefile Builder verfügbar.

November 2017

Ankündigung der Version v6.6

Wir haben die OR-Tools-Version 6.6 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierungen erforderlicher Abhängigkeiten

• Protobuf bis 3.3.0 -> 3.5.0.
• gflags zu 2.2.0 -> 2.2.1.
• CBC 2.9.8 -> 2.9.9.
• Fügen Sie das Python-Modul sechs (1.10) als erforderliche Abhängigkeit für Python hinzu.

Fehlerkorrekturen

• Pull-Anfrage Nr. 494: Refaktorierung des Namens. in einigen Editoren Kommentare für IntelliSense hinzufügen. Vielen Dank an Matthew Moore.
• Pull-Anfrage Nr. 516 Anleitung für eigenständiges F#-Binärprogramm. Vielen Dank an Matthew Moore.
• Verbessern Sie die Precision in Glop.

SAT-Rechner

• Verbesserung des internen SAT-Resolvers und Behebung verschiedener Fehler
• Füge dem SAT-Rechner eine VRP-Einschränkung hinzu, die mit dem LP-Rechner verknüpft ist.
• Ändern Sie den Lösungsbeobachter im SAT-Rechner so, dass er CpSolverResponse als Parameter verwendet.
• Verbessern Sie den Einsatz von Glop in SAT Solver.
• SAT-LP-Verbindung beschleunigen.
• Hinzufügen der Reservoir-Einschränkung zum Protokoll des Protokollzwischenspeichers SAT cp_model.

SAT/Python

• Einführung der SAT API in Python.
• Code in ortools/sat/python/cp_model.py
• Fügen Sie Beispiele in examples/python/ hinzu:
• assignment_sat.py
• assignment_with_constraints_sat.py
• code_samples_sat.py
• cp_is_fun_sat.py
• gate_scheduling_sat.py
• hidato_sat.py
• jobshop_ft06_sat.py
• nqueens_sat.py
• nurses_sat.py
• rcpsp_sat.py
• steel_mill_slab_sat.py
• worker_schedule_sat.py
• Fügen Sie die Unterstützung für das IPython-Notebook hinzu.
• Python-Beispiele werden in Notebooks exportiert und sind unter examples/notebook verfügbar.

Beispiele

• Schreiben Sie rcpsp_parser so um, dass zum Speichern des Problems das ProtoBuf-Format verwendet wird.
• Verbessern Sie den RCPSP-Parser.

Oktober 2017

Ankündigung der Version v6.5

Die OR-Tools-Version 6.5 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Änderung bei Plattformen

• Das pypi-Modul „py3-ortools“ wurde mit dem Modul „ortools“ zusammengeführt. Jetzt gibt es nur noch ein Modul: „ortools“.
• Das Hauptformat für diese Python-Module sind jetzt Wheel-Dateien. Um OR-Tools für Python aus pypi zu installieren, führen Sie einfach pip install ortools aus. Es muss eine aktuelle Version von pip installiert werden (>= 9.0.1). Dadurch sollte die neueste Version (Version 6.5) abgerufen werden.

Bug fixed

Die protobuf-JAR-Datei wird jetzt korrekt mit kompilierten Klassen erstellt.

Neue Beispiele

• Weitere F#-Beispiele wurden zum Verzeichnis examples/fsharp beigefügt (nochmals vielen Dank an Matthew Moore).
• Java MIP-Beispiele wurden ebenfalls zur Verfügung gestellt (Thanks Darian).

September 2017

Ankündigung der Version v6.4

Wir haben die OR-Tools-Version 6.4 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Änderung bei Plattformen

• Pypi-Module auf Linux-Plattformen werden jetzt als Wheel-Dateien mit dem Tag Manylinux1 bereitgestellt. Vielen Dank an Federico Ficarelli. Mit dieser Änderung haben wir die Module pro Linux zurückversetzt, die im Release vom Juli 2017 eingeführt wurden.

Neue Funktionen

• Die in GLOP verwendete Skalierungsmethode wurde verbessert.
• Das Wrapping von Evaluators in der C#-Routingbibliothek wurde korrigiert. Vielen Dank an DevNamedZed.
• Verbessern Sie die Leistung der Flatzinc-Vorauslösung für große Modelle.
• Verwenden Sie standardmäßig die SAT-Sicherung für Flatzinc.
• Verbessern Sie die Leistung des Core-basierten Ansatzes für den Satelliten-Resolver.
• Ein Fehler im Algorithmus der linearen Zuweisung wurde behoben, der fehlerhaft war.
• F#-Beispiele wurden in ortools/examples/fsharp hinzugefügt.
• Entfernen Sie die Prüfung auf positive Strafen in der Routing-Bibliothek.

August 2017

Ankündigung der Version v6.3

Die OR-Tools-Version 6.3 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Neue Downloaddateien

Python-Wheel-Dateien für Linux können jetzt zusammen mit den aktuellen Versionen aller Downloads auf der Release-Seite OR-Tools heruntergeladen werden.

Minizink-Löser

Diese Version enthält den endgültigen SAT- und Flatzinc-Code, der für die Minizinc 2017-Challenge gesendet wurde.

Juli 2017

Ankündigung der Version v6.2

Die OR-Tools-Version 6.2 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Änderung bei Plattformen

• Wir unterstützen jetzt mehrere Linux-Binärverteilungen (Ubuntu 14.04, 16.04, 17.04, CentOS 7 und Debian 9).
• Pypi-Module auf Linux-Plattformen enthalten jetzt ein Tag, das die Distribution beschreibt (Ubuntu-14.04, Ubuntu-16.04, Ubuntu-17.04, centos-7, debian-9).

Neue Funktionen

Docker unterstützt jetzt auch Linux-Artefakte. Rufen Sie or-tools/tools/docker auf und sehen Sie sich Makefile an, um mögliche Ziele zu sehen (make archive, make pypi und make pypi3).

Mit diesen Befehlen wird ein export-Unterverzeichnis erstellt, in dem binäre Artefakte hinzugefügt werden.

Juni 2017

Ankündigung der Version v6.1

Die OR-Tools-Version 6.1 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Änderung bei Plattformen

• Visual Studio 2017 wird unterstützt, Visual Studio 2013 wird nicht mehr unterstützt.
• Die macOS-Versionen 10.9 und höher werden unterstützt.

Neue Funktionen

Wir haben ein neues protobuf-Format für unseren CP-SAT-Resolver hinzugefügt. Unter ortools/sat/cp_model.proto können Sie Ihr Modell definieren und unter ortools/sat/cp_model_solver.h das Problem lösen.

Fehlerkorrekturen

Problem 420: Wir haben das fehlende __version__-Attribut in Python-Pypi-Modulen auf allen Plattformen behoben.

Mai 2017

Ankündigung der Version v6.0

Die OR-Tools-Version 6.0 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Neue Verzeichnisstruktur in C++

Wir haben die Quell-/Einschließen-Struktur der OR-Tools bei Verwendung von C++ geändert. Das Ziel besteht darin, eine bessere Kapselung der C++-Include-Dateien zu ermöglichen. Außerdem hat sie den Vorteil, dass die Verzeichnisstrukturen in C++ und Python ausgerichtet werden.

• src/ wurde in ortools/ umbenannt.
• Allen #include-Befehlen in C++-Dateien wurde jetzt das Präfix ortools hinzugefügt. #include "constraint/constraint_solver.h" ist jetzt #include "ortools/constraint/constraint_solver.h".

Neue Funktionen

• Baseball-Unterstützung. Sie können jetzt OR-Tools mit bazel, dem Build-Tool von Google, erstellen. Er ist mit Linux und Mac OS X kompatibel. Nachdem Sie Version 0.4.5 oder höher heruntergeladen haben, wechseln Sie zum Verzeichnis „or-tools“ und erstellen Sie die Beispiele: bazel build examples/cpp/....

Routen

Wir haben die Unterstützung für Pausen (z.B. Fahrzeugausfälle aufgrund des Mittagessens von Fahrern) in der Routenplanungsbibliothek implementiert. Diese Funktion wird im Beispiel für cvrptw_with_breaks.cc gezeigt.

SCIP-Unterstützung

Der Linear Solver-Wrapper unterstützt jetzt SCIP 4.0. Zuerst erstellen Sie SCIP und teilen dann or-tools mit, dass Sie SCIP nutzen werden. Eine Anleitung dazu finden Sie hier.

GLPK-Support

Auch mit „Build with GLPK“ haben wir den Weg geändert. Weitere Informationen

Bereinigungen

• Wir haben die gesamte Verwendung von hash_map und hash_set in der C++-Codebasis entfernt, da sie eingestellt werden. Sie wurden durch unordered_map und unordered_set aus dem STL ersetzt.
• Bereinigung der C#-Makefiles mit freundlicher Genehmigung von Michael Powell.

Januar 2017

Ankündigung der Version v5.1

Die OR-Tools-Version 5.1 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Neue Funktionen

Wird installiert

• Einführung einfacherer Verfahren zum Installieren von OR-Tools, entweder aus binären Distributionen oder aus Quellcode. Weitere Informationen finden Sie unter OR-Tools aus dem Binärprogramm installieren oder OR-Tools aus der Quelle installieren.

Routen

Es wurde ein Algorithmus zur Berechnung der Held-Karp-Untergrenze für symmetrische Probleme von Reiseverkäufern implementiert. Auf diese Weise können Sie eine Obergrenze für die Lücke zwischen den Kosten einer potenziell nicht optimalen Lösung und den Kosten der optimalen Lösung berechnen.

• Der Fahrzeugroutenbibliothek RoutingModel::SetBreakIntervalsOfVehicle wurde eine neue Methode hinzugefügt, mit der Sie break hinzufügen können. Das sind Zeiträume, in denen ein Fahrzeug keine Aufgaben ausführen kann (z. B. Fahren oder Besuch eines Knotens). Ein Beispiel für diese Option finden Sie unter cvrptw_with_breaks.cc.

Wird geplant

• Im Parser werden jetzt mehr Datenformate für die Projektplanungsbibliothek unterstützt.

Sat-Resolver

• Die kumulative Einschränkung des SAT-Resolvers akzeptiert jetzt optionale Intervalle, die mit der Methode NewOptionalInterval erstellt wurden. Ein Beispiel finden Sie unter https://github.com/google/or-tools/blob/master/examples/cpp/rcpsp_sat.cc.
• Sie können jetzt ein Max-SAT-Problem (Maximum satisfiability_ Problem) lösen, indem Sie das Ziel als gewichtete Summe von Literalen angeben. Es ist nicht mehr erforderlich, eine Ganzzahlvariable zu erstellen.

Leistungsverbesserungen

• SAT-Resolver: Verbesserte Leistung des Sat-Resolvers, insbesondere für die kumulative Einschränkung.
• Glop Solver: Verbesserte numerische Robustheit des Glop Solver, der jetzt noch genauere Lösungen für schwierige numerische Probleme zurückgibt.
• Flatzink-Löser
• Deutlich verbesserte Leistung des Sat-Backends für den Flatzinc-Dolmetscher.
• Die C#-Flatzinc-Schnittstelle wurde vereinfacht. Ein Beispiel für die neue Schnittstelle finden Sie unter https://github.com/google/or-tools/blob/master/examples/csharp/csfz.cs.

Fehlerkorrekturen

• Die Verwendung der Heuristik PathCheapestArc für Routenmodelle mit einem einzelnen Fahrzeug und Seiteneinschränkungen führt manchmal dazu, dass der Solver über einen übermäßig langen Zeitraum ausgeführt wird. Dies wurde durch die korrekte Berücksichtigung von Seiteneinschränkungen behoben.
• In Java stürzt der Routing-Rechner manchmal ab, wenn Probleme mit der Routenführung gelöst werden. Dieses Problem wurde in der neuesten Version behoben.

November 2016

Ankündigung der Version v5.0

Die OR-Tools-Version 5.0 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Ausführungsbeispiele

• Es wurden sprachspezifische Ziele eingeführt, die das Kompilieren und Ausführen Ihrer Programme vereinfachen, sowie die Beispiele in OR-Tools.

Sa.

• Die Einschränkungsprogrammierung wird jetzt unterstützt.
• Die Einschränkungen für diffn, kumulative , Netzwerkverbindungen und Subnetzwerke wurden implementiert.
• Implementierung der Überlastprüfung auf Grundlage des Max. Energy Filtering Algorithm for Diskrete Cumulative Constraint.
• Der all unterschiedlicher gebundener beständiger Propagator wurde implementiert, der eine bessere Weitergabe der AllDifferent-Einschränkung ermöglicht.

FlatZinc

• Implementierung eines SAT-Rechners für FlatZinc-Probleme.

Einschränkungslöser

• Es wurden die folgenden Einschränkungen implementiert :
• atMost: Legt eine Obergrenze für die Anzahl der Variablen fest, die einem bestimmten Wert entsprechen.
• MakePathPrecedenceConstraint und MakePathTransitPrecedenceConstraint: Implementieren Sie die Prioritätseinschränkung für eine Reihe von Paaren.

Routen

• AddAtSolutionCallback wurde implementiert. Dabei handelt es sich um einen Callback, der jedes Mal aufgerufen wird, wenn während der Suche eine Lösung gefunden wird.
• Die RoutingModel-Konstruktoren ohne Depot wurden entfernt. Es muss jetzt mindestens ein Depot im Routingmodell angegeben werden.

September 2016

Ankündigung der Version v4.4

Die OR-Tools-Version 4.4 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Sa.

• Erweiterte Planungs-API und modifizierte Beispiele (Weighted_tardiness_sat und jobshop_sat) zur Verwendung

Grafik

• Graph-Klassen wurden Iterator-Traits hinzugefügt.

Bereitstellung von OR-Tools

• Das NuGet-Paket wird wieder unterstützt.

August 2016

Ankündigung der Version v4.3

Die OR-Tools-Version 4.3 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Einschränkungslöser

• Die Methode NotBetween wurde implementiert, um eine Variable auf außerhalb eines bestimmten Intervalls zu beschränken.

Bankleitzahl

• Es wurde ein Parsing des Modells hinzugefügt, um vorhandene NotMember-Einschränkungen zu prüfen, wie in diesem Beispiel gezeigt, und sie in lokalen Suchfiltern zu verwenden.
• Profilerstellung für die lokale Suche wurde hinzugefügt.
• Für lokale Umzüge wurde ein Fehler behoben.

Linear Solver

• Die Berichterstellung zum SCIP-Status wurde korrigiert.

Sa.

• Implementierung der Methode SolveWithPresolve zur Vereinfachung der Verwendung des SAT-Presolver
• Die Suchwerkzeuge wurden in "src/sat/util.h|cc" neu gruppiert.
• Implementierte SMT-Planungseinschränkungen (Lazy Clause Generation): siehe jobshop_sat.cc und weighted_tardiness_sat.cc

Globus

• Leistungsverbesserung durch Ausnutzung von Datendichten in mehreren Berechnungsphasen

Flachzink

• Bei der Minizinc-Herausforderung gefundene Fehler wurden behoben.

Lp_data

• Fortlaufende Vereinfachung von Vorlagen in Iterationen.

Bereitstellung von OR-Tools

• C#-Assemblies erhalten jetzt standardmäßig starke Namen.
• Upgrade auf Protobuf3.0.0 durchgeführt.
• Wir haben ein Python-Skript hinzugefügt, um Abhängigkeiten des OR-Tools-Archivs zu prüfen.

Juli 2016

Ankündigung der Version v4.2

Die OR-Tools-Version 4.2 wurde veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Einschränkungslöser (Routing)

• Eine Disjunktion kann jetzt mit einer Kardinalität definiert werden. Dies ist die maximale Anzahl von Knoten, die innerhalb dieser Disjunktion aktiv sein können. Wenn Sie beispielsweise eine Disjunktion mit n Knoten und einer Kardinalität von k hinzufügen, dürfen k Knoten von den n Knoten aktiv sein. Dazu können Sie die neue Definition von AddDisjunction verwenden.
• Mehrere Disjunktionen pro Knoten werden jetzt unterstützt. Beispielsweise können Sie jetzt vielen Disjunktionen (D1..Dm) einen Knoten (N1) hinzufügen. Dadurch steigt die Wahrscheinlichkeit, dass du in einer dieser Apps aktiv bist. Es wurde ein schnellerer Routing-Suchalgorithmus für Probleme mit disjunkten Zeitfenstern eingeführt.
• Einschränkungslöser-Parameter zu Routingmodellparametern und log_search zu Routing-Suchparametern hinzugefügt.
• Der lokale Suchalgorithmus ist schneller bei der Lösung von Problemen mit unterschiedlichen Zeitfenstern. Weitere Informationen finden Sie im Beispiel cvrp_disjoint_tw.cc.

Globus (lineare Optimierung)

• Einführung eines schnelleren Simplex-Algorithmus.

Bereitstellung von OR-Tools

• Ein Archiv pro Plattform und keine einzelnen Archive für jedes C++-, Java- und .Net-Archiv. Python-Archive werden weiterhin auf pypi gehostet.
• Auf pypi sind wir auf Wheel-Module (.whl) unter Mac OS X und Windows umgestiegen. Es wurde ein MAJOR.MINOR-Nummerierungsschema eingeführt. Diese Nummern verwenden die Archivnamen, die Version, die in gemeinsam genutzten Bibliotheken unter Mac OS X, Python-Modulen und .NET-Assemblies gespeichert ist. Die erste Version, die wir veröffentlichen, ist v4.2 mit diesem Schema.

Juni 2016

Ankündigung der Version v2016-06

Wir haben die OR-Tools-Version v2016-06 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Einschränkungslöser

• Die meisten Instanzen der Callbacks (src/base/callback.h) wurden aus der CP-Bibliothek entfernt.
• NotMemberCt wurde hinzugefügt (die Variable kann nicht zu einem Satz von Intervallen gehören).

Routingbibliothek

• INKOMPATIBEL ÄNDERUNG: Zum Angeben der Kapazität von Fahrzeugen in AddDimensionWithVehicleCapacity müssen Sie jetzt ein Array (einen Vektor in C++) anstelle eines Callbacks übergeben.

GLOP

• Interne Darstellung der dünnbesetzten Matrix ändern.
• Leistungsverbesserungen

Grafik

• Schreiben Sie die Dijkstra- und Bellman-Ford-Algorithmen so um, dass Callbacks durch std::function (C++) ersetzt werden.
• Ändern Sie die API unterschiedlicher Diagrammimplementierungen, wenn Sie über Bögen und Knoten iterieren.

Sa.

• Entfernen Sie nicht verwendete Kernmethode (Auflösungsknoten).
• Ein Schreibtool zur Prüfung von Nachweisen für Unerfüllbarkeit wurde hinzugefügt.
• Präprozessor hinzufügen.

Bebop

• Neue Viertel hinzufügen.

Beispiele

• c++: „filelinereader“ wird in Beispielen entfernt.
• Daten: Planungsprobleme für einzelne Maschinen hinzufügen.

Dokumentation

• Sehen Sie sich die neue Dokumentation an.

April 2016

Ankündigung der Version v2016-04

Wir haben die OR-Tools-Version v2016-04 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Aktualisierte Abhängigkeiten

• Verwenden Sie in den Constraint-Programming- und Routing-Bibliotheken Protobufs anstelle von Flags. Weitere Informationen finden Sie unter http://or-tools.blogspot.fr/2016/02/heads-up-upcoming-incompatibility-in.html.

Dezember 2015

Ankündigung der Version v2015-12

Wir haben die OR-Tools-Version v2015-12 veröffentlicht. Informationen zum Aktualisieren der Version finden Sie im entsprechenden Abschnitt unter OR-Tools-Installation.

Einschränkungslöser

• Die Kompatibilität der Large Neighborhood Search im CP Solver wurde unterbrochen (siehe examples/cpp/ls_api.cc, examples/python/pyls_api.py, examples/csharp/csls_api.cs und examples/com/google/ortools/sample/LsApi.java, um die neue API zu sehen).
• Das Python-Wrapping wurde bereinigt. Unterstützen Sie benutzerdefinierte Entscheidungen im CP Solver (siehe examples/test/test_cp_api.py, um die API in Aktion zu sehen).
• Verschiedene Verbesserungen und Fehlerkorrekturen.

September 2015

Ankündigung des ersten Release auf GitHub.

Ab sofort werden die Dateien dort gespeichert.

Flachzink

• Es wurden Binärarchiven für den Flatzinc-Interpreter hinzugefügt (siehe www.minizinc.org).
• Enthält einige Fehlerbehebungen für die Version, die für den Wettkampf verwendet wurde.