HuberLawSampler

All Implemented Interfaces:
```
public final class HuberLawSampler
extends PermSolver
                    
```
Sampling method to approximate the permanent using the Huber-Law bound.
The Huber-Law algorithm uses acceptance-rejection sampling with a carefully constructed bound to estimate the permanent. The method rescales the matrix to be doubly stochastic and then uses the Huber-Law bound for efficient sampling.
Key features:
- Provides theoretical guarantees on approximation quality
- Three sampling modes: classic (with acceptance guarantee), time-limited, and sample-limited
- Automatic matrix rescaling to doubly stochastic form

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description
`private final List<Integer>`	`sampleAccepted`
`private final List<Long>`	`sampleTime`
`private final 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
`HuberLawSampler(Matrix matrix, Double delta, Double alpha2, Double epsilon, String mode, Integer numberOfSamples, Long maximumTime, Boolean solve)`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`final List<Integer>`	`getSampleAccepted()`
`final List<Long>`	`getSampleTime()`
`final List<Double>`	`getPermStep()`
`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
  - HuberLawSampler
```
HuberLawSampler(Matrix matrix, Double delta, Double alpha2, Double epsilon, String mode, Integer numberOfSamples, Long maximumTime, Boolean solve)
```
    Parameters:
    
    matrix - The matrix for which to compute the permanent approximation
    
    delta - Approximation parameter: result will be (1+delta) times the true value with high probability (default: 0.
    
    alpha2 - Accuracy of doubly stochastic rescaling (default: 0.
    
    epsilon - Confidence parameter: approximation holds with probability (1-epsilon) (default: 0.
    
    mode - Sampling mode: "classic", "time", or "sample" (default: "classic")
    
    numberOfSamples - Maximum number of samples for sample mode (default: 1000)
    
    maximumTime - Maximum time in seconds for time mode (default: 30)
    
    solve - Whether to automatically run solve() after construction (default: false)
- Method Detail
  - getSampleAccepted
```
 final List<Integer> getSampleAccepted()
```
  - getSampleTime
```
 final List<Long> getSampleTime()
```
  - getPermStep
```
 final List<Double> getPermStep()
```
  - 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.