Hogyan alkalmazhatók a logikai utasítások a programozásban?

A programozás alapja az, hogy a különböző utasítások lehetővé teszik a programok működésének irányítását, és a logikai feltételek segítenek abban, hogy a program különböző helyzetekben eltérő módon viselkedjen. Az alábbiakban részletesen bemutatjuk, hogyan alkalmazhatóak a logikai utasítások a Fortran programozásban, különös figyelmet fordítva a ciklusok, az if állítások, és a GOTO utasítások használatára.

Először is, vegyünk egy egyszerű példát, amely kiszámítja az első n pozitív egész szám összegét. Az alábbi program segítségével meghatározhatjuk a számok összegét logikai utasítások használatával:

fortran
Copy code
c program to calculate sum of first n integers

write(*,*) 'Input n'
read(*,*) n
is=0
i=1
10 is = is + i
if (i .eq. n) goto 20
i = i + 1
goto 10
20 write(*,*) 'calculated value', is
write(*,*) 'formula value', n*(n+1)/2
end

A fenti program logikája meglehetősen egyszerű: először beolvassuk a felhasználótól az n értéket, majd egy ciklus segítségével kiszámítjuk az összegét az első n számnak. A ciklus minden egyes iterációja után hozzáadjuk az aktuális számot az összeghez (is), és folytatjuk a ciklust mindaddig, amíg el nem érjük az n értéket. Amikor i eléri az n értéket, a program a goto 20 utasítással átvált a 20. sorszámú parancsra, amely kiírja a kiszámított összeg értékét, és összehasonlítja azt a formulával kiszámított értékkel.

Ez a program nemcsak a programozás alapvető logikai szerkezetét mutatja be, hanem arra is rávilágít, hogy a Fortran programozási nyelvben a GOTO utasítás hogyan irányíthatja a program folyamát, amely különösen hasznos lehet a bonyolultabb feltételes logikai struktúrák kezelésére.

A következő példában a program validálja a felhasználó által megadott sebességet, hogy biztosítsa, hogy az érték nem negatív vagy nulla. Ha a megadott sebesség érvénytelen, a program leáll egy hibaüzenet kiírásával:

fortran
Copy code
c DATA VALIDATION USING LOGICAL IF STATEMENT

c READ VELOCITY, REJECT IT IF -VE OR ZERO WITH A MESSAGE AND STOP
REAL VEL
WRITE(*,*) 'Input velocity'
READ(*,*) VEL
IF (VEL .LE. 0) WRITE(*,*) 'Negative or zero velocity not allowed, Program is stopped!'
STOP
END

Itt a program a VEL változót használja, amelyet a felhasználó ad meg. Ha a sebesség kisebb vagy egyenlő nullával, a program leáll, és kiír egy hibaüzenetet. A logikai IF állítás használata biztosítja, hogy a program csak érvényes sebességgel folytathassa a működést, megakadályozva ezzel a hibás adatok feldolgozását.

A következő példa a diákok átmeneti státuszát vizsgálja a megszerzett pontszámok alapján. Ha egy diák 40%-nál kevesebb pontot szerez, akkor nem halad át, különben átment:

fortran
Copy code
c FIND PROMOTIONAL STATUS OF A STUDENT USING LOGICAL IF STATEMENT

WRITE(*,*) 'ENTER FULL MARKS'
READ(*,*) MF
WRITE(*,*) 'ENTER MARKS OBTAINED OUT OF', MF
READ(*,*) MO
PCNTM = REAL(MO) / REAL(MF) * 100
IF (PCNTM .LT. 40) WRITE(*,*) 'OBTAINED MARKS', PCNTM, ' % STATUS FAIL'
IF (PCNTM .GE. 40) WRITE(*,*) 'OBTAINED MARKS', PCNTM, ' % STATUS PASS'
STOP
END

Ebben a példában a program a teljes pontszámot és a megszerzett pontszámot kérdezi a felhasználótól, majd kiszámítja a százalékos eredményt. Ha a diák pontszáma 40% alatt van, akkor a program azt jelzi, hogy a diák nem felelt meg. Ha a pontszám eléri a 40%-ot vagy annál magasabb, akkor a program jelzi, hogy a diák átment.

A programok ezen változataiban a logikai feltételek és a ciklusok használata lehetővé teszi a dinamikus ellenőrzést és a program működésének irányítását, miközben a felhasználó interakciójának is érdemi szerepe van a program eredményének meghatározásában.

fortran
Copy code
c Print Fibonacci numbers upto 20000
c find ratio of the higher to lower consecutive F. nos.
n0 = 0
n1 = 1
WRITE(*,*) 'F.No Ratio'
5 n = n0 + n1
IF (n .GT. 20000) STOP
WRITE(*,*) n, '  ', REAL(n) / REAL(n1)
n0 = n1
n1 = n
GOTO 5
END

Mindezek a példák jól mutatják, hogy hogyan alkalmazhatók a logikai utasítások és a ciklusok a programozás során. A logikai feltételek használata lehetővé teszi a program számára, hogy dinamikusan reagáljon a felhasználói bemenetekre, biztosítva, hogy a program a kívánt módon működjön. A GOTO utasítások pedig segítenek a vezérlés hatékony irányításában, még ha a program logikája bonyolultabb is.

Hogyan oldjunk meg numerikus problémákat Fortran segítségével?

A programozás egyik legnagyobb kihívása, hogy képesek legyünk hatékonyan kezelni és elemezni nagy mennyiségű adatot. A Fortran programozási nyelv, amely különösen hasznos numerikus elemzésekhez, lehetőséget ad arra, hogy gyorsan és egyszerűen végezzünk különféle számításokat. Az alábbiakban bemutatott programok és példák arra mutatnak, hogyan lehet különböző típusú számításokat végrehajtani, kezdve a számok összegzésétől a Pithagoraszi-hármasok kereséséig.

Az első példa három szám összegzésére összpontosít, ahol a felhasználó megadja, hány alkalommal szeretné végrehajtani a műveletet. Az inner loop a három szám összegzéséért felelős, míg a külső loop a műveletek számát kezeli. A program így képes több szám összegzésére többször is, és a felhasználó minden alkalommal különböző számokat adhat meg.

fortran
Copy code
! P57-triplet.f

C To find sum of three integers specified times
write(*,*)'input how many times you want to sum'
read*,n
do 10 i=1,n
    mt=0
    write(*,*)'input integers one after another'
    do 20 j=1,3
        read*,m
        mt=mt+m
    20 continue
    print*,'sum ',i,'  sum value   ',mt
10 continue
end

A fenti program azt mutatja be, hogyan lehet egyszerűen kezelni a felhasználói inputokat és végezni el ismétlődő számításokat. Az adatok összeadásához szükséges ciklusok jól illusztrálják, hogy miként lehet többszörös műveleteket végezni ugyanazon adatokkal, miközben a program rugalmas marad.

fortran
Copy code
! P58-pytha.f
C find Pythagorian triplets a^2 + b^2 = c^2
C using integers upto 100 and find sum of the triplet forming integers
write(*,*) 'Pythagorian triplets   sum'
do 10 i=1,100
    do 10 j=i+1,100
        do 10 k=i+2,100
            if ((i**2 + j**2).eq.k**2) then
                sum=i+j+k
                write(*,*) i, j, k,'                ', sum
            endif
10 continue
end

Ez a program nemcsak a hármasokat találja meg, hanem azok összegét is kiszámítja, miközben az eredményeket szépen formázva jeleníti meg.

fortran
Copy code
! P59-prime1.f
C To find Prime nos upto 100
Integer c
write(*,*) 'Prime nos upto 100'
c=0
do 10 i=2,100
    nc=sqrt(real(i))+1
    do 20 j=2,nc
        if (i.eq.2) goto 7
        if (mod(i,j).eq.0) goto 10
20 continue
7 c=c+1
write(*,*) i
10 continue
write(*,*) 'total count', c
end

Ebben a programban láthatjuk, hogy a prímszámok számát is nyomon követhetjük, és a teljesítmény növelése érdekében a ciklusok számát is csökkenthetjük a négyzetgyökös optimalizálással.

Végül a faktoriálisok összegzésének példáját is bemutatjuk. Bár a faktoriálisok gyorsan növekednek, a Fortran lehetőséget biztosít arra, hogy akár nagy számok faktoriálisait is számoljuk, ha nem lépünk túl a 12-es határt, amit a program biztonságosan tud kezelni.

fortran
Copy code
! P61-series-sum4

C Find 1! + 2! + 3! +.......+ n!
WRITE(*,*)'INPUT THE VALUE OF N, max value 12'
READ(*,*)N
IF(N.GT.12) GOTO 40
IS=0
DO 10 I=1,N
    LP=1
    DO 20 K=1,I
        LP=LP*K
20 CONTINUE
    IS=IS+LP
10 CONTINUE
WRITE(*,*)'THE VALUE OF SUMMATION=',IS
END

Ez a program az n faktoriálisok összegzését végzi el, mindaddig, amíg az n értéke nem haladja meg a 12-t, mivel a nagyobb számok összegét már nem lehet biztonságosan tárolni az alapértelmezett egész típusú változókban.

A fenti példák bemutatják, hogy a Fortran használata nem csupán egyszerű adatfeldolgozást, hanem komolyabb matematikai problémák megoldását is lehetővé teszi. A Fortran egyik nagy előnye, hogy egyszerű szintaxisával lehetővé teszi a hatékony számításokat és a különböző algoritmusok könnyű implementálását. Azonban, ha a programok komplexebbé válnak, az optimalizálás és a memória kezelése egyre fontosabb szerepet kap.