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


o /

using System;

/***************************************************************************

* 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,

Input Iterator 2? first2, T init
{
for ( ; first1 != last1; ++first1, ++first2
init = init + (*first1 * *first2;
return init;

}

template <class Input Iterator 1?, class Input Iterator 2?, class T,

class Binary Operation 1?, class Binary Operation 2?>

T inner_product(Input Iterator 1? first1, Input Iterator 1? last1,

Input Iterator 2? first2, T init, Binary Operation 1? binary_op1,
Binary Operation 2? binary_op2

{

for ( ; first1 != last1; ++first1, ++first2
init = binary_op1(init, binary_op2(*first1, *first2;
return init;

}

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,

Output Iterator? result, Binary Operation? binary_op

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.