convertir c pour boucle à fortran faire boucle

Question

Je convertis un cpp prog (d'un autre auteur) en un prog Fortran, mon C n'est pas trop fort. Je suis tombé sur des constructions en boucle pour en commençant par

for (int n = 1; 1; ++n) { 
... 

Je me serais attendu à ce à convertir en Fortran Do selon

Do n=1, 1, 2 
... 

... au moins c'est mon estimation basée sur ma compréhension ce que ++ n fera.

Ma traduction est-elle correcte? Si c'est le cas, la boucle fera un cycle au plus une fois, alors qu'est-ce qui me manque ???

Je comprends que, à certains égards, les boucles for-c ont un aspect «do-while», et donc des rides de portage à Fortran Do.

De toute façon ... une précision serait très appréciée.

ÉDITÉE: après quelques réponses rapides, et je pense que je vois où cela va

D'abord, le code exact C copier/coller mais « couper » un peu, est

for (int n = 1; 1; ++n) { 
     const double coef = exp(-a2*(n*n)) * expx2/(a2*(n*n) + y*y); 
     prod2ax *= exp2ax; 
     prodm2ax *= expm2ax; 
     sum1 += coef; 
     sum2 += coef * prodm2ax; 
     sum4 += (coef * prodm2ax) * (a*n); 
     sum3 += coef * prod2ax; 
     sum5 += (coef * prod2ax) * (a*n); 
     // test convergence via sum5, since this sum has the slowest decay 
     if ((coef * prod2ax) * (a*n) < relerr * sum5) break; 
    } 

Alors oui , il y a une "pause" dans la boucle, qui du côté Fortran est remplacée par une "Sortie".

Je pense que la clé semble être des réponses ci-dessous que l'auteur du code d'origine a créé le for (int n = 1; 1; ++ n) précisément pour créer une boucle infinie, et je ne l'avais pas deviné que cela pour construire créerait une boucle infinie.

Quoi qu'il en soit, je peux certainement créer une boucle infinie avec une « sortie » en Fortran (bien que je pense que je pourrais « faire » un peu plus judicieusement)

Un grand merci à tous.

Il semble que la réponse de M. Gregory a été celle qui a immédiatement conduit à une solution pour moi, donc je vais marquer son correct. Pour ce qui est du côté Fortran, il y a un certain nombre d'alternatives telles que:

Do While 
    : 
    If(something) Exit 
    End Do 

mais étant vieux jeu, je serais probablement utiliser une construction avec une « limite », comme

Do i=1, MaxIter 
    : 
    If(something) Exit 
    End Do 

Pour les applications un peu plus fantaisistes Je pourrais inclure un drapeau de retour au cas où il n'a pas convergé dans etc. de maxiter

Answer 1

Voici ce que

for (int n = 1; 1; ++n) 

fait:

Il définit n à 1, puis une boucle infinie, incrémenter n par 1 à la fin de chaque itération de la boucle. La boucle ne se terminera jamais à moins que quelque chose à l'intérieur de la boucle ne se déclenche.

Cela fait longtemps que j'ai écrit Fortran mais si je me souviens bien, la boucle do que vous avez traduite en n'est pas correcte.

Answer 2

Je ne pense pas que vous pouvez traduire

for (int n = 1; 1; ++n) 

à une FORTRAN boucle DO. D'après ce que je me rappelle, la notion de condition générique en C/C++ ne peut pas être émulée dans une boucle FORTRAN DO.

L'équivalent de

Do n=1, 1, 2 

en C/C++ est

for (int n = 1; n <= 1; n += 2) 

Answer 3

Etes-vous sûr que vous avez écrit le code C correctement? boucles généralement en C/C++ sont fait comme ceci:

for (int n = 1; n < 10; ++n) { 
    // ... 
} 

Notez la condition de test "n < 10". La condition de test de votre code est simplement 1, qui sera toujours évaluée à Boolean "true". Cela signifie que le code tournera infiniment, sauf s'il y a un break dans la boucle, que vous n'avez pas montré.

++n signifie «incrément n».

Donc, si le code que vous avez montré est en effet correct, l'équivalent FORTRAN serait:

n = 1 
do 
    [Body of the loop, which you haven't shown] 
    n = n + 1 
enddo 

Answer 4

Quelques notes en plus de la réponse de CareyGregory.

++n moyen d'incrément de n par une (avant n est évaluée) "

en C et C++, une boucle for a trois articles, un peu comme dans FORTRAN:

for (init; condition; increment) 

La différence est que chacune des clauses doit être une expression complète, alors que dans FORTRAN les clauses sont juste des valeurs. Il est juste une « courte » façon d'écrire une boucle while équivalente:

int n = 1;   │ for (int n = 1; 1; ++n) │ n = 1 
while (1)   │ {       │ do 
{     │ ...      │ ... 
    ...    │ }       │ n = n + 1 
    ++n;    │       │ enddo 
}     │       │ 

Answer 5

Il est difficile d'être définitive sans voir comment le C++ Ruptures du programme sur cette boucle, mais un équivalent Fortran simple serait

n = 1 
do 
    ! code, including an exit under some condition, presumably on the value of n 
    n = n+1 
end do 

Si la boucle est terminée lorsque n atteint une valeur critique alors l'équivalent pourrait être

do n = 1, critical_value ! no need to indicate step size if it is 1 
    ! code 
end do