Generating Random Numbers Until Some Condition Is Met in R
Last Updated :
25 Sep, 2023
R Language is mainly used for machine learning, statistics, and data analysis. Objects, functions, and R packages can easily be created by R. However we can use this language for other purposes like generating random numbers until a number greater than 0.9 is generated. We can do that using loops as R supports three kinds of loops.
Loops
To solve this problem first we need to understand the Concepts of Loops in R– R is very good at performing repetitive tasks. If we want a set of operations to be repeated several times we use what’s known as a loop. When you create a loop, R will execute the instructions in the loop a specified number of times or until a specified condition is met.
There are three main types of loops in R
- For Loop: With the for loop we can execute a set of statements, once for each item in a vector, array, list, etc.
- While Loop: While Loop can execute a block of code as long as a specified condition is reached.
- Repeat Loop: This loop can execute a block of code multiple times, however the repeat loop does not have any condition to terminate the loop. You need to put an exit condition implicitly with a break statement inside the loop.
Uniform Distribution
A uniform distribution is a probability distribution where each value in the range from a to b has an equal chance of being selected. The ‘runif()’ function is used to generate sequence of random numbers in the uniform distribution.
Syntax:
runif(n, min = 0, max = 1)
Parameter:
n= number of random samples
min=minimum value(by default 0)
max=maximum value(by default 1)
Generate random numbers using For Loop
R
x <- 0
for (i in 1:100) {
x <- runif(1)
print(x)
if (x > 0.9) {
break
}
}
|
Output
[1] 0.5482922
[1] 0.81156
[1] 0.3938314
[1] 0.9569094
- 1. First, it initializes a variable called x and assigns it the value of 0. This variable will store the random number that will be generated in each iteration of the loop.
- 2. Next, it uses a for loop to repeat a block of code 100 times. The for loop has a variable called i that takes values from 1 to 100 in each iteration. The for loop is enclosed by curly braces {} that indicate the start and end of the loop body.
- 3. Inside the loop body, the code does the following:
- It generates a random number between 0 and 1 using the runif function, which takes one argument: the number of random numbers to generate. In this case, it is 1. The random number is assigned to the variable x.
- It prints the value of x using the print function, which displays the output on the console.
- It checks if the value of x is greater than 0.9 using the if statement, which evaluates a logical condition and executes a block of code if it is true. The if statement is also enclosed by curly braces {} that indicate the start and end of the conditional block.
- Inside the conditional block, the code uses the break statement, which terminates the execution of the loop and jumps out of it.
- After the loop ends, the code stops running.
Generate random numbers using While Loop
1. First, it initializes a variable called `x` and assigns it the value of 0. This variable will store the random number that will be generated in each iteration of the loop.
2. Next, it uses a `while` loop to repeat a block of code as long as a condition is true. The `while` loop has a condition that checks if the value of `x` is less than or equal to 0.9. The `while` loop is enclosed by curly braces `{}` that indicate the start and end of the loop body.
3. Inside the loop body, the code does the following:
a. It generates a random number between 0 and 1 using the `runif` function, which takes one argument: the number of random numbers to generate. In this case, it is 1. The random number is assigned to the variable `x`.
b. It prints the value of `x` using the `print` function, which displays the output on the console.
4. After the loop ends, the code stops running.
R
x <- 0
while (x <= 0.9) {
x <- runif(1)
print(x)
}
|
Output
[1] 0.1120839
[1] 0.4356025
[1] 0.02041804
[1] 0.5944996
[1] 0.7476459
[1] 0.3314883
[1] 0.4432616
[1] 0.8747775
[1] 0.2771189
[1] 0.4299433
[1] 0.2105656
[1] 0.2088417
[1] 0.7823486
[1] 0.3891303
[1]...
Assign the value while (x <= 0.9).- This is a
while loop that continues executing as long as the value of x is less than or equal to 0.9.
x <- runif(1):- In each iteration of the loop, a random number between 0 and 1 is generated using the
runif() function.
- The
1 argument specifies that a single random number should be generated.
print(x):- After generating the random number, the value of
x is printed to the console using the print() function.
Generate random numbers using Repeat Loop
1. First, it initializes a variable called `x` and assigns it the value of 0. This variable will store the random number that will be generated in each iteration of the loop.
2. Next, it uses a `repeat` loop to repeat a block of code indefinitely. The `repeat` loop is enclosed by curly braces `{}` that indicate the start and end of the loop body.
3. Inside the loop body, the code does the following:
a. It generates a random number between 0 and 1 using the `runif` function, which takes one argument: the number of random numbers to generate. In this case, it is 1. The random number is assigned to the variable `x`.
b. It prints the value of `x` using the `print` function, which displays the output on the console.
c. It checks if the value of `x` is greater than 0.9 using the `if` statement, which evaluates a logical condition and executes a block of code if it is true. The `if` statement is also enclosed by curly braces `{}` that indicate the start and end of the conditional block.
d. Inside the conditional block, the code uses the `break` statement, which terminates the execution of the loop and jumps out of it.
4. After the loop ends, the code stops running.
R
x <- 0
repeat {
x <- runif(1)
print(x)
if (x > 0.9) {
break
}
}
|
Output
[1] 0.288129
[1] 0.5386403
[1] 0.1097055
[1] 0.6238026
[1] 0.9355597
x <- 0: Initialize the variable x with a value of 0.repeat: This initiates an infinite loop using the repeat keyword. The loop will keep running until the break statement is encountered.- Inside the loop:
x <- runif(1): Generate a random number between 0 and 1 using the runif() function. This function returns a random number from a uniform distribution.print(x): Print the generated random number to the console.if (x > 0.9) : Check if the generated random number is greater than 0.9.- If the condition is true, the
break statement is executed, which terminates the repeat loop.
- If the condition is false, the loop continues to generate and print random numbers.
Share your thoughts in the comments
Please Login to comment...