docs/index.md
# cimod : C++ header-only library for a binary quadratic model
[](https://pypi.python.org/pypi/jij-cimod/)
[](https://pypi.python.org/pypi/jij-cimod/)
[](https://pypi.python.org/pypi/ji-cimod/)
[](https://pypi.python.org/pypi/jij-cimod/)
[](https://pypi.python.org/pypi/jij-cimod/)
[](https://pypi.python.org/pypi/jij-cimod/)
[](https://github.com/OpenJij/cimod/actions/workflows/ci-test.yml)
[](https://github.com/OpenJij/cimod/actions/workflows/build_and_upload.yaml)
[](https://github.com/OpenJij/cimod/actions/workflows/codeql.yml)
[](https://github.com/OpenJij/cimod/actions/workflows/buid-doc.yml)
[](https://github.com/OpenJij/cimod/actions/workflows/pages/pages-build-deployment)
[](https://www.codacy.com/gh/OpenJij/cimod/dashboard?utm_source=github.com&utm_medium=referral&utm_content=OpenJij/cimod&utm_campaign=Badge_Grade)
[](https://codeclimate.com/github/OpenJij/cimod/maintainability)
[](https://codecov.io/gh/OpenJij/cimod)
# How to use
You should only include a header `src/binary_quadratic_model.hpp` in your project.
## Example
### C++
```cpp
#include "src/binary_quadratic_model.hpp"
using namespace cimod;
int main()
{
// Set linear biases and quadratic biases
Linear<uint32_t, double> linear{ {1, 1.0}, {2, 2.0}, {3, 3.0}, {4, 4.0} };
Quadratic<uint32_t, double> quadratic
{
{std::make_pair(1, 2), 12.0}, {std::make_pair(1, 3), 13.0}, {std::make_pair(1, 4), 14.0},
{std::make_pair(2, 3), 23.0}, {std::make_pair(2, 4), 24.0},
{std::make_pair(3, 4), 34.0}
};
// Set offset
double offset = 0.0;
// Set variable type
Vartype vartype = Vartype::BINARY;
// Create a BinaryQuadraticModel instance
BinaryQuadraticModel<uint32_t, double, cimod::Dense> bqm(linear, quadratic, offset, vartype);
//linear terms -> bqm.get_linear()
//quadratic terms -> bqm.get_quadratic()
return 0;
}
```
### Python
```python
import cimod
import dimod
# Set linear biases and quadratic biases
linear = {1:1.0, 2:2.0, 3:3.0, 4:4.0}
quadratic = {(1,2):12.0, (1,3):13.0, (1,4):14.0, (2,3):23.0, (2,4):24.0, (3,4):34.0}
# Set offset
offset = 0.0
# Set variable type
vartype = dimod.BINARY
# Create a BinaryQuadraticModel instance
bqm = cimod.BinaryQuadraticModel(linear, quadratic, offset, vartype)
print(bqm.linear)
print(bqm.quadratic)
```
## For Contributor
Use `pre-commit` for auto chech before git commit.
`.pre-commit-config.yaml`
```
# pipx install pre-commit
# or
# pip install pre-commit
pre-commit install
```
## Install
### via this directory
```sh
$ python -m pip install -vvv .
```
### via pip
```sh
# Binary
$ pip install jij-cimod
# From Source
$ pip install --no-binary=jij-cimod jij-cimod
```
## Test
### Python
```sh
$ python -m venv .venv
$ pip install pip-tools
$ pip-compile setup.cfg
$ pip-compile dev-requirements.in
$ pip-sync requirements.txt dev-requirements.txt
$ source .venv/bin/activate
$ export CMAKE_BUILD_TYPE=Debug
$ python setup.py --force-cmake install --build-type Debug -G Ninja
$ python setup.py --build-type Debug test
$ python -m coverage html
```
### C++
```sh
$ mkdir build
$ cmake -DCMAKE_BUILD_TYPE=Debug -S . -B build
$ cmake --build build --parallel
$ cd build
$ ./tests/cimod_test
# Alternatively Use CTest
$ ctest --extra-verbose --parallel --schedule-random
```
Needs: CMake > 3.22, C++17
- Format
```sh
$ pip-compile format-requirements.in
$ pip-sync format-requirements.txt
```
```sh
$ python -m isort
$ python -m black
```
- Aggressive Format
```sh
$ python -m isort --force-single-line-imports --verbose ./cimod
$ python -m autoflake --in-place --recursive --remove-all-unused-imports --ignore-init-module-imports --remove-unused-variables ./cimod
$ python -m autopep8 --in-place --aggressive --aggressive --recursive ./cimod
$ python -m isort ./cimod
$ python -m black ./cimod
```
- Lint
```sh
$ pip-compile setup.cfg
$ pip-compile dev-requirements.in
$ pip-compile lint-requirements.in
$ pip-sync requirements.txt dev-requirements.txt lint-requirements.txt
```
```sh
$ python -m flake8
$ python -m mypy
$ python -m pyright
```
## Benchmark
### Benchmark code
```python
import dimod
import cimod
import time
fil = open("benchmark", "w")
fil.write("N t_dimod t_cimod\n")
def benchmark(N, test_fw):
linear = {}
quadratic = {}
spin = {}
# interactions
for i in range(N):
spin[i] = 1
for elem in range(N):
linear[elem] = 2.0*elem;
for i in range(N):
for j in range(i+1, N):
if i != j:
quadratic[(i,j)] = (i+j)/(N)
t1 = time.time()
# initialize
a = test_fw.BinaryQuadraticModel(linear, quadratic, 0, test_fw.BINARY)
a.change_vartype(test_fw.SPIN)
# calculate energy for 50 times.
for _ in range(50):
print(a.energy(spin))
t2 = time.time()
return t2-t1
d_arr = []
c_arr = []
for N in [25, 50, 100, 200, 300, 400, 600, 800,1000, 1600, 2000, 3200, 5000]:
print("N {}".format(N))
d = benchmark(N, dimod)
c = benchmark(N, cimod)
print("{} {} {}".format(N, d, c))
fil.write("{} {} {}\n".format(N, d, c))
```