La eficiencia de los programas Jordi Linares Pellicer EPSA-DSIC

Índice General 1

Introducción .......................................................................................................................... 2

2

El coste temporal y espacial de los programas.................................................................... 2

3

2.1

El coste temporal medido en función de tiempos de las operaciones elementales .... 2

2.2

El coste como una función del tamaño del problema .................................................. 3

2.3

La función de coste temporal definida por conteo de pasos ....................................... 4

Complejidad asintótica.......................................................................................................... 4 3.1

Comparación de los costes de los algoritmos ............................................................. 4

3.2

Uso de la notación asintótica ....................................................................................... 6

3.2.1

Análisis por casos.................................................................................................... 6

3.2.2

Notación asintótica en el mejor y peor caso............................................................ 6

3.3

Reglas generales ......................................................................................................... 6

3.3.1

Análisis del coste de los algoritmos iterativos ......................................................... 7

3.3.2

Análisis del coste de los algoritmos recursivos ....................................................... 7

1

1 Introducción Habitualmente se dispone de varios programas que resuelven un mismo problema. Para decidir cuál es el mejor, un criterio objetivo de comparación es el de eficiencia: el programa más eficiente, el mejor, será aquel que menos recursos requiera para su ejecución. Visto que los recursos básicos de un ordenador son la memoria y el tiempo de CPU, la eficiencia de un programa se expresa en términos de: •

su coste espacial o medida del espacio que ocupa en memoria a lo largo de su ejecución; sería la suma de los tamaños de todas las variables que implícita o explícitamente se utilizan.

•

su coste temporal o una medida del tiempo empleado por éste para ejecutarse y dar un resultado a partir de los datos de entrada.

A partir de estas definiciones, los costes de un programa concreto dependen de dos tipos de factores. A saber, 1. Factores propios del programa utilizado, como son su estrategia de resolución o los tipos de datos que emplea. 2. Factores que dependen del entorno de programación donde se vaya a ejecutar el programa, como son el tipo de computador, el lenguaje de programación utilizado, el compilador que se utiliza, la carga del sistema, etc. Por tanto, se pueden seguir dos aproximaciones para establecer el coste de un programa dado: 1. Análisis teórico o a priori: cálculo del coste en función de los factores propios del programa, y por lo tanto, independiente del entorno de programación. 2. Análisis experimental o a posteriori: medida del tiempo, en segundos, y memoria, en bytes, empleados en la ejecución del programa: •

en un entorno de programación determinado y

•

para un conjunto de datos de entrada adecuado.

Es importante recalcar que ambos tipos de análisis son complementarios, y no excluyentes; realizar un análisis teórico de su coste evita en ocasiones implementaciones tan laboriosas como inútiles. Más aún, la eficiencia es un criterio a incorporar en la estrategia de diseño de un programa; independientemente del entorno donde se ejecute, un programa debe ser eficiente. En lo que resta nos centraremos exclusivamente en el estudio del coste temporal y espacial a priori de los programas.

2 El coste temporal y espacial de los programas 2.1 El coste temporal medido en función de los tiempos de las operaciones elementales Supongamos que se dispone de los siguientes algoritmos para calcular n*n, y el resultado dejarlo sobre la variable m: •

Algoritmo A1: m ← n*n;

•

Algoritmo A2: m ← 0; desde i ← 1 hasta n hacer m ← m+n; fin_desde

2

•

Algoritmo A3: m ← 0; desde i ← 1 hasta n hacer desde j ← 1 hasta n hacer m ← m+1; fin_desde fin_desde

Si se define el coste temporal de un algoritmo como la suma de los costes de las operaciones que implica, tenemos los costes siguientes: •

Coste del algoritmo A1: TA1 = ta + top donde ta es el coste de la operación de asignación y top es el coste de una operación aritmética, en concreto de una multiplicación.

•

Coste del algoritmo A2: TA2 = ta + ta + (n+1) * tc + n * ta + 2 * n * top donde tc es el coste de la comparación y top es en este caso el coste de la suma.

•

Coste del algoritmo A3: TA3 = ta + ta + (n+1) * tc + n * ta + n * (n+1) * tc + n2 * ta + 2 * n2 *top + n * top

Si queremos comparar los costes de estos algoritmos resulta bastante difícil, ya que los tiempos de las operaciones pueden variar significativamente en función del entorno de programación utilizado; por otra parte, el estudio de costes así planteado requiere un considerable esfuerzo de conteo. Una primera simplificación consiste en independizar las funciones de coste de los tiempos de ejecución de las operaciones elementales. De esta forma, las funciones de coste anteriores quedarían: •

Coste del algoritmo A1: TA1 = k1 de esta forma estamos indicando que el coste del algoritmo A1 es constante, independiente de n.

•

Coste del algoritmo A2: TA2 = k2 * n + k3 de esta forma indicamos que el coste del algoritmo va a depender de n de una forma lineal.

•

Coste del algoritmo A3: TA3 = k4 * n2 + k5 * n + k6 de esta forma indicamos que el coste del algoritmo va a depender de forma cuadrática de n.

2.2 El coste como una función del tamaño del problema El coste temporal (espacial) de un algoritmo se define como una función no decreciente de la cantidad de tiempo (espacio) necesario que el algoritmo necesita para realizarse en función del tamaño del problema. El tiempo necesario para ejecutar un algoritmo depende casi siempre de la cantidad de datos que tiene que procesar; es de esperar que, por ejemplo, ordenar 10.000 elementos requiera más tiempo que ordenar 10. La talla o tamaño de un problema se define precisamente como el valor o conjunto de valores asociados a la entrada de un problema que representan una medida de la dificultad de su resolución. Por ejemplo, el número de elementos de un vector que se desea ordenar, el valor del número del que quiere calcularse su factorial, etc. A partir de ahora, se notará el coste temporal de un algoritmo A como TA(talla); por ejemplo, el coste del algoritmo A2 se expresará como TA2(n).

3

2.3 La función de coste temporal definida por conteo de pasos Se define un paso de programa como cualquier secuencia de operaciones con significado, cuyo coste sea independiente del tamaño del problema. Un paso se puede considerar como una unidad de tiempo válida para expresar el coste de un algoritmo. A partir de esta definición se puede calcular el coste de un algoritmo como el número de pasos de programa que realiza. De esta forma, se independiza el análisis de costes del tiempo de las operaciones elementales. Utilizando esta definición, los costes de los algoritmos anteriores serían: •

Coste del algoritmo A1: TA1(n) = 1 paso

•

Coste del algoritmo A2: TA2 (n) = n + 2 pasos

•

Coste del algoritmo A3: TA3 (n) = n2 + n + 2 pasos

La decisión sobre qué es un paso en un determinado algoritmo o programa no es única; en cualquier caso, la única diferencia que podría haber entre diferentes análisis por pasos serían constantes multiplicativas o aditivas. En el apartado siguiente veremos cómo estas diferencias no tienen importancia en el estudio que se propone.

3 Complejidad asintótica 3.1 Comparación de los costes de los algoritmos El coste de un algoritmo se expresa como una función T(n) no decreciente de la talla del problema. Por lo tanto comparar costes es comparar funciones no decrecientes de las que nos interesa sólo su tasa de crecimiento. Por ejemplo, si T(n) es un polinomio, entonces el monomio de mayor grado del mismo es el que da el aspecto de la curva de crecimiento. En la siguiente tabla se muestran, en orden creciente de tasa de crecimiento, distintas funciones que describen comúnmente el tiempo de ejecución de los algoritmos. Función

Nombre

c

constante

logn

logarítmica

2

log n

logarítmica al cuadrado

n

lineal

nlogn

nlogn

n

2

cuadrática

n

3

cúbica

2

n

exponencial

Supongamos que se está descargando un fichero de Internet, de forma que hay un retraso inicial de 2 seg. para establecer la conexión y después la descarga se realiza a razón de 1.6 kbytes/seg. Si el tamaño del fichero es de N kbytes, el tiempo de descarga viene descrito por la fórmula lineal:

La descarga de un fichero de 80 kbytes requiere 52 seg., la descarga de un fichero el doble de grande requiere del orden de 102 seg, es decir casi el doble. Esta propiedad, por la cual el tiempo de ejecución es esencialmente proporcional al tamaño de la entrada, caracteriza a un algoritmo lineal. Como puede verse en las gráficas que se presentan a continuación, las curvas no lineales conducen a tiempos de ejecución mayores. Esto indica que el coste lineal es, de entre todos los que se muestran en estas gráficas, el más favorable.

4

Una función cúbica es una función cuyo término dominante es n3 multiplicado por alguna constante. Una función cuadrática tiene como término dominante n2 por alguna constante, y una función lineal tiene como término dominante n por alguna constante. El término dominante de la función nlogn es n veces el logaritmo de n; la función logaritmo crece muy lentamente, más lentamente que cualquier raíz. En las figuras siguientes se presentan cuatro funciones típicas en el análisis de algoritmos: lineal, nlogn, cuadrático y cúbico, sobre distintos tamaños del problema, la primera desde 1 hasta 100 y la segunda desde 1.000 hasta 10.000.

5

3.2 Uso de la notación asintótica Cuando se analiza el coste de un algoritmo, el objetivo es conocer sobre qué curva de coste se encuentra dicho algoritmo. También es necesario poder comparar estas curvas de costes con el fin de poder decidir si un determinado algoritmo es mejor, peor o equivalente a otro. Es por esto que lo que nos interesa es medir el índice de crecimiento de las funciones de coste y expresarlo en notación asintótica. Tres razones apoyan esta decisión: •

Para valores de n suficientemente grandes el valor de la función está completamente determinado por el término dominante.

•

El valor exacto del coeficiente del término dominante no se conserva al cambiar de entorno de programación.

•

El uso de la notación asintótica nos permite establecer un orden relativo entre funciones comparando términos dominantes.

3.2.1 Análisis por casos Como ya se ha comentado, el coste de un algoritmo es una función no decreciente de la talla del problema. Además, para un tamaño fijo del mismo, el coste del algoritmo puede depender de la configuración de la entrada del problema, de lo que llamaremos instancia del problema. Una instancia de un problema representa todas las configuraciones diferentes de la entrada, de una talla determinada, para las que el comportamiento del algoritmo es el mismo en cuanto a costes. Cuando en el coste de un algoritmo se detectan instancias, a partir de las instancias significativas se definen los siguientes conceptos: •

Coste del algoritmo en el caso peor: es la complejidad del mismo para la instancia del problema que presente el coste mayor.

•

Coste del algoritmo en el caso mejor: es la complejidad del mismo para la instancia del problema que presente el coste menor.

•

Coste promedio del algoritmo: a la media de los costes de todas las instancias del problema.

En general, el estudio del coste promedio de los algoritmos es difícil de realizar, tanto analítica como experimentalmente, la principal dificultad reside en conocer la distribución de probabilidad sobre las instancias del problema.

3.2.2 Notación asintótica en el mejor y peor caso •

Diremos que el coste de un algoritmo T(n) pertenece a O(g(n)) cuando T(n) no superará, para grandes tallas, un múltiplo de g(n). En otras palabras, T(n) no crece asintóticamente más rápido que g(n), es decir, g(n) por una constante es una cota superior de T(n).

•

Diremos que el coste de un algoritmo T(n) pertenece a Ω(h(n)) cuando T(n) superará, para grandes tallas, un múltiplo de g(n). En otras palabras, T(n) crece asintóticamente más rápido que h(n), es decir, h(n) por una constante es una cota inferior de T(n).

Por tanto, utilizaremos la notación asintótica O para catalogar el algoritmo en su comportamiento en el peor de los casos, y la notación Ω para el caso mejor: T(n) ∈ O(g(n))

=> T(n) es como máximo del orden de g(n)

T(n) ∈ Ω(h(n))

=> T(n) es como mínimo del orden de h(n)

Por último, si caso mejor y peor coinciden, podremos utilizar la notación Θ(g(n)).

3.3 Reglas generales Para el estudio del coste temporal de los algoritmos se seguirán los siguientes pasos:

6

•

Determinar el tamaño del problema; esto es, estudiar de qué parámetros va a depender el coste.

•

Analizar si, para un tamaño del problema fijo, existen instancias significativas para el coste.

•

Obtener la función de coste. Si existen instancias significativas, el estudio de costes se particularizará para el caso peor y el caso mejor. El estudio de costes en el caso peor da una cota superior para el coste del algoritmo, utilizaremos en este caso la notación O.

3.3.1 Análisis del coste de los algoritmos iterativos Una forma de obtener la función de coste de un determinado algoritmo iterativo consiste en contar el número de veces que se repite lo que llamaremos una instrucción crítica o instrucción barómetro. Una instrucción crítica en un determinado algoritmo es aquella que se ejecuta por lo menos con tanta frecuencia como cualquier otra del algoritmo. En realidad no hay problema si hay alguna instrucción que se ejecuta un número de veces constante más que el barómetro, ya que quedará absorbida en la notación asintótica. Ejemplo propuesto: Calcular el coste temporal en el peor y mejor caso en el algoritmo que nos permite buscar un elemento dentro de un vector.

3.3.2 Análisis del coste de los algoritmos recursivos En el caso del estudio del coste de los algoritmos recursivos, podemos utilizar para su resolución la relación de recurrencia utilizada a menudo como paso previo a la definición del algoritmo. Ejemplo propuesto: Calcular el coste temporal y espacial en el algoritmo del cálculo del factorial recursivo.

7