SALib

https://salib.readthedocs.io/en/latest/
Admin
SALib is a Python library that implements commonly used sensitivity analysis methods including...
Tokens:244,403
Snippets:1,169
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Test install from TestPyPI in temporary environment

Source: https://salib.readthedocs.io/en/latest/_sources/release_guide.md.txt

Creates a temporary virtual environment with uv, activates it, and installs the package from TestPyPI to verify installation. The activation command differs on *nix systems.

```bash
$ uv venv .venv-test
$ .venv-test/Scripts/activate        # or: source .venv-test/bin/activate on *nix
$ uv pip install --index-url https://test.pypi.org/simple/ SALib==X.Y.Z

```

--------------------------------

### Test install from TestPyPI in temporary environment

Source: https://salib.readthedocs.io/en/latest/release_guide.html

Creates a temporary virtual environment, activates it, and installs the package from TestPyPI to verify it installs correctly. The activation command differs on *nix systems.

```bash
$ uv venv .venv-test
$ .venv-test/Scripts/activate        # or: source .venv-test/bin/activate on *nix
$ uv pip install --index-url https://test.pypi.org/simple/ SALib==X.Y.Z
```

--------------------------------

### Sync dependencies and install pre-commit

Source: https://salib.readthedocs.io/en/latest/developers_guide.html

Installs SALib and development dependencies, sets up pre-commit hooks, and runs tests.

```bash
$ uv sync                      # equivalent: pip install -e .
$ uv sync --extra dev          # equivalent: pip install -e ".[dev]"

# Install pre-commit as a tool and set up the hook
$ uv tool install pre-commit   # equivalent: pip install --user pre-commit (but isolated)
$ pre-commit install

# To run tests:
$ uv run pytest    # equivalent: pytest (but runs within the uv-managed environment)

```

--------------------------------

### Install documentation dependencies

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Installs the documentation dependencies using uv sync with the doc extra.

```bash
$ uv sync --extra doc    # equivalent: pip install -e ".[doc]"
```

--------------------------------

### Install hatch as a tool

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Installs hatch using uv tool install, which is equivalent to pip install --user hatch but isolated.

```bash
$ uv tool install hatch      # equivalent: pip install --user hatch (but isolated)
```

--------------------------------

### Install SALib and development dependencies

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Installs SALib and its dependencies using uv sync, including development extras, pre-commit, and running tests.

```bash
$ uv sync                      # equivalent: pip install -e .
$ uv sync --extra dev          # equivalent: pip install -e ".[dev]"

# Install pre-commit as a tool and set up the hook
$ uv tool install pre-commit   # equivalent: pip install --user pre-commit (but isolated)
$ pre-commit install

# To run tests:
$ uv run pytest    # equivalent: pytest (but runs within the uv-managed environment)
```

--------------------------------

### Install documentation dependencies

Source: https://salib.readthedocs.io/en/latest/developers_guide.html

Installs extra dependencies needed for building documentation.

```bash
$ uv sync --extra doc    # equivalent: pip install -e ".[doc]"

```

--------------------------------

### Install core dependencies

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/getting-started.rst.txt

Installs NumPy, SciPy, pandas, and matplotlib, which are normally installed automatically with SALib but can be installed manually if needed.

```bash
pip install numpy scipy pandas matplotlib
```

--------------------------------

### Install development version from GitHub

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/getting-started.rst.txt

Clones the SALib repository and installs it in development mode. The development version may be unstable and include bugs.

```bash
git clone https://github.com/SALib/SALib.git
cd SALib
pip install .
```

--------------------------------

### Basic uniform sampling example

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/advanced.rst.txt

Shows the basic SALib example from the basics section, generating a uniform sample of parameter space using saltelli.sample.

```python
from SALib.sample import saltelli
from SALib.analyze import sobol
from SALib.test_functions import Ishigami
import numpy as np

problem = {
    'num_vars': 3,
    'names': ['x1', 'x2', 'x3'],
    'bounds': [[-3.14159265359, 3.14159265359],
               [-3.14159265359, 3.14159265359],
               [-3.14159265359, 3.14159265359]]
}

param_values = saltelli.sample(problem, 1024)
```

--------------------------------

### CLI parsing and action for Morris method in SALib

Source: https://salib.readthedocs.io/en/latest/_modules/SALib/sample/morris/morris.html

These are the CLI setup and action functions for the Morris sampling command. The cli_parse function defines command-line arguments for levels, k-optimal, and local. The cli_action function reads the parameter file, samples using the provided arguments with seed and local_optimization, and saves the result with np.savetxt. The __main__ block invokes common_args.run_cli to start the CLI.

```Python
def cli_parse(parser):
    parser.add_argument(
        "-l",
        "--levels",
        type=int,
        required=False,
        default=4,
        help="Number of grid levels \
                        (Morris only)",
    )
    parser.add_argument(
        "-k",
        "--k-optimal",
        type=int,
        required=False,
        default=None,
        help="Number of optimal trajectories \
                        (Morris only)",
    )
    parser.add_argument(
        "-lo",
        "--local",
        type=bool,
        required=True,
        default=False,
        help="Use the local optimisation method \
                        (Morris with optimization only)",
    )
    return parser
```

```Python
def cli_action(args):
    problem = read_param_file(args.paramfile)
    param_values = sample(
        problem,
        args.samples,
        num_levels=args.levels,
        optimal_trajectories=args.k_optimal,
        local_optimization=args.local,
        seed=args.seed,
    )

    np.savetxt(
        args.output,
        param_values,
        delimiter=args.delimiter,
        fmt="%." + str(args.precision) + "e",
    )
```

```Python
if __name__ == "__main__":
    common_args.run_cli(cli_parse, cli_action)
```

--------------------------------

### Install SALib with pip

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/getting-started.rst.txt

Installs the latest stable version of SALib from PyPI along with all dependencies.

```bash
pip install SALib
```

--------------------------------

### Example: Using fast.analyze with fast_sampler and Ishigami

Source: https://salib.readthedocs.io/en/latest/api/SALib.analyze.html

Shows how to use SALib.analyze.fast.analyze with the fast_sampler and the Ishigami test function. The example samples 1000 inputs, evaluates the model, and computes sensitivity indices with console output disabled.

```python
>>> X = fast_sampler.sample(problem, 1000)
>>> Y = Ishigami.evaluate(X)
>>> Si = fast.analyze(problem, Y, print_to_console=False)
```

--------------------------------

### Create bar chart of results with SALib.plotting.bar.plot

Source: https://salib.readthedocs.io/en/latest/api/SALib.plotting.html

Example from the SALib.plotting.bar module documentation. It shows how to import the bar plot function, sample the Ishigami function, analyze with Sobol, and plot the total-order indices. The example references a README for the problem specification and uses `print_to_console=False` in the analysis.

```python
>>> from SALib.plotting.bar import plot as barplot
>>> from SALib.test_functions import Ishigami
>>>
>>> # See README for example problem specification
>>>
>>> X = saltelli.sample(problem, 512)
>>> Y = Ishigami.evaluate(X)
>>> Si = sobol.analyze(problem, Y, print_to_console=False)
>>> total, first, second = Si.to_df()
>>> barplot(total)
```

--------------------------------

### Sobol sensitivity analysis example

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/getting-started.rst.txt

Interactive Python example that samples the Ishigami function, runs the model, and performs Sobol sensitivity analysis. If installed correctly, the last line prints three values similar to [ 0.31683154 0.44376306 0.01220312].

```python
from SALib.analyze.sobol import analyze
from SALib.sample.sobol import sample
from SALib.test_functions import Ishigami
import numpy as np

# Define the model inputs
problem = {
    'num_vars': 3,
    'names': ['x1', 'x2', 'x3'],
    'bounds': [[-3.14159265359, 3.14159265359],
               [-3.14159265359, 3.14159265359],
               [-3.14159265359, 3.14159265359]]
}

# Generate samples
param_values = sample(problem, 1024)

# Run model (example)
Y = Ishigami.evaluate(param_values)

# Perform analysis
Si = analyze(problem, Y, print_to_console=True)

# Print the first-order sensitivity indices
print(Si['S1'])
```

--------------------------------

### SALib.analyze.common_args.setup

Source: https://salib.readthedocs.io/en/latest/api/SALib.analyze.html

Sets up the CLI parser with common arguments.

```APIDOC
## SALib.analyze.common_args.setup

### Description
Sets up the CLI parser with common arguments.

### Method
setup

### Parameters
- `_parser` - The parser to set up.

### Returns
None.
```

--------------------------------

### SALib.sample.common_args.setup

Source: https://salib.readthedocs.io/en/latest/api/SALib.sample.html

Adds common sampling options to a CLI parser.

```APIDOC
## setup(parser)

### Description
Adds common sampling options to a CLI parser.

### Parameters
- **parser** (argparse object) - The parser to update

### Returns
- **Updated argparse object** - The parser with common options added

```

--------------------------------

### PAWN analyze function source code

Source: https://salib.readthedocs.io/en/latest/_modules/SALib/analyze/pawn.html

The full source code of the analyze function for PAWN sensitivity analysis. It imports necessary modules, defines the function signature, and includes the docstring with an example usage. The implementation starts by setting the random seed, extracting problem dimensions, and initializing result arrays.

```python
from typing import Dict

import numpy as np
from scipy.stats import ks_2samp

from . import common_args
from ..util import read_param_file, ResultDict, extract_group_names, _check_groups




[docs]
def analyze(
    problem: Dict,
    X: np.ndarray,
    Y: np.ndarray,
    S: int = 10,
    print_to_console: bool = False,
    seed: int | None = None,
):
    """Performs PAWN sensitivity analysis.

    The PAWN method [1] is a moment-independent approach to Global Sensitivity
    Analysis (GSA). It is described as producing robust results at relatively
    low sample sizes (see [2]) for the purpose of factor ranking and screening.

    The distribution of model outputs is examined rather than
    their variation as is typical in other common GSA approaches. The PAWN
    method further distinguishes itself from other moment-independent
    approaches by characterizing outputs by their cumulative distribution
    function (CDF) as opposed to their probability distribution function.
    As the CDF for a given random variable is typically normally distributed,
    PAWN can be more appropriately applied when outputs are highly-skewed or
    multi-modal, for which variance-based methods may produce unreliable
    results.

    PAWN characterizes the relationship between inputs and outputs by
    quantifying the variation in the output distributions after conditioning
    an input. A factor is deemed non-influential if distributions coincide at
    all ``S`` conditioning intervals. The Kolmogorov-Smirnov statistic is used
    as a measure of distance between the distributions.

    This implementation reports the PAWN index at the min, mean, median, and
    max across the slides/conditioning intervals as well as the coefficient of
    variation (``CV``) and standard deviation (``stdev``). The median value is the
    typically reported value. As the ``CV`` is (standard deviation / mean), it
    indicates the level of variability across the slides, with values closer to zero
    indicating lower variation.


    Notes
    -----
    Compatible with:
        all samplers

    This implementation ignores all NaNs.

    When applied to grouped factors, the analysis is conducted on each factor
    individually, and the mean of their results are reported.


    Examples
    --------
        >>> X = latin.sample(problem, 1000)
        >>> Y = Ishigami.evaluate(X)
        >>> Si = pawn.analyze(problem, X, Y, S=10, print_to_console=False)


    Parameters
    ----------
    problem : dict
        The problem definition
    X : numpy.array
        A NumPy array containing the model inputs
    Y : numpy.array
        A NumPy array containing the model outputs
    S : int
        Number of slides; the conditioning intervals (default 10)
    print_to_console : bool
        Print results directly to console (default False)
    seed : int
        Seed value to ensure deterministic results


    References
    ----------
    1. Pianosi, F., Wagener, T., 2015.
           A simple and efficient method for global sensitivity analysis
           based on cumulative distribution functions.
           Environmental Modelling & Software 67, 1-11.
           https://doi.org/10.1016/j.envsoft.2015.01.004

    2. Pianosi, F., Wagener, T., 2018.
           Distribution-based sensitivity analysis from a generic input-output sample.
           Environmental Modelling & Software 108, 197-207.
           https://doi.org/10.1016/j.envsoft.2018.07.019

    3. Baroni, G., Francke, T., 2020.
           An effective strategy for combining variance- and
           distribution-based global sensitivity analysis.
           Environmental Modelling & Software, 134, 104851.
           https://doi.org/10.1016/j.envsoft.2020.104851

    4. Baroni, G., Francke, T., 2020.
           GSA-cvd
           Combining variance- and distribution-based global sensitivity analysis
           https://github.com/baronig/GSA-cvd
    """
    if seed:
        np.random.seed(seed)

    D = problem["num_vars"]
    var_names, _ = extract_group_names(problem)

    results = np.full((D, 6), np.nan)
    temp_pawn = np.full((S, D), np.nan)

    step = 1 / S
    for d_i in range(D):
        seq = np.arange(0, 1 + step, step)
        X_di = X[:, d_i]
        X_q = np.nanquantile(X_di, seq)

        for s in range(S):
            Y_sel = Y[(X_di >= X_q[s]) & (X_di < X_q[s + 1])]
            if len(Y_sel) == 0:
                # no available samples
                continue

```

--------------------------------

### SALib basic usage example with Ishigami function

Source: https://salib.readthedocs.io/en/latest/user_guide/getting-started.html

Interactive Python session demonstrating SALib's Sobol sensitivity analysis workflow: define a problem, generate samples, evaluate the Ishigami function, and print first-order sensitivity indices. If installed correctly, the last line prints three values similar to [ 0.31683154 0.44376306 0.01220312].

```python
from SALib.analyze.sobol import analyze
from SALib.sample.sobol import sample
from SALib.test_functions import Ishigami
import numpy as np

# Define the model inputs
problem = {
    'num_vars': 3,
    'names': ['x1', 'x2', 'x3'],
    'bounds': [[-3.14159265359, 3.14159265359],
               [-3.14159265359, 3.14159265359],
               [-3.14159265359, 3.14159265359]]
}

# Generate samples
param_values = sample(problem, 1024)

# Run model (example)
Y = Ishigami.evaluate(param_values)

# Perform analysis
Si = analyze(problem, Y, print_to_console=True)

# Print the first-order sensitivity indices
print(Si['S1'])

```

--------------------------------

### Verify hatch installation

Source: https://salib.readthedocs.io/en/latest/developers_guide.html

Checks that hatch is installed and accessible.

```bash
$ hatch --version

```

--------------------------------

### Run Sobol analysis with core SALib functions

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/wrappers.rst.txt

Equivalent to the previous example but using the core SALib functions directly. It defines a problem dictionary, samples with saltelli.sample, evaluates the wrapped function in a loop, and analyzes with sobol.analyze.

```python
problem = {
    'names': ['a', 'b', 'x'],
    'bounds': [
        [-1, 0],
        [-1, 0],
        [-1, 1],
    ],
    'num_vars': 3
}

X = saltelli.sample(problem, 64)
Y = np.empty(params.shape[0])
for i in range(params.shape[0]):
    Y[i] = wrapped_linear(params[i, :])

res = sobol.analyze(problem, Y)
res.to_df()
```

--------------------------------

### Build documentation on *nix

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Builds the documentation locally on Unix-like systems using make html.

```bash
$ cd docs
$ make html
```

--------------------------------

### Verify hatch installation

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Checks that hatch is installed and accessible by displaying its version.

```bash
$ hatch --version
```

--------------------------------

### PAWN analysis example

Source: https://salib.readthedocs.io/en/latest/api.html

Example usage of pawn.analyze with Latin hypercube sampling and the Ishigami function. The example samples 1000 inputs, evaluates the model, and performs PAWN analysis with S=10 and print_to_console=False.

```python
>>> X = latin.sample(problem, 1000)
>>> Y = Ishigami.evaluate(X)
>>> Si = pawn.analyze(problem, X, Y, S=10, print_to_console=False)
```

--------------------------------

### SALib.analyze.common_args module source

Source: https://salib.readthedocs.io/en/latest/_modules/SALib/analyze/common_args.html

Defines setup(), create(), and run_cli() for building and running SALib CLI parsers. setup() adds -p/--paramfile, -Y/--model-output-file, -c/--column (default 0), --delimiter (default space), and -s/--seed (default None). create() optionally applies a cli_parser to customize the parser. run_cli() parses known_args and calls run_analysis(args).

```python
import argparse




[docs]
def setup(parser):
    parser = argparse.ArgumentParser(
        description="Perform sensitivity analysis on model output"
    )
    parser.add_argument(
        "-p", "--paramfile", type=str, required=True, help="Parameter range file"
    )
    parser.add_argument(
        "-Y", "--model-output-file", type=str, required=True, help="Model output file"
    )
    parser.add_argument(
        "-c",
        "--column",
        type=int,
        required=False,
        default=0,
        help="Column of output to analyze",
    )
    parser.add_argument(
        "--delimiter",
        type=str,
        required=False,
        default=" ",
        help="Column delimiter in model output file",
    )
    parser.add_argument(
        "-s", "--seed", type=int, required=False, default=None, help="Random Seed"
    )
    return parser






[docs]
def create(cli_parser=None):
    parser = argparse.ArgumentParser(
        description="Perform sensitivity analysis on model output"
    )
    parser = setup(parser)

    if cli_parser:
        parser = cli_parser(parser)

    return parser






[docs]
def run_cli(cli_parser, run_analysis, known_args=None):
    parser = create(cli_parser)
    args = parser.parse_args(known_args)

    run_analysis(args)

```

--------------------------------

### Imports for parabola example

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/basics.rst.txt

Import numpy, matplotlib, and SALib modules for the parabola example.

```python
import numpy as np
import matplotlib.pyplot as plt

from SALib.sample import saltelli
from SALib.analyze import sobol
```

--------------------------------

### Build SALib with hatch

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Builds the SALib project using hatch.

```bash
$ hatch build
```

--------------------------------

### Install SALib prerequisite packages

Source: https://salib.readthedocs.io/en/latest/user_guide/getting-started.html

Installs the core dependencies (NumPy, SciPy, pandas, matplotlib) if they are not already present. These are normally installed automatically with SALib and are included in most Python bundles like Anaconda and Canopy.

```bash
pip install numpy scipy pandas matplotlib

```

--------------------------------

### Sample, evaluate, and analyze parabola

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/basics_with_interface.rst.txt

Create bins of x, wrap the parabola to run each a, b combination separately, then sample, evaluate, and analyze using Sobol.

```python
# Create "bins" of x
x = np.linspace(-1, 1, 100)

# Create wrapper (runs each a, b combination separately)
def wrapped_parabola(ab, x=x):
    y = np.zeros((ab.shape[0], x.shape[0]))
    for i, (a, b) in enumerate(ab):
        y[i,:] = parabola(x, a, b)

    return y

(
    sp.sample_sobol(2**6)
    .evaluate(wrapped_parabola)
    .analyze_sobol()
)
```

--------------------------------

### Build documentation on Unix

Source: https://salib.readthedocs.io/en/latest/developers_guide.html

Builds the HTML documentation on Unix-like systems.

```bash
$ cd docs
$ make html

```

--------------------------------

### Define problem dict for parabola example

Source: https://salib.readthedocs.io/en/latest/_sources/user_guide/basics.rst.txt

Define the problem dictionary for the parabola example, with only parameters a and b.

```python
problem = {
    'num_vars': 2,
    'names': ['a', 'b'],
    'bounds': [[0, 1]]*2
}
```

--------------------------------

### Analyze DGSM Example

Source: https://salib.readthedocs.io/en/latest/_modules/SALib/analyze/dgsm.html

Example usage of the dgsm.analyze function to perform sensitivity analysis on model outputs.

```python
>>> X = finite_diff.sample(problem, 1000)
>>> Y = Ishigami.evaluate(X)
>>> Si = dgsm.analyze(problem, X, Y, print_to_console=False)
```

--------------------------------

### Example: Using analyze_hdmr with ProblemSpec

Source: https://salib.readthedocs.io/en/latest/_modules/SALib/analyze/hdmr.html

Shows how to set up a ProblemSpec, sample with Saltelli, evaluate with the Ishigami function, and run HDMR analysis, then call the emulator.

```python
sp = ProblemSpec({
    'names': ['X1', 'X2', 'X3'],
    'bounds': [[-np.pi, np.pi]] * 3,
    # 'groups': ['A', 'B', 'A'],
    'outputs': ['Y']
})

(sp.sample_saltelli(2048)
    .evaluate(Ishigami.evaluate)
    .analyze_hdmr()
)

sp.emulate()
```

--------------------------------

### Build documentation on Windows

Source: https://salib.readthedocs.io/en/latest/_sources/developers_guide.md.txt

Builds the documentation locally on Windows using sphinx-build.

```bash
> cd docs
> sphinx-build . ./html
```

--------------------------------

### Delta analyze example

Source: https://salib.readthedocs.io/en/latest/api.html

Example usage of delta.analyze with Latin hypercube sampling and Ishigami evaluation. The output is printed to console.

```python
>>> X = latin.sample(problem, 1000)
>>> Y = Ishigami.evaluate(X)
>>> Si = delta.analyze(problem, X, Y, print_to_console=True)
```

--------------------------------

### avail_approaches(pkg)

Source: https://salib.readthedocs.io/en/latest/api/SALib.util.html

Creates a list of available submodules in a given module. Useful for discovering available analysis methods.

```APIDOC
## avail_approaches(pkg)

### Description
Creates a list of available submodules in a given module. Useful for discovering available analysis methods.

### Method
Function

### Signature
`avail_approaches(pkg)`

### Parameters
- **pkg** (module) - Required - The module to inspect.

### Returns
- **method** (list) - A list of available submodules.

```

--------------------------------

### sample(problem, N, *, calc_second_order=True, scramble=True, skip_values=0, seed=None)

Source: https://salib.readthedocs.io/en/latest/_modules/SALib/sample/sobol.html

Generates model inputs using Saltelli's extension of the Sobol' sequence. Returns a NumPy matrix of samples intended for use with SALib.analyze.sobol.analyze.

```APIDOC
## sample(problem, N, *, calc_second_order=True, scramble=True, skip_values=0, seed=None)

### Description
Generates model inputs using Saltelli's extension of the Sobol' sequence. Returns a NumPy matrix containing the model inputs using Saltelli's sampling scheme.

### Method
Function call

### Signature
```python
def sample(
    problem: Dict,
    N: int,
    *,
    calc_second_order: bool = True,
    scramble: bool = True,
    skip_values: int = 0,
    seed: Optional[Union[int, np.random.Generator]] = None,
)
```

### Parameters
- **problem** (dict) - Required - The problem definition.
- **N** (int) - Required - The number of samples to generate. Ideally a power of 2 and <= `skip_values`.
- **calc_second_order** (bool, optional) - Calculate second-order sensitivities. Default is True.
- **scramble** (bool, optional) - If True, use LMS+shift scrambling. Otherwise, no scrambling is done. Default is True.
- **skip_values** (int, optional) - Number of points in Sobol' sequence to skip, ideally a value of base 2. It's recommended not to change this value and use `scramble` instead. `scramble` and `skip_values` can be used together. Default is 0.
- **seed** ({None, int, `numpy.random.Generator`}, optional) - If `seed` is None the `numpy.random.Generator` generator is used. If `seed` is an int, a new ``Generator`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` instance then that instance is used. Default is None.

### Returns
- **NumPy matrix** - Model inputs using Saltelli's sampling scheme. If `calc_second_order` is False, the resulting matrix has `N * (D + 2)` rows, where `D` is the number of parameters. If `calc_second_order` is True, the resulting matrix has `N * (2D + 2)` rows.

### Notes
The initial points of the Sobol' sequence has some repetition, which can be avoided by scrambling the sequence. Another option, not recommended and available for educational purposes, is to use the `skip_values` parameter. Skipping values reportedly improves the uniformity of samples, but it has been shown that naively skipping values may reduce accuracy, increasing the number of samples needed to achieve convergence.

### References
1. Sobol', I.M., 2001. Global sensitivity indices for nonlinear mathematical models and their Monte Carlo estimates. Mathematics and Computers in Simulation, The Second IMACS Seminar on Monte Carlo Methods 55, 271-280. https://doi.org/10.1016/S0378-4754(00)00270-6
2. Saltelli, A. (2002). Making best use of model evaluations to compute sensitivity indices. Computer Physics Communications, 145(2), 280-297. https://doi.org/10.1016/S0010-4655(02)00280-1
3. Campolongo, F., Saltelli, A., Cariboni, J., 2011. From screening to quantitative sensitivity analysis. A unified approach. Computer Physics Communications 182, 978-988. https://doi.org/10.1016/j.cpc.2010.12.039
4. Owen, A. B., 2020. On dropping the first Sobol' point. arXiv:2008.08051 [cs, math, stat]. Available at: http://arxiv.org/abs/2008.08051 (Accessed: 20 April 2021).
```
Tokens:
Raw