Solo estoy aprendiendo MATLAB y me resulta difícil entender elfactores de rendimiento de bucles frente a funciones vectorizadas.

En mi pregunta anterior:nidado para bucles extremadamente lentos en MATLAB (preasignado) Me di cuenta de que el uso de una función vectorizada frente a 4 bucles anidados hizo un 7 veces la diferencia en el tiempo de ejecución.

n ese ejemplo, en lugar de recorrer todas las dimensiones de una matriz de 4 dimensiones y calcular la mediana para cada vector, fue mucho más limpio y rápido simplemente llamar mediana (stack, n) donde n significaba la dimensión de trabajo de la función mediana.

Pero la mediana es solo un ejemplo muy fácil y Solo tuve suerte que tenía estedimension parámetro implementado.

Mi pregunta es que ¿cómo se escribe una función que funciona de manera tan eficiente como una que tiene este rango de dimensión implementado?

Por ejemplo, tienes una funciónmy_median_1D que solo funciona en un vector 1-D y devuelve un número.

¿Cómo se escribe una funciónmy_median_nD que actúa como la mediana de MATLAB, tomando una matriz n-dimensional y una "dimensión de trabajo" parámetro?

Actualiza

Encontré el código para calcular la mediana en dimensiones superiores

% In all other cases, use linear indexing to determine exact location
% of medians.  Use linear indices to extract medians, then reshape at
% end to appropriate size.
cumSize = cumprod(s);
total = cumSize(end);            % Equivalent to NUMEL(x)
numMedians = total / nCompare;

numConseq = cumSize(dim - 1);    % Number of consecutive indices
increment = cumSize(dim);        % Gap between runs of indices
ixMedians = 1;

y = repmat(x(1),numMedians,1);   % Preallocate appropriate type

% Nested FOR loop tracks down medians by their indices.
for seqIndex = 1:increment:total
  for consIndex = half*numConseq:(half+1)*numConseq-1
    absIndex = seqIndex + consIndex;
    y(ixMedians) = x(absIndex);
    ixMedians = ixMedians + 1;
  end
end

% Average in second value if n is even
if 2*half == nCompare
  ixMedians = 1;
  for seqIndex = 1:increment:total
    for consIndex = (half-1)*numConseq:half*numConseq-1
      absIndex = seqIndex + consIndex;
      y(ixMedians) = meanof(x(absIndex),y(ixMedians));
      ixMedians = ixMedians + 1;
    end
  end
end

% Check last indices for NaN
ixMedians = 1;
for seqIndex = 1:increment:total
  for consIndex = (nCompare-1)*numConseq:nCompare*numConseq-1
    absIndex = seqIndex + consIndex;
    if isnan(x(absIndex))
      y(ixMedians) = NaN;
    end
    ixMedians = ixMedians + 1;
  end
end

¿Podrías explicarme quepor qué este código es tan efectivo en comparación con los bucles anidados simples? Tiene bucles anidados al igual que la otra función.

No entiendo ¿cómo podría ser 7 veces más rápido y también, quepor qué es tan complicado.

Update 2

Me di cuenta de que usar la mediana no era un buen ejemplo, ya que es una función complicada que requiere la clasificación de la matriz u otros trucos ingeniosos. Realicé nuevamente las pruebas con mean y los resultados son aún más locos: 19 segundos frente a 0,12 segundos. Significa que elbuilt en camino para la suma es 160 veces más rápido que los bucles anidados.

s realmente difícil para mí entender cómo puede un lenguaje líder en la industria tener una diferencia de rendimiento tan extrema en función del estilo de programación, pero veo los puntos mencionados en las respuestas a continuación.