# Can Mathematica Operators be combined in a linear fashion for readability? [duplicate]

Here's a simple example. Suppose we want to find the off-diagonal matrix of m:

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


This can be solved fairly simply by extracting a list of the diagonal elements, re-creating the diagonal matrix from these, and removing them from the full matrix to get the off-diagonal elements:

m - DiagonalMatrix[Diagonal[m]]


to get

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


Now, this was a fairly simple solution to the given problem, but what I'm wondering is if there is a way to write something akin to

(Identity - DiagonalMatrix@Diagonal)[m]


To get the same result. In this simple example, not much would be gained by doing this, but I just thought it could be interesting in more complicated problems and help make the code resemble more closely the underlying mathematics in some cases.

• # - DiagonalMatrix[Diagonal[#]] &[m] ? Of course you can add Identity[#] at the beginning. – Kuba Feb 18 '14 at 20:39
• Also look at Composition for chaining long functions. It will greatly improve the clarity of your code. – rm -rf Feb 18 '14 at 20:45
• You should look at Through too, e.g. Through[(f + g + h)[x]] gives f[x] + g[x] + h[x]. – Simon Woods Feb 18 '14 at 21:32
• @Steve It doesn't work for two reasons: @ doesn't denote function composition, but function application (use Composition for function composition) and because Through only goes in one level while here we actually have an expression of the form (a + (-1)*b), not of a simpler form a-b. I'm afraid there's no easy and simple solution to your problem other than building pure functions as in (Identity[#] - DiagonalMatrix@Diagonal[#]) &[m]. – Szabolcs Feb 18 '14 at 22:42
• Following Rojo's idea, you can do operatorApply[f_[x__]] := Replace[f, s_Symbol :> s[x], {0, Infinity}, Heads -> False]. See where this goes wrong: operatorApply[(Sin + 1)[x]] transforms to Sin[x]+1, all is fine. Now what about operatorApply[(Sin + Pi)[x]]? You get Pi[x] + Sin[x], wrong! This is probably why it's not a built-in function. I don't see a good way around this problem, i.e. it's not a problem with my implementation but an inherent problem to the idea: it's not possible to distinguish functions from other symbols, e.g. constants. – Szabolcs Feb 18 '14 at 23:35

In version 10 we can use the new shorthand notation for Composition to write
Through@(Identity + Minus@*DiagonalMatrix@*Diagonal)[m]

As noted in the comments, Through@(a - b)[x] won't work the way we'd like because a - b is represented internally as a + (-1)*b. Composing with Minus gets around this problem.