‫آﻣﻮزش ﻓﺮﺗﺮن ‪ - FORTRAN‬ﻣﻘﺪﻣﺎﺗﯽ‬

‫ﻣﻌﺮﻓﯽ ﻭ ﺗﺎﺭﻳﺨﭽﻪ ﻓﺮﺗﺮﻥ‬

‫ﻫﻤﺎﻧﻄﻮﺭ ﮐﻪ ﺩﺭ ﺍﻏﻠﺐ ﮐﺘﺎﺑﻬﺎﯼ ﻣﮑﺎﻧﻴﮏ ﺩﻳﺪﻩ ﺍﻳﺪ‪ ،‬ﺩﺭ ﺍﻏﻠﺐ ﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﻣﻬﻨﺪﺳﯽ ﺍﺯ ﺍﻳﻦ ﺯﺑﺎﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‪ .‬ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ‬

‫ﻓﺮﺗﺮﻥ ﺑﺎ ﻭﺟﻮﺩ ﺳﺎﺩﮔﯽ ﺍﺯ ﻗﺪﺭﺕ ﻭ ﺳﺮﻋﺖ ﺑﺎﻻﻳﯽ ﺑﺮﺧﻮﺭﺩﺍﺭ ﺍﺳﺖ‪ ،‬ﺑﻄﻮﺭﻳﮑﻪ ﻣﯽ ﺗﻮﺍﻥ ﺍﺯ ﺁﻥ ﺑﺮﺍﯼ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ‪ CFD‬ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ‪ .‬ﻓﺮﺗﺮﻥ‬

‫ﺍﻏﻠﺐ ﺑﺎ ﻗﺎﺑﻠﻴﺖ ﻓﻮﻕ ﺍﻟﻌﺎﺩﻩ ﺩﺭ ﻣﻮﺭﺩ ﺍﻋﺪﺍﺩ ﻣﻌﺮﻓﯽ ﻣﯽ ﮔﺮﺩﺩ ﻭ ﻫﻤﺎﻧﻄﻮﺭ ﮐﻪ ﺍﺯ ﺍﺳﻤﺶ )‪ (FORmula TRANslation‬ﭘﻴﺪﺍﺳﺖ‪ ،‬ﺑﺮﺍﯼ ﺍﻧﺠﺎﻡ‬

‫ﻣﺤﺎﺳﺒﺎﺕ ﺭﻳﺎﺿﯽ ﺩﺭ ﮐﺎﺭﻫﺎﯼ ﻋﻠﻤﯽ ﺧﻠﻖ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺩﺭ ﮔﺬﺷﺘﻪ ﺍﻳﻦ ﺯﺑﺎﻥ ﺩﺍﺭﺍﯼ ﻣﺤﺪﻭﺩﻳﺘﻬﺎﻳﯽ ﺑﻮﺩﻩ ﮐﻪ ﺩﺭ ﻧﺴﺨﻪ ﻫﺎﯼ ﺟﺪﻳﺪ ﺍﻳﻦ ﻣﺸﮑﻼﺕ‬

‫ﺣﻞ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﺍﻳﻦ ﺯﺑﺎﻥ ﺑﻪ ﻳﮏ ﺯﺑﺎﻥ ﺑﺴﻴﺎﺭ ﻗﻮﯼ ﺗﺒﺪﻳﻞ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺍﻏﻠﺐ ﮐﺘﺎﺑﺨﺎﻧﻪ ﻫﺎﯼ ﻻﺯﻡ ﺑﺮﺍﯼ ﺍﻧﺠﺎﻡ ﺍﻧﻮﺍﻉ ﻣﺤﺎﺳﺒﺎﺕ ﺩﺭ ﺍﻳﻦ ﺯﺑﺎﻥ ﻭﺟﻮﺩ‬

‫ﺩﺍﺭﺩ‪ .‬ﺍﻳﻦ ﺯﺑﺎﻥ ﺩﺭ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻓﺮﺗﺮﻥ ‪ 90‬ﺍﺯ ﻗﺎﺑﻠﻴﺖ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﻣﺤﺎﺳﺒﺎﺕ ﻣﻮﺍﺯﯼ ﺑﺮﺍﯼ ﮐﺎﻣﭙﻴﻮﺗﺮ ﻫﺎﯼ ﭼﻨﺪ ﭘﺮﺩﺍﺯﻧﺪﻩ ﺍﯼ ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ‬

‫ﮐﻨﺪ ﮐﻪ ﺁﻳﻨﺪﻩ ﺭﻭﺷﻨﯽ ﺭﺍ ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﺎﺕ ﺳﻨﮕﻴﻦ ‪ CFD‬ﻧﺸﺎﻥ ﻣﯽ ﺩﻫﺪ‪ .‬ﺍﻳﻦ ﺯﺑﺎﻥ ﺟﺰﺀ ﺍﻭﻟﻴﻦ ﺯﺑﺎﻧﻬﺎﯼ ﺧﻠﻖ ﺷﺪﻩ ﺑﺮﺍﯼ ﮐﺎﻣﭙﻴﻮﺗﺮ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﺩﺭ‬

‫‪ IBM‬ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﻗﺎﺑﻠﻴﺖ ﻣﺤﺎﺳﺒﺎﺕ ﺳﺮﻳﻊ ﺑﺎ ﺳﺎﺩﮔﯽ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺑﺎﻋﺚ ﻣﺤﺒﻮﺑﻴﺖ ﺁﻥ ﺑﻴﻦ ﻣﻬﻨﺪﺳﺎﻥ ﻭ ﺩﺍﻧﺸﻤﻨﺪﺍﻥ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺯﺑﺎﻥ‬

‫ﻓﺮﺗﺮﻥ ﺩﺭ ﺣﺎﻝ ﺣﺎﺿﺮ ﺩﺍﺭﺍﯼ ﻗﺎﺑﻠﻴﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺷﻲﺀ ﮔﺮﺍ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬

‫ﻣﻌﻤﻮ ﹰﻻ ﺍﺯ ﻓﺮﺗﺮﻥ ‪ 77‬ﻭ ‪ 90‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ ﮐﻪ ﻧﺴﺨﻪ ‪ 90‬ﺁﻥ ﻣﺤﺒﻮﺑﻴﺖ ﻋﻤﻮﻣﯽ ﺗﺮﯼ ﺩﺍﺭﺩ‪ .‬ﺩﺭ ﺍﻳﻦ ﻣﺘﻦ ﺍﺯ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻫﺎﯼ ﺑﺮﻧﺎﻣﻪ‬

‫ﻧﻮﻳﺴﯽ ﻓﺮﺗﺮﻥ ‪ 90‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮐﻨﻴﻢ ﻭ ﺩﺭ ﻣﻮﺍﺭﺩ ﻻﺯﻡ ﺩﺭ ﻣﻮﺭﺩ ﻓﺮﺗﺮﻥ ‪ 77‬ﻫﻢ ﺑﺤﺚ ﺧﻮﺍﻫﻴﻢ ﮐﺮﺩ‪.‬‬

‫ﺗﺎﺭﻳﺨﭽﻪ ]‪[2‬‬

‫‪Fortran I 1954‬‬ ‫‪‬‬

‫‪Fortran II 1958‬‬ ‫‪‬‬

‫‪Fortran IV 1958‬‬ ‫‪‬‬

‫‪Fortran 66 standard 1966‬‬ ‫‪‬‬

‫‪Fortran 77 standard 1978‬‬ ‫‪‬‬

 ‫‪Fortran 90 standard 1991‬‬ ‫‪‬‬

‫‪Fortran 95 standard 1996‬‬ ‫‪‬‬

‫ﭼﺮﺍ ﻓﺮﺗﺮﻥ؟‬

‫ﺯﺑﺎﻥ ﺍﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺩﺭ ﮐﺎﺭﺑﺮﺩﻫﺎﯼ ﻋﻠﻤﯽ ﻓﺮﺗﺮﻥ ﺍﺳﺖ‪ .‬ﺍﻏﻠﺐ ﮐﺪﻫﺎﯼ ﻗﺪﻳﻤﯽ ﺑﺎ ﺍﻳﻦ ﺯﺑﺎﻥ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﻻﺯﻡ ﺍﺳﺖ ﮐﻪ ﻳﮏ‬

‫ﺩﺍﻧﺸﺠﻮﯼ ﻣﻬﻨﺪﺳﯽ ﺑﺎ ﺍﻳﻦ ﺯﺑﺎﻥ ﺁﺷﻨﺎﻳﯽ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺳﺎﻟﻬﺎ ﭘﻴﺶ ﺑﻪ ﻧﻈﺮ ﻣﯽ ﺭﺳﻴﺪ ﮐﻪ ﺑﺎ ﭘﻴﺸﺮﻓﺖ ﻭ ﻣﺤﺒﻮﺑﻴﺖ ﻋﻤﻮﻣﯽ ﺯﺑﺎﻧﻬﺎﻳﯽ ﻣﺎﻧﻨﺪ ‪ C‬ﺯﺑﺎﻥ‬

‫ﻓﺮﺗﺮﻥ ﻣﻨﺴﻮﺥ ﮔﺮﺩﺩ‪ ،‬ﺍﻣﺎ ﺑﺎ ﮔﺬﺷﺖ ﺳﺎﻟﻬﺎ ﺍﻳﻦ ﺯﺑﺎﻥ ﻫﻤﭽﻨﺎﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻓﺮﺍﻭﺍﻥ ﺩﺍﺭﺩ‪ .‬ﺍﻳﻦ ﻣﺎﻧﺪﮔﺎﺭﯼ ﻣﺪﻳﻮﻥ ﮐﺘﺎﺑﺨﺎﻧﻪ ﻫﺎ ﻭ ﮐﺪﻫﺎﯼ ‪ 40‬ﺳﺎﻟﻪ ﺍﻳﻦ‬

‫ﺯﺑﺎﻥ ﺍﺳﺖ‪ .‬ﺩﺭ ﻫﺮ ﺣﺎﻝ ﺍﺳﺘﺎﻧﺪﺍﺭﺩﻫﺎﯼ ﺟﺪﻳﺪ ﺍﻳﻦ ﺯﺑﺎﻥ ﻗﺪﺭﺕ ﺯﻳﺎﺩﯼ ﺑﻪ ﺍﻳﻦ ﺯﺑﺎﻥ ﺩﺍﺩﻩ ﺍﺳﺖ‪ .‬ﺍﻳﻦ ﺯﺑﺎﻥ ﻫﻤﭽﻨﺎﻥ ﺑﻌﻨﻮﺍﻥ ﻣﻬﻤﺘﺮﻳﻦ ﺯﺑﺎﻥ ﺑﺮﺍﯼ‬

‫ﻣﻬﻨﺪﺳﺎﻥ ﻭ ﺩﺍﻧﺸﻤﻨﺪﺍﻥ ﺑﺸﻤﺎﺭ ﻣﯽ ﺁﻳﺪ‪ .‬ﻓﺮﺗﺮﻥ ﺑﺮﺍﯼ ﺍﻧﺠﺎﻡ ﻣﺤﺎﺳﺒﺎﺕ ﺭﻳﺎﺿﯽ ﺑﺎ ﺳﺮﻋﺖ ﻭ ﻗﺎﺑﻠﻴﺖ ﺑﺎﻻ ﻃﺮﺍﺣﯽ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺍﻟﺒﺘﻪ ﺯﺑﺎﻥ ﻓﺮﺗﺮﻥ‬

‫ﻫﻨﻮﺯ ﺩﺭ ﺍﻳﺠﺎﺩ ﻣﺤﻴﻂ ﮔﺮﺍﻓﻴﮑﯽ ﮐﻤﺒﻮﺩ ﺩﺍﺭﺩ ﻭ ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﺪ ﺑﺮﺍﯼ ﻓﺮﺗﺮﻥ ﻳﮏ ﺭﺍﺑﻂ ﮔﺮﺍﻓﻴﮑﯽ ﮐﺎﺭﺑﺮ)‪ (Graphical User Interface‬ﺑﻨﻮﻳﺴﻴﺪ‪،‬‬

‫ﺑﺎﻳﺪ ﺧﻮﺩ ﺭﺍ ﺩﺭﮔﻴﺮ ﻓﺮﺍﺧﻮﺍﻧﯽ ﺗﻮﺍﺑﻊ ﻭﻳﻨﺪﻭﺯ)‪ API‬ﻫﺎ!( ﮐﻨﻴﺪ‪ .‬ﺍﻧﺘﺨﺎﺏ ﺭﺍﺣﺖ ﺗﺮ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﺯﺑﺎﻥ ﺳﺎﺩﻩ ﻣﺎﻧﻨﺪ ‪ Visual Basic‬ﻳﺎ ‪ Delphi‬ﺑﺮﺍﯼ‬

‫ﺍﻳﺠﺎﺩ ﺭﺍﺑﻂ ﮔﺮﺍﻓﻴﮑﯽ ﮐﺎﺭﺑﺮ ﺍﺳﺖ‪ .‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ‪ GUI‬ﺭﺍ ﺩﺭ ﺍﻳﻦ ﺯﺑﺎﻧﻬﺎ ﻣﯽ ﺳﺎﺯﻳﻢ ﻭ ﻣﻮﺗﻮﺭ ﺍﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﺑﺮﺍﯼ ﮐﺎﺭ ﺑﺎ ﻣﻌﺎﺩﻻﺕ ﻭ ﺍﻧﺠﺎﻡ ﻣﺤﺎﺳﺒﺎﺕ‬

‫ﺭﺍ ﺩﺭ ‪ FORTRAN‬ﻣﯽ ﻧﻮﻳﺴﻴﻢ ﻭ ﺑﻌﺪ ﺁﻧﺮﺍ ﺑﺎ ﻓﺮﻣﺖ ‪ (Dynamic Link Library) DLL‬ﺩﺭ ﺍﺧﺘﻴﺎﺭ ﺑﺮﻧﺎﻣﻪ ﻗﺮﺍﺭ ﻣﯽ ﺩﻫﻴﻢ‪ .‬ﺍﻳﻨﮑﺎﺭ ﺭﺍ ﺩﺭ ﻣﺮﺍﺣﻞ‬

‫ﭘﻴﺸﺮﻓﺘﻪ ﺗﺮ ﺁﻣﻮﺯﺵ )ﺳﻄﺢ ﻣﺘﻮﺳﻂ( ﺑﻪ ﺷﻤﺎ ﺁﻣﻮﺯﺵ ﺧﻮﺍﻫﻢ ﺩﺍﺩ‪.‬‬

‫ﺑﺮﻧﺎﻣﻪ ‪ Ansys‬ﮐﻪ ﺑﻴﻦ ﻣﻬﻨﺪﺳﺎﻥ ﻣﮑﺎﻧﻴﮏ ﻣﺤﺒﻮﺑﻴﺖ ﺩﺍﺭﺩ ﺑﺎ ﺯﺑﺎﻥ ﻓﺮﺗﺮﻥ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬

‫ﻓﺮﺗﺮﻥ ‪90‬‬

‫ﻓﺮﺗﺮﻥ ‪ 90‬ﻓﺮﺍﺗﺮ ﺍﺯ ﻳﮏ ﻭﻳﺮﺍﻳﺶ ﺟﺪﻳﺪ ﺍﺯ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻓﺮﺗﺮﻥ ﻣﯽ ﺑﺎﺷﺪ ﻭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺭﺍ ﺑﺴﻴﺎﺭ ﺁﺳﺎﻧﺘﺮ ﮐﺮﺩﻩ ﺍﺳﺖ‪ .‬ﺍﻳﻦ ﻭﻳﺮﺍﻳﺶ ﮐﺪﻫﺎﯼ ﻓﺮﺗﺮﻥ‬

‫‪ 77‬ﺭﺍ ﻧﻴﺰ ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﮐﻨﺪ‪ .‬ﻓﺮﺗﺮﻥ ‪ 90‬ﻳﮏ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺍﻧﻌﻄﺎﻑ ﭘﺬﻳﺮ ﻭ ﻗﻮﯼ ﺍﺳﺖ‪ ,‬ﺍﻳﻦ ﺯﺑﺎﻥ ﺍﻣﮑﺎﻧﺎﺕ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺷﻲﺀ ﮔﺮﺍ ﺭﺍ‬

‫ﺩﺍﺭﺍﺳﺖ‪ .‬ﺍﻣﮑﺎﻧﺎﺕ ﺩﺳﺘﺮﺳﯽ ﺑﻪ ﺍﻣﮑﺎﻧﺎﺕ ﺳﻴﺴﺘﻤﯽ ﻣﺎﻧﻨﺪ ﺗﺨﺼﻴﺺ ﺣﺎﻓﻈﻪ‪ ,‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﺷﺎﺭﻩ ﮔﺮﻫﺎ ﻭ ﺑﺴﻴﺎﺭﯼ ﺍﻣﮑﺎﻧﺎﺕ ﺩﻳﮕﺮ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﺷﺪﻩ‬

‫ﺍﺳﺖ؛ ﺑﻌﺒﺎﺭﺕ ﺩﻳﮕﺮ ﻓﺮﺗﺮﻥ ‪ 90‬ﺑﻴﺸﺘﺮ ﺷﺒﻴﻪ ﺑﻪ ‪ C++‬ﺍﺳﺖ ﺗﺎ ﻓﺮﺗﺮﻥ ‪ !77‬ﺍﺭﺗﻘﺎﺀ ﻗﺎﺑﻠﻴﺘﻬﺎﯼ ﻋﺪﺩﯼ‪ ,‬ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ﺣﺎﻟﺖ ﻣﻮﺍﺯﯼ )ﭼﻨﺪ‬
‫ﭘﺮﺩﺍﺯﻧﺪﻩ ﺍﯼ( ﮐﻪ ﻳﮏ ﭘﻴﺸﺮﻓﺖ ﺷﺎﻳﺎﻥ ﺫﮐﺮ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻋﻠﻤﯽ ﻭ ﻧﻮﺷﺘﻦ ﮐﺪﻫﺎﯼ ﻣﻮﺍﺯﯼ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺍﻳﻦ ﺭﻭﻧﺪ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 95‬ﺩﻧﺒﺎﻝ ﺷﺪﻩ‬

‫ﺍﺳﺖ ﻭ ﺍﻧﺘﻈﺎﺭ ﻣﯽ ﺭﻭﺩ ﺩﺭ ﻭﻳﺮﺍﻳﺶ ﻫﺎﯼ ﺟﺪﻳﺪﺗﺮ ﺍﻳﻦ ﺯﺑﺎﻥ ﺍﻣﮑﺎﻧﺎﺕ ﮔﺴﺘﺮﺩﻩ ﺗﺮﯼ ﺑﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻋﻠﻤﯽ ﺑﻪ ﺍﻳﻦ ﺯﺑﺎﻥ ﺍﺿﺎﻓﻪ ﮔﺮﺩﺩ‪.‬‬

‫ﻣﻘﺪﻣﻪ ﮐﺎﺭ ﺑﺎ ‪Digital Visual Fortran‬‬

‫ﺩﺭ ﺍﻳﻦ ﺑﺨﺶ ﺍﻃﻼﻋﺎﺕ ﻻﺯﻡ ﺟﻬﺖ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﻣﺤﻴﻂ ‪ Visual Fortran‬ﺍﺭﺍﺋﻪ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﻣﺤﻴﻂ ‪ Visual Fortran‬ﻫﻤﺎﻥ ﻣﺤﻴﻂ‬

‫ﻼ ﺗﺠﺮﺑﻪ ﮐﺎﺭ ﺑﺎ ﺍﻳﻦ ﻣﺤﻴﻂ ﺭﺍ ﺩﺍﺭﻳﺪ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﻣﻄﺎﻟﺐ ﺭﺍ ﺍﺯ ﺑﺨﺶ ﺑﻌﺪﯼ ﺍﺩﺍﻣﻪ ﺩﻫﻴﺪ‪.‬‬
‫‪ Microsoft Visual Studio‬ﺍﺳﺖ‪ .‬ﺍﮔﺮ ﻗﺒ ﹰ‬

‫ﺑﺮﺍﯼ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ ﺍﺑﺘﺪﺍ ﻳﮏ ﭘﺮﻭﮊﻩ ﻣﯽ ﺳﺎﺯﻳﻢ‪ .‬ﻣﺮﺍﺣﻞ ﺯﻳﺮ ﺭﺍ ﺩﻧﺒﺎﻝ ﮐﻨﻴﺪ‪ .‬ﺳﺎﺩﻩ ﺗﺮﻳﻦ ﺭﺍﻩ ﺑﺮﺍﯼ ﺍﻳﻦ ﮐﺎﺭ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻣﻨﻮﯼ ﻓﺎﻳﻞ ﺍﺳﺖ‪ .‬ﺍﺯ‬

‫ﻣﻨﻮﯼ ﺍﺻﻠﯽ ‪ File‬ﻭ ‪ New‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ‪.‬‬

‫‪New < File -1‬‬

‫ﺍﺯ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﺷﺪﻩ ‪ ،‬ﺑﺮﮔﻪ ‪ Projects‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ‪ .‬ﺩﺭ ﺍﻳﻦ ﺑﺮﮔﻪ ﺁﻳﮑﻮﻥ )‪ Fortran Consol Application ,(Icon‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ‬

‫ﮐﻨﻴﺪ‪ .‬ﻓﺮﺍﻣﻮﺵ ﻧﮑﻨﻴﺪ ﺑﺮﺍﯼ ﭘﺮﻭﮊﻩ ﺩﺭ ﻗﺴﻤﺖ ‪ ،Project Name‬ﻳﮏ ﻧﺎﻡ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ‪.‬‬

‫‪Application Fortran Consol < (tab)Project -2‬‬

‫ﺭﻭﯼ ‪ OK‬ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪ .‬ﺻﻔﺤﻪ ﺍﯼ ﮐﻪ ﻧﻮﻉ ﭘﺮﻭﮊﻩ ﺭﺍ ﺍﺯ ﺷﻤﺎ ﻣﯽ ﭘﺮﺳﺪ‪ ،‬ﻇﺎﻫﺮ ﻣﯽ ﮔﺮﺩﺩ؛ ﺭﻭﯼ ‪ Finish‬ﮐﻠﻴﮏ ﮐﻨﻴﺪ ﺗﺎ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺍﻳﺠﺎﺩ ﺷﻮﺩ‪.‬‬

‫ﺻﻔﺤﻪ ﺍﯼ ﺷﺎﻣﻞ ﺍﻃﻼﻋﺎﺕ ﭘﺮﻭﮊﻩ ﺷﻤﺎ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﺧﻮﺍﻫﺪ ﺷﺪ؛ ﺭﻭﯼ ‪ OK‬ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪ .‬ﭘﺮﻭﮊﻩ ﺷﻤﺎ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺍﻣﺎ ﺍﻳﻦ ﭘﺮﻭﮊﻩ ﺧﺎﻟﯽ ﺍﺳﺖ‪.‬‬

‫ﺣﺎﻻ ﺑﺎﻳﺪ ﺑﺮﻧﺎﻣﻪ ﺍﺻﻠﯽ ﺭﺍ ﺑﻪ ﺍﻳﻦ ﭘﺮﻭﮊﻩ ﺍﺿﺎﻓﻪ ﮐﻨﻴﻢ‪.‬‬

‫ﺑﺮﺍﯼ ﺍﺿﺎﻓﻪ ﮐﺮﺩﻥ ﻓﺎﻳﻞ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ ﺑﻪ ﺍﻳﻦ ﭘﺮﻭﮊﻩ ﺩﻭﺑﺎﺭﻩ ﺍﺯ ﻣﻨﻮﯼ ﺍﺻﻠﯽ ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮐﻨﻴﻢ‪.‬‬

‫‪New < File -3‬‬

‫ﺑﺮﮔﻪ ‪ Files‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ‪ .‬ﺩﺭ ﺍﻳﻦ ﺑﺮﮔﻪ ﺁﻳﮑﻮﻥ ‪ Fortran Free Format Source File‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ )ﺍﻳﻦ ﻗﺎﻟﺐ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻓﺮﺗﺮﻥ ‪90‬‬

‫ﻣﯽ ﺑﺎﺷﺪ( ‪ .‬ﻓﺮﺍﻣﻮﺵ ﻧﮑﻨﻴﺪ ﺑﺮﺍﯼ ﺍﻳﻦ ﻓﺎﻳﻞ ﺩﺭ ﻗﺴﻤﺖ ‪ ،File Name‬ﻳﮏ ﻧﺎﻡ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ‪ .‬ﺗﺎ ﺣﺪ ﻣﻤﮑﻦ ﻧﺎﻡ ﻓﺎﻳﻠﻬﺎ ﺭﺍ ﺑﺎ ﺩﻗﺖ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ ﺗﺎ‬

‫ﺩﺭ ﺁﻳﻨﺪﻩ ﺑﺎ ﺧﻮﺍﻧﺪﻥ ﻧﺎﻡ ﻓﺎﻳﻞ ﺑﺘﻮﺍﻧﻴﺪ ﺑﻪ ﻣﺤﺘﻮﺍﯼ ﺁﻥ ﭘﯽ ﺑﺒﺮﻳﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﺗﻮﺟﻪ ﮐﻨﻴﺪ ﮐﻪ ﭼﮏ ﺑﺎﮐﺲ ‪ Add to project‬ﺗﻴﮏ ﺧﻮﺭﺩﻩ ﺑﺎﺷﺪ‪.‬‬

‫‪Free Format Source File Fortran < (tab)Files -4‬‬

‫ﺭﻭﯼ ﮐﻠﻴﺪ ‪ OK‬ﮐﻠﻴﮏ ﮐﻨﻴﺪ‪ .‬ﻓﺎﻳﻞ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺳﺎﺧﺘﻪ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺣﺎﻝ ﻧﻮﺑﺖ ﺑﻪ ﻧﻮﺷﺘﻦ ﺍﻭﻟﻴﻦ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ ﻣﯽ ﺭﺳﺪ‪ .‬ﻟﻄﻔﺎﹰ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ﺭﺍ ﺩﺭ ﺍﻳﻦ‬

‫ﻓﺎﻳﻞ ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬

‫‪PROGRAM hello_fortran‬‬

‫‪!This is comment in fortran file‬‬

‫‪CHARACTER::A‬‬

‫'‪WRITE(*,*) 'Hello dear user, Fortran is so easy‬‬

‫‪READ(*,*) A‬‬

‫‪END PROGRAM hello_fortran‬‬

‫ﻓﺎﻳﻞ ﺭﺍ ﺫﺧﻴﺮﻩ ﮐﻨﻴﺪ)‪.(File > Save or CTRL+S‬‬

‫ﺑﺮﺍﯼ ﺍﺟﺮﺍﯼ ﺍﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺍﺑﺘﺪﺍ ﺁﻧﺮﺍ ﺗﺮﺟﻤﻪ )‪ (Compile‬ﻣﯽ ﮐﻨﻴﻢ‪ .‬ﺑﺮﺍﯼ ﺍﻳﻨﮑﺎﺭ ﺍﺯ ﻣﻨﻮ ﺍﺻﻠﯽ ‪ Build > Build Hello.exe‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﯽ ﮐﻨﻴﻢ ﻳﺎ‬

‫ﮐﻠﻴﺪ ‪ F7‬ﺭﺍ ﻣﯽ ﺯﻧﻴﻢ‪ .‬ﺍﮔﺮ ﺧﻄﺎﻳﯽ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﺗﻌﺪﺍﺩ ﻭ ﻣﻨﺒﻊ ﺧﻄﺎ ﺩﺭ ﭘﻨﺠﺮﻩ ﺯﻳﺮﻳﻦ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﺧﻮﺍﻫﺪ ﺷﺪ‪ .‬ﺑﺎ ﺩﺍﺑﻞ‪-‬ﮐﻠﻴﮏ‬

‫ﺭﻭﯼ ﺧﻄﺎ‪ ،‬ﻣﻨﺒﻊ ﺧﻄﺎ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﺸﺎﻥ ﺩﺍﺩﻩ ﺧﻮﺍﻫﺪ ﺷﺪ‪ .‬ﺍﮔﺮ ﺧﻄﺎﻳﯽ ﻭﺟﻮﺩ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺑﺮﻧﺎﻣﻪ ﺗﺮﺟﻤﻪ ﺷﺪﻩ ﻭ ﻓﺎﻳﻞ ﺍﺟﺮﺍﻳﯽ ‪hello.exe‬‬

‫ﺳﺎﺧﺘﻪ ﻣﯽ ﺷﻮﺩ‪ .‬ﻭ ﺩﺭ ﭘﻨﺠﺮﻩ ﻭﺿﻌﻴﺖ ﭘﻴﺎﻣﯽ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﻣﯽ ﺷﻮﺩ‪.‬‬

‫)‪Hello.exe - 0 error(s), 0 warning(s‬‬

‫ﺑﺮﺍﯼ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺑﻪ ﻣﺤﻞ ﺫﺧﻴﺮﻩ ﺑﺮﻧﺎﻣﻪ ﺭﻓﺘﻪ ﺩﺭ ﭘﻮﺷﻪ ‪ Debug‬ﺑﺮﻧﺎﻣﻪ ﺍﺟﺮﺍﻳﯽ ﺭﺍ ﻳﺎﻓﺘﻪ ﻭ ﺍﺟﺮﺍ ﮐﻨﻴﺪ ﻳﺎ ﮐﻠﻴﺪ ‪ F5‬ﺭﺍ ﺑﺰﻧﻴﺪ‪ .‬ﻳﺎ ﺍﺯ‬

‫ﺁﻳﮑﻮﻥ ‪ go‬ﺍﺳﺘﻔﺎﺩﻩ ﮐﻨﻴﺪ )ﺍﻳﻦ ﺁﻳﮑﻮﻥ ﺷﺒﻴﻪ ﻳﮏ ﺑﺮﮎ ﮐﺎﻏﺬ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﺳﻤﺖ ﺭﺍﺳﺖ ﺁﻥ ﻳﮏ ﻓﻠﺶ ﺭﻭ ﺑﻪ ﭘﺎﻳﻴﻦ ﻭﺟﻮﺩ ﺩﺍﺭﺩ(‪.‬‬

‫ﺍﺳﺘﺎﻧﺪﺍﺭﺩﻫﺎﯼ ﮐﺪ ﻧﻮﻳﺴﯽ‬

‫ﺑﺮﺍﯼ ﺳﺎﺯﮔﺎﺭﯼ ﻭ ﺧﻮﺍﻧﺎﻳﯽ ﺑﻴﺸﺘﺮ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺑﻬﺘﺮ ﺍﺳﺖ ﮐﻪ ﻗﻮﺍﻧﻴﻦ ﺯﻳﺮ ﺭﺍ ﺭﻋﺎﻳﺖ ﮐﻨﻴﺪ‪.‬‬

‫‪ -1‬ﻫﻤﺔ ﮐﻠﻤﺎﺕ ﮐﻠﻴﺪﯼ ﺍﻳﻦ ﺯﺑﺎﻥ ﺭﺍ ﺑﺎ ﺣﺮﻭﻑ ﺑﺰﺭﮒ ﻭ ﻫﻤﻪ ﭼﻴﺰ ﺩﻳﮕﺮ ﺭﺍ ﺑﺎ ﺣﺮﻭﻑ ﮐﻮﭼﮏ ﺑﻨﻮﻳﺴﻴﺪ )ﺍﻳﻦ ﺯﺑﺎﻥ ﺑﻴﻦ ﺣﺮﻭﻑ ﮐﻮﭼﮏ ﻭ‬

‫ﺑﺰﺭﮒ ﻓﺮﻗﯽ ﻧﻤﯽ ﺩﺍﻧﺪ!(‪ .‬ﺍﻟﺒﺘﻪ ﺍﻳﻦ ﺳﺎﺧﺘﺎﺭ ﺁﻧﭽﻨﺎﻥ ﻣﻨﺎﺳﺐ ﻧﻤﯽ ﺑﺎﺷﺪ ﻭ ﻣﯽ ﺗﻮﺍﻧﺪ ﺧﻮﺍﻧﺎﻳﯽ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﮐﺎﻫﺶ ﺩﻫﺪ ﻭ ﺩﻟﻴﻞ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ‬

‫ﺁﻥ ﻗﺪﻣﺖ ﺍﻳﻦ ﺭﻭﺵ ﺍﺳﺖ‪ .‬ﺩﺭ ﻫﺮ ﺣﺎﻝ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺭﻭﺵ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻣﺪﺭﻥ ﮐﺎﺭ ﺩﺭﺳﺘﯽ ﻧﻴﺴﺖ‪.‬‬

‫‪ -2‬ﺍﺯ ﺩﻧﺪﺍﻧﻪ ﺩﺍﺭ ﮐﺮﺩﻥ ﺩﺭ ﻣﺘﻦ ﺍﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﻭ ﻫﻤﭽﻨﻴﻦ ﺑﻠﻮﮐﻬﺎﯼ ﺩﻳﮕﺮ ﺍﺳﺘﻔﺎﺩﻩ ﮐﻨﻴﺪ‪.‬‬

‫‪ -3‬ﺍﺳﻢ ﺑﺮﻧﺎﻣﻪ ﻫﺎ‪ ،‬ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻭ ﺗﻮﺍﺑﻊ ﺭﺍ ﺩﺭ ﺍﻧﺘﻬﺎﯼ ﺁﻧﻬﺎ ﺫﮐﺮ ﮐﻨﻴﺪ‪.‬‬
 ‫ﺳﺎﺧﺘﺎﺭ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ‬

‫ﺳﺎﺧﺘﺎﺭ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 90‬ﺑﻪ ﺳﺎﺧﺘﺎﺭ ﺯﺑﺎﻧﻬﺎﯼ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺩﻳﮕﺮ ﺷﺒﺎﻫﺖ ﺯﻳﺎﺩﯼ ﺩﺍﺭﺩ ﻭ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪.‬‬

‫‪PROGRAM program_name‬‬

‫‪! Comment and program information‬‬

‫‪Declaration of variables and/or external functions‬‬

‫‪Program body‬‬

‫‪END PROGRAM program_name‬‬

‫‪Declaration and body of user-made functions‬‬

‫ﻣﺜﺎﻝ ﺳﺎﺩﻩ ﺍﯼ ﺍﺯ ﺍﻳﻦ ﺳﺎﺧﺘﺎﺭ ﺭﺍ ﺩﺭ ﺑﺨﺶ ﻗﺒﻠﯽ ﺩﻳﺪﻩ ﺍﻳﺪ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﮐﻤﯽ ﻣﺘﻔﺎﻭﺕ ﻭ ﭘﻴﭽﻴﺪﻩ ﺗﺮ ﺍﺳﺖ! ﺩﺭ ﻓﺮﺗﺮﻥ ‪ ،77‬ﮐﻞ‬

‫ﺻﻔﺤﻪ ﺑﻪ ﺳﺘﻮﻧﻬﺎﻳﯽ ﺗﻘﺴﻴﻢ ﻣﯽ ﮔﺮﺩﺩ ﻭ ﻫﺮ ﺑﺨﺶ ﺍﺯ ﺑﺮﻧﺎﻣﻪ ﻣﺤﻞ ﻣﺸﺨﺼﯽ ﺩﺍﺭﺩ‪ .‬ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﺎﻳﺪ ﺍﺯ ﻗﻮﺍﻧﻴﻦ ﺯﻳﺮ ﭘﻴﺮﻭﯼ ﮐﻨﺪ‪:‬‬

‫ﺗﻤﺎﻡ ﺩﺳﺘﻮﺭﺍﺕ ﻓﺮﺗﺮﻥ ﺑﺎﻳﺪ ﺑﻴﻦ ﺳﺘﻮﻥ ‪ 7‬ﺗﺎ ‪ 72‬ﺍﺯ ﻓﺎﻳﻞ ﻗﺮﺍﺭ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬‬ ‫‪‬‬

‫ﻓﺎﺻﻠﻪ ﺧﺎﻟﯽ ﺑﺮﺍﯼ ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ ﻣﻌﻨﺎﻳﯽ ﻧﺪﺍﺭﺩ ﻭﻟﯽ ﺑﺮﺍﯼ ﺧﻮﺍﻧﺎﻳﯽ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻳﺪ ﺍﺯ ﺁﻧﻬﺎ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ!‬ ‫‪‬‬

‫ﺩﺳﺘﻮﺭﺍﺗﯽ ﮐﻪ ﺩﺭ ﺳﺘﻮﻥ ‪ 1‬ﺗﺎ ‪ 5‬ﺁﻧﻬﺎ ﺧﺎﻟﯽ ﺍﺳﺖ ﺍﻣﺎ ﺩﺭ ﺳﺘﻮﻥ ‪ 6‬ﮐﺎﺭﺍﮐﺘﺮﯼ ﻏﻴﺮ ﺍﺯ ﺻﻔﺮ ﻗﺮﺍﺭ ﺩﺍﺭﺩ ﺑﻪ ﻋﻨﻮﺍﻥ ﺍﺩﺍﻣﻪ‬ ‫‪‬‬

‫ﺩﺳﺘﻮﺭﺍﺕ ﺧﻂ ﻗﺒﻞ ﺑﻪ ﺣﺴﺎﺏ ﻣﯽ ﺁﻳﻨﺪ )ﺣﺪﺍﮐﺜﺮ ﺗﺎ ‪ 19‬ﺧﻂ ﻣﺠﺎﺯ ﺍﺳﺖ!(‪.‬‬

‫ﺷﻤﺎﺭﻩ ﺧﻂ ﺩﺳﺘﻮﺭﺍﺕ ﺑﺎﻳﺪ ﺑﻴﻦ ﺳﺘﻮﻥ ‪ 1‬ﺗﺎ ‪ 5‬ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ ﻭ ﺣﺪﺍﮐﺜﺮ ﻣﯽ ﺗﻮﺍﻧﺪ ﻳﮏ ﻋﺪﺩ ‪ 5‬ﺭﻗﻤﯽ ﺑﺎﺷﺪ )ﻓﺮﺗﺮﻥ ﺑﻪ‬ ‫‪‬‬

‫ﺷﻤﺎﺭﻩ ﺧﻂ ﻧﻴﺎﺯﯼ ﻧﺪﺍﺭﺩ ﻭ ﻓﻘﻂ ﺑﺮﺍﯼ ﺍﺭﺟﺎﻉ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺗﯽ ﻣﺎﻧﻨﺪ ‪ GOTO‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‪.‬‬

‫ﺗﻮﺿﻴﺤﺎﺕ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺳﺘﻮﻥ ﺍﻭﻝ ﺧﻮﺩ ‪ C‬ﺩﺍﺭﻧﺪ‪.‬‬ ‫‪‬‬

‫ﺧﻮﺏ ﺍﺳﺖ ﮐﻪ ﺣﺪﺍﮐﺜﺮ ﺑﺎ ﺩﻭ ﺩﻧﺪﺍﻧﻪ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﺨﺸﻬﺎﯼ ﻣﺨﺘﻠﻒ ﺭﺍ ﻣﺸﺨﺺ ﮐﻨﻴﺪ‪.‬‬ ‫‪‬‬

‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻮﺿﻴﺤﺎﺕ ﺑﺎﻻ ﺳﺎﺧﺘﺎﺭ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪.‬‬

‫‪PROGRAM program_name‬‬

‫‪C‬‬ ‫‪Comment and program information‬‬

‫‪Declare of variables and/or external functions‬‬

‫‪Body of program‬‬

‫‪END PROGRAM program_name‬‬

‫‪Declaration an body of user-made functions‬‬

‫ﻣﯽ ﺗﻮﺍﻥ ﻣﺜﺎﻝ ﻗﺒﻞ ﺭﺍ ﺑﺮﺍﯼ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﻧﻮﺷﺖ‪:‬‬

‫‪PROGRAM hello_fortran‬‬
‫‪C This is comment in fortran file‬‬

‫‪CHARACTER::A‬‬

‫'‪WRITE(*,*) 'Hello dear user, Fortran is so easy‬‬

‫‪READ(*,*) A‬‬

‫‪END PROGRAM hello_fortran‬‬

‫ﻣﺘﻐﻴﺮﻫﺎ‬

‫ﭘﻴﺸﻨﻬﺎﺩ ﻣﯽ ﮔﺮﺩﺩ ﮐﻪ ﻫﻤﺔ ﻣﺘﻐﻴﺮﻫﺎﯼ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺗﻌﺮﻳﻒ )ﺗﻌﻴﻴﻦ ﻧﻮﻉ( ﮔﺮﺩﻧﺪ‪ .‬ﺑﺮﺍﯼ ﺍﻳﻨﮑﻪ ﻫﻴﭻ ﻣﺘﻐﻴﺮﯼ ﺍﺯ ﻗﻠﻢ ﻧﻴﻔﺘﺪ‪ ،‬ﺍﺯ ﺩﺳﺘﻮﺭ‬

‫‪ IMPLICIT NONE‬ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺘﻔﺎﺩﻩ ﮐﻨﻴﺪ‪ .‬ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﻪ ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ ﺧﻮﺍﻫﺪ ﮔﻔﺖ ﮐﻪ ﺍﮔﺮ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻣﺘﻐﻴﺮ ﺗﻌﺮﻳﻒ ﻧﺸﺪﻩ ﺍﯼ‬

‫ﺑﺮﺧﻮﺭﺩ‪ ،‬ﺍﻋﻼﻡ ﺧﻄﺎ ﮐﻨﺪ‪ .‬ﺍﻟﺒﺘﻪ ﻓﺮﺗﺮﻥ ﺑﻪ ﺗﻌﻴﻴﻦ ﻧﻮﻉ ﻧﻴﺎﺯﯼ ﻧﺪﺍﺭﺩ! ﺍﻣﺎ ﺍﻳﻦ ﮐﺎﺭ ﺧﻄﺎﻫﺎﯼ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺷﻤﺎ ﺭﺍ ﮐﺎﻫﺶ ﺧﻮﺍﻧﺪ ﺩﺍﺩ‪ .‬ﺯﺑﺎﻧﻬﺎﯼ ﺑﺮﻧﺎﻣﻪ‬

‫ﻧﻮﻳﺴﯽ ﺯﻳﺎﺩﯼ ﺩﺭ ﺍﻭﻟﻴﻦ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻣﺘﻐﻴﺮ ﺑﺮﺍﯼ ﺁﻥ ﻣﺘﻐﻴﺮ ﻧﻮﻋﯽ ﺩﺭ ﻧﻈﺮ ﻣﯽ ﮔﻴﺮﻧﺪ ﻭ ﻧﻴﺎﺯﯼ ﻧﻴﺴﺖ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻧﻮﻉ ﻣﺘﻐﻴﺮﻫﺎ ﺭﺍ ﻣﺸﺨﺺ‬

‫ﮐﻨﺪ ﺯﺑﺎﻥ ﻓﺮﺗﺮﻥ ﻧﻴﺰ ﭼﻨﻴﻦ ﺍﺳﺖ‪ .‬ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻳﺎ ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺣﺮﻓﻪ ﺍﯼ ﺑﺮﺍﯼ ﻣﺪﺕ ﺯﻳﺎﺩﯼ ﻣﻮﺭﺩ ﺑﺤﺚ‬

‫ﺑﻮﺩ ﺗﺎ ﺍﻳﻨﮑﻪ ﻧﺎﺳﺎ ﻳﮑﯽ ﺍﺯ ﺳﻨﺴﻮﺭﻫﺎﯼ ﺳﻔﻴﻨﻪ ﻓﻀﺎﻳﯽ ﻭﻧﻮﺱ ﺭﺍ ﺑﻌﻠﺖ ﻳﮏ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﺍﺷﺘﺒﺎﻩ ﺗﻮﺳﻂ ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ )ﻣﺘﺮﺟﻢ ﻧﻮﻉ ﺩﻳﮕﺮﯼ ﺭﺍ‬

‫ﺑﺮﺍﯼ ﻣﺘﻐﻴﺮ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺑﻮﺩ( ﺍﺯ ﺩﺳﺖ ﺩﺍﺩ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺑﻌﻨﻮﺍﻥ ﻳﮏ ﺭﻭﺵ ﻣﻨﺎﺳﺐ ﺍﻧﺘﺨﺎﺏ ﺷﺪ‪ .‬ﺧﻮﺷﺒﺨﺘﺎﻧﻪ ﺩﺭ‬

‫ﺑﺴﻴﺎﺭﯼ ﺍﺯ ﺯﺑﺎﻧﻬﺎﯼ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻣﺪﺭﻥ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﺍﺟﺒﺎﺭﯼ ﺍﺳﺖ‪ .‬ﻓﺮﺗﺮﻥ ﺑﺮﺍﯼ ﺩﺍﺷﺘﻦ ﺳﺎﺯﮔﺎﺭﯼ ﺍﺯ ﺗﻌﺮﻳﻒ ﺩﺍﺧﻠﯽ‬

‫ﻣﺘﻐﻴﺮ ﺗﻮﺳﻂ ﻣﺘﺮﺟﻢ ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﮐﻨﺪ‪.‬‬

‫ﻧﺎﻡ ﮔﺬﺍﺭﯼ ﻣﺘﻐﻴﺮﻫﺎ‬

‫ﻗﻮﺍﻧﻴﻦ ﻧﺎﻣﮕﺬﺍﺭﯼ ﻣﺘﻐﻴﺮﻫﺎ ‪:‬‬

‫ﺣﺪﺍﮐﺜﺮ ﻃﻮﻝ ﻧﺎﻡ ﻣﺘﻐﻴﺮﻫﺎ ‪ 34‬ﮐﺎﺭﺍﮐﺘﺮ ﺍﺳﺖ‪.‬‬ ‫‪‬‬

‫ﻓﻘﻂ ﺍﻣﮑﺎﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺣﺮﻭﻑ ﮐﻮﭼﮏ ﻭ ﺑﺰﺭﮒ ﺍﻧﮕﻠﻴﺴﯽ )‪ ،(A...Z, a...z‬ﺍﻋﺪﺍﺩ)‪ (0,1,..,9‬ﻭ ﮐﺎﺭﺍﮐﺘﺮ ﺯﻳﺮ‪-‬ﺧﻂ ) _ (‬ ‫‪‬‬

‫ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬‬

‫ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﮐﻪ ﺑﺰﺭﮔﯽ ﻳﺎ ﮐﻮﭼﮑﯽ ﺣﺮﻭﻑ ﺑﺮﺍﯼ ﻓﺮﺗﺮﻥ ﻓﺮﻗﯽ ﻧﺪﺍﺭﺩ‪.‬‬ ‫‪‬‬

‫ﺍﻭﻟﻴﻦ ﮐﺎﺭﺍﮐﺘﺮ ﻳﮏ ﺍﺳﻢ ﺑﺎﻳﺪ ﺣﺮﻑ ﺑﺎﺷﺪ‪.‬‬ ‫‪‬‬

‫ﺍﺯ ﮐﻠﻤﺎﺕ ﮐﻠﻴﺪﯼ ﺩﺭ ﻧﺎﻣﮕﺬﺍﺭﯼ ﺍﺳﺘﻔﺎﺩﻩ ﻧﮑﻨﻴﺪ‪.‬‬ ‫‪‬‬

‫ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩ ﻫﺎ‬

‫ﺷﻤﺎ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻣﺘﻐﻴﺮﻫﺎ ﺭﺍ ﺑﺮﺍﯼ ﺍﻧﻮﺍﻉ ﻣﺨﺘﻠﻔﯽ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎ ﺑﮑﺎﺭ ﻣﯽ ﺑﺮﻳﺪ‪ .‬ﺍﻧﻮﺍﻋﯽ ﺍﺯ ﺩﺍﺩﻩ ﻫﺎ ﮐﻪ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﭘﻴﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﮔﺮﺩﻧﺪ ﺑﻪ ﺷﺮﺡ ﺯﻳﺮ‬

‫ﺍﺳﺖ‪:‬‬

‫ﻧﻮﻉ ‪ INTEGER‬ﺑﺮﺍﯼ ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ‬ ‫‪‬‬

‫ﻧﻮﻉ ‪ REAL‬ﺑﺮﺍﯼ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﯼ )ﺗﻘﺮﻳﺒﺎﹰ ‪ 8‬ﺭﻗﻢ(‬ ‫‪‬‬

‫ﻧﻮﻉ ‪ DOUBLE‬ﺑﺮﺍﯼ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﯼ ﺑﺎ ﺩﻗﺖ ﺑﻴﺸﺘﺮ )ﺗﻘﺮﻳﺒﺎﹰ ‪ 16‬ﺭﻗﻢ ﻣﻌﻨﯽ ﺩﺍﺭ( ]ﺍﻳﻦ ﺍﻋﺪﺍﺩ ﺭﺍ ﻣﻀﺎﻋﻒ ﻣﯽ ﻧﺎﻣﻴﻢ[‬ ‫‪‬‬

‫ﻧﻮﻉ ‪ CHARACTER‬ﺑﺮﺍﯼ ﻳﮏ ﮐﺎﺭﺍﮐﺘﺮ ﻳﺎ ﺭﺷﺘﻪ ﺍﯼ ﺍﺯ ﮐﺎﺭﺍﮐﺘﺮﻫﺎ‬ ‫‪‬‬

‫ﻧﻮﻉ ‪ LOGICAL‬ﺑﺮﺍﯼ ﻣﻘﺎﺩﻳﺮ ﻣﻨﻄﻘﯽ‬ ‫‪‬‬

‫ﻧﻮﻉ ‪ COMPLEX‬ﺑﺮﺍﯼ ﺍﻋﺪﺍﺩ ﻣﺨﺘﻠﻂ ﺑﻪ ﻋﻨﻮﺍﻥ ﻳﮏ ﺟﻔﺖ ﺑﺎ ﺩﻗﺖ ‪ ،REAL‬ﺍﻏﻠﺐ ﺗﻮﺍﺑﻊ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﺮ ﺭﻭﯼ ﺍﻋﺪﺍﺩ ﻣﺨﺘﻠﻂ‬ ‫‪‬‬

‫ﻗﺎﺑﻞ ﺍﺳﺘﻔﺎﺩﻩ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺛﺎﺑﺖ ﻫﺎﯼ ﻫﻢ ﺑﻪ ﻫﻤﻴﻦ ﺷﮑﻞ ﺑﮑﺎﺭ ﻣﯽ ﺭﻭﻧﺪ ﻣﺜﻼﹰ ‪ 1234‬ﻳﮏ ﻋﺪﺩ ﺛﺎﺑﺖ ﺻﺤﻴﺢ ﺍﺳﺖ‪ 1234.0 ،‬ﻳﺎ ‪ 1.234E3‬ﻳﮏ ﺛﺎﺑﺖ ﺍﻋﺸﺎﺭ ﻭ ‪1.234D3‬‬

‫ﻋﺪﺩ ﺍﻋﺸﺎﺭ ﺑﺎ ﺩﻗﺖ ﻣﻀﺎﻋﻒ ﺍﺳﺖ‪ .‬ﺍﻋﺪﺍﺩ ﻣﺨﺘﻠﻂ ﺑﻪ ﺷﮑﻞ )‪ (3.14,-1E5‬ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﻣﯽ ﺷﻮﻧﺪ ﻭ ﮐﺎﺭﺍﮐﺘﺮﻫﺎ ﺑﻴﻦ ﺩﻭ ﮐﻮﺗﻴﺸﻦ ﻗﺮﺍﺭ ﻣﯽ ﮔﻴﺮﻧﺪ‬

‫’‪ ‘AbBa‬ﻳﺎ ’‪ .‘S‬ﺛﺎﺑﺘﻬﺎﯼ ﻣﻨﻄﻘﯽ ﻓﻘﻂ ﻣﯽ ﺗﻮﺍﻧﻨﺪ ﺩﻭ ﻣﻘﺪﺍﺭ ‪ .TRUE.‬ﻭ ‪ .FALSE.‬ﺭﺍ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ )ﺑﻪ ﻧﻘﺎﻁ ﺍﺑﺘﺪﺍﻳﯽ ﻭ ﺍﻧﺘﻬﺎﻳﯽ ﻫﺮ ﻳﮏ ﺗﻮﺟﻪ‬

‫ﮐﻨﻴﺪ(‪.‬‬

‫ﺍﮔﺮ ﺍﻋﺪﺍﺩ ﺑﺴﻴﺎﺭ ﮐﻮﭼﮏ ﻳﺎ ﺑﺴﻴﺎﺭ ﺑﺰﺭﮒ ﺑﺎﺷﻨﺪ‪ ،‬ﻣﻤﮑﻦ ﺍﺳﺖ ﺳﻴﺴﺘﻢ ﺁﻧﻬﺎ ﺭﺍ ﺻﻔﺮ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻭ ﻣﺸﮑﻞ ﺗﻘﺴﻴﻢ ﺑﺮ ﺻﻔﺮ ﺩﺭ ﻣﺤﺎﺳﺒﺎﺕ ﭘﻴﺶ‬

‫ﺁﻳﺪ ﻳﺎ ﺍﻳﻨﮑﻪ ﺳﻴﺴﺘﻢ ﺩﭼﺎﺭ ﺳﺮ ﺭﻳﺰ ﮔﺮﺩﺩ‪ .‬ﺍﻳﻦ ﺧﻄﺎﻫﺎ ﺑﺴﻴﺎﺭ ﺭﺍﻳﺞ ﻫﺴﺘﻨﺪ ﻭ ﺍﺷﮑﺎﻝ ﮔﺰﺍﺭﺵ ﺷﺪﻩ ﺑﻪ ﺳﻴﺴﺘﻢ ﺑﺴﺘﮕﯽ ﺧﻮﺍﻫﺪ ﺩﺍﺷﺖ‪.‬‬

‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮﻫﺎ‬

‫ﺑﺮﺍﯼ ﺗﺨﺼﻴﺺ ﺣﺎﻓﻈﻪ ﻻﺯﻡ ﺑﻪ ﻣﺘﻐﻴﺮﻫﺎ‪ ،‬ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ )‪ (Compiler‬ﺑﺎﻳﺪ ﻧﺎﻡ‪ ،‬ﻧﻮﻉ ﻭ ﺍﻧﺪﺍﺯﻩ ﻫﺮ ﻣﺘﻐﻴﺮ ﺭﺍ ﺑﺪﺍﻧﺪ‪ .‬ﺍﮔﺮ ﺍﺯ ﺩﺳﺘﻮﺭ ‪IMPILICIT‬‬

‫‪ NONE‬ﺍﺳﺘﻔﺎﺩﻩ ﮔﺮﺩﺩ‪ ،‬ﻻﺯﻡ ﺍﺳﺖ ﮐﻪ ﺗﻤﺎﻡ ﻣﺘﻐﻴﺮﻫﺎ ﺗﻌﺮﻳﻒ ﮔﺮﺩﻧﺪ‪ .‬ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ﻧﻮﻉ ﻣﺘﻐﻴﺮ ﺑﺎ ﺣﺮﻑ ﺍﻭﻝ ﺁﻥ ﻣﺸﺨﺺ ﻣﯽ ﮔﺮﺩﺩ‪.‬‬

‫‪ a..h‬ﻭ ‪ o..z‬ﺑﺮﺍﯼ ﻣﺘﻐﻴﺮﻫﺎﯼ ﺍﻋﺸﺎﺭ‬ ‫‪‬‬

‫‪ i,j,k,l,m,n‬ﺑﺮﺍﯼ ﻣﺘﻐﻴﺮﻫﺎﯼ ﺻﺤﻴﺢ‬ ‫‪‬‬

‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﺑﺎ ﺩﺳﺘﻮﺭ ﺯﻳﺮ ﺻﻮﺭﺕ ﻣﯽ ﮔﻴﺮﺩ )ﺍﻳﻦ ﺗﻌﺮﻳﻒ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺑﺴﻴﺎﺭ ﭘﺴﻨﺪﻳﺪﻩ ﺍﺳﺖ(‪:‬‬

‫]‪Variable_type::variable_name [=initial value‬‬ ‫‪REAL:: alpha, beta, c=10.0‬‬

‫‪INTEGER:: count, hours, minutes=36‬‬

‫ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﺪ ﻣﻘﺪﺍﺭ ﺛﺎﺑﺘﯽ ﺭﺍ ﺗﻌﺮﻳﻒ ﮐﻨﻴﺪ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ PARAMETER‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‬

‫)}‪PARAMETER ({list of names=value‬‬ ‫)‪PARAMETER (pi=3.141592‬‬

‫ﻋﺒﺎﺭﺍﺕ ﺳﺎﺩﻩ‬

‫ﻋﺒﺎﺭﺍﺕ ﻭ ﻋﻤﻠﻴﺎﺕ ﻣﺤﺎﺳﺒﺎﺗﯽ‬

‫ﻋﻤﻠﮕﺮﻫﺎﻳﯽ ﻣﺎﻧﻨﺪ ‪) / ، - ، +‬ﻫﻤﺎﻥ ÷ ﺍﺳﺖ( ﻭ * )ﻫﻤﺎﻥ × ﺍﺳﺖ( ﺭﺍ ﻣﯽ ﺷﻨﺎﺳﻴﺪ‪ .‬ﻋﻤﻠﮕﺮ ﺗﻮﺍﻥ ﺩﺭ ﻓﺮﺗﺮﻥ ﺑﻪ ﺷﮑﻞ ** ﺍﺳﺖ‪ .‬ﺍﻭﻟﻮﻳﺖ ﻣﺤﺎﺳﺒﻪ‬

‫ﺩﺭ ﻋﺒﺎﺭﺍﺕ‬

‫‪ .1‬ﭘﺮﺍﻧﺘﺰ – ﺍﮔﺮ ﺩﺭ ﻋﺒﺎﺭﺍﺕ‪ ،‬ﭘﺮﺍﻧﺘﺰ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺍﻭﻝ ﺩﺍﺧﻠﯽ ﺗﺮﻳﻦ ﭘﺮﺍﻧﺘﺰ ﻣﺤﺎﺳﺒﻪ ﺧﻮﺍﻫﺪ ﺷﺪ ﻭ ﺑﻪ ﻫﻤﻴﻦ ﺗﺮﺗﻴﺐ‬

‫ﻋﺒﺎﺭﺍﺕ ﺩﺍﺧﻞ ﭘﺮﺍﻧﺘﺰ ﺍﻭﻟﻮﻳﺖ ﺍﻭﻝ ﺭﺍ ﺩﺍﺭﻧﺪ‪.‬‬

‫‪ .2‬ﺗﻮﺍﻥ‬

‫‪ .3‬ﺿﺮﺏ ﻭ ﺗﻘﺴﻴﻢ‬

‫‪ .4‬ﺟﻤﻊ ﻭ ﻣﻨﻬﺎ‬

‫‪ A*B**n-C/D‬ﻭ )‪ A*(B**n)-(C/D‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻋﺒﺎﺭﺕ ﻭ ﻳﮑﺴﺎﻥ ﻫﺴﺘﻨﺪ‪.‬‬

‫‪The image part with‬‬

‫ﻭ‬ ‫ﺍﮔﺮ ﺩﻭ ﻋﺒﺎﺭﺕ ﺍﺯ ﺍﻭﻟﻮﻳﺖ ﻳﮑﺴﺎﻧﯽ ﺑﺮﺧﻮﺭﺩﺍﺭ ﺑﺎﺷﻨﺪ‪ ،‬ﻣﺤﺎﺳﺒﻪ ﺍﺯ ﭼﭗ ﺑﻪ ﺭﺍﺳﺖ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻋﺒﺎﺭﺕ‬
‫‪The image part with relationship ID‬‬
‫‪rId6 was not found in the file.‬‬ ‫‪relationship ID rId5 was not‬‬
‫‪found in the file.‬‬

‫ﻳﮑﺴﺎﻥ ﻫﺴﺘﻨﺪ‪ .‬ﻻﺯﻡ ﺍﺳﺖ ﺑﺪﺍﻧﻴﺪ ﮐﻪ ﺣﺎﺻﻞ ﻋﻤﻠﻴﺎﺕ ﺑﻴﻦ ﺩﻭ ﺍﻋﺸﺎﺭ‪ ،‬ﺍﻋﺸﺎﺭ ﺍﺳﺖ ﻭ ﺣﺎﺻﻞ ﻋﻤﻠﻴﺎﺕ ﺑﻴﻦ ﺩﻭ ﻋﺪﺩ ﺻﺤﻴﺢ‪ ،‬ﻋﺪﺩ ﺻﺤﻴﺢ ﺍﺳﺖ؛‬

‫ﺣﺎﺻﻞ ﻋﻤﻠﻴﺎﺕ ﺑﻴﻦ ﻋﺪﺩ ﺍﻋﺸﺎﺭ ﻭ ﻋﺪﺩ ﺻﺤﻴﺢ‪ ،‬ﻋﺪﺩ ﺍﻋﺸﺎﺭ ﺍﺳﺖ‪ .‬ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺣﺎﺻﻞ ‪ 1/5‬ﺑﺮﺍﺑﺮ ‪ 0‬ﺻﺤﻴﺢ ﺍﺳﺖ‪ ،‬ﺣﺎﺻﻞ ‪ 1./5.‬ﺑﺮﺍﺑﺮ‬

‫‪0.2‬ﺍﻋﺸﺎﺭ ﺍﺳﺖ ﻭ ﺣﺎﺻﻞ ‪ 1d0/1d5‬ﺑﺮﺍﺑﺮ ‪ 0.2‬ﻣﻀﺎﻋﻒ ﺍﺳﺖ‪ .‬ﺑﻄﻮﺭ ﮐﻠﯽ ﻣﯽ ﺗﻮﺍﻥ ﮔﻔﺖ ﮐﻪ ﺩﺭ ﻣﺤﺎﺳﺒﻪ ﻋﺒﺎﺭﺍﺕ ﺍﮔﺮ ﺗﺒﺪﻳﻞ ﻧﻮﻉ ﻻﺯﻡ ﺑﺎﺷﺪ‪،‬‬

‫ﻣﺘﻐﻴﺮﻫﺎ ﺑﻪ ﻣﺘﻐﻴﺮ ﺑﺎ ﺑﺎﻻﺗﺮﻳﻦ ﺩﻗﺖ ﺗﺒﺪﻳﻞ ﻣﯽ ﮔﺮﺩﻧﺪ‪ .‬ﺩﺭ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻋﺪﺍﺩ ﺩﻗﺖ ﮐﻨﻴﺪ‪ ،‬ﻋﺪﺩ ‪ 4‬ﺻﺤﻴﺢ ﺍﺳﺖ‪ ،‬ﻋﺪﺩ ‪ 4.‬ﺍﻋﺸﺎﺭ ﻭ ﻋﺪﺩ ‪4d0‬‬

‫ﻣﻀﺎﻋﻒ ﺍﺳﺖ‪.‬‬

‫ﺑﺮﺍﺑﺮ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ﻣﻘﺪﺍﺭ ﻳﮏ ﻣﺘﻐﻴﺮ ﺑﺎ ﻳﮏ ﻋﺒﺎﺭﺕ ﻳﮑﯽ ﺍﺯ ﺳﺎﺩﻩ ﺗﺮﻳﻦ ﻋﺒﺎﺭﺍﺕ ﻫﺮ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺍﺳﺖ‪.‬‬

‫‪variable = expression‬‬

‫‪The image part with relationship ID rId7‬‬

‫‪was not found in the file.‬‬
‫‪The image part with relationship ID rId8 was not found in the‬‬

‫ﻧﻮﺷﺘﻪ ﻣﯽ ﺷﻮﺩ ﻭ ﮐﺎﻣﭙﻴﻮﺗﺮ ﺑﻌﺪ ﺍﺯ ﻣﺤﺎﺳﺒﻪ ﻋﺒﺎﺭﺕ‬ ‫‪file.‬‬

‫ﺩﺭ ﻓﺮﺗﺮﻥ ﺑﺼﻮﺭﺕ‬ ‫ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻋﺒﺎﺭﺕ ﺭﻳﺎﺿﯽ‬

‫ﺳﻤﺖ ﺭﺍﺳﺖ‪ ،‬ﻣﻘﺪﺍﺭ ﺁﻧﺮﺍ ﺩﺭ ﻣﺘﻐﻴﺮ ‪ a‬ﻗﺮﺍﺭ ﻣﯽ ﺩﻫﺪ‪ .‬ﮐﺎﺭﺑﺮﺩ ﭘﺮﺍﻧﺘﺰ ﺩﺭ ﻋﺒﺎﺭﺍﺕ ﺭﻳﺎﺿﯽ ﺑﻪ ﺧﻮﺍﻧﺎﻳﯽ ﺑﻴﺸﺘﺮ ﺑﺮﻧﺎﻣﻪ ﻭ ﺟﻠﻮﮔﻴﺮﯼ ﺍﺯ ﺍﺷﺘﺒﺎﻩ ﮐﻤﮏ ﻣﯽ‬

‫ﮐﻨﺪ‪.‬‬
 ‫ﻣﻘﺎﻳﺴﻪ ﻣﺘﻐﻴﺮﻫﺎ‬

‫ﻣﻘﺎﻳﺴﻪ ﻣﺘﻐﻴﺮﻫﺎ ﺑﻪ ﮐﺎﻣﭙﻴﻮﺗﺮ ﻗﺪﺭﺕ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﺩﺍﺩﻩ ﺍﺳﺖ‪ .‬ﻣﺘﺄﺳﻔﺎﻧﻪ ﻓﺮﺗﺮﻥ ‪ 77‬ﺍﺯ ﻋﺒﺎﺭﺍﺗﯽ ﻣﺎﻧﻨﺪ >‪ < ,‬ﻭ ‪ ...‬ﺭﺍ ﺑﻪ ﺍﻳﻦ ﺷﮑﻞ ﭘﺸﺘﻴﺒﺎﻧﯽ ﻧﻤﯽ‬

‫ﮐﻨﺪ ﻭ ﺑﺠﺎﯼ ﺁﻧﻬﺎ ﻣﻘﺎﻳﺴﻪ ﺭﺍ ﺑﺎ ﻋﺒﺎﺭﺍﺗﯽ ﭼﻮﻥ ‪ .EQ.‬ﺍﻧﺠﺎﻡ ﻣﯽ ﺩﻫﺪ‪.‬‬

‫‪.EQ. equal to‬‬

‫‪.GE. greater or equal to‬‬

‫‪.GT. greater than‬‬

‫‪.LE. less than or equal to‬‬

‫‪.LT. less than‬‬

‫‪.NE. not equal to‬‬

‫ﺍﻳﻦ ﻣﺸﮑﻞ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 90‬ﺣﻞ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﻓﺮﺗﺮﻥ ‪ 90‬ﻋﻼﻣﺘﻬﺎﯼ >‪ == ،=> ،=< ،< ،‬ﻭ >< ﺭﺍ ﻫﻢ ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﮐﻨﺪ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻋﺒﺎﺭﺕ‬

‫)‪ (A .EQ. B‬ﻣﻌﺎﺩﻝ )‪ (A==B‬ﻭ ﻳﮏ ﻋﺒﺎﺭﺕ ﻣﻨﻄﻘﯽ ﺍﺳﺖ‪ ،‬ﺍﻳﻦ ﻋﺒﺎﺭﺕ ﺩﺭ ﺻﻮﺭﺗﯽ ﺻﺤﻴﺢ ﺍﺳﺖ ﮐﻪ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮﻫﺎ ﺑﺎ ﻫﻢ ﺑﺮﺍﺑﺮ ﺑﺎﺷﺪ‪ .‬ﺩﺭ ﻫﺮ ﺣﺎﻝ‬

‫ﺣﺎﺻﻞ ﻳﮏ ﻋﺒﺎﺭﺕ ﻣﻘﺎﻳﺴﻪ ﺍﯼ ﻳﮏ ﻣﻘﺪﺍﺭ ﻣﻨﻄﻘﯽ ﺧﻮﺍﻫﺪ ﺑﻮﺩ ﮐﻪ ﻣﯽ ﺗﻮﺍﻧﺪ ﺩﺭﺳﺖ ﻳﺎ ﺍﺷﺘﺒﺎﻩ ﺑﺎﺷﺪ‪.‬‬

‫ﻋﺒﺎﺭﺍﺕ ﻣﻨﻄﻘﯽ‬

‫ﺩﺳﺘﻮﺭﺍﺕ ﻣﻨﻄﻘﯽ ﺍﻳﻦ ﺯﺑﺎﻥ ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ‪:‬‬

‫‪.NOT.‬‬ ‫‪logical negative‬‬

‫‪.AND.‬‬ ‫‪logical and‬‬

‫‪.OR.‬‬ ‫‪logical or‬‬

‫‪.EQV.‬‬ ‫‪logical equivalence‬‬

‫‪.NEQV.‬‬ ‫)‪logical non-equivalence (exclusive or‬‬

‫‪T: TRUE, F:FALSE‬‬

‫‪x .NEQV. y‬‬ ‫‪x .EQV. y‬‬ ‫‪x .OR. y‬‬ ‫‪x .AND. y‬‬ ‫‪.NOT. x‬‬ ‫‪y‬‬ ‫‪x‬‬

‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬

‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪F‬‬ ‫‪T‬‬

‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪F‬‬

 ‫‪F‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪F‬‬ ‫‪T‬‬ ‫‪T‬‬

‫ﮐﺎﺭﺍﮐﺘﺮ ﻭ ﺭﺷﺘﻪ‬

‫ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﺭﺷﺘﻪ ﻫﺎ ﺑﺎﻳﺪ ﺍﻧﺪﺍﺯﻩ ﺍﯼ ﺛﺎﺑﺖ ﻭ ﺍﺯ ﭘﻴﺶ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ .‬ﺗﻌﺮﻳﻒ ﺭﺷﺘﻪ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﻪ ﺍﻳﻦ ﺷﮑﻞ ﺍﺳﺖ‪:‬‬

‫‪CHARACTER name*length‬‬

‫ﻫﻤﭽﻨﻴﻦ ﻣﯽ ﺗﻮﺍﻥ ﺁﺭﺍﻳﻪ ﺍﯼ ﺍﺯ ﺭﺷﺘﻪ ﻫﺎ ﺗﻌﺮﻳﻒ ﮐﺮﺩ‪:‬‬

‫‪CHARACTER array (size)*length‬‬

‫ﺑﺮﺍﯼ ﻧﻮﺷﺘﻦ ﺭﺷﺘﻪ ﻫﺎﯼ ﺛﺎﺑﺖ ﺗﻌﺪﺍﺩ ﻻﺯﻡ ﻧﻴﺴﺖ ﻭ ﺑﺠﺎﯼ ﺁﻥ ﺍﺯ * ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‪.‬‬

‫)*(*‪CHARACTER format_scope‬‬

‫)’!‪PARAMETER(format_scope=’this is constant character‬‬

‫ﺩﻭ ﻋﻤﻠﻴﺎﺕ ﺳﺎﺩﻩ ﺑﺎ ﺭﺷﺘﻪ ﻫﺎﯼ ﮐﺎﺭﺍﮐﺘﺮﯼ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ ﺍﺳﺘﺨﺮﺍﺝ ﺑﺨﺸﯽ ﺍﺯ ﺭﺷﺘﻪ ﻳﺎ ﭘﻴﻮﻧﺪ ﺩﻭ ﺭﺷﺘﻪ ﺑﻪ ﻳﮑﺪﻳﮕﺮ‪ .‬ﺍﺳﺘﺨﺮﺍﺝ ﺑﺨﺸﯽ‬

‫ﺍﺯ ﺭﺷﺘﻪ ﺑﺎ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ﻋﻼﻣﺖ ‪ :‬ﺑﻴﻦ ﺷﺮﻭﻉ ﻭ ﭘﺎﻳﺎﻥ ﺑﺨﺶ ﻣﻮﺭﺩ ﻧﻈﺮ ﺻﻮﺭﺕ ﻣﯽ ﮔﻴﺮﺩ‪ .‬ﺑﺮﺍﯼ ﺗﺮﮐﻴﺐ ﺭﺷﺘﻪ ﻫﺎ ﺍﺯ ﻋﻼﻣﺖ ‪ //‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‪.‬‬

‫)‪substring= string(start position: end position‬‬

‫ﺑﺮﺍﯼ ﮐﺎﺭﺍﮐﺘﺮﻫﺎﯼ ﺷﺮﻭﻉ ﻭ ﭘﺎﻳﺎﻥ‪ ,‬ﻣﯽ ﺗﻮﺍﻥ ﻋﺪﺩ ﺷﺮﻭﻉ ﻳﺎ ﭘﺎﻳﺎﻥ ﺭﺍ ﻧﻨﻮﺷﺖ‪.‬‬

‫‪CHARACTER first_word*8, second_word*5, third_word*20‬‬

‫’‪first_word=’FORTRAN‬‬

‫)‪second_word=first_word(:3‬‬

‫)‪third_word=second_word // first_word(4:‬‬

‫ﻣﺘﻐﻴﺮ ‪ third_word‬ﭘﺲ ﺍﺯ ﺍﺟﺮﺍﯼ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺑﺮﺍﺑﺮ ﺭﺷﺘﻪ ﮐﺎﺭﺍﮐﺘﺮﯼ ‪ FOR TRAN‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ) ﻓﺎﺻﻠﻪ ﺑﻌﻠﺖ ﺍﻧﺪﺍﺯﻩ ﻣﺘﻐﻴﺮ‬

‫‪ second_word‬ﺍﺳﺖ(‪.‬‬

‫ﺗﻮﺍﺑﻊ ﺭﺷﺘﻪ ﺍﯼ‬

‫ﺩﺭ ﺗﻮﺍﺑﻊ ﺩﺍﺧﻠﯽ ﻓﺮﺗﺮﻥ‪ ،‬ﺗﻮﺍﺑﻊ ﺭﺷﺘﻪ ﺍﯼ ﻧﻴﺰ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺗﺎﺑﻊ ‪ LEN‬ﺍﻧﺪﺍﺯﻩ ﺭﺷﺘﻪ ﻣﯽ ﺩﻫﺪ‪ ،‬ﺗﻮﺍﺑﻊ ‪ CHAR‬ﻭ ‪ ICHAR‬ﺑﺘﺮﺗﻴﺐ ﺑﺮﺍﯼ‬

‫ﺗﺒﺪﻳﻞ ﻋﺪﺩ ﺻﺤﻴﺢ ﺑﻪ ﮐﺎﺭﺍﮐﺘﺮ ﻭ ﺗﺒﺪﻳﻞ ﮐﺎﺭﺍﮐﺘﺮ ﺑﻪ ﻋﺪﺩ ﺻﺤﻴﺢ ﺑﻪ ﮐﺎﺭ ﻣﯽ ﺭﻭﻧﺪ‪ INDEX .‬ﺑﺮﺍﯼ ﻳﺎﻓﺘﻦ ﻳﮏ ﺭﺷﺘﻪ ﺩﺭ ﺭﺷﺘﻪ ﺩﻳﮕﺮ ﮐﺎﺭﺑﺮﺩ ﺩﺍﺭﺩ‪.‬‬
‫ﺗﻮﺍﺑﻊ ﻣﻘﺎﻳﺴﻪ ﺭﺷﺘﻪ ﻫﺎ ﻣﺎﻧﻨﺪ ‪ LLE ،LGT ،LGE‬ﻭ ‪ LLT‬ﻭ ﺑﺴﻴﺎﺭﺱ ﺍﺯ ﺗﻮﺍﺑﻊ ﺩﻳﮕﺮ ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﮐﻪ ﺩﺭ ﺻﻮﺭﺕ ﻧﻴﺎﺯ ﺍﻣﮑﺎﻥ ﻣﻄﺎﻟﻌﻪ ﺁﻧﻬﺎ ﺭﺍ ﺧﻮﺍﻫﻴﺪ‬

‫ﺩﺍﺷﺖ‪.‬‬

‫ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ‬

‫ﺩﺭ ﺍﻏﻠﺐ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻧﻴﺎﺯ ﺩﺍﺭﻳﻢ ﮐﻪ ﺍﻃﻼﻋﺎﺕ ﻭﺭﻭﺩﯼ ﺭﺍ ﺍﺯ ﺻﻔﺤﻪ ﮐﻠﻴﺪ ﻳﺎ ﻓﺎﻳﻞ ﺑﺨﻮﺍﻧﻴﻢ ﻭ ﺍﻃﻼﻋﺎﺕ ﺧﺮﻭﺟﯽ ﺭﺍ ﺩﺭ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﻧﺸﺎﻥ ﺩﻫﻴﻢ ﻳﺎ‬

‫ﺁﻧﻬﺎ ﺭﺍ ﺩﺭ ﻓﺎﻳﻞ ﺧﺮﻭﺟﯽ ﺫﺧﻴﺮﻩ ﮐﻨﻴﻢ‪.‬‬

‫ﺩﺳﺘﻮﺭ ‪READ‬‬

‫ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﺮﺍﯼ ﺩﺭﻳﺎﻓﺖ ﻭﺭﻭﺩﯼ ﺍﺯ ﺻﻔﺤﻪ ﮐﻠﻴﺪ ﺑﮑﺎﺭ ﻣﯽ ﺭﻭﺩ ﻭ ﺳﺎﺧﺘﺎﺭ ﺁﻥ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪.‬‬

‫‪READ *, {input list} or‬‬

‫}‪RAED([UNIT=] unit type, [FMT=] format) {input list‬‬

‫‪ unit type‬ﻋﺪﺩﯼ ﺍﺳﺖ ﮐﻪ ﻧﻮﻉ ﻭﺭﻭﺩﯼ ﺭﺍ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ‪ ،‬ﻣﺜﻼﹰ ‪ 5‬ﺑﺮﺍﯼ ﺻﻔﺤﻪ ﮐﻠﻴﺪ‪ ،‬ﺍﻳﻦ ﻋﺪﺩ ﺍﻏﻠﺐ ﺑﺮﺍﯼ ﺧﻮﺍﻧﺪﻥ ﻭﺭﻭﺩﯼ ﺍﺯ ﻓﺎﻳﻞ ﺑﮑﺎﺭ ﻣﯽ‬

‫ﺭﻭﺩ‪ format .‬ﺑﺮﺍﯼ ﺩﺭﻳﺎﻓﺖ ﻭﺭﻭﺩﯼ ﻣﻌﻤﻮﻻﹰ * ﺍﺳﺖ‪ ،‬ﺍﻣﺎ ﮐﺎﺭﺑﺮﺩ ﺍﺻﻠﯽ ﺁﻥ ﺑﺮﺍﯼ ﺧﻮﺍﻧﺪﻥ ﻭﺭﻭﺩﯼ ﻓﺮﻣﺖ ﺷﺪﻩ ﺍﺯ ﻓﺎﻳﻞ ﺍﺳﺖ‪.‬‬

‫‪READ (*,*) a, b, c‬‬

‫ﺩﺳﺘﻮﺭ ‪WRITE‬‬

‫ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﺮﺍﯼ ﻧﻤﺎﻳﺶ ﺧﺮﻭﺟﯽ ﺩﺭ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﻳﺎ ﻓﺮﺳﺘﺎﺩﻥ ﺧﺮﻭﺟﯽ ﺑﻪ ﭘﺮﻳﻨﺘﺮ ﻳﺎ ﻓﺎﻳﻞ ﺧﺮﻭﺟﯽ ﺑﮑﺎﺭ ﻣﯽ ﺭﻭﺩ‪.‬‬

‫}‪PRINT *,{output list‬‬

‫}‪WRITE([UNIT=] unit type, [FMT=] format) {output list‬‬

‫ﻣﺎﻧﻨﺪ ﺩﺳﺘﻮﺭ ‪ unit type ،READ‬ﻧﻮﻉ ﺧﺮﻭﺟﯽ ﺭﺍ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﻭ ‪ format‬ﻓﺮﻣﺖ ﺧﺮﻭﺟﯽ ﺭﺍ ﺗﻌﻴﻴﻦ ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪WRITE(*,*) ‘The total is:’, total‬‬

‫ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺍﺑﺘﺪﺍ ﺭﺷﺘﻪ ‪ The total is:‬ﻭ ﺩﺭ ﺍﺩﺍﻣﻪ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ‪ total‬ﺭﺍ ﺭﻭﯼ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﻧﺸﺎﻥ ﺧﻮﺍﻫﺪ ﺩﺍﺩ‪.‬‬

‫ﺗﻌﻴﻴﻦ ﻗﺎﻟﺐ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ‪ -‬ﺩﺳﺘﻮﺭ ‪FORMAT‬‬

‫ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﻗﺎﻟﺐ ﺑﻨﺪﯼ ﺩﺍﺩﻩ ﺭﺍ ﺗﻌﻴﻴﻦ ﻣﯽ ﮐﻨﺪ ﻭ ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﺑﮑﺎﺭ ﻣﯽ ﺭﻭﺩ‪ .‬ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﻪ ﺩﻭ ﺻﻮﺭﺕ ﺑﻪ ﮐﺎﺭ ﻣﯽ ﺭﻭﺩ‪ .‬ﻳﮏ‬

‫ﺭﻭﺵ ﺍﺳﺘﻔﺎﺩﻩ ﻣﺴﺘﻘﻴﻢ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺩﺭ ﺑﺨﺶ ‪ format‬ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﺍﺳﺖ‪ .‬ﺭﻭﺵ ﺩﻭﻡ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ﻳﮏ ﺷﻤﺎﺭﻩ ﺧﻂ ﻗﺒﻞ ﺍﺯ ﺍﻳﻦ‬
‫ﺩﺳﺘﻮﺭ )ﺷﻤﺎﺭﻩ ﺧﻂ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﻴﻦ ﺧﻂ ‪ 1‬ﺗﺎ ‪ 5‬ﻗﺮﺍﺭ ﻣﯽ ﮔﻴﺮﺩ‪ (.‬ﻭ ﺍﺭﺟﺎﻉ ﺍﻳﻦ ﺷﻤﺎﺭﻩ ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﺍﺳﺖ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺍﻳﻦ‬

‫ﺩﺳﺘﻮﺭ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪.‬‬

‫)‪FORMAT (format sequence‬‬

‫ﻳﺎ ﺍﮔﺮ ﺩﺍﺧﻞ ﺩﺳﺘﻮﺭﺍﺗﯽ ﭼﻮﻥ ‪ WRITE‬ﻗﺮﺍﺭ ﮔﻴﺮﺩ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬

‫)’‪FMT= (‘format sequence‬‬

‫ﺳﺎﺧﺘﺎﺭ ﺍﺳﺘﻔﺎﺩﻩ ﺷﺪﻩ ﺩﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﻣﺸﺨﺺ ﮐﻨﻨﺪﻩ ﺗﻌﺪﺍﺩ ﺍﺭﻗﺎﻡ ﺧﺮﻭﺟﯽ ﻭ ﺷﮑﻞ ﻧﻤﺎﻳﺶ ﺁﻧﻬﺎﺳﺖ‪.‬‬

‫ﻫﻤﺎﻧﻄﻮﺭ ﮐﻪ ﺩﺭ ﻣﺜﺎﻟﻬﺎﯼ ﻗﺒﻠﯽ ﻣﺘﻮﺟﻪ ﺷﺪﻩ ﺍﻳﺪ؛ ﺍﮔﺮ ﻗﺎﻟﺐ ﺑﻨﺪﯼ ﺁﺯﺍﺩ ﺍﻧﺘﺨﺎﺏ ﮔﺮﺩﺩ‪ ،‬ﻣﯽ ﺗﻮﺍﻥ ﺑﺠﺎﯼ ﺍﻳﻦ ﺑﺨﺶ ﺩﺭ ﺩﺳﺘﻮﺭﺍﺕ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ‬

‫ﺍﺯ * ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ‪.‬‬

‫ﺗﺮﺗﻴﺐ ﻗﺎﻟﺐ ﺑﻨﺪﯼ ‪format sequence‬‬

‫ﺑﺮﺍﯼ ﻣﺸﺨﺺ ﮐﺮﺩﻥ ﻗﺎﻟﺐ ﺑﻨﺪﯼ ﺩﺭ ﺩﺳﺘﻮﺭ ‪ ،FORMAT‬ﻗﺎﻟﺐ ﻫﺮ ﻣﺘﻐﻴﺮ ﺑﺎﻳﺪ ﻣﺸﺨﺺ ﮔﺮﺩﺩ‪ .‬ﺍﻳﻦ ﻗﺎﻟﺐ ﺑﻨﺪﯼ ﺷﺎﻣﻞ ﻧﻮﻉ ﻣﺘﻐﻴﺮ ﻭ ﺗﻌﺪﺍﺩ ﺍﺭﻗﺎﻡ‬

‫ﺁﻥ ﻭ ﻧﻮﻉ ﻧﻤﺎﻳﺶ ﺍﺭﻗﺎﻡ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫‪Data type‬‬ ‫‪Data description‬‬

‫‪Integer‬‬ ‫‪Iw, Iw.m‬‬

‫‪Floating Point‬‬ ‫‪Ew.d, Ew.dEe, Fw.d,Gw.d, Gw.dEe‬‬

‫‪Logical‬‬ ‫‪Lw‬‬

‫‪Character‬‬ ‫‪A, Aw‬‬

‫ﺩﺭ ﺍﻳﻦ ﺟﺪﻭﻝ ﺣﺮﻭﻑ ﺑﺰﺭﮒ ﻣﺸﺨﺺ ﮐﻨﻨﺪﻩ ﻧﻮﻉ ﻣﺘﻐﻴﺮ ﻫﺴﺘﻨﺪ‪:‬‬

‫ﻣﺘﻐﻴﺮ ﺻﺤﻴﺢ‬ ‫‪:I‬‬

‫ﻣﺘﻐﻴﺮ ﺍﻋﺸﺎﺭ ﺑﺎ ﺍﻋﺸﺎﺭ ﻣﺸﺨﺺ‬ ‫‪:F‬‬

‫ﻧﻤﺎﻳﺶ ﻋﻠﻤﯽ ﻋﺪﺩ ﺍﻋﺸﺎﺭ‬ ‫‪:E‬‬

‫ﻣﺎﻧﻨﺪ ‪ ،F‬ﺑﻪ ﺩﻗﺖ ﻋﺪﺩ ﺑﺴﺘﮕﯽ ﺩﺍﺭﺩ‬ ‫‪:G‬‬

‫ﻣﺘﻐﻴﺮ ﻣﻨﻄﻘﯽ‬ ‫‪:L‬‬

 ‫ﻣﺘﻐﻴﺮ ﮐﺎﺭﺍﮐﺘﺮﯼ!‬ ‫‪:A‬‬

‫ﻭ ﺣﺮﻭﻑ ﮐﻮﭼﮏ ﻗﺎﻟﺐ ﻣﺘﻐﻴﺮ ﺭﺍ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﻨﺪ‬

‫ﺗﻌﺪﺍﺩ ﮐﻞ ﺍﺭﻗﺎﻡ‬ ‫‪:w‬‬

‫ﺣﺪﺍﻗﻞ ﺗﻌﺪﺍﺩ ﺍﺭﻗﺎﻣﯽ ﮐﻪ ﺑﺎﻳﺪ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﺷﻮﺩ‬ ‫‪:m‬‬

‫ﺗﻌﺪﺍﺩ ﺍﺭﻗﺎﻡ ﺑﻌﺪ ﺍﺯ ﻣﻤﻴﺰ )ﺩﻗﺖ(‬ ‫‪:d‬‬

‫ﺗﻌﺪﺍﺩ ﺍﺭﻗﺎﻡ ﺗﻮﺍﻥ‬ ‫‪:e‬‬

‫ﺗﻌﺪﺍﺩﯼ ﺍﺯ ﮐﺎﺭﺍﮐﺘﺮﻫﺎﯼ ﮐﻨﺘﺮﻟﯽ ﮐﻪ ﮐﺎﺭﺑﺮﺩ ﺑﻴﺸﺘﺮﯼ ﺩﺍﺭﻧﺪ‬

‫ﺍﻧﺘﻔﺎﻝ ﺑﻪ ﺧﻂ ﺑﻌﺪﯼ‬ ‫‪/‬‬

‫ﺭﺷﺘﻪ ﺍﯼ ﺭﺍ ﺑﻪ ﺧﺮﻭﺟﯽ ﺍﻧﺘﻘﺎﻝ ﻣﯽ ﺩﻫﺪ‬ ‫’‪‘Any string‬‬

‫ﻣﮑﺎﻥ ﻧﻤﺎ ﺭﺍ ‪ n‬ﺧﺎﻧﻪ ﺑﻪ ﺭﺍﺳﺖ ﻫﺪﺍﻳﺖ ﻣﯽ ﮐﻨﺪ‬ ‫‪nX‬‬

‫ﺑﺮﺍﯼ ﻣﺜﺎﻝ‪:‬‬

‫'‪WRITE(UNIT=*,FMT=10) 'The frequency is', f, 'Hz‬‬

‫‪10‬‬ ‫)‪FORMAT(1X, A, F10.5, A‬‬

‫ﺍﺑﺘﺌﺎ ﻣﮑﺎﻥ ﻧﻤﺎ ﻳﮏ ﺧﺎﻧﻪ ﺑﻪ ﺭﺍﺳﺖ ﺣﺮﮐﺖ ﻣﯽ ﮐﻨﺪ‪ ،‬ﺭﺷﺘﻪ ﮐﺎﺭﺍﮐﺘﺮﯼ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﻣﯽ ﺳﻮﺩ‪ ،‬ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ‪ f‬ﺑﺎ ﺣﺪﺍﮐﺜﺮ ‪ 15‬ﺭﻗﻢ ﻭ ﺑﺎ ﺩﻗﺖ ‪ 5‬ﺭﻗﻢ‬

‫ﺍﻋﺸﺎﺭ ﻧﻤﺎﻳﺶ ﺩﺍﺩﻩ ﺷﺪﻩ ﻭ ﺩﻭﺑﺎﺭﻩ ﺭﺷﺘﻪ ﮐﺎﺭﺍﮐﺘﺮ ﭼﺎﭖ ﻣﯽ ﮔﺮﺩﺩ‪ .‬ﻣﯽ ﺗﻮﺍﻥ ﺍﺯ ﮐﻠﻤﺎﺕ ﮐﻠﻴﺪﯼ ‪ UNIT‬ﻭ ‪ FMT‬ﺻﺮﻓﻨﻈﺮ ﮐﺮﺩ ﻭ ﻓﻘﻂ ﻣﻘﺪﺍﺭ ﺁﻧﻬﺎ ﺭﺍ‬

‫ﻧﻮﺷﺖ‪.‬‬

‫'‪WRITE(*,10) 'The frequency is', f, 'Hz‬‬

‫‪10‬‬ ‫)‪FORMAT(1X, A, F10.5, A‬‬

‫ﻣﺜﺎﻝ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ‪:‬‬

‫ﺷﺎﻳﺪ ﺍﺯ ﺁﻣﻮﺧﺘﻦ ﺗﺌﻮﺭﯼ ﮐﻤﯽ ﺧﺴﺘﻪ ﺷﺪﻩ ﺑﺎﺷﻴﺪ‪ ،‬ﺣﺎﻝ ﻭﻗﺖ ﺁﻥ ﺍﺳﺖ ﮐﻪ ﺁﻧﭽﻪ ﺭﺍ ﮐﻪ ﺁﻣﻮﺧﺘﻪ ﺍﻳﻢ ﺍﺳﺘﻔﺎﺩﻩ ﮐﻨﻴﻢ‪ .‬ﻣﯽ ﺧﻮﺍﻫﻴﻢ ﺑﺮﻧﺎﻣﻪ ﺍﯼ‬

‫ﺑﻨﻮﻳﺴﻴﻢ ﮐﻪ ﺭﻳﺸﻪ ﻫﺎﯼ ﺣﻘﻴﻘﯽ ﻳﮏ ﻣﻌﺎﺩﻟﻪ ﺩﺭﺟﻪ ‪ 2‬ﺭﺍ ﭘﻴﺪﺍ ﮐﻨﺪ‪ .‬ﺿﺮﺍﻳﺐ ﻣﻌﺎﺩﻟﻪ ﺩﺭﺟﻪ ‪ 2‬ﺭﺍ ﺍﺯ ﻭﺭﻭﺩﯼ ﺧﻮﺍﻫﻴﻢ ﺧﻮﺍﻧﺪ‪.‬‬

‫ﺭﻳﺎﺿﻴﺎﺕ ﻣﺴﺌﻠﻪ‪:‬‬ ‫‪‬‬

‫‪The image part with relationship ID rId9 was not found in‬‬

‫ﺩﺍﺭﺍﯼ ﺩﻭ ﺭﻳﺸﻪ ﺍﺳﺖ‪ .‬ﺩﺭ ﺻﻮﺭﺗﯽ ﺍﻳﻦ ﺭﻳﺸﻪ ﻫﺎ ﺣﻘﻴﻘﯽ ﻫﺴﺘﻨﺪ ﮐﻪ ﺑﺎﺷﺪ‪.‬‬ ‫ﻣﯽ ﺩﺍﻧﻴﻢ ﮐﻪ ﻫﺮ ﻣﻌﺎﺩﻟﻪ ﺩﺭﺟﻪ ‪ 2‬ﺑﻪ ﺷﮑﻞ‬
‫‪the file.‬‬

‫ﺩﺭ ﺍﻳﻨﺼﻮﺭﺕ ﺭﻳﺸﻪ ﻫﺎﯼ ﺣﻘﻴﻘﯽ ﻣﻌﺎﺩﻟﻪ ﺍﺯ ﺭﺍﺑﻄﻪ ﺯﻳﺮ ﺑﺪﺳﺖ ﻣﯽ ﺁﻳﻨﺪ‪.‬‬
 The image part with relationship ID rId10 was not found in the file.

:‫ﺩﻳﺎﮔﺮﺍﻡ ﺑﺮﻧﺎﻣﻪ‬ 

‫ ﺷﺮﻭﻉ‬.1

‫ ﺿﺮﺍﻳﺐ ﻭﺭﻭﺩﯼ ﻣﻌﺎﺩﻟﻪ ﺭﺍ ﺑﺨﻮﺍﻥ‬.2

‫ ﺩﻟﺘﺎ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﮐﻦ‬.3

‫ ﺍﮔﺮ ﺩﻟﺘﺎ ﺑﺰﺭﮔﺘﺮ ﻳﺎ ﻣﺴﺎﻭﯼ ﺻﻔﺮ ﺍﺳﺖ‬.4

‫ﺭﻳﺸﻪ ﻫﺎ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﮐﻦ‬ .1-4

‫ﺭﻳﺸﻪ ﻫﺎ ﺭﺍ ﭼﺎﭖ ﮐﻦ‬ .2-4

‫ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ‬ _

"‫ﭼﺎﭖ ﮐﻦ "ﻣﻌﺎﺩﻟﻪ ﺭﻳﺸﻪ ﺣﻘﻴﻘﯽ ﻧﺪﺍﺭﺩ‬ .3-4

‫ ﭘﺎﻳﺎﻥ‬.5

:‫ﺑﺮﻧﺎﻣﻪ‬ 
PROGRAM Equation_solver_fortran

! This is program calculate the real roots of second order equation

IMPLICIT NONE ! this is important to get used to this statment

! Variable decleration

CHARACTER::end_key

REAL::a,b,c

REAL::Delta, x1, x2

! Main Porgram

WRITE(*,*) ‘Please enter the equation coefficients a*x^2+b*x+c’

WRITE(*,*) ‘a: ?’

READ(*,*) a

WRITE(*,*) ‘b: ?’

READ(*,*) b

WRITE(*,*) ‘c: ?’

READ(*,*) c

Delta=b**2-4*a*c
 ‫‪IF (Delta >= 0) THEN‬‬

‫)‪x1=(b+SQRT(Delta))/(2*a‬‬

‫)‪x2=(b-SQRT(Delta))/(2*a‬‬

‫‪WRITE(*,*) ‘ The real roots are : ‘, x1, x2‬‬

‫‪ELSE‬‬

‫’!‪WRITE(*,*) ‘ This equation has no real root‬‬

‫‪ENDIF‬‬

‫‪READ(*,*) end_key‬‬

‫‪END PROGRAM Equation_solver_fortran‬‬

‫ﺍﮔﺮ ﺩﺭ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﺍﺷﺘﺒﺎﻫﯽ ﻧﮑﺮﺩﻩ ﺑﺎﺷﻴﺪ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﺍﺟﺮﺍ ﺧﻮﺍﻫﺪ ﺷﺪ‪ .‬ﺗﺒﺮﻳﮏ ﻣﯽ ﮔﻮﻳﻢ‪ ،‬ﺷﻤﺎ ﺍﻭﻟﻴﻦ ﺑﺮﻧﺎﻣﻪ ﻣﻬﻨﺪﺳﯽ ﺧﻮﺩ ﺭﺍ ﻧﻮﺷﺘﻪ ﺍﻳﺪ‪ .‬ﺩﺭ‬

‫ﺧﻮﺍﻧﺪﻥ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ ﻧﺒﺎﻳﺪ ﻣﺸﮑﻠﯽ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ‪ .‬ﻓﻘﻂ ﻣﻤﮑﻦ ﺍﺳﺖ ﺳﺎﺧﺘﺎﺭ ‪ IF..THEN..ELSE‬ﻭ ﺗﺎﺑﻊ )(‪ SQRT‬ﺑﺮﺍﻳﺘﺎﻥ ﺗﺎﺯﮔﯽ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻭ‬

‫ﻫﻤﺎﻧﻄﻮﺭ ﮐﻪ ﺣﺪﺱ ﺯﺩﻩ ﺍﻳﺪ‪ ،‬ﺳﺎﺧﺘﺎﺭ ‪ IF..THEN..ELSE‬ﺳﺎﺧﺘﺎﺭ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﻭ ﺗﺎﺑﻊ )(‪ SQRT‬ﺗﺎﺑﻊ ﺟﺬﺭ ﻣﯽ ﺑﺎﺷﺪ ﮐﻪ ﺩﺭ ﺑﺨﺸﻬﺎﯼ ﺑﻌﺪﯼ ﺩﺭ‬

‫ﻣﻮﺭﺩ ﺁﻥ ﺑﺤﺚ ﺧﻮﺍﻫﻴﻢ ﮐﺮﺩ‪.‬‬

‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺷﻤﺎ ﻓﻘﻂ ﻣﺤﺪﻭﺩ ﺑﻪ ﺗﻔﮑﺮ ﺷﻤﺎ ﺩﺭ ﻣﻮﺭﺩ ﺑﺮﻧﺎﻣﻪ ﻫﺎﺳﺖ‪ .‬ﻫﺮ ﺁﻧﭽﻪ ﮐﻪ ﻓﮑﺮ ﮐﻨﻴﺪ ﺭﺍ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺑﻨﻮﻳﺴﻴﺪ‪ .‬ﺣﺘﯽ ﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﭘﻴﭽﻴﺪﻩ‬

‫ﻫﻮﺵ ﻣﺼﻨﻮﻋﯽ ﻧﻴﺰ ﺑﺎ ﻫﻤﻴﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺳﺎﺩﻩ ﻗﺎﺑﻞ ﻧﻮﺷﺘﻦ ﺍﺳﺖ‪ .‬ﺩﺭ ﻫﺮ ﺣﺎﻝ ﺍﮔﺮ ﺑﺪﺍﻧﻴﺪ ﭼﻪ ﻣﯽ ﺧﻮﺍﻫﻴﺪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﺑﺴﻴﺎﺭ ﻟﺬﺕ ﺑﺨﺶ‬

‫ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﺁﻣﻮﺧﺘﻦ ﻳﮏ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻣﺎﻧﻨﺪ ﻳﺎﺩﮔﺮﻓﺘﻦ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﺍﺑﺰﺍﺭ ﺍﺳﺖ‪ .‬ﻫﺮ ﭼﻪ ﺍﺑﺰﺍﺭ ﻗﻮﻳﺘﺮﯼ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﮐﺎﺭﻫﺎ ﺳﺎﺩﻩ ﺗﺮ‬

‫ﺍﻧﺠﺎﻡ ﺧﻮﺍﻫﺪ ﮔﺮﻓﺖ‪ ،‬ﺯﺑﺎﻥ ﻓﺮﺗﺮﻥ ﻳﮏ ﺍﺑﺰﺍﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻣﻬﻨﺪﺳﯽ ﺑﺴﻴﺎﺭ ﮐﺎﺭﺁﻣﺪ ﺍﺳﺖ‪.‬‬

‫ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﻓﺎﻳﻞ‬

‫ﮐﺎﺭ ﮐﺮﺩﻥ ﺑﺎ ﻓﺎﻳﻠﻬﺎ ﺩﺭ ﻓﺮﺗﺮﻥ ﺑﺴﻴﺎﺭ ﺳﺎﺩﻩ ﺍﺳﺖ‪ .‬ﻭﺭﻭﺩﯼ ﻭﺧﺮﻭﺟﯽ ﻓﺎﻳﻞ ﻫﻢ ﻣﺎﻧﻨﺪ ﻭﺭﻭﺩﯼ ﺍﺯ ﺻﻔﺤﻪ ﮐﻠﻴﺪ ﻳﺎ ﺧﺮﻭﺟﯽ ﺑﻪ ﻧﻤﺎﻳﺸﮕﺮ ﺑﺎ ﺩﺳﺘﻮﺭ‬

‫‪ READ‬ﻭ ‪ WRITE‬ﺻﻮﺭﺕ ﻣﯽ ﮔﻴﺮﺩ‪ .‬ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﺑﺨﺶ ‪ UNIT‬ﺩﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﻣﺸﺨﺺ ﮐﻨﻨﺪﻩ ﻧﻮﻉ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﺍﺳﺖ‪ .‬ﺑﺮﺍﯼ ﻭﺭﻭﺩﯼ‬

‫ﺍﺯ ﺻﻔﺤﻪ ﮐﻠﻴﺪ ﻭ ﺧﺮﻭﺟﯽ ﺑﻪ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ‪ ،‬ﺑﺨﺶ ‪ UNIT‬ﺩﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺑﺮﺍﺑﺮ * ﻗﺮﺍﺭ ﻣﯽ ﮔﻴﺮﺩ‪ .‬ﺑﺮﺍﯼ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﺍﺯ ﻓﺎﻳﻞ‪ ،‬ﺍﺑﺘﺪﺍ ﻓﺎﻳﻞ‬

‫ﺭﺍ ﺑﺎﺯ ﻣﯽ ﮐﻨﻴﻢ‪ ،‬ﺍﻳﻦ ﮐﺎﺭ ﻳﮏ ﻋﺪﺩ )‪ (UNIT‬ﺑﻪ ﻓﺎﻳﻞ ﺍﺧﺘﺼﺎﺹ ﻣﯽ ﺩﻫﺪ‪.‬‬

‫ﺩﺳﺘﻮﺭ ‪OPEN‬‬

‫ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﻳﮏ ﻓﺎﻳﻞ ﺭﺍ ﺑﺎﺯ ﻣﯽ ﮐﻨﺪ ﻭ ﻳﮏ ﻋﺪﺩ ﺑﻪ ﻓﺎﻳﻞ ﺍﺧﺘﺼﺎﺹ ﻣﯽ ﺩﻫﺪ‪ .‬ﺍﻳﻦ ﺍﻣﮑﺎﻥ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﻓﺎﻳﻞ ﺭﺍ ﺍﻳﺠﺎﺩ ﮐﺮﺩ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ‬

‫ﺑﻪ ﺍﻳﻦ ﺷﮑﻞ ﺍﺳﺖ‪:‬‬

 ‫‪(…ACCESS= access ,OPEN(UNIT= number, FILE= ’Name of file’, STATUS= status‬‬

‫‪ number‬ﻋﺪﺩﯼ ﺍﺳﺖ ﮐﻪ ﺷﻤﺎ ﺑﻪ ﻓﺎﻳﻞ ﺍﺧﺘﺼﺎﺹ ﻣﯽ ﺩﻫﻴﺪ )ﺍﻳﻦ ﻋﺪﺩ ﺭﺍ ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 255‬ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﺪ – ﻳﻌﻨﯽ ﺷﻤﺎ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺑﺎ ﺧﻴﺎﻝ‬

‫ﺭﺍﺣﺖ ﺗﺎ ‪ 255‬ﻓﺎﻳﻞ ﻣﺠﺰﺍ ﺭﺍ ﺑﺎﺯ ﮐﻨﻴﺪ!(‪ ،‬ﺍﻳﻦ ﻋﺪﺩ ﺷﻨﺎﺳﻪ ﻓﺎﻳﻞ ﺍﺳﺖ‪.‬‬

‫‪ status‬ﻭﺿﻌﻴﺖ ﻓﺎﻳﻞ ﺭﺍ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﻭ ﻣﯽ ﺗﻮﺍﻧﺪ ﺑﺮﺍﯼ ﺍﻳﺠﺎﺩ ﻓﺎﻳﻞ ﺟﺪﻳﺪ ’‪ ‘NEW‬ﺑﺎﺷﺪ‪ ،‬ﻳﺎ ’‪ ‘OLD‬ﺑﺮﺍﯼ ﺑﺎﺯ ﮐﺮﺩﻥ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ ﻭ ﺍﮔﺮ‬

‫ﻣﻄﻤﺌﻦ ﻧﻴﺴﺘﻴﺪ ’‪ ‘UNKNOWN‬ﺑﮑﺎﺭ ﻣﯽ ﺭﻭﺩ ﻭ ’‪ ‘SCRATCH‬ﺑﺮﺍﯼ ﺍﻳﺠﺎﺩ ﻓﺎﻳﻠﻬﺎﯼ ﻣﻮﻗﺖ ﮐﻪ ﺑﺎ ﭘﺎﻳﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻳﺎ ﺑﺴﺘﻪ ﺷﺪﻥ ﻓﺎﻳﻞ‪ ،‬ﻓﺎﻳﻞ ﺍﺯ ﺑﻴﻦ‬

‫ﻣﯽ ﺭﻭﺩ! ﻭﺿﻌﻴﺖ ’‪ ‘REPLACE‬ﺑﺮﺍﯼ ﺟﺎﻳﮕﺰﺍﺭﯼ ﻓﺎﻳﻞ ﺟﺪﻳﺪ ﺍﺳﺖ‪ .‬ﺍﮔﺮ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ ﺑﺎﺷﺪ‪ ،‬ﭘﺎﮎ ﺷﺪﻩ ﻭ ﻓﺎﻳﻞ ﺟﺪﻳﺪ ﺟﺎﻳﮕﺰﻳﻦ ﺁﻥ ﻣﯽ ﮔﺮﺩﺩ ﻭ‬

‫ﺍﮔﺮ ﻓﺎﻳﻞ ﻣﻮﺟﻮﺩ ﻧﺒﺎﺷﺪ‪ ،‬ﻓﺎﻳﻞ ﺟﺪﻳﺪ ﺍﻳﺠﺎﺩ ﻣﯽ ﮔﺮﺩﺩ‪.‬‬

‫‪ access‬ﻧﻮﻉ ﺩﺳﺘﺮﺳﯽ ﺑﻪ ﻓﺎﻳﻞ ﺭﺍ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﻣﻤﮑﻦ ﺍﺳﺖ‪ ‘DIRECT’ ،‬ﻳﺎ ’‪ ‘SEQUENTAL‬ﺑﺎﺷﺪ‪ .‬ﻧﻮﻉ ﺩﺳﺘﺮﺳﯽ ﺑﻪ ﻓﺎﻳﻞ ﺑﺴﻴﺎﺭ ﻣﻬﻢ‬

‫ﺍﺳﺖ‪ ،‬ﺍﻣﺎ ﺩﺳﺘﺮﺳﯽ ﺗﺮﺗﻴﺒﯽ ’‪ ‘SEQUENTAL‬ﺑﺴﻴﺎﺭ ﺳﺎﺩﻩ ﺍﺳﺖ‪ .‬ﺩﺭ ﺍﻳﻦ ﻓﺎﻳﻠﻬﺎ ﺩﺍﺩﻩ ﻫﺎ ﺑﺘﺮﺗﻴﺐ ﺧﻂ ﺑﻪ ﺧﻂ ﺧﻮﺍﻧﺪﻩ ﻭ ﻧﻮﺷﺘﻪ ﻣﯽ ﺷﻮﻧﺪ‪ .‬ﭘﻴﺶ‬

‫ﻓﺮﺽ ﺩﺳﺘﺮﺳﯽ ﺗﺮﺗﻴﺒﯽ ﺍﺳﺖ‪.‬‬

‫ﺩﺳﺘﻮﺭ ‪CLOSE‬‬

‫ﭘﻴﺸﻨﻬﺎﺩ ﻣﯽ ﮔﺮﺩﺩ ﺑﻌﺪ ﺍﺯ ﭘﺎﻳﺎﻥ ﮐﺎﺭ ﺑﺎ ﻓﺎﻳﻞ ﺁﻧﺮﺍ ﺑﺒﻨﺪﻳﺪ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫‪(…UNIT= unit, STATUS = status) CLOSE‬‬

‫‪ unit‬ﺷﻤﺎﺭﻩ ﺷﻨﺎﺳﻪ ﻓﺎﻳﻞ ﺍﺳﺖ ﻭ ‪ status‬ﻭﺿﻌﻴﺖ ﺑﺴﺘﻦ ﻣﯽ ﺗﻮﺍﻧﺪ ’‪ ‘KEEP‬ﺑﺮﺍﯼ ﺣﻔﻆ ﻓﺎﻳﻞ ﻭ ’‪ ‘DELETE‬ﺑﺮﺍﯼ ﺣﺬﻑ ﻓﺎﻳﻞ ﺍﺳﺖ‪ .‬ﭘﻴﺶ ﻓﺮﺽ‬

‫ﺣﺬﻑ ﻓﺎﻳﻞ ﺍﺳﺖ‪.‬‬

‫ﺗﻮﺍﺑﻊ ﻭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ‬

‫ﺗﻮﺍﺑﻊ ﺩﺍﺧﻠﯽ ‪Intrinsic Functions‬‬

‫ﻫﺮ ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ ﻓﺮﺗﺮﻥ ﮐﺘﺎﺑﺨﺎﻧﻪ ﺍﯼ ﺍﺯ ﺗﻮﺍﺑﻊ ﺩﺍﺧﻠﯽ ﺩﺍﺭﺩ‪ .‬ﺑﻌﻀﯽ ﺍﺯ ﻣﻬﻤﺘﺮﻳﻦ ﺍﻳﻦ ﺗﻮﺍﺑﻊ ﺑﻪ ﺷﺮﺡ ﺯﻳﺮ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺗﻮﺍﺑﻊ ﻣﺜﻠﺜﺎﺗﯽ‪SIN, COS, ASIN, ACOS, TAN, ATAN, COTAN :‬‬

‫ﺗﻮﺍﺑﻊ ﺭﻳﺎﺿﯽ‪ :‬ﻗﺪﺭﻣﻄﻠﻖ ‪ ،ABS‬ﺟﺬﺭ ‪ ،SQRT‬ﻟﮕﺎﺭﻳﺘﻢ ‪ ،LOG, LOG10‬ﺗﺎﺑﻊ ﻧﻤﺎﻳﯽ ‪ ،EXP‬ﺣﺪﺍﻗﻞ ﻭ ﺣﺪﺍﮐﺜﺮ ‪ ،MIN,MAX‬ﺑﺎﻗﻴﻤﺎﻧﺪﻩ ﺗﻘﺴﻴﻢ‬

‫‪ MOD‬ﻭ‪...‬‬
 ‫ﺗﻮﺍﺑﻊ ﻣﺎﺗﺮﻳﺴﯽ‪DOT_PRODUCT, MATMUL, TRANSPOSE,… :‬‬

‫ﺗﻮﺍﺑﻊ ﺑﺴﻴﺎﺭ ﺯﻳﺎﺩ ﺩﻳﮕﺮﯼ ﻧﻴﺰ ﻭﺟﻮﺩ ﺩﺍﺭﺩ؛ ﻫﻤﭽﻨﻴﻦ ﻣﻤﮑﻦ ﺍﺳﺖ ﮐﻪ ﻣﺘﺮﺟﻢ ﺷﻤﺎ ﺗﻮﺍﺑﻊ ﺑﻴﺸﺘﺮﯼ ﺍﺯ ﺗﻮﺍﺑﻊ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﺩﺭ ﺍﺧﺘﻴﺎﺭ ﺷﻤﺎ ﻗﺮﺍﺭ ﺩﻫﺪ‪ .‬ﺩﺭ‬

‫ﻫﺮ ﺣﺎﻝ ﺍﮔﺮ ﺍﺣﺘﻴﺎﺝ ﺑﻪ ﺗﺎﺑﻌﯽ ﺩﺍﺷﺘﻴﺪ‪ ،‬ﻗﺒﻞ ﺍﺯ ﺍﻳﻨﮑﻪ ﺧﻮﺩﺗﺎﻥ ﺑﻪ ﻓﮑﺮ ﻧﻮﺷﺘﻦ ﺁﻥ ﺑﺎﺷﻴﺪ ﻣﻄﻤﺌﻦ ﺷﻮﻳﺪ ﮐﻪ ﺁﻥ ﺗﺎﺑﻊ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ!!‬

‫ﺑﻌﻀﯽ ﺍﺯ ﺍﻳﻦ ﺗﻮﺍﺑﻊ ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩ ﻫﺎ ﺭﺍ ﺑﻌﻨﻮﺍﻥ ﻭﺭﻭﺩﯼ ﺧﻮﺩ ﻣﯽ ﭘﺬﻳﺮﻧﺪ ﺍﻟﺒﺘﻪ ﺍﮔﺮ ﭼﻨﺪ ﻭﺭﻭﺩﯼ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻫﻤﻪ ﺑﺎﻳﺪ ﺍﺯ ﻳﮏ ﻧﻮﻉ ﺑﺎﺷﻨﺪ‪،‬‬

‫ﺑﻌﻀﯽ ﺍﺯ ﺍﻳﻦ ﺗﻮﺍﺑﻊ ﻧﻴﺰ ﻧﻮﻉ ﻣﺸﺨﺼﯽ ﺭﺍ ﭘﺸﺘﻴﺒﺎﻧﯽ ﻣﯽ ﮐﻨﻨﺪ‪ .‬ﺑﻌﻀﯽ ﺍﺯ ﻣﺘﺮﺟﻢ ﻫﺎ ﻣﺎﻧﻨﺪ ‪ Digital Visual Fortran‬ﺑﺮﺍﯼ ﻣﺸﺨﺺ ﮐﺮﺩﻥ ﻧﻮﻉ‬

‫ﺩﺍﺩﻩ ﻭﺭﻭﺩﯼ ﻭ ﺧﺮﻭﺟﯽ ﺍﺯ ﭘﻴﺸﻮﻧﺪ ﻭ ﭘﺴﻮﻧﺪ ﺑﺮﺍﯼ ﺗﻮﺍﺑﻊ ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮐﻨﺪ )ﺑﺮﺍﯼ ﺟﺰﺋﻴﺎﺕ ﺑﻪ ‪ help‬ﻧﺮﻡ ﺍﻓﺰﺍﺭ ﺧﻮﺩ ﻣﺮﺍﺟﻌﻪ ﻧﻤﺎﻳﻴﺪ‪.(.‬‬

‫ﻓﺮﺍﺧﻮﺍﻧﯽ ﺗﻮﺍﺑﻊ ﻣﺎﻧﻨﺪ ﺍﺧﺘﺼﺎﺹ ﻳﮏ ﻣﻘﺪﺍﺭ ﺑﻪ ﻣﺘﻐﻴﺮ ﻣﯽ ﺑﺎﺷﺪ‪.‬‬

‫)}‪Result_variable = function_name({list of parameters‬‬

‫ﺑﺮﺍﯼ ﻣﺜﺎﻝ‪:‬‬

‫)‪a= sin(b‬‬

‫‪ b‬ﻣﺘﻐﻴﺮﯼ ﺍﺳﺖ ﮐﻪ ﺑﻪ ﺗﺎﺑﻊ ﺍﺭﺳﺎﻝ ﻣﯽ ﮔﺮﺩﺩ ﻭ ‪ a‬ﺣﺎﺻﻞ ﺗﺎﺑﻊ ﺳﻴﻨﻮﺱ ﺧﻮﺍﻫﺪ ﺑﻮﺩ!‬

‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﺩﺍﺧﻠﯽ ‪Intrinsic Subroutines‬‬

‫ﻓﺮﻕ ﺗﺎﺑﻊ ﻭ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺗﻌﺪﺍﺩ ﻣﺘﻐﻴﺮﻫﺎﯼ ﺑﺎﺯﮔﺸﺘﯽ ﺁﻧﻬﺎﺳﺖ‪ .‬ﺍﻟﺒﺘﻪ ﺍﻳﻦ ﺗﻨﻬﺎ ﻓﺮﻕ ﺁﻧﻬﺎ ﻧﻴﺴﺖ! ﺗﺎﺑﻊ ﻳﮏ ﻣﺘﻐﻴﺮ ﺑﺎﺯﮔﺸﺘﯽ ﺩﺍﺭﺩ ﺩﺭﺣﺎﻟﻴﮑﻪ ﺯﻳﺮ‬

‫ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺗﻮﺍﻧﺪ ﺑﻴﺶ ﺍﺯ ﻳﮏ ﻣﻘﺪﺍﺭ ﺭﺍ ﺑﺮﮔﺮﺩﺍﻧﺪ‪ .‬ﺗﺎﺑﻊ ﻳﮏ ﻣﻘﺪﺍﺭ ﺭﺍ ﺑﺮ ﻣﯽ ﮔﺮﺩﺍﻧﻨﺪ ﺍﻣﺎ ﺣﻖ ﺗﻐﻴﻴﺮ ﻣﺘﻐﻴﺮﻫﺎﯼ ﻭﺭﻭﺩﯼ ﺭﺍ ﻧﺪﺍﺭﻧﺪ‪ .‬ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎ‬

‫ﻣﻘﺪﺍﺭ ﺑﺎﺯﮔﺸﺘﯽ ﻧﺪﺍﺭﻧﺪ‪ ،‬ﺩﺭ ﻋﻮﺽ ﺍﻣﮑﺎﻥ ﺗﻐﻴﻴﺮ ﻣﺘﻐﻴﺮﻫﺎﯼ ﺧﻮﺩ ﺭﺍ ﺩﺍﺭﻧﺪ‪ .‬ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﺎ ﺩﺳﺘﻮﺭ ‪ CALL‬ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﻓﺮﺍﺧﻮﺍﻧﯽ ﻣﯽ ﺷﻮﻧﺪ‪.‬‬

‫)}‪CALL subroutine_name({list of variables‬‬

‫ﺑﻌﻀﯽ ﺍﺯ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﺩﺍﺧﻠﯽ ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ‪:‬‬

‫‪SYSTEM_CLOCK ,DATE_AND_TIME, MVBITS, RANDOM_NUMBER, RANDOM_SEED‬‬

‫ﺗﻮﺍﺑﻊ ﺧﺎﺭﺟﯽ ‪External Functions‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺧﻮﺩﺗﺎﻥ ﺗﻮﺍﺑﻊ ﺭﺍ ﺑﻨﻮﻳﺴﻴﺪ‪ .‬ﻣﻌﻤﻮ ﹰﻻ ﺑﻌﺪ ﺍﺯ ﭘﺎﻳﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺗﻮﺍﺑﻊ ﺧﻮﺩﺗﺎﻥ ﺭﺍ ﺍﺿﺎﻓﻪ ﮐﻨﻴﺪ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺗﺎﺑﻊ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫)}‪type FUNCTION name ({dummy arguments‬‬

 ‫‪local variable declaration‬‬

‫…‪body of function‬‬

‫‪name = expression‬‬

‫‪body of function continued if needed‬‬

‫‪END FUNCTION name‬‬

‫‪ type‬ﻧﻮﻉ ﺗﺎﺑﻊ )ﻧﻮﻉ ﺣﺎﺻﻞ ﺗﺎﺑﻊ( ﺭﺍ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ‪ .‬ﺣﺎﺻﻞ ﺗﺎﺑﻊ ﻣﻘﺪﺍﺭﯼ ﺍﺳﺖ ﮐﻪ ﺗﻮﺳﻂ ﺗﺎﺑﻊ ﺑﺎﺯﮔﺮﺩﺍﻧﺪﻩ ﻣﯽ ﺷﻮﺩ‪ .‬ﺍﮔﺮ ﺑﻪ ﺳﺎﺧﺘﺎﺭ ﺑﺎﻻ ﺗﻮﺟﻪ‬

‫ﮐﻨﻴﺪ ﺩﻗﻴﻘ ﹰﺎ ﺟﺎﻳﯽ ﮐﻪ ﻧﺎﻡ ﺗﺎﺑﻊ ﺑﺮﺍﺑﺮ ﻳﮏ ﻋﺒﺎﺭﺕ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ‪ ،‬ﺣﺎﺻﻞ ﺗﺎﺑﻊ ﺍﺳﺖ‪ .‬ﺗﺎﺑﻊ ﺑﺎﻳﺪ ﺣﺪﺍﻗﻞ ﻳﮏ ﻣﻘﺪﺍﺭ ﺧﺮﻭﺟﯽ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻳﻌﻨﯽ ﺩﺭ‬

‫ﺟﺎﻳﯽ ﺍﺯ ﺗﺎﺑﻊ‪ ،‬ﻣﻘﺪﺍﺭﯼ ﺑﻪ "ﻧﺎﻡ" ﺗﺎﺑﻊ ﺍﺧﺘﺼﺎﺹ ﺩﺍﺩﻩ ﺷﻮﺩ‪.‬‬

‫ﻣﺘﻐﻴﺮﻫﺎﯼ ﻇﺎﻫﺮﯼ ‪ ،arguments dummy‬ﺷﺎﻣﻞ ﻫﻤﺔ ﺛﺎﺑﺖ ﻫﺎ‪ ،‬ﻣﺘﻐﻴﺮﻫﺎ ﻭ ﺣﺘﯽ ﺭﻭﺍﻟﻬﺎﻱ‪ 1‬ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳﯽ ﺩﺭ ﺑﺪﻧﻪ ﺗﺎﺑﻊ ﺍﺳﺖ‪) .‬ﻣﻨﻈﻮﺭ ﺍﺯ‬

‫ﺭﻭﺍﻟﻬﺎ‪ ،‬ﺗﻮﺍﺑﻊ ﻭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻫﺴﺘﻨﺪ(‪ .‬ﻭﻗﺘﯽ ﺗﺎﺑﻊ ﻓﺮﺍﺧﻮﺍﻧﯽ ﻣﯽ ﮔﺮﺩﺩ ﺑﺎﻳﺪ ﻟﻴﺴﺘﯽ ﺍﺯ ﺍﻳﻦ ﻣﺘﻐﻴﺮﻫﺎ ﺑﻪ ﺁﻥ ﻓﺮﺳﺘﺎﺩﻩ ﺷﻮﺩ‪ .‬ﻧﻮﻉ ﺍﻳﻦ ﻣﺘﻐﻴﺮﻫﺎﯼ‬

‫ﻭﺍﻗﻌﯽ ﺑﺎﻳﺪ ﺑﺎ ﻣﺘﻐﻴﺮﻫﺎﯼ ﻇﺎﻫﺮﯼ ﻣﻮﺟﻮﺩ ﺩﺭ ﺗﻌﺮﻳﻒ ﺗﺎﺑﻊ ﻳﮑﺴﺎﻥ ﺑﺎﺷﺪ‪ ،‬ﺍﻣﺎ ﻧﺎﻡ ﺁﻧﻬﺎ ﻣﻬﻢ ﻧﻴﺴﺖ‪ .‬ﻧﻮﻉ ﻣﺘﻐﻴﺮﻫﺎ ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﺭﺳﺎﻝ ﺑﻪ ﺗﻮﺍﺑﻊ ﺗﻮﺳﻂ‬

‫ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ ﮐﻨﺘﺮﻝ ﻧﻤﯽ ﮔﺮﺩﺩ ﻭ ﺍﮔﺮ ﻧﻮﻉ ﻣﺘﻐﻴﺮﻫﺎﯼ ﻳﮑﺴﺎﻥ ﻧﺒﺎﺷﺪ ﺑﺎ ﺍﺷﮑﺎﻻﺕ ﻋﺠﻴﺒﯽ ﺭﻭﺑﺮﻭ ﺧﻮﺍﻫﻴﺪ ﺷﺪ!‬

‫ﺑﻌﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﻪ ﻧﻴﺮﻭﯼ ﺟﺎﺫﺑﻪ ﺑﻴﻦ ﺩﻭ ﺟﺴﻢ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻓﺮﻣﻮﻝ ﻧﻴﻮﺗﻦ‪ ،‬ﺗﺎﺑﻊ ﻧﻴﻮﺗﻦ ﺭﺍ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺗﻌﺮﻳﻒ ﻣﯽ ﮐﻨﻴﻢ‪.‬‬

‫)‪REAL FUNCTION Newton (m1, m2, r‬‬

‫‪REAL:: gamma = 6.672E-11, m1, m2, r‬‬

‫‪Newton = -gamma*m1*m2/r**2‬‬

‫‪END Newton‬‬

‫ﺗﻮﺍﺑﻊ ﻳﮏ ﺧﻄﯽ ‪Statement Functions‬‬

‫ﻭﻗﺘﯽ ﺗﻮﺍﺑﻌﯽ ﮐﻪ ﺑﮑﺎﺭ ﻣﯽ ﺑﺮﻳﺪ‪ ،‬ﺁﻧﭽﻨﺎﻥ ﮐﻮﺗﺎﻩ ﻫﺴﺘﻨﺪ ﮐﻪ ﺩﺭ ﻳﮏ ﺧﻂ ﺗﻤﺎﻡ ﻣﯽ ﺷﻮﻧﺪ‪ ،‬ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺍﺯ ﺍﻳﻦ ﺳﺎﺧﺘﺎﺭ ﺍﺳﺘﻔﺎﺩﻩ ﮐﻨﻴﺪ‪.‬‬

‫‪Function_name({list of parameters}) = expression‬‬

‫ﻼ ﺗﺎﺑﻊ ﻧﻴﻮﺗﻦ ﮐﻪ ﺩﺭ ﺑﺎﻻ ﺗﻌﺮﻳﻒ ﺷﺪ ﺭﺍ ﻣﯽ ﺗﻮﺍﻥ ﺑﺎ ﺍﻳﻦ ﺳﺎﺧﺘﺎﺭ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﻧﻮﺷﺖ‪.‬‬
‫ﻣﺜ ﹰ‬

‫‪Newton(m1, m2, r) = -6.672E-11*m1*m2/r**2‬‬

‫ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻫﺎﯼ ﺧﺎﺭﺟﯽ ‪External Subroutines‬‬

‫ﺳﺎﺧﺘﺎﺭ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪.‬‬

 ‫‪{name {dummy argument list SUBROUTINE‬‬

‫‪local variables declaration‬‬

‫‪…body of subroutine‬‬

‫‪name END SUBROUTINE‬‬

‫ﺗﻤﺎﻡ ﻣﺘﻐﻴﺮﻫﺎ ﺑﺎ ﺁﺩﺭﺱ ﻓﺮﺳﺘﺎﺩﻩ ﻣﯽ ﺷﻮﻧﺪ ”‪) “call by reference‬ﻣﺎﻧﻨﺪ ‪ VAR arg‬ﺩﺭ ‪ Pascal‬ﻳﺎ ‪ &arg‬ﺩﺭ ‪ ،(C++‬ﻳﻌﻨﯽ ﺁﺩﺭﺱ ﻣﺘﻐﻴﺮ ﺩﺭ‬

‫ﺣﺎﻓﻈﻪ ﺑﻪ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻓﺮﺳﺘﺎﺩﻩ ﻣﯽ ﺷﻮﺩ‪ ،‬ﻭ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻣﯽ ﺗﻮﺍﻧﺪ ﻣﺘﻐﻴﺮ ﺭﺍ ﻣﺴﺘﻘﻴﻤ ﹰﺎ ﺗﻐﻴﻴﺮ ﺩﻫﺪ‪ .‬ﺩﺭ ﺗﻮﺍﺑﻊ ﻧﻴﺰ ﭼﻨﻴﻦ ﺍﺳﺖ‪ ،‬ﺍﻣﺎ ﻓﺮﺽ ﻣﯽ ﮔﺮﺩﺩ ﮐﻪ‬

‫ﺗﻮﺍﺑﻊ ﻣﺘﻐﻴﺮﻫﺎﯼ ﻭﺭﻭﺩﯼ ﺭﺍ ﺗﻐﻴﻴﺮ ﻧﻤﯽ ﺩﻫﻨﺪ‪.‬‬

‫ﺩﺳﺘﻮﺭﺍﺕ ‪RETURN, SAVE, EXTERNAL, INTERNAL‬‬

‫ﻫﻤﺔ ﺭﻭﺍﻟﻬﺎﯼ ﺧﻮﺏ ﺑﺎﻳﺪ ﻳﮏ ﻧﻘﻄﻪ ﻭﺭﻭﺩ ﻭ ﻳﮏ ﻧﻘﻄﻪ ﺧﺮﻭﺝ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ ،‬ﺍﻣﺎ ﮔﺎﻫﯽ ﻻﺯﻡ ﺍﺳﺖ ﮐﻪ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺩﺭ ﻧﻘﻄﻪ ﺍﯼ ﺩﻳﮕﺮ ﭘﺎﻳﺎ ﻥ ﻳﺎﺑﺪ‬

‫)ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻫﻨﮕﺎﻡ ﺍﻳﺠﺎﺩ ﺧﻄﺎ(‪ .‬ﺑﺮﺍﯼ ﺍﻳﻨﮑﺎﺭ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ RETURN‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‪ .‬ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺍﺟﺮﺍﯼ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﻣﺘﻮﻗﻒ ﮐﺮﺩﻩ ﻭ ﺑﺮﻧﺎﻣﻪ ﺭﺍ‬

‫ﺑﻪ ﺭﻭﺍﻝ ﻓﺮﺍﺧﻮﺍﻧﯽ ﮐﻨﻨﺪﻩ ﺍﻳﻦ ﺯﻳﺮ ﺑﺮﻧﺎﻣﻪ ﺑﺎﺯ ﻣﯽ ﮔﺮﺩﺍﻧﺪ‪.‬‬

‫ﭘﺲ ﺍﺯ ﭘﺎﻳﺎﻥ ﻳﮏ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ‪ ،‬ﻣﻘﺪﺍﺭ ﻫﻤﺔ ﻣﺘﻐﻴﺮﻫﺎﯼ ﻣﺤﻠﯽ ﺍﺯ ﺑﻴﻦ ﻣﯽ ﺭﻭﺩ‪ .‬ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺍﻳﻦ ﻣﻘﺎﺩﻳﺮ ﺩﺭ ﺍﺟﺮﺍﯼ ﺑﻌﺪﯼ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﻣﻮﺟﻮﺩ‬

‫ﺑﺎﺷﺪ)‪ ،(STATIC ALLOCATION‬ﺑﺎﻳﺪ ﺍﻳﻦ ﻣﻮﺿﻮﻉ ﺭﺍ ﺑﺮﺍﯼ ﻣﺘﺮﺟﻢ ﻣﺸﺨﺺ ﮐﻨﻴﻢ ﺗﺎ ﻣﺘﺮﺟﻢ ﺑﺪﺍﻧﺪ ﮐﻪ ﺑﺎﻳﺪ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮﻫﺎ ﺭﺍ ﺫﺧﻴﺮﻩ ﮐﻨﺪ‪ .‬ﺍﻳﻦ‬

‫ﻣﻮﺿﻮﻉ ﺭﺍ ﺑﺎ ﺩﺳﺘﻮﺭ ‪ SAVE‬ﺑﻪ ﻣﺘﺮﺟﻢ ﺍﺻﻼﻉ ﻣﯽ ﺩﻫﻴﻢ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﻪ ﺍﻳﻦ ﺷﮑﻞ ﺍﺳﺖ‪:‬‬

‫]}‪SAVE [{list of local variables to be saved‬‬

‫ﻭﻗﺘﯽ ﻳﮏ ﺗﺎﺑﻊ ﺑﻌﻨﻮﺍﻥ ﻣﺘﻐﻴﺮ ﺑﻪ ﻳﮏ ﺭﻭﺍﻝ ﺩﻳﮕﺮ ﻓﺮﺳﺘﺎﺩﻩ ﻣﯽ ﺷﻮﺩ‪ ،‬ﻧﻮﻉ ﺗﺎﺑﻊ ﺑﺎﻳﺪ ﻗﺒﻞ ﺍﺯ ﺍﺭﺳﺎﻝ ﺑﻌﻨﻮﺍﻥ ﺩﺍﺧﻠﯽ ﻳﺎ ﺧﺎﺭﺟﯽ ﺗﻌﺮﻳﻒ ﮔﺮﺩﺩ‪ .‬ﺍﻳﻦ‬

‫ﺗﻌﺮﻳﻒ ﺑﺎ ﺩﺳﺘﻮﺭﺍﺕ ﺯﻳﺮ ﺻﻮﺭﺕ ﻣﯽ ﮔﻴﺮﺩ‪.‬‬

‫}‪INTRINSIC {list of function names‬‬

‫}‪EXTERNAL {list of function names‬‬

‫ﺑﺮﺍﯼ ﻣﺜﺎﻝ‬

‫‪PROGRAM func‬‬

‫‪EXTERNAL CTN‬‬

‫‪INTRINSIC SIN, COS‬‬

‫‪REAL::angle=0.785 !...pi/4‬‬
 REAL::sine,cosine,tangent

CALL TRIG(angle,SIN,sine)

WRITE(*,*) 'SIN(0.785)=',sine

CALL TRIG(angle,COS,cosine)

WRITE(*,*) 'COS(0.785)=',cosine

CALL TRIG(angle,CTN,cotangent)

WRITE(*,*) 'COTAN(0.785)=',cotangent

READ*,r

END PROGRAM func

SUBROUTINE TRIG(X,F,Y)

Y = F(X)

RETURN

END SUBROUTINE TRIG

FUNCTION CTN(X)

CTN = COS(X)/SIN(X)

RETURN

END FUNCTION CTN

‫ﺳﺎﺧﺘﺎﺭﻫﺎﯼ ﮐﻨﺘﺮﻟﯽ‬

.‫ﺳﺎﺧﺘﺎﺭﻫﺎﯼ ﮐﻨﺘﺮﻟﯽ ﺟﻬﺖ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﮐﻨﺘﺮﻝ ﻣﯽ ﮐﻨﻨﺪ‬

IF ‫ﺳﺎﺧﺘﺎﺭ‬

‫ ﺳﺎﺧﺘﺎﺭ‬.‫ ﺩﺭ ﺍﻳﻦ ﺳﺎﺧﺘﺎﺭ ﺑﻨﺎﺑﺮ ﺣﺎﺻﻞ ﻳﮏ ﻣﻘﺎﻳﺴﻪ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺟﺎﯼ ﺩﻳﮕﺮﯼ ﻣﻨﺘﻘﻞ ﻣﯽ ﺷﻮﺩ‬.‫ﺍﻳﻦ ﺳﺎﺧﺘﺎﺭ ﻳﮏ ﺳﺎﺧﺘﺎﺭ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﺍﺳﺖ‬

.‫ﻋﻤﻮﻣﯽ ﺁﻥ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‬

IF (First condition statement) THEN

First sequence of commands

‫‪ELSE IF (Second condition statement) THEN‬‬

‫‪Second sequence of commands‬‬

‫… ‪ELSE IF‬‬

‫…‬

‫‪ELSE‬‬

‫‪Alternative sequence of commands‬‬

‫‪END IF‬‬

‫ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺑﺮﺍﯼ ﻳﺎﻓﺘﻦ ﻋﻼﻣﺖ ﻳﮏ ﻋﺪﺩ ﻣﯽ ﺗﻮﺍﻥ ﺍﺯ ﺑﺨﺶ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ‪:‬‬

‫‪IF (number .LT. 0) THEN‬‬

‫‪sign=-1‬‬

‫‪ELSE IF (number .GT. 0) THEN‬‬

‫‪sign=1‬‬

‫‪ELSE‬‬

‫‪sign=0‬‬

‫‪END IF‬‬

‫ﻣﯽ ﺗﻮﺍﻥ ﺑﺮﺍﯼ ﺍﺟﺮﺍﯼ ﻳﮏ ‪ IF‬ﺑﺎ ﻳﮏ ﺩﺳﺘﻮﺭ‪ ،‬ﺁﻧﺮﺍ ﺩﺭ ﻳﮏ ﺧﻂ ﺧﻼﺻﻪ ﮐﺮﺩ‪ .‬ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﺍﺯ ‪ ELSE ، THEN‬ﻭ ‪ END IF‬ﺻﺮﻓﻨﻈﺮ ﻣﯽ ﺷﻮﺩ‪.‬‬

‫‪IF (Condition statement) Statement to be executed‬‬

‫'‪IF (r==0) WRITE(*,*) 'r=0‬‬

‫ﺣﻠﻘﻪ ‪Do‬‬

‫ﺍﻳﻦ ﺣﻠﻘﻪ ﺑﺮﺍﯼ ﺗﮑﺮﺍﺭ ﺑﺨﺸﯽ ﺍﺯ ﺑﺮﻧﺎﻣﻪ ﺍﺳﺖ‪ .‬ﭼﻮﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺣﻠﻘﻪ ‪ GOTO‬ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﭘﻴﺸﺮﻓﺘﻪ ﺑﺴﻴﺎﺭ ﺑﺪ ﺍﺳﺖ )ﮔﻔﺘﻪ ﻣﯽ ﺷﻮﺩ ﮐﻪ‬

‫ﺍﻣﮑﺎﻥ ﺍﺷﺘﺒﺎﻩ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﺴﻴﺎﺭ ﺯﻳﺎﺩ ﺍﺳﺖ(‪ .‬ﺩﺭ ﻫﺮ ﺣﺎﻝ ﺟﺎﻟﺐ ﻧﻴﺴﺖ ﮐﻪ ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺑﺨﺶ ﺩﻳﮕﺮﯼ ﭘﺮﺵ ﮐﺮﺩ‪ ،‬ﺣﺪﺍﻗﻞ ﺍﻳﻨﮑﺎﺭ‬

‫ﺧﻮﺍﻧﺎﻳﯽ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺑﺴﻴﺎﺭ ﮐﺎﻫﺶ ﺧﻮﺍﻫﺪ ﺩﺍﺩ‪.‬‬

‫ﺳﺎﺧﺘﺎﺭ ﺩﺳﺘﻮﺭﯼ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺣﻠﻘﻪ ‪ DO‬ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫‪label: DO counter=start, limit, step‬‬

‫‪Sequence of commands to be looped through‬‬

‫‪END DO label‬‬
 ‫ﺑﺮﺍﯼ ﭘﻴﺎﺩﻩ ﺳﺎﺯﯼ ﺣﻠﻘﻪ ﻫﺎﯼ ﺩﻳﮕﺮ ﻣﺜﻞ ﺣﻠﻘﻪ ‪ for‬ﻭ ‪ while‬ﺩﺭ ﺯﺑﺎﻥ ‪ C‬ﻣﯽ ﺗﻮﺍﻥ ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ‪.‬‬

‫ﺩﺳﺘﻮﺭ ‪ EXIT‬ﺑﺮﺍﯼ ﺧﺮﻭﺝ ﺍﺯ ﺍﺟﺮﺍﯼ ﺣﻠﻘﻪ ﻭ ﺩﺳﺘﻮﺭ ‪ CYCLE‬ﺑﺮﺍﯼ ﺗﮑﺮﺍﺭ ﺣﻠﻘﻪ ﺍﺯ ﺍﺑﺘﺪﺍ ﻣﯽ ﺑﺎﺷﺪ‪ .‬ﺑﺮﺍﯼ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺑﺎﻳﺪ ﺑﺮﺍﯼ ﺣﻠﻘﻪ‬

‫ﻫﺎ ﺑﺮﭼﺴﺐ )‪ (label‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺖ ﺍﻳﻦ ﮐﺎﺭ ﺭﺍ ﺑﺎ ﺩﻗﺖ ﺑﺴﻴﺎﺭ ﺯﻳﺎﺩ ﺍﻧﺠﺎﻡ ﺩﻫﻴﺪ ﺯﻳﺮﺍ ﺍﻳﻨﮑﺎﺭ ﻧﻴﺰ ﻣﺎﻧﻨﺪ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ GOTO‬ﺍﺳﺖ! ﺳﺎﺧﺘﺎﺭ‬

‫ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫]‪EXIT [name of loop‬‬

‫]‪CYCLE [name of loop‬‬

‫ﭘﻴﺸﻨﻬﺎﺩ ﻣﯽ ﮐﻨﻢ ﺗﺎ ﺟﺎﯼ ﻣﻤﮑﻦ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺍﺳﺘﻔﺎﺩﻩ ﻧﮑﻨﻴﺪ‪ ،‬ﭼﻮﻥ ﺷﻤﺎ ﻣﯽ ﺗﻮﺍﻧﻴﺪ ﺑﺠﺎﯼ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺑﺎ ﺗﻐﻴﻴﺮﺍﺗﯽ ﺩﺭ ﮐﺪ‬

‫ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺑﻪ ﺷﮑﻞ ﺩﻳﮕﺮﯼ ﺑﻨﻮﻳﺴﻴﺪ‪ .‬ﺑﻪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﮐﻨﻴﺪ ﮐﻪ ﺑﺮﺍﯼ ﺭﻭﺷﻨﺘﺮ ﺷﺪﻥ ﺭﻭﺵ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭﺍﺕ ﺑﻴﺎﻥ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺩﺭ ﺍﻳﻦ‬

‫ﻣﺜﺎﻝ ﺩﺍﺩﻩ ﻫﺎﯼ ﻣﻮﺟﻮﺩ ﺩﺭ ﻳﮏ ﺁﺭﺍﻳﻪ ﺑﺘﺮﺗﻴﺐ ﺟﺬﺭ ﮔﺮﻓﺘﻪ ﻭ ﻣﻌﮑﻮﺱ ﻣﯽ ﮔﺮﺩﺩ‪ .‬ﻣﺸﺨﺺ ﺍﺳﺖ ﮐﻪ ﺍﻋﺪﺍﺩ ﻧﺒﺎﻳﺪ ﺻﻔﺮ ﻳﺎ ﻣﻨﻔﯽ ﺑﺎﺷﻨﺪ‪.‬‬

‫)‪REAL:: array(5‬‬

‫‪Outer: DO‬‬

‫‪READ(*,*) array‬‬

‫‪Inner: DO k=1, 5‬‬

‫‪IF (array(k)==0) CYCLE inner‬‬

‫‪IF (array(k)<0) EXIT‬‬

‫))‪Array(k)=1/SQRT(array(k‬‬

‫‪END DO inner‬‬

‫‪WRITE(*,*) array‬‬

‫‪END DO outer‬‬

‫ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ ﻳﮏ ﺣﻠﻘﻪ ﺑﻴﻨﻬﺎﻳﺖ ﻭﺟﻮﺩ ﺩﺍﺭﺩ )ﺣﻠﻘﻪ ‪ DO‬ﺑﺪﻭﻥ ﻣﺤﺪﻭﺩﻳﺖ(‪ .‬ﺑﺮﺍﯼ ﺧﺮﻭﺝ ﺍﺯ ﭼﻨﻴﻦ ﺣﻠﻘﻪ ﻫﺎﻳﯽ ﺍﺯ ﺩﺳﺘﻮﺭ ‪ EXIT‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ‬

‫ﮔﺮﺩﺩ‪.‬‬

‫ﺳﺎﺧﺘﺎﺭ ﺣﻠﻘﻪ ‪ DO‬ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﺑﺸﮑﻞ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫‪DO label, counter=start, limit, step‬‬

‫‪Sequence of commands to be looped through‬‬

‫‪label‬‬ ‫‪CONTINUE‬‬

‫ﺩﺳﺘﻮﺭ ‪GOTO‬‬

‫ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺗﺎ ﺣﺪ ﺍﻣﮑﺎﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻧﮑﻨﻴﺪ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﺴﻴﺎﺭ ﺳﺎﺩﻩ ﺍﺳﺖ‪.‬‬
 ‫‪GOTO label‬‬

‫ﻭ ﻳﮏ ﺑﺮﭼﺴﺐ ﺩﺭ ﻫﺮ ﺟﺎﯼ ﺑﺮﻧﺎﻣﻪ ﮐﻪ ﺑﺨﻮﺍﻫﻴﺪ! ﻭ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺁﻥ ﻣﺤﻞ ﻣﻨﺘﻘﻞ ﻣﯽ ﮔﺮﺩﺩ‪.‬‬

‫ﺩﺳﺘﻮﺭ ‪ GOTO‬ﺷﺮﻃﯽ‬

‫ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﻫﻢ ﻣﺎﻧﻨﺪ ﺩﺳﺘﻮﺭ ﻗﺒﻞ ﻣﻨﻊ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬

‫ﺩﺳﺘﻮﺭ ‪STOP‬‬

‫ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﻣﺘﻮﻗﻒ ﮐﻨﻴﻢ ﻭ ﮐﻨﺘﺮﻝ ﺭﺍ ﺑﻪ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﺑﺎﺯﮔﺮﺩﺍﻧﻴﻢ! ﺍﺯ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺍﺳﺘﻔﺎﺩﻩ ﻣﯽ ﮔﺮﺩﺩ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺍﻳﻦ ﺩﺳﺘﻮﺭ ﺑﻪ ﺷﮑﻞ‬

‫ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫]’‪STOP [‘message‬‬

‫ﺁﺭﺍﻳﻪ ﻫﺎ ‪Arrays‬‬

‫ﻳﮑﯽ ﺍﺯ ﻣﻬﻤﺘﺮﻳﻦ ﺳﺎﺧﺘﺎﺭﻫﺎﯼ ﺩﺍﺩﻩ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻣﻬﻨﺪﺳﯽ ﺁﺭﺍﻳﻪ ﻫﺎ ﻫﺴﺘﻨﺪ ﻣﺨﺼﻮﺻﺎﹰ ﻭﻗﺘﯽ ﺑﺎ ﺗﻌﺪﺍﺩ ﺯﻳﺎﺩﯼ ﻋﺪﺩ ﺩﺭ ﻧﻘﺎﻁ ﻣﺨﺘﻠﻒ ﮐﺎﺭ ﻣﯽ‬

‫ﮐﻨﻴﻢ‪ .‬ﺳﺎﺧﺘﺎﺭ ﺁﺭﺍﻳﻪ ﻫﺎ ﻣﺎﻧﻨﺪ ﺍﻧﻮﺍﻉ ﺩﻳﮕﺮ ﺩﺍﺩﻩ ﻫﺎ ﻣﯽ ﺑﺎﺷﺪ ﻓﻘﻂ ﺗﻌﺪﺍﺩ ﺩﺍﺩﻩ ﻫﺎ ﻣﺸﺨﺺ ﻣﯽ ﮔﺮﺩﺩ‪ .‬ﺍﻟﺒﺘﻪ ﺩﺭ ﺷﺮﺍﻳﻄﯽ ﮐﻪ ﻣﯽ ﺧﻮﺍﻫﻴﻢ ﮐﻪ ﺗﻌﺪﺍﺩ‬

‫ﺑﺼﻮﺭﺕ ﺩﻳﻨﺎﻣﻴﮏ ﺍﺧﺘﺼﺎﺹ ﺩﺍﺩﻩ ﺷﻮﺩ‪ ،‬ﺗﻌﺪﺍﺩ ﺭﺍ ﻣﺸﺨﺺ ﻧﻤﯽ ﮐﻨﻴﻢ‪.‬‬

‫)}‪type array_name({lower bound in nth dimention:Upper bound in nth dimention‬‬

‫ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻓﺮﺽ ﮐﻨﻴﺪ ﮐﻪ ﻣﯽ ﺧﻮﺍﻫﻴﺪ ﺩﺍﺩﻩ ﻫﺎﯼ ﺩﻣﺎﯼ ﻧﻘﺎﻁ ﺩﺭ ﻳﮏ ﺷﺒﮑﻪ ﺭﺍ ﺫﺧﻴﺮﻩ ﮐﻨﻴﺪ‪ ،‬ﻧﻮﻉ ﺩﺍﺩﻩ ﺭﺍ ﺍﻋﺪﺍﺩ ﺣﻘﻴﻘﯽ ﺩﺭ ﻧﻈﺮ ﻣﯽ ﮔﻴﺮﻳﻢ‪.‬‬

‫ﺷﻤﺎﺭﻩ ﻧﻘﺎﻁ ﺩﺭ ﻃﻮﻝ ﺍﺯ ‪ 50‬ﺗﺎ ‪ 70‬ﻣﯽ ﺑﺎﺷﺪ ﻭ ﺩﺭ ﻋﺮﺽ ﺍﺯ ‪ 1‬ﺗﺎ ‪ 20‬ﺍﺳﺖ‪:‬‬

‫)‪REAL:: temperature(50:70, 1:20‬‬

‫ﻳﺎ‬

‫)‪REAL:: temperature(50:70, 20‬‬

‫ﺣﺪ ﭘﺎﻳﻴﻦ ﺁﺭﺍﻳﻪ ﺑﺼﻮﺭﺕ ﭘﻴﺶ ﻓﺮﺽ ﺍﺯ ﻳﮏ ﺷﺮﻭﻉ ﻣﯽ ﺷﻮﺩ‪ .‬ﺁﺭﺍﻳﻪ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 77‬ﻣﯽ ﺗﻮﺍﻧﺪ ﺗﺎ ‪ 7‬ﺑﻌﺪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺁﺭﺍﻳﻪ ﻫﺎ ﺑﺘﺮﺗﻴﺐ ﺳﺘﻮﻥ ﺩﺭ‬

‫ﺣﺎﻓﻈﻪ ﻗﺮﺍﺭ ﻣﯽ ﮔﻴﺮﻧﺪ ﻭ ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺑﺎ ﺩﺳﺘﻮﺭ ‪ DO‬ﺑﻪ ﺁﺭﺍﻳﻪ ﻫﺎ ﺩﺳﺘﺮﺳﯽ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﺑﻬﺘﺮ ﺍﺳﺖ ﮐﻪ ﺣﻠﻘﻪ ﺷﻤﺎﺭﻧﺪﻩ ﺳﺘﻮﻧﻬﺎ ﺩﺍﺧﻞ ﺣﻠﻘﻪ‬

‫ﺷﻤﺎﺭﻧﺪﻩ ﺳﻄﺮ ﻫﺎ ﻗﺮﺍﺭ ﮔﻴﺮﺩ )ﺑﺮﺍﯼ ﺳﺮﻋﺖ ﺩﺳﺘﺮﺳﯽ ﺑﺎﻻﺗﺮ(‪ .‬ﺩﺳﺘﺮﺳﯽ ﺑﻪ ﻫﺮﻳﮏ ﺍﺯ ﺍﺟﺰﺍﺉ ﺁﺭﺍﻳﻪ ﻫﺎ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺴﻬﺎﯼ ﺁﻥ ﺻﻮﺭﺕ ﻣﯽ‬

‫ﮔﻴﺮﺩ‪ ،‬ﺍﻟﺒﺘﻪ ﺩﺳﺘﻮﺭﺍﺗﯽ ﺩﺭ ﻓﺮﺗﺮﻥ ‪ 90‬ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﮐﺎﺭ ﺑﺎ ﺁﺭﺍﻳﻪ ﻫﺎ ﺭﺍ ﺳﺮﻳﻌﺘﺮ ﻭ ﮐﺎﺭﺁﻣﺪﺗﺮ ﮐﺮﺩﻩ ﺍﺳﺖ ﻭ ﺩﺭ ﺻﻮﺭﺗﯽ ﮐﻪ ﭼﻨﻴﻦ ﺩﺳﺘﻮﺭﺍﺗﯽ ﻭﺟﻮﺩ‬

‫ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﺍﺯ ﺁﻧﻬﺎ ﺍﺳﺘﻔﺎﺩﻩ ﮐﻨﻴﺪ‪ .‬ﻣﺨﺼﻮﺻﹰﺎ ﺍﮔﺮ ﺑﺮﺍﯼ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﮐﺎﻣﭙﻴﻮﺗﺮﻫﺎﯼ ﭼﻨﺪ ﭘﺮﺩﺍﺯﻧﺪﻩ ﺍﯼ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﻣﯽ ﮐﻨﻴﺪ‪.‬‬
‫ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﻓﺮﺽ ﮐﻨﻴﺪ ﮐﻪ ﺩﻣﺎﯼ ﻧﻘﻄﻪ ﺍﯼ ﺑﺎ ﻃﻮﻝ ‪ 55‬ﻭ ﻋﺮﺽ ‪ 12‬ﺭﺍ ﺑﻴﺎﺑﻴﻢ ﻭ ﺩﺭ ﻣﺘﻐﻴﺮ ‪ temp‬ﻗﺮﺍﺭ ﺩﻫﻴﻢ ﻭ ﻫﻤﭽﻨﻴﻦ ﺩﻣﺎﯼ ﻧﻘﻄﻪ ‪ 56‬ﻭ‬

‫‪ 13‬ﺭﺍ ﺑﺮﺍﺑﺮ ‪ 400‬ﮐﻠﻮﻳﻦ ﻗﺮﺍﺭ ﺩﻫﻴﻢ‪.‬‬

‫)‪temp = temperature(55,12‬‬

‫‪temperature(56,13) = 400.0‬‬

‫ﺑﺮﺍﯼ ﺧﻮﺍﻧﺪﻥ ﻳﺎ ﭼﺎﭖ ﺁﺭﺍﻳﻪ ﻫﺎ ﻣﯽ ﺗﻮﺍﻥ ﺍﻧﺪﻳﺴﻬﺎ ﺭﺍ ﻧﺎﺩﻳﺪﻩ ﮔﺮﻓﺖ ﺗﺎ ﻋﻤﻞ ﻣﻮﺭﺩ ﻧﻈﺮ ﺭﻭﯼ ﮐﻞ ﺁﺭﺍﻳﻪ ﺍﻧﺠﺎﻡ ﮔﻴﺮﺩ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺑﺮﺍﯼ ﻧﻤﺎﻳﺶ ﮐﻞ‬

‫ﺁﺭﺍﻳﻪ ‪ temperature‬ﺭﻭﯼ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﺍﺯ ﺩﺳﺘﻮﺭ ﺯﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ‪.‬‬

‫‪WRITE(*,*) temperature‬‬

‫ﺍﻳﻦ ﻧﻤﺎﻳﺶ ﺩﺭ ﺻﻮﺭﺗﯽ ﮐﻪ ﺗﻌﺪﺍﺩ ﺍﻋﻀﺎﺀ ﺩﺭ ﻳﮏ ﺳﻄﺮ ﺟﺎ ﻧﮕﻴﺮﺩ ﮐﻤﯽ ﮔﻴﺞ ﮐﻨﻨﺪﻩ ﺍﺳﺖ‪.‬‬

‫ﺍﺭﺳﺎﻝ ﺁﺭﺍﻳﻪ ﺑﻌﻨﻮﺍﻥ ﻳﮏ ﭘﺎﺭﺍﻣﺘﺮ ﺑﻪ ﺗﺎﺑﻊ‬

‫ﺑﺴﻴﺎﺭﯼ ﺍﺯ ﻣﻮﺍﺭﺩ ﺷﻤﺎ ﻣﯽ ﺧﻮﺍﻫﻴﺪ ﮐﻪ ﻳﮏ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﻪ ﻳﮏ ﺗﺎﺑﻊ ﺍﺭﺳﺎﻝ ﮐﻨﻴﺪ‪ ,‬ﺗﻨﻬﺎ ﻣﺸﮑﻞ ﻋﺪﻡ ﺍﻃﻼﻉ ﺁ ﺭﺍﻳﻪ ﺍﺯ ﺍﻧﺪﺍﺯﻩ ﺧﻮﺩﺵ ﻣﯽ ﺑﺎﺷﺪ‪ ,‬ﭘﺲ‬

‫ﺑﺎﻳﺪ ﺁﺭﺍﻳﻪ ﻓﺮﺳﺘﺎﺩﻩ ﺷﺪﻩ ﺑﻪ ﺗﺎﺑﻊ ﺩﺍﺭﺍﯼ ﺍﻧﺪﺍﺯﻩ ﺛﺎﺑﺖ ﺑﺎﺷﺪ )‪ (fixed-size array‬ﻳﺎ ﺑﺎﻳﺪ ﺍﻧﺪﺍﺯﻩ ﺁﺭﺍﻳﻪ ﺭﺍ ﻫﻢ ﺑﻌﻨﻮﺍﻥ ﻳﮏ ﭘﺎﺭﺍﻣﺘﺮ ﺩﻳﮕﺮ ﺑﻪ ﺗﺎﺑﻊ‬

‫ﺍﺭﺳﺎﻝ ﮐﻨﻴﻢ ﺗﺎ ﻣﺒﺎﺩﺍ ﺍﺯ ﻣﺮﺯﻫﺎﯼ ﺁﺭﺍﻳﻪ ﻓﺮﺍﺗﺮ ﺑﺮﻭﻳﻢ! ﺍﮔﺮ ﺍﻧﺪﺍﺯﻩ ﺁﺭﺍﻳﻪ ﻣﺸﺨﺺ ﻧﺒﺎﺷﺪ ﻣﯽ ﺗﻮﺍﻧﻴﻢ ﺁﻥ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﺎ ﺁﺭﮔﻮﻣﺎﻥ * ﺑﺮﺍﯼ ﺁﺧﺮﻳﻦ ﭘﺎﺭﺍﻣﺘﺮ‬

‫ﺁﺭﺍﻳﻪ )ﻓﻘﻂ ﻳﮏ ﺑﻌﺪ ﺍﺯ ﺁﺭﺍﻳﻪ ﺭﺍ ﻣﯽ ﺗﻮﺍﻥ ﺑﻪ ﺍﻳﻦ ﺷﮑﻞ ﺗﻌﺮﻳﻒ ﮐﺮﺩ( ﺑﻪ ﺗﺎﺑﻊ ﺍﺭﺳﺎﻝ ﮐﻨﻴﻢ‪ .‬ﺩﺭ ﻫﺮ ﺣﺎﻝ ﺑﺨﺎﻃﺮ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﮐﻪ ﻣﺘﺮﺟﻢ ﺑﺮﻧﺎﻣﻪ ﺍﺯ‬

‫ﻃﻮﻝ ﺁﺭﺍﻳﻪ ﺍﻃﻼﻉ ﻧﺨﻮﺍﻫﺪ ﺩﺍﺷﺖ ﻭ ﺷﻤﺎ ﺧﻮﺩﺗﺎﻥ ﺑﺎﻳﺪ ﻣﻄﻤﺌﻦ ﺷﻮﻳﺪ ﮐﻪ ﻓﺮﺍﺗﺮ ﺍﺯ ﻣﺤﺪﻭﺩﻩ ﺍﻋﻀﺎﺀ ﺁﺭﺍﻳﻪ ﻧﺮﻭﻳﺪ‪.‬‬

‫ﻣﺮﺍﺟﻊ‪:‬‬

‫‪Physics Department, State University of Michigan, September ,“to FORTRAN Introduction” ,Aloksandra Donev‬‬

‫‪reading recommended for – 1999‬‬

‫ﺗﺮﺟﻤﻪ‪ :‬ﻣﺤﻤﺪ ﻧﻮﺭﻭﺯﯼ‪" ،‬ﮐﺘﺎﺏ ﺁﻣﻮﺯﺷﯽ ‪ ،"Visual C++ 6‬ﮐﺎﻧﻮﻥ ﻧﺸﺮ ﻋﻠﻮﻡ‪ ،‬ﭼﺎﭖ ﺍﻭﻝ‪1377 ،‬‬

‫ﺩﮐﺘﺮ ﺣﺒﻴﺐ ﺍﷲ ﺩﻩ ﻣﺮﺩﻩ‪ ،‬ﭘﺮﻭﻳﺰ ﺳﺮﮔﻠﺰﺍﻳﯽ‪ ،‬ﭼﻨﮕﻴﺰ ﺩﻝ ﺁﺭﺍ‪" ،‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﯽ ﮐﺎﻣﭙﻴﻮﺗﺮ – ﻓﺮﺗﺮﻥ‪ ،‬ﻣﻮﺳﺴﻪ ﻧﺸﺮ ﻋﻠﻮﻡ ﻧﻮﻳﻦ"‪ ،‬ﭼﺎﭖ ﺩﻭﻡ ‪1370‬‬

‫]‪http://www.pcc.qub.ac.uk/tec/courses/f90/ohp/header_ohMIF_1.html [2‬‬

‫]‪Help of Digital Visual FORTRAN –standard edition V 6.0 [3‬‬