El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Métodos Numéricos en Fortran

Siguiente ►
►

En este módulo, exploraremos cómo implementar métodos numéricos en Fortran. Los métodos numéricos son técnicas utilizadas para resolver problemas matemáticos que no pueden ser resueltos de manera analítica. Fortran, con su fuerte enfoque en el cálculo numérico y científico, es una herramienta poderosa para este propósito.

Contenido

  1. Introducción a los Métodos Numéricos
  2. Solución de Ecuaciones No Lineales
  3. Métodos de Integración Numérica
  4. Métodos de Diferenciación Numérica
  5. Solución de Sistemas de Ecuaciones Lineales
  6. Interpolación y Aproximación de Funciones
  7. Ejercicios Prácticos

  1. Introducción a los Métodos Numéricos

Los métodos numéricos son algoritmos diseñados para resolver problemas matemáticos mediante aproximaciones. Estos métodos son esenciales en situaciones donde las soluciones exactas no son posibles o son difíciles de obtener.

Conceptos Clave

  • Error Numérico: Diferencia entre el valor exacto y el valor aproximado.
  • Convergencia: Propiedad de un método numérico de acercarse a la solución exacta a medida que se refina la aproximación.
  • Estabilidad: Capacidad de un método para producir resultados precisos a pesar de errores en los datos de entrada o en los cálculos intermedios.

  1. Solución de Ecuaciones No Lineales

Método de Bisección

El método de bisección es una técnica simple y robusta para encontrar raíces de ecuaciones no lineales. Se basa en el teorema del valor intermedio.

Ejemplo de Código

program bisection_method
  implicit none
  real(8) :: a, b, c, tol, fa, fb, fc
  integer :: max_iter, iter

  ! Definir los límites iniciales y la tolerancia
  a = 1.0
  b = 2.0
  tol = 1.0e-6
  max_iter = 100

  ! Función a resolver: f(x) = x^3 - x - 2
  fa = f(a)
  fb = f(b)

  if (fa * fb > 0.0) then
    print *, "La función no cambia de signo en el intervalo dado."
    stop
  end if

  iter = 0
  do while (abs(b - a) > tol .and. iter < max_iter)
    c = (a + b) / 2.0
    fc = f(c)

    if (fc == 0.0) exit
    if (fa * fc < 0.0) then
      b = c
      fb = fc
    else
      a = c
      fa = fc
    end if

    iter = iter + 1
  end do

  print *, "La raíz aproximada es: ", c
  print *, "Número de iteraciones: ", iter

contains
  real(8) function f(x)
    real(8), intent(in) :: x
    f = x**3 - x - 2
  end function f
end program bisection_method

Explicación del Código

  1. Definición de Variables: Se definen los límites iniciales a y b, la tolerancia tol y el número máximo de iteraciones max_iter.
  2. Evaluación de la Función: Se evalúa la función en los puntos a y b.
  3. Verificación del Cambio de Signo: Se verifica que la función cambie de signo en el intervalo dado.
  4. Iteración: Se realiza la iteración del método de bisección hasta que la diferencia entre a y b sea menor que la tolerancia o se alcance el número máximo de iteraciones.
  5. Resultado: Se imprime la raíz aproximada y el número de iteraciones realizadas.

  1. Métodos de Integración Numérica

Regla del Trapecio

La regla del trapecio es un método simple para aproximar la integral de una función.

Ejemplo de Código

program trapezoidal_rule
  implicit none
  real(8) :: a, b, h, integral
  integer :: n, i

  ! Definir los límites de integración y el número de subintervalos
  a = 0.0
  b = 1.0
  n = 100
  h = (b - a) / n

  integral = 0.5 * (f(a) + f(b))
  do i = 1, n-1
    integral = integral + f(a + i * h)
  end do
  integral = integral * h

  print *, "La integral aproximada es: ", integral

contains
  real(8) function f(x)
    real(8), intent(in) :: x
    f = x**2
  end function f
end program trapezoidal_rule

Explicación del Código

  1. Definición de Variables: Se definen los límites de integración a y b, el número de subintervalos n y el tamaño del paso h.
  2. Cálculo de la Integral: Se utiliza la regla del trapecio para aproximar la integral de la función f(x) = x^2.
  3. Resultado: Se imprime la integral aproximada.

  1. Métodos de Diferenciación Numérica

Diferencias Finitas

Las diferencias finitas son una técnica para aproximar derivadas.

Ejemplo de Código

program finite_differences
  implicit none
  real(8) :: x, h, derivative

  ! Definir el punto de evaluación y el tamaño del paso
  x = 1.0
  h = 1.0e-5

  derivative = (f(x + h) - f(x - h)) / (2.0 * h)

  print *, "La derivada aproximada en x = ", x, " es: ", derivative

contains
  real(8) function f(x)
    real(8), intent(in) :: x
    f = x**2
  end function f
end program finite_differences

Explicación del Código

  1. Definición de Variables: Se define el punto de evaluación x y el tamaño del paso h.
  2. Cálculo de la Derivada: Se utiliza la fórmula de diferencias finitas centradas para aproximar la derivada de la función f(x) = x^2.
  3. Resultado: Se imprime la derivada aproximada.

  1. Solución de Sistemas de Ecuaciones Lineales

Método de Gauss-Seidel

El método de Gauss-Seidel es un algoritmo iterativo para resolver sistemas de ecuaciones lineales.

Ejemplo de Código

program gauss_seidel
  implicit none
  real(8), dimension(3,3) :: A
  real(8), dimension(3) :: b, x
  real(8) :: tol
  integer :: max_iter, iter, i, j

  ! Definir el sistema de ecuaciones Ax = b
  A = reshape([4.0, -1.0, 0.0, -1.0, 4.0, -1.0, 0.0, -1.0, 4.0], [3,3])
  b = [15.0, 10.0, 10.0]
  x = [0.0, 0.0, 0.0]
  tol = 1.0e-6
  max_iter = 100

  iter = 0
  do while (iter < max_iter)
    x_old = x
    do i = 1, 3
      x(i) = (b(i) - sum(A(i,1:i-1) * x(1:i-1)) - sum(A(i,i+1:3) * x_old(i+1:3))) / A(i,i)
    end do
    if (maxval(abs(x - x_old)) < tol) exit
    iter = iter + 1
  end do

  print *, "La solución aproximada es: ", x
  print *, "Número de iteraciones: ", iter
end program gauss_seidel

Explicación del Código

  1. Definición de Variables: Se define la matriz A, el vector b, el vector de solución x, la tolerancia tol y el número máximo de iteraciones max_iter.
  2. Iteración: Se realiza la iteración del método de Gauss-Seidel hasta que la diferencia entre x y x_old sea menor que la tolerancia o se alcance el número máximo de iteraciones.
  3. Resultado: Se imprime la solución aproximada y el número de iteraciones realizadas.

  1. Interpolación y Aproximación de Funciones

Interpolación Lineal

La interpolación lineal es una técnica simple para aproximar valores entre dos puntos conocidos.

Ejemplo de Código

program linear_interpolation
  implicit none
  real(8) :: x0, x1, y0, y1, x, y

  ! Definir los puntos conocidos
  x0 = 1.0
  y0 = 2.0
  x1 = 2.0
  y1 = 3.0

  ! Punto a interpolar
  x = 1.5

  y = y0 + (y1 - y0) * (x - x0) / (x1 - x0)

  print *, "El valor interpolado en x = ", x, " es: ", y
end program linear_interpolation

Explicación del Código

  1. Definición de Variables: Se definen los puntos conocidos x0, y0, x1, y1 y el punto a interpolar x.
  2. Cálculo de la Interpolación: Se utiliza la fórmula de interpolación lineal para aproximar el valor de y en el punto x.
  3. Resultado: Se imprime el valor interpolado.

  1. Ejercicios Prácticos

Ejercicio 1: Método de Newton-Raphson

Implementa el método de Newton-Raphson para encontrar la raíz de la función f(x) = x^3 - 2x - 5.

Solución

program newton_raphson
  implicit none
  real(8) :: x, tol, fx, dfx
  integer :: max_iter, iter

  ! Definir el punto inicial, la tolerancia y el número máximo de iteraciones
  x = 2.0
  tol = 1.0e-6
  max_iter = 100

  iter = 0
  do while (iter < max_iter)
    fx = f(x)
    dfx = df(x)
    if (abs(fx) < tol) exit
    x = x - fx / dfx
    iter = iter + 1
  end do

  print *, "La raíz aproximada es: ", x
  print *, "Número de iteraciones: ", iter

contains
  real(8) function f(x)
    real(8), intent(in) :: x
    f = x**3 - 2*x - 5
  end function f

  real(8) function df(x)
    real(8), intent(in) :: x
    df = 3*x**2 - 2
  end function df
end program newton_raphson

Ejercicio 2: Método de Simpson

Implementa el método de Simpson para aproximar la integral de la función f(x) = sin(x) en el intervalo [0, π].

Solución

program simpson_rule
  implicit none
  real(8) :: a, b, h, integral
  integer :: n, i

  ! Definir los límites de integración y el número de subintervalos
  a = 0.0
  b = 3.141592653589793
  n = 100
  h = (b - a) / n

  integral = f(a) + f(b)
  do i = 1, n-1
    if (mod(i, 2) == 0) then
      integral = integral + 2.0 * f(a + i * h)
    else
      integral = integral + 4.0 * f(a + i * h)
    end if
  end do
  integral = integral * h / 3.0

  print *, "La integral aproximada es: ", integral

contains
  real(8) function f(x)
    real(8), intent(in) :: x
    f = sin(x)
  end function f
end program simpson_rule

Conclusión

En este módulo, hemos explorado varios métodos numéricos fundamentales y cómo implementarlos en Fortran. Estos métodos son herramientas esenciales para resolver problemas matemáticos complejos en diversas áreas de la ciencia y la ingeniería. A través de ejemplos prácticos y ejercicios, hemos demostrado cómo aplicar estos métodos de manera efectiva. En el próximo módulo, nos enfocaremos en la creación de un proyecto integral que combine estos conceptos para resolver problemas reales.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados