R help es - Feb 2013 - Almacenamiento de información (matriz en matriz) e iteradores

Saludos, me encuentro realizando una simulación de una red de transporte
(paradas, líneas de frecuencia, usuarios, etc), para lo cual necesito el
almacenamiento de información de forma matricial.

El sistema cuenta con un numero determinado de paradas (38 paradas), en
donde cada parada representa una matriz la cual tiene asociada la llegada
de pasajeros, el tiempo en el cual llegaron, el déstino y otros atributos
más, mi pregunta es que si existe alguna paquete o forma de almacenar esta
información a manera de una "super matriz", donde cada componente de
una
matriz simple representa una nueva matriz, algo similar a lo que en física
se denomina tensor.

Mi otra pregunta radica en como asignar valores mediante iteración a las
componentes de una matriz de acuerdo al cumplimiento de ciertas
condiciones, tengo el siguiente código

for (i in 5:23)   # creación de 19 matrices nulas con subindices 5 6 7...23
{
  mat.i<-paste("mat",i,sep="")
  assign(mat.i,matrix(0,32,32))
  data.matrix(mat.i)
}

# Mediante
for (i in 1:32){  # iterador para realizar operaciones sobre cada fila de
la matriz deseada
  isup.i<-paste("isup",i,sep="")
  if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) | (sum(m_sup7[i,])==0)){
  # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas filas
tienen componentes nulas (cero)
    mat5[i,]=0
    mat6[i,]=0
    mat7[i,]=0}
  else {

mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))

mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))

mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
   }}

El anterior codigo funciona con condiciones de hasta 3 matrices 5, 6 y 7 a
partir de 8 me arroja un error. Como podría reemplazar este código mediante
otro iterador que me reconozca el subíndice de la matriz que estoy
trabajando y adicionalmente me realice la operación deseada sobre cada
componente de la fila de la matriz trabajada en ese momento.

Necesito un código similar a:

for (j in 5:23){
for (i in 1:32){
isup.i<-paste("isup",i,sep="")
if ((sum(m_supj[i,]==0)) # utilizando el subíndice "j" que reemplace a
las
matrices de 5 a 23
else
{
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
}
}}

Los errores que me arroja son de tipo que no existe relación al objeto que
se quiere almacenar, incoherencia en las dimensiones, la función assign()
no asigna valores adecuados,etc, lo he intendado todo lo que se me a
ocurrido sin ningun resultado favorable, algun comentario o ayuda??

Muchas gracias por su respuesta

	[[alternative HTML version deleted]]

Estimado Alejandro,

La primera parte puedes solucionarla usando listas:

# matrices nulas
matrices <- lapply(1:19, function(x) matrix(0, 32, 32))
names(matrices) <- paste0(''mat'', 1:19)
matrices

Para obtener la informacion de la 5a matriz, solo debes hacer

matrices[[5]]

Podrias por favor explicarnos un poco mas lo que intentas hacer en la 2a
parte de tu codigo y que comienza con "# Mediante"?

Saludos,
Jorge.-

2013/2/20 Alejandro Ayala <>
> Saludos, me encuentro realizando una simulación de una red de transporte
> (paradas, líneas de frecuencia, usuarios, etc), para lo cual necesito el
> almacenamiento de información de forma matricial.
>
> El sistema cuenta con un numero determinado de paradas (38 paradas), en
> donde cada parada representa una matriz la cual tiene asociada la llegada
> de pasajeros, el tiempo en el cual llegaron, el déstino y otros atributos
> más, mi pregunta es que si existe alguna paquete o forma de almacenar esta
> información a manera de una "super matriz", donde cada componente
de una
> matriz simple representa una nueva matriz, algo similar a lo que en física
> se denomina tensor.
>
> Mi otra pregunta radica en como asignar valores mediante iteración a las
> componentes de una matriz de acuerdo al cumplimiento de ciertas
> condiciones, tengo el siguiente código
>
> for (i in 5:23)   # creación de 19 matrices nulas con subindices 5 6 7...23
> {
>   mat.i<-paste("mat",i,sep="")
>   assign(mat.i,matrix(0,32,32))
>   data.matrix(mat.i)
> }
>
> # Mediante
> for (i in 1:32){  # iterador para realizar operaciones sobre cada fila de
> la matriz deseada
>   isup.i<-paste("isup",i,sep="")
>   if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) | (sum(m_sup7[i,])==0)){
>   # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas filas
> tienen componentes nulas (cero)
>     mat5[i,]=0
>     mat6[i,]=0
>     mat7[i,]=0}
>   else {
>
>
>
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))
>
>
>
mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))
>
>
>
mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
>    }}
>
> El anterior codigo funciona con condiciones de hasta 3 matrices 5, 6 y 7 a
> partir de 8 me arroja un error. Como podría reemplazar este código mediante
> otro iterador que me reconozca el subíndice de la matriz que estoy
> trabajando y adicionalmente me realice la operación deseada sobre cada
> componente de la fila de la matriz trabajada en ese momento.
>
> Necesito un código similar a:
>
> for (j in 5:23){
> for (i in 1:32){
> isup.i<-paste("isup",i,sep="")
> if ((sum(m_supj[i,]==0)) # utilizando el subíndice "j" que
reemplace a las
> matrices de 5 a 23
> else
> {
>
>
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
> }
> }}
>
> Los errores que me arroja son de tipo que no existe relación al objeto que
> se quiere almacenar, incoherencia en las dimensiones, la función assign()
> no asigna valores adecuados,etc, lo he intendado todo lo que se me a
> ocurrido sin ningun resultado favorable, algun comentario o ayuda??
>
> Muchas gracias por su respuesta
>
>         [[alternative HTML version deleted]]
>
>
> _______________________________________________
> R-help-es mailing list
> R-help-es@r-project.org
> https://stat.ethz.ch/mailman/listinfo/r-help-es
>
>
	[[alternative HTML version deleted]]

El 20 de febrero de 2013 07:08, Jorge I Velez
<jorgeivanvelez@gmail.com>escribió:
> Estimado Alejandro,
>
> La primera parte puedes solucionarla usando listas:
>
> # matrices nulas
> matrices <- lapply(1:19, function(x) matrix(0, 32, 32))
> names(matrices) <- paste0(''mat'', 1:19)
> matrices
>
> Para obtener la informacion de la 5a matriz, solo debes hacer
>
> matrices[[5]]
>
> Podrias por favor explicarnos un poco mas lo que intentas hacer en la 2a
> parte de tu codigo y que comienza con "# Mediante"?
>
> Saludos,
> Jorge.-
>
> 2013/2/20 Alejandro Ayala <>
>
>> Saludos, me encuentro realizando una simulación de una red de
transporte
>> (paradas, líneas de frecuencia, usuarios, etc), para lo cual necesito
el
>> almacenamiento de información de forma matricial.
>>
>> El sistema cuenta con un numero determinado de paradas (38 paradas), en
>> donde cada parada representa una matriz la cual tiene asociada la
llegada
>> de pasajeros, el tiempo en el cual llegaron, el déstino y otros
atributos
>> más, mi pregunta es que si existe alguna paquete o forma de almacenar
esta
>> información a manera de una "super matriz", donde cada
componente de una
>> matriz simple representa una nueva matriz, algo similar a lo que en
física
>> se denomina tensor.
>>
>> Mi otra pregunta radica en como asignar valores mediante iteración a
las
>> componentes de una matriz de acuerdo al cumplimiento de ciertas
>> condiciones, tengo el siguiente código
>>
>> for (i in 5:23)   # creación de 19 matrices nulas con subindices 5 6
>> 7...23
>> {
>>   mat.i<-paste("mat",i,sep="")
>>   assign(mat.i,matrix(0,32,32))
>>   data.matrix(mat.i)
>> }
>>
>> # Mediante
>> for (i in 1:32){  # iterador para realizar operaciones sobre cada fila
de
>> la matriz deseada
>>   isup.i<-paste("isup",i,sep="")
>>   if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) |
(sum(m_sup7[i,])==0)){
>>   # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas
filas
>> tienen componentes nulas (cero)
>>     mat5[i,]=0
>>     mat6[i,]=0
>>     mat7[i,]=0}
>>   else {
>>
>>
>>
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))
>>
>>
>>
mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))
>>
>>
>>
mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
>>    }}
>>
>> El anterior codigo funciona con condiciones de hasta 3 matrices 5, 6 y
7 a
>> partir de 8 me arroja un error. Como podría reemplazar este código
>> mediante
>> otro iterador que me reconozca el subíndice de la matriz que estoy
>> trabajando y adicionalmente me realice la operación deseada sobre cada
>> componente de la fila de la matriz trabajada en ese momento.
>>
>> Necesito un código similar a:
>>
>> for (j in 5:23){
>> for (i in 1:32){
>> isup.i<-paste("isup",i,sep="")
>> if ((sum(m_supj[i,]==0)) # utilizando el subíndice "j" que
reemplace a las
>> matrices de 5 a 23
>> else
>> {
>>
>>
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
>> }
>> }}
>>
>> Los errores que me arroja son de tipo que no existe relación al objeto
que
>> se quiere almacenar, incoherencia en las dimensiones, la función
assign()
>> no asigna valores adecuados,etc, lo he intendado todo lo que se me a
>> ocurrido sin ningun resultado favorable, algun comentario o ayuda??
>>
>> Muchas gracias por su respuesta
>>
>>         [[alternative HTML version deleted]]
>>
>>
>> _______________________________________________
>> R-help-es mailing list
>> R-help-es@r-project.org
>> https://stat.ethz.ch/mailman/listinfo/r-help-es
>>
>>
> Estimado Jorge, tengo un total de 19 matrices cuadradas (32x32)
Lo que necesito es que para cada fila de cada matriz se realice una
operación (cabe indicar que algunas filas de la matriz posee valores en
cero y la operación ha realizar es la division de cada componente de la
fila para la suma total de los valores de la fila) de ahí que se coloque la
instrucción if else ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) |
(sum(m_sup7[i,])==0)) en vista que no existe division para cero.

La pregunta que planteo es: Existe la posibilidad de sustituir mediante
loops "for anidados" las operaciones sobre cada fila de cada matriz,
es
decir se reemplace:

for (i in 1:32){  # iterador para realizar operaciones sobre cada fila de
la matriz que se encuentra trabajando en ese instante.
  isup.i<-paste("isup",i,sep="")

if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) | (sum(m_sup7[i,])==0)){
  # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas filas
tienen componentes nulas (cero)

    mat5[i,]=0 # matrices nulas creadas anteriormente donde se van a
almacenar los nuevos valores de la operación
    mat6[i,]=0
    mat7[i,]=0
}

else {
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))

mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))

mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
   }}

Se reemplace por un codigo similar a:

for (j in 1:19){ # iterador de las matrices existentes
for (i in 1:32){ # iterador de las filas de las matrices (j=1,2,...,19)
isup.i<-paste("isup",i,sep="")
if ((sum(m_supj[i,]==0)) # reemplazo de los valores 1,2,...,19 por el
subíndice "j" (m_sup1[i,] a m_supj[i,])
else
{
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
}
}}

Despues de todo esto ya con las nuevas matrices generadas con la operación
(división) necesito almacenar en forma de una matriz o vector
"gigante"
donde cada componente haga referencia a una de las 19 matrices.

Alguna idea al respecto grácias y saludos.

	[[alternative HTML version deleted]]

Hola, ¿qué tal?

Creo que te bastaría con una tabla (un dataframe estándar) para
almacenar tu información. No necesitas llenar tu espacio de trabajo de
objetos inconexos (matrices independientes).

Luego, las funciones ddply y similares del paquete plyr te servirían
para procesar la información por, p.e., parada de manera muy limpia.

Un saludo,

Carlos J. Gil Bellosta
http://www.datanalytics.com


El día 20 de febrero de 2013 05:20, Alejandro Ayala
<alejo.ayalab en gmail.com> escribió:
> Saludos, me encuentro realizando una simulación de una red de transporte
> (paradas, líneas de frecuencia, usuarios, etc), para lo cual necesito el
> almacenamiento de información de forma matricial.
>
> El sistema cuenta con un numero determinado de paradas (38 paradas), en
> donde cada parada representa una matriz la cual tiene asociada la llegada
> de pasajeros, el tiempo en el cual llegaron, el déstino y otros atributos
> más, mi pregunta es que si existe alguna paquete o forma de almacenar esta
> información a manera de una "super matriz", donde cada componente
de una
> matriz simple representa una nueva matriz, algo similar a lo que en física
> se denomina tensor.
>
> Mi otra pregunta radica en como asignar valores mediante iteración a las
> componentes de una matriz de acuerdo al cumplimiento de ciertas
> condiciones, tengo el siguiente código
>
> for (i in 5:23)   # creación de 19 matrices nulas con subindices 5 6 7...23
> {
>   mat.i<-paste("mat",i,sep="")
>   assign(mat.i,matrix(0,32,32))
>   data.matrix(mat.i)
> }
>
> # Mediante
> for (i in 1:32){  # iterador para realizar operaciones sobre cada fila de
> la matriz deseada
>   isup.i<-paste("isup",i,sep="")
>   if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) | (sum(m_sup7[i,])==0)){
>   # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas filas
> tienen componentes nulas (cero)
>     mat5[i,]=0
>     mat6[i,]=0
>     mat7[i,]=0}
>   else {
>
>
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))
>
>
mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))
>
>
mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
>    }}
>
> El anterior codigo funciona con condiciones de hasta 3 matrices 5, 6 y 7 a
> partir de 8 me arroja un error. Como podría reemplazar este código mediante
> otro iterador que me reconozca el subíndice de la matriz que estoy
> trabajando y adicionalmente me realice la operación deseada sobre cada
> componente de la fila de la matriz trabajada en ese momento.
>
> Necesito un código similar a:
>
> for (j in 5:23){
> for (i in 1:32){
> isup.i<-paste("isup",i,sep="")
> if ((sum(m_supj[i,]==0)) # utilizando el subíndice "j" que
reemplace a las
> matrices de 5 a 23
> else
> {
>
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
> }
> }}
>
> Los errores que me arroja son de tipo que no existe relación al objeto que
> se quiere almacenar, incoherencia en las dimensiones, la función assign()
> no asigna valores adecuados,etc, lo he intendado todo lo que se me a
> ocurrido sin ningun resultado favorable, algun comentario o ayuda??
>
> Muchas gracias por su respuesta
>
>         [[alternative HTML version deleted]]
>
>
> _______________________________________________
> R-help-es mailing list
> R-help-es en r-project.org
> https://stat.ethz.ch/mailman/listinfo/r-help-es
>

Estimado Alejandro Ayala

Las respuestas que le brindaron son buenas, de pronto podría ser útil
utilizar el paquete sqldf, que no es otra cosa que un data.frame, o un
data.frame llevado a sqlite3, porque en algunas oportunidades es cómodo
utilizar sql para "trabajar" con datos y R para "calcular".
Aunque debo
reconocer que hace un tiempo no utilizo sqldf (la última vez en windows
tenía problemas en las fechas), sin dudas la versión actual es diferente
a la que yo utilicé en aquellos días. No tengo la respuesta a su
inquietud, solo puedo nombrar otra alternativa para almacenar
información.

Javier Marcuzzi

El mar, 19-02-2013 a las 23:20 -0500, Alejandro Ayala
escribió:
> Saludos, me encuentro realizando una simulacin de una red de transporte
> (paradas, lneas de frecuencia, usuarios, etc), para lo cual necesito el
> almacenamiento de informacin de forma matricial.
> 
> El sistema cuenta con un numero determinado de paradas (38 paradas), en
> donde cada parada representa una matriz la cual tiene asociada la llegada
> de pasajeros, el tiempo en el cual llegaron, el dstino y otros atributos
> ms, mi pregunta es que si existe alguna paquete o forma de almacenar esta
> informacin a manera de una "super matriz", donde cada componente
de una
> matriz simple representa una nueva matriz, algo similar a lo que en fsica
> se denomina tensor.
> 
> Mi otra pregunta radica en como asignar valores mediante iteracin a las
> componentes de una matriz de acuerdo al cumplimiento de ciertas
> condiciones, tengo el siguiente cdigo
> 
> for (i in 5:23)   # creacin de 19 matrices nulas con subindices 5 6 7...23
> {
>   mat.i<-paste("mat",i,sep="")
>   assign(mat.i,matrix(0,32,32))
>   data.matrix(mat.i)
> }
> 
> # Mediante
> for (i in 1:32){  # iterador para realizar operaciones sobre cada fila de
> la matriz deseada
>   isup.i<-paste("isup",i,sep="")
>   if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) | (sum(m_sup7[i,])==0)){
>   # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas filas
> tienen componentes nulas (cero)
>     mat5[i,]=0
>     mat6[i,]=0
>     mat7[i,]=0}
>   else {
> 
>
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))
> 
>
mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))
> 
>
mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
>    }}
> 
> El anterior codigo funciona con condiciones de hasta 3 matrices 5, 6 y 7 a
> partir de 8 me arroja un error. Como podra reemplazar este cdigo mediante
> otro iterador que me reconozca el subndice de la matriz que estoy
> trabajando y adicionalmente me realice la operacin deseada sobre cada
> componente de la fila de la matriz trabajada en ese momento.
> 
> Necesito un cdigo similar a:
> 
> for (j in 5:23){
> for (i in 1:32){
> isup.i<-paste("isup",i,sep="")
> if ((sum(m_supj[i,]==0)) # utilizando el subndice "j" que
reemplace a las
> matrices de 5 a 23
> else
> {
>
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
> }
> }}
> 
> Los errores que me arroja son de tipo que no existe relacin al objeto que
> se quiere almacenar, incoherencia en las dimensiones, la funcin assign()
> no asigna valores adecuados,etc, lo he intendado todo lo que se me a
> ocurrido sin ningun resultado favorable, algun comentario o ayuda??
> 
> Muchas gracias por su respuesta
> 
> 	[[alternative HTML version deleted]]
> 
> _______________________________________________
> R-help-es mailing list
> R-help-es en r-project.org
> https://stat.ethz.ch/mailman/listinfo/r-help-es

Buenas tardes Alejandro,

Muchas gracias por la explicacion.

Insisto nuevamente en que los for() no son necesarios.  Por ejemplo:

# matrices nulas
matrices <- lapply(1:19, function(x) matrix(0, 32, 32))
names(matrices) <- paste0(''mat'', 1:19)
matrices

# division de las filas de cada matriz por su correspondiente suma
#  -- si existe division por cero, entregara NA
out <- lapply(matrices, function(mat){
 res <- mat/rowSums(mat)
  ifelse(is.na(res), NA, res)
})
out

Ahora, si quieres acceder a la informacion de cada matriz en out, solo
basta hacer (por ejemplo para la 5a matriz)

out[[5]]

Si quieres transformar *todas* la matrices en un objeto, creo que

as.data.frame(out)
do.call(rbind, out)
sapply(out, c)   # cada columna tiene 32*32 elementos

podrian servirte.

Espero sea de utilidad.
Jorge.-


2013/2/21 Alejandro Ayala <>
>
>
> El 20 de febrero de 2013 07:08, Jorge I Velez <> escribió:
>
> Estimado Alejandro,
>>
>> La primera parte puedes solucionarla usando listas:
>>
>> # matrices nulas
>> matrices <- lapply(1:19, function(x) matrix(0, 32, 32))
>> names(matrices) <- paste0(''mat'', 1:19)
>> matrices
>>
>> Para obtener la informacion de la 5a matriz, solo debes hacer
>>
>> matrices[[5]]
>>
>> Podrias por favor explicarnos un poco mas lo que intentas hacer en la
2a
>> parte de tu codigo y que comienza con "# Mediante"?
>>
>> Saludos,
>> Jorge.-
>>
>> 2013/2/20 Alejandro Ayala <>
>>
>>> Saludos, me encuentro realizando una simulación de una red de
transporte
>>> (paradas, líneas de frecuencia, usuarios, etc), para lo cual
necesito el
>>> almacenamiento de información de forma matricial.
>>>
>>> El sistema cuenta con un numero determinado de paradas (38
paradas), en
>>> donde cada parada representa una matriz la cual tiene asociada la
llegada
>>> de pasajeros, el tiempo en el cual llegaron, el déstino y otros
atributos
>>> más, mi pregunta es que si existe alguna paquete o forma de
almacenar
>>> esta
>>> información a manera de una "super matriz", donde cada
componente de una
>>> matriz simple representa una nueva matriz, algo similar a lo que en
>>> física
>>> se denomina tensor.
>>>
>>> Mi otra pregunta radica en como asignar valores mediante iteración
a las
>>> componentes de una matriz de acuerdo al cumplimiento de ciertas
>>> condiciones, tengo el siguiente código
>>>
>>> for (i in 5:23)   # creación de 19 matrices nulas con subindices 5
6
>>> 7...23
>>> {
>>>   mat.i<-paste("mat",i,sep="")
>>>   assign(mat.i,matrix(0,32,32))
>>>   data.matrix(mat.i)
>>> }
>>>
>>> # Mediante
>>> for (i in 1:32){  # iterador para realizar operaciones sobre cada
fila de
>>> la matriz deseada
>>>   isup.i<-paste("isup",i,sep="")
>>>   if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) |
>>> (sum(m_sup7[i,])==0)){
>>>   # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas
filas
>>> tienen componentes nulas (cero)
>>>     mat5[i,]=0
>>>     mat6[i,]=0
>>>     mat7[i,]=0}
>>>   else {
>>>
>>>
>>>
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))
>>>
>>>
>>>
mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))
>>>
>>>
>>>
mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
>>>    }}
>>>
>>> El anterior codigo funciona con condiciones de hasta 3 matrices 5,
6 y 7
>>> a
>>> partir de 8 me arroja un error. Como podría reemplazar este código
>>> mediante
>>> otro iterador que me reconozca el subíndice de la matriz que estoy
>>> trabajando y adicionalmente me realice la operación deseada sobre
cada
>>> componente de la fila de la matriz trabajada en ese momento.
>>>
>>> Necesito un código similar a:
>>>
>>> for (j in 5:23){
>>> for (i in 1:32){
>>> isup.i<-paste("isup",i,sep="")
>>> if ((sum(m_supj[i,]==0)) # utilizando el subíndice "j"
que reemplace a
>>> las
>>> matrices de 5 a 23
>>> else
>>> {
>>>
>>>
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
>>> }
>>> }}
>>>
>>> Los errores que me arroja son de tipo que no existe relación al
objeto
>>> que
>>> se quiere almacenar, incoherencia en las dimensiones, la función
assign()
>>> no asigna valores adecuados,etc, lo he intendado todo lo que se me
a
>>> ocurrido sin ningun resultado favorable, algun comentario o ayuda??
>>>
>>> Muchas gracias por su respuesta
>>>
>>>         [[alternative HTML version deleted]]
>>>
>>>
>>> _______________________________________________
>>> R-help-es mailing list
>>> R-help-es@r-project.org
>>> https://stat.ethz.ch/mailman/listinfo/r-help-es
>>>
>>>
>> Estimado Jorge, tengo un total de 19 matrices cuadradas (32x32)
>
> Lo que necesito es que para cada fila de cada matriz se realice una
> operación (cabe indicar que algunas filas de la matriz posee valores en
> cero y la operación ha realizar es la division de cada componente de la
> fila para la suma total de los valores de la fila) de ahí que se coloque la
> instrucción if else ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) |
> (sum(m_sup7[i,])==0)) en vista que no existe division para cero.
>
> La pregunta que planteo es: Existe la posibilidad de sustituir mediante
> loops "for anidados" las operaciones sobre cada fila de cada
matriz, es
> decir se reemplace:
>
> for (i in 1:32){  # iterador para realizar operaciones sobre cada fila de
> la matriz que se encuentra trabajando en ese instante.
>
>   isup.i<-paste("isup",i,sep="")
>
> if ((sum(m_sup5[i,])==0) | (sum(m_sup6[i,])==0) | (sum(m_sup7[i,])==0)){
>   # hace referencia a matrices (m_sup5, m_sup6,....) donde algunas filas
> tienen componentes nulas (cero)
>
>     mat5[i,]=0 # matrices nulas creadas anteriormente donde se van a
> almacenar los nuevos valores de la operación
>
>     mat6[i,]=0
>     mat7[i,]=0
> }
>
> else {
>
>
mat5[i,]<-assign(isup.i,as.vector(m_sup5[i,]/sum(m_sup5[i,]),mode="numeric"))
>
>
>
mat6[i,]<-assign(isup.i,as.vector(m_sup6[i,]/sum(m_sup6[i,]),mode="numeric"))
>
>
>
mat7[i,]<-assign(isup.i,as.vector(m_sup7[i,]/sum(m_sup7[i,]),mode="numeric"))
>    }}
>
> Se reemplace por un codigo similar a:
>
> for (j in 1:19){ # iterador de las matrices existentes
> for (i in 1:32){ # iterador de las filas de las matrices (j=1,2,...,19)
>
> isup.i<-paste("isup",i,sep="")
> if ((sum(m_supj[i,]==0)) # reemplazo de los valores 1,2,...,19 por el
> subíndice "j" (m_sup1[i,] a m_supj[i,])
> else
> {
>
>
matj[i,]<-assign(isup.i,as.vector(m_supj[i,]/sum(m_supj[i,]),mode="numeric"))
> }
> }}
>
> Despues de todo esto ya con las nuevas matrices generadas con la operación
> (división) necesito almacenar en forma de una matriz o vector
"gigante"
> donde cada componente haga referencia a una de las 19 matrices.
>
> Alguna idea al respecto grácias y saludos.
>
	[[alternative HTML version deleted]]