In this article, you’ll learn how to draw elements randomly from an object in R. We will also be creating objects with random values all this using just one function `sample()`

`sample`

takes a sample of the specified size from the elements of `x`

using either with or without replacement.

**Usage**

```
> sample(x, size, replace = FALSE, prob = NULL)
> sample.int(n, size = n, replace = FALSE, prob = NULL,
useHash = (!replace && is.null(prob) && size <= n/2 && n > 1e7))
```

**Arguments**

Value | Description |

`x` | either a vector of one or more elements from which to choose, or a positive integer. See ‘Details.’ |

`n` | a positive number, the number of items to choose from. See ‘Details.’ |

`size` | a non-negative- integer giving the number of items to choose. |

`replace` | should sampling be with replacement? |

`prob` | a vector of probability weights for obtaining the elements of the vector being sampled. |

`useHash` | `logical` indicating if the hash-version of the algorithm should be used. Can only be used for `replace = FALSE` , `prob = NULL` , and `size <= n/2` , and really should be used for large `n` , as `useHash=FALSE` will use memory proportional to `n` . |

**Details**

If `x`

has length 1, is numeric (in the sense of `is.numeric`

) and `x >= 1`

, sampling *via* `sample`

takes place from `1:x`

. *Note* that this convenience feature may lead to undesired behaviour when `x`

is of varying length in calls such as `sample(x)`

. See the examples.

Otherwise `x`

can be any **R** object for which `length`

and subsetting by integers make sense: S3 or S4 methods for these operations will be dispatched as appropriate.

For `sample`

the default for `size`

is the number of items inferred from the first argument, so that `sample(x)`

generates a random permutation of the elements of `x`

(or `1:x`

).

It is allowed to ask for `size = 0`

samples with `n = 0`

or a length-zero `x`

, but otherwise `n > 0`

or positive `length(x)`

is required.

Non-integer positive numerical values of `n`

or `x`

will be truncated to the next smallest integer, which has to be no larger than `.Machine$integer.max`

.

The optional `prob`

argument can be used to give a vector of weights for obtaining the elements of the vector being sampled. They need not sum to one, but they should be non-negative and not all zero. If `replace`

is true, Walker’s alias method (Ripley, 1987) is used when there are more than 200 reasonably probable values: this gives results incompatible with those from **R** < 2.2.0.

If `replace`

is false, these probabilities are applied sequentially, that is the probability of choosing the next item is proportional to the weights amongst the remaining items. The number of nonzero weights must be at least `size`

in this case.

`sample.int`

is a bare interface in which both `n`

and `size`

must be supplied as integers.

Argument `n`

can be larger than the largest integer of type `integer`

, up to the largest representable integer in type `double`

.

**To draw elements randomly**

We first need an object with random values so that we can draw elements from it. And we will be doing this with the help of `sample()`

function.

```
# Creating a vector of 10 elements.
# Set seed to get the same random values every time.
> set.seed(100)
> x <- sample(1:100, size = 10)
> x
[1] 74 89 78 23 86 70 4 55 95 7
```

Now to draw elements randomly from the vector.

```
# to get one random value from x
> sample(x, 1)
[1] 4
# to get three random values from x
> sample(x, 3)
[1] 89 95 7
```

Conslusion

Hence, we saw how to draw elements randomly from an object and also about the `sample()`

function with its details and how to use it along with the examples.

This brings the end of this Blog. We really appreciate your time.

Hope you liked it.

Do visit our page www.zigya.com/blog for more informative blogs on Data Science

Keep Reading! Cheers!

Zigya Academy

BEING RELEVANT