Cimod

https://jij-inc.github.io/Cimod-Documentation
Admin
Cimod is a C++ library for binary quadratic models (Ising and QUBO) and binary polynomial models...
Tokens:185,927
Snippets:858
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### C++ Example: Creating an Empty Model

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Illustrates the usage of the static 'empty' method to create a new, uninitialized BinaryQuadraticModel.

```cpp
BinaryQuadraticModel empty(Vartype vartype) {
  return BinaryQuadraticModel(Linear<IndexType, FloatType>(), Quadratic<IndexType, FloatType>(), 0.0, vartype);
}
```

--------------------------------

### APIDOC: cimod Namespace and Variable Definitions

Source: https://jij-inc.github.io/Cimod-Documentation/index

API documentation detailing the cimod namespace and specific variable definitions used within the library, including references to their source files and line numbers.

```APIDOC
cimod
  Namespace for cimod library components.
  Definition: binary_polynomial_model.hpp:139

cimod.model.binary_polynomial_model.vartype
  vartype
  Definition: binary_polynomial_model.py:412

cimod.model.legacy.binary_quadratic_model.quadratic
  quadratic
  Definition: legacy/binary_quadratic_model.py:405

cimod.model.legacy.binary_quadratic_model.offset
  offset
  Definition: legacy/binary_quadratic_model.py:399
```

--------------------------------

### BinaryQuadraticModel Serialization Example

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

This snippet shows how to serialize a BinaryQuadraticModel object into a JSON format suitable for storage or transmission. It includes a Python example demonstrating the usage and expected output.

```python
import dimod

bqm = dimod.BinaryQuadraticModel({'c': -1, 'd': 1}, {('a', 'd'): 2, ('b', 'e'): 5, ('a', 'c'): 3}, 0.0, dimod.BINARY)

# Serialize the BQM to a dictionary representing JSON
serializable_bqm = bqm.to_serializable()
print(serializable_bqm)

# Expected output structure (values may vary based on exact BQM):
# {
#     'info': {}, 
#     'linear': {'c': -1.0, 'd': 1.0},
#     'quadratic': {('a', 'd'): 2.0, ('b', 'e'): 5.0, ('a', 'c'): 3.0},
#     'offset': 0.0,
#     'num_variables': 5,
#     'variable_type': 'BINARY'
# }
```

--------------------------------

### C++: Create and Print BinaryQuadraticModel and BinaryPolynomialModel

Source: https://jij-inc.github.io/Cimod-Documentation/index

This C++ code snippet demonstrates how to initialize and use BinaryQuadraticModel and BinaryPolynomialModel. It shows setting linear, quadratic, and polynomial biases, defining variable types, and printing model information. It includes necessary headers and namespace usage.

```cpp
#include "../src/binary_quadratic_model.hpp"
#include "../src/binary_polynomial_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 variable type
Vartype vartype = Vartype::BINARY;

// Set offset
double offset = 0.0;

// Create a BinaryQuadraticModel instance
BinaryQuadraticModel<uint32_t, double> bqm(linear, quadratic, offset, vartype);

// Print informations of bqm
bqm.print();

//Set polynomial biases
Polynomial<uint32_t, double> polynomial {
  //Linear biases
  {{1}, 1.0}, {{2}, 2.0}, {{3}, 3.0},
  //Quadratic biases
  {{1, 2}, 12.0}, {{1, 3}, 13.0}, {{2, 3}, 23.0},
  //Polynomial bias
  {{1, 2, 3}, 123.0}
};

// Create a BinaryPolynominalModel instance
BinaryPolynomialModel<uint32_t, double> bpm(polynomial, vartype);

// Print informations of bpm
bpm.print();

return 0;

}
```

--------------------------------

### BinaryPolynomialModel Constructor (variables, poly_key_distance_list)

Source: https://jij-inc.github.io/Cimod-Documentation/binary__polynomial__model_8hpp_source

Initializes BinaryPolynomialModel with a list of variables and polynomial key/value lists. Includes validation, variable deduplication, and parallel processing for interaction setup.

```C++
BinaryPolynomialModel(
    const std::vector<IndexType> &variables,
    const PolynomialKeyList<std::size_t> &poly_key_distance_list,
    const PolynomialValueList<FloatType> &poly_value_list,
    const Vartype vartype ) : 
    vartype_( vartype ) {
    if ( vartype_ == Vartype::NONE ) {
        throw std::runtime_error( "Unknown vartype detected" );
    }

    if ( poly_key_distance_list.size() != poly_value_list.size() ) {
        throw std::runtime_error( "The sizes of key_list and value_list must match each other" );
    }

    variables_ = std::unordered_set<IndexType>( variables.begin(), variables.end() );

    if ( variables_.size() != variables.size() ) {
        throw std::runtime_error( "Unknown error. It seems that the input variables contain the same variables" );
    }

    std::size_t num_interactions = poly_key_distance_list.size();
    poly_key_list_.resize( num_interactions );
    poly_value_list_.resize( num_interactions );

#pragma omp parallel for
    for ( int64_t i = 0; i < ( int64_t )num_interactions; ++i ) {
        std::vector<IndexType> temp;
        for ( const auto &it : poly_key_distance_list[ i ] ) {
            temp.push_back( variables[ it ] );
        }
        poly_key_list_[i] = temp;
        poly_value_list_[i] = poly_value_list[i];
    }
}
```

--------------------------------

### BinaryQuadraticModel Constructors

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Provides documentation for the different constructors of the BinaryQuadraticModel class. These constructors allow initialization using sparse matrices, dense matrices, and include options for setting offsets and labels.

```APIDOC
BinaryQuadraticModel(const SparseMatrix &mat, const std::vector< IndexType > &labels_vec, const Vartype vartype)
  - Constructor for BinaryQuadraticModel using a sparse matrix.
  - Intended for developers.
  - Parameters:
    - mat: The sparse matrix representing the quadratic terms.
    - labels_vec: A vector of labels for the variables.
    - vartype: The type of variables (e.g., binary).
  - Definition: binary_quadratic_model.hpp:1257

BinaryQuadraticModel(const Eigen::Ref< const DenseMatrix > &mat, const std::vector< IndexType > &labels_vec, const Vartype vartype, bool fix_format=true)
  - Constructor for BinaryQuadraticModel using a dense matrix.
  - Parameters:
    - mat: A reference to the dense matrix.
    - labels_vec: A vector of labels for the variables.
    - vartype: The type of variables.
    - fix_format: Optional flag to fix matrix format.
  - Definition: binary_quadratic_model.hpp:1220

BinaryQuadraticModel(const SparseMatrix &mat, const std::vector< IndexType > &labels_vec, const FloatType &offset, const Vartype vartype)
  - Constructor for BinaryQuadraticModel using a sparse matrix and an offset.
  - Intended for developers.
  - Parameters:
    - mat: The sparse matrix representing the quadratic terms.
    - labels_vec: A vector of labels for the variables.
    - offset: The offset value for the model.
    - vartype: The type of variables.
  - Definition: binary_quadratic_model.hpp:1238
```

--------------------------------

### Get item from Polynomial using get

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1model_1_1binary__polynomial__model_1_1Polynomial

Retrieves an item from the Polynomial instance. Takes a key and an optional default value. References internal `__bpm` and `declare_BQM`.

```python
cimod.model.binary_polynomial_model.Polynomial.get(self, arg1, arg2=None)
```

--------------------------------

### cimod::BinaryQuadraticModel Class Members

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel-members

This entry documents the members of the cimod::BinaryQuadraticModel class. It includes methods for internal management, data manipulation, and conversion related to binary and polynomial quadratic models. Detailed parameter descriptions, return values, and usage examples are not available in the source text.

```APIDOC
cimod::BinaryQuadraticModel< IndexType, FloatType, DataType >

  _add_new_label(IndexType label_i)
    - Adds a new label to the model.

  _add_triangular_elements(const DenseMatrix &mat, bool fix_format, dispatch_t< T, Dense >=nullptr)
    - Adds triangular elements from a dense matrix.

  _add_triangular_elements(const DenseMatrix &mat, bool fix_format, dispatch_t< T, Sparse >=nullptr)
    - Adds triangular elements from a dense matrix (sparse dispatch).

  _binary_to_spin(dispatch_t< T, Dense >=nullptr)
    - Converts binary representation to spin representation (dense dispatch).

  _binary_to_spin(dispatch_t< T, Sparse >=nullptr)
    - Converts binary representation to spin representation (sparse dispatch).

  _delete_label(IndexType label_i, bool force_delete=true)
    - Deletes a label from the model.

  _delete_label_from_mat(IndexType label_i, dispatch_t< T, Dense >=nullptr)
    - Deletes a label from the internal matrix (dense dispatch).

  _delete_label_from_mat(IndexType label_i, dispatch_t< T, Sparse >=nullptr)
    - Deletes a label from the internal matrix (sparse dispatch).

  _generate_linear() const
    - Generates linear terms for the model.

  _generate_quadratic(dispatch_t< T, Dense >=nullptr) const
    - Generates quadratic terms from a dense matrix.

  _generate_quadratic(dispatch_t< T, Sparse >=nullptr) const
    - Generates quadratic terms from a sparse matrix.

  _idx_to_label(IndexType index)
    - Converts an internal index to a label.

  _initialize_quadmat(const Linear< IndexType, FloatType > &linear, const Quadratic< IndexType, FloatType > &quadratic, dispatch_t< T, Dense >=nullptr)
    - Initializes the quadratic matrix with linear and quadratic terms (dense dispatch).

  _initialize_quadmat(const Linear< IndexType, FloatType > &linear, const Quadratic< IndexType, FloatType > &quadratic, dispatch_t< T, Sparse >=nullptr)
    - Initializes the quadratic matrix with linear and quadratic terms (sparse dispatch).

  _initialize_quadmat(const DenseMatrix &mat, const std::vector< IndexType > &labels_vec, bool fix_format)
    - Initializes the quadratic matrix from a dense matrix and labels.

  _initialize_quadmat(const SparseMatrix &mat, const std::vector< IndexType > &labels_vec)
    - Initializes the quadratic matrix from a sparse matrix and labels.
```

--------------------------------

### BinaryPolynomialModel Class Constructors and Methods

Source: https://jij-inc.github.io/Cimod-Documentation/main_8hpp_source

Documentation for the BinaryPolynomialModel (BPM) class, detailing its constructors for initializing a model from various polynomial representations and a method to retrieve the polynomial.

```APIDOC
declare_BPM(py::module& m, const std::string& name)
  - Function to declare Python bindings for the BinaryPolynomialModel class.

BinaryPolynomialModel(polynomial, vartype)
  - Constructor initializing BPM with a polynomial and variable type.
  - Parameters:
    - polynomial: The polynomial representation.
    - vartype: The variable type (e.g., BINARY).

BinaryPolynomialModel(keys, values, vartype)
  - Constructor initializing BPM from lists of keys and values.
  - Parameters:
    - keys: A list of polynomial keys.
    - values: A list of polynomial values.
    - vartype: The variable type.

BinaryPolynomialModel(variables, keys_distance, values, vartype)
  - Constructor initializing BPM with variables, key distances, and values.
  - Parameters:
    - variables: A list of variables.
    - keys_distance: Distances for keys.
    - values: A list of polynomial values.
    - vartype: The variable type.

BinaryPolynomialModel::get_polynomial()
  - Retrieves the polynomial representation of the BPM.
  - Returns: A dictionary representing the polynomial.
```

--------------------------------

### C++: Get Number of Variables

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Retrieves the count of variables currently stored in the model. This is determined by the size of the internal m_linear map.

```cpp
size_t get_num_variables() const {
  return m_linear.size();
}
```

--------------------------------

### Get Variables Set

Source: https://jij-inc.github.io/Cimod-Documentation/binary__polynomial__model_8hpp_source

Returns a set containing all unique variables managed by the model.

```cpp
const std::unordered_set<IndexType> &GetVariables() const {
  return variables_;
}
```

--------------------------------

### Initialize Quadratic Matrix and Labels

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Initializes the internal quadratic matrix and sets up the mapping between indices and labels for the BinaryQuadraticModel. It takes a sparse matrix and a vector of labels as input, sorts the labels, and prepares internal data structures.

```cpp
void _initialize_quadmat( const SparseMatrix& mat, const std::vector<IndexType>& labels_vec ) {
  this->_quadmat = mat;
  std::unordered_set<IndexType> labels( labels_vec.begin(), labels_vec.end() );
  this->_idx_to_label = std::vector<IndexType>( labels.begin(), labels.end() );
  std::sort( this->_idx_to_label.begin(), this->_idx_to_label.end() );
  this->_set_label_to_idx();
}
```

--------------------------------

### C++ Example: Adding a Variable

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Shows how to add a single variable with its linear bias to the BinaryQuadraticModel.

```cpp
void add_variable(const IndexType &v, const FloatType &bias) {
  // add new label if not exist
  _add_new_label(v);
  _mat(v) += bias;
}
```

--------------------------------

### Get BinaryQuadraticModel Offset

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Retrieves the current offset value stored within the BinaryQuadraticModel. This is a simple getter method for the internal m_offset member.

```cpp
return this->[m_offset](classcimod_1_1BinaryQuadraticModel.html#a84fff7f0a252a0e90bff4d0d13f0de05);
}
```

--------------------------------

### BinaryQuadraticModel Creation and Loading

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8py

Provides factory functions and constructors to create BinaryQuadraticModel objects. Supports initialization from direct parameters, JSON, NumPy matrices, QUBO, and Ising formats. Includes methods for extracting model components and handling different variable types.

```APIDOC
cimod.model.binary_quadratic_model.BinaryQuadraticModel

Constructor for BinaryQuadraticModel.

Signature:
BinaryQuadraticModel(linear, quadratic, offset=0.0, vartype='BINARY', **kwargs)

Parameters:
  - linear: A dictionary or list of tuples representing linear biases. Format: {variable: bias} or [(variable, bias)].
  - quadratic: A dictionary or list of tuples representing quadratic biases. Format: {(variable1, variable2): bias} or [(variable1, variable2, bias)].
  - offset: A float representing the constant offset of the model.
  - vartype: The type of variables in the model ('BINARY' or 'SPIN'). Defaults to 'BINARY'.
  - **kwargs: Additional keyword arguments.

Returns:
  A BinaryQuadraticModel object.

Related:
  - make_BinaryQuadraticModel
  - bqm_from_numpy_matrix
  - bqm_from_qubo
  - bqm_from_ising
  - make_BinaryQuadraticModel_from_JSON
```

```APIDOC
cimod.model.binary_quadratic_model.make_BinaryQuadraticModel

Factory function to create a BinaryQuadraticModel.

Signature:
make_BinaryQuadraticModel(linear, quadratic, offset=0.0, vartype='BINARY', **kwargs)

Parameters:
  - linear: Linear biases (dict or list of tuples).
  - quadratic: Quadratic biases (dict or list of tuples).
  - offset: Constant offset (float).
  - vartype: Variable type ('BINARY' or 'SPIN').
  - **kwargs: Additional keyword arguments.

Returns:
  A BinaryQuadraticModel object.

Related:
  - BinaryQuadraticModel constructor
  - bqm_from_numpy_matrix
  - bqm_from_qubo
  - bqm_from_ising
```

```APIDOC
cimod.model.binary_quadratic_model.make_BinaryQuadraticModel_from_JSON

Creates a BinaryQuadraticModel from a JSON object.

Signature:
make_BinaryQuadraticModel_from_JSON(obj)

Parameters:
  - obj: A JSON object representing the BQM. Expected format includes 'linear', 'quadratic', 'offset', and 'vartype'.

Returns:
  A BinaryQuadraticModel object.

Related:
  - BinaryQuadraticModel constructor
  - bqm_from_numpy_matrix
  - bqm_from_qubo
  - bqm_from_ising
```

```APIDOC
cimod.model.binary_quadratic_model.bqm_from_numpy_matrix

Creates a BinaryQuadraticModel from a NumPy matrix.

Signature:
bqm_from_numpy_matrix(mat, list_variables=None, offset=0.0, vartype='BINARY', **kwargs)

Parameters:
  - mat: A NumPy array representing the QUBO or Ising matrix.
  - list_variables: An optional list of variable labels corresponding to the matrix indices.
  - offset: Constant offset (float).
  - vartype: Variable type ('BINARY' or 'SPIN').
  - **kwargs: Additional keyword arguments.

Returns:
  A BinaryQuadraticModel object.

Related:
  - BinaryQuadraticModel constructor
  - make_BinaryQuadraticModel
  - bqm_from_qubo
  - bqm_from_ising
```

```APIDOC
cimod.model.binary_quadratic_model.bqm_from_qubo

Creates a BinaryQuadraticModel from a QUBO dictionary.

Signature:
bqm_from_qubo(Q, offset=0.0, **kwargs)

Parameters:
  - Q: A dictionary representing the QUBO. Keys are tuples (variable1, variable2) for quadratic terms and single variables for linear terms. Values are biases.
  - offset: Constant offset (float).
  - **kwargs: Additional keyword arguments.

Returns:
  A BinaryQuadraticModel object.

Related:
  - BinaryQuadraticModel constructor
  - make_BinaryQuadraticModel
  - bqm_from_numpy_matrix
  - bqm_from_ising
```

```APIDOC
cimod.model.binary_quadratic_model.bqm_from_ising

Creates a BinaryQuadraticModel from Ising parameters.

Signature:
bqm_from_ising(linear, quadratic, offset=0.0, **kwargs)

Parameters:
  - linear: A dictionary or list of tuples representing linear biases (h).
  - quadratic: A dictionary or list of tuples representing quadratic biases (J).
  - offset: Constant offset (float).
  - **kwargs: Additional keyword arguments.

Returns:
  A BinaryQuadraticModel object.

Related:
  - BinaryQuadraticModel constructor
  - make_BinaryQuadraticModel
  - bqm_from_numpy_matrix
  - bqm_from_qubo
```

--------------------------------

### C++: Get Total Number of Variables (length)

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Returns the total number of variables in the BinaryQuadraticModel. This method acts as an alias for the get_num_variables() function.

```cpp
size_t length() const {
  return get_num_variables();
}
```

--------------------------------

### Python Package Initialization Variables

Source: https://jij-inc.github.io/Cimod-Documentation/____init_____8py

Defines common variables used in Python package initialization files (__init__.py). `__path__` is extended to include the package's directory, and `__all__` typically lists the public API members.

```Python
cimod.__path__ = extend_path(__path__, [__name__])
```

```Python
cimod.__all__
```

--------------------------------

### Get Variables - cimod::BinaryQuadraticModel

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel_3_01IndexType_00_01FloatType_00_01Dict_01_4

Retrieves a list of all variables present in the BinaryQuadraticModel. This is useful for iterating through or identifying the model's components.

```C++
template<typename IndexType, typename FloatType>
const std::vector<IndexType> & cimod::BinaryQuadraticModel<IndexType, FloatType, Dict>::get_variables() const inline

Get variables.

Returns:
  variables

References declare_BQM().
```

--------------------------------

### BinaryQuadraticModel Utility Methods

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel_3_01IndexType_00_01FloatType_00_01Dict_01_4-members

Utility methods for the BinaryQuadraticModel class, including getting the model length and defining a JSON type alias.

```APIDOC
size_t BinaryQuadraticModel<IndexType, FloatType, Dict>::length() const
  - Returns the total number of terms (linear and quadratic) in the model.
  - Returns: The total count of terms.

typedef json BinaryQuadraticModel<IndexType, FloatType, Dict>::json;
  - Defines a type alias 'json' for the underlying JSON type used by the model.
```

--------------------------------

### BQM Constructors

Source: https://jij-inc.github.io/Cimod-Documentation/main_8hpp_source

Defines the ways to initialize a BQM object. Supports creation from a SparseMatrix and Vartype, or by copying another BQM instance.

```APIDOC
BQM::BQM(const SparseMatrix& mat, std::vector<IndexType> labels_vec, Vartype vartype)
  - Constructs a BQM from a sparse matrix, labels, and variable type.

BQM::BQM(const BQM& bqm)
  - Constructs a BQM by copying an existing BQM object.
```

--------------------------------

### BinaryQuadraticModel Class Methods

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Comprehensive documentation for the methods of the cimod::BinaryQuadraticModel class, detailing their signatures, parameters, return values, and functionality for managing binary quadratic models.

```APIDOC
cimod::BinaryQuadraticModel

This class represents a Binary Quadratic Model (BQM), which is a mathematical formulation used in quantum computing and optimization problems. It supports various operations for creating, modifying, and querying BQMs.

Methods:

- **_quadmat_get(size_t i, size_t j, dispatch_t< T, Sparse >=nullptr)**: Accesses elements for a sparse matrix representation of the quadratic terms.
  - **Parameters**:
    - `i`: Row index.
    - `j`: Column index.
    - `dispatch_t< T, Sparse >=nullptr`: Dispatcher for sparse matrix access.
  - **Returns**:
    - `FloatType`: The value of the element at (i, j).
  - **Definition**:
    binary_quadratic_model.hpp:268

- **_quadmat_get(size_t i, size_t j, dispatch_t< T, Dense >=nullptr) const**: Accesses elements for a dense matrix representation of the quadratic terms.
  - **Parameters**:
    - `i`: Row index.
    - `j`: Column index.
    - `dispatch_t< T, Dense >=nullptr`: Dispatcher for dense matrix access.
  - **Returns**:
    - `FloatType`: The value of the element at (i, j).
  - **Definition**:
    binary_quadratic_model.hpp:253

- **from_ising(const Linear< IndexType, FloatType > &linear, const Quadratic< IndexType, FloatType > &quadratic, FloatType offset=0.0)**: Creates a binary quadratic model from an Ising problem formulation.
  - **Parameters**:
    - `linear`: A Linear object representing the linear biases.
    - `quadratic`: A Quadratic object representing the quadratic biases.
    - `offset`: An optional offset value for the model.
  - **Returns**:
    - `BinaryQuadraticModel< IndexType, FloatType, DataType >`: A new BQM instance.
  - **Definition**:
    binary_quadratic_model.hpp:1781

- **add_interaction(const IndexType &u, const IndexType &v, const FloatType &bias)**: Adds an interaction and/or quadratic bias between two variables.
  - **Parameters**:
    - `u`: The first variable index.
    - `v`: The second variable index.
    - `bias`: The bias value for the interaction.
  - **Returns**:
    - `void`
  - **Definition**:
    binary_quadratic_model.hpp:1401

- **from_serializable(const json &input, dispatch_t< T, Sparse >=nullptr)**: Creates a BinaryQuadraticModel instance from a serializable object (e.g., JSON).
  - **Parameters**:
    - `input`: The serializable object containing the BQM data.
    - `dispatch_t< T, Sparse >=nullptr`: Dispatcher for sparse matrix handling.
  - **Returns**:
    - `BinaryQuadraticModel< IndexType_serial, FloatType_serial, DataType >`: A new BQM instance.
  - **Definition**:
    binary_quadratic_model.hpp:2020

- **_set_label_to_idx()**: Sets the internal mapping from variable labels to indices based on the current index-to-label mapping.
  - **Returns**:
    - `void`
  - **Definition**:
    binary_quadratic_model.hpp:218

- **fix_variables(const std::vector< std::pair< IndexType, int32_t > > &fixed)**: Fixes the value of specified variables and removes them from the model.
  - **Parameters**:
    - `fixed`: A vector of pairs, where each pair contains a variable index and its fixed value.
  - **Returns**:
    - `void`
  - **Definition**:
    binary_quadratic_model.hpp:1586

- **change_vartype(const Vartype &vartype, bool inplace)**: Creates a new BQM with the specified variable type (e.g., BINARY, SPIN) or modifies the current one if `inplace` is true.
  - **Parameters**:
    - `vartype`: The target variable type.
    - `inplace`: A boolean indicating whether to modify the model in-place.
  - **Returns**:
    - `BinaryQuadraticModel< IndexType, FloatType, DataType >`: The BQM with the changed variable type.
  - **Definition**:
    binary_quadratic_model.hpp:1668

- **_binary_to_spin(dispatch_t< T, Dense >=nullptr)**: Converts the internal representation of variables from QUBO (BINARY) to Ising (SPIN) for dense matrix representations.
  - **Parameters**:
    - `dispatch_t< T, Dense >=nullptr`: Dispatcher for dense matrix operations.
  - **Returns**:
    - `void`
  - **Definition**:
    binary_quadratic_model.hpp:1056

- **_generate_quadratic(dispatch_t< T, Sparse >=nullptr) const**: Generates the quadratic term representation, potentially for sparse matrices.
  - **Parameters**:
    - `dispatch_t< T, Sparse >=nullptr`: Dispatcher for sparse matrix operations.
  - **Returns**:
    - `Quadratic< IndexType, FloatType >`: The quadratic term representation.
  - **Definition**:
    binary_quadratic_model.hpp:879

- **_idx_to_label()**: Returns the internal vector used for converting indices to variable labels. This list is assumed to be sorted.
  - **Returns**:
    - `std::vector< IndexType >`: The index-to-label mapping vector.
  - **Definition**:
    binary_quadratic_model.hpp:196

- **_min_quadratic(dispatch_t< T, Sparse >=nullptr) const**: Calculates the minimum element in the quadratic term, specifically for dense graphs.
  - **Parameters**:
    - `dispatch_t< T, Sparse >=nullptr`: Dispatcher for sparse matrix operations.
  - **Returns**:
    - `FloatType`: The minimum quadratic element.
  - **Definition**:
    binary_quadratic_model.hpp:435

- **_initialize_quadmat(const Linear< IndexType, FloatType > &linear, const Quadratic< IndexType, FloatType > &quadratic, dispatch_t< T, Dense >=nullptr)**: Initializes the quadratic matrix with linear and quadratic dictionaries, intended for dense matrix representations.
  - **Parameters**:
    - `linear`: A Linear object for linear biases.
    - `quadratic`: A Quadratic object for quadratic biases.
    - `dispatch_t< T, Dense >=nullptr`: Dispatcher for dense matrix operations.
  - **Returns**:
    - `void`
  - **Definition**:
    binary_quadratic_model.hpp:620

- **normalize(const std::pair< FloatType, FloatType > &bias_range={ 1.0, 1.0 }, const bool use_quadratic_range=false, const std::pair< FloatType, FloatType > &quadratic_range={ 1.0, 1.0 }, const std::vector< IndexType > &ignored_variables={}, const std::vector< std::pair< IndexType, IndexType > > &ignored_interactions={}, const bool ignored_offset=false)**: Normalizes the biases of the BQM to fall within specified ranges. It can optionally consider quadratic ranges and ignore certain variables or interactions.
  - **Parameters**:
    - `bias_range`: A pair specifying the target range for linear biases.
    - `use_quadratic_range`: Boolean to indicate if quadratic ranges should be used.
    - `quadratic_range`: A pair specifying the target range for quadratic biases.
    - `ignored_variables`: A vector of variable indices to ignore during normalization.
    - `ignored_interactions`: A vector of pairs of variable indices representing interactions to ignore.
    - `ignored_offset`: Boolean to indicate if the offset should be ignored.
  - **Returns**:
    - `void`
  - **Definition**:
    binary_quadratic_model.hpp:1525
```

--------------------------------

### Get Sorted Variables from BinaryQuadraticModel

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Retrieves all variables currently stored in the BinaryQuadraticModel. It collects variables from the internal m_linear structure, sorts them, and returns them as a vector of IndexType.

```cpp
const std::vector<IndexType> [get_variables]() const {
  std::vector<IndexType> variables;
  variables.reserve( m_linear.size() );
  for ( auto &&[elem] : m_linear ) {
    variables.push_back( elem.first );
  }
  std::sort( variables.begin(), variables.end() );
  return variables;
}
```

--------------------------------

### cimod::BinaryQuadraticModel Class Methods

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Comprehensive documentation for the methods available in the cimod::BinaryQuadraticModel class. This includes functions for initializing, modifying, and querying the model's state, as well as converting it to other formats like QUBO.

```APIDOC
cimod::BinaryQuadraticModel::BinaryQuadraticModel
BinaryQuadraticModel(const Linear< IndexType, FloatType > &linear, const Quadratic< IndexType, FloatType > &quadratic, const Vartype vartype)
  Constructor for the BinaryQuadraticModel.
  Initializes the model with provided linear and quadratic terms, and a specified variable type.
  Parameters:
    linear: The linear terms of the model.
    quadratic: The quadratic terms of the model.
    vartype: The type of variables used in the model.
  Definition: binary_quadratic_model.hpp:1185
```

```APIDOC
cimod::BinaryQuadraticModel::empty
BinaryQuadraticModel< IndexType, FloatType, DataType > empty(Vartype vartype)
  Creates an empty BinaryQuadraticModel.
  This is useful for starting a new model from scratch.
  Parameters:
    vartype: The type of variables for the empty model.
  Returns: An empty BinaryQuadraticModel instance.
  Definition: binary_quadratic_model.hpp:1364
```

```APIDOC
cimod::BinaryQuadraticModel::get_quadratic
Quadratic< IndexType, FloatType > get_quadratic() const
  Retrieves the quadratic object associated with the model.
  This object contains all pairwise interactions between variables.
  Returns: The Quadratic object.
  Definition: binary_quadratic_model.hpp:1328
```

```APIDOC
cimod::BinaryQuadraticModel::energy
FloatType energy(const Sample< IndexType > &sample) const
  Calculates the energy of a given sample.
  The energy is computed based on the linear and quadratic terms of the model for the specified variable assignments.
  Parameters:
    sample: A Sample object containing variable assignments.
  Returns: The computed energy value.
  Definition: binary_quadratic_model.hpp:1686
```

```APIDOC
cimod::BinaryQuadraticModel::to_qubo
std::tuple< Quadratic< IndexType, FloatType >, FloatType > to_qubo() const
  Converts the binary quadratic model to QUBO (Quadratic Unconstrained Binary Optimization) format.
  This method returns the QUBO representation and an offset value.
  Returns: A tuple containing the QUBO quadratic terms and the offset.
  Definition: binary_quadratic_model.hpp:1718
```

```APIDOC
cimod::BinaryQuadraticModel::remove_offset
void remove_offset()
  Sets the model's offset to zero.
  This operation modifies the model in place by removing any constant offset term.
  Definition: binary_quadratic_model.hpp:1474
```

```APIDOC
cimod::BinaryQuadraticModel::remove_variable
void remove_variable(const IndexType &v)
  Removes a variable and all its associated interactions from the model.
  This includes linear terms involving 'v' and quadratic terms where 'v' is one of the variables.
  Parameters:
    v: The index of the variable to remove.
  Definition: binary_quadratic_model.hpp:1424
```

```APIDOC
cimod::BinaryQuadraticModel::fix_variable
void fix_variable(const IndexType &v, const int32_t &value)
  Fixes the value of a variable and removes it from the model.
  The variable 'v' is set to a specific 'value' (typically 0 or 1 for binary models), and its interactions are removed.
  Parameters:
    v: The index of the variable to fix.
    value: The fixed value for the variable.
  Definition: binary_quadratic_model.hpp:1564
```

```APIDOC
cimod::BinaryQuadraticModel::flip_variable
void flip_variable(const IndexType &v)
  Flips the value of a specified variable.
  This operation is relevant for models where variable states can be toggled.
  Parameters:
    v: The index of the variable to flip.
  Definition: binary_quadratic_model.hpp:1597
```

```APIDOC
cimod::BinaryQuadraticModel::_add_new_label
void _add_new_label(IndexType label_i)
  Adds a new label (variable index) to the model.
  If the label already exists, this operation is skipped.
  Parameters:
    label_i: The index of the label to add.
  Definition: binary_quadratic_model.hpp:572
```

```APIDOC
cimod::BinaryQuadraticModel::_delete_label_from_mat
void _delete_label_from_mat(IndexType label_i, dispatch_t< T, Dense >=nullptr)
  Deletes a row and column corresponding to an existing label from the quadratic matrix (_quadmat) for dense matrices.
  This is an internal helper function for managing matrix structure.
  Parameters:
    label_i: The index of the label (row/column) to delete.
    dispatch_t: Dispatcher for handling dense matrix operations.
  Definition: binary_quadratic_model.hpp:509
```

```APIDOC
cimod::BinaryQuadraticModel::_insert_label_into_mat
void _insert_label_into_mat(IndexType label_i, dispatch_t< T, Sparse >=nullptr)
  Inserts a row and column corresponding to an added label into the quadratic matrix (_quadmat) for sparse matrices.
  This is an internal helper function for managing matrix structure.
  Parameters:
    label_i: The index of the label (row/column) to insert.
    dispatch_t: Dispatcher for handling sparse matrix operations.
  Definition: binary_quadratic_model.hpp:468
```

```APIDOC
cimod::BinaryQuadraticModel::_generate_linear
Linear< IndexType, FloatType > _generate_linear() const
  Generates the linear terms for the model.
  This is an internal method likely used during model construction or transformation.
  Returns: The generated Linear object.
  Definition: binary_quadratic_model.hpp:853
```

```APIDOC
cimod::BinaryQuadraticModel::_initialize_quadmat
void _initialize_quadmat(const SparseMatrix &mat, const std::vector< IndexType > &labels_vec)
  Initializes the quadratic matrix (_quadmat) with a given sparse matrix and a vector of labels.
  The input matrix is assumed to be in a specific format.
  Parameters:
    mat: The SparseMatrix to initialize with.
    labels_vec: A vector of labels corresponding to the matrix dimensions.
  Definition: binary_quadratic_model.hpp:914
```

```APIDOC
cimod::BinaryQuadraticModel::_max_linear
FloatType _max_linear(dispatch_t< T, Sparse >=nullptr) const
  Calculates the maximum element in the linear term for a dense graph.
  This is an internal utility function.
  Parameters:
    dispatch_t: Dispatcher for handling sparse matrix operations.
  Returns: The maximum linear term value.
  Definition: binary_quadratic_model.hpp:396
```

```APIDOC
cimod::BinaryQuadraticModel::SpIter
typename SparseMatrix::InnerIterator SpIter
  An alias for the inner iterator type of the SparseMatrix.
  Used for iterating over non-zero elements in sparse representations.
  Definition: binary_quadratic_model.hpp:169
```

```APIDOC
cimod::BinaryQuadraticModel::m_vartype
Vartype m_vartype
  The type of variables used in the model (e.g., binary, spin).
  This member stores the model's variable type.
  Definition: binary_quadratic_model.hpp:213
```

--------------------------------

### Get BinaryQuadraticModel Variable Type

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Returns the current variable type (e.g., BINARY, SPIN, NONE) of the BinaryQuadraticModel. This method accesses the internal m_vartype member.

```cpp
const [Vartype](namespacecimod.html#af804dc431446f6af153364fec5c5aaf8) &[get_vartype]() const {
  return this->[m_vartype](classcimod_1_1BinaryQuadraticModel.html#ad809a22677bd04e53c974b5e7e7a8a63);
}
```

--------------------------------

### C++: Get All Quadratic Coefficients

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Returns a constant reference to the entire collection of quadratic coefficients. This provides access to all stored quadratic terms and their associated values.

```cpp
const Quadratic<IndexType, FloatType> &get_quadratic() const {
  return this->m_quadratic;
}
```

--------------------------------

### BQM Creation from Ising, QUBO, and NumPy

Source: https://jij-inc.github.io/Cimod-Documentation/main_8hpp

Utility functions for creating Binary Quadratic Models (BQM) from different input formats: Ising Hamiltonian, QUBO (Quadratic Unconstrained Binary Optimization) problems, and NumPy matrices.

```python
cimod.model.binary_quadratic_model.bqm_from_ising(linear, quadratic, offset, vartype='BINARY')
  - Creates a BQM from Ising model parameters.

  Parameters:
    linear (dict or list): Linear biases.
    quadratic (dict or list): Quadratic biases.
    offset (float): Offset value.
    vartype (str): The variable type ('BINARY' or 'SPIN'). Defaults to 'BINARY'.

  Returns:
    BinaryQuadraticModel: The created BQM.

  Example:
    bqm = cimod.model.binary_quadratic_model.bqm_from_ising({0: -1}, {(0, 1): -2}, 0.5)
```

```python
cimod.model.binary_quadratic_model.bqm_from_numpy_matrix(matrix, offset=0.0, vartype='BINARY')
  - Creates a BQM from a NumPy matrix representation.

  Parameters:
    matrix (numpy.ndarray): A square matrix representing the BQM.
    offset (float): Offset value. Defaults to 0.0.
    vartype (str): The variable type ('BINARY' or 'SPIN'). Defaults to 'BINARY'.

  Returns:
    BinaryQuadraticModel: The created BQM.

  Example:
    import numpy as np
    mat = np.array([[0, 1], [1, 0]])
    bqm = cimod.model.binary_quadratic_model.bqm_from_numpy_matrix(mat)
```

```python
cimod.model.binary_quadratic_model.bqm_from_qubo(qubo, offset=0.0, vartype='BINARY')
  - Creates a BQM from a QUBO dictionary.

  Parameters:
    qubo (dict): A dictionary representing the QUBO problem.
    offset (float): Offset value. Defaults to 0.0.
    vartype (str): The variable variable type ('BINARY' or 'SPIN'). Defaults to 'BINARY'.

  Returns:
    BinaryQuadraticModel: The created BQM.

  Example:
    qubo_dict = {(0, 0): 1, (1, 1): 1, (0, 1): 2}
    bqm = cimod.model.binary_quadratic_model.bqm_from_qubo(qubo_dict)
```

--------------------------------

### cimod::BinaryPolynomialModel: Constructor

Source: https://jij-inc.github.io/Cimod-Documentation/binary__polynomial__model_8hpp_source

Constructor for the BinaryPolynomialModel class, initializing the model with variables, keys, values, and vartype.

```APIDOC
cimod::BinaryPolynomialModel::BinaryPolynomialModel

BinaryPolynomialModel(const std::vector< IndexType > &variables, const PolynomialKeyList< std::size_t > &poly_key_distance_list, const PolynomialValueList< FloatType > &poly_value_list, const Vartype vartype)

BinaryPolynomialModel constructor.

Parameters:
  - variables: A list of variables for the model.
  - poly_key_distance_list: A list of polynomial keys with distance information.
  - poly_value_list: A list of polynomial values.
  - vartype: The type of variables used in the model.

Definition: binary_polynomial_model.hpp:220
```

--------------------------------

### C++: Get All Linear Coefficients

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Returns a constant reference to the entire collection of linear coefficients. This provides access to all stored linear terms and their associated values.

```cpp
const Linear<IndexType, FloatType> &get_linear() const {
  return this->m_linear;
}
```

--------------------------------

### cimod::BinaryPolynomialModel API Reference

Source: https://jij-inc.github.io/Cimod-Documentation/binary__polynomial__model_8hpp_source

This section details the methods available for the cimod::BinaryPolynomialModel class, covering initialization, interaction management, data conversion, and retrieval.

```APIDOC
class cimod::BinaryPolynomialModel

  // Constructors
  BinaryPolynomialModel(PolynomialKeyList< IndexType > &key_list, const PolynomialValueList< FloatType > &value_list, const Vartype vartype)
    // BinaryPolynomialModel constructor.
    // Parameters:
    //   key_list: A list of polynomial keys.
    //   value_list: A list of polynomial values.
    //   vartype: The type of variable used in the polynomial.

  BinaryPolynomialModel(const PolynomialKeyList< IndexType > &key_list, const PolynomialValueList< FloatType > &value_list, const Vartype vartype)
    // BinaryPolynomialModel constructor.
    // Parameters:
    //   key_list: A constant reference to a list of polynomial keys.
    //   value_list: A constant reference to a list of polynomial values.
    //   vartype: The type of variable used in the polynomial.

  // Static Factory Methods
  static BinaryPolynomialModel FromHubo(PolynomialKeyList< IndexType > &key_list, const PolynomialValueList< FloatType > &value_list)
    // Create a BinaryPolynomialModel from a Hubo model.
    // Parameters:
    //   key_list: The list of polynomial keys from the Hubo model.
    //   value_list: The list of polynomial values from the Hubo model.
    // Returns: A new BinaryPolynomialModel instance.

  static BinaryPolynomialModel FromHubo(const Polynomial< IndexType, FloatType > &poly_map)
    // Create a BinaryPolynomialModel from a Hubo model represented by a polynomial map.
    // Parameters:
    //   poly_map: A constant reference to the polynomial map representing the Hubo model.
    // Returns: A new BinaryPolynomialModel instance.

  // Interaction Management
  void AddInteraction(std::vector< IndexType > &key, const FloatType &value, const Vartype vartype=Vartype::NONE)
    // Add an interaction to the BinaryPolynomialModel.
    // Parameters:
    //   key: A vector of indices representing the interaction key.
    //   value: The value associated with the interaction.
    //   vartype: The type of variable (defaults to Vartype::NONE).

  void AddInteractionsFrom(PolynomialKeyList< IndexType > &key_list, const PolynomialValueList< FloatType > &value_list, const Vartype vartype=Vartype::NONE)
    // Add interactions to the BinaryPolynomialModel from provided lists.
    // Parameters:
    //   key_list: A list of polynomial keys to add.
    //   value_list: A list of polynomial values corresponding to the keys.
    //   vartype: The type of variable (defaults to Vartype::NONE).

  void RemoveInteraction(const std::vector< IndexType > &key)
    // Remove the specified interaction from the BinaryPolynomialModel.
    // Parameters:
    //   key: A constant reference to the vector of indices representing the interaction key to remove.

  void RemoveInteractionsFrom(const PolynomialKeyList< IndexType > &key_list)
    // Remove the specified interactions from the BinaryPolynomialModel.
    // Parameters:
    //   key_list: A constant reference to the list of polynomial keys to remove.

  // Data Retrieval and Conversion
  const PolynomialValueList< FloatType > & GetValueList() const
    // Get the PolynomialValueList object.
    // Returns: A constant reference to the PolynomialValueList.

  int64_t GetVariablesToIntegers(const IndexType &index) const
    // Get the specific integer number corresponding to the input variable (index).
    // Parameters:
    //   index: The variable index to look up.
    // Returns: The integer representation of the variable.

  std::vector< IndexType > GenerateSortedVariables() const
    // Generate sorted variables.
    // Returns: A vector of IndexType representing the sorted variables.

  PolynomialValueList< FloatType > Energies(const std::vector< std::vector< int32_t > > &samples_vec)
    // Determine the energies of the given samples_vec.
    // Parameters:
    //   samples_vec: A vector of sample vectors to calculate energies for.
    // Returns: A list of calculated energies.

  Polynomial< IndexType, FloatType > ToHising() const
    // Generate the polynomial interactions corresponding to the vartype being SPIN from the BinaryPolynomialModel.
    // Returns: A Polynomial object representing the Hising model.

  // Member Variables (Informational)
  // std::unordered_map< IndexType, int64_t > variables_to_integers_
  //   // The correspondence from variables to the integer numbers.
  // std::unordered_map< IndexType, std::size_t > each_variable_num_
  //   // The list of the number of the variables appeared in the polynomial interactions as std::unordered_map...

```

--------------------------------

### Get Vartype of BinaryQuadraticModel

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel

Retrieves the vartype object associated with the BinaryQuadraticModel. This method is inline and const, indicating it does not modify the object's state.

```C++
template<typename IndexType, typename FloatType, typename DataType >
/*
Get the vartype object.

Returns
:   Type of the model.

References cimod::BinaryQuadraticModel< IndexType, FloatType, DataType >::m_vartype.

Referenced by cimod::BinaryQuadraticModel< IndexType, FloatType, Dict >::add_interaction(), and cimod::BinaryQuadraticModel< IndexType, FloatType, Dict >::add_variable().
*/
inline Vartype cimod::BinaryQuadraticModel< IndexType, FloatType, DataType >::get_vartype() const
```

--------------------------------

### cimod::BinaryQuadraticModel Constructors

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel

Documentation for the constructors of the cimod::BinaryQuadraticModel class. These constructors allow initialization using sparse matrices, labels, and offset values, catering to different initialization needs for binary quadratic models. They are intended for developers and handle internal initialization processes.

```cpp
template<typename IndexType, typename FloatType, typename DataType >
class cimod::BinaryQuadraticModel< IndexType, FloatType, DataType > {
public:
    // Constructor (with sparse matrix, labels, and offset)
    BinaryQuadraticModel(const SparseMatrix& mat, const std::vector<IndexType>& labels_vec, const FloatType& offset, const Vartype vartype);

    // Constructor (with sparse matrix and labels)
    BinaryQuadraticModel(const SparseMatrix& mat, const std::vector<IndexType>& labels_vec, const Vartype vartype);

    // Default constructor
    BinaryQuadraticModel();

    // ... other members
};

// Constructor (with sparse matrix, labels, and offset) - Developer focused
// Parameters:
//   mat: The sparse matrix representing the quadratic interactions.
//   labels_vec: A vector of labels corresponding to the variables.
//   offset: The linear offset value for the model.
//   vartype: The type of variables (e.g., BINARY).
// References: _initialize_quadmat(), declare_BQM()

// Constructor (with sparse matrix and labels) - Developer focused
// Parameters:
//   mat: The sparse matrix representing the quadratic interactions.
//   labels_vec: A vector of labels corresponding to the variables.
//   vartype: The type of variables (e.g., BINARY).

// Default constructor - Developer focused
```

--------------------------------

### cimod::BinaryQuadraticModel Class Methods and Types

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

This entry consolidates documentation for various methods and type definitions within the cimod::BinaryQuadraticModel class. It covers initialization, internal data manipulation, and access to model components.

```APIDOC
cimod::BinaryQuadraticModel::from_serializable

static BinaryQuadraticModel< IndexType_serial, FloatType_serial, DataType > from_serializable(const json &input, dispatch_t< T, Dense >=nullptr)
  - Create a BinaryQuadraticModel instance from a serializable object.
  - Defined in: binary_quadratic_model.hpp:1976
```

```APIDOC
cimod::BinaryQuadraticModel::_spin_to_binary

void _spin_to_binary(dispatch_t< T, Dense >=nullptr)
  - Changes internal variables from Ising to QUBO ones for dense matrices.

void _spin_to_binary(dispatch_t< T, Sparse >=nullptr)
  - Changes internal variables from Ising to QUBO ones for sparse matrices.
  - Defined in: binary_quadratic_model.hpp:937, binary_quadratic_model.hpp:976
```

```APIDOC
cimod::BinaryQuadraticModel::_delete_label_from_mat

void _delete_label_from_mat(IndexType label_i, dispatch_t< T, Sparse >=nullptr)
  - Deletes the row and column corresponding to an existing label from _quadmat for sparse matrices.
  - Defined in: binary_quadratic_model.hpp:529
```

```APIDOC
cimod::BinaryQuadraticModel::_min_quadratic

FloatType _min_quadratic(dispatch_t< T, Dense >=nullptr) const
  - Calculates the minimum element in the quadratic term for a dense graph.
  - Defined in: binary_quadratic_model.hpp:385
```

```APIDOC
cimod::BinaryQuadraticModel::_min_linear

FloatType _min_linear(dispatch_t< T, Dense >=nullptr) const
  - Calculates the minimum element in the linear term for a dense graph.

FloatType _min_linear(dispatch_t< T, Sparse >=nullptr) const
  - Calculates the minimum element in the linear term for a sparse graph.
  - Defined in: binary_quadratic_model.hpp:374, binary_quadratic_model.hpp:422
```

```APIDOC
cimod::BinaryQuadraticModel::remove_variables_from

void remove_variables_from(const std::vector< IndexType > &variables)
  - Removes specified variables and all of their interactions from a binary quadratic model.
  - Defined in: binary_quadratic_model.hpp:1433
```

```APIDOC
cimod::BinaryQuadraticModel::_initialize_quadmat

void _initialize_quadmat(const DenseMatrix &mat, const std::vector< IndexType > &labels_vec, bool fix_format)
  - Initializes the internal quadratic matrix with provided matrix and labels.
  - The form of the matrix is assumed to be one of two specific structures.
  - Defined in: binary_quadratic_model.hpp:834
```

```APIDOC
cimod::BinaryQuadraticModel::DenseMatrix

Eigen::Matrix< FloatType, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > DenseMatrix
  - Type alias for Eigen Matrix when DataType is Dense. When DataType is Sparse, Matrix is equal to Eigen::Matrix.
  - Defined in: binary_quadratic_model.hpp:167
```

```APIDOC
cimod::BinaryQuadraticModel::_mat

FloatType _mat(IndexType label_i, IndexType label_j) const
  - Gets a reference to the element at _quadmat(i,j).

FloatType & _mat(IndexType label_i, IndexType label_j)
  - Gets a reference to the element at _quadmat(i,j).
  - Defined in: binary_quadratic_model.hpp:324, binary_quadratic_model.hpp:295
```

```APIDOC
cimod::BinaryQuadraticModel::interaction_matrix

Matrix interaction_matrix() const
  - Generates a (Dense or Sparse) interaction matrix using the provided list of indices.
  - The generated matrix will have a specific structure.
  - Defined in: binary_quadratic_model.hpp:1805
```

```APIDOC
cimod::BinaryQuadraticModel::_binary_to_spin

void _binary_to_spin(dispatch_t< T, Sparse >=nullptr)
  - Changes internal variables from QUBO to Ising ones for sparse matrices.
  - The following conversion is applied.
  - Defined in: binary_quadratic_model.hpp:1094
```

```APIDOC
cimod::BinaryQuadraticModel::json

nlohmann::json json
  - Member variable representing the JSON representation of the model.
  - Defined in: binary_quadratic_model.hpp:1809
```

```APIDOC
cimod::BinaryQuadraticModel::get_vartype

Vartype get_vartype() const
  - Gets the vartype object associated with the model.
  - Defined in: binary_quadratic_model.hpp:1346
```

--------------------------------

### Access Quadratic Matrix Elements (i,i) (const)

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel

Gets the quadratic matrix diagonal element at index (i, i). This provides read-only access to diagonal elements.

```APIDOC
cimod::BinaryQuadraticModel::_mat (i,i, const)

  FloatType _mat(IndexType label_i) const

  Description:
    Get reference of _quadmat(i,i). The stored matrix has a specific triangular form.
  Parameters:
    - label_i: The label (index) for the diagonal element.
  Returns:
    The value of the matrix element at the specified label on the diagonal.
```

--------------------------------

### BinaryQuadraticModel Constructors (cimod)

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model__dict_8hpp_source

Documentation for various constructors of the cimod::BinaryQuadraticModel class. These constructors handle initialization with linear and quadratic terms, and some indicate unimplemented matrix-based initializations.

```APIDOC
BinaryQuadraticModel(const Linear<IndexType, FloatType>& linear, const Quadratic<IndexType, FloatType>& quadratic, const FloatType offset, const Vartype vartype):
  m_offset(offset),
  m_vartype(vartype) {
  add_variables_from(linear);
  add_interactions_from(quadratic);
}
```

```APIDOC
BinaryQuadraticModel(const Linear<IndexType, FloatType>& linear, const Quadratic<IndexType, FloatType>& quadratic, const Vartype vartype):
  BinaryQuadraticModel(linear, quadratic, 0.0, vartype) {}
```

```APIDOC
BinaryQuadraticModel(const Eigen::Ref<const DenseMatrix>&, const std::vector<IndexType>&, const FloatType&, const Vartype, bool):
  throw std::runtime_error("Initialization from matrix is not implemented on dict-type BQM");
```

```APIDOC
BinaryQuadraticModel(const Eigen::Ref<const DenseMatrix>&, const std::vector<IndexType>&, const Vartype, bool):
  throw std::runtime_error("Initialization from matrix is not implemented on dict-type BQM");
```

```APIDOC
BinaryQuadraticModel(const SparseMatrix&, const std::vector<IndexType>&, const FloatType&, const Vartype):
  throw std::runtime_error("Initialization from matrix is not implemented on dict-type BQM");
```

```APIDOC
BinaryQuadraticModel(const SparseMatrix&, const std::vector<IndexType>&, const Vartype):
  throw std::runtime_error("Initialization from matrix is not implemented on dict-type BQM");
```

```APIDOC
BinaryQuadraticModel(const BinaryQuadraticModel&) = default;
```

--------------------------------

### Get Quadratic Object - cimod::BinaryQuadraticModel

Source: https://jij-inc.github.io/Cimod-Documentation/classcimod_1_1BinaryQuadraticModel_3_01IndexType_00_01FloatType_00_01Dict_01_4

Retrieves the quadratic object associated with the BinaryQuadraticModel. This object typically holds the quadratic biases for the model.

```C++
template<typename IndexType, typename FloatType>
const Quadratic & cimod::BinaryQuadraticModel<IndexType, FloatType, Dict>::get_quadratic() const inline

Get the quadratic object.

Returns:
  A quadratic bias.
```

--------------------------------

### Cimod BinaryPolynomialModel Methods

Source: https://jij-inc.github.io/Cimod-Documentation/main_8hpp

Documentation for various methods within the Cimod BinaryPolynomialModel class, covering energy calculation, variable generation, and serialization.

```APIDOC
cimod::BinaryPolynomialModel< IndexType, FloatType >::Energy()
  - Calculates the energy of the model.
  - Parameters: None
  - Returns: The energy value.

cimod::BinaryPolynomialModel< IndexType, FloatType >::FromHising(const std::string& filename)
  - Loads a BinaryPolynomialModel from a Hising file.
  - Parameters:
    - filename: Path to the Hising file.
  - Returns: A BinaryPolynomialModel instance.

cimod::BinaryPolynomialModel< IndexType, FloatType >::FromHubo(const std::string& filename)
  - Loads a BinaryPolynomialModel from a Hubo file.
  - Parameters:
    - filename: Path to the Hubo file.
  - Returns: A BinaryPolynomialModel instance.

cimod::BinaryPolynomialModel< IndexType, FloatType >::FromSerializable(const std::string& filename)
  - Loads a BinaryPolynomialModel from a serializable file.
  - Parameters:
    - filename: Path to the serializable file.
  - Returns: A BinaryPolynomialModel instance.

cimod::BinaryPolynomialModel< IndexType, FloatType >::GenerateChangedKey()
  - Generates a new key for changes within the model.
  - Parameters: None
  - Returns: A generated key.

cimod::BinaryPolynomialModel< IndexType, FloatType >::GenerateSortedVariables()
  - Generates a list of variables sorted according to internal logic.
  - Parameters: None
  - Returns: A list of sorted variables.

cimod::BinaryPolynomialModel< IndexType, FloatType >::GenerateVariablesToIntegers()
  - Maps variables to integer representations.
  - Parameters: None
  - Returns: Mapping of variables to integers.
```

--------------------------------

### Get Variables to Integers Map

Source: https://jij-inc.github.io/Cimod-Documentation/binary__polynomial__model_8hpp_source

Retrieves the mapping of variables to their integer representations. If relabeling is active, it first generates the mapping.

```cpp
std::unordered_map<IndexType, int64_t> GetVariablesToIntegers() const {
  if ( relabel_flag_for_variables_to_integers_ ) {
    return GenerateVariablesToIntegers();
  } else {
    return variables_to_integers_;
  }
}
```

--------------------------------

### C++ Example: Accessing Quadratic Bias

Source: https://jij-inc.github.io/Cimod-Documentation/binary__quadratic__model_8hpp_source

Demonstrates how to retrieve the quadratic bias between two specific variables using the get_quadratic method.

```cpp
FloatType get_quadratic(IndexType label_i, IndexType label_j) const {
  return _mat(label_i, label_j);
}
```
Tokens:
Raw