April 18, 2018

About homework

Struggling is good

Solutions may not be immediate

It can take time to figure out

Keep trying

Homework step 0

“As we discussed in class, the initial condition is not very important, since the long time behavior is an attractor. The result will be the same as long as x_ini is strictly between 0 and 1. For this exercise you can use x_ini=0.5.”

Just remember that

Step 1

“Your first mission is to build a vector a_values with numbers from 2.9 to 4 incrementing by 0.001.”

a_values <- seq(from=2.9, to=4, by=0.001)

Step 2

Then you have to draw an “empty” plot with horizontal axis from 2.9 to 4, and vertical axis from 0 to 1. You can plot anything or use the xlim= and ylim= options, but make sure that the plot area is clean. For example you can use the option type="n".

plot(0, xlim=c(2.9, 4), ylim=c(0, 1), type="n")

It can also be

plot(x=c(2.9, 4), y=c(0, 1), type="n")

Step 3

Now, for each value of a_values you have to simulate quad_map() for 1500 steps. The first 1000 steps are transient. You have to draw the last 500 steps in the same plot. Since there are many points, use pch=".".

Some people tried this

y <- quad_map(N=1500, x_ini=0.5, A=a_values)
Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length

Warning in x[i] <- A * x[i - 1] * (1 - x[i - 1]):
number of items to replace is not a multiple of
replacement length
plot(x=a_values, y)
Error in xy.coords(x, y, xlabel, ylabel, log): 'x' and 'y' lengths differ

Not all functions accept vector inputs

In R many functions accepts vectors instead of numbers. For example

sqrt(2:6)
[1] 1.414214 1.732051 2.000000 2.236068 2.449490

But this is not always true. In our case

x[i] <- A * x[i-1] * (1 - x[i-1])

We see that x[i] is a single number (why?) thus A has to be a single number too

Another try, using for()

plot(x=c(2.9, 4), y=c(0, 1), type="n")

for(i in 1:length(a_values)) {
    y <- quad_map(N=1500,
        x_ini=a_values[i], A=2.9)
    points(x=a_values[i], y=y[1001:1500],
        pch=".")
}
Error in xy.coords(x, y): 'x' and 'y' lengths differ

Now things got interesting

Error: x and y must be the same size

The vector y[1001:1500] has 500 elements. We can check with this

length(y[1001:1500])
[1] 500

It is easy to see that a_values[i] is a single number, because of []

length(a_values[i])
[1] 1

Making x and y the same size

In this plot we want to see all the last 500 values of y in the same column

So we need to repeat a_values[i] 500 times, like

points(x=rep(a_values[i], 500), y=y[1001:1500])

Drawing again

plot(x=c(2.9, 4), y=c(0, 1), type="n")
for(i in 1:length(a_values)) {
    y <- quad_map(N=1500,
        x_ini=a_values[i], A=2.9)
    points(x=rep(a_values[i], 500),
        y=y[1001:1500], pch=".")
}

Why the plot is empty?

Remember that x_ini=0.5 constant. We have to use different values for A, not for x_init

The system’s behavior depends only on initial conditions and rate constants

Here we change only rate

Finally

plot(x=c(2.9, 4), y=c(0, 1), type="n")
for(i in 1:length(a_values)) {
    y <- quad_map(N=1500, x_ini=0.5, A=a_values[i])
    points(x=rep(a_values[i], 500), y=y[1001:1500],
        pch=".")
}

We do not need to save each result

There are some answers like this

ans <- data.frame(V1=quad_map(N=1500, x_ini=0.5, A=2.9))
for(i in 2:length(a_values)) {
  ans[[i]] <- quad_map(N=1500, x_ini=0.5, A=a_values[i])
}
for(i in 1:length(a_values)) {
  points(x=rep(a_values[i],500), y=ans[1001:1500,i])
}

But we do not use ans again. We do not need to use it

We can also avoid i

In this case we can use the for() loop directly on a_values

plot(x=c(2.9, 4), y=c(0, 1), type="n")
for(a in a_values) {
    y <- quad_map(N=1500, x_ini=0.5, A=a)
    points(x=rep(a,500), y=y[1001:1500], pch=".")
}

Remember that for(i in 1:10) loops over the vector 1:10

We can use any vector instead

We need to practice more

Friday: Quiz

End of first part

Probabilities

In summary

  • All (infinite) experiment results are a population
  • Probabilities describe our knowledge of the population
  • Experiments produce Samples
  • Samples give us Empirical Frequencies
  • Empirical Frequencies are close to Probabilities
  • We can use the computer to get Empirical Frequencies

Real v/s Estimated probabilities

This can be something confusing

  • Real probabilities are usually unknown
  • We can make educated guesses of them
  • For example we can do real experiments
  • In the computer we only simulate experiments

Simulated experiments are not real

To simulate experiments in the computer, we have to choose “real” probabilities

But we don’t know the real real probabilities

Why we do this on the computer?

Simulations tell us what can happen

In the computer we have to make an hypothesis about the probabilities

Then we can see the consequences of this hypothesis

If the simulated results do not match reality, then we know that the hypothesis is wrong

Different probabilities for each outcome

We saw the case of two dice. What is the sum 🎲 +🎲 ?

dice <- function() {
    return(
        sample.int(6,
            size=1, 
            replace=TRUE
        )
    )
}
freq <- table(replicate(1000, dice() + dice()))/2000

Another way

result <- data.frame(d1=replicate(1000, dice()),
                     d2=replicate(1000, dice()))
result$sum <- result$d1 + result$d2
freq <- table(result$sum)/nrow(result)
freq*100 # Show as a percentage
   2    3    4    5    6    7    8    9   10   11   12 
 3.6  5.8  6.2 10.8 14.7 15.5 14.7 10.8  8.0  6.8  3.1

In this case some outcomes have bigger proportions

Another way

We can use sample(..., size=1000, replace=TRUE) instead of replicate

dice <- function(size=1) {
    return(sample.int(6, size, replace=TRUE))
}
result <- data.frame(d1=dice(1000), d2=dice(1000))
result$sum <- result$d1 + result$d2
freq1 <- table(result$sum)/nrow(result)

Let’s compare both outputs

Both simulations give similar results

Probability distribution: how many of each?

We do not know the complete population

We do not know what will be the next result

We do know that outcomes may have different proportions

The proportion of each outcome is a vector

We want to know the distribution for the sum of two dice

How we know “two dice” probabilities?

There are two ways of doing this

  1. We simulate a lot of times and we average the empirical probabilities

  2. We use mathematics

In both cases the result is c(0,1,2,3,4,5,6,5,4,3,2,1)/36

We can simulate with proportions

Instead of simulating two dice, we can tell to sample what are the proportions we want

sum_two_dice <- function() {
    return(sample.int(12,
        size=1, 
        replace=TRUE,
        prob=c(0,1,2,3,4,5,6,5,4,3,2,1)/36
    ))
}
freq2 <- table(replicate(1000, sum_two_dice()))/1000

The result is similar to dice()+dice()

freq2*100 # show as percentage
   2    3    4    5    6    7    8    9   10   11   12 
 3.3  5.4  7.3 11.0 14.6 17.2 13.4 11.5  8.2  5.3  2.8 
barplot(freq2)

We can use this for DNA

We know that GC content is different on each organisms

If GC content is 60% then G and C got 30% each

If we simulate the DNA of this organism we have to use

prob=c(a=0.2, c=0.3, g=0.3, t=0.2)

Application

How many persons with epilepsy in our course?

What is the distribution of number of epilepsy

Worldwide proportion is 1%. And world is a population

Thus, probability for one person is c(Yes=0.01, No=0.99)

epilepsy <- function(size) {
    return(
        sample(c("Yes","No"), 
            size=size, 
            replace = TRUE,
            prob = c(0.01, 0.99)
        )
    )
}

We are 97 people in the course, including me

This can be us

epilepsy(97)
 [1] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
 [9] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[17] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[25] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[33] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[41] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[49] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[57] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[65] "No"  "No"  "No"  "No"  "Yes" "No"  "No"  "No" 
[73] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[81] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[89] "No"  "No"  "No"  "No"  "No"  "No"  "No"  "No" 
[97] "No"

We get a single course

Let’s sample 1000 groups of size 97

courses <- replicate(1000, epilepsy(97))
dim(courses)
[1]   97 1000

Here courses is a matrix, not a data frame

We have to use [row, col], not [[column]]

We want numbers, not words

We got a lot of data, but very little information

We did not learn anything from the 97000 words

Fortunately, we did “Computing in Molecular Biology 1” and we know how to extract information from the raw data

How many epilepsies on each course?

we need a function that

  • takes one column of courses, and
  • gives us an integer with the number of “yes”

How do we do that?

This is the result

   [1] 1 0 0 0 1 1 0 2 1 1 0 0 1 1 1 1 3 1 2 0 2 1 2 1 0 1 0 0 1 3 2 2 0 0 1 1 0 1 0 1 0 1
  [43] 0 5 3 1 3 0 3 0 0 3 0 0 2 0 1 0 3 0 1 1 0 0 0 1 0 1 0 1 0 0 0 1 3 1 1 2 1 2 0 1 1 1
  [85] 3 0 0 0 2 2 1 0 0 1 0 1 1 1 1 1 0 0 1 1 0 0 2 1 0 0 3 0 0 2 1 1 0 0 2 1 3 0 1 3 0 0
 [127] 3 1 0 2 2 2 1 2 0 0 2 0 0 0 2 2 0 4 1 3 1 2 1 1 3 0 1 1 0 1 2 0 0 2 2 1 2 0 2 0 1 0
 [169] 0 1 1 1 1 0 1 2 2 0 1 1 0 2 2 0 1 1 4 0 0 1 1 1 1 3 1 0 2 0 0 1 1 0 0 0 1 3 2 0 0 1
 [211] 0 1 1 0 1 2 0 3 0 0 0 2 1 2 0 2 0 1 3 0 0 1 2 3 0 2 0 0 1 1 1 0 2 0 0 0 0 1 1 1 2 0
 [253] 0 3 2 1 1 0 2 2 3 2 2 2 5 1 1 1 0 1 2 2 1 0 1 1 3 1 0 2 1 2 1 1 1 1 1 2 3 0 2 2 0 0
 [295] 1 0 1 2 1 3 0 1 0 1 2 0 1 1 0 0 1 2 1 0 2 0 1 0 0 3 3 0 4 0 0 1 1 2 0 0 0 0 1 1 1 2
 [337] 0 1 1 2 0 0 0 0 0 0 0 2 1 0 2 0 1 0 0 1 2 0 0 1 2 1 1 1 1 0 1 0 0 2 0 1 1 1 0 1 0 2
 [379] 1 3 1 1 1 0 0 1 3 0 1 1 0 1 1 1 0 1 0 0 0 0 1 0 0 0 0 0 2 0 0 3 0 0 2 0 1 1 0 2 0 0
 [421] 2 0 0 2 1 1 0 1 2 1 2 2 1 0 0 0 1 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 0 3 0 3 0 2 1 1 2 2
 [463] 0 1 1 0 1 1 1 0 0 0 3 1 1 3 3 1 1 3 0 0 1 1 1 0 1 0 0 1 0 1 1 1 0 2 1 0 1 0 2 2 0 3
 [505] 1 3 2 2 1 1 4 1 1 1 5 0 1 1 1 0 3 1 1 2 1 0 0 0 0 2 0 0 1 0 1 0 1 1 0 0 1 0 2 1 0 1
 [547] 1 2 1 1 1 1 1 1 1 0 0 1 0 0 1 0 1 1 0 0 2 2 1 1 0 1 1 0 2 2 2 1 0 0 1 1 2 1 0 1 1 0
 [589] 2 1 1 1 1 1 2 2 1 0 1 1 2 1 0 2 1 2 1 0 1 0 0 0 0 1 1 0 4 3 0 2 1 0 1 0 0 3 0 0 0 2
 [631] 0 0 0 4 1 2 1 1 0 0 0 0 0 0 1 0 1 1 2 2 2 0 0 0 1 1 1 1 2 1 0 2 0 3 0 1 0 0 1 0 1 1
 [673] 1 0 1 1 0 1 1 0 0 1 4 2 3 1 2 1 0 0 0 1 2 1 0 0 1 2 1 1 0 0 2 0 0 0 0 2 2 0 1 0 0 2
 [715] 2 2 0 2 0 1 1 0 2 1 0 2 3 1 0 2 2 2 0 1 0 1 1 1 1 0 1 2 1 2 3 1 1 1 2 0 1 1 1 1 1 0
 [757] 0 0 2 1 1 1 1 2 2 1 1 2 0 1 2 0 2 2 1 1 0 2 0 0 1 0 0 0 2 2 1 2 0 0 0 2 0 2 0 2 1 2
 [799] 1 0 1 0 1 1 0 0 3 1 1 3 1 1 0 0 1 2 1 1 1 2 1 2 0 0 0 0 0 0 3 2 1 1 0 1 0 1 1 0 0 2
 [841] 1 0 1 1 1 3 2 0 0 1 2 2 1 1 0 2 1 2 0 0 1 1 0 1 0 1 0 3 0 1 1 0 2 1 0 3 2 2 0 2 0 0
 [883] 0 1 0 1 1 1 0 0 2 0 0 2 0 1 1 0 0 0 1 0 0 1 2 0 1 2 2 0 0 0 0 0 0 2 1 2 0 0 0 1 0 1
 [925] 1 1 1 1 0 0 0 0 0 1 0 2 1 3 2 2 0 0 2 0 1 1 2 1 5 1 0 0 3 0 0 2 1 2 0 1 2 1 2 2 1 1
 [967] 0 0 2 1 0 1 1 1 1 2 0 1 0 0 1 1 1 2 1 0 0 1 1 2 0 2 0 1 1 1 2 0 2 0

Still too much “noise”

Let’s make a table

cases
  0   1   2   3   4   5 
380 377 179  53   7   4

What are your results?

Results will be a bit different

Each simulation is a random sample

So each time we get some different

How much different can results be?

If they change every time, are they useful?

That is something for another class