फोरट्रान में अनंतता

Question

फोरट्रान में एक चर सेट करने के लिए सबसे सुरक्षित तरीका क्या है? फिलहाल मैं इसका उपयोग कर रहा हूं:

program test 
    implicit none 
    print *,infinity() 
contains 
    real function infinity() 
    implicit none 
    real :: x 
    x = huge(1.) 
    infinity = x + x 
    end function infinity 
end program test 

लेकिन मुझे आश्चर्य है कि कोई बेहतर तरीका है या नहीं?

Answer 1

यदि आपका कंपाइलर supports आईएसओ टीआर 15580 आईईईई अंकगणित जो आप तथाकथित फोरट्रान 2003 मानक का हिस्सा है, तो आप ieee_ * मॉड्यूल से प्रक्रियाओं का उपयोग कर सकते हैं।

PROGRAM main 

    USE ieee_arithmetic 

    IMPLICIT NONE 

    REAL :: r 

    IF (ieee_support_inf(r)) THEN 
    r = ieee_value(r, ieee_negative_inf) 
    END IF 

    PRINT *, r 

END PROGRAM main 

Answer 2

मुझे सबसे सुरक्षित नहीं पता, लेकिन मैं आपको एक वैकल्पिक विधि प्रदान कर सकता हूं।

PROGRAM infinity 
    IMPLICIT NONE 
    INTEGER :: inf 
    REAL :: infi 
    EQUIVALENCE (inf,infi) !Stores two variable at the same address 
    DATA inf/z'7f800000'/ !Hex for +Infinity 
    WRITE(*,*)infi 
END PROGRAM infinity 

आप भाव में असाधारण मूल्यों उपयोग कर रहे हैं (मुझे नहीं लगता कि यह आम तौर पर सलाह दी जाती है) आप चाहते हैं कि आपके संकलक उन्हें संभालती है सावधान ध्यान देना चाहिए, आप कुछ मिल सकता है: मैं इसे इस तरह से करने के लिए सीखा अन्यथा अप्रत्याशित परिणाम।

Answer 3

मैं संकलक आईईईई मानक का समर्थन करने के पर भरोसा नहीं होता है और काफी क्या आप दो परिवर्तन के साथ किया था, है:

1. मैं कुछ compilers आप कर सकते हैं पर huge(1.)+huge(1.) जोड़ नहीं होता है, के बाद से -huge(1.)+1 के साथ समाप्त होता है --- और इससे स्मृति मेमोरी हो सकती है (कारण पता नहीं है, लेकिन यह एक प्रयोगात्मक तथ्य है, इसलिए कहने के लिए)।

2. आप यहां real प्रकार का उपयोग कर रहे हैं। मैं व्यक्तिगत रूप से अपने सभी फ़्लोटिंग-पॉइंट नंबर real*8 के रूप में रखना पसंद करता हूं, इसलिए सभी फ्लोट स्थिरांक d0 के साथ योग्य हैं, जैसे: huge(1.d0)। यह निश्चित रूप से एक नियम नहीं है; कुछ लोग real -s और real*8 -s दोनों का उपयोग करना पसंद करते हैं।

Answer 4

मुझे यकीन है कि अगर समाधान bellow सभी compilers पर काम करता है नहीं कर रहा हूँ, लेकिन यह -log के रूप में अनंत तक पहुँचने का एक अच्छा तरीका है गणितीय (0)।

program test 
    implicit none 
    print *,infinity() 
contains 
    real function infinity() 
    implicit none 
    real :: x 
    x = 0 
    infinity=-log(x) 
    end function infinity 
end program test 

जटिल चर के लिए भी अच्छी तरह से काम करता है।

Answer 5

यह मेरे लिए काम करता प्रतीत होता है। एक पैरामीटर

double precision,parameter :: inf = 1.d0/0.d0 

परिभाषित करें तो यह में उपयोग परीक्षण करता है, तो।

real :: sng 
    double precision :: dbl1,dbl2 

    sng = 1.0/0.0 
    dbl1 = 1.d0/0.d0 
    dbl2 = -log(0.d0) 

    if(sng == inf) write(*,*)"sng = inf" 
    if(dbl1 == inf) write(*,*)"dbl1 = inf" 
    if(dbl2 == inf) write(*,*)"dbl2 = inf" 
    read(*,*) 

जब ifort & रन के साथ संकलित, मैं

sng = inf 
dbl1 = inf 
dbl2 = inf