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

Módulos e Interfaces

Siguiente ►
►

En este módulo, aprenderemos sobre los módulos e interfaces en Fortran, que son herramientas poderosas para organizar y estructurar el código, facilitando la reutilización y el mantenimiento.

Contenido

  1. Introducción a los Módulos
  2. Creación y Uso de Módulos
  3. Interfaces en Fortran
  4. Ejemplos Prácticos
  5. Ejercicios

  1. Introducción a los Módulos

¿Qué es un Módulo?

Un módulo en Fortran es una unidad de código que permite agrupar variables, constantes, tipos de datos, subrutinas y funciones. Los módulos facilitan la organización del código y la reutilización de componentes.

Ventajas de Usar Módulos

  • Encapsulación: Permiten encapsular datos y procedimientos.
  • Reutilización: Facilitan la reutilización de código en diferentes partes del programa.
  • Mantenimiento: Hacen que el código sea más fácil de mantener y entender.
  • Control de Acceso: Permiten controlar el acceso a los datos y procedimientos.

  1. Creación y Uso de Módulos

Sintaxis Básica de un Módulo

module nombre_modulo
  ! Declaraciones de variables, constantes, tipos de datos, subrutinas y funciones
contains
  ! Definiciones de subrutinas y funciones
end module nombre_modulo

Ejemplo de un Módulo Simple

module operaciones_matematicas
  implicit none
  contains
    function suma(a, b)
      integer :: suma
      integer, intent(in) :: a, b
      suma = a + b
    end function suma

    function resta(a, b)
      integer :: resta
      integer, intent(in) :: a, b
      resta = a - b
    end function resta
end module operaciones_matematicas

Uso de un Módulo en un Programa

Para usar un módulo en un programa, se utiliza la declaración use.

program ejemplo_modulo
  use operaciones_matematicas
  implicit none
  integer :: resultado

  resultado = suma(5, 3)
  print *, "La suma es: ", resultado

  resultado = resta(5, 3)
  print *, "La resta es: ", resultado
end program ejemplo_modulo

  1. Interfaces en Fortran

¿Qué es una Interfaz?

Una interfaz en Fortran es una declaración que describe la firma de una subrutina o función. Las interfaces son útiles para definir procedimientos externos o para sobrecargar procedimientos.

Declaración de una Interfaz

interface
  subroutine mi_subrutina(a, b)
    integer, intent(in) :: a, b
  end subroutine mi_subrutina
end interface

Ejemplo de Uso de una Interfaz

module modulo_interfaz
  implicit none
  interface
    function multiplicar(a, b)
      integer :: multiplicar
      integer, intent(in) :: a, b
    end function multiplicar
  end interface
end module modulo_interfaz

program ejemplo_interfaz
  use modulo_interfaz
  implicit none
  integer :: resultado

  resultado = multiplicar(4, 5)
  print *, "El producto es: ", resultado
end program ejemplo_interfaz

function multiplicar(a, b)
  integer :: multiplicar
  integer, intent(in) :: a, b
  multiplicar = a * b
end function multiplicar

  1. Ejemplos Prácticos

Ejemplo 1: Módulo con Variables y Subrutinas

module datos_y_procedimientos
  implicit none
  integer :: contador = 0
contains
  subroutine incrementar_contador()
    contador = contador + 1
  end subroutine incrementar_contador

  subroutine mostrar_contador()
    print *, "El contador es: ", contador
  end subroutine mostrar_contador
end module datos_y_procedimientos

program uso_modulo
  use datos_y_procedimientos
  implicit none

  call incrementar_contador()
  call mostrar_contador()

  call incrementar_contador()
  call mostrar_contador()
end program uso_modulo

Ejemplo 2: Interfaz para Sobrecarga de Funciones

module sobrecarga_funciones
  implicit none
  interface area
    module procedure area_cuadrado
    module procedure area_rectangulo
  end interface
contains
  function area_cuadrado(lado)
    real :: area_cuadrado
    real, intent(in) :: lado
    area_cuadrado = lado * lado
  end function area_cuadrado

  function area_rectangulo(largo, ancho)
    real :: area_rectangulo
    real, intent(in) :: largo, ancho
    area_rectangulo = largo * ancho
  end function area_rectangulo
end module sobrecarga_funciones

program uso_sobrecarga
  use sobrecarga_funciones
  implicit none
  real :: resultado

  resultado = area(5.0)
  print *, "El área del cuadrado es: ", resultado

  resultado = area(5.0, 3.0)
  print *, "El área del rectángulo es: ", resultado
end program uso_sobrecarga

  1. Ejercicios

Ejercicio 1: Crear un Módulo de Operaciones Básicas

Crea un módulo llamado operaciones_basicas que contenga funciones para sumar, restar, multiplicar y dividir dos números enteros. Luego, escribe un programa que use este módulo para realizar estas operaciones y mostrar los resultados.

Solución

module operaciones_basicas
  implicit none
contains
  function suma(a, b)
    integer :: suma
    integer, intent(in) :: a, b
    suma = a + b
  end function suma

  function resta(a, b)
    integer :: resta
    integer, intent(in) :: a, b
    resta = a - b
  end function resta

  function multiplicar(a, b)
    integer :: multiplicar
    integer, intent(in) :: a, b
    multiplicar = a * b
  end function multiplicar

  function dividir(a, b)
    integer :: dividir
    integer, intent(in) :: a, b
    if (b /= 0) then
      dividir = a / b
    else
      print *, "Error: División por cero"
      dividir = 0
    end if
  end function dividir
end module operaciones_basicas

program uso_operaciones
  use operaciones_basicas
  implicit none
  integer :: resultado

  resultado = suma(10, 5)
  print *, "La suma es: ", resultado

  resultado = resta(10, 5)
  print *, "La resta es: ", resultado

  resultado = multiplicar(10, 5)
  print *, "La multiplicación es: ", resultado

  resultado = dividir(10, 5)
  print *, "La división es: ", resultado
end program uso_operaciones

Ejercicio 2: Crear una Interfaz para Sobrecargar Funciones

Crea un módulo llamado geometria que contenga una interfaz para sobrecargar una función perimetro que calcule el perímetro de un cuadrado y un rectángulo. Luego, escribe un programa que use este módulo para calcular y mostrar los perímetros.

Solución

module geometria
  implicit none
  interface perimetro
    module procedure perimetro_cuadrado
    module procedure perimetro_rectangulo
  end interface
contains
  function perimetro_cuadrado(lado)
    real :: perimetro_cuadrado
    real, intent(in) :: lado
    perimetro_cuadrado = 4 * lado
  end function perimetro_cuadrado

  function perimetro_rectangulo(largo, ancho)
    real :: perimetro_rectangulo
    real, intent(in) :: largo, ancho
    perimetro_rectangulo = 2 * (largo + ancho)
  end function perimetro_rectangulo
end module geometria

program uso_geometria
  use geometria
  implicit none
  real :: resultado

  resultado = perimetro(5.0)
  print *, "El perímetro del cuadrado es: ", resultado

  resultado = perimetro(5.0, 3.0)
  print *, "El perímetro del rectángulo es: ", resultado
end program uso_geometria

Conclusión

En este módulo, hemos aprendido sobre los módulos e interfaces en Fortran. Los módulos nos permiten organizar y encapsular el código, facilitando su reutilización y mantenimiento. Las interfaces nos permiten definir la firma de subrutinas y funciones, y son útiles para la sobrecarga de procedimientos. Con estos conocimientos, estamos mejor preparados para escribir código Fortran más estructurado y eficiente.

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