These functions can be used to turn a list into an array and extract or replace values or take the sum along a certain dimension of an array.

1 2 3 4 | ```
list2array(l)
slice(arr, d = NULL, i = 1, value = NULL)
dimSums(arr, d = 1, i = NULL)
slice.affinity(affinity, d = 1, i = 1)
``` |

`l` |
a list. |

`arr` |
an array. |

`d` |
numeric, what dimension to use. |

`i` |
numeric, what slice to use. |

`value` |
values to assign to the portion of an array specified by |

`affinity` |
list, output from |

`list2array`

turns a list of `array`

s, each with the same dimensions, into a new array having one more dimension whose size is equal to the number of initial arrays.

`slice`

extracts or assigns values from/to the `i`

th slice(s) in the `d`

th dimension of an array. Values are assigned to an array if `value`

is not NULL. This function works by building an expression containing the extraction operator (`[`

).

`slice.affinity`

performs a slice operation on the values element of the affinity variable (which should be the output of `affinity`

). This function is used e.g. by `anim.TCA`

to extract slices that are the basis for frames of an animated stability diagram.

`dimSums`

sums an array along the `d`

th dimension using only the `i`

th slices in that dimension. If `i`

is NULL, all slices in that dimension are summed together. For matrices, `dimSums(x,1)`

has the same result as `colSums(x)`

and `dimSums(x,2)`

has the same result as `rowSums(x)`

.

In the examples below, the “stopifnot” tests fail unless a and b are both created as multiples of the starting matrix x. This behavior probably reflects the internal representation of these matrices in **R**.

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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | ```
# start with a matrix
x <- matrix(1:12,ncol=3)
# pay attention to the following when
# writing examples that test for identity!
identical(1*x,x) # FALSE
# create two matrices that are multiples of the first
a <- 1*x
b <- 2*a
# these both have two dimensions of lengths 4 and 3
dim(a) # 4 3
# combine them to make an array with three dimensions
c <- list2array(list(a,b))
# the third dimension has length 2
dim(c) # 4 3 2
# the first slice of the third dimension == a
stopifnot(identical( slice(c,3), a ))
# the second slice of the third dimension == b
stopifnot(identical( slice(c,3,2), b ))
# 'slice' works just like the bracket operator
c11 <- slice(c,1)
c12 <- slice(c,1,2)
c21 <- slice(c,2,1)
c212 <- slice(c,2,1:2)
stopifnot(identical( c11, c[1,,] ))
stopifnot(identical( c12, c[2,,] ))
stopifnot(identical( c21, c[,1,] ))
stopifnot(identical( c212, c[,1:2,] ))
# let us replace part of the array
d <- slice(c,3,2,value=a)
# now the second slice of the third dimension == a
stopifnot(identical( slice(d,3,2), a ))
# and the sum across the third dimension == b
stopifnot(identical( dimSums(d,3), b ))
# taking the sum removes that dimension
dim(d) # 4 3 2
dim(dimSums(d,1)) # 3 2
dim(dimSums(d,2)) # 4 2
dim(dimSums(d,3)) # 4 3
# working with an 'affinity' object
basis("CHNOS+")
species("alanine")
a1 <- affinity(O2=c(-80,-60)) # at pH=7
a2 <- affinity(O2=c(-80,-60),pH=c(0,14,7))
# in the 2nd dimension (pH) get the 4th slice (pH=7)
a3 <- slice.affinity(a2,2,4)
stopifnot(all.equal(a1$values,a3$values))
``` |

Questions? Problems? Suggestions? Tweet to @rdrrHQ or email at ian@mutexlabs.com.

Please suggest features or report bugs with the GitHub issue tracker.

All documentation is copyright its authors; we didn't write any of that.