De manera amigable con la memoria caché y más rápida – `InvokeMe()`
Estoy tratando de averiguar si este realmente es el enfoque más rápido. Quiero que esto sea lo más rápido posible, que sea compatible con caché y que tenga una buena complejidad temporal.
DEMO: https://dotnetfiddle.net/BUGz8s
private static void InvokeMe()
{
int hz = horizontal.GetLength(0) * horizontal.GetLength(1);
int vr = vertical.GetLength(0) * vertical.GetLength(1);
int hzcol = horizontal.GetLength(1);
int vrcol = vertical.GetLength(1);
//Determinar los valores verdaderos a partir de la información horizontal:
for (int i = 0; i < hz; i++)
{
if(horizontal[i / hzcol, i % hzcol] == true)
System.Console.WriteLine("Verdadero, en la posición: {0},{1}", i / hzcol, i % hzcol);
}
//Determinar los valores verdaderos a partir de la información vertical:
for (int i = 0; i < vr; i++)
{
if(vertical[i / vrcol, i % vrcol] == true)
System.Console.WriteLine("Verdadero, en la posición: {0},{1}", i / vrcol, i % vrcol);
}
}
Páginas que he leído:
- https://stackoverflow.com/questions/49429613/is-there-a-faster-way-to-iterate-through-a-two-dimensional-array-than-using-ne/49430288
- https://stackoverflow.com/questions/997212/fastest-way-to-loop-through-a-2d-array
- https://stackoverflow.com/questions/10344834/time-complexity-of-a-nested-for-loop-that-parses-a-matrix
- https://stackoverflow.com/questions/11094330/determining-the-big-o-runtimes-of-these-different-loops
davy.ai
Después de revisar el código proporcionado e investigar las mejores prácticas para iterar a través de matrices bidimensionales, es posible optimizar el enfoque actual para lograr una mejor complejidad temporal y eficiencia de caché.
Actualmente, el código utiliza dos bucles separados para iterar a través de las matrices bidimensionales “horizontal” y “vertical”, respectivamente. Esto resulta en una complejidad temporal de O(n^2), donde n es el tamaño de las matrices. Además, acceder a la memoria de manera no secuencial puede afectar negativamente el rendimiento de la caché.
Un enfoque para mejorar el rendimiento es combinar los dos bucles en un solo bucle anidado. Esto se puede lograr iterando simultáneamente a través de cada fila y columna, y verificando los valores respectivos en ambas matrices al mismo tiempo. Esto reduce la complejidad temporal a O(n) y asegura que el acceso a la memoria sea secuencial, mejorando el rendimiento de la caché.
Aquí tienes un ejemplo de código actualizado:
Este enfoque no solo mejora el rendimiento sino que también simplifica el código eliminando código redundante y mejorando la legibilidad.
En general, es importante considerar el rendimiento y la complejidad temporal al trabajar con estructuras de datos grandes. Al optimizar algoritmos y utilizar las mejores prácticas para el acceso a la memoria, podemos lograr un código más rápido y eficiente.