# Source code for SALib.sample.ff

```"""The sampling implementation of fractional factorial method

This implementation is based on the formulation put forward in
[`Saltelli et al. 2008 <http://doi.org/10.1002/9780470725184>`_]
"""

import numpy as np
from . import common_args

[docs]
def find_smallest(num_vars):
"""Find the smallest exponent of two that is greater than the number
of variables.

Parameters
----------
num_vars : int
Number of variables

Returns
-------
x : int
Smallest exponent of two greater than `num_vars`
"""
for x in range(10):
if num_vars <= 2**x:
return x

[docs]
def extend_bounds(problem):
"""Extends the problem bounds to the nearest power of two.

Parameters
----------
problem : dict
The problem definition
"""

num_vars = problem["num_vars"]
num_ff_vars = 2 ** find_smallest(num_vars)
num_dummy_variables = num_ff_vars - num_vars

bounds = list(problem["bounds"])
names = problem["names"]
if num_dummy_variables > 0:
bounds.extend([[0, 1] for x in range(num_dummy_variables)])
names.extend(["dummy_" + str(var) for var in range(num_dummy_variables)])
problem["bounds"] = bounds
problem["names"] = names
problem["num_vars"] = num_ff_vars

return problem

[docs]
def generate_contrast(problem):
"""Generates the raw sample from the problem file.

Parameters
----------
problem : dict
The problem definition
"""

num_vars = problem["num_vars"]

# Find the smallest n, such that num_vars < k
k_chosen = 2 ** find_smallest(num_vars)

# Generate the fractional factorial contrast

return contrast

[docs]
def sample(problem, seed=None):
"""Generates model inputs using a fractional factorial sample.

Returns a NumPy matrix containing the model inputs required for a
fractional factorial analysis.
The resulting matrix has D columns, where D is smallest power of 2 that is
greater than the number of parameters.
These model inputs are intended to be used with
:func:`SALib.analyze.ff.analyze`.

The problem file is padded with a number of dummy variables called
``dummy_0`` required for this procedure. These dummy variables can be used
as a check for errors in the analyze procedure.

This algorithm is an implementation of that contained in Saltelli et al
[`Saltelli et al. 2008 <http://doi.org/10.1002/9780470725184>`_]

Parameters
----------
problem : dict
The problem definition
seed : int
Seed to generate a random number

Returns
-------
sample : :class:`numpy.array`

References
----------
1. Saltelli, A., Ratto, M., Andres, T., Campolongo, F.,
Cariboni, J., Gatelli, D., Saisana, M., Tarantola, S., 2008.
Global Sensitivity Analysis: The Primer.
Wiley, West Sussex, U.K.
http://doi.org/10.1002/9780470725184
"""
if seed:
np.random.seed(seed)
contrast = generate_contrast(problem)
sample = np.array((contrast + 1.0) / 2, dtype=float)
problem = extend_bounds(problem)

sample = scale_samples(sample, problem)
return sample

cli_parse = None

[docs]
def cli_action(args):
"""Run sampling method

Parameters
----------
args : argparse namespace
"""