Vòng lặp for-loop vs while trong R

Question

Tôi đã nhận thấy một điều kỳ lạ khi làm việc trong R. Khi tôi có một chương trình đơn giản tính toán các ô từ 1 đến N được thực hiện bằng cách sử dụng vòng lặp và lặp lại hành vi không phải là tương tự. (Tôi không quan tâm đến vectorisation trong trường hợp này hoặc áp dụng các chức năng).

fn1 <- function (N) 
{ 
    for(i in 1:N) { 
     y <- i*i 
    } 
} 

VÀ

fn2 <- function (N) 
{ 
    i=1 
    while(i <= N) { 
     y <- i*i 
     i <- i + 1 
    } 
} 

Kết quả là:

system.time(fn1(60000)) 
    user system elapsed 
    2.500 0.012 2.493 
There were 50 or more warnings (use warnings() to see the first 50) 
Warning messages: 
1: In i * i : NAs produced by integer overflow 
. 
. 
. 

system.time(fn2(60000)) 
    user system elapsed 
    0.138 0.000 0.137 

Bây giờ chúng ta biết rằng cho vòng lặp là nhanh hơn, tôi đoán là do phân bổ trước và optimisations đó. Nhưng tại sao nó tràn?

UPDATE: Bây giờ cố gắng một cách khác với vectơ:

fn3 <- function (N) 
{ 
    i <- 1:N 
    y <- i*i 
} 
system.time(fn3(60000)) 
    user system elapsed 
    0.008 0.000 0.009 
Warning message: 
In i * i : NAs produced by integer overflow 

Vì vậy, Có lẽ một vấn đề bộ nhớ sôi nổi của nó? Tôi đang chạy trên OS X với 4Gb bộ nhớ và tất cả các thiết lập mặc định trong R. Điều này xảy ra trong phiên bản 32 và 64 bit (ngoại trừ thời gian đó nhanh hơn).

Alex

Answer 1

Vì 1 là số, nhưng không phải là số nguyên (ví dụ đó là một số dấu chấm động), và 1:6000 là số và số nguyên.

> print(class(1)) 
[1] "numeric" 
> print(class(1:60000)) 
[1] "integer" 

60000 bình là 3,6 tỷ đồng, mà không phải là biểu diễn trong ký 32-bit số nguyên, do đó bạn nhận được một lỗi tràn bộ nhớ:

> as.integer(60000)*as.integer(60000) 
[1] NA 
Warning message: 
In as.integer(60000) * as.integer(60000) : NAs produced by integer overflow 

3,6 tỷ đồng là dễ dàng biểu diễn trong dấu chấm động, tuy nhiên:

> as.single(60000)*as.single(60000) 
[1] 3.6e+09 

để sửa mã for của bạn, chuyển đổi sang một đại diện dấu chấm động:

function (N) 
{ 
    for(i in as.single(1:N)) { 
     y <- i*i 
    } 
} 

Answer 2

Biến trong vòng lặp for là một chuỗi số nguyên, và vì vậy cuối cùng bạn làm điều này:

> y=as.integer(60000)*as.integer(60000) 
Warning message: 
In as.integer(60000) * as.integer(60000) : NAs produced by integer overflow 

trong khi trong vòng lặp trong khi bạn đang tạo ra một số dấu chấm động.

của nó cũng là lý do những điều này là khác nhau:

> seq(0,2,1) 
[1] 0 1 2 
> seq(0,2) 
[1] 0 1 2 

Đừng tin tôi?

> identical(seq(0,2),seq(0,2,1)) 
[1] FALSE 

vì:

> is.integer(seq(0,2)) 
[1] TRUE 
> is.integer(seq(0,2,1)) 
[1] FALSE 

Answer 3

Và khoảng thời gian:

fn1 <- function (N) { 
    for(i in as.numeric(1:N)) { y <- i*i } 
} 
fn2 <- function (N) { 
    i=1 
    while (i <= N) { 
     y <- i*i 
     i <- i + 1 
    } 
} 

system.time(fn1(60000)) 
# user system elapsed 
# 0.06 0.00 0.07 
system.time(fn2(60000)) 
# user system elapsed 
# 0.12 0.00 0.13 

Và bây giờ chúng ta biết rằng cho vòng lặp là nhanh hơn so với vòng lặp while. Bạn không thể bỏ qua cảnh báo trong thời gian.