

How do you specify matrix location a[i,j] (or a[i1,j], etc.) in a "for"
loop?
I am looking for a flexible method of indexing neighbors over a series
of lags (1,2,3...) and I may wish to extend this method to 3D arrays.
Example:
Data matrix
> fun
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
For each element a[i,j] in "fun", sum the 1st order (Rook's) neighbors:
a[i1,j]
a[i+1,j]
a[i,j1]
a[i,j+1]
Then divide by the number of elements included as neighbors this
number depends on the location of a[i,j] in the matrix.
Insert the product of the neighbor calculation for each a[i,j] into the
corresponding position b[i,j] in an empty matrix with the same
dimensions as "fun".
For example, element [2,2] in "fun" should yield element [2,2] in a new
matrix equal to 24/4=6. Of course, element [1,1] in the new matrix
should be the product of only two numbers.
Thanks
J. Mills
[[alternative HTML version deleted]]
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html


Do you have to use a loop? The following function should do what you want for the 1st order:
rook = function(Y) {
rsub = function(Z) {
X = matrix(0,nrow(Z),ncol(Z));
X[1:(N1),1:M] = X[1:(N1),1:M] + Z[2:N,1:M];
X[2:N,1:M] = X[2:N,1:M] + Z[1:(N1),1:M];
X[1:N,1:(M1)] = X[1:N,1:(M1)] + Z[1:N,2:M];
X[1:N,2:M] = X[1:N,2:M] + Z[1:N,1:(M1)];
return(X);
}
return(rsub(Y)/rsub(matrix(1,nrow(Y),ncol(Y))));
}
I'm not sure I understand how the higher orders work. For example, an interior element for the 1st order is always divided by 4. Is an interior element for a 3rd order divided by 4 or 8 or something else? Also, how are you implementing your 3D matrices?
Brett
Original Message
From: [hidden email] [mailto: [hidden email]] On Behalf Of Mills, Jason
Sent: Friday, February 17, 2006 1:36 PM
To: [hidden email]
Subject: [R] Matrix indexing in a loop
How do you specify matrix location a[i,j] (or a[i1,j], etc.) in a "for"
loop?
I am looking for a flexible method of indexing neighbors over a series of lags (1,2,3...) and I may wish to extend this method to 3D arrays.
Example:
Data matrix
> fun
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
For each element a[i,j] in "fun", sum the 1st order (Rook's) neighbors:
a[i1,j]
a[i+1,j]
a[i,j1]
a[i,j+1]
Then divide by the number of elements included as neighbors this number depends on the location of a[i,j] in the matrix.
Insert the product of the neighbor calculation for each a[i,j] into the corresponding position b[i,j] in an empty matrix with the same dimensions as "fun".
For example, element [2,2] in "fun" should yield element [2,2] in a new matrix equal to 24/4=6. Of course, element [1,1] in the new matrix should be the product of only two numbers.
Thanks
J. Mills
[[alternative HTML version deleted]]
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html


You're right I had N and M defined outside of the function and rook and rsub were picking up on that. The following is a bit better and more cleaned up version with ith order option:
rook = function(Y,i) {
N = nrow(Y);
M = ncol(Y);
rsub = function(Z,i) {
X = matrix(0,N,M);
X[1:(Ni),] = X[1:(Ni),] + Z[(1+i):N,];
X[(1+i):N,] = X[(1+i):N,] + Z[1:(Ni),];
X[,1:(Mi)] = X[,1:(Mi)] + Z[,(1+i):M];
X[,(1+i):M] = X[,(1+i):M] + Z[,1:(Mi)];
return(X);
}
return(rsub(Y,i)/rsub(matrix(1,N,M),i));
}
Notice that the variable "i" can be passed any value even one that causes an error.
Brett
Original Message
From: Mills, Jason [mailto: [hidden email]]
Sent: Friday, February 17, 2006 4:11 PM
To: Pontarelli, Brett
Subject: RE: [R] Matrix indexing in a loop
Hi Brett, thanks for the tip.
I tried this function on my sample matrix and got the error message "Error in rsub(fun) : object "N" not found". Your code looks like it should work, so I must be doing some wrong. I will continue to experiment.
As for the neighbor pattern, the convention follows the rules of chess.
I would consider a 2nd order rook case to include only 4 elements:
a[i2,j]
a[i+2,j]
a[i,j2]
a[i,j+2]
Even 3rd order Rook would still only include 4 elements. As another example, a Queen neighborhood includes 8 elements, independent of the lag order.
I haven't started using 3D arrays yet. I am attempting spatiotemporal analysis and I have thought about representing my landscape (two
dimensions) over time (the third dimension). For now, I'm trying to get a handle on working in two dimensions.
Thanks.
Jason
Original Message
From: Pontarelli, Brett [mailto: [hidden email]]
Sent: Friday, February 17, 2006 4:04 PM
To: Mills, Jason; [hidden email]
Subject: RE: [R] Matrix indexing in a loop
Do you have to use a loop? The following function should do what you want for the 1st order:
rook = function(Y) {
rsub = function(Z) {
X = matrix(0,nrow(Z),ncol(Z));
X[1:(N1),1:M] = X[1:(N1),1:M] + Z[2:N,1:M];
X[2:N,1:M] = X[2:N,1:M] + Z[1:(N1),1:M];
X[1:N,1:(M1)] = X[1:N,1:(M1)] + Z[1:N,2:M];
X[1:N,2:M] = X[1:N,2:M] + Z[1:N,1:(M1)];
return(X);
}
return(rsub(Y)/rsub(matrix(1,nrow(Y),ncol(Y))));
}
I'm not sure I understand how the higher orders work. For example, an interior element for the 1st order is always divided by 4. Is an interior element for a 3rd order divided by 4 or 8 or something else?
Also, how are you implementing your 3D matrices?
Brett
Original Message
From: [hidden email]
[mailto: [hidden email]] On Behalf Of Mills, Jason
Sent: Friday, February 17, 2006 1:36 PM
To: [hidden email]
Subject: [R] Matrix indexing in a loop
How do you specify matrix location a[i,j] (or a[i1,j], etc.) in a "for"
loop?
I am looking for a flexible method of indexing neighbors over a series of lags (1,2,3...) and I may wish to extend this method to 3D arrays.
Example:
Data matrix
> fun
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
For each element a[i,j] in "fun", sum the 1st order (Rook's) neighbors:
a[i1,j]
a[i+1,j]
a[i,j1]
a[i,j+1]
Then divide by the number of elements included as neighbors this number depends on the location of a[i,j] in the matrix.
Insert the product of the neighbor calculation for each a[i,j] into the corresponding position b[i,j] in an empty matrix with the same dimensions as "fun".
For example, element [2,2] in "fun" should yield element [2,2] in a new matrix equal to 24/4=6. Of course, element [1,1] in the new matrix should be the product of only two numbers.
Thanks
J. Mills
[[alternative HTML version deleted]]
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide!
http://www.Rproject.org/postingguide.html______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html


For 2d here is a solution based on zoo. It turns the matrix into
a time series and lags it forwards and backwards and does the
same for its transpose in order to avoid index machinations.
The function is called rook2 and it first defines three local
functions, one that converts NAs to zero, one that does
a lag using na.pad = TRUE and one to invoke Lag and
add up the lags:
library(zoo)
rook2 < function(x, i = 1) {
na2zero < function(x) ifelse(is.na(x), 0, x)
Lag < function(x, i) na2zero(lag(zoo(x), i, na.pad = TRUE))
Rook < function(x, i) Lag(x, i) + Lag(x, i) + t(Lag(t(x), i) +
Lag(t(x), i))
Rook(x, i) / Rook(1+0*x, i)
}
# test
m < matrix(1:24, 6)
rook2(m)
On 2/17/06, Mills, Jason < [hidden email]> wrote:
>
> How do you specify matrix location a[i,j] (or a[i1,j], etc.) in a "for"
> loop?
>
> I am looking for a flexible method of indexing neighbors over a series
> of lags (1,2,3...) and I may wish to extend this method to 3D arrays.
>
>
> Example:
>
> Data matrix
> > fun
> [,1] [,2] [,3]
> [1,] 1 5 9
> [2,] 2 6 10
> [3,] 3 7 11
> [4,] 4 8 12
>
>
> For each element a[i,j] in "fun", sum the 1st order (Rook's) neighbors:
>
> a[i1,j]
>
> a[i+1,j]
>
> a[i,j1]
>
> a[i,j+1]
>
> Then divide by the number of elements included as neighbors this
> number depends on the location of a[i,j] in the matrix.
>
>
> Insert the product of the neighbor calculation for each a[i,j] into the
> corresponding position b[i,j] in an empty matrix with the same
> dimensions as "fun".
>
>
> For example, element [2,2] in "fun" should yield element [2,2] in a new
> matrix equal to 24/4=6. Of course, element [1,1] in the new matrix
> should be the product of only two numbers.
>
>
> Thanks
>
> J. Mills
>
> [[alternative HTML version deleted]]
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/rhelp> PLEASE do read the posting guide! http://www.Rproject.org/postingguide.html>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html


Thought about this some more and here is a solution that
works with 2d and 3d (and higher dimensions).
inner is a generalized inner product similar to a function
I have posted previously and f(x,y) is an inner product such
that f(x,y) is TRUE if abs(x  y) == order (after converting
both x and y to numeric) and FALSE otherwise. Root then
uses as.data.frame.table to turn the array into data frames
with the last column having
the data and the other columns representing the indexes.
We then perform the inner product and use the resulting
matrix to multiply c(x) which is the input strung out
into a vector reshaping it back into the same shape as x.
Finally we divide each cell by the number of surrounding
cells.
root3 < function(x, order = 1) {
f < function(x,y) sum(abs(as.numeric(x)  as.numeric(y))) == order
inner < function(a,b,f)
apply(b,1,function(x)apply(a,1,function(y)f(x,y)))
Root < function(x) {
n < length(dim(x))
dd < sapply(as.data.frame.table(x)[,n1], as.numeric)
structure(inner(dd, dd, f) %*% c(x), .Dim = dim(x))
}
Root(x) / Root(1+0*x)
}
# tests
m < matrix(1:24, 6) # 2d
root3(m)
mm < array(1:24, 2:4) # 3d
root3(mm)
On 2/17/06, Gabor Grothendieck < [hidden email]> wrote:
> For 2d here is a solution based on zoo. It turns the matrix into
> a time series and lags it forwards and backwards and does the
> same for its transpose in order to avoid index machinations.
> The function is called rook2 and it first defines three local
> functions, one that converts NAs to zero, one that does
> a lag using na.pad = TRUE and one to invoke Lag and
> add up the lags:
>
> library(zoo)
> rook2 < function(x, i = 1) {
> na2zero < function(x) ifelse(is.na(x), 0, x)
> Lag < function(x, i) na2zero(lag(zoo(x), i, na.pad = TRUE))
> Rook < function(x, i) Lag(x, i) + Lag(x, i) + t(Lag(t(x), i) +
> Lag(t(x), i))
> Rook(x, i) / Rook(1+0*x, i)
> }
>
> # test
> m < matrix(1:24, 6)
> rook2(m)
>
>
> On 2/17/06, Mills, Jason < [hidden email]> wrote:
> >
> > How do you specify matrix location a[i,j] (or a[i1,j], etc.) in a "for"
> > loop?
> >
> > I am looking for a flexible method of indexing neighbors over a series
> > of lags (1,2,3...) and I may wish to extend this method to 3D arrays.
> >
> >
> > Example:
> >
> > Data matrix
> > > fun
> > [,1] [,2] [,3]
> > [1,] 1 5 9
> > [2,] 2 6 10
> > [3,] 3 7 11
> > [4,] 4 8 12
> >
> >
> > For each element a[i,j] in "fun", sum the 1st order (Rook's) neighbors:
> >
> > a[i1,j]
> >
> > a[i+1,j]
> >
> > a[i,j1]
> >
> > a[i,j+1]
> >
> > Then divide by the number of elements included as neighbors this
> > number depends on the location of a[i,j] in the matrix.
> >
> >
> > Insert the product of the neighbor calculation for each a[i,j] into the
> > corresponding position b[i,j] in an empty matrix with the same
> > dimensions as "fun".
> >
> >
> > For example, element [2,2] in "fun" should yield element [2,2] in a new
> > matrix equal to 24/4=6. Of course, element [1,1] in the new matrix
> > should be the product of only two numbers.
> >
> >
> > Thanks
> >
> > J. Mills
> >
> > [[alternative HTML version deleted]]
> >
> > ______________________________________________
> > [hidden email] mailing list
> > https://stat.ethz.ch/mailman/listinfo/rhelp> > PLEASE do read the posting guide! http://www.Rproject.org/postingguide.html> >
>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html


There was an error in the function f  it only worked correctly if
order was 1. Here it is with that fixed. The function f is the
only thing changed from my last post. It makes use of the
fact that sum(x) == n and sum(x*x) == n*n only occur when
one element of x is n and the rest are 0.
root3 < function(x, order = 1) {
f < function(x,y) {
z < abs(as.numeric(x)  as.numeric(y))
(sum(z) == order) & (sum(z*z) == order * order)
}
inner < function(a,b,f)
apply(b,1,function(x)apply(a,1,function(y)f(x,y)))
Root < function(x) {
n < length(dim(x))
dd < sapply(as.data.frame.table(x)[,n1], as.numeric)
structure(inner(dd, dd, f) %*% c(x), .Dim = dim(x))
}
Root(x) / Root(1+0*x)
}
# tests
m < matrix(1:24, 6) # 2d
root3(m)
mm < array(1:24, 2:4) # 3d
root3(mm)
On 2/17/06, Gabor Grothendieck < [hidden email]> wrote:
> Thought about this some more and here is a solution that
> works with 2d and 3d (and higher dimensions).
>
> inner is a generalized inner product similar to a function
> I have posted previously and f(x,y) is an inner product such
> that f(x,y) is TRUE if abs(x  y) == order (after converting
> both x and y to numeric) and FALSE otherwise. Root then
> uses as.data.frame.table to turn the array into data frames
> with the last column having
> the data and the other columns representing the indexes.
> We then perform the inner product and use the resulting
> matrix to multiply c(x) which is the input strung out
> into a vector reshaping it back into the same shape as x.
> Finally we divide each cell by the number of surrounding
> cells.
>
> root3 < function(x, order = 1) {
> f < function(x,y) sum(abs(as.numeric(x)  as.numeric(y))) == order
> inner < function(a,b,f)
> apply(b,1,function(x)apply(a,1,function(y)f(x,y)))
>
> Root < function(x) {
> n < length(dim(x))
> dd < sapply(as.data.frame.table(x)[,n1], as.numeric)
> structure(inner(dd, dd, f) %*% c(x), .Dim = dim(x))
> }
> Root(x) / Root(1+0*x)
> }
>
> # tests
> m < matrix(1:24, 6) # 2d
> root3(m)
> mm < array(1:24, 2:4) # 3d
> root3(mm)
>
>
> On 2/17/06, Gabor Grothendieck < [hidden email]> wrote:
> > For 2d here is a solution based on zoo. It turns the matrix into
> > a time series and lags it forwards and backwards and does the
> > same for its transpose in order to avoid index machinations.
> > The function is called rook2 and it first defines three local
> > functions, one that converts NAs to zero, one that does
> > a lag using na.pad = TRUE and one to invoke Lag and
> > add up the lags:
> >
> > library(zoo)
> > rook2 < function(x, i = 1) {
> > na2zero < function(x) ifelse(is.na(x), 0, x)
> > Lag < function(x, i) na2zero(lag(zoo(x), i, na.pad = TRUE))
> > Rook < function(x, i) Lag(x, i) + Lag(x, i) + t(Lag(t(x), i) +
> > Lag(t(x), i))
> > Rook(x, i) / Rook(1+0*x, i)
> > }
> >
> > # test
> > m < matrix(1:24, 6)
> > rook2(m)
> >
> >
> > On 2/17/06, Mills, Jason < [hidden email]> wrote:
> > >
> > > How do you specify matrix location a[i,j] (or a[i1,j], etc.) in a "for"
> > > loop?
> > >
> > > I am looking for a flexible method of indexing neighbors over a series
> > > of lags (1,2,3...) and I may wish to extend this method to 3D arrays.
> > >
> > >
> > > Example:
> > >
> > > Data matrix
> > > > fun
> > > [,1] [,2] [,3]
> > > [1,] 1 5 9
> > > [2,] 2 6 10
> > > [3,] 3 7 11
> > > [4,] 4 8 12
> > >
> > >
> > > For each element a[i,j] in "fun", sum the 1st order (Rook's) neighbors:
> > >
> > > a[i1,j]
> > >
> > > a[i+1,j]
> > >
> > > a[i,j1]
> > >
> > > a[i,j+1]
> > >
> > > Then divide by the number of elements included as neighbors this
> > > number depends on the location of a[i,j] in the matrix.
> > >
> > >
> > > Insert the product of the neighbor calculation for each a[i,j] into the
> > > corresponding position b[i,j] in an empty matrix with the same
> > > dimensions as "fun".
> > >
> > >
> > > For example, element [2,2] in "fun" should yield element [2,2] in a new
> > > matrix equal to 24/4=6. Of course, element [1,1] in the new matrix
> > > should be the product of only two numbers.
> > >
> > >
> > > Thanks
> > >
> > > J. Mills
> > >
> > > [[alternative HTML version deleted]]
> > >
> > > ______________________________________________
> > > [hidden email] mailing list
> > > https://stat.ethz.ch/mailman/listinfo/rhelp> > > PLEASE do read the posting guide! http://www.Rproject.org/postingguide.html> > >
> >
>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide! http://www.Rproject.org/postingguide.html

