Utiliser CEILING sans l'effet d'arrondi Erreur

Question

J'essaie d'utiliser la fonction intrinsèque 'CEILING', mais l'erreur d'arrondi rend difficile l'obtention de ce que je veux parfois. L'exemple de code est juste très simple:

PROGRAM MAIN 

    IMPLICIT NONE 

    INTEGER, PARAMETER  ::  ppm_kind_double = KIND(1.0D0) 
    REAL(ppm_kind_double)  ::  before,after,dx 

    before = -0.112 
    dx = 0.008 
    after = CEILING(before/dx) 

    WRITE(*,*) before, dx, before/dx, after 

    END 

Et je a obtenu des résultats:

La valeur que je donne à « avant » et « dx » dans le code est juste pour la démonstration. Pour ceux avant/dx = -13.5 par exemple, je veux utiliser CEILING pour obtenir -13. Mais pour la photo que je montre, je veux vraiment -14. J'ai considéré l'utilisation de certains arguments comme

IF(ABS(NINT(before/dx) - before/dx) < 0.001) 

Mais ce n'est tout simplement pas beau. Y a-t-il une meilleure façon de faire cela?

Mise à jour:

Je fus surpris de constater que le problème ne se produira pas si je mets les variables constantes dans ppm_kind_double. Donc je suppose que cette "erreur d'arrondi" ne se produira que lorsque le nombre de chiffres pour la précision d'arrondi de la machine que j'utilise est supérieur à ce qui est défini dans ppm_kind_double. Je cours réellement mon programme (pas ce code de démo) sur un groupe, que je ne sais pas au sujet de la précision de machine. Alors peut-être que c'est la précision quadruple sur cette machine qui mène au problème?

Après avoir défini des constantes à double précision:

before = -0.112_ppm_kind_double 
dx = 0.008_ppm_kind_double 

Answer 1

Ceci est un peu difficile, parce que vous ne savez jamais où l'erreur d'arrondi vient. Si dx était juste un petit peu plus grand que 0.008 alors la division before/dx pourrait encore être arrondie à la même valeur, mais maintenant -13 serait la bonne réponse. Cela dit, la méthode la plus commune autour de ce que j'ai vu est juste nudge la valeur précédente jamais si peu dans la direction opposée. Quelque chose comme ceci:

program sign_test 
    use iso_fortran_env 
    implicit none 
    real(kind=real64) :: a, b 
    integer(kind=int32) :: c 
    a = -0.112 
    b = 0.008 
    c = my_ceiling(a/b) 
    print*, a, b, c 
contains 
    function my_ceiling(v) 
     implicit none 
     real(kind=real64), intent(in) :: v 
     integer(kind=int32) :: my_ceiling 
     my_ceiling = ceiling(v - 1d-6, kind=int32) 
    end function my_ceiling 
end program sign_test 

Cela n'aura aucun impact sur la grande majorité des valeurs, mais il y a maintenant quelques valeurs qui s'arrondi de plus que prévu.

Answer 2

note si vos nombres réels sont fictivement « exacte » à une certaine précision que vous pourriez faire quelque chose comme ceci:

after=nint(1000*before)/nint(1000*dx) 

cela fonctionne pour votre exemple .. vous n'avez pas dit ce que vous attendez pour les valeurs positives et ainsi de suite, donc vous pourriez avoir besoin de travailler un peu.