Should scalar divided by matrix be allowed?

[bsxfan]

Given a square (invertible) matrix D and a scalar s, the operations s/D and D\s are not allowed in Julia. I’d like to give some arguments both in favour and against allowing these operations. Some related discussion can be found here and here. (My interest in this question stems from our current work on a macro that allows a convenient syntax for calling inplace operations such as BLAS.trsm.)

Although s\D and D/s are disallowed, all of the following can be done successfully in Julia:

using LinearAlgebra
D = randn(3,3); N = randn(3,3); s = randn()
inv(D)*s
D \ (s*N)
D \ 2N
D \ N*s
s*inv(D)
N*s/D

however, the following variants fail:

D \ s*N
D \ 2*N

because they are parsed from left to right and attempt D\s before multiplying by N.

As pointed out in the discussions cited above, a scalar can be divided by a vector, which results in (a multiple of) the pseudoinverse of the vector. That is, the following can be done successfully:

v = randn(3)
@assert s/v ≈ s*pinv(v)
@assert v'\s ≈ s*pinv(v')

However, the following variants fail:

v \ s
s / v'
s / randn(2,3)

even though all of the above denominators do have pseudoinverses (the pseudoinverse always exists).

My argument in favour of more generally allowing the division of scalars by matrices is therefore one of consistency.

However, there is also a good argument for the case against: In general, D\(s*N) is both faster and more accurate than inv(D)*s*N. If D\s were to be implemented as s*inv(D), or s*pinv(D), then D\s*N would end up doing the slower, inaccurate calculation. (The MATLAB editor will usually warn the programmer about attempts to multiply inverses.)

I think therefore, for fast accurate Julia, scalar divided by matrix should remain disallowed and perhaps to improve consistency, scalar / vector should be deprecated.

[Tamas_Papp]

@bsxfan

My argument in favour of more generally allowing the division of scalars by matrices is therefore one of consistency .

In the name of consistency, instead of extending it, I would suggest removing the pseudoinverse / magic for vectors. It is a bad pun, and just causes confusion. Cf

Feature or Bug? - Divide by zeros: 1/0 vs [1]/[0]

Before I open an Issue, I would like to discuss this question. The core of the question is the following difference: julia> 1 / 0 Inf julia> [1] / [0] 1×1 Array{Float64,2}: 0.0 In my method this lead to a problem as discovered here, because I use the left division with a non-square matrix, which can be full of zeros in some special situation. I supposed that as a tends to zero [1]/[a] tends to infinity julia> [1] / [0.01] 1×1 Array{Float64,2}: 100.0 julia> [1] / [0.001] 1×1 Array{Float64,2…

Users who want a pseudoinverse should explicitly ask for it.

Also, are you aware of LinearAlgebra.I? Eg (2*I)/randn(3,3) etc.

[bsxfan]

@Tamas_Papp, Please see the last paragraph in my post—we are in agreement about deprecation of scalar divided by vector. But thanks also for the other example, which reinforces the case for this deprecation.

[Tamas_Papp]

Thanks, I missed that. The way your post is organized is a bit confusing: first you argue for something we don’t have, then conclude we don’t need it.

[dlfivefifty]

Agree as someone who was never a Matlab user the behaviour of \ is strange and inconsistent: it’s annoying that it returns a wrong answer instead of erroring out or returning NanN/Inf when you really want the inverse, and it’s not not even always the pseudo-inverse: sometimes it does error out when you do want the pseudo-inverse!