Algoritmos Numericos

Un algoritmo es un conjunto finito de instrucciones o pasos que sirven para ejecutar una tarea y/o resolver un problema. De un modo más formal, un algoritmo es una secuencia finita de operaciones realizables, no ambiguas, cuya ejecución da una solución de un problema en un tiempo finito.

El término algoritmo no está exclusivamente relacionado con la matemática, ciencias de la computación o informática. 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 preparación de una comida (porque no están perfectamente definidos los pasos).

También existen ejemplos de índole matemática, como el algoritmo de la división para calcular el cociente de dos números, el algoritmo de Euclides para calcular el máximo común divisor de dos enteros

positivos, o incluso el método de Gauss para resolver Sistema lineal de ecuaciones.

Un algoritmo numérico es el conjunto de instrucciones ordenadas para resolver un problema que involucra procesos matemáticos (con calculo de formulas de manera repetida).

Este tipo de algoritmos no admiten ambigüedades y debe darse cada uno de los pasos para su solución.

Se define el concepto de algoritmo numérico. Se presentan varios casos de problemas numéricos, se dan sus soluciones en forma algorítmica y se agrega en cada caso una representación en forma de diagrama de flujo.

La noción de algoritmo aparece en numerosas y disímiles 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 métodos numéricos permiten resolver problemas obteniendo aproximaciones para las soluciones mediante algoritmos iterativos. Estos algoritmos reciben el nombre de algoritmos numéricos.

Las aproximaciones resultan de mucha utilidad cuando las soluciones analíticas o algebraicas resultan muy difíciles o hasta imposibles de obtener empleando métodos tradicionales. Los computadores ayudan en gran manera, al facilitar la programación de los algoritmos basados en iteración. En esta sección se presentan ejemplos de estos métodos. 1.1 Ejemplo: Cálculo de e mediante serie infinita Programa que calcula el valor de la constante e, base de los logaritmos neperianos. Se hace una aproximación empleando la siguiente serie infinita: e = 1 + 1/1! + 1/2! + 1/3! + 1/4! + … El cálculo se detiene cuando el valor acumulado de e, no se logra diferenciar (por la precisión del computador), del valor calculado en la iteración anterior. Es decir, cuando el siguiente término a sumar es tan pequeño que el computador lo considera como un cero. El factorial, representado por ! en la serie, se implementa en el programa mediante una función. Una vez que se calcula la aproximación, el programa despliega el valor encontrado, así como el número de iteraciones que se emplearon para obtenerlo, es decir, la cantidad de términos de la serie que fue necesario sumar para llegar a la aproximación.

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

    * Ejemplo: Calculo de la constante e mediante una serie infinita

                                                                                                                                                                                                                                                                                                              o / 

using System;

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

    * Función 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 multiplicación: 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 aproximación de la siguiente serie infinita:
* e = 1 + 1/1! + 1/2! + 1/3! + 1/4! + …
* El cálculo se detiene cuando el valor acumulado de e, no se logra
* diferenciar (por la precisión del computador), del valor calculado
* en la iteración 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 ejecución:
Valor de e:
2.718281828459045534884808148490265011787000000000
Se emplearon 19 iteraciones

Ejemplo: Cálculo de e a la x, mediante serie, comparando con función exp()
Programa que calcula e**x (e elevado a la x), haciendo una aproximación mediante una serie infinita. Se
siguen sumando términos mientras la diferencia entre el valor aproximado y el valor devuelto por la
función exp() de la biblioteca math de C, sea mayor que una precisión 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 aproximación, el programa despliega el valor calculado, y el número de iteraciones
que se emplearon para llegar a él, es decir, el número de términos 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 público 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 precisión: “);
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 precisión de {1} es: {2}”,
ex.iter,ex.precision,ex.res);
}
}

Ejemplo de ejecución:
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: Cálculo de a elevado a la x (a**x), mediante series, con la máxima
precisión posible
Programa que calcula a**x (a elevado a la x), haciendo una aproximación mediante una serie, con la
máxima precisión que el lenguaje C puede calcular, esto es, hasta que los resultados alcanzados por la
serie converjan en un mismo valor. Se siguen calculando términos 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 número a una potencia, es representado en el texto por ** (lo cual no es una sintaxis válida en
C#).
Una vez obtenida la aproximación, el programa despliega el valor calculado.
// Cálculo de a elevado a la x (a**x) con la máxima precisión 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 Numéricos 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 ejecución:

Introducir valores: 2 3

valores de a: 2.00000 y x: 3.00000

resultado 8.00000

Algoritmos numéricos paralelos. Diseño, estudio y evaluación

Una de las áreas de mayor importancia en el contexto de la computación paralela, y donde se está dedicando un gran esfuerzo al desarrollo de algoritmos numéricos eficientes, la constituye el álgebra lineal numérica. La introducción del paralelismo en el área ha influido notablemente en el desarrollo de algoritmos y programas. El grupo trabaja en la obtención de algoritmos eficientes motivados por el uso de máquinas paralelas para dos problemas concretos:

Algoritmos paralelos para sistemas lineales. El estudio se centra en la elaboración de librerías portables que incluyen algoritmos eficientes para la resolución de grandes sistemas de ecuaciones lineales diseñados previamente por el grupo y evaluados tanto desde el punto de vista teórico como experimental.

Algoritmos paralelos para sistemas no lineales.Aunque los sistemas no lineales aparecen en muchos problemas científicos y de ingeniería que provienen de la discretización de ecuaciones diferenciales como por ejemplo, el cálculo de trayectorias o el estudio de sistemas oscilatorios, es un problema poco estudiado desde el punto de vista paralelo. El grupo está diseñando y evaluando algoritmos paralelos eficientes que permitan resolver este tipo de sistemas aplicándolos a los problemas citados.

Aqui se ven algunos de los algoritmos mas utiles para procesamiento de secuencias de números. Actualmente existen muchos más.

Lista de algoritmos de conjuntos

accumulate() Función 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;

}

Descripción accumulate() incrementa el valor de init utilizando el operator+(). La version que recibe una función como argumento aplica en cada iteracion una operacion binaria a init y un elemento de la secuencia y lo asigna a init.

inner_product() Función 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;

}

Descripción inner_product() calcula el pruducto vectorial de dos secuencias, es decir las multiplica componente a componente y va acumulando los resultados.

partial_sum() Función 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)

Descripción 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 función.

adjacent_difference() Función & 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)

Descripción 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 función.

Competencias Digitales (Tic’s Basicas) a practicar con este TEMA:

Usar (click en )www.Google.com para buscar y localizar UN material academico apropiado y que se pueda recomendar para el tema, ver VIDEO BUSQUEDAS abajo en esta pagina.
En el post ( o tema ) apropiado en el Libro de Blogger, pegar el material localizado y que se recomienda para este tema, ver VIDEO BLOGGER abajo en esta pagina.

pd: Recordar incluir la fuente del tema usando el formato de citacion apropiado, ver VIDEO WIKIPEDIA abajo en esta pagina.

En el editor de Blogger usar colores para destacar los parrafos mas importantes y usar subrayados para las citas mas relevantes.
En el post ( o tema ) apropiado en el libro en Blogger, para incluir ecuaciones o notacion matematica se debera usar el icono del editor de Blogger IMAGE y construir esta notacion matematica con imagenes Latex, ver VIDEO LATEX ABAJO.
Construir al final y despues de la fuente del material, un breve resumen ( no mas de 2–3 parrafos) explicando palabras propias el contenido del tema.

pd: Se pueden usar alguna de las citas que encontradas dentro del tema, solo recordar encerrarla entre comillas.

pd: Se pueden usar tambien cambios en fonts para darle mas visibilidad, consistencia y relevancia al resumen del tema.

PUNTOS EXTRAS Si se usa una segunda fuente valiosa de informacion y recordar encadenar los dos materiales mediante uno o dos parrafos apropiados.
Enviar a el maestro o compañeros un correo electronico que incluya la liga a el tema en blogger para revision, recomendacion, sugerencias y evaluacion, ver VIDEO LIGAS GMAIL abajo.
Sacar una cuenta (click en)http://docs.google.com, usando el correo de Gmail y tratar de conseguir el mismo usuario que se construyo en Gmail y Blogger ver VIDEO GOOGLE DOCS abajo en esta pagina.

pd: Si ya se tiene una cuenta ignorar esta competencia digital.

pd: Google Docs es el equivalente a OFFICE pero con la caracteristica que todos sus componentes ( procesador de palabras, presentacion electronica y hoja de calculo) estan completamente en internet, es decir todos los archivos o material estaran en linea, seguros y siempre disponibles, ademas de que se pueden trabajarlos desde cualquier pc, ya sea la personal, la del laboratorio de la escuela o la de un lugar publico como la biblioteca o un cafe internet.

Construir una Presentacion Electronica ( usando muy pocos slides) del tema en GOOGLE DOCS e incrustrarla en el tema de bloger ver VIDEO GOOGLE DOCS en esta pagina abajo.

pd: Recordar que una presentacion electronica, es solamente un resumen muy condensado del tema ( o mapa o guia mental ), que ayuda a recordar los elementos y conceptos mas basicos del tema, cuando se estan exponiendo frente a un grupo.

pd: No olvidar incluir un primer slide con el titulo de la presentacion electronica, un segundo slide con un indice de la presentacion electronica y un ultimo slide con dos o tres parrafos de conclusiones y bibliografia.

Buscar en Google Imagenes o www.Flickr.com o www.PhotoBucket.com una galeria de fotos o de imagenes apropiadas al tema actual,
Para los casos de Photobucket y Flicker, ambos sitios proporcionan ligas a sus imagenes y tambien objetos (los recuerdan??), que se pueden incluir en el tema del libro apropiado en Blogger.

pd: para estos sitios deberan obtener una cuenta usando el correo de gmail y de preferencia obtener el mismo usario que se ha venido manejando a lo largo del curso.

pd: Tratar de usar resoluciones y tamaños de imagenes chicos o medianos, recordar que todo este material termina en el post del tema en Blogger y esa pagina no tiene mucho espacio para desplegar fotos o imagenes.

pd: El formato apropiado para fotos o imagenes es JPG, tratar de no usar otros formatos.

pd: Se puede construir y conseguir esta coleccion o galeria de imagenes con:

pd: Estas fotos almacenarlas en un folder en el desktop o escritorio de su computadora y subirlas a el post en blogger usando el icono IMAGE del editor de Blogger.

2) Flickr y Photo Bucket tambien tienen una gran cantidad de imagenes que se pueden usar o mejor dicho enlazar a el tema o post en Blogger.

3) Tambien se puede usar la camaras digitales o las camaras de sus telefonos celulares.

4) Tambien se puede usar el programa o aplicacion llamado Srip32.exe( solo buscar srip32 en google) bajarlo e instalarlo, este programa permite capturar una pantalla de la pc, es decir si se encuentra un sitio con imagenes o incluso texto apropiado o relevante al tema, capturar la pantalla con srip32 y ya se tendra la imagen, ver VIDEO Srip32 abajo.

Incluir al menos una imagen de cada uno de los dos sitios (flickr y Photobucket) en el tema o post que se esta construyendo en Blogger.
PUNTOS EXTRAS Si se incluyen una galeria completa de imagenes apropiadas desde cualquiera de estos sitios de FLICKR o Photobucket.
Sacar una cuenta (click en)www.DivShare.com, usando el correo de Gmail y tratar de conseguir el mismo usuario que se consiguio en Gmail y Blogger y Flickr ver VIDEO DIVSHARE abajo en esta pagina.

pd: Si ya se tiene una cuenta ignorar esta competencia digital.

pd: Usar Divshare para almacenar material en audio (MP3) apropiado a el tema ( no usarlo para almacenar material comercial o les suspenden la cuenta)

pd: El material en Audio, con formato MP3 se debera producir usando un microfono en la pc y programas de aplicacion apropiados, llamados editores de audio, un ejemplo de ellos es el SOUND RECORDER que ya viene en Windows, pero se recomienda usar mejor AUDACITY ( solo buscar en google AUDACITY) bajarlo e instalarlo, ver VIDEO AUDACITY abajo.

Crear al menos dos archivos de audio mp3:

1) El primero de ellos sera la lectura completa de este tema en voz apropiada. ( o aprender a editar con audacity la voz)

2) El segundo de ellos sera un resumen del tema. ( buena voz o editarla con audacity)

3) Ambos archivos subirlos a Div Share (recordor que tienen que ser MP3) y el reproductor que proporciona gratis Div Share, ver VIDEO DIVSHARE abajo e insertarlo en el lugar apropiado del tema que se esta construyendo en Blogger.

4) Ejemplo del reproductor incrustado en una pagina:

Sacar una cuenta (click en)www.YouTube.com, usando el correo de Gmail y tratar de conseguir el mismo usuario que se consiguio en Gmail y Blogger y Flickr.

pd: Si ya se tiene una cuenta ignorar esta competencia digital.

Para producir video se pueden usar tres fuentes:

1) Localizar Videos apropiados en Youtube.

2) Usar nuestras camaras digitales o nuestros telefonos celulares para producir video.

3) Producir un video de la propia pantalla de la computadora ( muy similar a lo que se hizo con Srip32) pero usando un programa especializado en video, tal como CAMSTUDIO (click en www.CamStudio.org) bajar e instalar ( no olvidar bajar e instalar el CODEC que esta abajo en el mismo sitio.

3.1) para Usar Camstudio solo recordar que es muy similar a Srip32 Solo que el resultado final es un archivo de video AVI.

Producir un video de resumen del tema (usar camstudio con el fondo de la pagina con el tema e irlo comentando en voz apropiada)
Producir un video en vivo con la exposicion del tema ( pueden usar la presentacion electronica de fondo o cualquier otro material, pizarron, filminas, rotafolios, etc.)
Subir los videos a su cuenta en Youtube e incluirlos o ligarlos en la pagina en Blogger, tambien los pueden subir directamente a BLOGGER ver VIDEO BLOGGER VIDEO abajo.

Saludos y suerte prof Lauro Soto, Ensenada, BC, Mexico.

EDIT

www.MiTecnologico.com

Politica de Privacidad