Dwave-optimization

New Features
- Implement C++ `operator<=>(const Update&, const Update&)` and
`operator==(const Update&, const Update&)`. This allows `Update` to
be used with `std::ranges::stable_sort()`.
- Add a new Cython extension type, `_Graph`. The `_Graph` class is
responsible for managing a C++ `dwave::optimization::Graph`. Also
make `Model` a Python class that inherits from `_Graph`, rather than
a Cython extension type.
- Add C++ `DivideNode` and Python `Divide` symbol, and overriding
`__truediv__`. `Divide` propagates the division of its
predecessors element-wise. Note that predecessors of Divide must be
either strictly positive or strictly negative.
- Add C++ `SquareRootNode` and Python `SquareRoot` symbol.
`SquareRoot` propagates the square-root(s) of its predecessor
element-wise.
- Add `const` and non-`const` versions of C++ array iterators.
- Make C++ array iterators random access iterators. Previously they
were bidirectional iterators.

Upgrade Notes

- Remove C++ `Update::equals(const Update&)` method in favour of
`operator==(const Update&, const Update&)`.
- It is no longer possible to
`from dwave.optimization.model cimport Model`. Instead, importers
should `from dwave.optimization.model cimport _Graph`. A `_Graph`
has most of the functionality that a `Model` did, although most of
the symbol construction methods have been kept on `Model`.
- The `dwave::optimization::ArrayIterator` class has been moved. It
can now be found as a nested class in the `Array`, i.e.
`dwave::optimization::Array::const_iterator`.

New Features

- Implement C++ `BinaryOpNode::sizeinfo()` overload.
- Add C++ `ModulusNode` and Python `Modulus` symbol. `Modulus`
propagates the modulus of its two predecessors element-wise. Modulus
symbols may be created with either the `%` operator or the `mod()`
function in `dwave.optimization.mathematical`. See [\156](https://github.com/dwavesystems/dwave-optimization/issues/156).

Bug Fixes

- Fix serializing models with binary operations over dynamic
predecessors. Previously it was not possible to estimate the state
size which caused serialization to fail.

New Features

- Add C++ `DisjointListsNode::set_state()` method which allows for
setting the state of disjoint lists directly.
- Add C++ `XorNode` and Python `Xor` symbol. `Xor` propagates the
logical exclusive-or of its two predecessors element-wise. See [\125](https://github.com/dwavesystems/dwave-optimization/issues/125).
- Add C++ `AnyNode`. See [\148](https://github.com/dwavesystems/dwave-optimization/issues/148).
- Add `Any` symbol and `ArraySymbol.any()` method. See [\148](https://github.com/dwavesystems/dwave-optimization/issues/148).
- Change the formulation of the `job_shop_scheduling()` generator to
remove redundant list variables and replace them with a disjunctive
non-overlapping constraint between each pair of jobs on the
machines.
- Raise clearer error messages when trying to use out-of-bounds
indices.
- Add C++ `Graph::remove_unused_nodes()` method to remove nodes that
are not used in the objective or constraints. See [\41](https://github.com/dwavesystems/dwave-optimization/issues/41).
- Add Python `Model.remove_unused_symbols()` method to remove nodes
that are not used in the objective or constraints. See [\41](https://github.com/dwavesystems/dwave-optimization/issues/41).
- Improve the move/copy behavior of C++ `ArrayIterator`.
- Add C++ index raveling-unraveling utilities functions.
- Add C++ `PartialReduceNode`.
- Add Python `PartialSum` symbol and added `axis` keyword in
`ArraySymbol.sum()` function.

Upgrade Notes

- Remove redundant list variables in the `job_shop_scheduling()`
generator and add disjunctive non-overlapping constraints between
each pair of jobs on the machines.
- Drop support for Python 3.8.
- Change C++ `ArrayIterator` to no longer have ownership of its fill
value when masked.
- Remove `vartypes.hpp`. The `Vartype` enum was not used by any other
classes or functions.

Bug Fixes

- Update C++ `UnaryOpNode` to correctly handle dynamic predecessors.
- Fix the possibility of creating a dangling reference when using a
masked C++ `ArrayIterator`.
- Implement missing overloads for `NaryMaximumNode::max()`,
`NaryMaximumNode::min()`, and `NaryMaximumNode::integral()`.
- Implement missing overloads for `NaryMinimumNode::max()`,
`NaryMinimumNode::min()`, and `NaryMinimumNode::integral()`.
- Fix two bugs in advanced indexing node propogation in the case of a
non-const main array with dynamic indexers, e.g. `A[x]` where `A` is
a 1d integer decision variable and `x` is a list. The first bug
could cause segfaults during propagation, and the second could lead
to incorrect output if both arrays were changed during propagation.
- Update the logic in the
`capacitated_vehicle_routing_with_time_windows()` generator function
to correctly account for asymmetric time-distance matrices.
- Fix the type information for `ArraySymbol.__abs__()`.

New Features

- Add capacitated vehicle routing problem with time windows generator.
See [\104](https://github.com/dwavesystems/dwave-optimization/issues/104).
- Reduce the number of symbols in the model returned by
`job_shop_scheduling()` generator.
- Add `Array::integral()`, `Array::max()`, and `Array::min()`
overloads for all existing C++ nodes.
- Add C++ `is_integer()` function.
- Support Python 3.13.
- `Model.add_constraints()` now returns the symbol for the constraint.
- Fully support scalar (0-dimensional) indices for advanced indexing
operations, e.g. `A[i, :, j, :]` where `i` and `j` are nodes with
scalar output. Previously, this would work only if the final output
of the indexing operation was also scalar.

Upgrade Notes

- Using advanced indexing nodes with indexing arrays that have a
higher dimension than one (e.g. `A[:, i, :, j]` where `i` and `j`
are 2d arrays) has been disabled. Previously, it was possible to
construct models that used this functionality, but the behavior of
the model during state initialization and propagation may not have
been correct.

Bug Fixes

- Fix combined indexing. Previously indexing an array symbol by a
mixture of arrays, integers, and non-empty slices would always
result in an error.
- Update `AdvancedIndexingNode` to check the indices of its indexing
arrays to prevent out-of-bounds access.
- Fix the case of using scalar indices in an advanced indexing
operation where the indices were not grouped, e.g. `A[:, i, :, j]`,
which was technically unsupported but no errors were raised. This
could also lead to segfaults during state initialization or
propagation.

New Features

- Add `Symbol.id()` method to return the identity of the underlying
node.
- Add bin packing generator.
- Add support for exponentiation of `ArraySymbol` for positive integer
exponents other than 2.
- Implement `ArrayNode` and `DecisionNode` C++ classes. These classes
are useful when creating nodes that require their predecessor(s) to
be both arrays and node. See [\75](https://github.com/dwavesystems/dwave-optimization/issues/75).
- Update C++ nodes that previously inherited from both `Array` and
`Node` to inherit from `ArrayNode`.
- Update C++ nodes that previously inherited from both `Decision` and
`Node` to inherit from `DecisionNode`.
- Add `ArraySymbol.initialize_arraynode()` Cython method.
- Update C++ `Graph` to hold a vector of `DecisionNode*` for easy
access. This will increase the memory usage for graphs with many
decisions, but provide faster access.
- Support binary operations between symbols representing a scalar and
other array symbols.
- Add `SizeNode` C++ class. `SizeNode` reports the size of its
predecessor. See [\48](https://github.com/dwavesystems/dwave-optimization/issues/48).
- Add `Size` Python class. `Size` reports the size of its predecessor. See [\48](https://github.com/dwavesystems/dwave-optimization/issues/48).
- Add C++ `Graph::objective()` method for accessing the current
objective.
- Add `::operands()` method to C++ `BinaryOpNode`, `NaryOpNode`,
`ReduceNode`, and `UnaryOpNode`. This method allows access to the
`Array*` of the node\'s predecessors without a dynamic cast.
- Add C++ `LogicalNode` and Python `Logical` symbol. `Logical`
propagates the truth value(s) of its predecessor element-wise.
- Add C++ `NotNode` and Python `Not` symbol. `Not` propagates the
inverse of the truth value(s) of its predecessor element-wise.
- Add C++ `void Graph::commit(State& state, std::vector<const Node*>&& changed) const`
overload.
- Add C++ `void Graph::propagate(State& state, std::vector<const Node*>&& changed) const`
overload.
- Add C++ `void Graph::revert(State& state, std::vector<const Node*>&& changed) const`
overload.
- Add predecessor shape test when initializing the state of C++
`ArrayValidationNode`.
- Add C++ `WhereNode`. See [\66](https://github.com/dwavesystems/dwave-optimization/issues/66).
- Add Python `Where` symbol and `where` function. See [\66](https://github.com/dwavesystems/dwave-optimization/issues/66).

Upgrade Notes

- Require and/or return `ArrayNode*` in many places that previously
required and/or returned an `Array*`.

The following `Graph` methods now require an `ArrayNode*` argument:
`Graph.set_objective()`, `Graph.add_constraint()`,
`Graph.constraints()`, `Graph.decisions()`.

The following nodes now require a `ArrayNode*` as argument(s) to
their constructor: `AdvancedIndexingNode`, `ArrayValidationNode`,
`BasicIndexingNode`, `BinaryOpNode`, `NaryOpNode`,
`PermutationNode`, `QuadraticModelNode`. `ReduceNode`,
`ReshapeNode`, and `UnaryOpNode`.

Python code is not affected.
- Remove `ArraySymbol.initialize_array()` Cython method. Python code
is not affected.
- Require `ArrayNode*` as an argument to the `symbol_from_ptr()`
Cython function.

Bug Fixes

- Fix `Array::min()`. Previously it incorrectly reported the smallest
number expressible by a `double`, rather than the lowest. See
[\85](https://github.com/dwavesystems/dwave-optimization/issues/85).
- Implement C++ `UnaryOpNode::max()`, `UnaryOpNode::min()`, and
`UnaryOpNode::logical()`. Therefore `AbsoluteNode`, `NegativeNode`,
and `SquareNode` will now correctly propagate their minimum and
maximum value and will now correctly report if they represent
integer or boolean values.

Other Notes

- Switch to using [Meson](https://mesonbuild.com/) as the build
system. When installing from source with `pip` or `pypa/build`,
Meson will be used to install the package. Previously `setuptools`
and `setuptools_dso` were used.

New Features

- Add C++ `NaryOpNode(std::span<Node*>)` and `NaryOpNode(std::span<Array*>)` constructors.
- Add `Model.num_edges()` method. See [\28](https://github.com/dwavesystems/dwave-optimization/issues/28).
- Add quadratic assignment problem generator. See [\29](https://github.com/dwavesystems/dwave-optimization/issues/29).
- Add C++ method to rotate elements in a disjoint list.
- Add support for `<,>,==,!=,<=,>=` operators between `Constant` and array-like objects.
- Add support for `bool(constant)`, `int(constant)`, and `not constant` when `constant` is an instance of `Constant` encoding a single scalar value.
- Make `repr()` of symbols unique to the underlying node, rather than to the Python symbol. See [\52](https://github.com/dwavesystems/dwave-optimization/issues/52).
- Allow `dwave.optimization.generators.traveling_salesperson()` to accept an asymmetric distance matrix.
- Allow `dwave.optimization.generators.flow_shop_scheduling()` to accept non-integer processing times.
- Implement `ArraySymbol.__iadd__()` and `ArraySymbol.__imul__()`. The `+=` operator will now return a `NaryAdd` symbol. The `*=` operator will now return a `NaryMultiply` symbol.
- Implement `NaryAdd.__iadd__()`. In-place addition with a `NaryAdd` symbol will no longer create a new symbol.
- Implement `NaryAdd.__imul__()`. In-place multiplication with a `NaryMultiply` symbol will no longer create a new symbol.
- Add missing `typing` information to `dwave.optimization.add()`, `dwave.optimization.maximum()`, `dwave.optimization.minimum()`, and `dwave.optimization.multiply()`.
- Support NumPy 2.0. Also, no longer require NumPy at build-time.
- Speed up `Model.iter_symbols()` and other symbol iteration methods.

Upgrade Notes

- Raise a `ValueError` when calling `bool()` on an `ArraySymbol`.
- `dwave.optimization.add()`, `dwave.optimization.maximum()`, `dwave.optimization.minimum()`, and `dwave.optimization.multiply()` no longer accept a tuple of symbols as inputs.
- `dwave.optimization.logical_and()` and `dwave.optimization.logical_or()` arguments have been renamed.
- Remove `.from_ptr()` `cdef` method from all of the symbol classes.

Bug Fixes

- Fix `ArraySymbol.all()` for empty array symbols. See [\43](https://github.com/dwavesystems/dwave-optimization/issues/43).
- Add missing `copy()` override for C++ `DisjointBitSetsNode` states.
- Fix `Symbol.to_networkx()` to no longer be compiler-dependant. See [18](https://github.com/dwavesystems/dwave-optimization/issues/18).
- Fix `dwave.optimization.generators.job_shop_scheduling()` for problems with the number of jobs is different than the number of machines.
- Return `NotImplemented` from `ArraySymbol` operator methods for unknown types.
- Fix return type of `Symbol.maybe_equals()` to be integer instead of boolean. See [\23](https://github.com/dwavesystems/dwave-optimization/issues/23).