always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Readme

Browse Source
This commit is contained in:
Corentin Le Molgat
2018-02-21 14:20:23 +01:00
parent 747d962dfd
commit 21ca5aa5e2
4 changed files with 233 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
CONTRIBUTING → CONTRIBUTING.md
View File

46
README
View File

@@ -1,46 +0,0 @@
These modules have been tested under:
- Ubuntu 16.04 up (64-bit).
- Mac OS X El Capitan with Xcode 7.x (64 bit).
- Microsoft Windows with Visual Studio 2015 and 2017 (64-bit)
Upon checking out the repository, you will get the following structure:
or-tools/
LICENSE-2.0.txt <- Apache license
Makefile <- Top-level Makefile
CONTRIBUTING <- Contribution guidelines
README <- This file
bin/ <- Compiled binaries
dependencies/ <- Built dependencies
examples/ <- Root directory for all examples
examples/com/ <- Java examples
examples/cpp/ <- C++ examples
examples/csharp/ <- C# examples
examples/data/ <- Data files for examples
examples/flatzinc/ <- Flatzinc examples
examples/fsharp/ <- F# examples
examples/notebook/ <- Jupyter/IPython notebooks
examples/python/ <- Python examples
examples/tests/ <- C# unit tests and bug reports
lib/ <- Libraries and jar files
makefiles/ <- Subsidiary makefiles
objs/ <- C++ object files
ortools/ <- Source code
ortools/algorithms/ <- Basic algorithms
ortools/base/ <- Basic utilities
ortools/bop/ <- Boolean solver based on SAT
ortools/com/ <- C# and Java source files
ortools/constraint_solver/ <- Constraint solver
ortools/flatzinc/ <- Flatzinc interpreter
ortools/gen/ <- Generated files
ortools/glop/ <- Linear solver
ortools/graph/ <- Graph algorithms
ortools/linear_solver/ <- Linear solver wrapper
ortools/lp_data/ <- Data structures for linear model
ortools/ortools <- Python source code
ortools/sat/ <- Sat solver
ortools/util/ <- Utilities needed by the constraint solver
tools/ <- Windows binaries
For installation instructions (both source and binary), visit
https://developers.google.com/optimization/introduction/installing.

133
README.md Normal file
View File

@@ -0,0 +1,133 @@
# OR-Tools - Google Optimization Tools
[![Build
Status](https://travis-ci.org/google/or-tools.svg?branch=master)](https://travis-ci.org/google/or-tools)
Google's software suite for combinatorial optimization.
## Table of Contents
* [About OR-Tools](#about-or-tools)
* [Codemap](#codemap)
* [Installation](#installation)
* [Experimental Build with CMake](#experimental-build-with-cmake)
* [Quick Start](#quick-start)
* [Documentation](#documentation)
* [Contributing](#contributing)
* [License](#license)
## About OR-Tools
Google Optimization Tools (a.k.a., OR-Tools) is an open-source, fast and
portable software suite for solving combinatorial optimization problems.
The suite contains:
* A constraint programming solver;
* A linear programming solvers;
* Wrappers around commercial and other open source solvers, including mixed
integer solvers;
* Bin packing and knapsack algorithms;
* Algorithms for the Traveling Salesman Problem and Vehicule Routing Problem;
* Graph algorithms (shortest paths, min cost flow, max flow, linear sum
assignment).
We wrote OR-Tools in C++, but also provide wrappers in Python, C# and
Java.
## Codemap
This software suite is composed of the following components:
```
├── Makefile <- Top-level Makefile
├── makefiles <- Subsidiary makefiles
├── CMakeLists.txt <- Top-level CMakeLists.txt
├── cmake <- Subsidiary CMake files
├── ortools <- Root directory for Source code
│ ├── base <- Basic utilities
│ ├── algorithms <- Basic algorithms
│ │   ├── csharp <- C# wrapper
│ │   ├── java <- Java wrapper
│ │   └── python <- Python wrapper
│ ├── util <- Utilities needed by the constraint solver
│ ├── constraint_solver <- Constraint solver
│ │   ├── csharp <- C# wrapper
│ │   ├── java <- Java wrapper
│ │   └── python <- Python wrapper
│ ├── sat <- Sat solver
│ │   ├── csharp <- C# wrapper
│ │   ├── java <- Java wrapper
│ │   └── python <- Python wrapper
│ ├── bop <- Boolean solver based on SAT
│ ├── linear_solver <- Linear solver wrapper
│ │   ├── csharp <- C# wrapper
│ │   ├── java <- Java wrapper
│ │   └── python <- Python wrapper
│ ├── glop <- Linear solver
│ ├── lp_data <- Data structures for linear models
│ ├── graph <- Graph algorithms
│ │   ├── csharp <- C# wrapper
│ │   ├── java <- Java wrapper
│ │   └── python <- Python wrapper
│ ├── flatzinc <- FlatZinc interpreter
│ └── com
│    └── google
│    └── ortools <- C# and Java source files
├── examples <- Root directory for all examples
│   ├── data <- Data files for examples
│   ├── cpp <- C++ examples
│   ├── python <- Python examples
│   ├── notebook <- Jupyter/IPython notebooks
│   ├── csharp <- C# examples
│   ├── fsharp <- F# examples
│   ├── com <- Java examples
│   ├── flatzinc <- FlatZinc examples
│   └── tests <- Unit tests and bug reports
├── LICENSE-2.0.txt <- Apache license
├── gen <- Generated files
└── tools <- Delivery Tools (e.g. Windows GNU binaries, scripts, dockers)
```
## Installation
This software suite has been tested under:
- Ubuntu 16.04 and up (64-bit);
- Mac OSX El Capitan with Xcode 7.x (64-bit);
- Microsoft Windows with Visual Studio 2015 and 2017 (64-bit).
OR-Tools currently builds with a Makefile, but also provides Bazel support.
For installation instructions (both source and binary), please visit
https://developers.google.com/optimization/introduction/installing.
## Experimental Build with CMake
We also provide experimental CMake support.<br>Please check the
[CMake build instructions](cmake/README.md).
## Quick Start
The best way to learn how to use OR-Tools is to follow the tutorials in our
developer guide:
https://developers.google.com/optimization/introduction/using
If you want to learn from code examples, take a look at the examples in the
[examples](examples) directory.
## Documentation
The complete documentation for OR-Tools is available at:
https://developers.google.com/optimization/
## Contributing
The [CONTRIBUTING.md](CONTRIBUTING.md) file contains instructions on how to
submit the Contributor License Agreement before sending any pull requests (PRs).
Of course, if you're new to the project, it's usually best to discuss any
proposals and reach consensus before sending your first PR.
## License
The OR-Tools software suite is licensed under the terms of the Apache license.
<br>See [LICENSE-2.0](LICENSE-2.0.txt) for more information.

100
cmake/README.md Normal file
View File

@@ -0,0 +1,100 @@
# OR-Tools CMake Build Instructions
OR-Tools comes with a CMake build script ([CMakeLists.txt](../CMakeLists.txt))
that can be used on a wide range of platforms (the "C" stands for
cross-platform). If you don't have CMake installed already, you can download it
for free from <http://www.cmake.org/>.
CMake works by generating native Makefiles or build projects that can be used in
the compiler environment of your choice.<br>You can either build OR-Tools with
CMake as a standalone project or it can be incorporated into an existing CMake
project.
**warning: Currently OR-Tools CMake doesn't support Java nor C#.**
## Table of Contents
* [Building OR-Tools with CMake](#building-or-tools-with-cmake)
* [Consuming OR-Tools in a CMake Project](#consuming-or-tools-in-a-cmake-project)
* [Incorporating OR-Tools into a CMake Project](#incorporating-or-tools-into-a-cmake-project)
For API/ABI compatibility reasons, if you will be using OR-Tools inside a larger
C++ project, we recommend using CMake and incorporate OR-Tools as a CMake
subproject (i.e. using `add_sudirectory()`).
## Building OR-Tools with CMake
When building OR-Tools as a standalone project on Unix-like systems with GNU
Make, the typical workflow is:
1. Get the source code and change to it.
```sh
git clone https://github.com/google/or-tools.git
cd or-tools
```
2. Run CMake to configure the build tree.
```sh
cmake -H. -Bbuild -G "Unix Makefiles"
```
note: To get the list of available generators (e.g. Visual Studio), use `-G ""`
3. Afterwards, generated files can be used to compile the project.
```sh
cmake --build build
```
4. Test the build software (optional).
```sh
cmake --build build --target test
```
5. Install the built files (optional).
```sh
cmake --build build --target install
```
## Consuming OR-Tools in a CMake Project
If you already have OR-Tools installed in your system, you can use the CMake
command
[`find_package()`](https://cmake.org/cmake/help/latest/command/find_package.html)
to include OR-Tools in your C++ CMake Project.
```cmake
cmake_minimum_required(VERSION 3.0.2)
project(myproj VERSION 1.0)
find_package(ortools CONFIG REQUIRED)
add_executable(myapp main.cpp)
target_link_libraries(myapp ortools::ortools)
```
Include directories, compile definitions and compile options will be added
automatically to your target as needed.
## Incorporating OR-Tools into a CMake Project
The recommendations below are similar to those for using CMake within the
googletest framework
(<https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project>)
Thus, you can use the CMake command
[`add_subdirectory()`](https://cmake.org/cmake/help/latest/command/add_subdirectory.html)
to include OR-Tools directly from a subdirectory of your C++ CMake project.<br>
Note: The **ortools::ortools** target is in this case an ALIAS library target
for the **ortools** library target.
```cmake
cmake_minimum_required(VERSION 3.0.2)
project(myproj VERSION 1.0)
add_subdirectory(or-tools)
add_executable(myapp main.cpp)
target_link_libraries(myapp ortools::ortools)
```
Again, include directories, compile definitions and compile options will be
added automatically to your target as needed.