Dos formas de “recorrer” un arreglo en lenguaje R

En un curso de R realizado en 2004 se propone un ejercicio (nro 3, pp. 22) en el cual se requiere dividir los primeros 100 términos de un vector con 200 elementos por el módulo de la división de su correspondiente posición entre 5. Para aquellos que están acostumbrados a programar con bucles probablemente la primera intención sería usar un for para recorrer el arreglo al efectuar el cálculo deseado. Sería algo como esto:

> v<-1:200
> v
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
 [19]  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
 [37]  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
 [55]  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
 [73]  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
 [91]  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108
[109] 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
[127] 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
[145] 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
[163] 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
[181] 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
[199] 199 200
> v2<-NULL
> for(i in 1:100) v2[i] <- v[i]/(i%%5)
> v2
  [1]  1.000000  1.000000  1.000000  1.000000       Inf  6.000000  3.500000
  [8]  2.666667  2.250000       Inf 11.000000  6.000000  4.333333  3.500000
 [15]       Inf 16.000000  8.500000  6.000000  4.750000       Inf 21.000000
 [22] 11.000000  7.666667  6.000000       Inf 26.000000 13.500000  9.333333
 [29]  7.250000       Inf 31.000000 16.000000 11.000000  8.500000       Inf
 [36] 36.000000 18.500000 12.666667  9.750000       Inf 41.000000 21.000000
 [43] 14.333333 11.000000       Inf 46.000000 23.500000 16.000000 12.250000
 [50]       Inf 51.000000 26.000000 17.666667 13.500000       Inf 56.000000
 [57] 28.500000 19.333333 14.750000       Inf 61.000000 31.000000 21.000000
 [64] 16.000000       Inf 66.000000 33.500000 22.666667 17.250000       Inf
 [71] 71.000000 36.000000 24.333333 18.500000       Inf 76.000000 38.500000
 [78] 26.000000 19.750000       Inf 81.000000 41.000000 27.666667 21.000000
 [85]       Inf 86.000000 43.500000 29.333333 22.250000       Inf 91.000000
 [92] 46.000000 31.000000 23.500000       Inf 96.000000 48.500000 32.666667
 [99] 24.750000       Inf

Por la manera como se gestiona la memoria en R y al hecho de que éste, en su sistema base, incluye librerías que soportan álgebra vectorial, a diferencia de otros lenguajes, lo más aconsejable es crear un arreglo de índices para efectuar dicho cálculo.

> v <- 1:200
> v
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
 [19]  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
 [37]  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
 [55]  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
 [73]  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
 [91]  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108
[109] 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
[127] 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
[145] 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
[163] 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
[181] 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
[199] 199 200
> i <- 1:100
> i
  [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
 [19]  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
 [37]  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
 [55]  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
 [73]  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
 [91]  91  92  93  94  95  96  97  98  99 100
> v2<- v[1:100]/(i%%5)
> v2
  [1]  1.000000  1.000000  1.000000  1.000000       Inf  6.000000  3.500000
  [8]  2.666667  2.250000       Inf 11.000000  6.000000  4.333333  3.500000
 [15]       Inf 16.000000  8.500000  6.000000  4.750000       Inf 21.000000
 [22] 11.000000  7.666667  6.000000       Inf 26.000000 13.500000  9.333333
 [29]  7.250000       Inf 31.000000 16.000000 11.000000  8.500000       Inf
 [36] 36.000000 18.500000 12.666667  9.750000       Inf 41.000000 21.000000
 [43] 14.333333 11.000000       Inf 46.000000 23.500000 16.000000 12.250000
 [50]       Inf 51.000000 26.000000 17.666667 13.500000       Inf 56.000000
 [57] 28.500000 19.333333 14.750000       Inf 61.000000 31.000000 21.000000
 [64] 16.000000       Inf 66.000000 33.500000 22.666667 17.250000       Inf
 [71] 71.000000 36.000000 24.333333 18.500000       Inf 76.000000 38.500000
 [78] 26.000000 19.750000       Inf 81.000000 41.000000 27.666667 21.000000
 [85]       Inf 86.000000 43.500000 29.333333 22.250000       Inf 91.000000
 [92] 46.000000 31.000000 23.500000       Inf 96.000000 48.500000 32.666667
 [99] 24.750000       Inf

Los resultados son idénticos pero si sustituyen, por ejemplo, 200 por 2000000 (que es del orden del número de elementos que pueden presentarse en un ráster) verán la desproporcionada diferencia en el tiempo de cómputo a favor del segundo procedimiento.

Esta entrada fue publicada en Lenguaje R, Software Libre. Guarda el enlace permanente.

Responder

Por favor, inicia sesión con uno de estos métodos para publicar tu comentario:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s