How to subtract the column means from each row of a matrix?

Question

Given a matrix, we want to subtract the mean of each column, from all entries in that column. So given this matrix:

 (mat = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}) // MatrixForm

the mean of each column is m = Mean[mat].

So the result should be

This operation is called centering of observations in data science.

The best I could find using Mathematica, is as follows:

mat = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
m = Mean[mat];
(mat[[All, #]] - m[[#]]) & /@ Range@Length@m // Transpose

But I am not too happy with it. I think it is too complicated. Is there a simpler way to do it? I tried Map and MapThread, but I had hard time getting the syntax to work.

In MATLAB, there is a nice function called bsxfun which is sort of like MapThread. Here is how it is done in MATLAB:

A = [1 2 3 4;5 6 7 8;9 10 11 12];
bsxfun(@minus, A, mean(A))

    -4    -4    -4    -4
     0     0     0     0
     4     4     4     4

It maps the function minus, taking one column from A and one element from mean(A). I think it is more clear than what I have in Mathematica. One should be able to do this in Mathematica using one of the map functions more easily and clearly than what I have above.

The question is: Can the Mathematica solution above be improved?

Answer 1

It is there:

Standardize[mat, Mean, 1 &]

Answer 2

Well, transposing, subtracting, transposing...

Transpose[Transpose[mat] - Mean[mat]]

Answer 3

mat - ConstantArray[Mean[mat], 3]

or more generally:

mat - ConstantArray[Mean[mat], Length[mat]]

Answer 4

# - Mean@mat & /@ mat // MatrixForm

Answer 5

If you don't mind the type of mat changes:

CircleMinus = Compile[{{a, _Real, 1}, {b, _Real, 1}}, a - b, RuntimeAttributes -> Listable]
mat⊖Mean@mat

$\left( \begin{array}{cccc} -4. & -4. & -4. & -4. \\ 0. & 0. & 0. & 0. \\ 4. & 4. & 4. & 4. \\ \end{array} \right)$

Answer 6

I was asked to post an answer based on a recently uncovered (at least, for me) undocumented function, Statistics`Library`MatrixRowTranslate, available in V10 and later. My feeling is that, at heart, it is essentially the same as Kuba's answer, which I will use this answer to explain. I will also shed some further light on Kuba's comment.

First, the function Statistics`Library`MatrixRowTranslate modifies the matrix in place, which is uncharacteristic of Mathematica. Here is a typical usage applied to the OP's problem:

mat = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Module[{res = mat},
  Statistics`Library`MatrixRowTranslate[res, -Mean[res]];
  res] // MatrixForm

In V11 (but not in V10, though the functionality exists), Kuba's Standardize[mat, Mean, 1 &] uses this call to shift mat by the mean, but it also rescales by the second function, which seems inefficient for the problem at hand. However, it turns out that rescaling by constant & is a special case that is implemented by dividing the translated matrix by constant. In case you didn't know, multiplying by 1 (not 1.) is also a special case, which the comparison below will show. Dividing by 1 in normal Mathematica means multiplying by the reciprocal Power[1, -1] and takes roughly twice as long as multiplication, unless you use Divide.

SeedRandom[0];
data = RandomReal[{0, 50}, {1*^7, 2}];
1*data; // RepeatedTiming
data/1; // RepeatedTiming
Divide[data, 1]; // RepeatedTiming
1.*data; // RepeatedTiming
data/2; // RepeatedTiming
(*
  {3.01*10^-7, Null}
  {5.2*10^-7, Null}
  {3.8*10^-7, Null}
  {0.063, Null}
  {0.062, Null}
*)    

So we should expect that the rescaling by 1 & in Kuba's answer to add a negligible amount of time to the overall time of the operation in V11:

mrt = Module[{res = data},
    Statistics`Library`MatrixRowTranslate[res, -Mean[res]];
    res]; // RepeatedTiming
(*  {0.139, Null}  *)

st = Standardize[data, Mean, 1 &]; // RepeatedTiming
(*  {0.139, Null}  *)

mrt == st     (* check *)
(*  True  *)

Answer 7

mat = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Transpose[Map[# - Mean[#] &, Transpose[mat]]]

which gives you

{{-4, -4, -4, -4}, {0, 0, 0, 0}, {4, 4, 4, 4}}

Answer 8

You might think of transposing your data. MATLAB naturally has the column as the basic subunit of the matrix, while Mathematica has the row.

Defining

(mat = Transpose[{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 
 12}}]) // MatrixForm

the (transpose) of the desired result is then

mat - Mean /@ mat // MatrixForm

Answer 9

Here is something a bit closer to the Matlab syntax

mat1=Partition[Range@12,4];
mat2 = ConstantArray[Mean[mat1], Length[mat1]];
binaryFunction = #1 - #2 &;

MapThread[binaryFunction, {mat1,mat2}]

Answer 10

TranslationTransform[- Mean @ mat] @ mat

{{-4, -4, -4, -4}, {0, 0, 0, 0}, {4, 4, 4, 4}}

Roughly comparable to Standardize in speed.

In versions 13.1.0+, you can also use Threaded:

mat - Threaded @ Mean @ mat

{{-4, -4, -4, -4}, {0, 0, 0, 0}, {4, 4, 4, 4}}

Answer 11

Mike's answer (the accepted one), almost implements bsxfun, taking listability for granted, like this

bsxfunListable[listableFu_, mat_, vec_] :=
 listableFu[mat, ConstantArray[vec, Length@mat]];

bsxfun[Subtract, mat, Mean@mat]

We can generalise the function like this

bsxfun[fu_, mat_, vec_] :=
 Thread @@ {Unevaluated @@ 
    fu @@@ Hold@Evaluate@{mat, ConstantArray[vec, Length@mat]}}

bsxfun[Subtract, mat, Mean@mat]

Answer 12

In addition:

Inner[Subtract, mat, Mean[mat],List]
(* {
    {-4, -4, -4, -4}, 
    {0,   0,  0,  0}, 
    {4,   4,  4,  4}
   }  *)

Inner[Subtract, mat, {a,b,c,d},List]

(* {
    {1 - a,  2 - b,  3 - c,  4 - d}, 
    {5 - a,  6 - b,  7 - c,  8 - d}, 
    {9 - a, 10 - b, 11 - c, 12 - d}
   }  *)