Maraming tao ang nakakilala sa Fortran bilang isang archaic at "patay" na wika ng programa. Gayunpaman, ang karamihan sa pang-agham at engineering code ay nakasulat sa Fortran. Tulad ng naturan, ang programa sa F77 at F90 ay nananatiling isang kinakailangang kasanayan para sa karamihan sa mga teknikal na programmer. Bukod dito, ang pinakabagong pamantayan ng Fortran (2003, 2008, 2015) ay pinapayagan ang programmer na magsulat ng mahusay na code na may pinakamaliit na pagsisikap, habang ginagamit ang lahat ng mga modernong tampok sa wika, tulad ng OOP (object-oriented program). Ang FORTRAN ay isang akronim para sa "FORmula TRANslation", at pinakaangkop para sa mga aplikasyon sa matematika at numerikal kaysa sa mga application ng grapiko o database. Karamihan sa mga fortran code ay kumukuha ng input ng teksto mula sa isang file o command-line kaysa sa isang menu o interface ng GUI.
Mga hakbang
Bahagi 1 ng 4: Pagsulat at Pagbuo ng isang Simpleng Programa
Hakbang 1. Sumulat ng isang programang "Hello World"
Kadalasan ito ang unang programa na sumulat sa anumang wika, at pini-print lamang nito ang "Kamusta mundo" sa screen. Isulat ang sumusunod na code sa anumang text editor at i-save ito bilang helloworld.f. Bigyang pansin na dapat mayroong eksaktong 6 na puwang sa harap ng bawat linya.
program helloworld implicit none character * 13 hello_string hello_string = "Kumusta, mundo!" sumulat (*, *) hello_string end program helloworld
Tip: Ang mga puwang ay kinakailangan lamang sa mga bersyon ng Fortran hanggang sa FORTRAN 77. Kung gumagamit ka ng isang mas bagong bersyon, maaari mong i-drop ang mga puwang. Mag-ipon ng mga programa mula sa mas bagong bersyon na may f95, hindi f77; gamitin ang.f95 bilang extension ng file sa halip na.f lamang.
Hakbang 2. Tipunin ang programa
Upang magawa ito, i-type ang f77 helloworld.f sa linya ng utos. Kung nagbibigay ito ng isang error, marahil ay hindi ka pa naka-install ng Fortran compiler tulad halimbawa ng gfortran.
Hakbang 3. Patakbuhin ang iyong programa
Gumawa ang tagatala ng isang file na tinatawag na a.out. Patakbuhin ang file na ito sa pamamagitan ng pagta-type./a.out.
Hakbang 4. Maunawaan kung ano ang isinulat mo lamang
-
programa helloworld
ipinapahiwatig ang pagsisimula ng programang "helloworld". Katulad din
tapusin ang programa helloworld
- ay nagpapahiwatig ng pagtatapos nito.
-
Bilang default, kung hindi mo idedeklara ang isang variable na uri, tinatrato ng Fortran ang isang variable na may isang pangalan na nagsisimula sa isang titik mula sa i hanggang n bilang integer, at lahat ng iba pa bilang isang tunay na numero. Inirerekumenda na gamitin
walang implicit
- kung hindi mo kailangan ang ugali.
-
character * 13 hello_string
- idineklara ang isang hanay ng mga character na tinatawag na hello_string.
-
hello_string = "Hello, mundo!"
- itinalaga ang halagang "Kamusta, mundo!" sa idineklarang array. Hindi tulad ng sa ibang mga wika tulad ng C, hindi ito magagawa sa parehong linya sa pagdedeklara ng array.
-
isulat ang (*, *) hello_string
- naka-print ang halaga ng hello_string sa karaniwang output. Ang unang * nangangahulugang sumulat sa karaniwang output, taliwas sa ilang file. Ang pangalawang * ay nangangahulugang hindi gumamit ng anumang espesyal na pag-format.
Hakbang 5. Magdagdag ng komento
Hindi ito kinakailangan sa isang simpleng programa, ngunit magiging kapaki-pakinabang kapag nagsulat ka ng isang bagay na mas kumplikado, kaya dapat mong malaman kung paano mo idagdag ang mga ito. Mayroong dalawang paraan upang magdagdag ng isang komento.
- Upang magdagdag ng isang puna na may isang buong linya sa sarili nitong, sumulat ng isang c nang direkta sa isang bagong linya, nang walang 6 na puwang. Pagkatapos nito, isulat ang iyong puna. Dapat kang mag-iwan ng puwang sa pagitan ng c at ng iyong puna para sa mas mahusay na kakayahang mabasa, ngunit hindi ito kinakailangan. Tandaan na kailangan mong gumamit ng a! sa halip na isang c sa Fortran 95 at mas bago.
- Upang magdagdag ng isang puna sa parehong linya bilang code, magdagdag ng! kung saan mo nais magsimula ang iyong puna. Muli, ang isang puwang ay hindi kinakailangan, ngunit pinapabuti ang kakayahang mabasa.
Bahagi 2 ng 4: Paggamit ng Pag-input at Kung-Mga Pagbuo
Hakbang 1. Maunawaan ang iba't ibang mga uri ng data
- Ginagamit ang INTEGER para sa buong numero, tulad ng 1, 3, o -3.
- Ang TUNAY ay maaari ring maglaman ng isang numero na hindi buo, tulad ng 2.5.
- Ginagamit ang COMPLEX upang mag-imbak ng mga kumplikadong numero. Ang unang numero ay ang totoo at ang pangalawa ay imahinasyong bahagi.
- Ang CHARACTER ay ginagamit para sa mga character, tulad ng mga letra o bantas.
- Ang LOGICAL ay maaaring alinman. Totoo. o.mali.. Ito ay tulad ng uri ng boolean sa ibang mga wika ng pagprograma.
Hakbang 2. Kunin ang input ng gumagamit
Sa programang "Kamusta mundo" na isinulat mo dati, magiging walang silbi ang pagkuha ng input ng gumagamit. Kaya buksan ang isang bagong file at pangalanan ito compnum.f. Kapag natapos mo na ito, sasabihin nito sa gumagamit kung positibo, negatibo o katumbas ng zero ang bilang na kanilang ipinasok.
- Ipasok ang mga linya ng compnum ng programa at tapusin ang compnum ng programa.
- Pagkatapos, ideklara ang isang variable ng uri na TUNAY. Tiyaking ang iyong deklarasyon ay nasa pagitan ng simula at pagtatapos ng programa.
- Ipaliwanag ang gumagamit kung ano ang dapat nilang gawin. Sumulat ng ilang teksto na may function na pagsulat.
- Basahin ang input ng gumagamit sa variable na iyong idineklara na may read function.
programa compnum real r sumulat (*, *) "Magpasok ng isang tunay na numero:" basahin ang (*, *) r pagtatapos ng programa
Hakbang 3. Iproseso ang input ng gumagamit gamit ang isang if-konstruksyon
Ilagay ito sa pagitan ng
basahin ang (*, *) r
at ang
tapusin ang programa
- Ang paghahambing ay tapos na sa.gt. (mas malaki sa),.lt. (mas mababa sa) at.eq. (katumbas) sa Fortran.
- Sinusuportahan ng Fortran kung, iba pa kung, at iba pa
- Ang isang Fortran if-konstruksyon ay laging nagtatapos sa pagtatapos kung.
kung (r.gt. 0) pagkatapos ay isulat ang (*, *) "Ang numerong iyon ay positibo." kung hindi man kung (r.lt. 0) pagkatapos ay isulat ang (*, *) "Negatibo ang bilang na iyon." kung hindi man isulat (*, *) "Ang bilang na iyon ay 0." tapusin kung
Tip: Hindi mo kailangang i-indent ang code sa loob ng mga if-konstruksyon na may mas maraming puwang, ngunit pinapabuti nito ang kakayahang mabasa.
Hakbang 4. Compile at patakbuhin ang iyong programa
Magpasok ng ilang mga numero upang subukan ito. Kung nagpasok ka ng isang sulat, tataasan nito ang isang error, ngunit okay lang iyon dahil hindi masuri ng programa kung ang input ay isang liham, isang numero, o iba pa.
Bahagi 3 ng 4: Paggamit ng Mga Loop at Array
Hakbang 1. Magbukas ng isang bagong file
Dahil iba ang konseptong ito, magsusulat ka ulit ng isang bagong programa. Pangalanan ang file addmany.f. Ipasok ang katumbas na programa at wakasan ang mga pahayag ng programa, pati na rin ang isang implicit na wala. Kapag natapos ka na, ang program na ito ay magbabasa ng 10 mga numero at mai-print ang kanilang kabuuan.
Hakbang 2. Ipahayag ang isang hanay ng haba 10
Dito mo maiimbak ang mga numero. Dahil malamang na gusto mo ng isang kabuuan ng mga totoong numero, dapat mong ideklara ang array bilang real. Idineklara mo ang tulad ng isang array sa
totoong mga numero (50)
(ang mga numero ay ang pangalan ng array, hindi isang expression).
Hakbang 3. Ipahayag ang ilang mga variable
Ipahayag ang numSum bilang isang tunay na numero. Gagamitin mo ito upang maiimbak ang kabuuan sa paglaon, ngunit dahil ang kabuuan ay nakuha na ng isang ekspresyong Fortran, kailangan mong gumamit ng isang pangalan tulad ng numSum. Itakda ito sa 0. Ideklara ang i bilang isang integer at huwag italaga ito sa anumang halaga. Gagawin iyon sa do-loop.
Hakbang 4. Lumikha ng isang do-loop
Ang katumbas ng na sa iba pang mga wika ng programa ay magiging isang for-loop.
- Ang isang do-loop ay laging nagsisimula sa do.
- Sa parehong linya tulad ng gawin, na pinaghiwalay mula dito ng isang puwang, ay ang tatak na pupuntahan ng programa kapag natapos na ito. Sa ngayon, magsulat lamang ng isang 1, itatakda mo ang label sa paglaon.
-
Pagkatapos nito, muling pinaghiwalay lamang ng isang puwang, uri
i = 1, 10
. Gagawin nito ang variable i, na iyong idineklara bago ang loop, mula 1 hanggang 10 sa mga hakbang na 1. Ang mga hakbang ay hindi nabanggit sa expression na ito, kaya't ginagamit ng Fortran ang default na halaga ng 1. Maaari mo ring isulat
i = 1, 10, 1
-
Maglagay ng ilang code sa loob ng loop (indent na may mga puwang para sa mas mahusay na kakayahang mabasa). Para sa program na ito, dapat mong dagdagan ang variable numSum gamit ang i-th na elemento ng mga numero ng array. Ginagawa ito sa ekspresyon
numSum = numSum + number (i)
- Tapusin ang loop sa isang patuloy na pahayag na may isang label. Mag-type lamang ng 4 na puwang. Pagkatapos nito, mag-type ng 1. Iyon ang tatak kung saan sinabi mo sa do-loop na puntahan pagkatapos nitong matapos. Pagkatapos, mag-type ng isang puwang at magpatuloy. Ang patuloy na expression ay walang ginagawa, ngunit nagbibigay ito ng isang magandang lugar upang maglagay ng isang label, pati na rin ang pagpapakita na natapos ang do-loop.
Ang iyong do loop ay dapat magmukhang ganito:
gawin ang 1 i = 1, 10 numSum = numSum + numero (i) 1 magpatuloy
Tip: Sa Fortran 95 at mas bago, hindi mo kailangang gumamit ng mga label. Huwag lamang ilagay ang isa sa do statement at tapusin ang loop ng "end do" sa halip na "magpatuloy".
Hakbang 5. I-print numSum
Gayundin, makatuwiran na magbigay ng ilang konteksto, halimbawa, "Ang kabuuan ng iyong mga numero ay:". Gamitin ang function ng pagsulat para sa pareho. Ang iyong buong code ay dapat na tumingin tulad ng sumusunod:
addmany ng programa na walang ipinahiwatig na walang totoong mga numero (10) tunay na numSum integer i numSum = 0 isulat (*, *) "Ipasok ang 10 na numero:" basahin ang (*, *) na mga numero ay gumagawa ng 1 i = 1, 10 numSum = numSum + na mga numero (i) 1 magpatuloy isulat (*, *) "Ang kanilang kabuuan ay:" isulat (*, *) numSum end program addmany
Hakbang 6. Compile at patakbuhin ang iyong code
Huwag kalimutang subukan ito. Maaari mong pindutin ang ↵ Ipasok pagkatapos ng bawat numero na ipinasok mo o ipasok ang maraming mga numero sa parehong linya at paghiwalayin ang mga ito ng isang puwang.
Bahagi 4 ng 4: Pag-unawa sa Mga Mabilis na Konsepto
Hakbang 1. Magkaroon ng isang magandang ideya kung ano ang gagawin ng iyong programa
Mag-isip tungkol sa kung anong uri ng data ang kinakailangan bilang pag-input, kung paano i-istraktura ang output, at isama ang ilang pansamantalang output upang masubaybayan mo ang pag-usad ng iyong pagkalkula. Napakapakinabangan nito kung alam mong tatakbo ang iyong pagkalkula ng mahabang panahon o nagsasangkot ng maraming kumplikadong mga hakbang.
Hakbang 2. Maghanap ng isang mahusay na sanggunian ng Fortran
Ang Fortran ay may higit pang mga pagpapaandar kaysa ipinaliwanag sa artikulong ito, at maaaring maging kapaki-pakinabang ang mga ito para sa program na nais mong isulat. Inililista ng isang sanggunian ang lahat ng mga pagpapaandar na mayroon ang isang wika ng programa. Ito ay isa para sa Fortran 77 at ito ay isa para sa Fortran 90/95.
Hakbang 3. Alamin ang tungkol sa mga subroutine at pag-andar
Hakbang 4. Alamin kung paano magbasa at magsulat mula sa / hanggang sa mga file
Alamin din kung paano i-format ang iyong input / output.
Hakbang 5. Alamin ang tungkol sa mga bagong tampok ng Fortran 90/95 at mas bago
Laktawan ang hakbang na ito kung alam mo na magsusulat ka lamang / mapanatili ang Fortran 77 code.
Tandaan na ipinakilala ng Fortran 90 ang "Free Form" na source code, pinapayagan ang code na maisulat nang walang mga puwang at walang limitasyong 72 character
Hakbang 6. Basahin o tingnan ang ilang mga libro tungkol sa Scientific Programming
Halimbawa, ang librong "Numerical Recipe sa Fortran" ay kapwa isang mahusay na teksto sa mga pang-agham na algorithm ng programa at isang mahusay na pagpapakilala sa kung paano pagsamahin ang mga code. Ang mga pinakabagong edisyon ay may kasamang mga kabanata tungkol sa kung paano magprogram sa isang magkakahalong wika na kapaligiran at parallel na programa. Ang isa pang halimbawa ay ang "Modern Fortran in Practice" na isinulat ni Arjen Markus. Ang libro ay nagbibigay ng isang pananaw sa kung paano magsulat ng mga programa ng Fortran sa estilo ng dalawampu't isang-siglong istilo alinsunod sa pinakabagong mga pamantayan ng Fortran.
Hakbang 7. Alamin kung paano mag-ipon ng isang program na kumalat sa maraming mga file
Ipagpalagay natin na ang iyong programa sa Fortran ay kumalat sa pangunahing mga file.f at morestuff.f, at nais mong ang nagresultang binary ay mapangalanan na allstuff. Pagkatapos ay kailangan mong isulat ang mga sumusunod na utos sa linya ng utos:
f77 -c morestuff.f f77 -c main.f f77 -c morestuff.f f77 -o allstuff main.o morestuff.f
Pagkatapos ay patakbuhin ang file sa pamamagitan ng pagta-type./allstuff.
Tip: Gumagana ito sa parehong paraan sa mga mas bagong bersyon ng Fortran. Palitan lamang ang.f ng tamang extension at f77 gamit ang tamang bersyon ng tagatala.
Hakbang 8. Gamitin ang pag-optimize na ibinibigay ng iyong tagatala
Karamihan sa mga tagabuo ay may kasamang mga algorithm sa pag-optimize na nagpapabuti sa kahusayan ng iyong code. Karaniwan itong naka-on sa pamamagitan ng pagsasama ng isang -O, -O2, o -O3 flag kapag nag-iipon (muli depende sa iyong bersyon ng fortran).
-
Pangkalahatan, ang pinakamababang antas -O o -O2 antas ay pinakamahusay. Magkaroon ng kamalayan na ang paggamit ng mas agresibong pagpipilian sa pag-optimize ay maaaring magpakilala ng mga pagkakamali sa mga kumplikadong code at maaari ring pabagalin ang mga bagay! Subukan ang iyong code.
Mga Tip
- Magsimula sa maliliit na programa. Kapag gumagawa ka ng iyong sariling code, subukang kilalanin ang pinakamahalagang bahagi ng problema - ito ba ang input ng data o ang pagtawag ng mga pagpapaandar, ang istraktura ng loop (ito ang ilang mga napaka-elementaryong halimbawa) at magsimula doon. Pagkatapos ay itayo iyon sa maliliit na palugit.
- Ang Fortran ay hindi sensitibo sa kaso. Maaari, halimbawa, ideklara ang isang variable na "totoong Num" at isulat ang "num = 1" sa susunod na linya upang magtalaga ng isang halaga dito. Ngunit masamang istilo iyan, kaya iwasan ito. Higit sa lahat, ang Fortran ay walang pakialam sa kaso ng mga pagpapaandar at pahayag din. Karaniwan na itong magsulat ng mga pagpapaandar at pahayag sa UPPERCASE at mga variable sa maliit na titik.
- Ang EMACS ay isang mahusay na libreng text editor upang magamit sa halip na Notepad.
- Maaaring mas madali mong gamitin ang isang online IDE (integrated development environment) sa una. Ang isang mahusay na pagpipilian ay ang Coding Ground. Mahahanap mo ang maraming wika sa pagprograma doon, kasama ang Fortran-95. Ang isa pang pagpipilian ay Ideone.
