# FUJITSU

## DACPU - Digital Annealer Cpu

From the [Fujitsu website](https://www.fujitsu.com/global/services/business-services/digital-annealer/): Fujitsu's Digital Annealer provides an alternative to quantum computing technology, which is at present both very expensive and difficult to run. Using a digital circuit design inspired by quantum phenomena, the Digital Annealer focuses on rapidly solving complex combinatorial optimization problems without the added complications and costs typically associated with quantum computing methods.

### Provider:

fujitsu

### Solution Example:

```
## Example of creating solution for digital_annealer_cpu (DACPU) from fujitsu
solution = ls.solution.create(
optimization_id=optimization.id,
solver_name="DACPU",
provider="fujitsu",
parameters={},
qpu_tokens={}
)
```

### Parameters:

**number_runs:** int

Number of stochastically independent runs. Min: 1, Max: 128

**Default:**2

**number_replicas:** int

Number of replicas in parallel tempering. Min: 5, Max: 128

**Default:**5

**number_iterations:** int

Total number of iterations per run. Min: 1, Max: 100_000_000

**Default:**1000

**pt_temperature_model:** Literal['Linear', 'Exponential', 'Hukushima']

Temperature model for furnace temperature distribution for parallel tempering process.

**Default:**"Exponential"

**pt_replica_exchange_model:** Literal['Neighbours', 'Far jump']

Select replica exchange model for parallel tempering process.

**Default:**"Neighbours"

**auto_tuning:** Literal['NOTHING', 'SCALING', 'AUTO_SCALING', 'SAMPLING', 'AUTO_SCALING_AND_SAMPLING', 'SCALING_AND_SAMPLING']

Following methods for scaling `qubo` and determining temperatures are available: AutoTuning.NOTHING: no action AutoTuning.SCALING: `scaling_factor` is multiplied to `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`. AutoTuning.AUTO_SCALING: A maximum scaling factor w.r.t. `scaling_bit_precision` is multiplied to `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`. AutoTuning.SAMPLING: `temperature_start`, `temperature_end` and `offset_increase_rate` are automatically determined. AutoTuning.AUTO_SCALING_AND_SAMPLING: Temperatures and scaling factor are automatically determined and applied.

**Default:**"NOTHING"

**scaling_factor:** Union[int, float]

The scaling factor for `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`.

**Default:**1

**scaling_bit_precision:** int

Maximum `scaling_bit_precision` for `qubo`. Used to define the scaling factor for `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`.

**Default:**64

**guidance_config:** dadk.BinPol.PartialConfig

Specifies an initial value for each polynomial (problem) variable that is set to find an optimal solution. By specifying a value that is close to the optimal solution, improvement in the accuracy of the optimal solution can be expected. If you repeatedly use the specified initial values to solve the same polynomial (problem), the same optimal solution is obtained each time.

**Default:**None

**random_seed:** int

Seed for random numbers for the optimization call. Min: 0, Max: 9_999

**Default:**None

**timeseries_max_bits:** int

Maximum number of bits for timeseries.

**Default:**None

**solver_max_bits:** int

Maximum number of bits on selected solver.

**Default:**8192

## DAV3 - Digital Annealer V3

From the [website](https://www.fujitsu.com/global/services/business-services/digital-annealer/): Fujitsu's Digital Annealer provides an alternative to quantum computing technology, which is at present both very expensive and difficult to run. Using a digital circuit design inspired by quantum phenomena, the Digital Annealer focuses on rapidly solving complex combinatorial optimization problems without the added complications and costs typically associated with quantum computing methods.

### Provider:

fujitsu

### Solution Example:

```
## Example of creating solution for digital_annealer_v3 (DAV3) from fujitsu
solution = ls.solution.create(
optimization_id=optimization.id,
solver_name="DAV3",
provider="fujitsu",
parameters={},
qpu_tokens={}
)
```

### Parameters:

**time_limit_sec:** int

Maximum running time of DA in seconds. Specifies the upper limit of running time of DA. Min: 1, Max: 1_800

**Default:**None

**target_energy:** int

Threshold energy for fast exit. This may not work correctly if the specified value is larger than its max value or lower than its min value. Min: -99_999_999_999, Max: 99_999_999_999

**Default:**None

**num_group:** int

Number of independent optimization processes. Increasing the number of independent optimization processes leads to better coverage of the search space. Note: Increasing this number requires to also increase `time_limit_sec` such that the search time for each process is sufficient. Min: 1, Max: 16

**Default:**1

**num_solution:** int

Number of solutions maintained and updated by each optimization process. Min: 1, Max: 16

**Default:**16

**num_output_solution:** int

Maximal number of the best solutions returned by each optimization. Total number of results is `num_solution` * `num_group`. Min: 1, Max: 1_024

**Default:**5

**gs_num_iteration_factor:** int

Maximal number of iterations in one epoch of the global search in each optimization is `gs_num_iteration_factor` * number of bits. Min: 0, Max: 100

**Default:**5

**gs_num_iteration_cl:** int

Maximal number of iterations without improvement in one epoch of the global search in each optimization before terminating and continuing with the next epoch. For problems with very deep local minima having a very low value is helpful. Min: 0, Max: 1_000_000

**Default:**800

**gs_penalty_auto_mode:** int

Parameter to choose whether to automatically incrementally adapt `gs_penalty_coef` to the optimal value. 0: Use `gs_penalty_coef` as the fixed factor to weight the penalty polynomial during optimization. 1: Start with `gs_penalty_coef` as weight factor for penalty polynomial and automatically and incrementally increase this factor during optimization by multiplying `gs_penalty_inc_rate` / 100 repeatedly until `gs_max_penalty_coef` is reached or the penalty energy is zero.

**Default:**1

**gs_penalty_coef:** int

Factor to weight the penalty polynomial. If `gs_penalty_auto_mode` is 0, this value does not change. If `gs_penalty_auto_mode` is 1, this initial weight factor is repeatedly increased by `gs_penalty_inc_rate` until `gs_max_penalty_coef` is reached or the penalty energy is zero. Min: 1, Max: 2**63 - 1

**Default:**1

**gs_penalty_inc_rate:** int

Only used if `gs_penalty_auto_mode` is 1. In this case, the initial weight factor `gs_penalty_coef` for the penalty polynomial is repeatedly increased by multiplying `gs_penalty_inc_rate` / 100 until `gs_max_penalty_coef` is reached or the penalty energy is zero. Min: 100, Max: 200

**Default:**150

**gs_max_penalty_coef:** int

Maximal value for the penalty coefficient. If `gs_penalty_auto_mode` is 0, this is the maximal value for `gs_penalty_coef`. If `gs_penalty_auto_mode` is 1, this is the maximal value to which `gs_penalty_coef` can be increased during the automatic adjustment. If `gs_max_penalty_coef` is set to 0, then the maximal penalty coefficient is 2^63 - 1. Min: 0, Max: 2**63 - 1

**Default:**0

**auto_tuning:** Literal['NOTHING', 'SCALING', 'AUTO_SCALING', 'SAMPLING', 'AUTO_SCALING_AND_SAMPLING', 'SCALING_AND_SAMPLING']

Following methods for scaling `qubo` and determining temperatures are available: AutoTuning.NOTHING: no action AutoTuning.SCALING: `scaling_factor` is multiplied to `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`. AutoTuning.AUTO_SCALING: A maximum scaling factor w.r.t. `scaling_bit_precision` is multiplied to `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`. AutoTuning.SAMPLING: `temperature_start`, `temperature_end` and `offset_increase_rate` are automatically determined. AutoTuning.AUTO_SCALING_AND_SAMPLING: Temperatures and scaling factor are automatically determined and applied.

**Default:**"NOTHING"

**scaling_factor:** Union[int, float]

The scaling factor for `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`.

**Default:**1

**scaling_bit_precision:** int

Maximum `scaling_bit_precision` for `qubo`. Used to define the scaling factor for `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`.

**Default:**64

**guidance_config:** dadk.BinPol.PartialConfig

Specifies an initial value for each polynomial (problem) variable that is set to find an optimal solution. By specifying a value that is close to the optimal solution, improvement in the accuracy of the optimal solution can be expected. If you repeatedly use the specified initial values to solve the same polynomial (problem), the same optimal solution is obtained each time.

**Default:**None

**random_seed:** int

Seed for random numbers for the optimization call. Min: 0, Max: 9_999

**Default:**None

**timeseries_max_bits:** int

Maximum number of bits for timeseries.

**Default:**None

**solver_max_bits:** int

Maximum number of bits on selected solver.

**Default:**8192

## DAV2 - Digital Annealer V2

From the [website](https://www.fujitsu.com/global/services/business-services/digital-annealer/): Fujitsu's Digital Annealer provides an alternative to quantum computing technology, which is at present both very expensive and difficult to run. Using a digital circuit design inspired by quantum phenomena, the Digital Annealer focuses on rapidly solving complex combinatorial optimization problems without the added complications and costs typically associated with quantum computing methods.

### Provider:

fujitsu

### Solution Example:

```
## Example of creating solution for digital_annealer_v2 (DAV2) from fujitsu
solution = ls.solution.create(
optimization_id=optimization.id,
solver_name="DAV2",
provider="fujitsu",
parameters={},
qpu_tokens={}
)
```

### Parameters:

**number_runs:** int

Number of stochastically independent runs. Min: 16, Max: 128

**Default:**16

**number_replicas:** int

Number of replicas in parallel tempering. Min: 26, Max: 128

**Default:**26

**number_iterations:** int

Total number of iterations per run. Min: 1, Max: 2_000_000_000

**Default:**1000000

**auto_tuning:** Literal['NOTHING', 'SCALING', 'AUTO_SCALING', 'SAMPLING', 'AUTO_SCALING_AND_SAMPLING', 'SCALING_AND_SAMPLING']

Following methods for scaling `qubo` and determining temperatures are available: AutoTuning.NOTHING: no action AutoTuning.SCALING: `scaling_factor` is multiplied to `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`. AutoTuning.AUTO_SCALING: A maximum scaling factor w.r.t. `scaling_bit_precision` is multiplied to `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`. AutoTuning.SAMPLING: `temperature_start`, `temperature_end` and `offset_increase_rate` are automatically determined. AutoTuning.AUTO_SCALING_AND_SAMPLING: Temperatures and scaling factor are automatically determined and applied.

**Default:**"NOTHING"

**scaling_factor:** Union[int, float]

The scaling factor for `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`.

**Default:**1

**scaling_bit_precision:** int

Maximum `scaling_bit_precision` for `qubo`. Used to define the scaling factor for `qubo`, `temperature_start`, `temperature_end` and `offset_increase_rate`.

**Default:**64

**guidance_config:** dadk.BinPol.PartialConfig

Specifies an initial value for each polynomial (problem) variable that is set to find an optimal solution. By specifying a value that is close to the optimal solution, improvement in the accuracy of the optimal solution can be expected. If you repeatedly use the specified initial values to solve the same polynomial (problem), the same optimal solution is obtained each time.

**Default:**None

**random_seed:** int

Seed for random numbers for the optimization call. Min: 0, Max: 9_999

**Default:**None

**timeseries_max_bits:** int

Maximum number of bits for timeseries.

**Default:**None

**solver_max_bits:** int

Maximum number of bits on selected solver.

**Default:**8192