[R] Doing %o% that operates on columns instead of atomics

jim holtman jholtman at gmail.com
Wed Mar 25 16:12:52 CET 2009


Is this what you want:

 > my.foo <- function( a, b ) a - b
> z <- combn(ncol(y), 2)  # get all the combinations of 2 columns
> result <- do.call(cbind, lapply(seq(ncol(z)), function(.cols){
+     my.foo(y[,z[1,.cols]], y[, z[2, .cols]])
+ }))
>
>
> result
  [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13]
[,14] [,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24]
[,25] [,26]
1   -1   -2   -3   -4   -5   -6   -7   -8   -1    -2    -3    -4    -5
   -6    -7    -1    -2    -3    -4    -5    -6    -1    -2    -3
-4    -5
2   -2   -4   -6   -8  -10  -12  -14  -16   -2    -4    -6    -8   -10
  -12   -14    -2    -4    -6    -8   -10   -12    -2    -4    -6
-8   -10
3   -3   -6   -9  -12  -15  -18  -21  -24   -3    -6    -9   -12   -15
  -18   -21    -3    -6    -9   -12   -15   -18    -3    -6    -9
-12   -15
4   -4   -8  -12  -16  -20  -24  -28  -32   -4    -8   -12   -16   -20
  -24   -28    -4    -8   -12   -16   -20   -24    -4    -8   -12
-16   -20
5   -5  -10  -15  -20  -25  -30  -35  -40   -5   -10   -15   -20   -25
  -30   -35    -5   -10   -15   -20   -25   -30    -5   -10   -15
-20   -25
6   -6  -12  -18  -24  -30  -36  -42  -48   -6   -12   -18   -24   -30
  -36   -42    -6   -12   -18   -24   -30   -36    -6   -12   -18
-24   -30
7   -7  -14  -21  -28  -35  -42  -49  -56   -7   -14   -21   -28   -35
  -42   -49    -7   -14   -21   -28   -35   -42    -7   -14   -21
-28   -35
8   -8  -16  -24  -32  -40  -48  -56  -64   -8   -16   -24   -32   -40
  -48   -56    -8   -16   -24   -32   -40   -48    -8   -16   -24
-32   -40
9   -9  -18  -27  -36  -45  -54  -63  -72   -9   -18   -27   -36   -45
  -54   -63    -9   -18   -27   -36   -45   -54    -9   -18   -27
-36   -45
  [,27] [,28] [,29] [,30] [,31] [,32] [,33] [,34] [,35] [,36]
1    -1    -2    -3    -4    -1    -2    -3    -1    -2    -1
2    -2    -4    -6    -8    -2    -4    -6    -2    -4    -2
3    -3    -6    -9   -12    -3    -6    -9    -3    -6    -3
4    -4    -8   -12   -16    -4    -8   -12    -4    -8    -4
5    -5   -10   -15   -20    -5   -10   -15    -5   -10    -5
6    -6   -12   -18   -24    -6   -12   -18    -6   -12    -6
7    -7   -14   -21   -28    -7   -14   -21    -7   -14    -7
8    -8   -16   -24   -32    -8   -16   -24    -8   -16    -8
9    -9   -18   -27   -36    -9   -18   -27    -9   -18    -9
>
> y
  1  2  3  4  5  6  7  8  9
1 1  2  3  4  5  6  7  8  9
2 2  4  6  8 10 12 14 16 18
3 3  6  9 12 15 18 21 24 27
4 4  8 12 16 20 24 28 32 36
5 5 10 15 20 25 30 35 40 45
6 6 12 18 24 30 36 42 48 54
7 7 14 21 28 35 42 49 56 63
8 8 16 24 32 40 48 56 64 72
9 9 18 27 36 45 54 63 72 81
>


On Wed, Mar 25, 2009 at 9:03 AM, Ken-JP <kfmfe04 at gmail.com> wrote:
>
> Okay, this one is hard to put into words:
>
>> x <- 1:9; names(x) <- x
>> y <- x %o% x
>> y
>
>  1  2  3  4  5  6  7  8  9
> 1 1  2  3  4  5  6  7  8  9
> 2 2  4  6  8 10 12 14 16 18
> 3 3  6  9 12 15 18 21 24 27
> 4 4  8 12 16 20 24 28 32 36
> 5 5 10 15 20 25 30 35 40 45
> 6 6 12 18 24 30 36 42 48 54
> 7 7 14 21 28 35 42 49 56 63
> 8 8 16 24 32 40 48 56 64 72
> 9 9 18 27 36 45 54 63 72 81
>
>> my.foo( a, b ) { c <- a - b; #really more complex, but just to illustrate
>> }
>
> ---------------------------------------------------------------------
>
> What I would like to do is apply my.foo() which takes two columns, a and b,
> does an operation and returns another column c.  The columns I want to feed
> into my.foo() are all the combinations of columns in y.  So I want to apply
> my.foo( y[,1], y[,1] ) and then my.foo( y[,1], y[,2] ), etc...  for all
> combinations() of the 10 columns in y.
>
> I would expect the final output to be 10x10x10.  Passing 10 columns by 10
> columns to my.foo() which outputs a vector of 10 numbers at a time.
>
> ***So in essence, what I am trying to accomplish is like outer(), but
> instead of operating on atomic values, I want to operate on columns of y.
>
> I know I can use loops to accomplish this, but I would like to code as
> R-like as possible.  I am learning a great deal about "how to think in R"
> from the excellent replies on this board.
>
> Thanks in advance for any suggestions.
>
>
>
> --
> View this message in context: http://www.nabble.com/Doing--o--that-operates-on-columns-instead-of-atomics-tp22701363p22701363.html
> Sent from the R help mailing list archive at Nabble.com.
>
> ______________________________________________
> R-help at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.
>



-- 
Jim Holtman
Cincinnati, OH
+1 513 646 9390

What is the problem that you are trying to solve?




More information about the R-help mailing list