Aplicar função para o triângulo inferior de uma matriz 2-d

Uma abordagem ingênua que faz mais trabalho do que o necessário é calcular toda a diferença e selecionar os elementos necessários:

np.where(np.arange(U.size)[:, None] > np.arange(U.size), U[:, None] - U, np.nan)

Esta é uma das ocasiões em que np.whereé realmente útil usar uma máscara simples, embora também possa ser feito com uma máscara:

result = np.full((U.size, U.size), np.nan)
index = np.arange(U.size)
mask = index[:, None] > index
result[mask] = [U[:, None] - U][mask]

Uma abordagem mais eficiente pode ser usar os índices mais diretamente para indexar na fonte:

result = np.full((U.size, U.size), np.nan)
r, c = np.tril_indices(U.size, k=-1)
result[r, c] = U[c] - U[r]

Não é muito eficiente, mas possui apenas algumas linhas de código:

• Calcular a matriz completa por meio de um u.
• Defina o triângulo superior e a diagonal como nan.

import numpy as np

u = np.array([3, 5, 7, 9, 11], dtype=float)

result = u - u[:, np.newaxis]
result[np.triu_indices(len(u), k=0)] = np.nan
print(result)
# [[nan nan nan nan nan]
#  [-2. nan nan nan nan]
#  [-4. -2. nan nan nan]
#  [-6. -4. -2. nan nan]
#  [-8. -6. -4. -2. nan]]

Aqui estão os resultados de tempo usando a resposta aceita como base – a versão que usa wheree a versão que usa mascaramento parecem ter uma vantagem para tamanhos menores; as diferenças parecem cada vez mais insignificantes para tamanhos maiores:

Código usado para cronometragem (observe que troquei a ordem de subtração por baseline_where()e baseline_mask()para estar de acordo com a pergunta do OP, também corrigi um erro de digitação ( (…)[mask]em vez de […][mask]) em baseline_mask():

import matplotlib.pyplot as plt
import numpy as np
from timeit import Timer

def proposed(U):
    result = U.astype(float) - U[:, np.newaxis]
    result[np.triu_indices(len(U), k=0)] = np.nan
    return result

def baseline_where(U):
    return np.where(np.arange(U.size)[:, None] > np.arange(U.size),
                    U - U[:, None], np.nan)

def baseline_mask(U):
    result = np.full((U.size, U.size), np.nan)
    index = np.arange(U.size)
    mask = index[:, None] > index
    result[mask] = (U - U[:, None])[mask]
    return result

def baseline_direct_indexing(U):
    result = np.full((U.size, U.size), np.nan)
    r, c = np.tril_indices(U.size, k=-1)
    result[r, c] = U[c] - U[r]
    return result

rand = np.random.default_rng(seed=42)
n = 100  # number of timing runs
sizes = np.round(np.logspace(0, 4, num=9)).astype(int)
timings = {}
for size in sizes:
    u = rand.integers(100, size=size)
    for fct in proposed, baseline_where, baseline_mask, baseline_direct_indexing:
        fct_name = fct.__name__
        fct_timings = timings.get(fct_name, [])
        fct_timings.append(Timer(lambda: fct(u)).timeit(n))
        timings[fct_name] = fct_timings

plt.loglog()
plt.xlabel("len(U)")
plt.ylabel(f"calculation time ({n=} runs) (s)")
for fct_name, fct_timings in timings.items():
    plt.plot(sizes, fct_timings, "x", label=fct_name)
plt.legend()