function - varias - Funciones FORTRAN

varias graficas en r

Question

Estoy trabajando en un proyecto que necesita implementar algunos métodos numéricos en FORTRAN. Para esto, necesito escribir algunas funciones recursivas. Aquí está mi código.

!
! File: main.F95
!
RECURSIVE FUNCTION integrate(n) RESULT(rv)
IMPLICIT NONE
DOUBLE PRECISION :: rv
INTEGER, INTENT(IN) :: n
DOUBLE PRECISION, PARAMETER :: minusone = -1.0
IF (n == 1) THEN
rv = 10 !exp(minusone)
RETURN
ELSE
rv = 1 - (n * integrate(n - 1))
RETURN
END IF
END FUNCTION integrate
RECURSIVE FUNCTION factorial(n) RESULT(res)
INTEGER res, n
IF (n .EQ. 0) THEN
res = 1
ELSE
res = n * factorial(n - 1)
END IF
END
PROGRAM main
DOUBLE PRECISION :: rv1
PRINT *, factorial(5)
PRINT *, integrate(2)
!READ *, rv1
END PROGRAM main

Para este programa, el resultado es:

 NaN
1

Si cambio el orden de las instrucciones de impresión (líneas 30 y 31), la salida será:

 1
-19.000000

La salida debe ser (para el orden de extracto de impresión original):

 120
-19

Tomé la función factorial de la página de características de lenguaje de Wikipedia Fortran 95 . Soy nuevo en FORTRAN, no sé lo que está mal en mi código. Por favor, ayúdenme chicos.

• Compilador: gfortran 4.5.3 con Cygwin
• IDE: Netbeans 7.0.1
• Plataforma: Windows 7

Gracias de antemano.

Answer 1

Como menciona uno de los comentarios, una mejor solución es poner sus subrutinas y funciones en un módulo, luego usar ese módulo desde su programa principal. Esto hará que la interfaz de esos procedimientos sea conocida por el que llama: "explícita" en la terminología de Fortran. El compilador no solo manejará correctamente el tipo de función, sino que también podrá verificar el acuerdo de tipo entre los argumentos en la llamada y los argumentos en el llamado ("argumentos ficticios") para mayor coherencia.

Si usa tantas opciones de depuración como sea posible, el compilador lo ayudará a encontrar errores. Con gfortran, pruebe: -O2 -fimplicit-none -Wall -Wline-truncation -Wcharacter-truncation -Wsused -Waliasing -Wimplicit-interface -Wunused-parameter -fwhole-file -fcheck = all -std = f2008 -pedantic -fbacktrace

module factorial_procs
IMPLICIT NONE
contains
RECURSIVE FUNCTION integrate(n) RESULT(rv)
DOUBLE PRECISION :: rv
INTEGER, INTENT(IN) :: n
IF (n == 1) THEN
rv = 10
RETURN
ELSE
rv = 1 - (n * integrate(n - 1))
RETURN
END IF
END FUNCTION integrate
RECURSIVE FUNCTION factorial(n) RESULT(res)
INTEGER res, n
IF (n .EQ. 0) THEN
res = 1
ELSE
res = n * factorial(n - 1)
END IF
END
end module factorial_procs
PROGRAM main
use factorial_procs
implicit none
PRINT *, factorial(5)
PRINT *, integrate(2)
END PROGRAM main

Probablemente descubrirá que solo puede calcular los factoriales de enteros muy pequeños mediante la multiplicación directa utilizando enteros regulares. Una solución es usar un tipo de entero más grande, por ejemplo,

integer, parameter :: BigInt_K = selected_int_kind (18)

Del mismo modo que podría modernizar y usar selected_real_kind en lugar de Double Precision.

Answer 2

Tus funciones están escritas correctamente. El problema está en el programa principal, donde no declaras explícitamente el tipo de funciones integrate y factorial , entonces tienes tipeo implícito, en cuyo caso factorial se supone REAL y se supone que INTEGER . Por algún motivo, su compilador no le advirtió sobre el desajuste de tipos. El mío lo hizo

$ gfortran recurs.f90
recurs.f90:26.22:
PRINT *, integrate(2)
1
Error: Return type mismatch of function ''integrate'' at (1) (INTEGER(4)/REAL(8))
recurs.f90:27.22:
PRINT *, factorial(5)
1
Error: Return type mismatch of function ''factorial'' at (1) (REAL(4)/INTEGER(4))

Debe cambiar su programa principal a:

PROGRAM main
IMPLICIT NONE
DOUBLE PRECISION, EXTERNAL :: integrate
INTEGER, EXTERNAL :: factorial
PRINT *, factorial(5)
PRINT *, integrate(2)
END PROGRAM main

Observe la línea IMPLICIT NONE . Esta declaración de declaración desactivará cualquier tipeo implícito, y el compilador generará un error si no todas las variables y funciones se declaran explícitamente. Esta es una línea muy importante en cada programa de Fortran, y si lo tuviera, usted mismo habría resuelto su problema, porque lo obligaría a declarar explícitamente todo en su programa.

El resultado ahora es:

 120
-19.0000000000000

como se esperaba.

Como nota al margen, la declaración de tipo DOUBLE PRECISION no es tan flexible como usar REAL con el parámetro KIND especificado en su lugar, por ejemplo, un REAL(KIND=myRealKind) . Vea las respuestas a esta pregunta sobre cómo usar KIND correctamente: parámetro tipo Fortran 90 .

Answer 3

I would like to highlight some points while using RECURSIVE functions or non recursive function.

1. Asegúrese de que la función tenga una interfaz explícita con el programa de llamada. Esto se puede lograr poniendo la función en un módulo y la asociación USE. Esto se explica en la respuesta antes mencionada. 2. Puede usar INTERFACE para construir una interfaz explícita con el programa principal de llamadas, esto es útil cuando tiene muy pocos números de funciones que tengan una interfaz implícita, como en su caso. El ejemplo se da a continuación.

PROGRAM main
IMPLICIT NONE
INTERFACE
FUNCTION factorial(n)
INTEGER:: factorial
INTEGER, INTENT(IN):: n
END FUNCTION factorial
FUNCTION integrate(n)
DOUBLE PRECISION:: integrate
INTEGER, INTENT(IN):: n
END FUNCTION integrate
END INTERFACE
PRINT *, factorial(5)
PRINT *, integrate(2)
END PROGRAM main

tenga en cuenta que siempre es mejor definir un parámetro tipo y luego usar la cláusula KIND como! explicado por @milancurcic

Hay otra forma muy simple de resolver su problema: simplemente defina factorial e itegrate en el programa principal de la siguiente manera y ya está listo para comenzar

PROGRAM main
IMPLICIT NONE
DOUBLE PRECISION :: integrate
INTEGER:: factorial
PRINT *, factorial(5)
PRINT *, integrate(2)
END PROGRAM main