# Brackets around each item in matrix

I have a matrix where every item in the matrix has its own brackets that I do not want. How can I remove the brackets around each item?

• Try mat /. List[x__] /; Length[List[x]] == 1 :> x where mat is your matrix (I can't read which letter you're using in this image). Feb 7 '16 at 20:34
• Flatten /@ matrix Feb 8 '16 at 6:18
• Related: (20180) Feb 8 '16 at 9:10
• Catenate /@ m is also a fast option. Feb 8 '16 at 17:27

Wrap the matrix rows with the the Flatten function

M = {{{1}, {2}, {3}, {4}}, {{5}, {6}, {7}, {8}}}


To save time you can wrap your whole matrix using: Map[Flatten, <yourmatrix> ]

Map[Flatten,{{{1}, {2}, {3}, {4}}, {{5}, {6}, {7}, {8}}}]


the outermost list contains two elements (the rows). the Map function wraps these elements with the Flatten function

{{1, 2, 3, 4}, {5, 6, 7, 8}}

In Mathematica this is known as "nested" Lists. Flatten removes all wrappings of the List function until only one remains

To understand what the Map function does: Below is the "manual" approach without the Map function.

{
Flatten[{{1}, {2}, {3}, {4}}],

Flatten[{{5}, {6}, {7}, {7}}]
}


As you are talking to an awesome machine called the Mathematica kernel you don't have to waste time writing things in long hand to make them readable (like you would for a slow-to-understand human reader of an essay or your future self reading your code).

hence Map[Flatten, Matrix] has the terse shorthand form Flatten /@ matrix

mentioned by @garej , @jjc385 and @Mr.Wizard below

• As this answer is clearly geared for new users, I think this answer would be somewhat improved by mentioning the syntactic sugar Flatten /@ <matrix>. Feb 8 '16 at 13:18
• (Is it polite/conventional to delete a comment such as mine above after the edit has been made?) Feb 8 '16 at 14:01
• @jjc385 I have not observed a specific convention in that regard. The comments can serve as minor credit for the source of an edit, and I don't see anything wrong with that. However since you are mentioned by (nick)name in the answer now the comments seems redundant and I would probably delete it if it where mine. Feb 16 '16 at 13:57

Lots of solutions. Time for a benchmark. My own contribution is Part:

m = {{{1}, {2}, {3}}, {{2}, {4}, {6}}};

m[[All, All, 1]];

{{1, 2, 3}, {2, 4, 6}}


Update: I made a complete mess of my earlier attempt at benchmarking. Here is a rewrite.

methods = Hold[Flatten /@ m, ArrayReshape[m, Most@Dimensions@m],
ArrayReshape[m, Dimensions[m][[1 ;; 2]]], Flatten[m, {Depth[m] - 1, 1}],
Apply[Sequence, m, {2}], Apply[Sequence, m, {-2}], Join @@@ m, m[[All, All, 1]],
Catenate /@ m];

names = {"Map[Flatten]", "ArrayReshape 1", "ArrayReshape 2", "Flatten w/ Depth",
"Sequence {2}", "Sequence {-2}", "Join", "Part", "Map[Catenate]"};

upk[{x_, y_}] := Table[{ToString[i*j]}, {i, x}, {j, y}];
pkd[{x_, y_}] := RandomReal[1, {x, y, 1}];

tab =
Table[
List @@ First /@ RepeatedTiming /@ methods,
{fn, {upk, pkd}},
{shape, {{10, 100000}, {1000, 1000}, {100000, 10}}},
{m, {fn[shape]}}
];

TableForm[
Append[names] /@ (tab //. {x_List} :> x),
TableHeadings -> {{"Unpacked", "Packed"}, {{10, 100000}, {1000, 1000}, {100000, 10}}},
TableSpacing -> {5, 1, 0.5}
]


(Benchmark timings in 10.1.0 under Windows 7 x64.)

It seems that in most instances Part wins, but a few times Catenate edges it out.

• @jjc385 Sorry, I was just being lazy. Actually really lazy as if the code I copied is actually what I ran the second test is a total mess. Earlier I had a comment "where's my coffee" -- I guess I really needed it! Feb 8 '16 at 14:15
• @jjc385 I rewrote the benchmark and got a different result. I hope I got it right this time but I am not certain I am still thinking clearly. Please let me know if you notice any stupid mistakes. Feb 8 '16 at 15:01
• It looks good to me, but then again I'm running on 2 hours of sleep and a can of soda at 7am ;) By the way, and I'm not suggesting you implement this here, do you know of a slick way to do something like highlighting the elements of a list, with the highlighting color changing based on their values? It would be a good way to instantly see the winner for tests like these. (I admit I ask more out of curiosity than practicality.) Feb 8 '16 at 15:43
• @Mr.Wizard, would you mind to check this method: Catenate /@ m. It will not beat Part but I'm not sure about other options. Feb 8 '16 at 16:52
• @garej What I found interesting was that relative performance seemed to vary by system so much. It's nice to see a new function (Catenate) be an improvement once in a while. My last row is very different: 0.0044, 0.0063, 0.11. Note though that Catenate is not compilable, which is why it loses out to Flatten on longer lists; it also why mapping it unpacks the list (to level 1 only), making further processing less efficient (unless repacked). Join unpacks to level 2; Sequence unpacks the whole array. Not sure why a difference in timing is not reflected on Mr.Wizard's computer. Feb 9 '16 at 13:52

You can use ArrayReshape. Either

ArrayReshape[mat, Most@Dimensions@mat]


or

ArrayReshape[mat, Dimensions[mat][[1 ;; 2]]]


It will keep a packed array packed, too.

• Readers of this answer can find some further discussion of using ArrayReshape to remove unwanted singleton list wrappings, e.g., {a] or {{a, b, c}} in this answer Aug 2 '16 at 12:51

Edit With m = RandomInteger[9, {3, 6, 1}]

Just for completeness:

Catenate /@ m


Just for diversity reasons

Apply[#&, m, {2}]
Apply[Sequence, m, {-2}]
Map[First, m, {2}]


Using @Mr.Wizard code I have updated the benchmark.

@MichaelE2 also noticed in comments that Catenate is not compilable.

• I get similar results, to within a scaling factor for my slow CPU. Interesting that Join is much worse on packed arrays! Feb 15 '16 at 20:22
• @SimonWoods, MichaelE2 in a comment says "that Join unpacks to level 2. Sequence unpacks the whole array". He gets similar results. I'm surprized that Catenate behaves so different within packed group. Feb 15 '16 at 21:12

You can also Apply Join at level 1 to your list:

m = RandomInteger[9, {2, 4, 1}]


{{{0}, {6}, {7}, {5}}, {{1}, {3}, {8}, {8}}}

Join @@@ m


{{0, 6, 7, 5}, {1, 3, 8, 8}}

• thanks @Mr. Wizard. Terser yet m // ## & @@@ # & /@ # &:)
– kglr
Feb 8 '16 at 17:12

I suggest Flatten[m, {Depth[m] - 1, 1}], where m is the matrix in question.

For example,

SeedRandom[1]; m = RandomInteger[99, {4, 5, 1}]

{{{80}, {14}, {0}, {67}, {3}},
{{65}, {23}, {97}, {68}, {74}},
{{15},{24}, {4}, {90}, {83}},
{{70}, {1}, {30}, {48}, {25}}}

Flatten[m, {Depth[m] - 1, 1}]

{{80, 14, 0, 67, 3},
{65, 23, 97, 68, 74},
{15, 24, 4, 90, 83},
{70, 1, 30, 48, 25}}


...and of course, there's always Transpose[]:

Transpose[{{{1}, {2}, {3}}, {{2}, {4}, {6}}}, {2, 3, 1}] // First
{{1, 2, 3}, {2, 4, 6}}


The Flatten[] equivalent is then

Flatten[{{{1}, {2}, {3}}, {{2}, {4}, {6}}}, {{1}, {3, 2}}]
{{1, 2, 3}, {2, 4, 6}}