cimod.cxxcimod

C++ library for a binary quadratic model

class cimod.cxxcimod.BinaryPolynomialModel

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, polynomial: Dict[List[int], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, keys: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, variables: List[int], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, polynomial: Dict[List[int], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, keys: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, variables: List[int], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel, key: List[int], value: float, vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) → None

add_interactions_from(*args, **kwargs)

Overloaded function.

1. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel, keys: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel, polynomial: Dict[List[int], float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel, offset: float) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryPolynomialModel

2. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel, vartype: cimod.cxxcimod.Vartype) -> None

clear(self: cimod.cxxcimod.BinaryPolynomialModel) → None

empty(self: cimod.cxxcimod.BinaryPolynomialModel, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryPolynomialModel

energies(*args, **kwargs)

Overloaded function.

1. energies(self: cimod.cxxcimod.BinaryPolynomialModel, samples: List[Dict[int, int]]) -> List[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel, samples: List[List[int]]) -> List[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel, sample: Dict[int, int], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel, sample: List[int], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: Dict[List[int], float]) -> cimod.cxxcimod.BinaryPolynomialModel

2. from_hising(keys: List[List[int]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: Dict[List[int], float]) -> cimod.cxxcimod.BinaryPolynomialModel

2. from_hubo(keys: List[List[int]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel

static from_serializable(input: object) → cimod.cxxcimod.BinaryPolynomialModel

get_degree(self: cimod.cxxcimod.BinaryPolynomialModel) → int

get_key_list(self: cimod.cxxcimod.BinaryPolynomialModel) → List[List[int]]

get_num_interactions(self: cimod.cxxcimod.BinaryPolynomialModel) → int

get_num_variables(self: cimod.cxxcimod.BinaryPolynomialModel) → int

get_offset(self: cimod.cxxcimod.BinaryPolynomialModel) → float

get_polynomial(*args, **kwargs)

Overloaded function.

1. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel) -> dict

2. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel, key: List[int]) -> float

get_value_list(self: cimod.cxxcimod.BinaryPolynomialModel) → List[float]

get_variables(self: cimod.cxxcimod.BinaryPolynomialModel) → List[int]

get_variables_to_integers(*args, **kwargs)

Overloaded function.

1. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel) -> Dict[int, int]

2. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel, v: int) -> int

get_vartype(self: cimod.cxxcimod.BinaryPolynomialModel) → cimod.cxxcimod.Vartype

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel, v: int) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel) → List[int]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel, range: Tuple[float, float] = (1.0, 1.0), ignored_interactions: List[List[int]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel, key: List[int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel, keys: List[List[int]]) → None

remove_offset(self: cimod.cxxcimod.BinaryPolynomialModel) → None

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel, v: int) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel, variables: List[int]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel, scalar: float, ignored_interactions: List[List[int]] = [], ignored_offset: bool = False) → None

to_hising(self: cimod.cxxcimod.BinaryPolynomialModel) → dict

to_hubo(self: cimod.cxxcimod.BinaryPolynomialModel) → dict

to_serializable(self: cimod.cxxcimod.BinaryPolynomialModel) → object

class cimod.cxxcimod.BinaryPolynomialModel_str

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, polynomial: Dict[List[str], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: List[List[str]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, variables: List[str], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, polynomial: Dict[List[str], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: List[List[str]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, variables: List[str], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_str, key: List[str], value: float, vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) → None

add_interactions_from(*args, **kwargs)

Overloaded function.

1. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: List[List[str]], values: List[float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_str, polynomial: Dict[List[str], float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_str, offset: float) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_str, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryPolynomialModel_str

2. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_str, vartype: cimod.cxxcimod.Vartype) -> None

clear(self: cimod.cxxcimod.BinaryPolynomialModel_str) → None

empty(self: cimod.cxxcimod.BinaryPolynomialModel_str, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryPolynomialModel_str

energies(*args, **kwargs)

Overloaded function.

1. energies(self: cimod.cxxcimod.BinaryPolynomialModel_str, samples: List[Dict[str, int]]) -> List[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_str, samples: List[List[int]]) -> List[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_str, sample: Dict[str, int], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_str, sample: List[int], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: Dict[List[str], float]) -> cimod.cxxcimod.BinaryPolynomialModel_str

2. from_hising(keys: List[List[str]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_str

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: Dict[List[str], float]) -> cimod.cxxcimod.BinaryPolynomialModel_str

2. from_hubo(keys: List[List[str]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_str

static from_serializable(input: object) → cimod.cxxcimod.BinaryPolynomialModel_str

get_degree(self: cimod.cxxcimod.BinaryPolynomialModel_str) → int

get_key_list(self: cimod.cxxcimod.BinaryPolynomialModel_str) → List[List[str]]

get_num_interactions(self: cimod.cxxcimod.BinaryPolynomialModel_str) → int

get_num_variables(self: cimod.cxxcimod.BinaryPolynomialModel_str) → int

get_offset(self: cimod.cxxcimod.BinaryPolynomialModel_str) → float

get_polynomial(*args, **kwargs)

Overloaded function.

1. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_str) -> dict

2. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_str, key: List[str]) -> float

get_value_list(self: cimod.cxxcimod.BinaryPolynomialModel_str) → List[float]

get_variables(self: cimod.cxxcimod.BinaryPolynomialModel_str) → List[str]

get_variables_to_integers(*args, **kwargs)

Overloaded function.

1. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_str) -> Dict[str, int]

2. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_str, v: str) -> int

get_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_str) → cimod.cxxcimod.Vartype

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_str, v: str) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_str) → List[str]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_str, range: Tuple[float, float] = (1.0, 1.0), ignored_interactions: List[List[str]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_str, key: List[str]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: List[List[str]]) → None

remove_offset(self: cimod.cxxcimod.BinaryPolynomialModel_str) → None

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_str, v: str) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_str, variables: List[str]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_str, scalar: float, ignored_interactions: List[List[str]] = [], ignored_offset: bool = False) → None

to_hising(self: cimod.cxxcimod.BinaryPolynomialModel_str) → dict

to_hubo(self: cimod.cxxcimod.BinaryPolynomialModel_str) → dict

to_serializable(self: cimod.cxxcimod.BinaryPolynomialModel_str) → object

class cimod.cxxcimod.BinaryPolynomialModel_tuple2

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, polynomial: Dict[List[Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: List[List[Tuple[int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, variables: List[Tuple[int, int]], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, polynomial: Dict[List[Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: List[List[Tuple[int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, variables: List[Tuple[int, int]], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, key: List[Tuple[int, int]], value: float, vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) → None

add_interactions_from(*args, **kwargs)

Overloaded function.

1. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: List[List[Tuple[int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, polynomial: Dict[List[Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, offset: float) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

2. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, vartype: cimod.cxxcimod.Vartype) -> None

clear(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → None

empty(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryPolynomialModel_tuple2

energies(*args, **kwargs)

Overloaded function.

1. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, samples: List[Dict[Tuple[int, int], int]]) -> List[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, samples: List[List[int]]) -> List[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, sample: Dict[Tuple[int, int], int], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, sample: List[int], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: Dict[List[Tuple[int, int]], float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

2. from_hising(keys: List[List[Tuple[int, int]]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: Dict[List[Tuple[int, int]], float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

2. from_hubo(keys: List[List[Tuple[int, int]]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

static from_serializable(input: object) → cimod.cxxcimod.BinaryPolynomialModel_tuple2

get_degree(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → int

get_key_list(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → List[List[Tuple[int, int]]]

get_num_interactions(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → int

get_num_variables(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → int

get_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → float

get_polynomial(*args, **kwargs)

Overloaded function.

1. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) -> dict

2. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, key: List[Tuple[int, int]]) -> float

get_value_list(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → List[float]

get_variables(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → List[Tuple[int, int]]

get_variables_to_integers(*args, **kwargs)

Overloaded function.

1. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) -> Dict[Tuple[int, int], int]

2. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, v: Tuple[int, int]) -> int

get_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → cimod.cxxcimod.Vartype

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, v: Tuple[int, int]) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → List[Tuple[int, int]]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, range: Tuple[float, float] = (1.0, 1.0), ignored_interactions: List[List[Tuple[int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, key: List[Tuple[int, int]]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: List[List[Tuple[int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → None

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, v: Tuple[int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, variables: List[Tuple[int, int]]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, scalar: float, ignored_interactions: List[List[Tuple[int, int]]] = [], ignored_offset: bool = False) → None

to_hising(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → dict

to_hubo(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → dict

to_serializable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → object

class cimod.cxxcimod.BinaryPolynomialModel_tuple3

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, polynomial: Dict[List[Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: List[List[Tuple[int, int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, variables: List[Tuple[int, int, int]], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, polynomial: Dict[List[Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: List[List[Tuple[int, int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, variables: List[Tuple[int, int, int]], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, key: List[Tuple[int, int, int]], value: float, vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) → None

add_interactions_from(*args, **kwargs)

Overloaded function.

1. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: List[List[Tuple[int, int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, polynomial: Dict[List[Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, offset: float) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

2. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, vartype: cimod.cxxcimod.Vartype) -> None

clear(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → None

empty(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryPolynomialModel_tuple3

energies(*args, **kwargs)

Overloaded function.

1. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, samples: List[Dict[Tuple[int, int, int], int]]) -> List[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, samples: List[List[int]]) -> List[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, sample: Dict[Tuple[int, int, int], int], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, sample: List[int], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: Dict[List[Tuple[int, int, int]], float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

2. from_hising(keys: List[List[Tuple[int, int, int]]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: Dict[List[Tuple[int, int, int]], float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

2. from_hubo(keys: List[List[Tuple[int, int, int]]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

static from_serializable(input: object) → cimod.cxxcimod.BinaryPolynomialModel_tuple3

get_degree(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → int

get_key_list(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → List[List[Tuple[int, int, int]]]

get_num_interactions(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → int

get_num_variables(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → int

get_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → float

get_polynomial(*args, **kwargs)

Overloaded function.

1. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) -> dict

2. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, key: List[Tuple[int, int, int]]) -> float

get_value_list(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → List[float]

get_variables(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → List[Tuple[int, int, int]]

get_variables_to_integers(*args, **kwargs)

Overloaded function.

1. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) -> Dict[Tuple[int, int, int], int]

2. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, v: Tuple[int, int, int]) -> int

get_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → cimod.cxxcimod.Vartype

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, v: Tuple[int, int, int]) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → List[Tuple[int, int, int]]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, range: Tuple[float, float] = (1.0, 1.0), ignored_interactions: List[List[Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, key: List[Tuple[int, int, int]]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: List[List[Tuple[int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → None

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, v: Tuple[int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, variables: List[Tuple[int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, scalar: float, ignored_interactions: List[List[Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

to_hising(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → dict

to_hubo(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → dict

to_serializable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → object

class cimod.cxxcimod.BinaryPolynomialModel_tuple4

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, polynomial: Dict[List[Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: List[List[Tuple[int, int, int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, variables: List[Tuple[int, int, int, int]], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, polynomial: Dict[List[Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: List[List[Tuple[int, int, int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, variables: List[Tuple[int, int, int, int]], keys_distance: List[List[int]], values: List[float], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, key: List[Tuple[int, int, int, int]], value: float, vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) → None

add_interactions_from(*args, **kwargs)

Overloaded function.

1. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: List[List[Tuple[int, int, int, int]]], values: List[float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, polynomial: Dict[List[Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, offset: float) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

2. change_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, vartype: cimod.cxxcimod.Vartype) -> None

clear(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → None

empty(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryPolynomialModel_tuple4

energies(*args, **kwargs)

Overloaded function.

1. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, samples: List[Dict[Tuple[int, int, int, int], int]]) -> List[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, samples: List[List[int]]) -> List[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, sample: Dict[Tuple[int, int, int, int], int], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, sample: List[int], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: Dict[List[Tuple[int, int, int, int]], float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

2. from_hising(keys: List[List[Tuple[int, int, int, int]]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: Dict[List[Tuple[int, int, int, int]], float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

2. from_hubo(keys: List[List[Tuple[int, int, int, int]]], value: List[float]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

static from_serializable(input: object) → cimod.cxxcimod.BinaryPolynomialModel_tuple4

get_degree(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → int

get_key_list(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → List[List[Tuple[int, int, int, int]]]

get_num_interactions(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → int

get_num_variables(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → int

get_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → float

get_polynomial(*args, **kwargs)

Overloaded function.

1. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) -> dict

2. get_polynomial(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, key: List[Tuple[int, int, int, int]]) -> float

get_value_list(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → List[float]

get_variables(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → List[Tuple[int, int, int, int]]

get_variables_to_integers(*args, **kwargs)

Overloaded function.

1. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) -> Dict[Tuple[int, int, int, int], int]

2. get_variables_to_integers(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, v: Tuple[int, int, int, int]) -> int

get_vartype(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → cimod.cxxcimod.Vartype

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, v: Tuple[int, int, int, int]) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → List[Tuple[int, int, int, int]]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, range: Tuple[float, float] = (1.0, 1.0), ignored_interactions: List[List[Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, key: List[Tuple[int, int, int, int]]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: List[List[Tuple[int, int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → None

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, v: Tuple[int, int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, variables: List[Tuple[int, int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, scalar: float, ignored_interactions: List[List[Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

to_hising(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → dict

to_hubo(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → dict

to_serializable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → object

class cimod.cxxcimod.BinaryQuadraticModel_Dense

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_Dense) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_Dense) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, u: int, v: int, bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, quadratic: Dict[Tuple[int, int], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, v: int, bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: Dict[int, float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_Dense

empty(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_Dense

energies(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, samples_like: List[Dict[int, int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, sample: Dict[int, int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, v: int, value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, fixed: List[Tuple[int, int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, v: int) → None

static from_ising(h: Dict[int, float], J: Dict[Tuple[int, int], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Dense

static from_qubo(Q: Dict[Tuple[int, int], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Dense

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_Dense

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, arg0: int) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) -> Dict[int, float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, arg0: int, arg1: int) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) -> Dict[Tuple[int, int], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → List[int]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[int] = [], ignored_interactions: List[Tuple[int, int]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, u: int, v: int) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, interactions: List[Tuple[int, int]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, v: int) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, variables: List[int]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, scalar: float, ignored_variables: List[int] = [], ignored_interactions: List[Tuple[int, int]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → Tuple[Dict[int, float], Dict[Tuple[int, int], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → Tuple[Dict[Tuple[int, int], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_Dense) → object

class cimod.cxxcimod.BinaryQuadraticModel_Dict

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_Dict) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_Dict) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, u: int, v: int, bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, quadratic: Dict[Tuple[int, int], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, v: int, bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: Dict[int, float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_Dict

empty(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_Dict

energies(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, samples_like: List[Dict[int, int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, sample: Dict[int, int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, v: int, value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, fixed: List[Tuple[int, int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, v: int) → None

static from_ising(h: Dict[int, float], J: Dict[Tuple[int, int], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Dict

static from_qubo(Q: Dict[Tuple[int, int], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Dict

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_Dict

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, arg0: int) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) -> Dict[int, float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, arg0: int, arg1: int) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) -> Dict[Tuple[int, int], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → List[int]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → cimod.cxxcimod.Vartype

interaction_matrix(*args, **kwargs)

Overloaded function.

1. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) -> numpy.ndarray[numpy.float64[m, n]]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, arg0: List[int]) -> numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[int] = [], ignored_interactions: List[Tuple[int, int]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, u: int, v: int) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, interactions: List[Tuple[int, int]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, v: int) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, variables: List[int]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, scalar: float, ignored_variables: List[int] = [], ignored_interactions: List[Tuple[int, int]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → Tuple[Dict[int, float], Dict[Tuple[int, int], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → Tuple[Dict[Tuple[int, int], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_Dict) → object

class cimod.cxxcimod.BinaryQuadraticModel_Sparse

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_Sparse) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: Dict[int, float], quadratic: Dict[Tuple[int, int], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[int], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_Sparse) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, u: int, v: int, bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, quadratic: Dict[Tuple[int, int], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, v: int, bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: Dict[int, float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_Sparse

empty(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_Sparse

energies(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, samples_like: List[Dict[int, int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, sample: Dict[int, int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, v: int, value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, fixed: List[Tuple[int, int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, v: int) → None

static from_ising(h: Dict[int, float], J: Dict[Tuple[int, int], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Sparse

static from_qubo(Q: Dict[Tuple[int, int], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Sparse

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_Sparse

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, arg0: int) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) -> Dict[int, float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, arg0: int, arg1: int) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) -> Dict[Tuple[int, int], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → List[int]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → scipy.sparse.csr_matrix[numpy.float64]

length(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[int] = [], ignored_interactions: List[Tuple[int, int]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, u: int, v: int) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, interactions: List[Tuple[int, int]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, v: int) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, variables: List[int]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, scalar: float, ignored_variables: List[int] = [], ignored_interactions: List[Tuple[int, int]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → Tuple[Dict[int, float], Dict[Tuple[int, int], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → Tuple[Dict[Tuple[int, int], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse) → object

class cimod.cxxcimod.BinaryQuadraticModel_str_Dense

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, u: str, v: str, bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, quadratic: Dict[Tuple[str, str], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, v: str, bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: Dict[str, float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_str_Dense

empty(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_str_Dense

energies(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, samples_like: List[Dict[str, int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, sample: Dict[str, int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, v: str, value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, fixed: List[Tuple[str, int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, v: str) → None

static from_ising(h: Dict[str, float], J: Dict[Tuple[str, str], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Dense

static from_qubo(Q: Dict[Tuple[str, str], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Dense

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_str_Dense

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, arg0: str) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) -> Dict[str, float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, arg0: str, arg1: str) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) -> Dict[Tuple[str, str], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → List[str]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[str] = [], ignored_interactions: List[Tuple[str, str]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, u: str, v: str) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, interactions: List[Tuple[str, str]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, v: str) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, variables: List[str]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, scalar: float, ignored_variables: List[str] = [], ignored_interactions: List[Tuple[str, str]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → Tuple[Dict[str, float], Dict[Tuple[str, str], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → Tuple[Dict[Tuple[str, str], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense) → object

class cimod.cxxcimod.BinaryQuadraticModel_str_Dict

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, u: str, v: str, bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, quadratic: Dict[Tuple[str, str], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, v: str, bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: Dict[str, float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_str_Dict

empty(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_str_Dict

energies(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, samples_like: List[Dict[str, int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, sample: Dict[str, int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, v: str, value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, fixed: List[Tuple[str, int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, v: str) → None

static from_ising(h: Dict[str, float], J: Dict[Tuple[str, str], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Dict

static from_qubo(Q: Dict[Tuple[str, str], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Dict

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_str_Dict

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, arg0: str) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) -> Dict[str, float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, arg0: str, arg1: str) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) -> Dict[Tuple[str, str], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → List[str]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → cimod.cxxcimod.Vartype

interaction_matrix(*args, **kwargs)

Overloaded function.

1. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) -> numpy.ndarray[numpy.float64[m, n]]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, arg0: List[str]) -> numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[str] = [], ignored_interactions: List[Tuple[str, str]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, u: str, v: str) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, interactions: List[Tuple[str, str]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, v: str) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, variables: List[str]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, scalar: float, ignored_variables: List[str] = [], ignored_interactions: List[Tuple[str, str]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → Tuple[Dict[str, float], Dict[Tuple[str, str], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → Tuple[Dict[Tuple[str, str], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict) → object

class cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: Dict[str, float], quadratic: Dict[Tuple[str, str], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[str], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, u: str, v: str, bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, quadratic: Dict[Tuple[str, str], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, v: str, bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: Dict[str, float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

empty(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

energies(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, samples_like: List[Dict[str, int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, sample: Dict[str, int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, v: str, value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, fixed: List[Tuple[str, int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, v: str) → None

static from_ising(h: Dict[str, float], J: Dict[Tuple[str, str], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

static from_qubo(Q: Dict[Tuple[str, str], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, arg0: str) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) -> Dict[str, float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, arg0: str, arg1: str) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) -> Dict[Tuple[str, str], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → List[str]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → scipy.sparse.csr_matrix[numpy.float64]

length(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[str] = [], ignored_interactions: List[Tuple[str, str]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, u: str, v: str) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, interactions: List[Tuple[str, str]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, v: str) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, variables: List[str]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, scalar: float, ignored_variables: List[str] = [], ignored_interactions: List[Tuple[str, str]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → Tuple[Dict[str, float], Dict[Tuple[str, str], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → Tuple[Dict[Tuple[str, str], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, u: Tuple[int, int], v: Tuple[int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: Tuple[int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: Dict[Tuple[int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, samples_like: List[Dict[Tuple[int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, sample: Dict[Tuple[int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: Tuple[int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, fixed: List[Tuple[Tuple[int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: Tuple[int, int]) → None

static from_ising(h: Dict[Tuple[int, int], float], J: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

static from_qubo(Q: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, arg0: Tuple[int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) -> Dict[Tuple[int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, arg0: Tuple[int, int], arg1: Tuple[int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) -> Dict[Tuple[Tuple[int, int], Tuple[int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → List[Tuple[int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, u: Tuple[int, int], v: Tuple[int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: Tuple[int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, variables: List[Tuple[int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, scalar: float, ignored_variables: List[Tuple[int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → Tuple[Dict[Tuple[int, int], float], Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → Tuple[Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, u: Tuple[int, int], v: Tuple[int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: Tuple[int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: Dict[Tuple[int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, samples_like: List[Dict[Tuple[int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, sample: Dict[Tuple[int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: Tuple[int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, fixed: List[Tuple[Tuple[int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: Tuple[int, int]) → None

static from_ising(h: Dict[Tuple[int, int], float], J: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

static from_qubo(Q: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, arg0: Tuple[int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) -> Dict[Tuple[int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, arg0: Tuple[int, int], arg1: Tuple[int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) -> Dict[Tuple[Tuple[int, int], Tuple[int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → List[Tuple[int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → cimod.cxxcimod.Vartype

interaction_matrix(*args, **kwargs)

Overloaded function.

1. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) -> numpy.ndarray[numpy.float64[m, n]]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, arg0: List[Tuple[int, int]]) -> numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, u: Tuple[int, int], v: Tuple[int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: Tuple[int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, variables: List[Tuple[int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, scalar: float, ignored_variables: List[Tuple[int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → Tuple[Dict[Tuple[int, int], float], Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → Tuple[Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: Dict[Tuple[int, int], float], quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, u: Tuple[int, int], v: Tuple[int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, quadratic: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: Tuple[int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: Dict[Tuple[int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, samples_like: List[Dict[Tuple[int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, sample: Dict[Tuple[int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: Tuple[int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, fixed: List[Tuple[Tuple[int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: Tuple[int, int]) → None

static from_ising(h: Dict[Tuple[int, int], float], J: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

static from_qubo(Q: Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, arg0: Tuple[int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) -> Dict[Tuple[int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, arg0: Tuple[int, int], arg1: Tuple[int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) -> Dict[Tuple[Tuple[int, int], Tuple[int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → List[Tuple[int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → scipy.sparse.csr_matrix[numpy.float64]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, u: Tuple[int, int], v: Tuple[int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: Tuple[int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, variables: List[Tuple[int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, scalar: float, ignored_variables: List[Tuple[int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int], Tuple[int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → Tuple[Dict[Tuple[int, int], float], Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → Tuple[Dict[Tuple[Tuple[int, int], Tuple[int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, u: Tuple[int, int, int], v: Tuple[int, int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: Tuple[int, int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: Dict[Tuple[int, int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, samples_like: List[Dict[Tuple[int, int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, sample: Dict[Tuple[int, int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: Tuple[int, int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, fixed: List[Tuple[Tuple[int, int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: Tuple[int, int, int]) → None

static from_ising(h: Dict[Tuple[int, int, int], float], J: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

static from_qubo(Q: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, arg0: Tuple[int, int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) -> Dict[Tuple[int, int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, arg0: Tuple[int, int, int], arg1: Tuple[int, int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) -> Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → List[Tuple[int, int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, u: Tuple[int, int, int], v: Tuple[int, int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: Tuple[int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, variables: List[Tuple[int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, scalar: float, ignored_variables: List[Tuple[int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → Tuple[Dict[Tuple[int, int, int], float], Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → Tuple[Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, u: Tuple[int, int, int], v: Tuple[int, int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: Tuple[int, int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: Dict[Tuple[int, int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, samples_like: List[Dict[Tuple[int, int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, sample: Dict[Tuple[int, int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: Tuple[int, int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, fixed: List[Tuple[Tuple[int, int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: Tuple[int, int, int]) → None

static from_ising(h: Dict[Tuple[int, int, int], float], J: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

static from_qubo(Q: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, arg0: Tuple[int, int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) -> Dict[Tuple[int, int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, arg0: Tuple[int, int, int], arg1: Tuple[int, int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) -> Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → List[Tuple[int, int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → cimod.cxxcimod.Vartype

interaction_matrix(*args, **kwargs)

Overloaded function.

1. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) -> numpy.ndarray[numpy.float64[m, n]]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, arg0: List[Tuple[int, int, int]]) -> numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, u: Tuple[int, int, int], v: Tuple[int, int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: Tuple[int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, variables: List[Tuple[int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, scalar: float, ignored_variables: List[Tuple[int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → Tuple[Dict[Tuple[int, int, int], float], Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → Tuple[Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: Dict[Tuple[int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, u: Tuple[int, int, int], v: Tuple[int, int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, quadratic: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: Tuple[int, int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: Dict[Tuple[int, int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, samples_like: List[Dict[Tuple[int, int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, sample: Dict[Tuple[int, int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: Tuple[int, int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, fixed: List[Tuple[Tuple[int, int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: Tuple[int, int, int]) → None

static from_ising(h: Dict[Tuple[int, int, int], float], J: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

static from_qubo(Q: Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, arg0: Tuple[int, int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) -> Dict[Tuple[int, int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, arg0: Tuple[int, int, int], arg1: Tuple[int, int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) -> Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → List[Tuple[int, int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → scipy.sparse.csr_matrix[numpy.float64]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, u: Tuple[int, int, int], v: Tuple[int, int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: Tuple[int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, variables: List[Tuple[int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, scalar: float, ignored_variables: List[Tuple[int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int], Tuple[int, int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → Tuple[Dict[Tuple[int, int, int], float], Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → Tuple[Dict[Tuple[Tuple[int, int, int], Tuple[int, int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, u: Tuple[int, int, int, int], v: Tuple[int, int, int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: Tuple[int, int, int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: Dict[Tuple[int, int, int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, samples_like: List[Dict[Tuple[int, int, int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, sample: Dict[Tuple[int, int, int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: Tuple[int, int, int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, fixed: List[Tuple[Tuple[int, int, int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: Tuple[int, int, int, int]) → None

static from_ising(h: Dict[Tuple[int, int, int, int], float], J: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

static from_qubo(Q: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, arg0: Tuple[int, int, int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) -> Dict[Tuple[int, int, int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, arg0: Tuple[int, int, int, int], arg1: Tuple[int, int, int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) -> Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → List[Tuple[int, int, int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, u: Tuple[int, int, int, int], v: Tuple[int, int, int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: Tuple[int, int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, variables: List[Tuple[int, int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, scalar: float, ignored_variables: List[Tuple[int, int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → Tuple[Dict[Tuple[int, int, int, int], float], Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → Tuple[Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, u: Tuple[int, int, int, int], v: Tuple[int, int, int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: Tuple[int, int, int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: Dict[Tuple[int, int, int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, samples_like: List[Dict[Tuple[int, int, int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, sample: Dict[Tuple[int, int, int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: Tuple[int, int, int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, fixed: List[Tuple[Tuple[int, int, int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: Tuple[int, int, int, int]) → None

static from_ising(h: Dict[Tuple[int, int, int, int], float], J: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

static from_qubo(Q: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, arg0: Tuple[int, int, int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) -> Dict[Tuple[int, int, int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, arg0: Tuple[int, int, int, int], arg1: Tuple[int, int, int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) -> Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → List[Tuple[int, int, int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → cimod.cxxcimod.Vartype

interaction_matrix(*args, **kwargs)

Overloaded function.

1. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) -> numpy.ndarray[numpy.float64[m, n]]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, arg0: List[Tuple[int, int, int, int]]) -> numpy.ndarray[numpy.float64[m, n]]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, u: Tuple[int, int, int, int], v: Tuple[int, int, int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: Tuple[int, int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, variables: List[Tuple[int, int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, scalar: float, ignored_variables: List[Tuple[int, int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → Tuple[Dict[Tuple[int, int, int, int], float], Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → Tuple[Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict) → object

class cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

__init__(*args, **kwargs) Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: Dict[Tuple[int, int, int, int], float], quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: numpy.ndarray[numpy.float64[m, n], flags.c_contiguous], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

5. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], offset: float, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: List[Tuple[int, int, int, int]], vartype: cimod.cxxcimod.Vartype) -> None

7. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, bqm: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, u: Tuple[int, int, int, int], v: Tuple[int, int, int, int], bias: float) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, quadratic: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, offset: float) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: Tuple[int, int, int, int], bias: float) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: Dict[Tuple[int, int, int, int], float]) → None

change_vartype(*args, **kwargs)

Overloaded function.

1. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, vartype: cimod.cxxcimod.Vartype) -> None

2. change_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, vartype: cimod.cxxcimod.Vartype, inplace: bool) -> cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

empty(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, vartype: cimod.cxxcimod.Vartype) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

energies(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, samples_like: List[Dict[Tuple[int, int, int, int], int]]) → List[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, sample: Dict[Tuple[int, int, int, int], int]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: Tuple[int, int, int, int], value: int) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, fixed: List[Tuple[Tuple[int, int, int, int], int]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: Tuple[int, int, int, int]) → None

static from_ising(h: Dict[Tuple[int, int, int, int], float], J: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

static from_qubo(Q: Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], offset: float = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

static from_serializable(input: object) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

get_linear(*args, **kwargs)

Overloaded function.

1. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, arg0: Tuple[int, int, int, int]) -> float

2. get_linear(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) -> Dict[Tuple[int, int, int, int], float]

get_num_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → int

get_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → float

get_quadratic(*args, **kwargs)

Overloaded function.

1. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, arg0: Tuple[int, int, int, int], arg1: Tuple[int, int, int, int]) -> float

2. get_quadratic(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) -> Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float]

get_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → List[Tuple[int, int, int, int]]

get_vartype(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → cimod.cxxcimod.Vartype

interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → scipy.sparse.csr_matrix[numpy.float64]

length(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → int

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, bias_range: Tuple[float, float] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: Tuple[float, float] = (1.0, 1.0), ignored_variables: List[Tuple[int, int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, u: Tuple[int, int, int, int], v: Tuple[int, int, int, int]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]]) → None

remove_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → None

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: Tuple[int, int, int, int]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, variables: List[Tuple[int, int, int, int]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, scalar: float, ignored_variables: List[Tuple[int, int, int, int]] = [], ignored_interactions: List[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]] = [], ignored_offset: bool = False) → None

to_ising(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → Tuple[Dict[Tuple[int, int, int, int], float], Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], float]

to_qubo(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → Tuple[Dict[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]], float], float]

to_serializable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse) → object

class cimod.cxxcimod.Vartype

Members:

SPIN

BINARY

NONE

__init__(self: cimod.cxxcimod.Vartype, value: int) -> None

__init__(self: cimod.cxxcimod.Vartype, value: int) → None

__new__(**kwargs)

BINARY = <Vartype.BINARY: 1>

NONE = <Vartype.NONE: -1>

SPIN = <Vartype.SPIN: 0>

property name

property value