My first foray in Java programming with a self set goal. To create a win-line based slot machine with: - A range of symbols and payouts, - An interactive UI, - Implementation of sounds. The learning outcomes were familiarisation with Java Swing, Workers, and the use of Git itself.

Introduction

Reinforcement Learning is definitely one of the most active and stimulating areas of research in AI.

The interest in this field grew exponentially over the last couple of years, following great (and greatly publicized) advances, such as DeepMind's AlphaGo beating the word champion of GO, and OpenAI AI models beating professional DOTA players.

Thanks to all of these advances, Reinforcement Learning is now being applied in a variety of different fields, from healthcare to finance, from chemistry to resource management.

In this article, we will introduce the fundamental concepts and terminology of Reinforcement Learning, and we will apply them in a practical example.

What is Reinforcement Learning?

Reinforcement Learning (RL) is a branch of machine learning concerned with actors, or agents, taking actions is some kind of environment in order to maximize some type of reward that they collect along the way.

This is deliberately a very loose definition, which is why reinforcement learning techniques can be applied to a very wide range of real-world problems.

Imagine someone playing a video game. The player is the agent, and the game is the environment. The rewards the player gets (i.e. beat an enemy, complete a level), or doesn't get (i.e. step into a trap, lose a fight) will teach him how to be a better player.

As you've probably noticed, reinforcement learning doesn't really fit into the categories of supervised/unsupervised/semi-supervised learning.

In supervised learning, for example, each decision taken by the model is independent, and doesn't affect what we see in the future.

(by kitty, Jul 5th, 2007)It makes me don't know why like NorahOh oh oh! (by kitty, Jul 5th, 2007)Make me crazyVegas Casino! Slot machine sounds ringtones.

In reinforcement learning, instead, we are interested in a long term strategy for our agent, which might include sub-optimal decisions at intermediate steps, and a trade-off between exploration (of unknown paths), and exploitation of what we already know about the environment.

Brief History of Reinforcement Learning

For several decades (since the 1950s!), reinforcement learning followed two separate threads of research, one focusing on trial and error approaches, and one based on optimal control.

Optimal control methods are aimed at designing a controller to minimize a measure of a dynamical system's behaviour over time. To achieve this, they mainly used dynamic programming algorithms, which we will see are the foundations of modern reinforcement learning techniques.

Trial-and-error approaches, instead, have deep roots in the psychology of animal learning and neuroscience, and this is where the term reinforcement comes from: actions followed (reinforced) by good or bad outcomes have the tendency to be reselected accordingly.

Arising from the interdisciplinary study of these two fields came a field called Temporal Difference (TD) Learning.

The modern machine learning approaches to RL are mainly based on TD-Learning, which deals with rewards signals and a value function (we'll see more in detail what these are in the following paragraphs).

Terminology

We will now take a look at the main concepts and terminology of Reinforcement Learning.

Agent

A system that is embedded in an environment, and takes actions to change the state of the environment. Examples include mobile robots, software agents, or industrial controllers.

Environment

The external system that the agent can 'perceive' and act on.

Environments in RL are defined as Markov Decision Processes (MDPs). A MDP is a tuple:

$$
(S, A, P, R, gamma)
$$

where:

• S is a finite set of states
• A is a finite set of actions
• P is a state transition probability matrix

• R is a reward function

• γ is a discount factor, γ ∈ [0,1]

A lot of real-world scenarios can be represented as Markov Decision Processes, from a simple chess board to a much more complex video game.

In a chess environment, the states are all the possible configurations of the board (there are a lot). The actions refer to moving the pieces, surrendering, etc.

The rewards are based on whether we win or lose the game, so that winning actions have higher return than losing ones.

State transition probabilities enforce the game rules. For example, an illegal action (move a rook diagonally) will have zero probability.

Reward Function

The reward function maps states to their rewards. This is the information that the agents use to learn how to navigate the environment.

A lot of research goes into designing a good reward function and overcoming the problem of sparse rewards, when the often sparse nature of rewards in the environment doesn't allow the agent to learn properly from it.

Return G_t is defined as the discounted sum of rewards from timestep t.

γ is called the discount factor, and it works by reducing the amount of the rewards as we move into the future.

Discounting rewards allows us to represent uncertainty about the future, but it also helps us model human behavior better, since it has been shown that humans/animals have a preference for immediate rewards.

Value Function

The value function is probably the most important piece of information we can hold about a RL problem.

Formally, the value function is the expected return starting from state s. In practice, the value function tells us how good it is for the agent to be in a certain state. The higher the value of a state, the higher the amount of reward we can expect:

The actual name for this function is state-value function, to distinguish it from another important element in RL: the action-value function.

The action-value function gives us the value, i.e. the expected return, for using action a in a certain state s:

Policy

The policy defines the behaviour of our agent in the MDP.

Formally, policies are distributions over actions given states. A policy maps states to the probability of taking each action from that state:

The ultimate goal of RL is to find an optimal (or a good enough) policy for our agent. In the video game example, you can think of the policy as the strategy that the player follows, i.e, the actions the player takes when presented with certain scenarios.

Main approaches

A lot of different models and algorithms are being applied to RL problems.

Really, a lot.

However, all of them more or less fall into the same two categories: policy-based, and value-based.

Policy-Based Approach

In policy-based approaches to RL, our goal is to learn the best possible policy. Policy models will directly output the best possible move from the current state, or a distribution over the possible actions.

Value-Based Approach

In value-based approaches, we want to find the the optimal value function, which is the maximum value function over all policies.

We can then choose which actions to take (i.e. which policy to use) based on the values we get from the model.

Exploration vs Exploitation

The trade-off between exploration and exploitation has been widely studied in the RL literature.

Exploration refers to the act of visiting and collecting information about states in the environment that we have not yet visited, or about which we still don't have much information. The ideas is that exploring our MDP might lead us to better decisions in the future.

On the other side, exploitation consists on making the best decision given current knowledge, comfortable in the bubble of the already known.

We will see in the following example how these concepts apply to a real problem.

Many modern machines are still equipped with a legacy lever in addition to the button.Slots machines have been around for a much longer period of time than video games. A slot machine informally known as fruit machine or puggy or slots or poker machine is a casino gambling machine with three or more reels which spin when a button is pushed.Slot machines are also known as one-armed bandits because they were originally operated by one lever on the side of the machine as distinct from a button on the front pane. What is a slot machine? These slot machines are developed by top notch gaming providers like, Konami, and many more with different themes and variety. Slot machines slot machines for sale amazon.

A Multi-Armed Bandit

We will now look at a practical example of a Reinforcement Learning problem - the multi-armed bandit problem.

The multi-armed bandit is one of the most popular problems in RL:

You are faced repeatedly with a choice among k different options, or actions. After each choice you receive a numerical reward chosen from a stationary probability distribution that depends on the action you selected. Your objective is to maximize the expected total reward over some time period, for example, over 1000 action selections, or time steps.

You can think of it in analogy to a slot machine (a one-armed bandit). Each action selection is like a play of one of the slot machine’s levers, and the rewards are the payoffs for hitting the jackpot.

Solving this problem means that we can come come up with an optimal policy: a strategy that allows us to select the best possible action (the one with the highest expected return) at each time step.

Action-Value Methods

A very simple solution is based on the action value function. Remember that an action value is the mean reward when that action is selected:

We can easily estimate q using the sample average:

If we collect enough observations, our estimate gets close enough to the real function. We can then act greedily at each timestep, i.e. select the action with the highest value, to collect the highest possible rewards.

Don't be too Greedy

Remember when we talked about the trade-off between exploration and exploitation? This is one example of why we should care about it.

As a matter of fact, if we always act greedily as proposed in the previous paragraph, we never try out sub-optimal actions which might actually eventually lead to better results.

To introduce some degree of exploration in our solution, we can use an ε-greedy strategy: we select actions greedily most of the time, but every once in a while, with probability ε, we select a random action, regardless of the action values.

It turns out that this simple exploration method works very well, and it can significantly increase the rewards we get.

One final caveat - to avoid from making our solution too computationally expensive, we compute the average incrementally according to this formula:

Python Solution Walkthrough

Et voilà! If we run this script for a couple of seconds, we already see that our action values are proportional to the probability of hitting the jackpots for our bandits:

This means that our greedy policy will correctly favour actions from which we can expect higher rewards.

Conclusion

Reinforcement Learning is a growing field, and there is a lot more to cover. In fact, we still haven't looked at general-purpose algorithms and models (e.g. dynamic programming, Monte Carlo, Temporal Difference).

The most important thing right now is to get familiar with concepts such as value functions, policies, and MDPs. In the Resources section of this article, you'll find some awesome resources to gain a deeper understanding of this kind of material.

Resources

Loops are R’s method for repeating a task, which makes them a useful tool for programming simulations. This chapter will teach you how to use R’s loop tools.

Let’s use the score function to solve a real-world problem.

Your slot machine is modeled after real machines that were accused of fraud. The machines appeared to pay out 40 cents on the dollar, but the manufacturer claimed that they paid out 92 cents on the dollar. You can calculate the exact payout rate of your machine with the score program. The payout rate will be the expected value of the slot machine’s prize.

11.1 Expected Values

The expected value of a random event is a type of weighted average; it is the sum of each possible outcome of the event, weighted by the probability that each outcome occurs:

[E(x) = sum_{i = 1}^{n}left( x_{i} cdot P(x_{i}) right)]

You can think of the expected value as the average prize that you would observe if you played the slot machine an infinite number of times. Let’s use the formula to calculate some simple expected values. Then we will apply the formula to your slot machine.

Do you remember the die you created in Project 1: Weighted Dice?

Each time you roll the die, it returns a value selected at random (one through six). You can find the expected value of rolling the die with the formula:

[E(text{die}) = sum_{i = 1}^{n}left( text{die}_{i} cdot P(text{die}_{i}) right)]

The (text{die}_{i})s are the possible outcomes of rolling the die: 1, 2, 3, 4, 5, and 6; and the (P(text{die}_{i}))’s are the probabilities associated with each of the outcomes. If your die is fair, each outcome will occur with the same probability: 1/6. So our equation simplifies to:

[begin{array}{rl}E(text{die}) & = sum_{i = 1}^{n}left( text{die}_{i} cdot P(text{die}_{i}) right)& = 1 cdot frac{1}{6} + 2 cdot frac{1}{6} + 3 cdot frac{1}{6} + 4 cdot frac{1}{6} + 5 cdot frac{1}{6} + 6 cdot frac{1}{6}& = 3.5end{array}]

Hence, the expected value of rolling a fair die is 3.5. You may notice that this is also the average value of the die. The expected value will equal the average if every outcome has the same chance of occurring.

But what if each outcome has a different chance of occurring? For example, we weighted our dice in Packages and Help Pages so that each die rolled 1, 2, 3, 4, and 5 with probability 1/8 and 6 with probability 3/8. You can use the same formula to calculate the expected value in these conditions:

[begin{array}{rl} E(die) & = 1 cdot frac{1}{8} + 2 cdot frac{1}{8} + 3 cdot frac{1}{8} + 4 cdot frac{1}{8} + 5 cdot frac{1}{8} + 6 cdot frac{3}{8} & = 4.125 end{array} ]

Hence, the expected value of a loaded die does not equal the average value of its outcomes. If you rolled a loaded die an infinite number of times, the average outcome would be 4.125, which is higher than what you would expect from a fair die.

Notice that we did the same three things to calculate both of these expected values. We have:

• Listed out all of the possible outcomes
• Determined the value of each outcome (here just the value of the die)
• Calculated the probability that each outcome occurred

The expected value was then just the sum of the values in step 2 multiplied by the probabilities in step 3.

You can use these steps to calculate more sophisticated expected values. For example, you could calculate the expected value of rolling a pair of weighted dice. Let’s do this step by step.

First, list out all of the possible outcomes. A total of 36 different outcomes can appear when you roll two dice. For example, you might roll (1, 1), which notates one on the first die and one on the second die. Or, you may roll (1, 2), one on the first die and two on the second. And so on. Listing out these combinations can be tedious, but R has a function that can help.

11.2 expand.grid

The expand.grid function in R provides a quick way to write out every combination of the elements in n vectors. For example, you can list every combination of two dice. To do so, run expand.grid on two copies of die:

Java Project Github

expand.grid will return a data frame that contains every way to pair an element from the first die vector with an element from the second die vector. This will capture all 36 possible combinations of values:

You can use expand.grid with more than two vectors if you like. For example, you could list every combination of rolling three dice with expand.grid(die, die, die) and every combination of rolling four dice with expand.grid(die, die, die, die), and so on. expand.grid will always return a data frame that contains each possible combination of n elements from the n vectors. Each combination will contain exactly one element from each vector.

You can determine the value of each roll once you’ve made your list of outcomes. This will be the sum of the two dice, which you can calculate using R’s element-wise execution:

R will match up the elements in each vector before adding them together. As a result, each element of value will refer to the elements of Var1 and Var2 that appear in the same row.

Next, you must determine the probability that each combination appears. You can calculate this with a basic rule of probability:

The probability that n independent, random events all occur is equal to the product of the probabilities that each random event occurs.

Or more succinctly:

[P(A & B & C & ..) = P(A) cdot P(B) cdot P(C) cdot ..]

So the probability that we roll a (1, 1) will be equal to the probability that we roll a one on the first die, 1/8, times the probability that we roll a one on the second die, 1/8:

[begin{array}{rl}P(1 & 1) & = P(1) cdot P(1) & = frac{1}{8} cdot frac{1}{8}& = frac{1}{64}end{array}]

And the probability that we roll a (1, 2) will be:

[begin{array}{rl}P(1 & 2) & = P(1) cdot P(2) & = frac{1}{8} cdot frac{1}{8}& = frac{1}{64}end{array}]

And so on.

Let me suggest a three-step process for calculating these probabilities in R. First, we can look up the probabilities of rolling the values in Var1. We’ll do this with the lookup table that follows:

If you subset this table by rolls$Var1, you will get a vector of probabilities perfectly keyed to the values of Var1:

Second, we can look up the probabilities of rolling the values in Var2:

Third, we can calculate the probability of rolling each combination by multiplying prob1 by prob2:

It is easy to calculate the expected value now that we have each outcome, the value of each outcome, and the probability of each outcome. The expected value will be the summation of the dice values multiplied by the dice probabilities:

So the expected value of rolling two loaded dice is 8.25. If you rolled a pair of loaded dice an infinite number of times, the average sum would be 8.25. (If you are curious, the expected value of rolling a pair of fair dice is 7, which explains why 7 plays such a large role in dice games like craps.)

Now that you’ve warmed up, let’s use our method to calculate the expected value of the slot machine prize. We will follow the same steps we just took:

• We will list out every possible outcome of playing the machine. This will be a list of every combination of three slot symbols.
• We will calculate the probability of getting each combination when you play the machine.
• We will determine the prize that we would win for each combination.

When we are finished, we will have a data set that looks like this:

The expected value will then be the sum of the prizes multiplied by their probability of occuring:

[E(text{prize}) = sum_{i = 1}^{n}left( text{prize}_{i} cdot P(text{prize}_{i}) right)]

Ready to begin?

Bonus Link: Red Dog Casino Download Casino. Bonus Code Expiration: September 30, 2019. Valid to play Slots, Real-Series Video Slots, Keno, Scratch Cards and Board games. Red dog casino no deposit code bonus september 2019. Utilize Red Dog Online Casino no deposit bonus code, without risking a dime and win real money! Free signup casino chips bonus no deposit needed. Red Dog Online Casino Review. Red Dog Casino is a new online casino, launched in 2019. Red Dog Online Casino offer more than 300 online casino games, among them live casino games by Visionary iGaming. Red Dog Casino Lets You Play Longer And Better With Bonuses, Free Spins And. Bonuses Casinos Slots. Red Dog Casino Bonus Codes December 2020. All (950) No Deposit (326) Free Spins (374) First Deposit (11) Free Chip (16) Match Bonus (223) active. $30 No Deposit Bonus at Red Dog Casino.

Be sure to add the argument stringsAsFactors = FALSE to your expand.grid call; otherwise, expand.grid will save the combinations as factors, an unfortunate choice that will disrupt the score function.

Now, let’s calculate the probability of getting each combination. You can use the probabilities contained in the prob argument of get_symbols to do this. These probabilities determine how frequently each symbol is chosen when your slot machine generates symbols. They were calculated after observing 345 plays of the Manitoba video lottery terminals. Zeroes have the largest chance of being selected (0.52) and cherries the least (0.01):

Now let’s look up our probabilities.

Now how should we calculate the total probability of each combination? Our three slot symbols are all chosen independently, which means that the same rule that governed our dice probabilities governs our symbol probabilities:

[P(A & B & C & ..) = P(A) cdot P(B) cdot P(C) cdot ..]

Exercise 11.4 (Calculate Probabilities for Each Combination) Calculate the overall probabilities for each combination. Save them as a column named prob in combos, then check your work.

You can check that the math worked by summing the probabilities. The probabilities should add up to one, because one of the combinations must appear when you play the slot machine. In other words, a combination will appear, with probability of one.

You can calculate the probabilities of every possible combination in one fell swoop with some element-wise execution:

The sum of the probabilities is one, which suggests that our math is correct:

You only need to do one more thing before you can calculate the expected value: you must determine the prize for each combination in combos. You can calculate the prize with score. For example, we can calculate the prize for the first row of combos like this:

However there are 343 rows, which makes for tedious work if you plan to calculate the scores manually. It will be quicker to automate this task and have R do it for you, which you can do with a for loop.

11.3 for Loops

A for loop repeats a chunk of code many times, once for each element in a set of input. for loops provide a way to tell R, “Do this for every value of that.” In R syntax, this looks like:

The that object should be a set of objects (often a vector of numbers or character strings). The for loop will run the code in that appears between the braces once for each member of that. For example, the for loop below runs print('one run') once for each element in a vector of character strings:

The value symbol in a for loop acts like an argument in a function. The for loop will create an object named value and assign it a new value on each run of the loop. The code in your loop can access this value by calling the value object.

What values will the for loop assign to value? It will use the elements in the set that you run the loop on. for starts with the first element and then assigns a different element to value on each run of the for loop, until all of the elements have been assigned to value. For example, the for loop below will run print(value) four times and will print out one element of c('My', 'second', 'for', 'loop') each time:

On the first run, the for loop substituted 'My' for value in print(value). On the second run it substituted 'second', and so on until for had run print(value) once with every element in the set:

If you look at value after the loop runs, you will see that it still contains the value of the last element in the set:

I’ve been using the symbol value in my for loops, but there is nothing special about it. No deposit bonus usa mobile casinos. You can use any symbol you like in your loop to do the same thing as long as the symbol appears before in in the parentheses that follow for. For example, you could rewrite the previous loop with any of the following:

Choose your symbols carefully

R will run your loop in whichever environment you call it from. This is bad news if your loop uses object names that already exist in the environment. Your loop will overwrite the existing objects with the objects that it creates. This applies to the value symbol as well.

For loops run on sets

In many programming languages, for loops are designed to work with integers, not sets. You give the loop a starting value and an ending value, as well as an increment to advance the value by between loops. The for loop then runs until the loop value exceeds the ending value.

You can recreate this effect in R by having a for loop execute on a set of integers, but don’t lose track of the fact that R’s

Github Java Download

for loops execute on members of a set, not sequences of integers.

for loops are very useful in programming because they help you connect a piece of code with each element in a set. For example, we could use a for loop to run score once for each row in combos. However, R’s for loops have a shortcoming that you’ll want to know about before you start using them: for loops do not return output.

for loops are like Las Vegas: what happens in a for loop stays in a for loop. If you want to use the products of a for loop, you must write the for loop so that it saves its own output as it goes.

Our previous examples appeared to return output, but this was misleading. The examples worked because we called print, which always prints its arguments in the console (even if it is called from a function, a for loop, or anything else). Our for loops won’t return anything if you remove the print call:

To save output from a for loop, you must write the loop so that it saves its own output as it runs. You can do this by creating an empty vector or list before you run the for loop. Then use the for loop to fill up the vector or list. When the for loop is finished, you’ll be able to access the vector or list, which will now have all of your results.

Let’s see this in action. The following code creates an empty vector of length 4:

The next loop will fill it with strings:

This approach will usually require you to change the sets that you execute your for loop on. Instead of executing on a set of objects, execute on a set of integers that you can use to index both your object and your storage vector. This approach is very common in R. You’ll find in practice that you use for loops not so much to run code, but to fill up vectors and lists with the results of code.

Let’s use a for loop to calculate the prize for each row in combos. To begin, create a new column in combos to store the results of the for loop:

The code creates a new column named prize and fills it with NAs. R uses its recycling rules to populate every value of the column with NA.

After you run the for loop, combos$prize will contain the correct prize for each row. This exercise also tests the score function; score appears to work correctly for every possible slot combination:

We’re now ready to calculate the expected value of the prize. The expected value is the sum of combos$prize weighted by combos$prob. This is also the payout rate of the slot machine:

Uh oh. The expected prize is about 0.54, which means our slot machine only pays 54 cents on the dollar over the long run. Does this mean that the manufacturer of the Manitoba slot machines was lying?

No, because we ignored an important feature of the slot machine when we wrote score: a diamond is wild. You can treat a DD as any other symbol if it increases your prize, with one exception. You cannot make a DD a C unless you already have another C in your symbols (it’d be too easy if every DD automatically earned you $2).

The best thing about DDs is that their effects are cumulative. For example, consider the combination B, DD, B. Not only does the DD count as a B, which would earn a prize of $10; the DD also doubles the prize to $20.

Adding this behavior to our code is a little tougher than what we have done so far, but it involves all of the same principles. You can decide that your slot machine doesn’t use wilds and keep the code that we have. In that case, your slot machine will have a payout rate of about 54 percent. Or, you could rewrite your code to use wilds. If you do, you will find that your slot machine has a payout rate of 93 percent, one percent higher than the manufacturer’s claim. You can calculate this rate with the same method that we used in this section.

Exercise 11.6 (Challenge) There are many ways to modify score that would count DDs as wild. If you would like to test your skill as an R programmer, try to write your own version of score that correctly handles diamonds.

If you would like a more modest challenge, study the following score code. It accounts for wild diamonds in a way that I find elegant and succinct. See if you can understand each step in the code and how it achieves its result.

To update the expected value, just update combos$prize:

Then recompute the expected value:

This result vindicates the manufacturer’s claim. If anything, the slot machines seem more generous than the manufacturer stated.

11.4 while Loops

R has two companions to the for loop: the while loop and the repeat loop. A while loop reruns a chunk while a certain condition remains TRUE. To create a while loop, follow while by a condition and a chunk of code, like this:

while will rerun condition, which should be a logical test, at the start of each loop. If condition evaluates to TRUE, while will run the code between its braces. If condition evaluates to FALSE, while will finish the loop.

Why might condition change from TRUE to FALSE? Presumably because the code inside your loop has changed whether the condition is still TRUE. If the code has no relationship to the condition, a while loop will run until you stop it. So be careful. You can stop a while loop by hitting Escape or by clicking on the stop-sign icon at the top of the RStudio console pane. The icon will appear once the loop begins to run.

Like for loops, while loops do not return a result, so you must think about what you want the loop to return and save it to an object during the loop.

You can use while loops to do things that take a varying number of iterations, like calculating how long it takes to go broke playing slots (as follows). However, in practice, while loops are much less common than for loops in R:

11.5 repeat Loops

repeat loops are even more basic than while loops. They will repeat a chunk of code until you tell them to stop (by hitting Escape) or until they encounter the command break, which will stop the loop.

You can use a repeat loop to recreate plays_till_broke, my function that simulates how long it takes to lose money while playing slots:

11.6 Summary

You can repeat tasks in R with for, while, and repeat loops. To use for, give it a chunk of code to run and a set of objects to loop through. for will run the code chunk once for each object. If you wish to save the output of your loop, you can assign it to an object that exists outside of the loop.

Repetition plays an important role in data science. It is the basis for simulation, as well as for estimates of variance and probability. Loops are not the only way to create repetition in R (consider replicate for example), but they are one of the most popular ways.

Is well established as one of the leading manufacturers, dealers and operators of gambling and gaming machines i. 178: Ohio Gaming Slot Machine Sales & Service Wilmington, Ohio Used Slot Machines Sales: Ohio Gaming supplies used and refurbished slot machines to the industry and home o. 179: Ortiz Gaming Boca Raton, Florida. Casino slot machines for sale provided by casinos all over the country for home entertainment. Shoppers can now build their own personal casino providing fun and excitement for everyone. Most people don't know that they can have their own personal slot machine. Casinos release various machines so that home owners can create their own game room. That par sheet makes the odds and the house edge for a slot machine game a known quantity—for the casino. Gambling companies keep these par sheets under wraps, though, so players never really get a clear idea of what the odds, the house edge, or the payback percentage is. https://cellnin.netlify.app/who-makes-slot-machines-for-casinos.html.

Unfortunately, loops in R can sometimes be slower than loops in other languages. As a result, R’s loops get a bad rap. This reputation is not entirely deserved, but it does highlight an important issue. Speed is essential to data analysis. When your code runs fast, you can work with bigger data and do more to it before you run out of time or computational power. Speed will teach you how to write fast for loops and fast code in general with R. There, you will learn to write vectorized code, a style of lightning-fast code that takes advantage of all of R’s strengths.