Terminología del compilador de Fortran: Variables ficticias y atributos

Question

¿Puede alguien explicarme a qué tipo de abstracción en el analizador/compilador corresponde una variable o atributo ficticio?

 PURE SUBROUTINE F(X, Y) 
     IMPLICIT NONE 
     REAL, INTENT(INOUT) :: X, Y, C 
C  REAL :: A, B 
C  REAL, SAVE :: C = 3.14E0 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
     X = Y + 2 * SIN(Y) 
     END 

---

cetin@unique:~/lab/secret/tapenade$ gfortran -x f77 -c 1.f 
1.f:6.37: 

     PARAMETER (C = 3.14E0, X = 32, Y = X)       
            1 
Error: PARAMETER attribute conflicts with DUMMY attribute in 'x' at (1) 
1.f:3.38: 

     REAL, INTENT(INOUT) :: X, Y, C         
            1 
Error: Symbol at (1) is not a DUMMY variable 

---

cetin@unique:~/lab/secret/tapenade$ ifort -c 1.f 
1.f(3): error #6451: A dummy argument name is required in this context. [C] 
     REAL, INTENT(INOUT) :: X, Y, C 
-------------------------------------^ 
1.f(6): error #6406: Conflicting attributes or multiple declaration of name. [X] 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
-------------------------------^ 
1.f(6): error #6406: Conflicting attributes or multiple declaration of name. [Y] 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
---------------------------------------^ 
1.f(6): error #6592: This symbol must be a defined parameter, an enumerator, or an argument of an inquiry function that evaluates to a compile-time constant. [X] 
     PARAMETER (C = 3.14E0, X = 32, Y = X) 
-------------------------------------------^ 
compilation aborted for 1.f (code 1) 

Answer 1

Fortran pasa por referencia. El atributo ficticio corresponde a aquellas variables que se transfieren a la función (X y Y en su caso). La instrucción de parámetro espera algo estático, pero dado que X es lo que se pasa a la función, realmente no tiene ningún sentido. La declaración de parámetro es una forma de configurar constantes; no tiene nada que ver con los parámetros de una subrutina.

Cuando se obtiene el error diciendo que C no es una variable DUMMY, entonces, significa que no está encontrando C en la lista de variables que se pasó a la entrada/salida de la función - su declaración sólo es F(X, Y): no C a la vista. Aunque no está utilizando explícitamente el atributo DUMMY, tiene el atributo INTENT(INOUT), lo que significa que estas variables corresponden a la entrada/salida de la subrutina.

para conseguir lo que desea, usted tendría una subrutina que se ve algo como:

subroutine F(X, Y) 
    implicit none 

    ! These are the dummy variables 
    real, intent(inout) :: X, Y 

    ! These are the variables in the scope of this subroutine 
    real     :: a, b 
    real, parameter, save :: c = 3.14E0 

    X = Y + 2*sin(Y) 
end subroutine F 

No estoy del todo seguro de lo que está tratando de hacer - que está declarando una subrutina pure, lo que significa una subrutina sin efectos secundarios, pero está utilizando intent(inout) para sus variables, lo que significa que X y Y se pueden alterar en el curso de la ejecución.

me gustaría añadir, así que dentro de una subrutina, la inicialización de una variable en su declaración declaración como REAL :: C = 3.14E0 produce una variable con una implícitasave atributo . Sin embargo, si desea que se guarde de llamada a llamada, ha hecho lo correcto al agregar explícitamente el atributo save para dejar en claro que eso es lo que está haciendo.

No soy un tipo de analizador/compilador, pero creo que para responder a su pregunta, el atributo dummy significa que solo está obteniendo un puntero, no tiene que asignar ningún espacio, ya que la variable utilizada en la llamada de función ya tiene espacio asignado.

Answer 2

El problema real con la llamada está bien explicado por Tim Whitcomb. Trataré de explicar más explícitamente los términos.

Dummy argumento es un término específico Fortran. Es lo que otros lenguajes llaman a parámetros formales o similar, es decir, es el objeto que se llama X y Y (en su caso) y que se asocia a un argumento real cuando se invoca el procedimiento.

lo tanto, en:

subroutine s(i) 
    integer :: i 
end 

call s(1) 

la i es un argumento ficticio de la subrutina s mientras que la expresión 1 es el argumento real que se pasa a la subrutina para el argumento ficticio i.

Los atributos son una forma de especificar propiedades adicionales de objetos o procedimientos de datos. Los atributos pueden ser especificados usando declaraciones:

real c 
intent(in) c 
optional c 

o pueden especificarse en una sola declaración:

real, intent(in), optional :: c 

De esta manera el argumento ficticio c es un verdadero defecto con atributos intent(in) y optional.

Atributos conflictivos son atributos que no se pueden especificar para un objeto al mismo tiempo. Su ejemplo con intent(...) y parameter sirve bien. Estos son incompatibles ya que el primero implica un argumento ficticio y el otro especifica un llamado constante.