Un algoritmo es un conjunto finito de instrucciones o pasos que sirven para ejecutar una
tarea y/o resolver un problema. De un modo ms formal, un algoritmo es una secuencia
finita de operaciones realizables, no ambiguas, cuya ejecucin da una solucin de un problema en un tiempo finito. El trmino algoritmo no est exclusivamente relacionado con la matemtica, ciencias de la computacin o informtica. En realidad, en la vida cotidiana empleamos algoritmos en multitud de ocasiones para resolver diversos problemas. Algunos ejemplos son el uso de una lavadora (se siguen las instrucciones, pero no la preparacin de una comida (porque no estn perfectamente definidos los pasos. Tambin existen ejemplos de ndole matemtica, como el algoritmo de la divisin para calcular el cociente de dos nmeros, el algoritmo de Euclides para calcular el mximo comn divisor de dos enteros positivos, o incluso el mtodo de Gauss para resolver Sistema lineal de ecuaciones. Un algoritmo numrico es el conjunto de instrucciones ordenadas para resolver un problema que involucra procesos matemticos (con calculo de formulas de manera repetida. Este tipo de algoritmos no admiten ambigedades y debe darse cada uno de los pasos para su solucin. Se define el concepto de algoritmo numrico. Se presentan varios casos de problemas numricos, se dan sus soluciones en forma algortmica y se agrega en cada caso una representacin en forma de diagrama de flujo. La nocin de algoritmo aparece en numerosas y dismiles situaciones de la vida cotidiana y es manejada por una gran cantidad de personas, algunas de las cuales ni tan siquiera conocen su existencia. De manera informal, un algoritmo puede definirse como una lista de instrucciones mediante las cuales puede llevarse a cabo un determinado proceso. Los mtodos numricos permiten resolver problemas obteniendo aproximaciones para las soluciones mediante algoritmos iterativos. Estos algoritmos reciben el nombre de algoritmos numricos. Las aproximaciones resultan de mucha utilidad cuando las soluciones analticas o algebraicas resultan muy difciles o hasta imposibles de obtener empleando mtodos tradicionales. Los computadores ayudan en gran manera, al facilitar la programacin de los algoritmos basados en iteracin. En esta seccin se presentan ejemplos de estos mtodos. 1.1 Ejemplo: Clculo de e mediante serie infinita Programa que calcula el valor de la constante e, base de los logaritmos neperianos. Se hace una aproximacin empleando la siguiente serie infinita: e = 1 + 1/1! + 1/2! + 1/3! + 1/4! + El clculo se detiene cuando el valor acumulado de e, no se logra diferenciar (por la precisin del computador, del valor calculado en la iteracin anterior. Es decir, cuando el siguiente trmino a sumar es tan pequeo que el computador lo considera como un cero. El factorial, representado por ! en la serie, se implementa en el programa mediante una funcin. Una vez que se calcula la aproximacin, el programa despliega el valor encontrado, as como el nmero de iteraciones que se emplearon para obtenerlo, es decir, la cantidad de trminos de la serie que fue necesario sumar para llegar a la aproximacin. /***************************************************************************
* Ejemplo: Calculo de la constante e mediante una serie infinita
* Funcin que calcula el factorial de su argumento. Tanto el argumento de * entrada (x como el valor de retorno son de tipo double. No se hacen * controles sobre la validez del argumento, cuyo valor debe ser > 0. * Cualquier valor de entrada 0 o negativo arrojara un resultado de 1. * Formula del factorial: x! = 1 * 2 * 3 * * (x-1 * x
public class C Calculate E { public double iter; public C Calculate E( { iter = 1; } private double mFactorial(double x { double i; // Factor actual de multiplicacin: 2, 3, , x double fact = 1.0; // Acumulador para el resultado, inicialmente 1 // Ciclo en el que se calcula el factorial: i variara de 2 a x for (i=2.0; i<=x; i++ // Se multiplica el acumulado actual por el factor actual (i fact = fact * i; // Devuelve como valor de retorno el resultado acumulado return(fact; } public double mGetE( { double e = 1, eanterior; do{ eanterior = e; e += 1/mFactorial(iter; iter++; }while( e != eanterior; return e; } } /*************************************************************************** * Programa que calcula el valor de la constante e, base de los logaritmos * neperianos. Se emplea una aproximacin de la siguiente serie infinita: * e = 1 + 1/1! + 1/2! + 1/3! + 1/4! + * El clculo se detiene cuando el valor acumulado de e, no se logra * diferenciar (por la precisin del computador, del valor calculado * en la iteracin anterior. ***************************************************************************/ public class C Main? { public static void Main( { C Calculate E ce = new C Calculate E(; Console.Write Line?(El valor de E es: {0},ce.mGetE(; Console.Write Line?(Se emplearon {0} iteraciones.,ce.iter; } } Ejemplo de ejecucin: Valor de e: 2.718281828459045534884808148490265011787000000000 Se emplearon 19 iteraciones
Ejemplo: Clculo de e a la x, mediante serie, comparando con funcin exp( Programa que calcula e**x (e elevado a la x, haciendo una aproximacin mediante una serie infinita. Se siguen sumando trminos mientras la diferencia entre el valor aproximado y el valor devuelto por la funcin exp( de la biblioteca math de C, sea mayor que una precisin dada por el usuario. La serie empleada es: Serie empleada: e**x = 1 + (x**1 / 1! + (x**2 / 2! + (x**3 / 3! + El factorial, representado por !, y el operador de potencia, representado por **, se implementan en el programa mediante funciones. Una vez obtenida la aproximacin, el programa despliega el valor calculado, y el nmero de iteraciones que se emplearon para llegar a l, es decir, el nmero de trminos que fue necesario sumar. /*************************************************************************** * Ejemplo: Calculo de e**x (e elevado a la x, empleando serie infinita * *************************************************************************** using System; public class C Eelevado X? { public double iter; public double res; public double exacto; public double precision; // Constructor de la clase C Eelevado X? public C Eelevado X?(double pres { precision = pres; iter = 1; res = 1; } // Miembro privado ya que solo se usa dentro de la clase private double mFactorial(double x { double i; double fact = 1; for (i=2.0; i<=x; i++ fact = fact * i; return(fact; } // Miembro privado ya que solo se usa dentro de la clase private double mPotencia(double x, double n { double i; double pot; pot = x; for (i=2; i<=n; i++ pot = pot * x; return(pot; } // Miembro pblico ya que se llama desde afuera de la clase para calcular e**x public double mGetEX(double power { exacto = Math.Exp(power; do { res += mPotencia(power,iter/mFactorial(iter; iter++; } while((exacto - res >= precision; return res; } } public class C Main? { public static void Main( { double pres,x; Console.Write(Ingrese la potencia: ; x = Double.Parse(Console.Read Line?(; Console.Write(Ingrese la precisin: ; pres = Double.Parse(Console.Read Line?(; // Nueva instancia de la clase C Eelevado X? C Eelevado X? ex = new C Eelevado X?(pres; ex.mGetEX(x; Console.Write Line?(El valor de e^x de System.Math es: {0},ex.exacto; Console.Write Line?(El valor de e^x con {0} iteraciones y precisin de {1} es: {2}, ex.iter,ex.precision,ex.res; } }
Ejemplo de ejecucin: Ingrese el valor de x: 5 Ingrese la precision para el calculo de e(x: 0.01 Valor exp(x de <math.h>: 148.413159102576600000000000000000000000000000000000 Calculo de e(x con precision 1.000000e-002: 148.410210275043060000000000000000000000000000000000 Se emplearon 17 iteraciones Ingrese el valor de x: 5 Ingrese la precision para el calculo de e(x: 0.000001 Valor exp(x de <math.h>: 148.413159102576600000000000000000000000000000000000 Calculo de e(x con precision 1.000000e-006: 148.413158521647740000000000000000000000000000000000 Se emplearon 23 iteraciones
Ejemplo: Clculo de a elevado a la x (a**x, mediante series, con la mxima precisin posible Programa que calcula a**x (a elevado a la x, haciendo una aproximacin mediante una serie, con la mxima precisin que el lenguaje C puede calcular, esto es, hasta que los resultados alcanzados por la serie converjan en un mismo valor. Se siguen calculando trminos de la serie mientras no exista diferencia entre un valor aproximado y el siguiente valor aproximado. La serie empleada es: a**x = 1+x*logE(a+((x*logE(a**2/2!+((x*logE(a**3/3! + Elevar un nmero a una potencia, es representado en el texto por ** (lo cual no es una sintaxis vlida en C#. Una vez obtenida la aproximacin, el programa despliega el valor calculado. // Clculo de a elevado a la x (a**x con la mxima precisin posible en C#. // los valores de a y x deben ser mayores que cero // se sabe que a**x = 1 + x * logE(a + ((x * logE(a**2/2! + ((x * logE(a**3/3! + // y que logE(x = 2 [(x-1/(x+1 + 1/3((x-1/(x+1**3 + 1/5((x-1(x+1**5 - // // Recuerde que: (a**n = a * (a**(n-1 using System; public class CA Elevado X? { private double mLogE(double x { double basem,bas,res,resa,rep; bas = (x-1.0/(x+1.0; basem = bas; res = bas; rep = 3.0; do { resa = res; basem = basem * bas * bas; res = res + (1/rep*basem; rep += 2.0; } while (res != resa; return(2*res; } Intro. Prog. Orientada a Objeto Algoritmos Numricos Rodrigo Sandoval U. private double mFactorial(int x { int i; double fact = 1; for (i=2; i<=x; i++ fact = fact * i; return fact; } public double mPower(double a, double x { double res,resa,bas,basem; int rep; bas = x * mLogE(a; basem = bas; rep = 2; res = bas; do { resa = res; basem = basem * bas; res += ( basem / mFactorial(rep ; rep++; } while (res != resa; return(1+res; } } public class C Main? { public static void Main( { double a,x; Console.Write(Ingrese la base: ; a = Double.Parse(Console.Read Line?(; Console.Write(Ingrese la Potencia: ; x = Double.Parse(Console.Read Line?(; CA Elevado X? ax = new CA Elevado X?(; Console.Write Line?(La respuesta es: {0},ax.mPower(a,x; } }
Ejemplo de ejecucin: Introducir valores: 2 3 valores de a: 2.00000 y x: 3.00000 resultado 8.00000 Algoritmos numricos paralelos. Diseo, estudio y evaluacin Una de las reas de mayor importancia en el contexto de la computacin paralela, y donde se est dedicando un gran esfuerzo al desarrollo de algoritmos numricos eficientes, la constituye el lgebra lineal numrica. La introduccin del paralelismo en el rea ha influido notablemente en el desarrollo de algoritmos y programas. El grupo trabaja en la obtencin de algoritmos eficientes motivados por el uso de mquinas paralelas para dos problemas concretos: Algoritmos paralelos para sistemas lineales. El estudio se centra en la elaboracin de libreras portables que incluyen algoritmos eficientes para la resolucin de grandes sistemas de ecuaciones lineales diseados previamente por el grupo y evaluados tanto desde el punto de vista terico como experimental. Algoritmos paralelos para sistemas no lineales.Aunque los sistemas no lineales aparecen en muchos problemas cientficos y de ingeniera que provienen de la discretizacin de ecuaciones diferenciales como por ejemplo, el clculo de trayectorias o el estudio de sistemas oscilatorios, es un problema poco estudiado desde el punto de vista paralelo. El grupo est diseando y evaluando algoritmos paralelos eficientes que permitan resolver este tipo de sistemas aplicndolos a los problemas citados. Aqui se ven algunos de los algoritmos mas utiles para procesamiento de secuencias de nmeros. Actualmente existen muchos ms. Lista de algoritmos de conjuntos accumulate( Funcin template <class Input Iterator?, class T> T accumulate(Input Iterator? first, Input Iterator? last, T init {
for ( ; first != last; ++first init = init + *first; return init;
}
template <class Input Iterator?, class T, class Binary Operation?> T accumulate(Input Iterator? first, Input Iterator? last, T init,
Binary Operation? binary_op
{
for ( ; first != last; ++first init = binary_op(init, *first; return init;
}
Descripcin accumulate( incrementa el valor de init utilizando el operator+(. La version que recibe una funcin como argumento aplica en cada iteracion una operacion binaria a init y un elemento de la secuencia y lo asigna a init.
inner_product( Funcin template <class Input Iterator 1?, class Input Iterator 2?, class T> T inner_product(Input Iterator 1? first1, Input Iterator 1? last1,
Descripcin inner_product( calcula el pruducto vectorial de dos secuencias, es decir las multiplica componente a componente y va acumulando los resultados.
partial_sum( Funcin template <class Input Iterator?, class Output Iterator?> Output Iterator? partial_sum(Input Iterator? first, Input Iterator? last,
Output Iterator? result
template <class Input Iterator?, class Output Iterator?, class Binary Operation?> Output Iterator? partial_sum(Input Iterator? first, Input Iterator? last,
Descripcin partial_sum( suma a cada elemento de una secuencia la suma de los valores anteriores. Podemos cambia la operacion de suma utilizando la version que permite pasarle un objeto funcin.
adjacent_difference( Funcin & template <class Input Iterator?, class Output Iterator?> Output Iterator? adjacent_difference(Input Iterator? first, Input Iterator? last,
Output Iterator? result
template <class Input Iterator?, class Output Iterator?, class Binary Operation?> Output Iterator? adjacent_difference(Input Iterator? first, Input Iterator? last,
Output Iterator? result, Binary Operation? binary_op Descripcin adjacent_difference( crea una secuencia de salida que consiste en la diferencia existente entre cada par de elementos adjacentes. Podemos utilizar otra funcion diferente a las resta mediante la versi nque permite utilizar un objeto funcin.