Как остановить процесс подсчета if l oop в моем коде?

Question

Я хочу остановить процесс подсчета для y после того, как он в первый раз соответствует условию y < 0 для каждого i в for loop. Это означает, что процесс подсчета для x будет продолжаться до тех пор, пока x > 0 (условие указано в while loop).

Я пытался сделать что-то, что if (y < 0 & (y - 120*(16/81)*time + (z-2)) > 0 & z > 2), это имеет смысл для меня, но результат не имеет смысла, потому что после запуска кода, count_x составляет около 100 (имеет смысл), но count_y больше, чем 1000, что не имеет смысла, так как for loop только от 1:1000.

count_x <- 0
count_y <- 0

for (i in 1:1000){
  x <- 25
  y <- 25
  t <- 0
  while ((x > 0 | y > 0) & t < 100){
    time <- rexp(1,100)
    u <- runif(1,0,1)
    z <- 4/((1-u)^0.2) - 4
    if (z < 2){
      x <- x + 110*(65/81)*time - z
    } else {
      y <- y + 120*(16/81)*time - (z-2)
      x <- x + 110*(65/81)*time - 2
    }
    t <- t + time
    if (x < 0){
      count_x <- count_x + 1
    }
    if (y < 0 & (y - 120*(16/81)*time + (z-2)) > 0 & z > 2){
      count_y <- count_y + 1
    }    
  }
}

Например, во время 1-й итерации i=1, while loop запустит и запустит код внутри l oop. Итак, что я хочу сделать, это:

Когда y в первый раз достигнет отрицательного значения в первой итерации, он обновит count_y на единицу, а затем весь if loop для процесса подсчета y перестанет делать что-либо, даже если while loop все еще продолжает работать, поскольку if loop для процесса подсчета x может еще не достичь первого отрицательного значения (условие для while loop все еще выполняется, если t по-прежнему меньше 100), поэтому while loop необходимо продолжать, не касаясь последнего внутреннего if loop, пока либо t>100 первый раз, либо x первый раз не достигнет своего отрицательного значения. Один раз условия для while loop не выполняются, тогда только go для 2-й итерации i=2.

То же самое относится к x, процесс подсчета для x перестанет делать что-либо, как только x впервые станет отрицательным значением, но while loop продолжит работать до тех пор, пока условие для while loop все еще удовлетворен.

Таким образом, будет только одно временное обновление для x или y для каждой итерации (поэтому максимум для y должен быть 1000, поскольку у нас 1000 итераций, хотя вряд ли достигнет 1000), поскольку процесс подсчета для x и y остановится, как только он достигнет первого отрицательного значения.

Я думаю добавить в нее функцию break, но не знаю, куда мне добавить.

Answer 1

Не думаю, что с кодом что-то не так. Счетчик у, по крайней мере, мне кажется, это правильно. Причина, по которой у больше, в два раза. Во-первых, даже если внешний for l oop равен только 1000, внутренний while l oop может потенциально работать более 100 на каждой итерации. Во-вторых, кажется, что y опускается ниже 0 до x, поэтому счетчик x меньше.

Я изменил ваш код, добавив в него счетчик, который подсчитывает количество итераций while и две переменные которые хранят значения x и y соответственно, когда y впервые падает ниже нуля.

count_x <- 0
count_y <- 0
while_count <- 0
store_x <- 0
store_y <- 0

a <- 1
b <- 1

for (i in 1:1000){
  x <- 25
  y <- 25
  t <- 0
  count_while <- 0
  while ((x > 0 | y > 0) & t < 100){
    time <- rexp(1,100)
    u <- runif(1,0,1)
    z <- 4/((1-u)^0.2) - 4
    if (z < 2){
      x <- x + 110*(65/81)*time - z
    } else {
      y <- y + 120*(16/81)*time - (z-2)
      x <- x + 110*(65/81)*time - 2
    }
    t <- t + time
    if (x < 0){
      count_x <- count_x + 1
    }
    if (y < 0 & (y - 120*(16/81)*time + (z-2)) > 0 & z > 2){
      count_y <- count_y + 1
      store_y[a] <- y
      store_x[a] <- x
      a <- a + 1
    }
    if (y > 0){
      count_while <- count_while + 1
    }
  }
  while_count[b] <- count_while
  b <- b + 1
}

Проверка средних значений показывает, что х почти всегда больше нуля в первый раз у идет ниже нуля. В то время как l oop составляет в среднем 163 итерации.

mean(store_x)
[1] 38.90333
mean(store_y)
[1] -2.035492
mean(while_count)
[1] 163.052
which(store_x < 0)
[1] 656

Итак, ваш счетчик мне кажется правильным, х низок просто потому, что он редко опускается ниже нуля. Фактически, запустив l oop всего за одну итерацию, установив for (i in 1:1) и запустив его несколько раз, вы обнаружите, что ваш count_x редко поднимается выше нуля, несмотря на то, что while l oop повторяется по 100 раз. С другой стороны, y опускается ниже нуля хотя бы один раз за каждую итерацию i.

Надеюсь, это поможет!

Answer 2

Мы создадим переменные для x и y, которые будут хранить и отслеживать, когда оба пересекают ноль на каждой итерации. Сначала мы проверим, равен ли x или y нулю и имеет ли neg класс NULL. Если так, то это первый минус. Мы храним x_0 или y_0 как 1. Затем при подсчете мы проверяем, равен ли x_0 или y_0 единице и равен ли neg NULL. Затем мы добавим к счетчику и запишем первый негатив. После этого условие оценивается как FALSE.

count_x <- 0
count_y <- 0
while_x <- 0
while_y <- 0

for (i in 1:1000){
  x <- 25
  y <- 25
  t <- 0
  x_0 <- 0
  y_0 <- 0
  neg <- NULL
  neg_x <- NULL
  while ((x > 0 | y > 0) & t < 100){
    time <- rexp(1,100)
    u <- runif(1,0,1)
    z <- 4/((1-u)^0.2) - 4
    if (z < 2){
      x <- x + 110*(65/81)*time - z
      if (x < 0 & is.null(neg_x)){
        x_0 <- 1
      }
    } else {
      y <- y + 120*(16/81)*time - (z-2)
      x <- x + 110*(65/81)*time - 2
      if (x < 0 & is.null(neg_x)){
        x_0 <- 1
      }
      if (y < 0 & is.null(neg)) {
        y_0 <- 1
      }
    }
    t <- t + time

    if (x_0 == 1 & is.null(neg_x)){
      count_x <- count_x + 1
      neg_x <- "First Negative"
      x_0 <- x_0 + 1
    }
    if (y_0 == 1 & is.null(neg)){
      count_y <- count_y + 1
      neg <- "first negative"
      y_0 <- y_0 + 1
    }
  }
}

Вы также можете разместить счетчик за пределами l oop. Если x или y меньше 0, добавьте к счетчику. Это, вероятно, лучшее решение. Условие будет оцениваться независимо от , когда x или y пересечется ниже нуля, при условии, что оно опустилось ниже нуля, оно будет оценено как TRUE

count_x <- 0
count_y <- 0

for (i in 1:1000){
  x <- 25
  y <- 25
  t <- 0
  while ((x > 0 | y > 0) & t < 100){
    time <- rexp(1,100)
    u <- runif(1,0,1)
    z <- 4/((1-u)^0.2) - 4
    if (z < 2){
      x <- x + 110*(65/81)*time - z
    } else {
      y <- y + 120*(16/81)*time - (z-2)
      x <- x + 110*(65/81)*time - 2
    }
    t <- t + time
  }
  if(x < 0) {
    count_x <- count_x + 1
  }
  if(y < 0){
    count_y <- count_y + 1
  }
}

Для меня count_y выходит на 1000 в обоих случаях. Это подтверждает то, что я сказал ранее, y уходит ниже нуля на каждой итерации while.