Slicing multidimensional table

Question

Say I have a multidimensional list created in the following way

 grid= 
 Table[{i, j+1, k+2}, {i, 0, 1}, {j, 0, 1}, {k, 0, 1}]
 

grid={{{{0, 1, 2}, {0, 1, 3}}, {{0, 2, 2}, {0, 2, 3}}},
      {{{1, 1, 2}, {1, 1, 3}}, {{1, 2, 2}, {1, 2, 3}}}}

How can I keep a 2-dimensional slice of this 3-dimensional table, or in general, a 2-dimensional slice of an n-dimensional table?. Say I would like to obtain the array for which the second quantity has the value of 1, i.e.

dim=2; (* The dimension I want to eliminate *)
value=1;
out=f[grid,dim,value]

out={{{0, 2}, {0, 3}}, {{1, 2}, {1, 3}}}

I have worked out a rudimentary way of taking 1-D slices from 2-D sets of data, but nothing I have tried works for >2-dimensional tables.

Thank you very much.

Answer 1

Here's an answer to the question in the comments below OP:

grid={{{{0, 1, 2}, {0, 1, 3}}, {{0, 2, 2}, {0, 2, 3}}},
      {{{1, 1, 2}, {1, 1, 3}}, {{1, 2, 2}, {1, 2, 3}}}}

A 2x2x2 list of 3-component vectors.

If I understood correctly, pick out, for example, all such vectors, that have 0 as their first component. I am inclined to take a pattern-matching approach.

grid /. Except[{0, _, _}, {_, _, _}] -> 
         Unevaluated[Sequence[]] //.
          {} -> Unevaluated[Sequence[]] //.
           {a_List} :> a

First line reads "take grid and replace everything that matches a 3-component vector, except a vector with 0 at the start with..."

Second line: "...a so called vanishing function. Then repeatedly apply the following rule until nothing changes..."

Third line: "...the rule is to replace empty lists with the same vanishing function. Finally repeatedly apply the rule..."

Fourth line: "...of replacing any list that is the only element of a parent list with itself".

{{{0, 1, 2}, {0, 1, 3}}, {{0, 2, 2}, {0, 2, 3}}}

Because otherwise we would get a 1x2x2 grid instead of a 2x2 grid. But if we have a different grid:

grid = {{{{0, 1, 2}, {0, 1, 3}}, {{0, 2, 2}, {0, 2, 3}}}, 
        {{{0, 1, 2}, {1, 1, 3}}, {{1, 2, 2}, {1, 2, 3}}}}

{{{{0, 1, 2}, {0, 1, 3}}, {{0, 2, 2}, {0, 2, 3}}}, {0, 1, 2}}

Not so great. Still a 3D grid, also the last vector is at a different depth than the others. But here we can drop the last of the replacement rules:

grid /.
  Except[{0, _, _}, {_, _, _}] -> Unevaluated[Sequence[]] //.
   {} -> Unevaluated[Sequence[]]

{{{{0, 1, 2}, {0, 1, 3}}, {{0, 2, 2}, {0, 2, 3}}}, {{{0, 1, 2}}}}

Anyway, whatever the output, a final replacement rule to drop the 0s:

% /. {0, a_, b_} :> {a, b}

{{{{1, 2}, {1, 3}}, {{2, 2}, {2, 3}}}, {{{1, 2}}}}

or with the original grid and result of its processing:

{{{1, 2}, {1, 3}}, {{2, 2}, {2, 3}}}

Update

This is largely guesswork, but the way your grid is structured is suggestive.

There's a great answer somewhere here about using Flatten with a matrix as the second argument.

This command gives all possible usage options that are applicable for your case ordered in a nice way.

MatrixForm /@ First /@ (Flatten[grid, #] & /@ Permutations[{{1}, {2}, {3}}])

The way your grid is structured,

First@Flatten[grid,{{i},{j},{k}}]

returns the four vectors with matching i-th elements, and depending on the order of j and k they are arranged as {{1,2},{3,4}} or {{1,3},{2,4}}.

So you can also try

(First@Flatten[grid,{{i},{j},{k}}])[[All,All,{j,k}]]

e.g.

(First@Flatten[grid, {{1}, {2}, {3}}])[[All, All, {2, 3}]]

{{{1, 2}, {1, 3}}, {{2, 2}, {2, 3}}}

Answer 2

Pick[#[[All, {1, 3}]], #[[All, 2]], 1] & @@@ grid
(* {{{0, 2}, {0, 3}}, {{1, 2}, {1, 3}}} *)

or

(Select[#, #[[2]] == 1 &] & @@@ grid)[[All, All , {1, 3}]]
(* {{{0, 2}, {0, 3}}, {{1, 2}, {1, 3}}} *)

or

Cases[grid, m : {{_, 1, _} ..} :> m[[All, {1, 3}]], {2}]
(* {{{0, 2}, {0, 3}}, {{1, 2}, {1, 3}}} *)

Update: You can also turn the methods above into functions:

pF[g_, keep_, drop_, val_] := Pick[#[[All, keep]], #[[All, drop]], val] & @@@ g

sF[g_, keep_, drop_, val_] := (Select[#, #[[drop]] == val &] & @@@ g)[[All, All, keep]]

cF[g_, keep_, drop_, val_] := Cases[g, m : {RotateRight[{val, _, _}, drop - 1] ..} :> 
   m[[All, keep]], {2}]

Examples:

pF[grid, {1, 3}, 2, 1]
(* {{{0, 2}, {0, 3}}, {{1, 2}, {1, 3}}} *)

pF[grid, {1, 2}, 3, 3]
(* {{{0, 1}}, {{1, 1}}} *)