For-Schleife vs While-Schleife in R

Habe ich bemerkt, eine seltsame Sache, die während Ihrer Arbeit in R.
Wenn ich ein einfaches Programm, das berechnet die Quadrate von 1 bis N, implementiert unter Verwendung von for-Schleife und while-Schleife, das Verhalten ist nicht das gleiche. (I don ' T care über Vektorisierung in diesem Fall oder anwenden von Funktionen).

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

UND

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

Sind die Ergebnisse:

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

Nun wissen wir, dass die for-Schleife ist schneller, meine Vermutung ist, da der pre-Allokation und Optimierungen gibt. Aber warum ist es überlaufen?

UPDATE: So, jetzt versuchen einen anderen Weg mit Vektoren:

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

So Vielleicht seine eine funky Speicher-Problem? Ich bin unter OS X mit 4Gb Speicher und alle Standard-Einstellungen in R. Dies geschieht in 32 - und 64-bit-Versionen (außer, die Zeiten sind schneller).

Alex

InformationsquelleAutor der Frage Alex | 2010-11-17

  1. 36

    Weil 1 ist numerisch, aber nicht ganzzahlig, d.h. es ist eine floating-point-Zahl), und 1:6000 ist numeric und integer.

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

    60000 Quadrat 3,6 Milliarden, die NICHT Darstellbare vorzeichenbehaftete 32-bit-Ganzzahl, daher bekommen Sie einen überlauf-Fehler:

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

    3,6 Milliarden ist leicht darstellbar, in floating point, aber:

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

    Reparieren Ihre for - code, konvertieren, um eine floating-point-Darstellung:

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

    InformationsquelleAutor der Antwort Alex Brown

  2. 4

    Die variable in der for-Schleife eine integer-Sequenz, und so schließlich Sie dies tun:

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

    in der Erwägung, dass in der while-Schleife erstellen Sie eine floating-point-Zahl.

    Ist auch der Grund, warum diese Dinge sind anders:

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

    Mir nicht glauben?

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

    weil:

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

    InformationsquelleAutor der Antwort Spacedman

  3. 3

    Und über das timing:

    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

    Und jetzt wissen wir, dass die for-Schleife ist schneller als die while-Schleife. Sie können nicht ignorieren Warnungen, die während des timing.

    InformationsquelleAutor der Antwort Marek

Schreibe einen Kommentar