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: collections.abc.Mapping[collections.abc.Sequence[typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, keys: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, variables: collections.abc.Sequence[typing.SupportsInt], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, polynomial: collections.abc.Mapping[collections.abc.Sequence[typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, keys: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel, variables: collections.abc.Sequence[typing.SupportsInt], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel, key: collections.abc.Sequence[typing.SupportsInt], value: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) → None

add_interactions_from(*args, **kwargs)

Overloaded function.

1. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel, keys: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel, polynomial: collections.abc.Mapping[collections.abc.Sequence[typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel, offset: SupportsFloat) → 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: collections.abc.Sequence[collections.abc.Mapping[typing.SupportsInt, typing.SupportsInt]]) -> list[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel, samples: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]]) -> list[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel, sample: collections.abc.Mapping[typing.SupportsInt, typing.SupportsInt], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel, sample: collections.abc.Sequence[typing.SupportsInt], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: collections.abc.Mapping[collections.abc.Sequence[typing.SupportsInt], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel

2. from_hising(keys: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], value: collections.abc.Sequence[typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: collections.abc.Mapping[collections.abc.Sequence[typing.SupportsInt], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel

2. from_hubo(keys: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], value: collections.abc.Sequence[typing.SupportsFloat]) -> 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: collections.abc.Sequence[typing.SupportsInt]) -> 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: typing.SupportsInt) -> int

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

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

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

normalize(self: cimod.cxxcimod.BinaryPolynomialModel, range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel, key: collections.abc.Sequence[SupportsInt]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel, keys: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]]) → None

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

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

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel, variables: collections.abc.Sequence[SupportsInt]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel, scalar: SupportsFloat, ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[SupportsInt]] = [], 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: collections.abc.Mapping[collections.abc.Sequence[str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: collections.abc.Sequence[collections.abc.Sequence[str]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, variables: collections.abc.Sequence[str], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, polynomial: collections.abc.Mapping[collections.abc.Sequence[str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: collections.abc.Sequence[collections.abc.Sequence[str]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_str, variables: collections.abc.Sequence[str], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_str, key: collections.abc.Sequence[str], value: typing.SupportsFloat, 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: collections.abc.Sequence[collections.abc.Sequence[str]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_str, polynomial: collections.abc.Mapping[collections.abc.Sequence[str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_str, offset: SupportsFloat) → 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: collections.abc.Sequence[collections.abc.Mapping[str, typing.SupportsInt]]) -> list[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_str, samples: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]]) -> list[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_str, sample: collections.abc.Mapping[str, typing.SupportsInt], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_str, sample: collections.abc.Sequence[typing.SupportsInt], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: collections.abc.Mapping[collections.abc.Sequence[str], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_str

2. from_hising(keys: collections.abc.Sequence[collections.abc.Sequence[str]], value: collections.abc.Sequence[typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_str

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: collections.abc.Mapping[collections.abc.Sequence[str], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_str

2. from_hubo(keys: collections.abc.Sequence[collections.abc.Sequence[str]], value: collections.abc.Sequence[typing.SupportsFloat]) -> 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: collections.abc.Sequence[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[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[str]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_str, keys: collections.abc.Sequence[collections.abc.Sequence[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: collections.abc.Sequence[str]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_str, scalar: SupportsFloat, ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[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: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, variables: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, variables: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, key: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], value: typing.SupportsFloat, 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: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, offset: SupportsFloat) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsInt]]) -> list[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, samples: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]]) -> list[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, sample: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsInt], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, sample: collections.abc.Sequence[typing.SupportsInt], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

2. from_hising(keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]], value: collections.abc.Sequence[typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple2

2. from_hubo(keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]], value: collections.abc.Sequence[typing.SupportsFloat]) -> 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> 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[typing.SupportsInt, typing.SupportsInt]) -> int

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

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, v: tuple[SupportsInt, SupportsInt]) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2) → list[tuple[int, int]]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, key: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, v: tuple[SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_tuple2, scalar: SupportsFloat, ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, variables: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, variables: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, key: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], value: typing.SupportsFloat, 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: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, offset: SupportsFloat) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsInt]]) -> list[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, samples: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]]) -> list[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, sample: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsInt], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, sample: collections.abc.Sequence[typing.SupportsInt], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

2. from_hising(keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], value: collections.abc.Sequence[typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple3

2. from_hubo(keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], value: collections.abc.Sequence[typing.SupportsFloat]) -> 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> int

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

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3) → list[tuple[int, int, int]]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, key: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_tuple3, scalar: SupportsFloat, ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, variables: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, variables: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], keys_distance: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

__new__(**kwargs)

add_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, key: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], value: typing.SupportsFloat, 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: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], values: collections.abc.Sequence[typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

2. add_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype = <Vartype.NONE: -1>) -> None

add_offset(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, offset: SupportsFloat) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsInt]]) -> list[float]

2. energies(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, samples: collections.abc.Sequence[collections.abc.Sequence[typing.SupportsInt]]) -> list[float]

energy(*args, **kwargs)

Overloaded function.

1. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, sample: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsInt], omp_flag: bool = True) -> float

2. energy(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, sample: collections.abc.Sequence[typing.SupportsInt], omp_flag: bool = True) -> float

static from_hising(*args, **kwargs)

Overloaded function.

1. from_hising(polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

2. from_hising(keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], value: collections.abc.Sequence[typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

static from_hubo(*args, **kwargs)

Overloaded function.

1. from_hubo(polynomial: collections.abc.Mapping[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat]) -> cimod.cxxcimod.BinaryPolynomialModel_tuple4

2. from_hubo(keys: collections.abc.Sequence[collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]], value: collections.abc.Sequence[typing.SupportsFloat]) -> 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> int

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

has_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → bool

indices(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4) → list[tuple[int, int, int, int]]

normalize(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, key: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, keys: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryPolynomialModel_tuple4, scalar: SupportsFloat, ignored_interactions: collections.abc.Sequence[collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: SupportsInt, v: SupportsInt, bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, quadratic: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, v: SupportsInt, bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, linear: collections.abc.Mapping[SupportsInt, SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[SupportsInt, SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, sample: collections.abc.Mapping[SupportsInt, SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, fixed: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

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

static from_ising(h: collections.abc.Mapping[SupportsInt, SupportsFloat], J: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Dense

static from_qubo(Q: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], offset: SupportsFloat = 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: typing.SupportsInt) -> 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: typing.SupportsInt, arg1: typing.SupportsInt) -> 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) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[SupportsInt] = [], ignored_interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

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

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

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, variables: collections.abc.Sequence[SupportsInt]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_Dense, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[SupportsInt] = [], ignored_interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], 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: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: SupportsInt, v: SupportsInt, bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, quadratic: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, v: SupportsInt, bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, linear: collections.abc.Mapping[SupportsInt, SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[SupportsInt, SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, sample: collections.abc.Mapping[SupportsInt, SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, fixed: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

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

static from_ising(h: collections.abc.Mapping[SupportsInt, SupportsFloat], J: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Dict

static from_qubo(Q: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], offset: SupportsFloat = 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: typing.SupportsInt) -> 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: typing.SupportsInt, arg1: typing.SupportsInt) -> 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) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, arg0: collections.abc.Sequence[typing.SupportsInt]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[SupportsInt] = [], ignored_interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

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

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

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, variables: collections.abc.Sequence[SupportsInt]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_Dict, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[SupportsInt] = [], ignored_interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], 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: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: collections.abc.Mapping[typing.SupportsInt, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: collections.abc.Sequence[typing.SupportsInt], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[typing.SupportsInt], 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: SupportsInt, v: SupportsInt, bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, quadratic: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, v: SupportsInt, bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, linear: collections.abc.Mapping[SupportsInt, SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[SupportsInt, SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, sample: collections.abc.Mapping[SupportsInt, SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, fixed: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

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

static from_ising(h: collections.abc.Mapping[SupportsInt, SupportsFloat], J: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_Sparse

static from_qubo(Q: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], offset: SupportsFloat = 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: typing.SupportsInt) -> 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: typing.SupportsInt, arg1: typing.SupportsInt) -> 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[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[SupportsInt] = [], ignored_interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

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

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

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, variables: collections.abc.Sequence[SupportsInt]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_Sparse, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[SupportsInt] = [], ignored_interactions: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], 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: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[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: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[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: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[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: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[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: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, quadratic: collections.abc.Mapping[tuple[str, str], SupportsFloat]) → None

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

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

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, linear: collections.abc.Mapping[str, SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[str, SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, sample: collections.abc.Mapping[str, SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, fixed: collections.abc.Sequence[tuple[str, SupportsInt]]) → None

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

static from_ising(h: collections.abc.Mapping[str, SupportsFloat], J: collections.abc.Mapping[tuple[str, str], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Dense

static from_qubo(Q: collections.abc.Mapping[tuple[str, str], SupportsFloat], offset: SupportsFloat = 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) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[str] = [], ignored_interactions: collections.abc.Sequence[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: collections.abc.Sequence[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: collections.abc.Sequence[str]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dense, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[str] = [], ignored_interactions: collections.abc.Sequence[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: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[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: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[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: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[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: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[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: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, quadratic: collections.abc.Mapping[tuple[str, str], SupportsFloat]) → None

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

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

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, linear: collections.abc.Mapping[str, SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[str, SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, sample: collections.abc.Mapping[str, SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, fixed: collections.abc.Sequence[tuple[str, SupportsInt]]) → None

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

static from_ising(h: collections.abc.Mapping[str, SupportsFloat], J: collections.abc.Mapping[tuple[str, str], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Dict

static from_qubo(Q: collections.abc.Mapping[tuple[str, str], SupportsFloat], offset: SupportsFloat = 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) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, arg0: collections.abc.Sequence[str]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[str] = [], ignored_interactions: collections.abc.Sequence[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: collections.abc.Sequence[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: collections.abc.Sequence[str]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_str_Dict, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[str] = [], ignored_interactions: collections.abc.Sequence[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: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[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: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[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: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: collections.abc.Mapping[str, typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[str, str], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[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: collections.abc.Sequence[str], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[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: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, quadratic: collections.abc.Mapping[tuple[str, str], SupportsFloat]) → None

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

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

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, linear: collections.abc.Mapping[str, SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[str, SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, sample: collections.abc.Mapping[str, SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, fixed: collections.abc.Sequence[tuple[str, SupportsInt]]) → None

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

static from_ising(h: collections.abc.Mapping[str, SupportsFloat], J: collections.abc.Mapping[tuple[str, str], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_str_Sparse

static from_qubo(Q: collections.abc.Mapping[tuple[str, str], SupportsFloat], offset: SupportsFloat = 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[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[str] = [], ignored_interactions: collections.abc.Sequence[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: collections.abc.Sequence[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: collections.abc.Sequence[str]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_str_Sparse, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[str] = [], ignored_interactions: collections.abc.Sequence[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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: tuple[SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: tuple[SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt]) -> 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) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, v: tuple[SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dense, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: tuple[SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: tuple[SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt]) -> 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) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, arg0: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, v: tuple[SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Dict, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: tuple[SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: tuple[SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt]) -> 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[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, v: tuple[SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple2_Sparse, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dense, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat]) → None

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

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]) → float

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

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, arg0: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

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

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Dict, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, offset: SupportsFloat) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt], value: SupportsInt) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, u: tuple[SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple3_Sparse, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, offset: SupportsFloat) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], value: SupportsInt) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, u: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dense, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, offset: SupportsFloat) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], value: SupportsInt) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

2. interaction_matrix(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, arg0: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

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

normalize(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, bias_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, u: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Dict, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

2. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: collections.abc.Mapping[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], typing.SupportsFloat], quadratic: collections.abc.Mapping[tuple[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], typing.SupportsFloat], vartype: cimod.cxxcimod.Vartype) -> None

3. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype, fix_format: bool = True) -> None

4. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.c_contiguous”], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], offset: typing.SupportsFloat, vartype: cimod.cxxcimod.Vartype) -> None

6. __init__(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, mat: scipy.sparse.csr_matrix[numpy.float64], labels_vec: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]], 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[SupportsInt, SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, quadratic: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat]) → None

add_offset(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, offset: SupportsFloat) → None

add_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], bias: SupportsFloat) → None

add_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, linear: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsFloat]) → 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: collections.abc.Sequence[collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → list[float]

energy(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, sample: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]) → float

fix_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], value: SupportsInt) → None

fix_variables(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, fixed: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsInt]]) → None

flip_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

static from_ising(h: collections.abc.Mapping[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], SupportsFloat], J: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 0.0) → cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse

static from_qubo(Q: collections.abc.Mapping[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]], SupportsFloat], offset: SupportsFloat = 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt], arg1: tuple[typing.SupportsInt, typing.SupportsInt, typing.SupportsInt, typing.SupportsInt]) -> 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[SupportsFloat, SupportsFloat] = (1.0, 1.0), use_quadratic_range: bool = False, quadratic_range: tuple[SupportsFloat, SupportsFloat] = (1.0, 1.0), ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], ignored_offset: bool = False) → None

remove_interaction(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, u: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_interactions_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]]) → None

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

remove_variable(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, v: tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]) → None

remove_variables_from(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]) → None

scale(self: cimod.cxxcimod.BinaryQuadraticModel_tuple4_Sparse, scalar: SupportsFloat, ignored_variables: collections.abc.Sequence[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]] = [], ignored_interactions: collections.abc.Sequence[tuple[tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt], tuple[SupportsInt, SupportsInt, SupportsInt, SupportsInt]]] = [], 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: typing.SupportsInt) -> None

__init__(self: cimod.cxxcimod.Vartype, value: SupportsInt) → None

__new__(**kwargs)

BINARY = <Vartype.BINARY: 1>

NONE = <Vartype.NONE: -1>

SPIN = <Vartype.SPIN: 0>

property name

property value