naginterfaces.library.rand.resample¶

naginterfaces.library.rand.resample(wt, statecomm, rtype=3, ipop=None, m=None, nrs=1, otype=2)[source]¶

resample selects a pseudorandom sample (or resamples) from a vector of integers based on the supplied weights.

For full information please refer to the NAG Library document for g05nf

https://support.nag.com/numeric/nl/nagdoc_30.2/flhtml/g05/g05nff.html

Parameters

wtfloat, array-like, shape $(n)$

$w_{i}$ , the weights. These weights need not sum to $1.0$ .

statecommdict, RNG communication object, modified in place

RNG communication structure.

This argument must have been initialized by a prior call to init_repeat() or init_nonrepeat().

rtypeint, optional

A flag indicating the resampling method to use.

$r t y p e = 1$

Multinomial resampling will be used.

$r t y p e = 2$

Systematic resampling will be used.

$r t y p e = 3$

Residual resampling will be used.

ipopNone or int, array-like, shape $(:)$ , optional

Note: the required length for this argument is determined as follows: if $i p o p is not N o n e$ : $n$ ; otherwise: $0$ .

$V$ , the vector to be sampled from. If $i p o p is N o n e$ then the $V$ is assumed to be the set of values $(1, 2, \dots, n)$ .

Elements of $i p o p$ with the same value are not combined, therefore, if $w t [i] \neq 0, w t [j] \neq 0$ and $i \neq j$ then there is a nonzero probability that the sample will contain both $i p o p [i]$ and $i p o p [j]$ , irrespective of their values.

If the values to be returned in $i s a m p l$ are counts, i.e., $o t y p e = 2$ , then $i p o p$ is not referenced.

mNone or int, optional

Note: if this argument is None then a default value will be used, determined as follows: $n$ .

$m$ , the size of the sample required.

nrsint, optional

The number of times to resample.

otypeint, optional

A flag indicating what is returned in $i s a m p l$ .

$o t y p e = 1$

The values returned in $i s a m p l$ are taken from the population.

$o t y p e = 2$

The values returned in $i s a m p l$ are counts.

See $i s a m p l$ for more information.

Returns

isamplint, ndarray, shape $(:, :)$

The selected samples.

If $o t y p e = 1$ then each column of $i s a m p l$ contains the $m$ values from $V$ that make up the sample.

If $o t y p e = 2$ then $i s a m p l [j - 1, k - 1]$ contains the number of times that $V_{j}$ appears in the $k$ th sample.

Raises

NagValueError

(errno $11$ )

On entry, $r t y p e = ⟨ v a l u e ⟩$ .

Constraint: $r t y p e = 1$ , $2$ or $3$ .

(errno $21$ )

On entry, $n = ⟨ v a l u e ⟩$ .

Constraint: $n \geq 0$ .

(errno $31$ )

On entry, $i = ⟨ v a l u e ⟩$ and $w t [i - 1] = ⟨ v a l u e ⟩$ .

Constraint: $w t [i - 1] \geq 0.0$ .

(errno $32$ )

On entry, all the weights are zero.

Constraint: at least one weight must be nonzero.

(errno $61$ )

On entry, $m = ⟨ v a l u e ⟩$ .

Constraint: $m \geq 0$ .

(errno $71$ )

On entry, $n r s = ⟨ v a l u e ⟩$ .

Constraint: $n r s \geq 0$ .

(errno $81$ )

On entry, $o t y p e = ⟨ v a l u e ⟩$ .

Constraint: $o t y p e = 1$ or $2$ .

(errno $121$ )

On entry, $s t a t e c o m m$ [‘state’] vector has been corrupted or not initialized.

Warns

NagAlgorithmicWarning

(errno $91$ ): There was no random component to the sample. Check the sample size and weights are as expected.

Notes

Given a vector $V$ , of $n$ integer values, resample selects $m$ elements with the probability of selecting $V_{j}$ proportional to a user-supplied weight, $w_{j}$ . The sampling is done with replacement, so that each value, $V_{j}$ , may appear more than once in the sample.

The most common usage case for resample is where $V$ was obtained using some other sampling method, for example, importance sampling. In such a case, this function is used to perform resampling.

Several methods of calculating $N_{j}$ , the number of times $V_{j}$ appears in the sample, are available:

Multinomial Resampling: The vector of counts; ${N_{j} : j = 1, 2, \dots, n}$ is drawn from a multinomial distribution with probabilities given by the normalised weights, $~ w$ .
Systematic Resampling:

$N_{j} = ∣ ∣ ∣ ∣ {u_{i} : i = 1, 2, \dots, m and j - 1 \sum k = 1 {~ w}_{k} < u_{i} \leq j \sum k = 1 {~ w}_{k}} ∣ ∣ ∣ ∣$

where $~ w$ are the normalised weights, $u_{1} \sim U (0, \frac{1}{m})$ , $u_{i} = u_{1} + \frac{i - 1}{m}$ , for $i = 2, 3, \dots, m$ and $\sum_{k = 1}^{0} {~ w}_{k}$ is defined to be zero. In other words, $N_{j}$ is the number of shifted and scaled uniform variates contained in bins defined by the partial sums of normalised weights.
Residual Resampling: $N_{j} = N_{j}^{S} + N_{j}^{R}$ , where $N_{j}^{S} = f l o o r (m {~ w}_{j})$ (i.e. the integer part of $m {~ w}_{j}$ ), and the vector of residual counts, ${N_{j}^{R} : j = 1, 2, \dots, n}$ is drawn from a multinomial distribution with probabilities given by ${{~ w}_{j} - \frac{N_{j}^{S}}{m} : j = 1, 2, \dots, n}$ .

See int_multinomial() for more information on the multinomial distribution and Douc et al. (2005) for more details on the resampling methods.

If multiple samples are requested ( $n r s > 1$ ) then the chosen resampling method is performed independently for each sample.

One of the initialization functions init_repeat() (for a repeatable sequence if computed sequentially) or init_nonrepeat() (for a non-repeatable sequence) must be called prior to the first call to resample.

References

Douc, R, Cappe, O, and Moulines, E, 2005, Comparison of resampling schemes for particle filtering, Proceedings of the 4th International Symposium on Image and Signal Processing and Analysis, 64–69, https://dx.doi.org/10.1109/ISPA.2005.195385

Li, T, Bolic, M, and Djuric, P M, 2015, Resampling Methods for Particle Filtering: Classification, implementation, and strategies, IEEE Signal Processing Magazine (vol. 32, no. 3), 70–86, https://dx.doi.org/10.1109/MSP.2014.2330626

NAG and Python

Return to Front

naginterfaces.library.rand.resample¶