unneeded (often undocumented) exports

[vtjnash]

I propose deprecating the following exports (the definitions will remain in base):
ldltd and ldltd! (implementation of factorize for SymTridiagonal)
solve (implementation of \ for some types)
symmetrize! (specialized function, only one of several possible ways to symmetrize a matrix, symmetrize_conj! is not exported, non-mutating variants don't exist)

[timholy]

Maybe solve should stay in cases where it really should be called solve!? (for pre-allocated outputs) Unless you think \! is clearer? (I worry it could be confused for an "escaped" !.)

[johnmyleswhite]

I use symmetrize! all the time.

Even though \! is a little cryptic, I'd prefer it over exporting solve/solve! to minimize duplicate names.

[timholy]

To clarify, I don't think we need solve (it's covered by \). Whether we choose solve! or !\, I'm fine either way.

[StefanKarpinski]

If we can support it in the parser reasonably, I think that \! has the advantage of having an obvious relationship to \.

[JeffBezanson]

I'm not sure I want to go down the road of \!, *!, ...

[johnmyleswhite]

I'll be the first to admit that \! and *! are horrible looking, but we need to pick some consistent interface for this and the exclamation suffix seems to be our best bet so far. In the end, I will be happy with any systematic solution.

[vtjnash]

@johnmyleswhite do you need this specific version of symmetrize!? For example, in the past I've used A'A or A'+A for this purpose. I'm mainly interested in whether there is a better name for that function -- such as symreflect! -- and if symmetrize_conj! (or whatever the name is) should also be exported

[johnmyleswhite]

My feeling is that we should export several methods for symmetrizing a matrix, but that there should be a sensible default called symmetrize!.

[StefanKarpinski]

I am not a fan of this function because there is no one obvious way to symmetrize a matrix. Without looking at the code, I cannot guess what this function does. Does it copy the upper triangular half over the lower? Does it do the moral equivalent of A += A' in place? (We really need a notation for that.) If one of those is what you want, we should just make sure it's easy to express each of those operations rather than picking an arbitrary one.

[johnmyleswhite]

I've been increasingly won over to the idea that =: should be our in-place operator so that A =: B + C is equivalent to add!(A, B, C). Having notation for the transpose case seems substantially harder.

[StefanKarpinski]

I'm not at all into =: as an operator. I would prefer .= or := instead – the .= seems better to me since it doesn't invoke the historical baggage associated with :=.

[johnmyleswhite]

I'm fine with anything real. The traditional use of ! as negation is what really screwed us over here, since the only really good notation would be !=. For me what matters is that 0.3 have any standard at all for translating something like A, B, C .= solve(D, E, F) into solve!(A, B, C, D, E, F).

[kmsquire]

+1 for .=