Using ReplacePart:

In[3]:= RandomReal[1, {4, 4}]

Out[3]= {
{0.419275, 0.63595, 0.465362, 0.14065}, 
{0.958899, 0.166556, 0.627401, 0.269303}, 
{0.214548, 0.722121, 0.344397, 0.193365}, 
{0.0503304, 0.670185, 0.805489, 0.0130992}}

In[4]:= ReplacePart[%, {i_, i_} :> 0]

Out[4]= {
{0, 0.63595, 0.465362, 0.14065}, 
{0.958899, 0, 0.627401, 0.269303}, 
{0.214548, 0.722121, 0, 0.193365}, 
{0.0503304, 0.670185,  0.805489, 0}}

Exactly, I did not suggest ReplacePart[m, {i_, i_} :> 0] because it runs on n^2. Wasn't the idea to use something that runs on a linear diagonal number of elements ~n? Plus something more efficient than patterns that are slow. @Itai are we missing something here?

Thank you all for your suggestions. This have been forwarded to internal teams. Feel free to add more design suggestions. If you have any ideas about syntax or options feel free to note those too.

@Hans Milton

That is a good solution for this specific matrix.

However, if you had m = ConstantArray[1.0, {4, 4}], with a floating point 1.0 instead of an integer 1, then it would unpack. Unless you use 0. instead of 0 in the ReplacePart.

The reason why I would like a function for this is that I found that I need this operation quite frequently. Your solution is still a bit too wordy for frequent use. That's usually no problem—I just wrap it up in a function and put it in a personal package. But in this case writing a function that is performant and general seems to be a lot of trouble.

Here's how I would try to generalize your and Sander's solution:

zeroDiagonal[mat_ /; Developer`PackedArrayQ[mat, Real, 2]] := ReplacePart[mat, Array[{#, #} &, Min@Dimensions[mat]] -> 0.0]
zeroDiagonal[mat_ /; Developer`PackedArrayQ[mat, Integer, 2]] := ReplacePart[mat, Array[{#, #} &, Min@Dimensions[mat]] -> 0]
zeroDiagonal[mat_ /; Developer`PackedArrayQ[mat, Complex, 2]] := ReplacePart[mat, Array[{#, #} &, Min@Dimensions[mat]] -> Complex[0., 0.]]
zeroDiagonal[mat_?MatrixQ] := ReplacePart[mat, Array[{#, #} &, Min@Dimensions[mat]] -> 0]

This already seems quite complicated (and uses arcane functions) yet at this point is still doesn't handle the type detection as well as UpperTriangularize does.

It would be nice to have good type detection at least for SparseArrays, which tend to be type-homogeneous (and probably use packed arrays under the hood, as does the MSparseArray LibraryLink type.

Unpacking can be easily detecting by evaluating On["Packing"].

O btw, whilst looking for new ideas I forgot about optimizing my Array part of the code in the ReplacePart implementation. I chose Array mostly because I didn't want to get another Range[Length[mat]] kinda code... However, there is some speed difference by using Table, Array, Range et cetera. So to put it to test, we benchmark it:

Needs["Benchmarking`"]
fs={
Map[{#,#}&,Range[#]]&,
Array[{#,#}&,#]&,
Table[{i,i},{i,#}]&,
Transpose[{Range[#],Range[#]}]&,
Transpose[{#,#}]&[Range[#]]&
};
GeneralUtilities`BenchmarkPlot[fs,Round,PowerRange[2,5000,1.25],"IncludeFits"->True,Frame->True]

on my computer this looks like:

as you can see, a Range-Transpose kinda solution is faster apart from tiny n, moreover you don't have problems with compilations that kick in or so like Map/Array/Table solutions...

That's a neat way of doing it. I was unaware of those two related functions! It, however, does not perform so good; probably because of the n^2 operations... A real good solution should scale as n, not n^2 in my opinion..

mat=RandomInteger[10,{1000,1000}];
RepeatedTiming[newmat1=UpperTriangularize[mat,1]+LowerTriangularize[mat,-1];]
RepeatedTiming[newmat2=ReplacePart[mat,Array[{#,#}&,Length[mat]]->0.0];]

mat=RandomInteger[10,{1000,1000}];
mat[[2,3]]=\[Infinity];
RepeatedTiming[newmat1=UpperTriangularize[mat,1]+LowerTriangularize[mat,-1];]
RepeatedTiming[newmat2=ReplacePart[mat,Array[{#,#}&,Length[mat]]->0.0];]

Depending if it is packed or not, one is faster than the other..

I've done it once using:

mat = RandomReal[1, {100, 100}];
newmat = mat - DiagonalMatrix[Diagonal[mat]];

keeps it packed if mat is packed, it is short and reasonably legible... Of course this does do n^2 operations while only n are necessary...

But I see other options:

mat=RandomReal[1,{10,10}];
RepeatedTiming[newmat=mat-DiagonalMatrix[Diagonal[mat]];]
RepeatedTiming[newmat2=mat(1-IdentityMatrix[Length[mat]]);]
RepeatedTiming[newmat3=ReplacePart[mat,Array[{#,#}&,Length[mat]]->0.0];]
RepeatedTiming[newmat4=(tmp=mat;Do[tmp[[i,i]]=0.0,{i,Length[tmp]}];tmp);]
newmat==newmat2==newmat3==newmat4

or with integers:

mat=RandomInteger[100,{10,10}];
RepeatedTiming[newmat=mat-DiagonalMatrix[Diagonal[mat]];]
RepeatedTiming[newmat2=mat(1-IdentityMatrix[Length[mat]]);]
RepeatedTiming[newmat3=ReplacePart[mat,Array[{#,#}&,Length[mat]]->0];]
RepeatedTiming[newmat4=(tmp=mat;Do[tmp[[i,i]]=0,{i,Length[tmp]}];tmp);]
newmat==newmat2==newmat3==newmat4

depending on the size of the matrix and the contents (partially symbolic, or packed or ...) one might be faster than the other.

Any idea about the name of the function and the implementation? I see several ways:

newmat = SetDiagonal[mat, a]

where a is a single element or a list.

or a Span-kinda implementation:

mat[[{1,1};;]] = 0

Where we now iterate (like a span) over 2 things at the same time. but might be a bit too confusing syntax. Another symbol (like span) is also possible of course:

mat[[Diagonal[k]]] = 0

where k must be in integer such as to not destroy Diagonal functionality, it merely acts as a wrapper...

Blinder's code does not work in general this time, as an arbitrary-value matrix may contain duplicate entries. Similar functionality is given by ReplacePart. In timing tests, ReplacePart performs relatively slow compared to direct / read write as suggested by Ungureanu:

DiagonalData = RandomReal[10, 1000];
MatrixData = RandomReal[1, {1000, 1000}];
Mean[AbsoluteTiming[
    Table[MatrixData[[i, i]] = DiagonalData[[i]], {i, 1000}];
    ] & /@ Range[100]]
Mean[AbsoluteTiming[ReplacePart[MatrixData,
       Table[Rule[{i, i}, DiagonalData[[i]]], {i, 1, 1000}]];
     ][[1]] & /@ Range[100]]

Out[] = .002
Out[] = .005

We are talking about a linear-complexity algorithm with one operation. In many it will not be the bottleneck in an algorithm. However, I agree that this could be a place for fundamental improvement, but why the air of mystery? Do you have timing data that supports your claim? If so, I think the burden is on you to give a procedure and / or show your results. Instead it seems like you call out the victims to show off their ignorance. How is that going to build support or help your case?

Edit: Bill Simpson, watch out, it's a trap! Horvat could retort with something along the lines of:

AbsoluteTiming[ MatrixData - DiagonalMatrix[Diagonal[MatrixData]] +  DiagonalMatrix[DiagonalData]; ]
Out[]=0.02

which is an order of magnitude slower than other methods above.

Brad

Construct a matrix n x n of random numbers and replace the diagonal element i with the equivalent roman numeral:

n = 10;
givenValues = Table[RomanNumeral[i], {i, n}];
matrix = Table[Random[], {i, n}, {j, n}];
Do[matrix[[i, i]] = givenValues[[i]], {i, n}];
matrix // MatrixForm