# 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). Commented Feb 7, 2016 at 20:34
• Flatten /@ matrix Commented Feb 8, 2016 at 6:18
• Related: (20180) Commented Feb 8, 2016 at 9:10
• Catenate /@ m is also a fast option. Commented Feb 8, 2016 at 17:27

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! Commented Feb 8, 2016 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. Commented Feb 8, 2016 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.) Commented Feb 8, 2016 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. Commented Feb 8, 2016 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. Commented Feb 9, 2016 at 13:52

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>. Commented Feb 8, 2016 at 13:18
• (Is it polite/conventional to delete a comment such as mine above after the edit has been made?) Commented Feb 8, 2016 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. Commented Feb 16, 2016 at 13:57

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 Commented Aug 2, 2016 at 12:51

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}}

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! Commented Feb 15, 2016 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. Commented Feb 15, 2016 at 21: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}}