AdaPartSampler

All Implemented Interfaces:
```
public final class AdaPartSampler
extends PermSolver
                    
```
Sampling method to approximate the permanent using Adaptive Partitioning (AdaPart).
The AdaPart algorithm uses importance sampling with adaptive partitioning to estimate the permanent. It iteratively refines the sampling space by partitioning based on upper bounds, leading to more efficient sampling than naive approaches.
The algorithm provides three sampling modes:
- Classic: Samples until reaching maximum accepted samples
- Time: Samples for a maximum time duration
- Sample: Samples for a maximum total number of samples

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description
`private List<Integer>`	`sampleAccepted`
`private List<Long>`	`sampleTime`
`private List<Double>`	`permStep`
`private final Integer`	`n`
`private Double`	`value`
`private Long`	`time`
`private Long`	`memory`
`private final Matrix`	`matrix`

Constructor Summary

Constructors
Constructor	Description
`AdaPartSampler(Matrix matrix, Integer maximumAcceptedSamples, Long maximumTime, Integer maximumSamples, String mode, Boolean solve)`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`final List<Integer>`	`getSampleAccepted()`
`final Unit`	`setSampleAccepted(List<Integer> sampleAccepted)`
`final List<Long>`	`getSampleTime()`
`final Unit`	`setSampleTime(List<Long> sampleTime)`
`final List<Double>`	`getPermStep()`
`final Unit`	`setPermStep(List<Double> permStep)`
`Unit`	`compute()`	Compute the permanent or approximation for the given matrix.

Methods inherited from class jline.lib.perm.PermSolver
getMatrix, getMemory, getN, getTime, getValue, setMemory, setTime, setValue, solve
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AdaPartSampler
```
AdaPartSampler(Matrix matrix, Integer maximumAcceptedSamples, Long maximumTime, Integer maximumSamples, String mode, Boolean solve)
```
    Parameters:
    
    matrix - The matrix for which to compute the permanent approximation
    
    maximumAcceptedSamples - Maximum number of accepted samples for classic mode (default: 100)
    
    maximumTime - Maximum time in seconds for time mode (default: 30)
    
    maximumSamples - Maximum total samples for sample mode (default: 450)
    
    mode - Sampling mode: "classic", "time", or "sample" (default: "classic")
    
    solve - Whether to automatically run solve() after construction (default: false)
- Method Detail
  - getSampleAccepted
```
 final List<Integer> getSampleAccepted()
```
  - setSampleAccepted
```
 final Unit setSampleAccepted(List<Integer> sampleAccepted)
```
  - getSampleTime
```
 final List<Long> getSampleTime()
```
  - setSampleTime
```
 final Unit setSampleTime(List<Long> sampleTime)
```
  - getPermStep
```
 final List<Double> getPermStep()
```
  - setPermStep
```
 final Unit setPermStep(List<Double> permStep)
```
  - compute
```
 Unit compute()
```
    Compute the permanent or approximation for the given matrix. This method must be implemented by all concrete solver classes. The result should be stored in the value property.