‫|‪(D)1‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺑﺴﻢ ﺍﻟﻠﻪ ﺍﻟﺮﺣﻤﻦ ﺍﻟﺮﺣﻴﻢ‬

‫ﻭﺯﺍﺭﺓ ﺍﻟﺘﻌﻠﻴﻢ ﺍﻟﻌﺎﻟﻲ ﻭﺍﻟﺒﺤﺚ ﺍﻟﻌﻠﻤﻲ‬

‫ﺟﺎﻣﻌﺔ ﻭﺍﺳﻂ _ ﻛﻠﻴﺔ ﺍﻟﻬﻨﺪﺳﺔ‬
‫ﻗﺴﻢ ﺍﻟﻤﺪﻧﻲ _ ﺍﻟﻤﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫ﺍﻟــــــﺒــــــﺮﻣـــــﺠــــــﺔ‬
‫‪Fortran 90/95‬‬

‫‪2017-2018‬‬
‫|‪(D)2‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫‪Fortran PowerStation‬‬ ‫ﻃﺮﻳﻘﺔ ﺍﺳﺘﺨﺪﺍﻡ‬

‫ﺃ( ﻣﺴﺎﺣﺔ ﺍﻟﻌﻤﻞ‬
‫ﻳﺘﻜﻮﻥ ﻛﻞ ﻣﺸﺮﻭﻉ ﻓﻲ ‪ (MSDEV) Microsoft Developer Studio‬ﻣﻦ ﻣﺠﻠﺪ ﻳﺤﻮﻱ ﻋﺪﺓ‬
‫ﻣﻠﻔﺎﺕ ﻣﻨﻬﺎ ﻣﺎ ﻳﻜﺘﺒﻪ ﺍﻟﻤﺒﺮﻣﺞ ﻟﺘﻜﻮﻳﻦ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻤﻄﻠﻮﺏ‪ ،‬ﻭﻣﻨﻬﺎ ﻣﺎ ﻳﺼﻨﻌﻪ ‪ MSDEV‬ﻟﻐﺮﺽ‬
‫ﺇﺩﺍﺭﺓ ﻋﻤﻞ ﺍﻟﻤﺸﺮﻭﻉ‪ .‬ﻳﺴﻤﻰ ﺍﻟﻤﺸﺮﻭﻉ ﻓﻲ ‪ MSDEV‬ﻣﺴﺎﺣﺔ ﻋﻤﻞ )‪.(Work Space‬‬

‫ﺏ( ﺗﻜﻮﻳﻦ ﺑﺮﻧﺎﻣﺞ‬

‫ﻟﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻓﻲ ‪ MSDEV‬ﻧﻔﺬ ﺍﻟﻤﺮﺍﺣﻞ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪ (1‬ﺷﻐﻞ ‪ ، MSDEV‬ﻭﺇﺫﺍ ﻛﺎﻥ ﻫﻨﺎﻙ ﻣﺸﺮﻭﻉ ﻗﺪﻳﻢ ﺃﻏﻠﻘﻪ ﺑﻨﻘﺮ ﻗﺎﺋﻤﺔ ‪ File‬ﻭﻣﻦ ﺛﻢ ﺍﺧﺘﻴﺎﺭ‬
‫‪ Close Workspace‬ﻓﻲ ﻫﺬﻩ ﺍﻟﻘﺎﺋﻤﺔ‪) .‬ﺳﺘﻜﺘﺐ ﻫﺬﻩ ﺍﻟﻤﺮﺍﺣﻞ ﻫﻨﺎ ﺑﺸﻜﻞ ﻣﺨﺘﺼﺮ ﻛﻤﺎ ﻳﻠﻲ‪File :‬‬
‫‪(» Close Workspace‬‬

‫‪ (2‬ﺛﻢ ﺍﺑﺪﺃ ﻣﺸﺮﻭﻉ ﺟﺪﻳﺪ ﺑـ‪:‬‬

‫‪File » New » Project Workspace » OK‬‬
‫ﻭﺍﺧﺘﺎﺭ ‪ ،Console Application‬ﻭﺍﻛﺘﺐ ﺍﺳﻢ ﺍﻟﻤﺸﺮﻭﻉ ﻭﻣﺤﻞ ﺧﺰﻧﻪ ﻓﻲ ﺣﻘﻠﻲ ‪ Name‬ﻭ‬
‫‪ Location‬ﺛﻢ ﺍﻧﻘﺮ ﻋﻠﻰ ‪.Create‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﺸﺎﺭ ﺇﻟﻰ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺬﻱ ﻳﺴﺘﺨﺪﻡ ﻃﺮﻳﻘﺔ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﺍﻟـ ‪ DOS‬ﻓﻲ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ‬
‫ﺍﻟﻤﺴﺘﺨﺪﻡ )ﺍﻟﺸﺎﺷﺔ ﺍﻟﺴﻮﺩﺍﺀ ﻭﺇﺩﺧﺎﻝ ﻭﺇﺧﺮﺍﺝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﺸﻜﻞ ﻧﺼﻮﺹ ﻓﻘﻂ( ﺑﺎﺳﻢ ‪Console‬‬
‫‪.Application‬‬

‫ﻓﻲ ﻫﺬﻩ ﺍﻟﻤﺮﺣﻠﺔ ﻳﻤﻜﻦ ﻣﻼﺣﻈﺔ ﺟﺰﺀ )‪ (Pane‬ﻣﺴﺎﺣﺔ ﻋﻤﻞ ﺍﻟﻤﺸﺮﻭﻉ ﻓﻲ ﻳﺴﺎﺭ ﻧﺎﻓﺬﺓ‬
‫‪ ،MSDEV‬ﻳﻤﻜﻦ ﺇﺧﻔﺎﺀ ﻭﺇﻇﻬﺎﺭ ﻫﺬﺍ ﺍﻟﺠﺰﺀ ﺑـ ‪.View » Project Workspace‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺗﻘﺴﻢ ﻭﺍﺟﻬﺔ ‪ MSDEV‬ﺇﻟﻰ ﻋﺪﺓ ﺃﻗﺴﺎﻡ ﻓﻲ ﺃﻋﻠﻰ ﺍﻟﻨﺎﻓﺬﺓ ﺷﺮﻳﻂ ﺍﻟﻌﻨﻮﺍﻥ )‪(Title Bar‬‬
‫ﻭﻣﻦ ﺛﻢ ﺷﺮﻳﻂ ﺍﻟﻘﻮﺍﺋﻢ )‪(Menu Bar‬ﻭﻣﻦ ﺛﻢ ﺃﺷﺮﻃﺔ ﺍﻷﺩﻭﺍﺕ )‪ (Tool Bars‬ﻭﺗﺤﺖ ﻫﺬﻩ‬
‫ﺍﻷﺷﺮﻃﺔ ﺗﻮﺟﺪ ﻣﻨﻄﻘﺔ ﺗﺤﻮﻱ ﻧﺎﻓﺬﺓ ﻟﺘﺤﺮﻳﺮ ﺍﻟﺒﺮﺍﻣﺞ ﻭﻋﺪﺓ ﺃﺟﺰﺍﺀ )‪ (Pane‬ﻳﻤﻜﻦ ﺇﻇﻬﺎﺭ ﻭﺇﺧﻔﺎﺀ‬
‫ﺃﻱ ﻣﻨﻬﺎ ﻣﻦ ﺧﻼﻝ ﻗﺎﺋﻤﺔ ‪.View‬‬

‫‪ (3‬ﺑﻌﺪ ﺫﻟﻚ ﺍﺻﻨﻊ ﻣﻠﻒ ﺑﺮﻧﺎﻣﺞ ﻓﻮﺭﺗﺮﺍﻥ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪File » New » Text File » OK‬‬
‫ﺛﻢ‪:‬‬
‫‪File » Save As‬‬
‫ﻭﺍﺩﺧﻞ ﺍﺳﻢ ﺍﻟﻤﻠﻒ‪ ،‬ﻭﺍﺣﻔﻆ ﺍﻟﻤﻠﻒ ﻓﻲ ﻧﻔﺲ ﻣﺠﻠﺪ ﺍﻟﻤﺸﺮﻭﻉ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﺠﺐ ﺃﻥ ﻳﻨﺘﻬﻲ ﺍﺳﻢ ﻣﻠﻒ ﺑﺮﻧﺎﻣﺞ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﺎﻻﻣﺘﺪﺍﺩ "‪) ".F90‬ﺍﻻﻣﺘﺪﺍﺩ =‬
‫‪.(extension‬‬

‫‪ (4‬ﺑﻌﺪ ﺫﻟﻚ ﻳﻤﻜﻦ ﺇﺿﺎﻓﺔ ﻫﺬﺍ ﺍﻟﻤﻠﻒ ﺇﻟﻰ ﺍﻟﻤﺸﺮﻭﻉ ﺑـ‪:‬‬

‫‪Insert » Files Into Project‬‬
‫ﻭﺍﺧﺘﻴﺎﺭ ﺍﻟﻤﻠﻒ ﺍﻟﺬﻱ ﺻﻨﻌﺘﻪ ﻓﻲ ﺍﻟﻔﻘﺮﺓ ‪.3‬‬

‫‪ (5‬ﺍﻵﻥ ﻳﻤﻜﻨﻚ ﻛﺘﺎﺑﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﻣﺜﻼً ﺍﻛﺘﺐ ﻓﻲ ﺍﻟﻤﻠﻒ ﺍﻟﺬﻱ ﺻﻨﻌﺘﻪ ﻓﻲ ﺍﻟﻔﻘﺮﺓ ‪:3‬‬
‫"!‪PRINT *, "Hello‬‬
‫‪END‬‬
‫|‪(D)3‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻭﺑﻌﺪﻫﺎ ‪ File » Save‬ﻟﺤﻔﻆ ﺍﻟﺘﻐﻴﻴﺮﺍﺕ ﺩﺍﺧﻞ ﺍﻟﻤﻠﻒ‪.‬‬

‫ﺝ( ﺗﺮﺟﻤﺔ ﻭﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫ﺗﺘﻢ ﺗﺮﺟﻤﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻟﻠﻐﺔ ﺍﻟﻤﺎﻛﻨﺔ ﺑـ ‪ Build » Build *.exe‬ﺳﻮﻑ ﻳُﻔﺘﺢ ﺟﺰﺀ ﻓﻲ ﺃﺳﻔﻞ ﺍﻟﻨﺎﻓﺬﺓ‬
‫ﻳﺴﻤﻰ ‪ Output Pane‬ﺗﻜﺘﺐ ﻓﻴﻪ ﺍﻷﺧﻄﺎﺀ )‪ (error‬ﻭﺍﻟﺘﺤﺬﻳﺮﺍﺕ )‪ (warning‬ﺍﻟﺘﻲ ﻳﻮﺍﺟﻬﻬﺎ‬
‫ﺍﻟﻤﺘﺮﺟﻢ ﻋﻨﺪ ﺗﺮﺟﻤﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ‪ .‬ﻭﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺻﺤﻴﺤﺎً ﺃﻱ ﻻ ﻳﺤﺘﻮﻱ ﻋﻠﻰ ﺃﻱ ﺧﻄﺄ)ﺇﻣﻼﺋﻲ‬
‫ﺃﻭ ﻧﺤﻮﻱ( ﻣﻦ ﺍﻟﻤﻤﻜﻦ ﺗﻨﻔﻴﺬﻩ ﺑـ‪:‬‬
‫‪Build » Execute *.exe‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻭﺟﻮﺩ ﺍﻟﺘﺤﺬﻳﺮﺍﺕ ﻻ ﻳﻤﻨﻊ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ﺍﻟﺘﺮﺟﻤﺔ ﻭﺍﻟﺘﻨﻔﻴﺬ ﻭﻟﻜﻦ ﻣﻦ ﺍﻷﻓﻀﻞ ﺇﺯﺍﻟﺔ‬
‫ﺍﻟﺘﺤﺬﻳﺮﺍﺕ ﻣﻦ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻷﻥ ﺗﺠﺎﻫﻞ ﺑﻌﺾ ﺍﻟﺘﺤﺬﻳﺮﺍﺕ ﻳﺴﺒﺐ ﻣﺸﺎﻛﻞ ﻏﻴﺮ ﻣﺘﻮﻗﻌﺔ ﻓﻲ ﻋﻤﻞ‬
‫ﺍﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻔﺎﺗﻴﺢ ﺍﻻﺧﺘﺼﺎﺭ ﺍﻟﻤﻜﺘﻮﺑﺔ ﺑﺠﺎﻧﺐ ﺍﻷﻭﺍﻣﺮ ﻓﻲ ﺍﻟﻘﻮﺍﺋﻢ ﺑﺪﻻً ﻣﻦ‬
‫ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻘﻮﺍﺋﻢ ﺑﻤﺆﺷﺮ ﺍﻟﻔﺄﺭﺓ‪.‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﻤﻜﻦ ﺍﺧﺘﺼﺎﺭ ﻫﺬﻩ ﺍﻟﻤﺮﺍﺣﻞ ﺑﻄﺮﻳﻘﺔ ﺳﺮﻳﻌﺔ ﻭﻟﻜﻦ ﻏﻴﺮ ﻛﺎﻣﻠﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪ (1‬ﺍﻏﻠﻖ ﺍﻟﻤﺸﺮﻭﻉ ﺍﻟﺴﺎﺑﻖ ﺇﺫﺍ ﻛﺎﻥ ﻣﻔﺘﻮﺣﺎً ﺑـ ‪File » Close Workspace‬‬
‫‪ (2‬ﺍﺻﻨﻊ ﻣﻠﻒ ﺟﺪﻳﺪ ﺑـ ‪File » New » Text File » OK‬‬
‫‪ (3‬ﺍﻛﺘﺐ ﺍﻟﺒﺮﻧﺎﻣﺞ‬
‫‪ (4‬ﺍﺣﻔﻆ ﺍﻟﻤﻠﻒ ﺑـ ‪ File » Save As‬ﺛﻢ ﺍﺩﺧﻞ ﺍﺳﻢ ﺍﻟﻤﻠﻒ‬
‫‪ (5‬ﺗﺮﺟﻢ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑـ ‪ ،Build » Build *.exe‬ﻓﻲ ﻫﺬﻩ ﺍﻟﻤﺮﺣﻠﺔ ﺳﻮﻑ ﻳﺴﺄﻟﻚ‪ :MSDEV‬ﻫﻞ‬
‫ﺗﺮﻳﺪ ﺇﻳﺠﺎﺩ ﻣﺴﺎﺣﺔ ﻋﻤﻞ ﺟﺪﻳﺪﺓ ﺧﺎﺻﺔ ﺑﻬﺬﺍ ﺍﻟﻤﻠﻒ؟ ﻭﺑﺎﻹﺟﺎﺑﺔ ﺑﻨﻌﻢ ﺳﻮﻑ ﻳﺼﻨﻊ ﻣﺴﺎﺣﺔ ﻋﻤﻞ‬
‫ﺑﻨﻔﺲ ﺍﺳﻢ ﻣﻠﻒ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻭﻳﻀﻊ ﻣﻠﻒ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻓﻴﻪ ﻭﻳﺘﺮﺟﻤﻪ ﻣﺒﺎﺷﺮﺓ‪.‬‬

‫ﺩ( ﺗﺘﺒﻊ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ‪:Trace‬‬

‫ﻳﻤﻜﻦ ﺗﺘﺒﻊ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺧﻄﻮﺓ ﺧﻄﻮﺓ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻗﺎﺋﻤﺔ ‪ ،Build » Debug‬ﺍﻟﻐﺮﺽ ﺍﻷﺻﻠﻲ‬
‫ﻣﻦ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻫﻮ ﺍﻛﺘﺸﺎﻑ ﺍﻷﺧﻄﺎﺀ ﺍﻟﻤﻨﻄﻘﻴﺔ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ‪ .‬ﻣﻦ ﺍﻟﺠﺪﻳﺮ ﺑﺎﻟﺬﻛﺮ ﺃﻥ‬
‫ﺍﻷﺧﻄﺎﺀ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺇﻣﺎ ﺃﻥ ﺗﻜﻮﻥ‪:‬‬
‫)‪ (1‬ﺃﺧﻄﺎﺀ ﺇﻣﻼﺋﻴﺔ )‪(lexical error‬ﺃﻭ ﺃﺧﻄﺎﺀ ﻧﺤﻮﻳﺔ )‪) (syntax error‬ﺗﺬﻛﺮ ﻋﺎﺩﺗﺎً ﻛﻼ‬
‫ﻫﺬﻳﻦ ﺍﻟﻨﻮﻋﻴﻦ ﺑﺎﺳﻢ ﺍﻷﺧﻄﺎﺀ ﺍﻟﻨﺤﻮﻳﺔ(‪ .‬ﺗﺤﺪﺙ ﻫﺬﻩ ﺍﻷﺧﻄﺎﺀ ﺑﺴﺒﺐ ﻋﺪﻡ ﺇﺗﺒﺎﻉ ﻗﻮﺍﻋﺪ ﺍﻟﻠﻐﺔ ﺑﺸﻜﻞ‬
‫ﺻﺤﻴﺢ‪ ،‬ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﻫﺬﻩ ﺍﻷﺧﻄﺎﺀ ﻋﻨﺪ ﺗﺮﺟﻤﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻷﻥ ﺍﻟﻤﺘﺮﺟﻢ )‪ (compiler‬ﻳﻘﺎﺭﻥ ﺍﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻣﻊ ﻗﻮﺍﻋﺪ ﺍﻟﻠﻐﺔ ﻭﻳﻤﻜﻦ ﻟﻪ ﺃﻥ ﻳﺤﺪﺩ ﺃﻱ ﺧﻄﺄ ﺇﻣﻼﺋﻲ ﺃﻭ ﻧﺤﻮﻱ ﻣﻮﺟﻮﺩ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﺃﻣﺎ ﺍﻟﻨﻮﻉ ﺍﻵﺧﺮ ﻣﻦ ﺍﻷﺧﻄﺎﺀ ﻓﻬﻲ )‪ (2‬ﺍﻷﺧﻄﺎﺀ ﺍﻟﻤﻨﻄﻘﻴﺔ )‪ (logical error‬ﻭﻫﻲ ﺍﻷﺧﻄﺎﺀ‬
‫ﺍﻟﺘﻲ ﺗﺤﺪﺙ ﺑﺴﺒﺐ ﻋﺪﻡ ﻓﻬﻢ "ﺍﻟﻤﺒﺮﻣﺞ" ﻟﻠﻤﺴﺄﻟﺔ ﺃﻭ ﺧﻄﺄ "ﺍﻟﻤﺒﺮﻣﺞ" ﻓﻲ ﺗﺮﺟﻤﺔ ﻓﻜﺮﺗﻪ ﺇﻟﻰ ﺑﺮﻧﺎﻣﺞ‪،‬‬
‫ﻭﺍﻟﻘﺴﻢ ﺍﻷﻋﻈﻢ ﻣﻦ ﻫﺬﻩ ﺍﻷﺧﻄﺎﺀ ﻻ ﻳﻤﻜﻦ "ﻟﻠﻤﺘﺮﺟﻢ" )ﻓﻮﺭﺗﺮﺍﻥ ﺑﻮﺭﺳﺘﻴﺸﻦ( ﺗﺤﺪﻳﺪﻫﺎ ﻭﻳﺠﺐ ﻋﻠﻰ‬
‫ﺍﻟﻤﺒﺮﻣﺞ ﺗﺘﺒﻌﻬﺎ ﺑﺘﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻭﻣﻘﺎﺭﻧﺔ ﻋﻤﻠﻪ ﻣﻊ ﻣﺎ ﻳﺘﻮﻗﻊ ﺃﻥ ﻳﻜﻮﻥ‪.‬‬
‫ﻭﻫﻨﺎﻙ ﻧﻮﻉ ﺁﺧﺮ ﻣﻦ ﺍﻷﺧﻄﺎﺀ ﻳﺴﻤﻰ )‪ (3‬ﺃﺧﻄﺎﺀ ﺯﻣﻦ ﺍﻟﺘﻨﻔﻴﺬ )‪ (run time error‬ﻣﺜﻼً ﻋﻨﺪ‬
‫ﻗﺴﻤﺔ ﻣﺘﻐﻴﺮ ﻋﻠﻰ ﻣﺘﻐﻴﺮ ﺁﺧﺮ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﺘﺨﺪﻡ ﻓﻲ ﺍﻟﻤﻘﺎﻡ ﺻﻔﺮ ﻓﺴﻮﻑ ﻳﺤﺪﺙ‬
‫ﺧﻄﺄ ﺯﻣﻦ ﺍﻟﺘﻨﻔﻴﺬ‪ .‬ﻳﺠﺐ ﻋﻠﻰ ﺍﻟﻤﺒﺮﻣﺞ ﺗﻨﺒﺆ ﻫﺬﻩ ﺍﻷﺧﻄﺎﺀ ﻹﻳﺠﺎﺩ ﺍﻟﺤﻠﻮﻝ ﺍﻟﻤﻨﺎﺳﺒﺔ ﻟﻬﺎ ﻋﻨﺪ ﻛﺘﺎﺑﺔ‬
‫ﺍﻟﺒﺮﻧﺎﻣﺞ ﻭﻋﺪﻡ ﺗﺮﻛﻬﺎ ﻟﺘﺤﺪﺙ ﻋﻨﺪ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫ﻣﺜﺎﻝ‪:‬ﺍﻛﺘﺐ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ‬

‫‪i = 10‬‬
‫‪IF (i>=0) THEN‬‬
‫|‪(D)4‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫"‪PRINT *, i, "is negative‬‬

‫‪ELSE‬‬
‫"‪PRINT *, i, "is positive‬‬
‫‪END IF‬‬
‫‪END‬‬
‫ﺛﻢ ﺗﺮﺟﻤﻪ ﻭﻧﻔﺬﻩ‪ ،‬ﺳﻮﻑ ﻳﺘﺮﺟﻢ ﻭﻳﻨﻔﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺪﻭﻥ ﺃﻱ ﺃﺧﻄﺎﺀ ﻭﻟﻜﻦ ﺳﻮﻑ ﻳﻌﻄﻲ ﺍﻹﺧﺮﺍﺝ‬
‫ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫‪10 is negative‬‬
‫ﻭﻫﻮ ﺟﻮﺍﺏ ﺧﺎﻃﺊ‪ ،‬ﻫﺬﺍ ﻫﻮ ﻣﺎ ﻳﺴﻤﻰ "ﺍﻟﺨﻄﺄ ﺍﻟﻤﻨﻄﻘﻲ" ﻭﺳﺒﺒﻪ ﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﺍﺳﺘﺨﺪﺍﻡ‬
‫ﺍﻟﺸﺮﻁ ﻓﻲ ﺗﺮﻛﻴﺒﺔ ‪ IF‬ﺑﺸﻜﻞ ﺧﺎﻃﺊ‪.‬‬
‫ﻟﻤﻌﺮﻓﺔ ﻣﺤﻞ ﺣﺪﻭﺙ ﺍﻟﺨﻄﺄ ﺍﻟﻤﻨﻄﻘﻲ ﻳﺠﺐ ﻋﻠﻰ ﺍﻟﻤﺒﺮﻣﺞ ﻣﺮﺍﺟﻌﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺪﻗﺔ ﻟﻴﻌﺮﻑ ﺃﻳﻦ‬
‫ﺃﺧﻄﺄ ﻓﻲ ﻛﺘﺎﺑﺔ ﺍﻟﻔﻜﺮﺓ ﺣﻴﻦ ﺣﻮﻟﻬﺎ ﺇﻟﻰ ﺑﺮﻧﺎﻣﺞ‪ ،‬ﻭﻫﺬﺍ ﻣﻦ ﺃﺻﻌﺐ ﺍﻷﻋﻤﺎﻝ ﺍﻟﺘﻲ ﻳﻘﻮﻡ ﺑﻬﺎ ﺍﻟﻤﺒﺮﻣﺞ‬
‫ﻭﺃﻛﺜﺮﻫﺎ ﺇﺗﻼﻓﺎً ﻟﻠﻮﻗﺖ‪ .‬ﺣﺘﻰ ﺃﻥ ﺑﻌﺾ ﺍﻷﺧﻄﺎﺀ ﺍﻟﻤﻨﻄﻘﻴﺔ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﺑﺮﺍﻣﺞ ﺍﻟﺸﺮﻛﺎﺕ ﺍﻟﻜﺒﺮﻯ‬
‫ﻻ ﺗﻜﺘﺸﻒ ﺇﻟﻰ ﺑﻌﺪ ﻋﺪﺓ ﺳﻨﻮﺍﺕ ﻭﺑﻌﻀﻬﺎ ﺍﻵﺧﺮ ﻳﺴﺒﺐ ﺇﻟﻐﺎﺀ ﺍﻟﻤﺸﺎﺭﻳﻊ ﻟﻌﺪﻡ ﺃﻣﻜﺎﻧﻴﺔ ﺗﻌﻘﺒﻪ‪.‬‬
‫ﻭﻳﺄﺗﻲ ﺍﻟﻤﺼﺤﺢ ‪ Debugger‬ﻛﺈﺣﺪ ﺍﻷﺩﻭﺍﺕ ﺍﻟﺘﻲ ﺗﺴﺘﻌﻤﻞ ﻓﻲ ﺍﻛﺘﺸﺎﻑ ﺍﻷﺧﻄﺎﺀ‬
‫ﺍﻟﻤﻨﻄﻘﻴﺔ‪،‬ﺣﻴﺚ ﻳﻌﻄﻲ ﻗﺪﺭﺓ ﺍﻟﺴﻴﻄﺮﺓ ﻋﻠﻰ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﺸﻜﻞ ﺍﻟﻤﻄﻠﻮﺏ‪ .‬ﻓﻤﺜﻼً ﻳﻤﻜﻦ ﺗﻨﻔﻴﺬ‬
‫ﺍﻟﺒﺮﻧﺎﻣﺞ ﺳﻄﺮﺍً ﺗﻠﻮ ﺍﻵﺧﺮ ﺑـ ‪Build » Debug » Step Into‬ﺃﻭ ﻳﻤﻜﻦ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻟﺤﺪ ﺳﻄﺮ‬
‫ﻣﻌﻴﻦ ﺑـ‪ ،Build » Debug » Run to Cursor‬ﻭﻓﻲ ﺃﻱ ﻣﺮﺣﻠﺔ ﻣﻦ ﺍﻟﺘﺼﺤﻴﺢ ﻳﻤﻜﻦ ﺇﻳﻘﺎﻑ‬
‫ﺍﻟﺘﻨﻔﻴﺬ ﺑــــ‪.Debug » Stop Debugging‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻟﻜﻲ ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﺼﺤﺢ ﻳﺠﺐ ﺗﺮﺟﻤﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﺸﻜﻴﻠﺔ ‪ Debug‬ﻭﺫﻟﻚ ﺑــ‬
‫…‪ Build » Configurations‬ﺛﻢ ﺍﺧﺘﻴﺎﺭ ﻫﺬﻩ ﺍﻟﺘﺸﻜﻴﻠﺔ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﺑﻌﺪ ﺑﺪﺀ ﺍﻟﻤﺼﺤﺢ ﺗﺘﻐﻴﺮ ﻭﺍﺟﻬﺔ ‪ MSDEV‬ﻓﻴﻈﻬﺮ ﺳﻬﻢ ﺃﺻﻔﺮ ﺃﻣﺎﻡ ﺍﻟﺴﻄﺮ ﺍﻟﺬﻱ‬
‫ﻭﺻﻞ ﺇﻟﻴﻪ ﺍﻟﺘﻨﻔﻴﺬ ﻭﺗﺘﻐﻴﺮ ﺍﻟﻘﻮﺍﺋﻢ ﺃﻳﻀﺎً ﻓﺘﻈﻬﺮ ﻗﺎﺋﻤﺔ ‪ Debug‬ﺇﺿﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻘﻮﺍﺋﻢ ﺍﻟﺴﺎﺑﻘﺔ ﻭﺃﻳﻀﺎً‬
‫ﻳﻈﻬﺮ ﺟﺰﺀ )‪ (Pane‬ﻣﻜﺘﻮﺏ ﻓﻴﻪ ﻗﻴﻢ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ )‪ (Variables‬ﺃﺳﻔﻞ ﺍﻟﻨﺎﻓﺬﺓ ﻭﺃﺟﺰﺍﺀ ﺃﺧﺮﻯ ﻳﻤﻜﻦ‬
‫ﺇﻇﻬﺎﺭﻫﺎ ﻭﺇﺧﻔﺎﺀﻫﺎ ﻣﻦ ﺧﻼﻝ ﻗﺎﺋﻤﺔ ‪.View‬‬

‫ﻫـ( ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‬
‫ﻣﻦ ﺍﻟﺨﺪﻣﺎﺕ ﺍﻟﺘﻲ ﻳﻘﺪﻣﻬﺎ ‪ MSDEV‬ﻫﻲ ﺇﻋﻄﺎﺀ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻟﻠﻤﺒﺮﻣﺞ‪ ،‬ﻓﻤﺜﻼً ﺇﺫﺍ ﻭﺿﻌﺖ‬
‫ﺍﻟﻤﺆﺷﺮ )‪ (cursor‬ﻋﻠﻰ ﻛﻠﻤﺔ ‪ IF‬ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻭﺿﻐﻄﺖ ﻋﻠﻰ ﺍﻟﻤﻔﺘﺎﺡ ‪ F1‬ﺳﻮﻑ ﻳﻌﺮﺽ ﻟﻚ‬
‫‪ MSDEV‬ﺗﻌﻠﻴﻤﺎﺕ ﺣﻮﻝ ﺗﺮﻛﻴﺒﺔ ‪ ،IF‬ﺃﻭ ﻣﺜﻼً ﺇﺫﺍ ﻛﺘﺒﺖ ﻛﻠﻤﺔ ‪ ABS‬ﺩﺍﺧﻞ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻭﻭﺿﻌﺖ‬
‫ﺍﻟﻤﺆﺷﺮ ﻋﻠﻰ ﺍﻟﻜﻠﻤﺔ ﻭﺿﻐﻄﺖ ﻋﻠﻰ ﻣﻔﺘﺎﺡ ‪ F1‬ﺳﻮﻑ ﺗﺤﺼﻞ ﻋﻠﻰ ﺗﻌﻠﻴﻤﺎﺕ ﻣﻔﻴﺪﺓ ﻋﻦ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ‬
‫ﻭﻃﺮﻳﻘﺔ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻭﺩﻭﺍﻝ ﻣﺸﺎﺑﻬﺔ ﺃﺧﺮﻯ‪.‬‬

‫ﺗﻌﺮﻳﻒ‬
‫ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻫﻲ ﺇﺣﺪﻯ ﺃﻗﺪﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺮﻣﺠﺔ ﻭﻗﺪ ﻃﻮﺭ ﻫﺬﻩ ﺍﻟﻠﻐﺔ ﻓﺮﻳﻖ ﻣﻦ ﺍﻟﻤﺒﺮﻣﺠﻴﻦ‬
‫ﺑﺈﺷﺮﺍﻑ ‪ John Backus‬ﻭﺗﻢ ﻧﺸﺮﻫﺎ ﻓﻲ ﻋﺎﻡ ‪ 1957‬ﻷﻭﻝ ﻣﺮﺓ‪ .‬ﺍﺳﻢ ﻫﺬﻩ ﺍﻟﻠﻐﺔ ﻫﻮ ﺍﺧﺘﺼﺎﺭ ﻟـ‬
‫‪ FORmulaTRANslation‬ﻣﻤﺎ ﻳﺆﻛﺪ ﺃﻥ ﻫﺬﻩ ﺍﻟﻠﻐﺔ ﻗﺪ ﺻﻤﻤﺖ ﻟﺘﺴﻬﻴﻞ ﻋﻤﻠﻴﺔ ﺗﺮﺟﻤﺔ ﺍﻟﺼﻴﻎ‬
‫ﺍﻟﺮﻳﺎﺿﻴﺔ ﺇﻟﻰ ﺑﺮﺍﻣﺞ ﻟﻠﺤﺎﺳﻮﺏ؛ ﻭﻟﻬﺬﺍ ﻓﺈﻧﻬﺎ ﻟﻐﺔ ﻋﻠﻤﻴﺔ– ﻫﻨﺪﺳﻴﺔ‪.‬‬
‫ﻣﺮّ ﺗﻄﻮﺭ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﻌﺪﺓ ﻣﺮﺍﺣﻞ ﺑﻌﺪ ﺃﻭﻝ ﺇﺻﺪﺍﺭ ﻟﻬﺎ ﻭﻟﺬﻟﻚ ﺗﻮﺟﺪ ﻋﺪﺓ ﺇﺻﺪﺍﺭﺍﺕ‬
‫ﻗﻴﺎﺳﻴﺔ ﻣﻦ ﺃﻫﻤﻬﺎ ﺍﻹﺻﺪﺍﺭ ‪ FORTRAN 66‬ﺍﻟﺬﻱ ﺗﻢ ﻧﺸﺮﻩ ﻓﻲ ﺳﻨﺔ ‪ 1966‬ﻭﺍﻹﺻﺪﺍﺭ ﺍﻟﻤﻌﺮﻭﻑ‬
‫ﺟﺪﺍً ‪ FORTRAN 77‬ﺍﻟﺬﻱ ﺗﻢ ﻧﺸﺮﻩ ﺳﻨﺔ ‪) 1978‬ﺑﺪﺃ ﺍﻟﻌﻤﻞ ﺑﻪ ﺳﻨﺔ ‪ (1977‬ﻭﺍﻹﺻﺪﺍﺭ‬
‫‪ Fortran 90‬ﺍﻟﺬﻱ ﺗﻢ ﺳﻨﺔ ‪ 1990‬ﻭﻓﻲ ﻫﺬﺍ ﺍﻹﺻﺪﺍﺭ ﺗﻢ ﺇﺿﺎﻓﺔ ﻣﻴﺰﺍﺕ ﺟﺪﻳﺪﺓ ﻛﺜﻴﺮﺓ ﺇﻟﻰ ﻫﺬﻩ‬
‫ﺍﻟﻠﻐﺔ ﺑﻌﺪ ﺍﻟﺘﻄﻮﺭ ﺍﻟﻜﺒﻴﺮ ﺍﻟﺬﻱ ﺣﺪﺙ ﻋﻠﻰ ﻟﻐﺎﺕ ﺍﻟﺒﺮﻣﺠﺔ ﻣﻨﺬ ﺇﺻﺪﺍﺭﺍﺕ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺍﻷﻭﻟﻰ‪.‬‬
‫|‪(D)5‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﺘﻨﻈﻴﻢ ﻓﻲ ﻃﺒﺎﻋﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ‪Formatting layout‬‬

‫ﻛﺎﻧﺖ ﻓﻲ ﺍﻻﺻﺪﺍﺭﺕ ﺍﻟﺴﺎﺑﻘﺔ ﻟﻠـ ‪ Fortran 90‬ﺗﺴﺘﺨﺪﻡ ﻃﺮﻳﻘﺔ ﻣﻌﻘﺪﺓ ﻟﺘﻨﻈﻴﻢ ﻃﺒﺎﻋﺔ ﺍﻷﻭﺍﻣﺮ‬
‫ﻓﻲ ﺍﻟﺼﻔﺤﺔ ﺣﻴﺚ ﻛﺎﻥ ﻳﺤﺪﺩ ﻣﺤﻞ ﻛﺘﺎﺑﺔ ﺍﻷﻭﺍﻣﺮ ﻭﺍﻹﻳﻀﺎﺡ ﻭﺃﺭﻗﺎﻡ ﺍﻷﺳﻄﺮ ﻓﻲ ﺃﻋﻤﺪﺓ ﻣﺨﺼﺼﺔ‪.‬‬
‫ﺃﻣﺎ ﺍﻹﺻﺪﺍﺭ ‪90‬ﻓﻴﺴﺘﺨﺪﻡ ﻃﺮﻳﻘﺔ ﻟﺘﻨﻈﻴﻢ ﺍﻟﺠﻤﻞ ﺗﺴﻤﻰ ﺍﻟﺘﻨﻈﻴﻢ ﺍﻟﺤﺮ ) ‪free formatting‬‬
‫‪ (layout‬ﻭﻳﺘﺒﻊ ﺍﻟﻘﻮﺍﻧﻴﻦ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪ -1‬ﻳﻤﻜﻦ ﺃﻥ ﺗﺒﺪﺃ ﺍﻟﺠﻤﻠﺔ ﻓﻲ ﺃﻱ ﻣﻜﺎﻥ ﻓﻲ ﺍﻟﺴﻄﺮ‬
‫‪ -2‬ﺍﻹﻳﻀﺎﺡ )‪ (comment‬ﻳﺒﺪﺃ ﺑﻌﻼﻣﺔ ﺍﻟﺘﻌﺠﺐ )!( ﻭﻳﺴﺘﻤﺮ ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﺍﻟﺴﻄﺮ‬
‫‪ -3‬ﻟﺘﻜﻤﻠﺔ ﺟﻤﻠﺔ ﻓﻲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﻟﻲ ﺗﻮﺿﻊ ﺍﻟﻌﻼﻣﺔ )&( ﻓﻲ ﻧﻬﺎﻳﺔ ﺍﻟﺴﻄﺮ ﻭﺗﻜﺘﺐ ﺑﻘﻴﺔ ﺍﻟﺠﻤﻠﺔ‬
‫ﻓﻲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﻟﻲ‬
‫‪ -4‬ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﺟﻤﻠﺘﻴﻦ ﻓﻲ ﺳﻄﺮ ﻭﺍﺣﺪ ﻭﻟﻜﻦ ﻳﺠﺐ ﺍﻟﻔﺼﻞ ﺑﻴﻨﻬﻤﺎ ﺑﻌﻼﻣﺔ );( ﺍﻟﻔﺎﺭﺯﺓ‬
‫ﺍﻟﻤﻨﻘﻮﻃﺔ‪.‬‬
‫‪ -5‬ﺣﺮﻭﻑ ﺍﻟﻔﻮﺍﺻﻞ )‪ (space, tab‬ﻳﻤﻜﻦ ﺃﻥ ﺗﻮﺿﻊ ﺑﻴﻦ ﺍﻟﺮﻣﻮﺯ ﻓﻲ ﺃﻱ ﻣﻜﺎﻥ ﻭﻟﻜﻦ ﻟﻴﺲ‬
‫ﺑﻴﻦ ﺣﺮﻭﻑ ﺍﻟﺮﻣﻮﺯ‬

‫‪Naming conventions‬‬ ‫ﻗﻮﺍﻋﺪ ﺗﺴﻤﻴﺔ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ‬

‫ﺗﺘﺒﻊ ﻟﻐﺔ ﻓﻮﺭﺗﺮﺍﻥ ‪ 90‬ﻗﻮﺍﻋﺪ ﺗﺸﺒﻪ ﻗﻮﺍﻋﺪ ﺍﻟﺘﺴﻤﻴﺔ )ﺃﺳﻤﺎﺀ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﺃﻭ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ ﺃﻭ‬
‫ﻏﻴﺮﻫﺎ( ﻓﻲ ﺑﺎﻗﻲ ﺍﻟﻠﻐﺎﺕ ﻭﻫﻲ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪ -1‬ﻳﺴﺘﺨﺪﻡ ﻓﻘﻂ ﺍﻟﺤﺮﻭﻑ ﺍﻻﻧﻜﻠﻴﺰﻳﺔ ﻭﺍﻷﺭﻗﺎﻡ ﻭﺍﻟﺨﻂ ﺍﻷﺳﻔﻞ )_( ﻓﻲ ﺍﻟﺘﺴﻤﻴﺔ‬
‫‪ -2‬ﻳﺠﺐ ﺃﻥ ﻳﻜﻮﻥ ﺍﻟﺤﺮﻑ ﺍﻷﻭﻝ ﻓﻲ ﺍﻷﺳﻤﺎﺀ ﺃﺣﺪ ﺍﻟﺤﺮﻭﻑ ﺍﻻﻧﻜﻠﻴﺰﻳﺔ‬
‫‪ -3‬ﻻ ﻳﻔﺮﻕ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﻴﻦ ﺍﻟﺤﺮﻭﻑ ﺍﻟﻜﺒﻴﺮﺓ ﻭﺍﻟﺼﻐﻴﺮﺓ ﻓﻲ ﺍﻷﺳﻤﺎﺀ )‪(case insensitive‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻣﺎ ﻫﻲ ﺍﻷﺧﻄﺎﺀ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﻗﻄﻌﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ؟‬

‫‪Cost$ = 37‬‬
‫"‪2nd_name = "Hamilton‬‬
‫ﻓﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻷﻭﻟﻰ ﺍﻟﻤﺘﻐﻴﺮ ﻳﺤﺘﻮﻱ ﻋﻠﻰ ﺍﻟﻌﻼﻣﺔ ‪ $‬ﻭﺍﻟﺘﻲ ﻻ ﻳﺴﻤﺢ ﺑﺎﺳﺘﺨﺪﺍﻣﻬﺎ ﻓﻲ ﺍﻟﺘﺴﻤﻴﺔ ﻓﻲ‬
‫ﺍﻟﻔﻮﺭﺗﺮﺍﻥ‪ ،‬ﺃﻣﺎ ﻓﻲ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻓﻘﺪ ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺮﻣﺰ ‪ 2‬ﻛﺄﻭﻝ ﺣﺮﻑ ﻓﻲ ﺍﻻﺳﻢ ﻭﻫﺬﺍ ﻳﺘﻌﺎﺭﺽ‬
‫ﻣﻊ ﺍﻟﻘﺎﻋﺪﺓ ﺍﻟﺜﺎﻧﻴﺔ ﻓﻲ ﺍﻟﺘﺴﻤﻴﺔ‪.‬‬

‫‪End‬‬ ‫ﺟﻤﻠﺔ ‪ Program‬ﻭﺟﻤﻠﺔ‬

‫ﻳﺘﻜﻮﻥ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ‪ 90‬ﻣﻦ ﺟﻤﻞ ﻭﺗﻜﻮﻥ ﺃﻭﻝ ﺟﻤﻠﺔ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻫﻲ ﺟﻤﻠﺔ‬
‫‪ Program‬ﻭﺗﻜﺘﺐ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺍﺳﻢ ﺍﻟﺒﺮﻧﺎﻣﺞ‪Program‬‬
‫ﻭﻫﻲ ﺟﻤﻠﺔ ﺧﻴﺎﺭﻳﺔ )‪ (optional‬ﻭﻟﻜﻦ ﻳﻔﻀﻞ ﻛﺘﺎﺑﺘﻬﺎ ﻹﺑﺮﺍﺯ ﺑﺪﺍﻳﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﻭﺗﻜﻮﻥ ﺃﺧﻴﺮ‬
‫ﺟﻤﻠﺔ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻫﻲ ﺟﻤﻠﺔ ‪ End‬ﻭﺗﻜﺘﺐ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺍﺳﻢ ﺍﻟﺒﺮﻧﺎﻣﺞ‪EndProgram‬‬
‫ﻭﻫﺬﻩ ﺍﻟﺠﻤﻠﺔ ﺗﺸﻴﺮ ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﻧﺺ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻓﻘﻂ ﻭﻫﻲ ﺟﻤﻠﺔ "ﻏﻴﺮ ﺗﻨﻔﻴﺬﻳﺔ" )ﻓﻲ ﺍﻟﺒﻴﺴﻚ ﺟﻤﻠﺔ‬
‫‪ End‬ﺟﻤﻠﺔ ﺗﻨﻔﻴﺬﻳﺔ ﺗﻌﻨﻲ ﺇﻧﻬﺎﺀ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻭﻟﻬﺬﺍ ﻓﻬﻲ ﺗﻮﺿﻊ ﻓﻲ ﺃﻱ ﻣﻜﺎﻥ ﻣﻦ ﺍﻟﺒﺮﻧﺎﻣﺞ(‪.‬‬
‫ﻭﻳﻤﻜﻦ ﺍﺧﺘﺼﺎﺭ ﺟﻤﻠﺔ ﺍﻹﻧﻬﺎﺀ ﺑﻜﻠﻤﺔ ‪ End‬ﻓﻘﻂ‬

‫ﻣﺜﺎﻝ‪:‬ﻣﺎ ﻫﻲ ﺍﻷﺧﻄﺎﺀ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﻗﻄﻌﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ؟‬

‫‪programprg#1‬‬
‫‪a = 10‬‬
‫‪end prg#1‬‬
‫|‪(D)6‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﺨﻄﺄ ﺍﻷﻭﻝ ﻫﻮ ﺧﻄﺄ ﺗﺴﻤﻴﺔ ﺣﻴﺚ ﺍﻻﺳﻢ ‪ prg#1‬ﻳﺤﺘﻮﻱ ﻋﻠﻰ ﺍﻟﺮﻣﺰ ‪ #‬ﺍﻟﻐﻴﺮ ﻣﺴﻤﻮﺡ ﺑﻪ‪،‬‬
‫ﻭﺍﻟﺨﻄﺄ ﺍﻟﺜﺎﻧﻲ ﻫﻮ ﻋﺪﻡ ﻛﺘﺎﺑﺔ ﻛﻠﻤﺔ ‪ program‬ﺑﻴﻦ ﻛﻠﻤﺔ ‪ end‬ﻭﺍﺳﻢ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﺟﻤﻠﺔ ﺍﻹﻧﻬﺎﺀ‪.‬‬

‫ﻳﺼﺤﺢ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺴﺎﺑﻖ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪program prg1‬‬
‫‪a = 10‬‬
‫‪end program prg1‬‬
‫ﺃﻭ ﺑﻌﺪ ﺣﺬﻑ ﺟﻤﻴﻊ ﺍﻷﺟﺰﺍﺀ ﺍﻟﺨﻴﺎﺭﻳﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪a = 10‬‬
‫‪end‬‬

‫‪Assignment‬‬ ‫ﺟﻤﻠﺔ ﺍﻟﺘﻌﻴﻴﻦ‬

‫ﺗﻜﺘﺐ ﺟﻤﻠﺔ ﺍﻟﺘﻌﻴﻴﻦ ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻣﺜﻞ ﺃﻛﺜﺮ ﺑﺎﻗﻲ ﺍﻟﻠﻐﺎﺕ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺍﻟﺘﻌﺒﻴﺮ = ﺍﺳﻢ ﺍﻟﻤﺘﻐﻴﺮ‬
‫ﻣﺜﻞ‪:‬‬
‫‪cost = 35 * 0.75‬‬

‫ﺟﻤﻞ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ‬

‫ﺗﻜﺘﺐ ﺟﻤﻠﺔ ﺍﻹﺧﺮﺍﺝ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫… ‪,‬ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﻟﺘﻌﺒﻴﺮ ﺍﻷﻭﻝ ‪print *,‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫"!‪print *, name, " is ", age, "years old‬‬
‫ﺍﻟﺘﻌﺒﻴﺮ ﺍﻷﻭﻝ ﻓﻲ ﻫﺬﻩ ﺍﻟﺠﻤﻠﺔ ﻫﻮ ﺍﻟﻤﺘﻐﻴﺮ ‪ name‬ﻭﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﺜﺎﻧﻲ ﻫﻮ ﺍﻟﻨﺺ " ‪ " is‬ﻭﺍﻟﺘﻌﺒﻴﺮ‬
‫ﺍﻟﺜﺎﻟﺚ ﻫﻮ ﺍﻟﻤﺘﻐﻴﺮ ‪ age‬ﻭﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﺮﺍﺑﻊ ﻫﻮ ﺍﻟﻨﺺ "!‪."years old‬‬

‫ﺃﻣﺎ ﺟﻤﻠﺔ ﺍﻹﺩﺧﺎﻝ ﻓﻬﻲ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫… ‪,‬ﺍﺳﻢ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﺳﻢ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻷﻭﻝ ‪read *,‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﺷﺮﺡ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ‬

‫" = ‪Print *, "A‬‬
‫‪Read *, A‬‬
‫" = ‪Print *, "B‬‬
‫‪Read *, B‬‬
‫‪Print *, "A*B = ", A*B‬‬
‫‪End‬‬

‫ﻋﻨﻬﺎ‪Variable Declaration‬‬ ‫ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﻭﺍﻹﻋﻼﻥ‬

‫ﺍﻟﻤﺘﻐﻴﺮ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻫﻮ ﻣﻜﺎﻥ ﻓﻲ ﺍﻟﺬﺍﻛﺮﺓ ﻳﺘﻢ ﺧﺰﻥ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻓﻴﻪ‪ ،‬ﻭﻳﺘﻢ ﺣﺠﺰ ﻫﺬﻩ ﺍﻟﺨﺎﻧﺎﺕ ﻓﻲ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﺑﺠﻤﻠﺔ ﺗﺴﻤﻰ ﺟﻤﻠﺔ ﺍﻹﻋﻼﻥ‪ ،‬ﺣﻴﺚ ﻳﺘﻢ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺟﻤﻠﺔ ﺍﻹﻋﻼﻥ ﻃﻠﺐ ﺣﺠﺰ ﻣﻜﺎﻥ ﻓﻲ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻭﺗﺨﺼﻴﺺ "ﻧﻮﻉ" ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺘﻲ ﺳﻮﻑ ﺗﺨﺰﻥ ﻓﻴﻪ ﻭﺗﺴﻤﻴﺔ ﺗﻠﻚ ﺍﻟﺨﺎﻧﺔ ﻓﻲ ﺍﻟﺬﺍﻛﺮﺓ‪.‬‬
‫ﻳﺴﺘﺤﺴﻦ ﺃﻥ ﻳﻌﻠﻦ ﺍﻟﻤﺒﺮﻣﺞ ﻋﻦ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﺍﻟﺘﻲ ﻳﺮﻳﺪ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻓﻲ ﺑﺪﺍﻳﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ‬
‫ﺻﺮﻳﺢ )‪ (explicit‬ﻭﻟﻜﻦ ﻓﻲ ﺣﺎﻟﺔ ﻋﺪﻡ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﻤﺘﻐﻴﺮﺍﺕ ﺑﺸﻜﻞ ﺻﺮﻳﺢ ﻓﺎﻥ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ‬
‫ﺳﻮﻑ ﻳﺘﺒﻊ ﻗﺎﻋﺪﺓ ﺿﻤﻨﻴﺔ )‪ (implicit‬ﻣﻔﺎﺩﻫﺎ ﺃﻥ ﺃﻱ ﻣﺘﻐﻴﺮ ﻳﺒﺪﺃ ﺃﺳﻤﻪ ﺑﺎﻷﺣﺮﻑ ‪i, j, k, l, m, n‬‬
‫|‪(D)7‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺳﻮﻑ ﻳﻜﻮﻥ ﻣﻦ ﻧﻮﻉ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻭﺃﻱ ﻣﺘﻐﻴﺮ ﺁﺧﺮ ﺳﻮﻑ ﻳﻜﻮﻥ ﻣﻦ ﻧﻮﻉ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ‪.‬‬
‫ﻳﻤﻜﻦ ﺇﻟﻐﺎﺀ ﺍﻹﻋﻼﻥ ﺍﻟﻀﻤﻨﻲ ﺑﻜﺘﺎﺑﺔ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺑﺪﺍﻳﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ‪:‬‬
‫‪implicitnone‬‬
‫ﻭﻫﺬﺍ ﻣﺎ ﻳﻘﻠﻞ ﻣﻦ ﺍﻷﺧﻄﺎﺀ ﺍﻟﻤﺤﺘﻠﻤﺔ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ )ﺍﻟﺼﺮﻳﺢ ﺃﻓﻀﻞ ﻣﻦ ﺍﻟﻀﻤﻨﻲ(‪.‬‬

‫ﺃﻧﻮﺍﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪Data Types‬‬

‫ﻫﻨﺎﻟﻚ ﺧﻤﺴﺔ ﺃﻧﻮﺍﻉ ﻣﻦ ﺍﻟﻤﻌﻄﻴﺎﺕ ﺍﻟﻤﺒﻨﻴّﺔ ﺃﻭ ﺍﻟﺬﺍﺗﻴﺔ )‪ (intrinsic‬ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻭﻫﻲ‪:‬‬
‫‪ -1‬ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺼﺤﻴﺤﺔ ‪: integer‬‬
‫ﻳﻤﻜﻦ ﺧﺰﻥ ﺑﻴﺎﻧﺎﺕ ﻋﺪﺩﻳﺔ ﺑﺪﻭﻥ ﺟﺰﺀ ﻋﺸﺮﻱ ﻣﺜﻞ "ﺍﻟﻘﻴﻢ"‪ 324‬ﺃﻭ ‪ -41‬ﺃﻭ ‪ 0‬ﻓﻲ ﻣﺘﻐﻴﺮ ﻣﻦ‬
‫ﻫﺬﺍ ﺍﻟﻨﻮﻉ‬

‫‪ -2‬ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺤﻘﻴﻘﻴﺔ ‪: real‬‬

‫ﻳﻤﻜﻦ ﺧﺰﻥ ﺑﻴﺎﻧﺎﺕ ﻣﺜﻞ "ﺍﻟﻘﻴﻢ"‪ 3.14‬ﺃﻭ ‪ 0.005‬ﺃﻭ ‪ 200e3‬ﻓﻲ ﻣﺘﻐﻴﺮ ﻣﻦ ﻫﺬﺍ ﺍﻟﻨﻮﻉ‬

‫‪ -3‬ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻤﺮﻛﺒﺔ ‪: complex‬‬

‫ﻳﻤﻜﻦ ﺧﺰﻥ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺘﻲ ﺗﺤﺘﻮﻱ ﻋﻠﻰ ﺟﺰﺀ ﺣﻘﻴﻘﻲ ﻭﺟﺰﺀ ﺗﺨﻴﻠﻲ ﻓﻲ ﻣﺘﻐﻴﺮ ﻣﻦ ﻫﺬﺍ ﺍﻟﻨﻮﻉ‬
‫ﻣﺜﻞ "ﺍﻟﻘﻴﻤﺔ"‪ 34+10i‬ﻭﺍﻟﺬﻱ ﻳﻜﺘﺐ ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﺸﻜﻞ )‪ (34, 10‬ﺃﻱ ﻳﻜﺘﺐ ﺍﻟﺠﺰﺀ ﺍﻟﺤﻘﻴﻘﻲ‬
‫ﺃﻭﻻً ﺛﻢ ﻓﺎﺭﺯﺓ ﺛﻢ ﺍﻟﺠﺰﺀ ﺍﻟﺘﺨﻴﻠﻲ ﺩﺍﺧﻞ ﺃﻗﻮﺍﺱ‬

‫‪ -4‬ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻤﻨﻄﻘﻴﺔ ‪logical‬‬

‫ﻳﻤﻜﻦ ﺧﺰﻥ ﺃﺣﺪ ﺍﻟﻘﻴﻤﺘﻴﻦ ﺻﺤﻴﺢ ﺃﻭ ﺧﻄﺄ ﻓﻲ ﻣﺘﻐﻴﺮ ﻣﻦ ﻫﺬﺍ ﺍﻟﻨﻮﻉ ﻭﺗﻜﺘﺐ ﻗﻴﻤﺔ ﺻﺤﻴﺢ ﻓﻲ‬
‫ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻛﻤﺎ ﻳﻠﻲ ‪ .TRUE.‬ﻭﻗﻴﻤﺔ ﺧﻄﺄ ﻛﻤﺎ ﻳﻠﻲ ‪) .FALSE.‬ﻻﺣﻆ ﺍﻟﻨﻘﺎﻁ ﻗﺒﻞ ﻭﺑﻌﺪ ﻛﻠﻤﺘﻲ ‪true‬‬
‫ﻭ ‪(false‬‬

‫‪ -5‬ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻨﺼﻴﺔ )ﺍﻟﺤﺮﻓﻴﺔ( ‪character‬‬

‫ﻳﻤﻜﻦ ﺧﺰﻥ ﺣﺮﻑ ﺃﻭ ﻋﺪﺓ ﺣﺮﻭﻑ ﻓﻲ ﺍﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻫﺬﺍ ﺍﻟﻨﻮﻉ ﻭﻳﺠﺐ ﺫﻛﺮ ﻋﺪﺩ ﺍﻟﺤﺮﻭﻑ ﺍﻟﺘﻲ‬
‫ﺗﺮﻳﺪ ﺃﻥ ﻳﺴﺘﻮﻋﺒﻬﺎ ﺍﻟﻤﺘﻐﻴﺮ ﻓﻲ ﺣﺎﻟﺔ ﺃﻛﺜﺮ ﻣﻦ ﺣﺮﻑ ﻭﺍﺣﺪ ﻛﻤﺎ ﻓﻲ ﺍﻟﻤﺜﺎﻝ ﺍﻟﺘﺎﻟﻲ‬

‫ﻭﺑﻨﺎﺀﺍً ﻋﻠﻰ ﻫﺬﺍ ﺳﺘﻜﻮﻥ ﺟﻤﻠﺔ ﺍﻹﻋﻼﻥ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫… ‪,‬ﺍﺳﻢ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﺳﻢ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻷﻭﻝ ‪ ::‬ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪integer :: count‬‬
‫‪logical :: done‬‬
‫‪character (len=30) :: name‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻓﻲ ﺣﺎﻟﺔ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻨﺼﻲ ﻳﺠﺐ ﺫﻛﺮ ﻋﺪﺩ ﺍﻟﺤﺮﻭﻑ ﺍﻟﺘﻲ ﻳﺴﺘﻮﻋﺒﻬﺎ ﺍﻟﻤﺘﻐﻴﺮ ﻭﻓﻲ ﺣﺎﻟﺔ‬
‫ﻋﺪﻡ ﺫﻛﺮ ﻃﻮﻝ ﺍﻟﻤﺘﻐﻴﺮ ﺳﻮﻑ ﻳﻜﻮﻥ ﺍﺳﺘﻴﻌﺎﺏ ﺍﻟﻤﺘﻐﻴﺮ ﺣﺮﻑ ﻭﺍﺣﺪ ﻓﻘﻂ‪.‬‬
‫ﺍﺳﻢ ﺍﻟﻤﺘﻐﻴﺮ ‪) ::‬ﻋﺪﺩ ﺍﻟﺤﺮﻭﻑ ﺍﻟﺘﻲ ﻳﺴﺘﻮﻋﺒﻬﺎ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻨﺼﻲ=‪character (len‬‬

‫ﻣﻼﺣﻈﺔ‪:‬ﻳﻤﻜﻦ ﺣﺬﻑ ﻛﻠﻤﺔ ‪ len‬ﻭﻋﻼﻣﺔ ﻳﺴﺎﻭﻱ ﺍﻟﺘﻲ ﺗﻠﻴﻬﺎ ﻭﻛﺘﺎﺑﺔ ﺍﻹﻋﻼﻥ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪character(30) :: name‬‬
‫|‪(D)8‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫‪Constants‬‬ ‫ﺍﻟﺜﻮﺍﺑﺖ‬
‫ﻟﻺﻋﻼﻥ ﻋﻦ ﺍﻟﺜﻮﺍﺑﺖ ﺗﺴﺘﺨﺪﻡ ﻓﻲ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻧﻔﺲ ﺟﻤﻠﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﻤﺘﻐﻴﺮ ﺑﺈﺿﺎﻓﺔ ﻛﻠﻤﺔ‬
‫‪ parameter‬ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺍﻟﻘﻴﻤﺔ = ﺍﺳﻢ ﺍﻟﺜﺎﺑﺖ ﺍﻷﻭﻝ ‪, parameter ::‬ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪real, parameter :: pi = 3.14‬‬
‫‪integer, parameter :: n = 20‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻻ ﻳﺨﺼﺺ ﻣﻜﺎﻥ ﻓﻲ ﺍﻟﺬﺍﻛﺮﺓ ﻟﺨﺰﻥ ﺍﻟﺜﺎﺑﺖ ﻭﺇﻧﻤﺎ ﻳﻌﻮﺽ ﻋﻦ ﺍﺳﻢ ﺍﻟﺜﺎﺑﺖ ﺑﻘﻴﻤﺘﻪ ﻓﻲ‬
‫ﻛﻞ ﻣﻜﺎﻥ ﻳُﺴﺘﺨﺪﻡ ﺍﻟﺜﺎﺑﺖ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﺠﺐ ﺃﻥ ﺗﻌﻄﻰ ﻗﻴﻤﺔ ﺍﻟﺜﺎﺑﺖ ﻓﻲ ﻧﻔﺲ ﺟﻤﻠﺔ ﺍﻹﻋﻼﻥ‪.‬‬

‫‪Expressions‬‬ ‫ﺍﻟﺘﻌﺎﺑﻴﺮ‬
‫ﺍﻟﺘﻌﺒﻴﺮ ﻫﻮ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﻘﻴﻢ )‪ (value‬ﻭﺍﻟﻤﺘﻐﻴﺮﺍﺕ )‪ (variable‬ﻭﺍﻟﻌﻮﺍﻣﻞ )‪(operator‬‬
‫ﻭﺍﻟﺪﻭﺍﻝ )‪ (function‬ﻭﺍﻟﻬﺪﻑ ﻣﻦ ﺍﻟﺘﻌﺒﻴﺮ ﺇﻳﺠﺎﺩ »ﻗﻴﻤﺔ« ﺟﺪﻳﺪﺓ‪.‬‬

‫‪Operators‬‬ ‫ﺍﻟﻌﻮﺍﻣﻞ‬
‫ﺇﻥ ﺃﺑﺴﻂ ﻋﻤﻠﻴﺎﺕ ﻣﻌﺎﻟﺠﺔ ﺗﺘﻢ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻫﻮ ﻣﺎ ﺗﻘﻮﻡ ﺑﻪ ﺍﻟﺤﺎﺳﺒﺔ ﺍﻟﻴﺪﻭﻳﺔ‬
‫ﻛﻌﻤﻠﻴﺔ ﺍﻟﺠﻤﻊ ﻭﺍﻟﻘﺴﻤﺔ ﻭﻏﻴﺮﻫﺎ‪ ،‬ﻭﺗﻨﻔﺬ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺮﻣﺠﺔ ﺑﻮﺍﺳﻄﺔ ﻣﺎ ﻳﺴﻤﻰ‬
‫ﺑﺎﻟﻌﻮﺍﻣﻞ ﻭﻫﻲ ﻋﻠﻰ ﺃﻧﻮﺍﻉ‪:‬‬

‫‪ -1‬ﺍﻟﻌﻮﺍﻣﻞ ﺍﻟﺤﺴﺎﺑﻴﺔ‪Arithmetic Operators‬‬

‫ﺗﺄﺧﺬ ﻫﺬﻩ ﺍﻟﻌﻮﺍﻣﻞ ﻗﻴﻤﺘﻴﻦ ﻣﻦ ﻧﻮﻉ )ﺻﺤﻴﺢ ﺃﻭ ﺣﻘﻴﻘﻲ ﺃﻭ ﻣﺮﻛﺐ( ﻭﺗﺮﺟﻊ ﺍﻟﻨﺎﺗﺞ ﺑﻌﺪ ﺗﻨﻔﻴﺬ‬
‫ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﻤﻄﻠﻮﺑﺔ ﻭﺗﻜﻮﻥ ﺍﻟﻌﻤﻠﻴﺔ ﻫﻲ ‪ +‬ﻟﻠﺠﻤﻊ ﻭ – ﻟﻠﻄﺮﺡ ﻭ ‪ /‬ﻟﻠﻘﺴﻤﺔ ﻭ * ﻟﻠﻀﺮﺏ ﻭ ** ﻟﻠﺮﻓﻊ‬
‫ﻟﻘﻮﺓ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪23 * 10.4 → 239.2‬‬
‫‪3.14 ** 2.718 → 22.420990‬‬
‫‪3 * 6 → 18‬‬
‫‪3.0 * 6 → 18.0‬‬
‫‪3/4→0‬‬
‫‪3.0 / 4 → 0.75‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻋﻤﻠﻴﺔ ﺍﻟﻘﺴﻤﺔ ﻓﻲ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺇﺫﺍ ﻧﻔﺬﺕ ﻋﻠﻰ ﻗﻴﻢ ﺻﺤﻴﺤﺔ ﺳﻮﻑ ﺗﻜﻮﻥ ﻗﺴﻤﺔ‬
‫ﺻﺤﻴﺤﺔ )ﺍﻟﻨﺎﺗﺞ ﺑﺪﻭﻥ ﺟﺰﺀ ﻋﺸﺮﻱ( ﻭﻻ ﺗﻮﺟﺪ ﻋﻤﻠﻴﺔ ﻗﺴﻤﺔ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﺧﺎﺻﺔ ﻛﻤﺎ ﻓﻲ‬
‫ﺍﻟﺒﻴﺴﻚ‪.‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻓﻲ ﺗﻨﻔﻴﺬ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺇﺫﺍ ﻛﺎﻥ ﺃﺣﺪ ﺍﻟﻘﻴﻢ ﺻﺤﻴﺤﺔ ﻭﺍﻟﻘﻴﻤﺔ ﺍﻷﺧﺮﻯ ﺣﻘﻴﻘﻴﺔ ﻓﺴﻮﻑ ﺗﺒﺪﻝ‬
‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﺼﺤﻴﺤﺔ ﺇﻟﻰ ﻗﻴﻤﺔ ﺣﻘﻴﻘﻴﺔ ﻭﻣﻦ ﺛﻢ ﺗﻨﻔﺬ ﺍﻟﻌﻤﻠﻴﺔ ﻭﻳﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﻗﻴﻤﺔ ﺣﻘﻴﻘﻴﺔ ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﺃﺣﺪ‬
‫ﺍﻟﻘﻴﻢ ﺣﻘﻴﻘﻴﺔ ﻭﺍﻟﻘﻴﻤﺔ ﺍﻷﺧﺮﻯ ﻣﺮﻛﺒﺔ ﻓﺴﻮﻑ ﻳﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﻗﻴﻤﺔ ﻣﺮﻛﺒﺔ ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﺃﺣﺪ ﺍﻟﻘﻴﻢ ﺻﺤﻴﺤﺔ‬
‫ﻭﺍﻟﻘﻴﻤﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﺮﻛﺒﺔ ﻓﺴﻮﻑ ﻳﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﻗﻴﻤﺔ ﻣﺮﻛﺒﺔ ﺃﻳﻀﺎً )ﺍﻟﻘﺎﻧﻮﻥ‪ :‬ﺗﺒﺪﻝ ﺍﻟﻘﻴﻢ ﻟﻠﻨﻮﻉ ﺍﻟﺬﻱ‬
‫ﻳﺴﺘﻮﻋﺐ ﺍﻟﻘﻴﻤﺘﻴﻦ(‪.‬‬

‫‪ -2‬ﻋﻮﺍﻣﻞ ﺍﻟﻤﻘﺎﺭﻧﺔ ‪Relational Operators‬‬

‫ﻳﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻋﻤﻠﻴﺎﺕ ﺍﻟﻤﻘﺎﺭﻧﺔ ﻟﻠﻤﻘﺎﺭﻧﺔ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ ﻣﻦ ﺍﻟﻨﻮﻉ "ﺍﻟﻌﺪﺩﻱ" ﺃﻭ ﻗﻴﻤﺘﻴﻦ ﻣﻦ ﺍﻟﻨﻮﻉ‬
‫|‪(D)9‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫"ﺍﻟﻨﺼﻲ" ﻭﻳﻜﻮﻥ ﻧﺎﺗﺞ ﻋﻤﻠﻴﺔ ﺍﻟﻤﻘﺎﺭﻧﺔ ﻗﻴﻤﺔ "ﻣﻨﻄﻘﻴﺔ"‪ ،‬ﻭﺗﻜﺘﺐ ﻋﻤﻠﻴﺎﺕ ﺍﻟﻤﻘﺎﺭﻧﺔ ﺑﻄﺮﻳﻘﺘﻴﻦ ﺍﻟﻄﺮﻳﻘﺔ‬
‫ﺍﻟﻘﺪﻳﻤﺔ ﻭﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﺤﺪﻳﺜﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﺤﺪﻳﺜﺔ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﻘﺪﻳﻤﺔ‬ ‫ﺍﻟﺸﺮﺡ‬

‫‪.EQ.‬‬ ‫==‬ ‫ﻳﺴﺎﻭﻱ؟‪equal to‬‬
‫‪.NE.‬‬ ‫=‪/‬‬ ‫ﻻ ﻳﺴﺎﻭﻱ؟‪not equal to‬‬
‫‪.LT.‬‬ ‫<‬ ‫ﺃﺻﻐﺮ ﻣﻦ؟‪less than‬‬
‫‪.LE.‬‬ ‫=<‬ ‫ﺃﺻﻐﺮ ﺃﻭ ﻳﺴﺎﻭﻱ؟ ‪less than or equal to‬‬
‫‪.GT.‬‬ ‫>‬ ‫ﺃﻛﺒﺮ ﻣﻦ؟ ‪greater than‬‬
‫‪.GE.‬‬ ‫=>‬ ‫ﺃﻛﺒﺮ ﺃﻭ ﻳﺴﺎﻭﻱ؟ ‪greater than or equal to‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻣﻘﺎﺭﻧﺔ ﺍﻟﻤﺴﺎﻭﺍﺓ ﺗﺴﺘﺨﺪﻡ ﺍﻟﺮﻣﺰ = ﻣﺮﺗﻴﻦ‪.‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪3 > 5 → .FALSE.‬‬
‫‪5 >= 5 → .TRUE.‬‬
‫‪"elephant" < "mouse" → .TRUE.‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺗﺘﻢ ﻋﻤﻠﻴﺔ ﻣﻘﺎﺭﻧﺔ ﺍﻟﻘﻴﻢ ﺍﻟﻨﺼﻴﺔ ﺑﻤﻘﺎﺭﻧﺔ ﺗﺮﺗﻴﺒﻬﺎ ﺍﻟﻬﺠﺎﺋﻲ‪.‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻣﻘﺎﺭﻧﺔ ﺍﻟﻤﺴﺎﻭﺍﺓ ﺃﻭ ﻋﺪﻡ ﺍﻟﻤﺴﺎﻭﺍﺓ ﺑﻴﻦ ﺍﻷﺭﻗﺎﻡ ﺍﻟﺤﻘﻴﻘﻴﺔ ﺗﺨﻀﻊ ﻟﺪﻗﺔ ﺍﻟﺤﺎﺳﻮﺏ ﻭﻗﺪ‬
‫ﺗﺆﺩﻱ ﺇﻟﻰ ﻧﺘﻴﺠﺔ ﺧﺎﻃﺌﺔ ﻓﻤﺜﻼً ﻗﺪ ﺗﻜﻮﻥ ﻧﺘﻴﺠﺔ ﺍﻟﺘﻌﺒﻴﺮ ‪ 3.0 == 3.000001‬ﺍﻟﻘﻴﻤﺔ ‪ .TRUE.‬ﻭﻫﻲ‬
‫ﻧﺘﻴﺠﺔ ﻏﻴﺮ ﺻﺤﻴﺤﺔ‪ ،‬ﻟﺬﻟﻚ ﻳﻔﻀﻞ ﻓﻲ ﻣﺜﻞ ﻫﺬﻩ ﺍﻟﺤﺎﻟﺔ ﺍﺳﺘﺨﺪﺍﻡ ﻃﺮﻳﻘﺔ ﻣﺜﻞ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫ﻋﺪﺩ ﺻﻐﻴﺮ< )ﺍﻟﻘﻴﻤﺔ ﺍﻟﺜﺎﻧﻴﺔ – ﺍﻟﻘﻴﻤﺔ ﺍﻷﻭﻟﻰ(‪abs‬‬

‫ﻣﺜﻞ‪ :‬ﻟﻤﻘﺎﺭﻧﺔ ﺍﻟﻤﺘﻐﻴﺮ ‪ x‬ﻣﻊ ﺍﻟﻌﺪﺩ ‪ 3.0‬ﻣﻦ ﺍﻷﻓﻀﻞ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫‪abs(x - 3.0) < 0.000001‬‬

‫‪ -3‬ﺍﻟﻌﻮﺍﻣﻞ ﺍﻟﻤﻨﻄﻘﻴﺔ ‪Logical Operators‬‬

‫ﺗﺄﺧﺬ ﻫﺬﻩ ﺍﻟﻌﻮﺍﻣﻞ ﻗﻴﻤﺘﻴﻦ ﻣﻨﻄﻘﻴﺘﻴﻦ ﻭﻳﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﺃﻳﻀﺎ ﻗﻴﻤﺔ ﻣﻨﻄﻘﻴﺔ ﻭﻫﻲ ‪ .not.‬ﻭ ‪ .and.‬ﻭ‬
‫‪ .or.‬ﻭ ‪ .eqv.‬ﻭ ‪ .neqv.‬ﻭﺗﻜﻮﻥ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻓﻲ ﺍﻟﺠﺪﻭﻝ ﺍﻟﺘﺎﻟﻲ‪:‬‬

‫‪.NOT.‬‬ ‫‪X .AND.‬‬ ‫‪X .OR.‬‬ ‫‪X .EQV.‬‬ ‫‪X .NEQV.‬‬

‫‪X‬‬ ‫‪Y‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪Y‬‬ ‫‪Y‬‬ ‫‪Y‬‬
‫‪.TRU‬‬ ‫‪.TRU‬‬ ‫‪.FALSE‬‬
‫‪.TRUE.‬‬ ‫‪.TRUE.‬‬ ‫‪.TRUE.‬‬ ‫‪.FALSE.‬‬
‫‪E.‬‬ ‫‪E.‬‬ ‫‪.‬‬
‫‪.TRU‬‬ ‫‪.FALS‬‬ ‫‪.FALSE‬‬
‫‪.FALSE.‬‬ ‫‪.TRUE.‬‬ ‫‪.FALSE.‬‬ ‫‪.TRUE.‬‬
‫‪E.‬‬ ‫‪E.‬‬ ‫‪.‬‬
‫‪.FALS‬‬ ‫‪.TRU‬‬
‫‪.TRUE.‬‬ ‫‪.FALSE.‬‬ ‫‪.TRUE.‬‬ ‫‪.TRUE.‬‬ ‫‪.FALSE.‬‬
‫‪E.‬‬ ‫‪E.‬‬
‫‪.FALS‬‬ ‫‪.FALS‬‬ ‫‪.FALSE‬‬
‫‪.TRUE.‬‬ ‫‪.FALSE.‬‬ ‫‪.FALSE.‬‬ ‫‪.TRUE.‬‬
‫‪E.‬‬ ‫‪E.‬‬ ‫‪.‬‬

‫‪ -4‬ﻋﺎﻣﻞ ﺍﻹﻟﺤﺎﻕ ‪Concatenation Operator‬‬

‫ﻳﺴﺘﺨﺪﻡ ﻫﺬﺍ ﺍﻟﻌﺎﻣﻞ ﻹﻟﺤﺎﻕ ﻗﻴﻤﺘﻴﻦ ﻧﺼﻴﺘﻴﻦ ﻭﺇﻳﺠﺎﺩ ﻧﺺ ﻭﺍﺣﺪ ﻣﻨﻬﻤﺎ ﻭﻳﺮﻣﺰ ﻟﻪ ﺑـ )‪.(//‬‬
‫|‪(D)10‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫"‪"Sir Isac" // "Newton" → "Sir IsacNewton‬‬

‫ﻣﻼﺣﻈﺔ‪:‬ﻻ ﺗﻀﻴﻒ ﻋﻤﻠﻴﺔ ﺍﻹﻟﺤﺎﻕ ﻓﻮﺍﺻﻞ ﺑﻴﻦ ﺍﻟﻨﺼﻴﻦ‪.‬‬

‫‪ -5‬ﺍﻷﺳﺒﻘﻴﺔ ﺃﻭ ﺍﻷﻭﻟﻮﻳﺔ ‪priority‬‬

‫ﻓﻲ ﺣﺎﻟﺔ ﻭﺟﻮﺩ ﺃﻛﺜﺮ ﻣﻦ ﻋﺎﻣﻞ ﻓﻲ ﺗﻌﺒﻴﺮ ﻭﺍﺣﺪ ﻣﺜﻞ ‪ 8 + 7 / 2‬ﻓﺴﻮﻑ ﻳﻨﻔﺬ ﺍﻟﻌﺎﻣﻞ ﺫﻭ‬
‫ﺍﻷﺳﺒﻘﻴﺔ ﺍﻷﻋﻠﻰ‪ ،‬ﻭﻓﻲ ﺣﺎﻟﺔ ﻭﺟﻮﺩ ﻋﺎﻣﻠﻴﻦ ﺑﻨﻔﺲ ﺍﻷﺳﺒﻘﻴﺔ ﻓﺴﻮﻑ ﺗﻨﻔﺬ ﺍﻟﻌﻮﺍﻣﻞ ﺣﺴﺐ ﻗﺎﻋﺪﺓ‬
‫ﺍﻹﺗﺤﺎﺩ ﺃﻭ ﺍﻻﺷﺘﺮﺍﻙ )‪ (Associativity‬ﻭﻳﻤﻜﻦ ﺗﻠﺨﻴﺺ ﺃﺳﺒﻘﻴﺔ ﺍﻟﻌﻮﺍﻣﻞ ﻭﺍﺗﺤﺎﺩﻫﺎ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪Type‬‬ ‫‪Operator‬‬ ‫‪Associativity‬‬

‫**‬ ‫‪right to left‬‬
‫‪Arithmetic‬‬ ‫*‬ ‫‪/‬‬ ‫‪left to right‬‬
‫‪+‬‬ ‫‪-‬‬ ‫‪left to right‬‬
‫‪Character‬‬ ‫‪//‬‬ ‫‪lefttoright‬‬
‫<‬ ‫=<‬ ‫>‬ ‫=>‬ ‫==‬ ‫=‪/‬‬
‫‪Relational‬‬ ‫‪.L‬‬ ‫‪.L‬‬ ‫‪.G .G‬‬ ‫‪.E‬‬ ‫‪.N‬‬ ‫‪None‬‬
‫‪T.‬‬ ‫‪E.‬‬ ‫‪T.‬‬ ‫‪E.‬‬ ‫‪Q.‬‬ ‫‪E.‬‬
‫‪.NOT.‬‬ ‫‪right to left‬‬
‫‪.AND.‬‬ ‫‪left to right‬‬
‫‪Logical‬‬
‫‪.OR.‬‬ ‫‪left to right‬‬
‫‪.EQV.‬‬ ‫‪.NEQV.‬‬ ‫‪left to right‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺍﻷﺟﺰﺍﺀ ﺩﺍﺧﻞ ﺍﻷﻗﻮﺍﺱ ﺗﻨﻔﺬ ﻗﺒﻞ ﺃﻱ ﺷﻲﺀ ﺁﺧﺮ‪ ،‬ﺃﻱ ﻳﻤﻜﻦ ﺍﻟﻘﻮﻝ ﺃﻥ ﺍﻷﻗﻮﺍﺱ ﺗﺘﻤﺘﻊ‬
‫ﺑﺄﻋﻠﻰ ﺃﺳﺒﻘﻴﺔ‪.‬‬

‫ﺃﻣﺜﻠﺔ‪:‬‬
‫‪3/4→0‬‬
‫‪13/4→3‬‬
‫‪13/4.0→3.25‬‬
‫ﻧﻮﻉ ﺍﻟﻨﺎﺗﺞ ﻳﺘﺒﻊ ﻧﻮﻉ ﺍﻟﻤﻌﺎﻣﻠﻴﻦ )‪(operands‬‬

‫‪-3**2.0 → -9.0‬‬
‫‪-5**2 → -25‬‬
‫ﻷﻥ ﺃﺳﺒﻘﻴﺔ ﺍﻟﺮﻓﻊ ﻟﻘﻮﺓ ﺃﻋﻠﻰ ﻣﻦ ﺍﻟﺴﺎﻟﺐ )ﻻﺣﻆ ﻓﻲ ﺍﻟﺤﺎﻟﺔ ﺍﻷﻭﻟﻰ ﺍﻟﻨﺎﺗﺞ ﺣﻘﻴﻘﻲ ﻭﻓﻲ ﺍﻟﺤﺎﻟﺔ‬
‫ﺍﻟﺜﺎﻧﻴﺔ ﺍﻟﻨﺎﺗﺞ ﺻﺤﻴﺢ(‬

‫‪4**3**2.0 → 4.0**(3.0**2.0) → 262144.0‬‬

‫ﻷﻥ ﺍﺗﺤﺎﺩ ﻋﻤﻠﻴﺔ ﺍﻷﺱ ﻣﻦ ﺍﻟﻴﻤﻦ ﺇﻟﻰ ﺍﻟﻴﺴﺎﺭ‬

‫‪4.0**(1/2) → 4.0**0 → 1.0‬‬

‫ﻷﻥ ﺩﺍﺧﻞ ﺍﻷﻗﻮﺍﺱ ﻳﻨﻔﺬ ﺃﻭﻻً‬

‫‪5-5/3*3→2‬‬
(D)11| Fortran 90 ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ‬

(‫ﻭﻫﺬﻩ ﻃﺮﻳﻘﺔ ﻟﻠﺤﺼﻮﻝ ﻋﻠﻰ ﺑﺎﻗﻲ ﺍﻟﻘﺴﻤﺔ )ﻛﻴﻒ؟‬

.not. .true. .and. .false. → (.not. .true.) .and. .false. -> .false.
5 > 10 .or. .not. 5 < 3 → (5 > 10) .or. (.not. (5 < 3)) → .false. .or. (.not.
.false.) → .true.

‫ ﻳﻔﻀﻞ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻷﻗﻮﺍﺱ ﻓﻲ ﻛﺘﺎﺑﺔ ﺍﻟﺘﻌﺎﺑﻴﺮ ﺍﻟﻄﻮﻳﻠﺔ ﻭﺫﻟﻚ ﻟﺰﻳﺎﺩﺓ ﻭﺿﻮﺡ ﺍﻟﺒﺮﻧﺎﻣﺞ‬:‫ﻣﻼﺣﻈﺔ‬
.‫ﻭﺗﺠﻨﺐ ﺍﻷﺧﻄﺎﺀ‬

Some useful intrinsic functions ‫ﺩﻭﺍﻝ ﺫﺍﺗﻴﺔ ﻣﻔﻴﺪﺓ‬

‫ ﺇﻟﻴﻚ ﻗﺎﺋﻤﺔ ﺑﺒﻌﺾ‬،‫ﻫﻨﺎﻟﻚ ﺑﻌﺾ ﺍﻟﺪﻭﺍﻝ ﺍﻟﻤﻔﻴﺪﺓ ﺍﻟﻤﺒﻨﻴّﺔ ﺑﺸﻜﻞ ﺫﺍﺗﻲ ﻛﺠﺰﺀ ﻣﻦ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ‬
:‫ﻫﺬﻩ ﺍﻟﺪﻭﺍﻝ‬

ABS absolute value of integer, real or complex X ABS(X)

ACOS arc cosine (inverse cosine) of X ACOS(X)
ASIN arc sine of X ASIN(X)
ATAN arc tangent of X in the range -p/2 to p/2 ATAN(X)
ATAN2 arc tangent of y/x in the range -p to p ATAN2(Y, X)
COS cosine of real or complex X COS(X)
COSH hyperbolic cosine of X COSH(X)
COT cotangent of X COT(X)
EXP value of the exponential function ex, where X EXP(X)
may be real or complex
INT converts integer, real or complex X to integer INT(X [,KIND])
type truncating toward zero, e.g. INT(3.9) returns 3,
INT(-3.9) returns -3. If the optional argument KIND is
present, it specifies the value of the kind parameter
of the result. Otherwise the result has default integer
kind
LOG natural logarithm of real or complex X. Note that LOG(X)
an integer argument will cause an error
LOG10 base 10 logarithm of X LOG10(X)
MAX maximum of two or more integer or real MAX(X1, X2[, X3, ...])
arguments
MIN minimum of two or more integer or real MIN(X1, X2[, X3, ...])
arguments
MOD remainder when K is divided by L. Arguments MOD(K, L)
must be both integer or both real
NINT nearest integer to X, e.g. NINT(3.9) returns 4, NINT(X [,KIND])
while NINT(-3.9) returns -4
REAL function converts integer, real or complex X to REAL(X [,KIND])
real type, e.g. REAL(2)/4 returns 0.5, whereas
REAL(2/4) returns 0.0
SIN sine of real or complex X SIN(X)
SINH hyperbolic sine of X SINH(X)
SQRT square root of real or complex X SQRT(X)
TAN tangent of X TAN(X)
TANH hyperbolic tangent of X TANH(X)
‫|‪(D)12‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻣﻼﺣﻈﺔ‪:‬ﺍﻟﻌﻮﺍﻣﻞ ﺩﺍﺧﻞ ﺍﻟﻤﻌﻘﻮﻓﺘﻴﻦ ﺧﻴﺎﺭﻳﺔ‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﻳﻘﻮﻡ ﺑﺤﺴﺎﺏ ﺟﺬﺭ ﺍﻟﻌﺪﺩ ﺍﻟﻤﺪﺧﻞ ﺑﺪﻗﺔ ﻗﻠﻴﻠﺔ ‪،‬ﺗﺎﺑﻊ ﺗﻨﻔﻴﺬ ﻫﺬﺍ ﺍﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻳﺪﻭﻳﺎ‪.‬‬
‫‪real :: x, y‬‬
‫‪read *, x‬‬
‫‪y=x‬‬
‫)‪y = 0.5 * (y +2 / y‬‬
‫)‪y = 0.5 * (y +2 / y‬‬
‫)‪y = 0.5 * (y +2 / y‬‬
‫‪print *, “the square root of ”, x, “ is approximately ”, y‬‬
‫‪end‬‬

‫ﺣﻜﻢ‪Control Constructs‬‬ ‫ﺗﺮﻛﻴﺐ‬

‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺗﻨﻔﺬ ﺍﻻﻭﺍﻣﺮ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻴﻪ ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ )‪ (sequential‬ﺃﻱ ﺃﻥ ﺍﻟﺤﺎﺳﻮﺏ‬
‫ﻳﻨﻔﺬ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻨﻔﻴﺬﻳﺔ ﺍﻷﻭﻟﻰ )ﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ(‬
‫ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﺬﻫﺐ ﺇﻟﻰ ﺍﻟﺠﻤﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻭﺑﻌﺪ ﺗﻨﻔﻴﺬﻫﺎ ﻳﺴﺘﻤﺮ ﺍﻟﺘﻨﻔﻴﺬ ﺣﺘﻰ ﺍﻟﻮﺻﻮﻝ ﺇﻟﻰ ﺃﺧﺮ ﺟﻤﻠﻪ‬
‫ﻓﻲ ﺍﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﻭﻟﻜﻦ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﺍﻟﺒﺴﻴﻂ ﻻﻳﻜﻔﻲ ﻟﻜﺘﺎﺑﺔ ﻃﺮﻕ ﺣﻞ ﻟﻜﺜﻴﺮ ﻣﻦ ﺍﻟﻤﺴﺎﺋﻞ ﺍﻟﺤﻘﻴﻘﻴﺔ‪،‬ﺣﻴﺚ ﻭﻛﻤﺎ ﺗﻌﻠﻢ‬
‫ﻓﺈﻧﻨﺎ ﻧﺴﺘﺨﺪﻡ ﻓﻴﺤﻞ ﺍﻟﻤﺸﺎﻛﻞ )ﺍﻟﻤﺴﺎﺋﻞ( ﺍﻟﻜﺜﻴﺮ ﻣﻦ ﻋﻤﻠﻴﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ ﻭﺍﻟﻔﺤﺺ ﻣﻦ ﺃﺟﻞ ﺍﻟﻮﺻﻮﻝ‬
‫ﺇﻟﻰ ﺍﻟﻨﺘﺎﺋﺞ ﺍﻟﻤﻄﻠﻮﺑﺔ‪ .‬ﻣﺜﻼ ﻟﺘﺤﻀﻴﺮ ﻛﻮﺏ ﻗﻬﻮﺓ ﻳﺠﺐ ﺃﻥ ﺗﻀﻊ ﺍﻟﻤﺎﺀ ﻓﻲ ﺇﻧﺎﺀ ﻭﺗﻀﻊ ﻋﻠﻰ ﻧﺎﺭﺣﺘﻰ‬
‫ﻳﻐﻠﻲ ﺍﻟﻤﺎﺀ )ﺩﺭﺟﺔ ﺣﺮﺍﺭﺓ ﺍﻟﻤﺎﺀ ﺗﺴﺎﻭﻱ ‪ 100‬ﺩﺭﺟﺔ ﻣﺌﻮﻳﺔ( ﺛﻢ ﺗﻀﻴﻒ ﺍﻟﻘﻬﻮﺓ ﺑﺎﻟﻤﻘﺪﺍﺭ ﺍﻟﻜﺎﻓﻲ‬
‫)ﺗﻜﺮﺭ ﺇﺿﺎﻓﺔ ﻣﻠﻌﻘﺔ ﻣﻦ ﺍﻟﻘﻬﻮﺓ ﻋﺪﺓ ﻣﺮﺍﺕ( ﻭ‪...‬‬

‫‪if‬‬ ‫‪ -1‬ﺗﺮﻛﻴﺒﺔ ﺍﻻﻧﺘﻘﺎﺀ ﺍﻟﺸﺮﻃﻴﺔ‬

‫ﺇﻥ ﺃﺑﺴﻂ ﺗﺮﻛﻴﺒﺔ ﺗﺤﻜﻢ ﻫﻲ ﺗﺮﻛﻴﺒﺔ ‪ if‬ﻭﺗﻜﺘﺐ ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﺄﺣﺪ ﺍﻟﻄﺮﻕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﺃﻭﻻ‪:‬‬
‫‪) then‬ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ( ‪if‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ[‬
‫‪End if‬‬
‫ﻋﻨﺪ ﻭﺻﻮﻝ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺳﻮﻑ ﻳﺤﺼﻞ ﺍﻟﺤﺎﺳﻮﺏ ﻋﻠﻰ ﻧﺎﺗﺞ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ ﻭﺇﺫﺍ‬
‫ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .true.‬ﻓﺈﻧﻪ ﺳﻮﻑ ﻳﻨﻔﺬ ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺩﺍﺧﻞ ﺍﻟﺘﺮﻛﻴﺒﺔ )ﺍﻟﺒﻠﻮﻙ( ﺟﻤﻠﺔ ﺑﻌﺪ‬
‫ﺍﻷﺧﺮﻯ ﻭﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،end if‬ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .false.‬ﻓﺈﻧﻪ ﻳﻨﺘﻘﻞ ﺑﺎﻟﺘﻨﻔﻴﺬ‬
‫ﺇﻟﻰ ﺃﻭﻝ ﺟﻤﻠﺔ ﺑﻌﺪ ﻛﻠﻤﺔ ‪.end if‬‬

‫ﺛﺎﻧﻴﺎً‪:‬‬
‫‪) then‬ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ( ‪if‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ ﺭﻗﻢ ‪[1‬‬
‫‪else‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ ﺭﻗﻢ ‪[2‬‬
‫‪endif‬‬
‫ﻋﻨﺪ ﻭﺻﻮﻝ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺳﻮﻑ ﻳﺤﺼﻞ ﺍﻟﺤﺎﺳﻮﺏ ﻋﻠﻰ ﻧﺎﺗﺞ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ‬
‫)ﻭﻫﻮ ﺍﻟﺸﺮﻁ( ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .true.‬ﻓﺈﻧﻪ ﺳﻮﻑ ﻳﻨﻔﺬ ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺭﻗﻢ ‪ 1‬ﺟﻤﻠﺔ ﺑﻌﺪ‬
‫ﺍﻷﺧﺮﻯ ﻭﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،end if‬ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .false.‬ﻓﺈﻧﻪ ﺳﻮﻑ ﻳﻨﻔﺬ‬
‫|‪(D)13‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺭﻗﻢ ‪ 2‬ﻭﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺑﻌﺪ ﻛﻠﻤﺔ ‪.end if‬‬

‫ﺛﺎﻟﺜﺎً‪:‬‬
‫‪) then‬ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ ﺃﻭﻝ( ‪if‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ[‬
‫‪) then‬ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ ﺛﺎﻧﻲ( ‪Else if‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ[‬
‫‪) then‬ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ ﺛﺎﻟﺚ( ‪Else if‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ[‬
‫‪...‬‬
‫‪else‬‬
‫ﺟﻤﻠﻪ ﺗﻨﻔﻴﺬﻳﺔ ﻓﻲ ﺣﺎﻝ ﻋﺪﻡ ﺗﻮﻓﺮ ﺍﻟﺸﺮﻭﻁ[‬
‫‪End if‬‬
‫ﻋﻨﺪ ﻭﺻﻮﻝ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺳﻮﻑ ﻳﺤﺼﻞ ﺍﻟﺤﺎﺳﻮﺏ ﻋﻠﻰ ﻧﺎﺗﺞ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ‬
‫"ﺍﻷﻭﻝ" ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .true.‬ﻓﺈﻧﻪ ﺳﻮﻑ ﻳﻨﻔﺬ ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺭﻗﻢ ‪ 1‬ﺟﻤﻠﺔ ﺑﻌﺪ ﺍﻷﺧﺮﻯ‬
‫ﻭﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،end if‬ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .false.‬ﻓﺈﻧﻪ ﻳﺤﺼﻞ ﻋﻠﻰ ﻧﺎﺗﺞ ﺍﻟﺘﻌﺒﻴﺮ‬
‫ﺍﻟﻤﻨﻄﻘﻲ "ﺍﻟﺜﺎﻧﻲ" ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .true.‬ﻓﺈﻧﻪ ﺳﻮﻑ ﻳﻨﻔﺬ ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺭﻗﻢ ‪ 2‬ﺟﻤﻠﺔ ﺑﻌﺪ‬
‫ﺍﻷﺧﺮﻯ ﻭﻣﻦ ﺛﻢ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،end if‬ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻨﺎﺗﺞ ‪ .false.‬ﻳﺤﺼﻞ ﻋﻠﻰ ﻧﺎﺗﺞ‬
‫ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ "ﺍﻟﺜﺎﻟﺚ" ‪ ...‬ﻭﻓﻲ ﺣﺎﻟﺔ ﻓﺸﻞ ﺟﻤﻴﻊ ﺍﻟﺸﺮﻭﻁ )ﻗﻴﻤﺔ ﺟﻤﻴﻊ ﺍﻟﺘﻌﺎﺑﻴﺮ ﺍﻟﻤﻨﻄﻘﻴﺔ‬
‫‪ (.false.‬ﺳﻮﻑ ﺗﻨﻔﺬ ﺃﺧﻴﺮ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺠﻤﻞ‪.‬‬

‫ﺭﺍﺑﻌﺎً‪ :‬ﻓﻲ ﺑﻌﺾ ﺍﻟﺤﺎﻻﺕ ﺍﻟﻤﻄﻠﻮﺏ ﻫﻮ ﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ ﻭﺍﺣﺪﺓ ﻓﻲ ﺣﺎﻝ ﺻﺤﺔ ﺷﺮﻁ ﻣﻌﻴﻦ ﻭﺗﻜﺘﺐ‬
‫ﺗﺮﻛﻴﺒﺔ ‪ if‬ﻓﻲ ﻫﺬﻩ ﺍﻟﺤﺎﻻﺕ ﺑﺸﻜﻞ ﻣﺒﺴﻂ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺟﻤﻠﺔ ﻭﺍﺣﺪﺓ )ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ( ‪if‬‬
‫ﻻﺣﻆ ﺃﻥ ﻛﻠﻤﺔ ‪then‬ﺗﺤﺬﻑ ﺃﻳﻀﺎً )ﺧﻼﻓﺎً ﻟﻠﻐﺔ ﺍﻟﺒﻴﺴﻚ(‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻣﺎ ﻫﻮ ﻋﻤﻞ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﻟﻲ‪:‬‬

‫‪if (x<0) x = -x‬‬
‫ﻳﻤﻜﻨﻚ ﺃﻥ ﺗﻘﺮﺃ ﻫﺬﺍ ﺍﻟﺴﻄﺮ ﻛﻤﺎ ﻳﻠﻲ‪ :‬ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﻌﺪﺩ ‪ x‬ﺳﺎﻟﺐ ﻓﺎﺟﻌﻠﻪ ﻳﺴﺎﻭﻱ ‪ –x‬ﺃﻱ ﺍﺿﺮﺑﻪ ﻓﻲ‬
‫ﺳﺎﻟﺐ ﻭﺍﺣﺪ ﻭﻫﺬﺍ ﻫﻮ ﻣﻌﻨﻰ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻄﻠﻘﺔ ﺇﺫﺍ ﺍﻟﺠﻮﺍﺏ ﻫﻮ ﺃﻥ ﻫﺬﺍ ﺍﻟﺴﻄﺮ ﻳﻨﻔﺬ ﻋﻤﻠﻴﺔ ﺣﺴﺎﺏ‬
‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻄﻠﻘﺔ ﻋﻠﻰ ﺍﻟﻤﺘﻐﻴﺮ ‪ x‬ﻭﻳﻤﻜﻦ ﺍﺳﺘﺒﺪﺍﻟﻪ ﺑﺎﻟﺴﻄﺮ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫)‪x = abs(x‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻳﺒﺪﻝ ﺩﺭﺟﺔ ﺍﻟﻄﺎﻟﺐ ﺇﻟﻰ ﺗﻘﺪﻳﺮ ﻋﻠﻤﺎً ﺑﺄﻥ ﺍﻟﺪﺭﺟﺔ ﻣﻦ ‪ 90‬ﺇﻟﻰ ‪ 100‬ﺗﻘﺪﺭ‬
‫ﺑـ ‪ A‬ﻭﻣﻦ ‪ 80‬ﺇﻟﻰ ‪ 89‬ﺗﻘﺪﺭ ﺑـ ‪ B‬ﻭﻣﻦ ‪ 70‬ﺇﻟﻰ ‪79‬ﺗﻘﺪﺭ ﺑـ ‪ C‬ﻭﻣﻦ ‪ 60‬ﺇﻟﻰ ‪ 69‬ﺗﻘﺪﺭ ﺑـ ‪ D‬ﻭﻣﻦ‬
‫‪ 50‬ﺇﻟﻰ ‪59‬ﺗﻘﺪﺭ ﺑـ ‪ E‬ﻭﺍﻟﺪﺭﺟﺎﺕ ﺃﻗﻞ ﻣﻦ ‪ 50‬ﺗﻘﺪﺭ ﺑـ ‪. F‬‬
‫ﺍﻟﺠﻮﺍﺏ‪:‬‬
‫‪integer :: deg‬‬
‫‪character :: eval‬‬

‫‪read *, deg‬‬

‫‪if (deg>= 90 .and. deg<= 100) then‬‬

‫’‪eval = ‘A‬‬
‫‪elseif (deg>= 80 .and. deg<= 89) then‬‬
‫|‪(D)14‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫’‪eval = ‘B‬‬
‫‪elseif (deg>= 70 .and. deg<= 79) then‬‬
‫’‪eval = ‘C‬‬
‫‪elseif (deg>= 60 .and. deg<= 69) then‬‬
‫’‪eval = ‘D‬‬
‫‪elseif (deg>= 50 .and. deg<= 59) then‬‬
‫’‪eval = ‘E‬‬
‫‪elseif (deg>= 0 .and. deg<= 49) then‬‬
‫’‪eval = ‘F‬‬
‫‪endif‬‬

‫‪print *, eval‬‬
‫‪end‬‬

‫ﻳﻤﻜﻦ ﺣﺬﻑ ﺃﺟﺰﺍﺀ ﻣﻦ ﺍﻟﺘﻌﺎﺑﻴﺮ ﺍﻟﻤﻨﻄﻘﻴﺔ )ﺍﻟﺸﺮﻭﻁ ﺍﻟﺘﻲ ﻳﻜﻮﻥ ﻧﺎﺗﺠﻬﺎ ﻣﻌﺮﻭﻑ ﻣﺴﺒﻘﺎً(‬
‫ﻭﺗﻠﺨﻴﺺ ﺍﻟﺠﻮﺍﺏ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪integer :: deg‬‬
‫‪character :: eval‬‬

‫‪read *, deg‬‬

‫‪if (deg>= 90) then‬‬

‫’‪eval = ‘A‬‬
‫‪elseif (deg>= 80) then‬‬
‫’‪eval = ‘B‬‬
‫‪elseif (deg>= 70) then‬‬
‫’‪eval = ‘C‬‬
‫‪elseif (deg>= 60) then‬‬
‫’‪eval = ‘D‬‬
‫‪elseif (deg>= 50) then‬‬
‫’‪eval = ‘E‬‬
‫‪else‬‬
‫’‪eval = ‘F‬‬
‫‪endif‬‬

‫‪print *, eval‬‬
‫‪end‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻫﺬﺍ ﺍﻟﺠﻮﺍﺏ ﻧﺎﻗﺺ ﺣﻴﺚ ﺃﻧﻪ ﻻ ﻳﻬﺘﻢ ﻟﻸﺭﻗﺎﻡ ﺍﻟﺘﻲ ﺗﻜﻮﻥ ﺃﺻﻐﺮ ﻣﻦ ﺍﻟﺼﻔﺮ ﺃﻭ ﺃﻛﺒﺮ‬
‫ﻣﻦ ﺍﻟﻤﺎﺋﺔ‪ ،‬ﻭﻳﺠﺐ ﻓﻲ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﺤﻘﻴﻘﻴﺔ ﺍﻟﺘﻨﺒﺆ ﻟﻤﺜﻞ ﻫﻜﺬﺍ ﺃﺧﻄﺎﺀ‪ ،‬ﻭﻋﺪﻡ ﻧﻘﻞ ﺃﺧﻄﺎﺀ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺇﻟﻰ‬
‫ﻣﺮﺍﺣﻞ ﺃﺧﺮﻯ ﻣﻦ ﺍﻟﺒﺮﻧﺎﻣﺞ )‪.(garbage in garbage out‬‬

‫‪ -2‬ﺗﺮﻛﻴﺒﺔ ﺍﻟﺤﺎﻻﺕ‪select-case‬‬
‫ﺗﺸﻜﻞ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺑﺪﻳﻼً ﻟﺘﺮﻛﻴﺒﺔ ‪ if‬ﻓﻲ "ﺑﻌﺾ" ﺍﻟﺤﺎﻻﺕ ﻭﺗﺘﻤﻴﺰ ﺑﻮﺿﻮﺣﻬﺎ ﻭﻟﻜﻦ ﻻ ﻳﻤﻜﻦ‬
‫ﺍﺳﺘﺒﺪﺍﻝ ﺃﻱ ﺗﺮﻛﻴﺒﺔ ‪ if‬ﺑﺘﺮﻛﻴﺒﺔ ﺣﺎﻻﺕ‪.‬‬
‫ﺗﺄﺧﺬ ﺗﺮﻛﻴﺒﺔ ﺍﻟﺤﺎﻻﺕ ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫)ﺗﻌﺒﻴﺮ( ‪select case‬‬
‫)ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﻘﻴﻢ( ‪case‬‬
‫|‪(D)15‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺟﻤﻞ ﺑﺮﻣﺠﺔ‬
‫)ﻣﺠﻤﻮﻋﺔ ﺛﺎﻧﻴﺔ ﻣﻦ ﺍﻟﻘﻴﻢ( ‪case‬‬
‫ﺟﻤﻞ ﺑﺮﻣﺠﺔ ﺛﺎﻧﻴﺔ‬
‫‪...‬‬
‫‪case default‬‬
‫ﺟﻤﻞ ﺑﺮﻣﺠﺔ ﺃﺧﺮﻯ‬
‫‪end select‬‬

‫ﻣﻼﺣﻈﺔ ﻫﺎﻣﺔ‪:‬ﻧﺎﺗﺞ ﺍﻟﺘﻌﺒﻴﺮ ﻓﻲ ﺗﺮﻛﻴﺒﺔ ﺍﻟﺤﺎﻻﺕ "ﻻ ﻳﺴﻤﺢ" ﺃﻥ ﻳﻜﻮﻥ ﻋﺪﺩ ﺣﻘﻴﻘﻲ ﺃﻭ ﻣﺮﻛﺐ‪.‬‬

‫ﻣﻼﺣﻈﺔ‪:‬ﺗﺘﻜﻮﻥ ﻣﺠﻤﻮﻋﺔ ﺍﻟﺤﺎﻻﺕ ﻣﻦ "ﻗﻴﻤﺔ ﻭﺍﺣﺪﺓ" ﺃﻭ "ﻗﻴﻢ" ﺃﻭ "ﻣﺠﺎﻻﺕ ﻗﻴﻢ" ﻳﻤﻜﻦ ﺃﻥ ﺗﻨﺘﺞ‬
‫ﻋﻦ ﺍﻟﺘﻌﺒﻴﺮ ﻣﻔﺼﻮﻟﺔ ﻋﻦ ﺑﻌﻀﻬﺎ ﺑﺎﻟﻔﺎﺭﺯﺓ‪.‬‬
‫ﻣﺠﺎﻝ ﺍﻟﻘﻴﻢ ﻳﻜﺘﺐ ﺑﺈﺣﺪﻯ ﺍﻷﺷﻜﺎﻝ ﺍﻟﺘﺎﻟﻴﺔ‬
‫ﺃ( )‪ (a : b‬ﻭﻳﺪﻝ ﻫﺬﺍ ﺍﻟﻤﺠﺎﻝ ﻋﻠﻰ ﺟﻤﻴﻊ ﺍﻟﻘﻴﻢ ﻣﺎ ﺑﻴﻦ ‪ a‬ﻭ‪ b‬ﻭﻛﺬﻟﻚ ﻧﻔﺲ ﻫﺎﺗﻴﻦ ﺍﻟﻘﻴﻤﺘﻴﻦ‪.‬‬
‫ﺏ( )‪ ( : b‬ﻭﻳﺪﻝ ﻫﺬﺍ ﺍﻟﻤﺠﺎﻝ ﻋﻠﻰ ﺟﻤﻴﻊ ﺍﻟﻘﻴﻢ ﺍﻷﺻﻐﺮ ﺃﻭ ﺗﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ‪.b‬‬
‫ﺝ( ) ‪ (a :‬ﻭﻳﺪﻝ ﻫﺬﺍ ﺍﻟﻤﺠﺎﻝ ﻋﻠﻰ ﺟﻤﻴﻊ ﺍﻟﻘﻴﻢ ﺍﻷﻛﺒﺮ ﺃﻭ ﺗﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ‪.a‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫)ﻳﻌﻨﻲ ﺍﻟﻌﺪﺩ ‪(71‬‬ ‫‪71‬‬
‫)ﻳﻌﻨﻲ ﺍﻟﻌﺪﺩ ‪ 1‬ﺃﻭ ﺍﻟﻌﺪﺩ ‪ 4‬ﺃﻭ ﺍﻟﻌﺪﺩ ‪(5‬‬ ‫‪1,4,5‬‬
‫)ﺍﻷﻋﺪﺍﺩ ‪ 1‬ﺇﻟﻰ ‪ 6‬ﺃﻭ ﺍﻟﻌﺪﺩ ‪ 9‬ﺃﻭ ﺍﻷﻋﺪﺍﺩ ‪ 11‬ﺇﻟﻰ ‪(20‬‬ ‫‪1:6,9,11:20‬‬
‫)ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﺼﻴﺔ "‪("RED‬‬ ‫"‪"RED‬‬
‫)ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﺼﻴﺔ "‪ "A‬ﺃﻭ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﺼﻴﺔ "‪("U‬‬ ‫"‪"A","U‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺗﺒﺪﻳﻞ ﺩﺭﺟﺔ ﺍﻟﻄﺎﻟﺐ ﺇﻟﻰ ﺗﻘﺪﻳﺮ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺗﺮﻛﻴﺒﺔ ‪select case‬‬

‫‪integer :: deg‬‬
‫‪character :: eval‬‬

‫‪read *, deg‬‬

‫)‪select case (deg‬‬

‫)‪case (90:100‬‬
‫’‪eval = ‘A‬‬
‫)‪case (80:89‬‬
‫’‪eval = ‘B‬‬
‫)‪case (70:79‬‬
‫’‪eval = ‘C‬‬
‫)‪case (60:69‬‬
‫’‪eval = ‘D‬‬
‫)‪case (50:59‬‬
‫’‪eval = ‘E‬‬
‫‪case default‬‬
‫’‪eval = ‘F‬‬
‫‪end select‬‬
‫|‪(D)16‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫‪print *, eval‬‬
‫‪end‬‬
‫ﻻﺣﻆ ﺃﻥ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺃﻭﺿﺢ ﻣﻤﺎ ﻛﺎﻥ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺗﺮﻛﻴﺒﺔ ‪.if‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺗﺄﺧﺬ ﺭﻗﻢ ﺍﻟﺸﻬﺮ ﺍﻟﻤﻴﻼﺩﻱ ﻭﺗﻌﻄﻲ ﻋﺪﺩ ﺃﻳﺎﻡ ﺍﻟﺸﻬﺮ‪.‬‬

‫‪integer :: month, days‬‬

‫‪read *, month‬‬
‫)‪select case (month‬‬
‫)‪case (1,3,5,7:8,10,12‬‬
‫‪days = 31‬‬
‫)‪case (4,6,9,11‬‬
‫‪days = 30‬‬
‫‪case default‬‬
‫‪days = 28‬‬
‫‪end select‬‬

‫"!‪print *, "month ", month, " has ", days, " days‬‬
‫‪end‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺍﻟﻤﻘﺪﺍﺭ ﺍﻟﻤﻄﻠﻖ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺗﺮﻛﻴﺒﺔ ‪select case‬‬

‫‪integer :: x‬‬
‫‪read *, x‬‬
‫)‪select case (x‬‬
‫)‪case (:0‬‬
‫‪x = -x‬‬
‫‪end select‬‬
‫‪print *, x‬‬
‫‪end‬‬

‫‪do‬‬ ‫‪ -3‬ﺗﺮﻛﻴﺒﺔ ﺍﻟﺘﻜﺮﺍﺭ‬

‫ﺗﺮﻛﻴﺒﺔ ‪ do‬ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻳﻤﻜﻦ ﺃﻥ ﺗﻌﻮﺽ ﻋﻦ ﺟﻤﻴﻊ ﺟﻤﻞ ﺍﻟﺘﻜﺮﺍﺭ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﺍﻟﻠﻐﺎﺕ‬
‫ﺍﻷﺧﺮﻯ‪ ،‬ﺣﻴﺚ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ ﺑﻌﺪﺓ ﺃﺷﻜﺎﻝ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫ﺃ( ﺗﺮﻛﻴﺒﺔ ‪ do‬ﺍﻟﻐﻴﺮ ﻣﺤﺪﺩﺓ‬

‫‪do‬‬
‫ﺟﻤﻞ ﺑﺮﻣﺠﻴﺔ‬
‫‪End do‬‬
‫ﻋﻨﺪ ﻭﺻﻮﻝ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻳﺒﺪﺃ ﺍﻟﺤﺎﺳﻮﺏ ﺑﺘﻨﻔﻴﺬ ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ ﺍﻟﻤﻮﺟﻮﺩﺓ ﺑﺪﺍﺧﻠﻪ‬
‫ﺟﻤﻠﺔ ﺗﻠﻮ ﺍﻷﺧﺮﻯ ﻭﻋﻨﺪ ﺍﻟﻮﺻﻮﻝ ﺇﻟﻰ ‪ end do‬ﻳﺮﺟﻊ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺑﺪﺍﻳﺔ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺃﻱ ﺇﻟﻰ ‪ do‬ﺇﺫﺍ‬
‫ﻳﻤﻜﻦ ﺍﻟﻘﻮﻝ ﺃﻥ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺑﻬﺬﺍ ﺍﻟﺸﻜﻞ ﺗﺤﻞ ﻣﺤﻞ ﺍﻷﻣﺮ ‪ go to‬ﻓﻲ ﺑﻌﺾ ﺍﻟﺤﺎﻻﺕ‪.‬‬

‫ﻣﻼﺣﻈﺔ ﻫﺎﻣﺔ‪:‬ﺟﻤﻠﺔ‪ EXIT‬ﻳﻤﻜﻦ ﺃﻥ ﺗﻮﺿﻊ ﺩﺍﺧﻞ ﺗﺮﻛﻴﺒﺔ ‪ do‬ﻛﺄﻱ ﺟﻤﻠﺔ ﺃﺧﺮﻯ ﻭﻋﻨﺪ ﻭﺻﻮﻝ‬
‫ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺠﻤﻠﺔ ﺳﻮﻑ ﺗﻨﻬﻲ ﺗﻨﻔﻴﺬ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻭﺗﺮﺳﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻣﺎ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،end do‬ﺃﻣﺎ‬
‫ﺟﻤﻠﺔ ‪ CYCLE‬ﻓﻬﻲ ﺃﻳﻀﺎً ﻳﻤﻜﻦ ﺃﻥ ﺗﻮﺿﻊ ﺩﺍﺧﻞ ﺗﺮﻛﻴﺒﺔ ‪ do‬ﻛﺄﻱ ﺟﻤﻠﺔ ﺃﺧﺮﻯ ﻭﻋﻨﺪ ﻭﺻﻮﻝ‬
‫ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺠﻤﻠﺔ ﺳﻮﻑ ﻳﺬﻫﺐ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ ﺃﻭﻝ ﺟﻤﻠﺔ ﻓﻲ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،do‬ﺗﺴﺘﺨﺪﻡ‬
‫|‪(D)17‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻫﺎﺗﻴﻦ ﺍﻟﺠﻤﻠﺘﻴﻦ ﻓﻲ ﺟﻤﻴﻊ ﺣﺎﻻﺕ ﺗﺮﻛﻴﺒﺔ ‪.do‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻛﻴﻒ ﻳﻌﻤﻞ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ؟‬

‫‪integer :: n,i, f‬‬

‫‪read *, n‬‬
‫‪i=n‬‬
‫‪f=1‬‬
‫‪do‬‬
‫‪f=f*i‬‬
‫‪i = i-1‬‬
‫‪if (i==0) exit‬‬
‫‪enddo‬‬
‫‪print *, "factorial of ", n, " = ", f‬‬
‫‪end‬‬

‫ﺏ( ﺗﺮﻛﻴﺒﺔ ‪ do‬ﺍﻟﺸﺮﻃﻴﺔ‬

‫)ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ( ‪Do while‬‬
‫ﺟﻤﻞ ﺑﺮﻣﺠﻴﺔ‬
‫‪End do‬‬

‫ﻋﻨﺪ ﻭﺻﻮﻝ ﺍﻟﺤﺎﺳﻮﺏ ﻟﻬﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻓﺈﻧﻪ ﺳﻮﻑ ﻳﻔﺤﺺ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ )ﺍﻟﺸﺮﻁ( ﻭﺇﺫﺍ ﻛﺎﻥ‬
‫ﺍﻟﻨﺎﺗﺞ ‪ .true.‬ﻓﺈﻧﻪ ﻳﺒﺪﺃ ﺑﺘﻨﻔﻴﺬ ﺍﻟﺠﻤﻞ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻟﻠﺘﺮﻛﻴﺒﺔ ﻭﻋﻨﺪ ﺍﻟﻮﺻﻮﻝ ﺇﻟﻰ ‪ enddo‬ﻳﺮﺟﻊ ﺍﻟﺘﻨﻔﻴﺬ‬
‫ﺇﻟﻰ ﺑﺪﺍﻳﺔ ﺍﻟﺘﺮﻛﻴﺒﺔ )ﻓﺤﺺ ﺍﻟﺸﺮﻁ ﻣﻦ ﺟﺪﻳﺪ ﻭﺗﻨﻔﻴﺬ ﻭ‪ ،(...‬ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ‬
‫‪ .false.‬ﻓﺈﻥ ﺍﻟﺘﻨﻔﻴﺬ ﺳﻮﻑ ﻳﻨﺘﻘﻞ ﺇﻟﻰ ﺃﻭﻝ ﺃﻣﺮ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ ،enddo‬ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺟﻤﻠﺘﻲ ‪ exit‬ﻭ‬
‫‪ cycle‬ﻓﻲ ﺍﻷﻭﺍﻣﺮ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻟﻬﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻛﻤﺎ ﻓﻲ ﺍﻟﺤﺎﻟﺔ ﺍﻟﺴﺎﺑﻘﺔ‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﺍﻟﻤﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺑﻄﺮﻳﻘﺔ ﺃﻓﻀﻞ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪integer :: n, i, f‬‬

‫‪read *, n‬‬
‫‪i=n‬‬
‫‪f=1‬‬
‫)‪dowhile (i>0‬‬
‫‪f=f*i‬‬
‫‪i = i-1‬‬
‫‪enddo‬‬
‫‪print *, "factorial of ", n, " = ", f‬‬
‫‪end‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻓﻲ ﻣﺘﺴﻠﺴﻠﺔ ﻓﻴﺒﻮﻧﺎﺟﻲ )‪ (Fibonacci series‬ﻛﻞ ﻋﻨﺼﺮ ﻳﺘﻜﻮﻥ ﻣﻦ ﻣﺠﻤﻮﻉ‬

‫ﺍﻟﻌﻨﺼﺮﻳﻦ ﺍﻟﺴﺎﺑﻘﻴﻦ ﻟﻪ‬
‫‪1, 1, 2, 3, 5, 8, 13, 21, ...‬‬
‫ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻳﻄﺒﻊ ﺃﺭﻗﺎﻡ ﻣﺘﺴﻠﺴﻠﺔ ﻓﻴﺒﻮﻧﺎﺟﻲ ﺍﻟﺘﻲ ﺗﻜﻮﻥ ﺃﺻﻐﺮ ﻣﻦ ﺍﻟﻌﺪﺩ ‪.N‬‬

‫ﺍﻟﺠﻮﺍﺏ‪:‬‬
‫‪integer :: a, b, c, N‬‬
‫|‪(D)18‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫‪read *, N‬‬

‫‪a=1‬‬
‫‪b=1‬‬
‫‪c=2‬‬
‫‪print *, a, b, c‬‬

‫)‪do while (c<N‬‬

‫‪c=a+b‬‬
‫‪a=b‬‬
‫‪b=c‬‬
‫‪print *, c‬‬
‫‪end do‬‬
‫‪end‬‬

‫ﺱ‪ :‬ﻫﻞ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺻﺤﻴﺢ ﺑﺘﻌﻮﻳﺾ ﺍﻟﺠﻤﻞ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻟﺘﺮﻛﻴﺒﺔ ‪ do‬ﻛﻤﺎ ﻳﻠﻲ؟‬
‫‪c=a+b‬‬
‫‪b=c‬‬
‫‪a=b‬‬

‫ﺝ( ﺗﺮﻛﻴﺒﺔ ‪ do‬ﺍﻟﻤﺤﺪﺩﺓ‬

‫ﺍﻟﺨﻄﻮﺓ ‪,‬ﻗﻴﻤﺔ ﻧﻬﺎﺋﻴﺔ ‪,‬ﻗﻴﻤﺔ ﺑﺪﺍﺋﻴﺔ=ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ‪do‬‬
‫ﺟﻤﻞ ﺑﺮﻣﺠﻴﺔ‬
‫‪End do‬‬

‫ﻭﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺗﻌﻤﻞ ﻋﻤﻞ ﺗﺮﻛﻴﺒﺔ ‪ for – next‬ﻓﻲ ﻟﻐﺔ ﺍﻟﺒﻴﺴﻚ‪ ،‬ﻓﻌﻨﺪ ﻭﺻﻮﻝ ﺍﻟﺤﺎﺳﻮﺏ ﺇﻟﻰ‬
‫ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻷﻭﻝ ﻣﺮﺓ ﻓﺈﻧﻪ )‪ (1‬ﺳﻮﻑ ﻳﻌﻄﻲ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺒﺪﺍﺋﻴﺔ ﻭ)‪ (2‬ﻳﻘﺎﺭﻥ ﻗﻴﻤﺔ‬
‫ﺍﻟﻤﺘﻐﻴﺮ ﻣﻊ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﻬﺎﺋﻴﺔ ﻓﺈﺫﺍ ﻛﺎﻧﺖ ﺃﺻﻐﺮ ﺃﻭ ﺗﺴﺎﻭﻱ ﻟﻠﻘﻴﻤﺔ ﺍﻟﻨﻬﺎﺋﻴﺔ ﻓﺈﻧﻪ ﺳﻴﺒﺪﺃ ﺑﺘﻨﻔﻴﺬ ﺟﻤﻞ‬
‫ﺍﻟﺘﺮﻛﻴﺒﺔ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ ﺃﻛﺒﺮ ﻣﻦ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﻬﺎﺋﻴﺔ ﻓﺈﻧﻪ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺇﻟﻰ‬
‫ﺍﻟﺠﻤﻠﺔ ﺍﻟﺘﻲ ﺗﻠﻲ ‪ ، end do‬ﻋﻨﺪ ﺍﻟﻮﺻﻮﻝ ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻓﺈﻥ ﺍﻟﺤﺎﺳﻮﺏ ﺳﻮﻑ ﻳﺮﺟﻊ ﺇﻟﻰ‬
‫ﺑﺪﺍﻳﺘﻬﺎ ﻭﻳﻀﻴﻒ ﺑﻤﻘﺪﺍﺭ ﺍﻟﺨﻄﻮﺓ ﻋﻠﻰ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ ﻭﻳﻘﺎﺭﻧﻪ ﻣﻊ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﻬﺎﺋﻴﺔ ‪...‬‬
‫ﻳﻤﻜﻦ ﺗﻠﺨﻴﺺ ﻫﺬﺍ ﺍﻟﺸﺮﺡ ﺑﻜﺘﺎﺑﺔ ﻣﻌﺎﺩﻝ ﻟﻬﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫ﻗﻴﻤﺔ ﺑﺪﺍﺋﻴﺔ=ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ‬

‫)ﻗﻴﻤﺔ ﻧﻬﺎﺋﻴﺔ =<ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ( ‪Do while‬‬
‫ﺟﻤﻞ ﺑﺮﻣﺠﻴﺔ‬
‫ﺍﻟﺨﻄﻮﺓ ‪ +‬ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ = ﺍﻟﻤﺘﻐﻴﺮ ﺍﻟﻤﺴﻴﻄﺮ‬
‫‪End do‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻫﺬﺍ ﺍﻟﻤﻌﺎﺩﻝ ﻟﻴﺲ ﺻﺤﻴﺤﺎ ﻓﻲ ﺣﺎﻟﺔ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻷﻣﺮ ‪ cycle‬ﻓﻲ ﺍﻟﺠﻤﻞ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻭﻣﻊ‬
‫ﺫﻟﻚ ﻓﺈﻧﻪ ﻳﻌﻄﻲ ﻓﻜﺮﺓ ﺑﺴﻴﻄﺔ ﺣﻮﻝ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ‪.‬‬

‫ﻣﻼﺣﻈﺔ ﻫﺎﻣﺔ‪ :‬ﻓﻲ ﺣﺎﻟﺔ ﻋﺪﻡ ﻛﺘﺎﺑﺔ ﺍﻟﺨﻄﻮﺓ ﻓﺈﻥ ﺍﻟﺤﺎﺳﻮﺏ ﺳﻮﻑ ﻳﺴﺘﺨﺪﻡ )‪ (1‬ﻟﻬﺬﺍ ﺍﻟﺠﺰﺀ‪.‬‬
‫ﻣﻼﺣﻈﺔ ﻫﺎﻣﺔ‪ :‬ﻳﺠﺐ ﺍﻻﺑﺘﻌﺎﺩ ﻋﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺘﻐﻴﺮ ﺣﻘﻴﻘﻲ ﻟﻠﺴﻴﻄﺮﺓ ﻋﻠﻰ ﺗﻨﻔﻴﺬ ﻫﺬﻩ ﺍﻟﺘﺮﻛﻴﺒﺔ‬
‫ﻭﺍﻻﻛﺘﻔﺎﺀ ﺑﺎﻟﻤﺘﻐﻴﺮ ﻣﻦ ﺍﻟﻨﻮﻉ ﺍﻟﺼﺤﻴﺢ‪.‬‬
‫|‪(D)19‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﺍﻟﻤﻀﺮﻭﺏ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪integer :: n, i, f‬‬
‫‪read *, n‬‬
‫‪f=1‬‬
‫‪do i = 1, n‬‬
‫‪f=f*i‬‬
‫‪enddo‬‬
‫‪print *, "factorial of ", n, " = ", f‬‬
‫‪end‬‬

‫‪Arrays‬‬ ‫ﺍﻟﻤﺼﻔﻮﻓﺎﺕ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺔ ﻫﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺧﻼﻳﺎ ﺍﻟﺬﺍﻛﺮﺓ ﺗﺴﻤﻰ ﺑﺎﺳﻢ ﻭﺍﺣﺪ ﻭﻳﺘﻢ ﺍﻟﺘﻤﻴﻴﺰ ﻣﺎ ﺑﻴﻦ ﺍﻟﺨﻼﻳﺎ‬
‫ﺑﺎﺳﺘﺨﺪﺍﻡ ﻋﺪﺩ ﺻﺤﻴﺢ ﻳﺴﻤﻰ ﺍﻟﻤﻤﻴﺰ )‪.(index‬‬

‫ﺃ( ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺔ‪:‬‬

‫ﻻﺑﺪ ﻣﻦ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻗﺒﻞ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻻﻥ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻻ ﻳﻘﺒﻞ ﺍﻹﻋﻼﻥ ﺍﻟﻀﻤﻨﻲ ﻋﻦ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻭﻳﺘﻢ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺍﺳﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) ::‬ﻣﺠﺎﻝ ﺍﻟﻤﻤﻴﺰ ﺃﻭ ﻋﺪﺩ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ(‪, DIMENSION‬ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ‬
‫ﺃﻣﺎ ﻣﺠﺎﻝ ﺍﻟﻤﻤﻴﺰ ﻓﻬﻮ ﺭﻗﻢ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﺛﻢ ﻧﻘﻄﺘﻴﻦ ﺛﻢ ﺭﻗﻢ ﺍﻟﺨﻠﻴﺔ ﺍﻷﺧﻴﺮﺓ ﻭﻓﻲ ﺣﺎﻟﺔ ﺗﺤﺪﻳﺪ‬
‫ﻋﺪﺩ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻓﻘﻂ ﺳﻴﻜﻮﻥ ﺭﻗﻢ ﺃﻭﻝ ﺧﻠﻴﺔ ﻫﻮ ﺍﻟﻌﺪﺩ ‪.1‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪integer, dimension(10:20) :: a‬‬
‫ﻳﻌﻠﻦ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺑﺎﺳﻢ ‪ a‬ﺗﺨﺰﻥ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﺗﻜﻮﻥ ﺧﻼﻳﺎﻫﺎ ﻣﺮﻗﻤﺔ ﻣﻦ ‪ 10‬ﺇﻟﻰ ‪11) 20‬‬
‫ﺧﻠﻴﺔ( ﻳﻤﻜﻦ ﺭﺳﻢ ﻫﺬﻩ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪a‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫‪15‬‬ ‫‪16‬‬ ‫‪17‬‬ ‫‪18‬‬
‫‪19‬‬ ‫‪20‬‬

‫‪real, dimension(10) :: b‬‬

‫ﻳﻌﻠﻦ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺑﺎﺳﻢ ‪ b‬ﺗﺨﺰﻥ ﺃﻋﺪﺍﺩ ﺣﻘﻴﻘﻴﺔ ﺗﻜﻮﻥ ﺧﻼﻳﺎﻫﺎ ﻣﺮﻗﻤﺔ ﻣﻦ ‪ 1‬ﺇﻟﻰ ‪10) 10‬‬
‫ﺧﻼﻳﺎ(‬

‫‪character (len=20),dimension(10) :: names‬‬

‫ﻳﻌﻠﻦ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺑﺎﺳﻢ ‪ names‬ﺗﺨﺰﻥ ﻛﻞ ﺧﻠﻴﺔ ﻣﻨﻬﺎ ﻧﺺ ﻻ ﻳﺰﻳﺪ ﻃﻮﻝ ﺍﻟﺨﻠﻴﺔ ﺍﻟﻮﺍﺣﺪﺓ ﻋﻦ‬
‫‪ 20‬ﺣﺮﻑ ﻭﺗﻜﻮﻥ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﺮﻗﻤﺔ ﻣﻦ ‪ 1‬ﺇﻟﻰ ‪ 10) 10‬ﺧﻼﻳﺎ ﻛﻞ ﺧﻠﻴﺔ ‪ 20‬ﺣﺮﻑ(‬

‫‪logical,dimension(-10:10) :: good‬‬

‫ﻳﻌﻠﻦ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺑﺎﺳﻢ‪ good‬ﺗﺨﺰﻥ ﻛﻞ ﺧﻠﻴﺔ ﻣﻨﻬﺎ ﻗﻴﻤﺔ ﻣﻨﻄﻘﻴﺔ )‪ .true.‬ﺃﻭ ‪(.false.‬‬
‫ﻭﺗﻜﻮﻥ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﺮﻗﻤﺔ ﻣﻦ ‪ -10‬ﺇﻟﻰ ‪ 21) 10‬ﺧﻠﻴﺔ(‬

‫ﻳﺘﻢ ﺍﻟﻮﺻﻮﻝ ﺇﻟﻰ ﺧﻠﻴﺔ ﺩﺍﺧﻞ ﻣﺼﻔﻮﻓﺔ ﺑﻜﺘﺎﺑﺔ ﺍﺳﻢ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺛﻢ ﺭﻗﻢ ﺍﻟﺨﻠﻴﺔ ﺍﻟﻤﻄﻠﻮﺑﺔ ﺩﺍﺧﻞ‬
‫|‪(D)20‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻗﻮﺳﻴﻦ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪integer, dimension(3) :: n‬‬
‫‪n(1) = 2‬‬
‫‪n(2) = 7‬‬
‫‪n(3) = n(1) * n(2) / 11‬‬
‫)‪print *, n(3‬‬
‫‪end‬‬
‫ﺍﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﻠﻐﺔ ﺍﻟﻌﺮﺑﻴﺔ‪:‬‬
‫ﺍﺣﺠﺰ ﻓﻲ ﺍﻟﺬﺍﻛﺮﺓ ﻣﻜﺎﻥ ﻟﻤﺼﻔﻮﻓﺔ ﻣﻦ ﺛﻼﺙ ﺧﻼﻳﺎ ﻟﺨﺰﻥ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﺑﺎﺳﻢ ‪n‬‬
‫ﺿﻊ ﻓﻲ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻣﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ n‬ﺍﻟﻌﺪﺩ ‪2‬‬
‫ﺿﻊ ﻓﻲ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ n‬ﺍﻟﻌﺪﺩ ‪7‬‬
‫ﺍﺿﺮﺏ ﻣﺤﺘﻮﻯ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ n‬ﻓﻲ ﻣﺤﺘﻮﻯ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪n‬‬
‫ﻭﻗﺴﻢ ﻧﺎﺗﺞ ﺍﻟﻀﺮﺏ ﻋﻠﻰ ﺍﻟﻌﺪﺩ ‪ 11‬ﻭﺿﻊ ﻧﺎﺗﺞ ﺍﻟﻘﺴﻤﺔ ﻓﻲ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻟﺜﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪n‬‬
‫ﺍﻃﺒﻊ ﻗﻴﻤﺔ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻟﺜﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪n‬‬
‫ﻧﻬﺎﻳﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ‬

‫ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﻣﺘﻌﺪﺩﺓ ﺍﻷﺑﻌﺎﺩ‬

‫ﻳﻤﻜﻦ ﺍﻻﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺃﻛﺜﺮ ﻣﻦ ﺑﻌﺪ ﻭﺍﺣﺪ ﻭﻳﺘﻢ ﺫﻟﻚ ﻛﻤﺎ ﻓﻲ ﺍﻷﻣﺜﻠﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫‪character(50), dimension(4, 30) :: names‬‬

‫ﻳﻌﻠﻦ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪﻳﻦ ﺑﺎﺳﻢ ‪ names‬ﻣﻜﻮﻧﺔ ﻣﻦ ‪ 4‬ﺍﺳﻄﺮﻭﻓﻲ ﻛﻞ ﺳﻄﺮ ‪30‬ﻋﻤﻮﺩ‬
‫ﻳﺨﺰﻥ ﻓﻲ ﻛﻞ ﺧﻠﻴﺔ ﻗﻴﻤﺔ ﻧﺼﻴﺔ ﻃﻮﻟﻬﺎ ﻻ ﻳﺰﻳﺪ ﻋﻦ ‪ 50‬ﺣﺮﻑ؛ ﻳﻤﻜﻦ ﻣﺜﻼً ﺃﻥ ﺗﺴﺘﺨﺪﻡ ﻣﺜﻞ ﻫﺬﻩ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺔ ﻟﺨﺰﻥ ﺃﺳﻤﺎﺀ ﻃﻼﺏ ﺍﻟﻤﺮﺍﺣﻞ ﺍﻷﺭﺑﻌﺔ ﻭﻋﻨﺪﻫﺎ ﺳﻮﻑ ﻳﻜﻮﻥ )‪ names(2, 10‬ﺃﺳﻢ‬
‫ﺍﻟﻄﺎﻟﺐ ﺫﻱ ﺍﻟﺘﺴﻠﺴﻞ ‪ 10‬ﻓﻲ ﺍﻟﻤﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‪.‬‬

‫‪integer, dimension(1:8, 8) :: board‬‬

‫ﻳﻌﻠﻦ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻌﺪﻳﻦ ﻣﻤﻴﺰ ﺍﻟﺒﻌﺪ ﺍﻷﻭﻝ ﻭﺍﻟﺜﺎﻧﻲ ﻳﻤﺘﺪﺍﻥ ﻣﻦ ‪ 1‬ﺇﻟﻰ ‪ 8‬ﺃﻱ ﺃﻥ ﻓﻲ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ 64‬ﺧﻠﻴﺔ‪.‬‬

‫ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ‬
‫ﺗﺘﻤﺘﻊ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﺈﻣﻜﺎﻧﻴﺎﺕ ﻧﺎﺩﺭﺓ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﺇﺿﺎﻓﺔ ﺇﻟﻰ ﺍﻟﻄﺮﻕ ﺍﻻﻋﺘﻴﺎﺩﻳﺔ‬
‫ﺍﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺮﻣﺠﺔ ﺍﻷﺧﺮﻯ ﻭﺍﻟﺘﻲ ﺗﻢ ﺷﺮﺣﻬﺎ ﻓﻲ ﻓﻘﺮﺓ ﺳﺎﺑﻘﺔ‪ .‬ﻭﺗﺮﺗﻜﺰ ﻫﺬﻩ ﺍﻹﻣﻜﺎﻧﻴﺎﺕ‬
‫ﻋﻠﻰ‪:‬‬
‫‪ (1‬ﺍﻟﻤﻤﻴﺰ ﺍﻟﺜﻼﺛﻲ ‪Triple Index‬‬
‫ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﻤﻴﺰ ﺍﻟﺜﻼﺛﻲ ﻻﺧﺘﻴﺎﺭ ﺍﻟﺨﻼﻳﺎ ﺍﻟﻤﻄﻠﻮﺑﺔ ﻭﻳﺘﻜﻮﻥ ﺍﻟﻤﻤﻴﺰ ﺍﻟﺜﻼﺛﻲ ﺃﻣﺎ )‪ (1‬ﻣﻦ‬
‫ﺭﻗﻤﻴﻦ ﻣﻔﺼﻮﻟﻴﻦ ﺑﺎﻟﻨﻘﻄﺘﻴﻦ ﻳﺤﺪﺩ ﺍﻟﺮﻗﻢ ﺍﻷﻭﻝ ﺍﻟﺤﺪ ﺍﻷﺩﻧﻰ ﻭﺍﻟﺮﻗﻢ ﺍﻟﺜﺎﻧﻲ ﺍﻟﺤﺪ ﺍﻷﻋﻠﻰ ﻷﺭﻗﺎﻡ‬
‫ﺍﻟﺨﻼﻳﺎ ﺍﻟﺘﻲ ﻳﺘﻢ ﺍﺧﺘﻴﺎﺭﻫﺎ ﺃﻭ )‪ (2‬ﻣﻦ ﺛﻼﺛﺔ ﺃﺭﻗﺎﻡ ﻣﻔﺼﻮﻟﺔ ﺑﺎﻟﻨﻘﻄﺘﻴﻦ ﻳﺤﺪﺩ ﺍﻟﺮﻗﻢ ﺍﻷﻭﻝ ﺍﻟﺤﺪ‬
‫ﺍﻷﺩﻧﻰ ﻭﺍﻟﺮﻗﻢ ﺍﻟﺜﺎﻧﻲ ﺍﻟﺤﺪ ﺍﻷﻋﻠﻰ ﻭﺍﻟﺮﻗﻢ ﺍﻟﺜﺎﻟﺚ ﺍﻟﻔﺎﺻﻠﺔ ﺑﻴﻦ ﺍﻟﺨﻠﻴﺘﻴﻦ ﻓﻲ ﺍﻟﻤﺠﺎﻝ ﺍﻟﺬﻱ ﻳﺘﻢ‬
‫ﺍﺧﺘﻴﺎﺭﻩ‪ ،‬ﻭﻳﻤﻜﻦ ﺣﺬﻑ ﺍﻟﺮﻗﻢ ﺍﻷﻭﻝ ﻭ‪/‬ﺃﻭ ﺍﻟﺜﺎﻧﻲ ﻭ‪/‬ﺃﻭ ﺍﻟﺜﺎﻟﺚ ﻓﻲ ﺍﻟﻤﻤﻴﺰ ﺍﻟﺜﻼﺛﻲ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫)ﻳﻌﻨﻲ ﺟﻤﻴﻊ ﺍﻟﺨﻼﻳﺎ ﺍﻟﺘﻲ ﻣﻤﻴﺰﻫﺎ ﺃﻛﺒﺮ ﻣﻦ ‪(4‬‬ ‫‪4:‬‬
‫)ﻳﻌﻨﻲ ﺟﻤﻴﻊ ﺍﻟﺨﻼﻳﺎ ﺍﻟﺘﻲ ﻣﻤﻴﺰﻫﺎ ﺃﺻﻐﺮ ﻣﻦ ‪(6‬‬ ‫‪:6‬‬
‫)ﻳﻌﻨﻲ ﺍﻟﺨﻼﻳﺎ ‪ 1‬ﻭ ‪ 3‬ﻭ ‪(5‬‬ ‫‪:6:2‬‬
‫|‪(D)21‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫)ﻳﻌﻨﻲ ﺍﻟﺨﻼﻳﺎ ‪ 2‬ﻭ ‪ 5‬ﻭ ‪ 8‬ﻻﺣﻆ ﺍﻟﺤﺪ ﺍﻷﻋﻠﻰ(‬ ‫‪2:9:3‬‬

‫)ﻳﻌﻨﻲ ﺍﻟﺨﻼﻳﺎ ‪ 10‬ﻭ ‪ 7‬ﻭ ‪ 4‬ﻭ ‪ 1‬ﻻﺣﻆ ﺍﻟﺤﺪ ﺍﻷﻋﻠﻰ(‬ ‫‪10:0:-3‬‬
‫)ﻳﻌﻨﻲ ﺟﻤﻴﻊ ﺍﻟﺨﻼﻳﺎ(‬ ‫‪:‬‬

‫‪ (2‬ﺍﻟﻤﺼﻔﻮﻓﺔ ﺍﻟﺜﺎﺑﺘﺔ‬
‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﻟﻘﻴﻢ ﺑﻮﺿﻊ ﺍﻟﻘﻴﻢ ﺩﺍﺧﻞ ﻋﻼﻣﺘﻲ )‪ /‬ﻭ ‪ (/‬ﻭﺑﻬﺬﺍ ﺗﺘﻜﻮﻥ ﻣﺼﻔﻮﻓﺔ‬
‫ﺛﺎﺑﺘﺔ‪ .‬ﻣﺜﻞ‪:‬‬
‫ﻳﻌﻨﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺍﻟﻘﻴﻢ ‪ 12‬ﻭ ‪ 4‬ﻭ ‪ 5‬ﻭ ‪9‬‬ ‫)‪(/12, 4, 5, 9/‬‬
‫ﻳﻌﻨﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺍﻟﻘﻴﻢ ‪ 44‬ﻭ ﻣﺤﺘﻮﻯ ﺍﻟﺨﻠﻴﺔ‬ ‫)‪(/ 44 , x(5), 20 /‬‬
‫ﺍﻟﺨﺎﻣﺴﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ x‬ﻭ ﺍﻟﻘﻴﻤﺔ ‪20‬‬
‫ﻳﻌﻨﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺍﻟﻘﻴﻢ ‪ 11‬ﻭ ‪33‬ﻭ ‪ 10‬ﻭ ‪2‬‬ ‫)‪(/ 11, (/33, 10/), 2 /‬‬

‫ﻭﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺍﻟﺜﺎﺑﺘﺔ ﺑﺪﻝ ﺍﻟﻤﻤﻴﺰ ﻛﻤﺎ ﺃﻧﻪ ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻟﺘﻌﻴﻴﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ‬
‫ﺍﻟﻘﻴﻢ ﻳﻤﻜﻦ ﻧﻘﻠﻬﺎ ﺇﻟﻰ ﻣﺼﻔﻮﻓﺔ ﺃﻭ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻛﻤﺼﻔﻮﻓﺔ ﻛﻤﺎ ﺳﺘﻼﺣﻆ ﻓﻲ ﺍﻷﻣﺜﻠﺔ‪.‬‬

‫ﻭﺑﻨﺎﺀ ﻋﻠﻰ ﻫﺬﺍ‪:‬‬

‫‪ (1‬ﻳﻤﻜﻦ ﻧﻘﻞ ﻗﻴﻤﺔ ﻭﺍﺣﺪﺓ ﺇﻟﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺨﻼﻳﺎ‬
‫‪ (2‬ﻳﻤﻜﻦ ﻧﻘﻞ ﻋﺪﺩ ﻣﻦ ﺍﻟﻘﻴﻢ )ﻣﺼﻔﻮﻓﺔ ﺛﺎﺑﺘﺔ( ﺇﻟﻰ ﻧﻔﺲ ﺍﻟﻌﺪﺩ ﻣﻦ ﺍﻟﺨﻼﻳﺎ ﻓﻲ ﻣﺼﻔﻮﻓﺔ‬

‫ﺃﻣﺜﻠﺔ‪:‬ﻟﻨﻔﺘﺮﺽ ﺍﻹﻋﻼﻧﺎﺕ ﺃﺩﻧﺎﻩ‬

‫‪real, dimension(10) :: x‬‬
‫‪real, dimension(5, 11:15) :: y‬‬
‫‪integer, dimension(4) :: m‬‬

‫)‪m = (/12, 4, 5, 9/‬‬

‫ﻳﻨﻘﻞ ﺍﻟﻌﺪﺩ ‪ 12‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻭﺍﻟﻌﺪﺩ ‪ 4‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻭﺍﻟﻌﺪﺩ ‪ 5‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻟﺜﺔ‬
‫ﻭﺍﻟﻌﺪﺩ ‪ 9‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺮﺍﺑﻌﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) m‬ﻻﺣﻆ ﻋﻠﻰ ﻳﻤﻴﻦ ﺍﻟﺘﻌﻴﻴﻦ ‪ 4‬ﻣﺼﻔﻮﻓﺔ ﺛﺎﺑﺘﺔ ﻣﻦ‬
‫ﺃﺭﺑﻊ ﻗﻴﻢ ﻭﻋﻠﻰ ﻳﺴﺎﺭ ﺍﻟﺘﻌﻴﻦ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺃﺭﺑﻊ ﺧﻼﻳﺎ(‬

‫‪x = 1.0‬‬
‫ﻳﻨﻘﻞ ﺍﻟﻘﻴﻤﺔ ‪ 1,0‬ﺇﻟﻰ ﺟﻤﻴﻊ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) x‬ﻋﻠﻰ ﺍﻟﻴﻤﻴﻦ ﻗﻴﻤﺔ ﻭﺍﺣﺪﺓ ﻭﻋﻠﻰ ﺍﻟﻴﺴﺎﺭ‬
‫ﻣﺼﻔﻮﻓﺔ(‬

‫‪x( (/7, 9/) ) = 3.14‬‬

‫ﻳﻨﻘﻞ ﺍﻟﻌﺪﺩ ‪ 3,14‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺴﺎﺑﻌﺔ ﻭﺍﻟﺨﻠﻴﺔ ﺍﻟﺘﺎﺳﻌﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) x‬ﻋﻠﻰ ﺍﻟﻴﻤﻴﻦ ﻗﻴﻤﺔ‬
‫ﻭﺍﺣﺪﺓ ﻭﻋﻠﻰ ﺍﻟﻴﺴﺎﺭ ﺧﻠﻴﺘﻴﻦ ﻣﻦ ﻣﺼﻔﻮﻓﺔ( )ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺼﻔﻮﻓﺔ ﺛﺎﺑﺘﺔ ﻛﻤﻤﻴﺰ ﻟﺘﺤﺪﻳﺪ ﺍﻟﺨﻼﻳﺎ‬
‫ﺍﻟﻤﻄﻠﻮﺑﺔ(‬

‫‪y(1, (/12, 14/)) = 20.0‬‬

‫ﻳﻨﻘﻞ ﺍﻟﻌﺪﺩ ‪ 20‬ﺇﻟﻰ )ﺍﻟﺨﻠﻴﺔ ﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ ﻭﺍﻟﻌﻤﻮﺩ ﺭﻗﻢ ‪ (12‬ﻭ)ﺍﻟﺨﻠﻴﺔ ﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ ﻭﺍﻟﻌﻤﻮﺩ‬
‫ﺭﻗﻢ ‪) (14‬ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺼﻔﻮﻓﺔ ﺛﺎﺑﺘﺔ ﻛﻤﻤﻴﺰ ﻟﺘﺤﺪﻳﺪ ﺍﻟﺨﻼﻳﺎ ﺍﻟﻤﻄﻠﻮﺑﺔ(‬

‫‪x( 1:5 ) = 2.71‬‬

‫ﻳﻨﻘﻞ ﺍﻟﻌﺪﺩ ‪ 2,71‬ﺇﻟﻰ ﺟﻤﻴﻊ ﺍﻟﺨﻼﻳﺎ ﺍﻟﺨﻤﺴﺔ ﺍﻷﻭﻟﻰ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) x‬ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﻤﻴﺰ‬
‫|‪(D)22‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﺜﻼﺛﻲ ﻛﻤﻤﻴﺰ ﻟﺘﺤﺪﻳﺪ ﺍﻟﺨﻼﻳﺎ ﺍﻟﻤﻄﻠﻮﺑﺔ(‬

‫‪x( 1:7:2 ) = 2.71‬‬

‫ﻳﻨﻘﻞ ﺍﻟﻌﺪﺩ ‪ 2,71‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻭﺍﻟﺜﺎﻟﺜﺔ ﻭﺍﻟﺨﺎﻣﺴﺔ ﻭﺍﻟﺴﺎﺑﻌﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) x‬ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ‬
‫ﺍﻟﻤﻤﻴﺰ ﺍﻟﺜﻼﺛﻲ ﻛﻤﻤﻴﺰ ﻟﺘﺤﺪﻳﺪ ﺍﻟﺨﻼﻳﺎ ﺍﻟﻤﻄﻠﻮﺑﺔ(‬

‫)‪x(1:3 ) = (/22, 11, y(1,12) /‬‬

‫ﻳﻨﻘﻞ ﺍﻟﻌﺪﺩ ‪ 22‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻭﺍﻟﻌﺪﺩ ‪ 11‬ﺇﻟﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻭﻣﺤﺘﻮﻯ ﺍﻟﺨﻠﻴﺔ )‪ y(1,12‬ﺇﻟﻰ‬
‫ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻟﺜﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) x‬ﺗﻢ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﻤﻴﺰ ﺍﻟﺜﻼﺛﻲ ﻛﻤﻤﻴﺰ ﻟﺘﺤﺪﻳﺪ ﺍﻟﺨﻼﻳﺎ ﺍﻟﻤﻄﻠﻮﺑﺔ‬
‫ﻭﻣﺼﻔﻮﻓﺔ ﺛﺎﺑﺘﺔ ﻛﻘﻴﻤﺔ ﺗﻨﻘﻞ ﺇﻟﻰ ﻫﺬﻩ ﺍﻟﺨﻼﻳﺎ(‬

‫‪y = y * 3.1‬‬
‫ﻳﻀﺮﺏ ﺟﻤﻴﻊ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ y‬ﻓﻲ ﺍﻟﻌﺪﺩ ‪ 3,1‬ﻭﻳﻀﻊ ﺍﻟﻨﺎﺗﺞ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪y‬‬

‫)‪x(1:2) = x(2:1:-1‬‬
‫ﺳﻮﻑ ﻳﻌﻮﺽ ﻗﻴﻢ ﺍﻟﺨﻠﻴﺘﻴﻦ ﺍﻷﻭﻟﻰ ﻭﺍﻟﺜﺎﻧﻴﺔ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪) x‬ﻷﻥ ﻋﻤﻠﻴﺔ ﺍﻟﻨﻘﻞ ﺗﺘﻢ ﻓﻲ ﺧﻄﻮﺓ‬
‫ﻭﺍﺣﺪﺓ(‬

‫)‪x(1:4) = x(4:1:-1) * (/ 5, 10, 15, 20 /‬‬

‫ﺳﻮﻑ ﻳﻀﺮﺏ ﻣﺤﺘﻮﻯ ﺍﻟﺨﻼﻳﺎ ﺭﻗﻢ ‪ 4‬ﻭ ‪ 3‬ﻭ ‪ 2‬ﻭ ‪ 1‬ﻓﻲ ﺍﻟﻘﻴﻢ ‪ 5‬ﻭ ‪ 10‬ﻭ ‪ 15‬ﻭ ‪ 20‬ﻭﻳﻀﻊ‬
‫ﺍﻟﻨﺎﺗﺞ ﻓﻲ ﺍﻟﺨﻼﻳﺎ ‪ 1‬ﻭ ‪ 2‬ﻭ ‪ 3‬ﻭ ‪ 4‬ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪x‬‬

‫ﺗﺮﻛﻴﺒﺔ ‪Where‬‬
‫ﺗﺴﺘﺨﺪﻡ ﺗﺮﻛﻴﺒﺔ ‪ where‬ﺍﻟﺸﺮﻃﻴﺔ ﻟﻤﺴﺎﻭﺍﺓ )ﺟﻤﻞ ﺗﻌﻴﻴﻦ ﻓﻘﻂ( ﻋﻨﺎﺻﺮ ﻣﺼﻔﻮﻓﺔ ﺑﻌﻨﺎﺻﺮ‬
‫ﻣﺼﻔﻮﻓﺔ ﺃﺧﺮﻯ ﺑﺸﺮﻁ ﺻﺤﺔ ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪integer, dimension(10) :: a, b, c‬‬
‫)‪where (a/=0‬‬
‫‪c=b/a‬‬
‫‪elsewhere‬‬
‫‪c=1‬‬
‫‪endwhere‬‬
‫ﻳﻌﻨﻲ ﺃﻳﻨﻤﺎ ﻛﺎﻧﺖ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ a‬ﺗﺴﺎﻭﻱ ﺍﻟﺼﻔﺮ ﺿﻊ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ c‬ﻧﺎﺗﺞ ﻗﺴﻤﺔ ﺍﻟﺨﻠﻴﺔ‬
‫ﺍﻟﻤﺘﻨﺎﻇﺮﺓ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ b‬ﻋﻠﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﻤﺘﻨﺎﻇﺮﺓ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ a‬ﻭﻓﻲ ﺑﺎﻗﻲ ﺍﻟﺤﺎﻻﺕ ﺿﻊ ﻓﻲ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺔ ‪ c‬ﺍﻟﻌﺪﺩ ‪.1‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻓﻲ ﺗﺮﻛﻴﺒﺔ ‪ where‬ﻳﻤﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺟﻤﻞ ﺍﻟﺘﻌﻴﻴﻦ ﻓﻘﻂ‬

‫ﻣﻼﺣﻈﺔ‪:‬ﻳﺠﺐ ﺃﻥ ﻳﻜﻮﻥ ﻧﺎﺗﺞ ﺍﻟﺘﻌﺒﻴﺮ ﺍﻟﻤﻨﻄﻘﻲ )ﺍﻟﺸﺮﻁ( ﻣﺼﻔﻮﻓﺔ ﺑﺤﺠﻢ ﻣﺼﻔﻮﻓﺎﺕ ﺟﻤﻞ‬
‫ﺍﻟﺘﻌﻴﻴﻦ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻓﻲ ﺗﺮﻛﻴﺒﺔ ‪where‬‬

‫ﺍﻟﺒﺤﺚ ﻋﻦ ﻗﻴﻤﺔ ﺩﺍﺧﻞ ﻣﺼﻔﻮﻓﺔ‬

‫ﻟﻨﻔﺘﺮﺽ ﺃﻥ ﻟﺪﻳﻨﺎ ﺃﺳﻤﺎﺀ ﻣﺨﺰﻭﻧﺔ ﻓﻲ ﺧﻼﻳﺎ ﻣﺼﻔﻮﻓﺔ ﻭﺍﻟﻤﻄﻠﻮﺏ ﻫﻮ ﺗﺤﺪﻳﺪ ﻣﺤﻞ ﺍﺳﻢ ﻣﻌﻴﻦ‬
‫ﺩﺍﺧﻞ ﻫﺬﻩ ﺍﻟﻤﺼﻔﻮﻓﺔ‪ ،‬ﻫﺬﺍ ﻫﻮ ﻣﺎ ﻳﺴﻤﻰ ﺑﻌﻤﻠﻴﺔ ﺍﻟﺒﺤﺚ )‪ .(search‬ﺇﻥ ﺃﺑﺴﻂ ﻃﺮﻳﻘﺔ ﻟﻠﺒﺤﺚ ﻫﻲ‬
‫ﻣﻘﺎﺭﻧﺔ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻭﺍﺣﺪﺓ ﺑﻌﺪ ﺍﻷﺧﺮﻯ ﺇﻟﻰ ﺃﻥ ﻧﺼﻞ ﺇﻟﻰ ﺧﻠﻴﺔ ﺗﺤﻤﻞ ﻧﻔﺲ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻄﻠﻮﺑﺔ؛‬
‫|‪(D)23‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪character(50), dimension(100) :: names‬‬

‫‪character(50) :: x‬‬

‫"‪names(1) = "basem‬‬
‫"‪names(2) = "jasem‬‬
‫…‬
‫"‪names(100) = "naser‬‬

‫"‪x = "naser‬‬

‫‪do i=1, 100‬‬

‫‪if (names(i)==x) exit‬‬
‫‪enddo‬‬

‫‪if (i<=100) then‬‬

‫‪print *, x, " is in position ", i‬‬
‫‪else‬‬
‫"‪print *, x, "not find.‬‬
‫‪endif‬‬

‫‪end‬‬
‫ﺍﻟﺠﺰﺀ ﺍﻟﻤﺆﻃﺮ ﻣﻦ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻫﻮ ﻣﺎ ﻳﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ ﺍﻟﺒﺤﺚ‪.‬‬
‫ﻭﻟﻜﻮﻥ ﻃﺮﻳﻘﺔ ﺍﻟﺒﺤﺚ ﻫﺬﻩ ﺑﻄﻴﺌﺔ ﻭﻣﻜﻠﻔﺔ ﻛﻮﻧﻬﺎ ﺗﻘﺎﺭﻥ ﺟﻤﻴﻊ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﻊ ﺍﻟﻘﻴﻤﺔ‬
‫ﺍﻟﻤﻄﻠﻮﺑﺔ؛ ﺗﺴﺘﺨﺪﻡ ﻃﺮﻳﻘﺔ ﺃﺧﺮﻯ ﻓﻲ ﻟﻠﺒﺤﺚ ﺗﻜﻮﻥ ﺃﺳﺮﻉ ﻭﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﺗﺴﺘﺨﺪﻡ ﻣﻨﺬ ﻓﺘﺮﺓ ﻃﻮﻳﻠﺔ‬
‫ﻓﻲ ﺍﻟﺒﺤﺚ ﻋﻦ ﺍﻟﻜﻠﻤﺎﺕ ﺩﺍﺧﻞ ﺍﻟﻘﺎﻣﻮﺱ‪ ،‬ﻭﻳﺘﻢ ﺫﻟﻚ ﺑﺘﺮﺗﻴﺐ ﻛﻠﻤﺎﺕ ﺍﻟﻘﺎﻣﻮﺱ ﻗﺒﻞ ﻋﻤﻠﻴﺔ ﺍﻟﺒﺤﺚ ﻟﻤﺮﺓ‬
‫ﻭﺍﺣﺪﺓ ﻭﻫﺬﺍ ﺳﻮﻑ ﻳﺨﻠﺼﻨﺎ ﻣﻦ ﻋﻤﻠﻴﺎﺕ ﻛﺜﻴﺮﺓ ﻓﻲ ﺍﻟﻤﺮﺍﺣﻞ ﺍﻟﺘﺎﻟﻴﺔ‪.‬‬

‫‪Binary Search‬‬ ‫ﺍﻟﺒﺤﺚ ﺍﻟﺜﻨﺎﺋﻲ‬

‫ﻳﺘﻢ ﺍﻟﺒﺤﺚ ﺍﻟﺜﻨﺎﺋﻲ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫ﺍﻟﻤﺨﻼﺕ‪ :‬ﻣﺼﻔﻮﻓﺔ ﻳﺠﺐ ﺃﻥ ﺗﻜﻮﻥ ﺍﻟﻘﻴﻢ ﻓﻴﻬﺎ ﻣﺮﺗﺒﺔ ﻭﻗﻴﻤﺔ ﻳﺘﻢ ﺍﻟﺒﺤﺚ ﻋﻨﻬﺎ ﺩﺍﺧﻞ ﺍﻟﻤﺼﻔﻮﻓﺔ‬
‫ﺍﻟﻤﺨﺮﺟﺎﺕ‪ :‬ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﻣﻮﺟﻮﺩﺓ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺭﻗﻢ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺘﻲ ﺗﻮﺟﺪ ﻓﻴﻬﺎ ﺍﻟﻘﻴﻤﺔ‬
‫ﺍﻟﺨﻄﻮﺍﺕ‪:‬‬
‫‪ (1‬ﺍﺣﺼﻞ ﻋﻠﻰ ﺍﻟﺨﻠﻴﺔ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﻣﻨﺘﺼﻒ ﺍﻟﻤﺼﻔﻮﻓﺔ‬
‫‪ (2‬ﻗﺎﺭﻥ ﻗﻴﻤﺔ ﻫﺬﻩ ﺍﻟﺨﻠﻴﺔ ﻣﻊ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻄﻠﻮﺑﺔ ﻓﺈﺫﺍ ﻛﺎﻧﺖ )ﺃ( ﺃﻛﺒﺮ ﻣﻨﻬﺎ ﺍﺣﺬﻑ ﻧﺼﻒ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺔ ﺍﻟﺜﺎﻧﻲ ﻭﺍﺭﺟﻊ ﻟﻠﺨﻄﻮﺓ )‪ (1‬ﻭﺇﺫﺍ ﻛﺎﻧﺖ )ﺏ( ﺃﺻﻐﺮ ﻣﻨﻬﺎ ﺃﻭ ﺗﺴﺎﻭﻳﻬﺎ ﺍﺣﺬﻑ ﺍﻟﻨﺼﻒ‬
‫ﺍﻷﻭﻝ ﻣﻦ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺍﺭﺟﻊ ﻟﻠﺨﻄﻮﺓ )‪(1‬‬
‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﻫﺬﻩ ﺍﻟﺨﻮﺍﺭﺯﻣﻴﺔ ﺑﻠﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪character(50), dimension(100) :: names‬‬
‫‪character(50) :: x‬‬

‫"‪names(1) = "ahmad‬‬
‫"‪names(2) = "basem‬‬
‫"‪names(3) = "ghasem‬‬
‫‪...‬‬
‫"‪names(30) = "jasem‬‬
‫|‪(D)24‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫‪...‬‬
‫"‪names(100) = "wael‬‬

‫"‪x = "ghasem‬‬

‫‪i=1‬‬
‫‪j = 100‬‬
‫)‪dowhile (i =/ j‬‬
‫‪m = (i+j) / 2‬‬
‫‪if (x > names(m)) then‬‬
‫‪i = m+1‬‬
‫‪else‬‬
‫‪j=m‬‬
‫‪endif‬‬
‫‪enddo‬‬

‫‪if (x==names(i)) then‬‬

‫‪print *, x, " is in position ", i‬‬
‫‪else‬‬
‫"‪print *, x, " not found.‬‬
‫‪endif‬‬

‫‪end‬‬

‫ﻣﻦ ﺍﻟﻮﺍﺿﺢ ﺃﻧﻪ ﺑﻌﺪ ﻛﻞ ﻣﻘﺎﺭﻧﺔ ﻳﺘﻢ ﺣﺬﻑ ﻧﺼﻒ ﻣﺠﺎﻝ ﺍﻟﺒﺤﺚ ﻳﺤﺚ ﺑﻬﺬﻩ ﺍﻟﻤﻘﺎﺭﻧﺔ ﺍﻟﻮﺍﺣﺪﺓ ﻳﺘﻢ‬
‫ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺮﺍﺩ ﺍﻟﺒﺤﺚ ﻋﻨﻬﺎ ﻟﻴﺴﺖ ﻣﻮﺟﻮﺩ ﻓﻲ ﺇﺣﺪﻯ ﻧﺼﻔﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺍﻟﻤﺘﺒﻘﻴﺔ؛ ﻟﻬﺬﺍ‬
‫ﻓﻠﻤﺼﻔﻮﻓﺔ ﻣﻦ ‪ n‬ﺧﻠﻴﺔ ﻳﺘﻢ ﺇﺑﻘﺎﺀ ﺧﻠﻴﺔ ﻭﺍﺣﺪﺓ ﻓﻘﻂ ﺑﻌﺪ ‪ log2 n‬ﻋﻤﻠﻴﺔ ﻣﻘﺎﺭﻧﺔ‪) .‬ﻣﺜﻼ‪ :‬ﺍﻟﺒﺤﺚ ﻓﻲ‬
‫ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 1024‬ﺧﻠﻴﺔ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﻭﺍﺣﺪﺓ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 512‬ﺧﻠﻴﺔ ﺑﻌﺪ‬
‫ﻣﻘﺎﺭﻧﺔ ﺛﺎﻧﻴﺔ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 256‬ﺧﻠﻴﺔ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﺛﺎﻟﺜﺔ ﻳﺼﺒﺤﺎﻟﺒﺤﺚ ﻓﻲ‬
‫ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 128‬ﺧﻠﻴﺔ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﺭﺍﺑﻌﺔ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 64‬ﺧﻠﻴﺔ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ‬
‫ﺧﺎﻣﺴﺔ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 32‬ﺧﻠﻴﺔ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﺳﺎﺩﺳﺔ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ‬
‫ﻣﻦ ‪ 16‬ﺧﻠﻴﺔ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﺳﺎﺑﻌﺔ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 8‬ﺧﻼﻳﺎ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﺛﺎﻣﻨﺔ ﻳﺼﺒﺢ‬
‫ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 4‬ﺧﻼﻳﺎ ﺑﻌﺪ ﻣﻘﺎﺭﻧﺔ ﺗﺎﺳﻌﺔ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 2‬ﺧﻼﻳﺎ ﺑﻌﺪ‬
‫ﻣﻘﺎﺭﻧﺔ ﻋﺎﺷﺮﺓ ﻳﺼﺒﺢ ﺍﻟﺒﺤﺚ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺧﻠﻴﺔ ﻭﺍﺣﺪﺓ ﻭﻫﻨﺎ ﻻ ﻧﺤﺘﺎﺝ ﺇﻻ ﻟﻠﺘﺄﻛﺪ ﻣﻦ ﺃﻥ ﻫﺬﻩ‬
‫ﺍﻟﺨﻠﻴﺔ ﺗﺤﺘﻮﻱ ﻋﻠﻰ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺘﻲ ﻧﺒﺤﺚ ﻋﻨﻬﺎ ﺃﻡ ﻻ(‪.‬‬

‫ﺳﺆﺍﻝ‪ :‬ﻣﺎﺫﺍ ﻳﺘﻐﻴﺮ ﻟﻮ ﺃﺭﺩﻧﺎ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺸﺮﻁ )‪ x < names(m‬ﺑﺪﻻ ﻣﻦ )‪ x > names(m‬ﻓﻲ‬
‫ﻫﺬﺍ ﺍﻟﺒﺮﻧﺎﻣﺞ؟‬
‫ﺳﺆﺍﻝ‪ :‬ﻣﺎﺫﺍ ﻳﺘﻐﻴﺮ ﻟﻮ ﻛﺎﻧﺖ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﺮﺗﺒﺔ ﺗﺮﺗﻴﺒﺎ ﻧﺰﻭﻟﻴﺎً )‪(descending order‬؟‬

‫‪Procedures‬‬ ‫ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ‬

‫ﺇﻥ ﺃﺣﺪﻯ ﺍﻹﻣﻜﺎﻧﺎﺕ ﺍﻟﻤﻮﺟﻮﺩﺓ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺮﻣﺠﺔ ﻫﻲ ﺇﻣﻜﺎﻧﻴﺔ ﺗﺠﺰﺋﺔ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺇﻟﻰ ﺃﺟﺰﺍﺀ‬
‫ﻭﺩﻣﺞ ﻫﺬﻩ ﺍﻷﺟﺰﺍﺀ ﻛﺒﺮﻧﺎﻣﺞ ﻭﺍﺣﺪ ﻭﻳﺘﻢ ﺫﻟﻚ ﻓﻲ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ‪ .‬ﺇﻥ‬
‫ﺍﻟﻔﺎﺋﺪﺓ ﺍﻟﻜﺒﺮﻯ ﻻﺳﺘﺨﺪﺍﻡ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ ﻫﻮ ﺍﻟﺘﻤﻜﻦ ﻣﻦ ﺍﻟﺴﻴﻄﺮﺓ ﻋﻠﻰ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻜﺒﺮﻯ ﺑﺘﻘﺴﻴﻤﻬﺎ‬
‫ﺇﻟﻰ ﺑﺮﺍﻣﺞ ﺃﺻﻐﺮ ﺗﻘﻮﻡ ﻛﻞ ﻣﻨﻬﺎ ﺑﻌﻤﻠﻴﺎﺕ ﻣﺤﺪﻭﺩﺓ‪ ،‬ﻭﺃﻳﻀﺎً ﻫﻨﺎﻙ ﻓﺎﺋﺪﺓ ﺃﺧﺮﻯ ﻣﻦ ﺍﻟﺒﺮﺍﻣﺞ‬
‫|‪(D)25‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﻔﺮﻋﻴﺔ ﻫﻲ ﺍﻟﺘﺨﻠﺺ ﻣﻦ ﺗﻔﺎﺻﻴﻞ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺑﺎﺳﺘﺪﻋﺎﺋﻬﺎ ﺑﺎﺳﻤﻬﺎ ﻓﻘﻂ ﻣﻤﺎ ﻳﻤﻜﻦ ﻓﺮﻕ ﺍﻟﺒﺮﻣﺠﺔ ﻣﻦ‬
‫ﺗﻘﺴﻴﻢ ﺍﻟﻌﻤﻞ ﻭﺍﺳﺘﺨﺪﺍﻡ ﻣﻨﺘﺠﺎﺕ ﻋﻤﻞ ﺍﻵﺧﺮﻳﻦ )ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ ﺍﻟﺘﻲ ﻳﻜﺘﺒﻬﺎ ﺑﺎﻗﻲ ﺃﻋﻀﺎﺀ‬
‫ﺍﻟﻔﺮﻳﻖ( ﻓﻲ ﺍﻟﻤﺸﺮﻭﻉ‪.‬‬
‫ﻭﻫﻨﺎﻙ ﻧﻮﻋﻴﻦ ﻣﻦ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ ﻓﻲ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻭﻫﻤﺎ )‪ (1‬ﺍﻟﺮﻭﺗﻴﻦ ﺍﻟﻔﺮﻋﻲ ‪subroutine‬‬
‫ﻭﻫﻮ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ ﺍﻟﺬﻱ ﻳﺄﺧﺬ ﻣﺪﺧﻼﺕ ﻭﻻ ﻳﺮﺟﻊ ﻧﺎﺗﺞ ﻭ)‪ (2‬ﺍﻟﺪﺍﻟﺔ ‪ functions‬ﻭﻫﻮ‬
‫ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ ﺍﻟﺬﻱ ﻳﺄﺧﺬ ﻣﺪﺧﻼﺕ ﻭﻳﺮﺟﻊ ﻧﺎﺗﺞ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻫﺬﻩ ﺍﻟﻤﺪﺧﻼﺕ‪.‬‬

‫ﻭﻳﺘﻜﻮﻥ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﻓﺮﻋﻲ ﻣﻦ )‪ (1‬ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ )‪ (2‬ﺍﺳﺘﺪﻋﺎﺀ ﺍﻟﺒﺮﻧﺎﻣﺞ‬

‫ﺍﻟﻔﺮﻋﻲ‪.‬‬

‫ﺍﻟﺮﻭﺗﻴﻦ ﺍﻟﻔﺮﻋﻲ‪:‬‬
‫ﻭﻳﻜﺘﺐ ﺍﻹﻋﻼﻥ ﻟﻠﺮﻭﺗﻴﻦ ﺍﻟﻔﺮﻋﻲ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫)‪, ...‬ﺍﻟﻌﺎﻣﻞ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﻟﻌﺎﻣﻞ ﺍﻷﻭﻝ( ﺍﺳﻢ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ ‪SUBROUTINE‬‬
‫ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ‬
‫‪END SUBROUTINE‬‬
‫ﺃﻣﺎ ﺍﻻﺳﺘﺪﻋﺎﺀ ﻓﻴﻜﺘﺐ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫)‪, ...‬ﺍﻟﻌﺎﻣﻞ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﻟﻌﺎﻣﻞ ﺍﻷﻭﻝ( ﺍﺳﻢ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ ‪CALL‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫)‪SUBROUTINE SWAP(A, B‬‬
‫‪INTEGER :: A, B, temp‬‬
‫‪temp = A‬‬
‫‪A=B‬‬
‫‪B = temp‬‬
‫‪END SUBROUTINE‬‬

‫‪PROGRAM main‬‬
‫‪INTEGER :: X, Y‬‬

‫‪X = 19‬‬
‫‪X=7‬‬
‫‪PRINT *, X, Y‬‬
‫)‪CALL SWAP(X, Y‬‬
‫‪PRINT *, X, Y‬‬
‫‪END‬‬

‫ﺍﻟﺪﺍﻟﺔ‪:‬‬
‫ﻭﻳﻜﺘﺐ ﺍﻹﻋﻼﻥ ﻟﻠﺪﺍﻟﺔ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫)ﻣﺘﻐﻴﺮ ﺍﻟﻨﺎﺗﺞ(‪, ...) RESULT‬ﺍﻟﻌﺎﻣﻞ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﻟﻌﺎﻣﻞ ﺍﻷﻭﻝ( ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ‪FUNCTION‬‬
‫ﺍﻟﺠﻤﻞ ﺍﻟﺒﺮﻣﺠﻴﺔ‬
‫‪END FUNCTION‬‬
‫ﺃﻣﺎ ﺍﻻﺳﺘﺪﻋﺎﺀ ﻓﻴﻜﺘﺐ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﻟﻲ‪:‬‬
‫)‪, ...‬ﺍﻟﻌﺎﻣﻞ ﺍﻟﺜﺎﻧﻲ ‪,‬ﺍﻟﻌﺎﻣﻞ ﺍﻷﻭﻝ( ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ‬
‫ﻭﻳﻤﻜﻦ ﺃﻥ ﻳﺴﺘﺨﺪﻡ ﻛﺠﺰﺀ ﻣﻦ ﺗﻌﺒﻴﺮ‪.‬‬
‫|‪(D)26‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻓﺮﻋﻴﺎً ﻟﺤﺴﺎﺏ ﺍﻟﺘﻮﺍﻓﻴﻖ‬

‫‪n‬‬
‫!‪n‬‬
‫= ‪Cr‬‬
‫!)‪r!(n - r‬‬
‫ﺑﺎﻟﺘﺒﺪﻳﻞ ﺍﻟﻤﺒﺎﺷﺮ ﻟﻬﺬﻩ ﺍﻟﻤﻌﺎﺩﻟﺔ ﻳﺘﻢ ﺍﻟﺤﺼﻮﻝ ﻋﻠﻰ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ ﺍﻟﻤﻜﻮﻥ ﻣﻦ ﺩﺍﻟﺔ ﻭﺑﺮﻧﺎﻣﺞ‬
‫ﺃﺻﻠﻲ‪:‬‬
‫)‪FUNCTIONC(n, r)RESULT(x‬‬
‫‪INTEGER :: m, n, i, x‬‬
‫‪x=1‬‬
‫‪DO i = 1, n‬‬
‫‪x=x*i‬‬
‫‪ENDDO‬‬
‫‪DO i = 1, r‬‬
‫‪x=x/i‬‬
‫‪ENDDO‬‬
‫)‪DO i = 1, (n-r‬‬
‫‪x=x/i‬‬
‫‪ENDDO‬‬
‫‪ENDFUNCTION‬‬

‫‪PROGRAM TESTC‬‬
‫‪INTEGER :: C‬‬
‫)‪n = C(10, 4‬‬
‫‪PRINT *, n‬‬
‫‪END‬‬

‫ﻭﻳﻤﻜﻦ ﺗﻼﻓﻲ ﻋﻤﻠﻴﺎﺕ ﺍﻟﻀﺮﺏ ﻭﺍﻟﻘﺴﻤﺔ ﺍﻟﺰﺍﺋﺪﺓ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻤﻌﺎﺩﻟﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫!‪n‬‬ ‫‪(n - r + 1)(n - r + 2)…(n - 1)n‬‬ ‫)‪n(n - 1)…(n - r + 1‬‬
‫‪n‬‬
‫= ‪Cr‬‬ ‫=‬ ‫=‬
‫!)‪r!(n - r‬‬ ‫!‪r‬‬ ‫)‪1(2)…(r‬‬

‫ﻭﺑﺘﺒﺪﻳﻠﻬﺎ ﺇﻟﻰ ﺩﺍﻟﺔ ﺳﻴﻨﺘﺞ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﺘﺎﻟﻲ‪:‬‬

‫)‪FUNCTIONC(n, r) RESULT(x‬‬
‫‪INTEGER :: m, n, i, x‬‬
‫‪x=1‬‬
‫‪DO i = 1, r‬‬
‫‪x = x * (n - i + 1) / i‬‬
‫‪ENDDO‬‬
‫‪ENDFUNCTION‬‬

‫‪PROGRAM TESTC‬‬
‫‪INTEGER :: C‬‬
‫)‪n = C(10, 4‬‬
‫‪PRINT *, n‬‬
‫‪END‬‬

‫‪Recursion‬‬ ‫ﺍﻹﺭﺟﺎﻉ‬
‫ﻳﺴﻤﻰ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ ﺍﻟﺬﻱ ﻳﺴﺘﺪﻋﻲ ﻧﻔﺴﻪ ﻣﻦ ﺟﺪﻳﺪ ﻟﻠﺤﺼﻮﻝ ﻋﻠﻰ ﺍﻟﺠﻮﺍﺏ ﺇﺭﺟﺎﻋﻲ‬
‫)‪ (RECURSIVE‬ﻭﻟﻜﺘﺎﺑﺔ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻲ ﺍﻹﺭﺟﺎﻋﻲ ﻳﺠﺐ ﺇﺿﺎﻓﺔ ﻛﻠﻤﺔ ‪ RECURSIVE‬ﻓﻲ‬
‫|‪(D)27‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺑﺪﺍﻳﺔ ﺍﻹﻋﻼﻥ‪.‬‬
‫ﺗﻮﺟﺪ ﻧﻘﻄﺔ ﻣﻬﻤﺔ ﺟﺪﺍً ﻓﻲ ﻛﺘﺎﺑﺔ ﺍﻟﺒﺮﺍﻣﺞ ﺍﻟﻔﺮﻋﻴﺔ ﺍﻻﺭﺟﺎﻋﻴﺔ ﻭﻫﻲ ﺃﻥ ﻳﺘﻮﻗﻒ ﺍﻹﺭﺟﺎﻉ‬
‫)ﺍﺳﺘﺪﻋﺎﺀ ﺍﻟﺒﺮﻧﺎﻣﺞ( ﻟﻨﻔﺴﻪ ﻓﻲ ﺍﻟﻨﻬﺎﻳﺔ ﻟﻜﻲ ﻳﻘﻊ ﺍﻟﺘﻨﻔﻴﺬ ﻓﻲ ﺩﻭﺭ ﻻ ﻣﺘﻨﺎﻫﻲ ﻣﻦ ﺍﻹﺭﺟﺎﻋﺎﺕ‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﻋﻤﻠﻴﺔ ﺍﻟﻤﻀﺮﻭﺏ ﺍﻟﺘﺎﻟﻴﺔ ﺑﺼﻮﺭﺓ ﺩﺍﻟﺔ‪.‬‬

‫(‬ ‫)‬
‫= )‪n! = f(x‬‬ ‫‪{ n - 1 ! × 1,n, nn => 11‬‬
‫ﺍﻟﺠﻮﺍﺏ‪:‬‬
‫ﺗﻼﺣﻆ ﺃﻥ ﺍﻟﻤﻌﺎﺩﻟﺔ ﻣﻜﺘﻮﺑﺔ ﺑﺸﻜﻞ ﺇﺭﺟﺎﻋﻲ ﻟﺬﺍ ﻧﺤﺘﺎﺝ ﺇﻟﻰ ﻛﺘﺎﺑﺔ ﺩﺍﻟﺔ ﺍﺭﺟﺎﻋﻴﺔ‪:‬‬

‫)‪RECURSIVEFUNCTIONFACTORIAL(N) RESULT (F‬‬

‫‪INTEGER :: N, F‬‬
‫‪IF (N==1) THEN‬‬
‫‪F=1‬‬
‫‪ELSE‬‬
‫‪F = FACTORIAL(N-1) * N‬‬
‫‪ENDIF‬‬
‫‪ENDFUNCTION‬‬

‫‪PROGRAM TEST‬‬
‫‪INTEGER :: FACTORIAL‬‬
‫‪INTEGER :: A‬‬

‫)‪A = FACTORIAL(10‬‬

‫‪PRINT *, A‬‬
‫‪END‬‬

‫ﻣﻼﺣﻈﺔ ﻫﺎﻣﺔ ﺟﺪﺍ‪ :‬ﻳﺠﺐ ﺍﻹﻋﻼﻥ ﻋﻦ ﻧﻮﻉ ﺍﻟﺪﺍﻟﺔ ﻓﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺬﻱ ﻧﺤﺘﺎﺝ ﻻﺳﺘﺨﺪﺍﻣﻪ ﻭﻗﺪ ﺗﻢ‬
‫ﺫﻟﻚ ﻓﻲ ﻫﺬﺍ ﺍﻟﻤﺜﺎﻝ ﺑﺎﻟﺴﻄﺮ‬
‫‪INTEGER :: FACTORIAL‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺍﺳﺘﺪﻋﺎﺀ ﺩﺍﻟﺔ ‪ FACTORIAL‬ﻟﻨﻔﺴﻬﺎ ﻳﺘﻢ ﻓﻲ ﻇﺮﻭﻑ ﻣﻌﻴﻨﺔ‪ ،‬ﺃﻳﻀﺎ ﻛﻠﻤﺎ ﺍﺳﺘﺪﻋﺖ‬
‫ﺍﻟﺪﺍﻟﺔ ﻧﻔﺴﻬﺎ ﻣﻦ ﺟﺪﻳﺪ ﻳﻜﻮﻥ ﺍﻻﺳﺘﺪﻋﺎﺀ ﺍﻟﺠﺪﻳﺪ ﺃﻗﺮﺏ ﺇﻟﻰ ﺷﺮﻭﻁ ﻋﺪﻡ ﺍﻻﺳﺘﺪﻋﺎﺀ‪.‬‬

‫‪Sort‬‬ ‫ﺍﻟﺘﺮﺗﻴﺐ )ﺍﻟﻔﺮﺯ(‬

‫ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ ﺃﻭ ﺍﻟﺘﺮﺗﻴﺐ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﻋﻤﻠﻴﺔ ﺗﻐﻴﻴﺮ ﻣﺤﻞ ﺍﻟﻘﻴﻢ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﺑﺤﻴﺚ ﺗﻜﻮﻥ‬
‫ﺍﻟﻘﻴﻢ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺑﻌﺪ ﺍﻟﻔﺮﺯ ﺫﺍﺕ ﺗﺮﺗﻴﺐ ﻭﺍﺣﺪ ﺇﻣﺎ ﺻﻌﻮﺩﻳﺎ )‪ (ascending‬ﺃﻭ ﻧﺰﻭﻟﻴﺎ‬
‫)‪ (descending‬ﻭﺗﻮﺟﺪ ﻃﺮﻕ ﻛﺜﻴﺮﺓ ﻟﺘﻨﻔﻴﺬ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻣﻦ ﺟﻤﻠﺔ ﻫﺬﻩ ﺍﻟﻄﺮﻕ ﻫﻲ ﻃﺮﻳﻘﺔ ﺍﻟﻔﺮﺯ‬
‫ﺍﻟﻔﻘﺎﻋﻲ )‪ (bubble sort‬ﺣﻴﺚ ﻭﻓﻲ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ‪:‬‬
‫‪ (1‬ﻳﺘﻢ ﻣﻘﺎﺭﻧﺔ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﻊ ﻛﻞ ﺍﻟﺨﻼﻳﺎ ﺍﻟﺘﻲ ﺗﻠﻴﻬﺎ ﻭﻓﻲ ﺣﺎﻟﺔ ﻭﺟﻮﺩ ﺧﻠﻴﺔ‬
‫ﻗﻴﻤﺘﻬﺎ ﺃﺻﻐﺮ ﻣﻦ ﻗﻴﻤﺔ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻳﺘﻢ ﺗﻌﻮﻳﺾ ﻗﻴﻤﺔ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻣﻊ ﺗﻠﻚ ﺍﻟﺨﻠﻴﺔ‬
‫‪ (2‬ﺗﻜﺮﺭ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻋﻠﻰ ﺑﺎﻗﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺃﻱ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﺇﻟﻰ ﺍﻟﻨﻬﺎﻳﺔ‬
‫‪ (3‬ﺗﻜﺮﺭ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻋﻠﻰ ﺑﺎﻗﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺃﻱ ﺍﻟﺨﻠﻴﺔ ﺍﻟﺜﺎﻟﺜﺔ ﺇﻟﻰ ﺍﻟﻨﻬﺎﻳﺔ‬
‫‪... (4‬‬
‫|‪(D)28‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪INTEGER, DIMENSION(10) :: A‬‬
‫‪INTEGER:: i, j, t‬‬

‫)‪A = (/18, 1, -9, 11, 23, 8, 0, 4, 27, 53/‬‬

‫‪DOi = 1, 10‬‬
‫‪DOj = i+1, 10‬‬
‫‪IF(A(j)<A(i)) THEN‬‬
‫)‪t = A(i‬‬
‫)‪A(i) = A(j‬‬
‫‪A(j) = t‬‬
‫‪ENDIF‬‬
‫‪ENDDO‬‬
‫‪ENDDO‬‬
‫‪PRINT *, A‬‬
‫‪END‬‬

‫ﺳﺆﺍﻝ‪ :‬ﺍﺷﺮﺡ ﻃﺮﻳﻘﺔ ﻋﻤﻞ ﺍﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫ﻭﻟﻜﻦ ﻫﺬﺍ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻳﺴﺘﻐﺮﻕ ﻭﻗﺘﺎً ﻃﻮﻳﻼ ﻟﺘﻨﻔﻴﺬ ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ‪ ،‬ﻓﻬﻮ ﻳﺤﺘﺎﺝ ﻣﺜﻼً ﺇﻟﻰ ‪ 9‬ﻋﻤﻠﻴﺎﺕ‬
‫ﻣﻘﺎﺭﻧﺔ ﻟﻠﺤﺼﻮﻝ ﻋﻠﻰ ﺃﺻﻐﺮ ﻋﺪﺩ ﻟﻴﻀﻌﻪ ﻓﻲ ﺍﻟﺨﻠﻴﺔ ﺍﻷﻭﻟﻰ ﻭﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ‪n‬‬
‫‪2‬‬
‫‪n‬‬ ‫)‪n(n + 1‬‬
‫ﺧﻠﻴﺔ ﻓﺈﻥ ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ ﺗﺤﺘﺎﺝ ﺇﻟﻰ ‪ 2 ≈ 2‬ﻋﻤﻠﻴﺔ ﻣﻘﺎﺭﻧﺔ ﻭﻫﺬﺍ ﺍﻟﻘﺪﺭ ﻣﻦ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻳﺤﺘﺎﺝ ﺇﻟﻰ‬
‫ﻭﻗﺖ ﻃﻮﻳﻞ ﻟﻤﺼﻔﻮﻓﺎﺕ ﻟﻴﺴﺖ ﻛﺒﻴﺮﺓ ﺟﺪﺍً‪.‬‬
‫ﺗﻮﺟﺪ ﻃﺮﻕ ﺃﺧﺮﻯ ﻟﻠﻔﺮﺯ ﻣﻦ ﺃﻫﻤﻬﺎ ﻃﺮﻳﻘﺔ ﺍﻟﻔﺮﺯ ﺍﻟﺴﺮﻳﻊ ﺍﻟﺘﻲ ﺗﺴﺘﺨﺪﻡ ﺃﺳﻠﻮﺑﺘﻘﺴﻴﻢ ﺍﻟﻤﺴﺄﻟﺔ‬
‫ﺇﻟﻰ ﻣﺴﺎﺋﻞ ﺃﺻﻐﺮ ﻭﺣﻞ ﺍﻟﻤﺴﺎﺋﻞ ﺍﻟﺼﻐﻴﺮﺓ ﻭﺩﻣﺞ ﺍﻟﻨﻮﺍﺗﺞ ﻟﻠﺤﺼﻮﻝ ﻋﻠﻰ ﺍﻟﻨﺎﺗﺞ ﺍﻟﻨﻬﺎﺋﻲ‪.‬‬

‫‪Quick Sort‬‬ ‫ﺍﻟﻔﺮﺯ ﺍﻟﺴﺮﻳﻊ‬

‫ﺗﺘﻢ ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ ﺍﻟﺴﺮﻳﻊ ﺑﺎﻟﺨﻄﻮﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪ (1‬ﻳﺘﻢ ﺍﺧﺘﻴﺎﺭ ﻗﻴﻤﺔ ﻣﻦ ﺩﺍﺧﻞ ﺍﻟﻤﺼﻔﻮﻓﺔ ﺑﺸﻜﻞ ﻋﺸﻮﺍﺋﻲ‬
‫‪ (2‬ﻳﺘﻢ ﻣﻘﺎﺭﻧﺔ ﺟﻤﻴﻊ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ ﻣﻊ ﻫﺬﻩ ﺍﻟﻘﻴﻤﺔ ﻓﺈﺫﺍ ﻛﺎﻧﺖ )ﺃ( ﻗﻴﻤﺔ ﺍﻟﺨﻠﻴﺔ ﺃﺻﻐﺮ ﺃﻭ‬
‫ﺗﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺗﻮﺿﻊ ﻓﻲ ﺍﻟﺠﺰﺀ ﺍﻷﻭﻝ ﻭﺇﺫﺍ ﻛﺎﻧﺖ )ﺏ( ﻗﻴﻤﺔ ﺍﻟﺨﻠﻴﺔ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺃﻛﺒﺮ ﻣﻦ‬
‫ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺨﺘﺎﺭﺓ ﺗﻮﺿﻊ ﻓﻲ ﺍﻟﺠﺰﺀ ﺍﻟﺜﺎﻧﻲ‬
‫‪ (3‬ﺗﺘﻢ ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ ﺍﻟﺴﺮﻳﻊ ﻋﻠﻰ ﺍﻟﺠﺰﺀ ﺍﻷﻭﻝ ﺇﺫﺍ ﻛﺎﻧﺖ ﻓﻴﻪ ﺃﻛﺜﺮ ﻣﻦ ﺧﻠﻴﺔ‬
‫‪ (4‬ﺗﺘﻢ ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ ﺍﻟﺴﺮﻳﻊ ﻋﻠﻰ ﺍﻟﺠﺰﺀ ﺍﻟﺜﺎﻧﻲ ﺇﺫﺍ ﻛﺎﻧﺖ ﻓﻴﻪ ﺃﻛﺜﺮ ﻣﻦ ﺧﻠﻴﺔ‬

‫ﺗﻼﺣﻆ ﺃﻥ ﻋﻤﻠﻴﺔ ﺍﻟﻔﺮﺯ ﺍﻟﺴﺮﻳﻊ ﺗﺴﺘﺪﻋﻲ ﻧﻔﺴﻬﺎ ﺑﺸﻜﻞ ﺇﺭﺟﺎﻋﻲ ﻟﺬﻟﻚ ﺳﻴﻜﻮﻥ ﺍﻟﺠﻮﺍﺏ ﻛﻤﺎ‬
‫ﻳﻠﻲ‪:‬‬
‫)‪RECURSIVESUBROUTINEQuickSort(A, first, last‬‬
‫‪INTEGER :: first, last‬‬
‫‪INTEGER, DIMENSION(first:last) :: A‬‬
‫‪INTEGER :: i, j, chosen, t‬‬

‫)‪k = first + RAND()*(last-first+1‬‬

‫)‪chosen = A(k‬‬
‫|‪(D)29‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫‪i = first‬‬
‫‪j = last‬‬
‫‪DO‬‬
‫)‪DOWHILE (A(i)<=chosen‬‬
‫‪i = i+1‬‬
‫‪ENDDO‬‬

‫)‪DOWHILE (A(j)>chosen .AND. j>first‬‬

‫‪j = j-1‬‬
‫‪ENDDO‬‬

‫‪IF (i<j) THEN‬‬

‫)‪t = A(i‬‬
‫)‪A(i) = A(j‬‬
‫‪A(j) = t‬‬
‫‪ELSE‬‬
‫‪EXIT‬‬
‫‪ENDIF‬‬
‫‪ENDDO‬‬

‫)‪IF (first<j) CALLQuickSort(A(first:j), first, j‬‬

‫)‪IF (i<last) CALLQuickSort(A(i:last), i, last‬‬
‫‪ENDSUBROUTINE‬‬

‫‪PROGRAMmain‬‬
‫)‪INTEGER :: x(6‬‬
‫)‪x = (/3,4,7,1,2,-3/‬‬
‫‪PRINT *, x‬‬
‫)‪CALLQuickSort(x, 1, 6‬‬
‫‪PRINT *, x‬‬
‫‪END‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺍﻟﺪﺍﻟﺔ )(‪ RAND‬ﺗﻌﻄﻲ ﻋﺪﺩ ﻋﺸﻮﺍﺋﻲ ﺑﻴﻦ ﺍﻟﺼﻔﺮ ﻭﺍﻟﻮﺍﺣﺪ‪ ،‬ﻭﻗﺪ ﺍﺳﺘﺨﺪﻣﺖ ﻓﻲ‬
‫ﺍﺧﺘﻴﺎﺭ ﺧﻠﻴﺔ ﺑﺸﻜﻞ ﻋﺸﻮﺍﺋﻲ ﻓﻲ ﺍﻟﻤﺼﻔﻮﻓﺔ‪.‬‬

‫ﺷﺮﺡ ﺍﻟﺒﺮﻧﺎﻣﺞ‪ :‬ﻳﺘﻢ ﻓﻲ ﺍﻟﺒﺪﺍﺋﻴﺔ ﺍﺧﺘﻴﺎﺭ ﺧﻠﻴﺔ ﺑﺸﻜﻞ ﻋﺸﻮﺍﺋﻲ ﻣﻦ ﺑﻴﻦ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ‪ ،‬ﺛﻢ‬
‫ﻳﺴﺘﺨﺪﻡ ﻣﺆﺷﺮ ﻳﺆﺷﺮ ﺇﻟﻰ ﺑﺪﺍﻳﺔ ﺍﻟﻤﻨﻄﻘﺔ ﺍﻟﻤﺮﺍﺩ ﺗﺮﺗﻴﺒﻬﺎ ﻭﻣﺆﺷﺮ ﻳﺆﺷﺮ ﺇﻟﻰ ﻧﻬﺎﻳﺔ ﻫﺬﻩ ﺍﻟﻤﻨﻄﻘﺔ‪،‬‬
‫ﻳﺘﻘﺪﻡ ﺍﻟﻤﺆﺷﺮ ﺍﻷﻭﻝ ﺣﺘﻰ ﻳﺼﻞ ﺇﻟﻰ ﻗﻴﻤﺔ ﺃﻛﺒﺮ ﻣﻦ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺨﺘﺎﺭﺓ )ﻗﻴﻤﺔ ﻓﻲ ﺍﻟﺠﺰﺀ ﺍﻷﻭﻝ ﻟﻴﺴﺖ‬
‫ﻓﻲ ﻣﻜﺎﻧﻬﺎ( ﺛﻢ ﻳﺘﺮﺍﺟﻊ ﺍﻟﻤﺆﺷﺮ ﺍﻟﺜﺎﻧﻲ ﺣﺘﻰ ﻳﺼﻞ ﺇﻟﻰ ﻗﻴﻤﺔ ﺃﺻﻐﺮ ﺃﻭ ﺗﺴﺎﻭﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﺨﺘﺎﺭﺓ‬
‫)ﻗﻴﻤﺔ ﻓﻲ ﺍﻟﺠﺰﺀ ﺍﻟﺜﺎﻧﻲ ﻟﻴﺴﺖ ﻓﻲ ﻣﻜﺎﻧﻬﺎ( ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﺘﻢ ﺗﻌﻮﻳﺾ ﻫﺎﺗﻴﻦ ﺍﻟﻘﻴﻤﺘﻴﻦ؛ ﻭﺗﺴﺘﻤﺮ ﻫﺬﻩ‬
‫ﺍﻟﻌﻤﻠﻴﺔ ﺣﺘﻰ ﺗﺘﻢ ﻋﻠﻰ ﺟﻤﻴﻊ ﺧﻼﻳﺎ ﺍﻟﻤﺼﻔﻮﻓﺔ‪ .‬ﻭﻓﻲ ﺍﻟﻨﻬﺎﻳﺔ ﺇﺫﺍ ﻛﺎﻥ ﻛﻞ ﻣﻦ ﺍﻟﺠﺰﺀ ﺍﻷﻭﻝ ﻭﺍﻟﺠﺰﺀ‬
‫ﺍﻟﺜﺎﻧﻲ ﻓﻴﻪ ﺃﻛﺜﺮ ﻣﻦ ﺧﻠﻴﺔ ﻳُﺮﺳﻞ ﺇﻟﻰ ﺍﻟﺒﺮﻧﺎﻣﺞ ﺍﻟﻔﺮﻋﻲ ﻧﻔﺴﻪ ﻟﻴﺮﺗﺒﻪ‪.‬‬

‫ﺍﻟﻄﺒﺎﻋﺔ‪Format Specification‬‬ ‫ﺻﻴﻎ‬

‫ﺇﻥ ﻟﻐﺔ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻣﻦ ﺃﻛﺜﺮ ﺍﻟﻠﻐﺎﺕ ﺍﻫﺘﻤﺎﻣﺎ ﺑﺸﻜﻞ ﺍﻟﻨﺎﺗﺞ ﻭﻫﻲ ﺗﻌﻄﻲ ﺍﻟﻤﺒﺮﻣﺞ ﻭﺳﺎﺋﻞ ﻭﺍﺳﻌﺔ‬
‫ﻟﻠﺘﺤﻜﻢ ﺑﻄﺒﺎﻋﺔ ﻧﺎﺗﺞ ﺍﻟﺒﺮﻧﺎﻣﺞ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ‪.‬‬
‫ﻭﻳﺘﻢ ﺍﻟﺘﺤﻜﻢ ﻋﻠﻰ ﻃﺒﺎﻋﺔ ﺍﻟﻨﺎﺗﺞ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻗﻴﻤﺔ ﻧﺼﻴﺔ ﺗﻜﺘﺐ ﻣﺒﺎﺷﺮﺓ ﺑﻌﺪ ﻛﻠﻤﺔ ‪ print‬ﻓﻲ ﺟﻤﻠﺔ‬
‫|‪(D)30‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﻄﺒﺎﻋﺔ ﻋﻮﺿﺎ ﻋﻦ ﻋﻼﻣﺔ ﺍﻟﻨﺠﻤﺔ ﻓﻔﻲ ﺣﺎﻟﺔ ﻛﺘﺎﺑﺔ ﺟﻤﻠﺔ ﺍﻹﺧﺮﺍﺝ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪ ...‬ﺗﻌﺒﻴﺮ ﺛﺎﻧﻲ ‪,‬ﺗﻌﺒﻴﺮ ﺃﻭﻝ ‪print *,‬‬
‫ﻣﺜﻼً‪:‬‬
‫"‪print *, 22, " birds‬‬
‫ﺳﻮﻑ ﻳﻄﺒﻊ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻗﻴﻢ ﺍﻟﺘﻌﺎﺑﻴﺮ ﻣﺘﺘﺎﻟﻴﺔ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻃﺮﻳﻘﺘﻪ ﺍﻻﻓﺘﺮﺍﺿﻴﺔ ﻓﻴﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ‬
‫ﺍﻟﻌﺪﺩ ﺍﻟﺼﺤﻴﺢ ‪ 11‬ﺧﺎﻧﺔ )ﻋﻤﻮﺩ( ﻣﻦ ﺍﻟﺴﻄﺮ ﺍﻟﺤﺎﻟﻲ ﻓﻲ ﺍﻟﺸﺎﺷﺔ ﻭﻳﻄﺒﻊ ﺍﻟﻌﺪﺩ ‪ 22‬ﻓﻲ ﺍﻟﺠﻬﺔ‬
‫ﺍﻟﻴﻤﻨﻰ ﻣﻦ ﻫﺬﻩ ﺍﻟﺨﺎﻧﺎﺕ ﺛﻢ ﻳﺴﺘﺨﺪﻡ ﺧﺎﻧﺎﺕ ﺑﻘﺪﺭ ﺣﺮﻭﻑ ﺍﻟﻨﺺ )ﺳﺘﺔ ﺧﺎﻧﺎﺕ ﻷﻥ ﺍﻟﺤﺮﻑ ﺍﻷﻭﻝ‬
‫ﻓﻲ ﻫﺬﺍ ﺍﻟﻨﺺ ﻫﻮ ﺍﻟﻔﺮﺍﻍ( ﻭﻳﻄﺒﻊ ﻓﻴﻬﺎ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻨﺼﻴﺔ‪.‬‬

‫ﻭﻳﻤﻜﻦ ﺍﻟﺘﺤﻜﻢ ﺑﻬﺬﻩ ﺍﻟﺘﻔﺎﺻﻴﻞ ﻣﻦ ﺧﻼﻝ ﺻﻴﻎ ﺍﻟﻄﺒﺎﻋﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪ (1‬ﺻﻴﻐﺔ ‪i‬ﻭﺗﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ ﺍﻟﻘﻴﻢ ﺍﻟﻨﺼﻴﺔ ﻭﺗﺄﺧﺬ ﺍﻟﺸﻜﻞ ‪) in‬ﻣﺜﻼً ‪ i5‬ﺃﻭ ‪ (i2‬ﺣﻴﺚ ﻳﺤﺪﺩ‬
‫ﺍﻟﻌﺪﺩ ‪ n‬ﻋﺪﺩ ﺍﻟﺨﺎﻧﺎﺕ ﺍﻟﺘﻲ ﻳﺤﺘﻠﻬﺎ ﺍﻟﺮﻗﻢ ﺃﺛﻨﺎﺀ ﺍﻟﻄﺒﺎﻋﺔ‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪n = 120‬‬
‫‪m=8‬‬
‫‪print "(i3, i2)", n, m/4‬‬
‫ﺳﻮﻑ ﻳﻄﺒﻊ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﻗﻴﻤﺔ ﺍﻟﻤﺘﻐﻴﺮ ‪ n‬ﻓﻲ ﺛﻼﺛﺔ ﺧﺎﻧﺎﺕ ﻭﺑﻌﺪﻫﺎ ﺳﻮﻑ ﻳﻄﺒﻊ ﻓﻲ ﺧﺎﻧﺘﻴﻦ ﻗﻴﻤﺔ‬
‫ﺍﻟﺘﻌﺒﻴﺮ ‪ ،.m/4‬ﻫﻜﺬﺍ‪:‬‬
‫‪1‬‬ ‫‪2‬‬ ‫‪0‬‬ ‫‪2‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺇﺫﺍ ﻛﺎﻧﺖ ﻋﺪﺩ ﺍﻟﺨﺎﻧﺎﺕ ﺍﻟﻤﺤﺪﺩﺓ ﻟﻠﻄﺒﺎﻋﺔ ﻻ ﺗﻜﻔﻲ ﻟﻄﺒﺎﻋﺔ ﺍﻟﺘﻌﺒﻴﺮ ﺳﻴﻄﺒﻊ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ‬
‫ﻧﺠﻤﺎﺕ ﺑﺤﺠﻢ ﺍﻟﺤﻘﻞ ﺍﻟﻤﺨﺼﺺ ﻟﺘﺒﻴﻴﻦ ﺣﺪﻭﺙ ﻫﺬﺍ ﺍﻟﺨﻄﺄ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﺗﻜﺘﺐ ﺻﻴﻎ ﺍﻟﻄﺒﺎﻋﺔ ﻛﻘﻴﻤﺔ ﻧﺼﻴﺔ ﺣﺮﻓﻬﺎ ﺍﻷﻭﻝ ﻭﺍﻷﺧﻴﺮ ﻫﻮ ﻓﺘﺢ ﻭﻏﻠﻖ ﺃﻗﻮﺍﺱ‪.‬‬

‫‪ (2‬ﺻﻴﻐﺔ ‪ f‬ﻭﺗﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ ﺍﻟﺘﻌﺎﺑﻴﺮ ﺍﻟﺤﻘﻴﻘﻴﺔ ﻭﺗﺄﺧﺬ ﺍﻟﺸﻜﻞ ‪ fn.m‬ﺣﻴﺚ ﻳﺤﺪﺩ ﺍﻟﻌﺪﺩ ‪ n‬ﻋﺪﺩ‬
‫ﺍﻟﺨﺎﻧﺎﺕ ﺍﻟﻜﻠﻲ ﺍﻟﻤﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ ﺍﻟﺘﻌﺒﻴﺮ ﻭﻳﺤﺪﺩ ﺍﻟﻌﺪﺩ ‪ m‬ﻋﺪﺩ ﺍﻟﺨﺎﻧﺎﺕ ﺍﻟﺘﻲ ﺗﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ‬
‫ﺍﻟﺠﺰﺀ ﺍﻟﻌﺸﺮﻱ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪a = 3.14‬‬
‫‪b = 34127.19‬‬
‫‪print "(f6.1, f6.1)", a, b‬‬
‫ﺳﻮﻑ ﻳﻄﺒﻊ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪3‬‬ ‫‪.‬‬ ‫‪1‬‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬

‫‪ (3‬ﺻﻴﻐﺔ ‪ /‬ﻭﺗﺴﺘﺨﺪﻡ ﻟﻨﻘﻞ ﺍﻟﻄﺒﺎﻋﺔ ﺇﻟﻰ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪m = 712‬‬
‫‪x = 2.5‬‬
‫‪print "(i5, /, f6.1)", m, x‬‬
‫ﺳﻮﻑ ﻳﻄﺒﻊ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪7‬‬ ‫‪1‬‬ ‫‪2‬‬
‫‪2‬‬ ‫‪.‬‬ ‫‪5‬‬

‫‪ (4‬ﺻﻴﻐﺔ ‪ a‬ﻭﺗﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ ﺍﻟﻘﻴﻢ ﺍﻟﻨﺼﻴﺔ ﻭﺗﺄﺧﺬ ﺍﻟﺸﻜﻞ ‪ an‬ﺣﻴﺚ ﻳﺤﺪﺩ ‪ n‬ﻋﺪﺩ ﺍﻟﺨﺎﻧﺎﺕ‬
‫ﺍﻟﺘﻲ ﺗﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ ﺍﻟﻨﺺ‪ ،‬ﻭﻓﻲ ﺣﺎﻟﺔ ﻋﺪﻡ ﺫﻛﺮ ﺍﻟﻌﺪﺩ ‪ n‬ﻓﺈﻥ ﺍﻟﻔﻮﺭﺗﺮﺍﻥ ﺳﻮﻑ ﻳﻄﺒﻊ ﺍﻟﻨﺺ ﺑﻌﺪﺩ‬
‫|‪(D)31‬‬ ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ ‪Fortran 90‬‬

‫ﺍﻟﺤﺮﻭﻑ ﺍﻟﻤﺨﺼﺼﺔ ﻟﻠﻤﺘﻐﻴﺮ ﺍﻟﻨﺼﻲ‪.‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪x = 2.3‬‬
‫‪y = -12.2‬‬
‫‪print "(a, f6.2, /, a, f6.2)", "x = ", y, "y = ", y‬‬
‫ﺳﻮﻑ ﻳﻄﺒﻊ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪X‬‬ ‫=‬ ‫‪2‬‬ ‫‪.‬‬ ‫‪3‬‬ ‫‪0‬‬
‫‪Y‬‬ ‫=‬ ‫‪-‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪.‬‬ ‫‪2‬‬ ‫‪0‬‬

‫ﺃﻣﺜﻠﺔ ﻋﺎﻣﺔ‬
‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎ ﻟﺤﺴﺎﺏ ﺃﻛﺒﺮﻋﺎﻣﻠﻤﺸﺘﺮﻙ )‪.(Greatest Common Divisor‬ﻫﻨﺎﻟﻚ‬
‫ﻃﺮﻳﻘﺔ ﻟﺤﺴﺎﺏ ﺃﻛﺒﺮ ﻋﺎﻣﻞ ﻣﺸﺘﺮﻙ ﻣﻌﺮﻭﻓﺔ ﺑﺎﺳﻢ ﻃﺮﻳﻘﺔ ﺍﻗﻠﻴﺪﺱ ﻫﻲ )ﺑﻌﺪ ﺗﻐﻴﻴﺮ ﻟﻠﺘﺴﻬﻴﻞ(‪:‬‬

‫{‬
‫‪a‬‬ ‫‪if a = b‬‬
‫(‬ ‫)‬
‫= ‪GCD a, b‬‬ ‫‪GCD(b,‬‬ ‫‪a‬‬ ‫‪-‬‬ ‫)‪b‬‬ ‫‪if a > b‬‬
‫‪GCD(a,b - a) if a < b‬‬

‫ﻓﻤﺜﻼ ﻟﺤﺴﺎﺏ ﺍﻛﺒﺮ ﻋﺎﻣﻞ ﻣﺸﺘﺮﻙ ﻟﻠﻌﺪﺩﻳﻦ ‪ 72‬ﻭ ‪:60‬‬

‫‪GCD(72, 60) → GCD(60, 12) → GCD(12, 48) → GCD(12, 36) → GCD(12,‬‬
‫‪24) → GCD(12, 12) → 12‬‬
‫ﺳﺆﺍﻝ‪ :‬ﻣﺎ ﻫﻮ ﺳﺒﺐ ﺻﺤﺔ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ؟‬

‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﺑﺎﻟﻔﻮﺭﺗﺮﺍﻥ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫‪integer :: a, b‬‬

‫" = ‪print *, "A‬‬

‫‪read *, a‬‬
‫" = ‪print *, "B‬‬
‫‪read *, b‬‬

‫‪do‬‬
‫‪if (a > b)then‬‬
‫‪a=a–b‬‬
‫‪elseif (a < b) then‬‬
‫‪b=b–a‬‬
‫‪else‬‬
‫‪exit‬‬
‫‪endif‬‬
‫‪enddo‬‬

‫‪print *, "GCD of them = ", a‬‬

‫‪end‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺍﻛﺘﺐ ﺑﺮﻧﺎﻣﺠﺎً ﻟﺤﻞ ﺍﻟﻤﻌﺎﺩﻟﺔ ﻣﻦ ﺍﻟﺪﺭﺟﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪2‬‬
‫‪+ bx + c = 0x a‬‬
‫ﺍﻟﺠﻮﺍﺏ‪:‬‬
‫ﻓﻲ ﻛﺘﺎﺑﺔ ﺍﻟﺒﺮﺍﻣﺞ ﻳﺠﺐ ﺩﺍﺋﻤﺎً ﺍﻟﺘﻔﻜﻴﺮ ﻟﺠﻤﻴﻊ ﺍﻟﺤﺎﻻﺕ ﺍﻟﺘﻲ ﻣﻦ ﺍﻟﻤﻤﻜﻦ ﺃﻥ ﺗﺤﺼﻞ ﻭﺇﻳﺠﺎﺩ‬
‫ﺍﻟﺤﻠﻮﻝ ﻟﻬﺎ‪.‬‬
(D)32| Fortran 90 ‫ﻟﻐﺔ ﺍﻟﺒﺮﻣﺠﺔ‬

PROGRAM QuadraticEquation
IMPLICITNONE

REAL :: a, b, c
REAL :: d, d2
REAL :: x1, x2

READ *, a, b, c

d2 = b*b - 4.0*a*c

IF (a == 0.0) THEN
IF (b == 0.0) THEN
IF (c == 0.0) THEN
PRINT *, "All numbers are roots"
ELSE
PRINT *, "Unsolvable equation"
ENDIF
ELSE
PRINT *, "This is linear equation, root = ", -c/b
ENDIF

ELSEIF (d2 > 0.0) THEN

d = SQRT(d2)
x1 = (-b + d)/(2.0*a)
x2 = (-b - d)/(2.0*a)
PRINT *, "Roots are ", x1, " and ", x2
ELSEIF (d2 == 0.0) THEN
PRINT *, "The repeated root is ", -b/(2.0*a)
ELSE
PRINT *, "There is no real roots!"
ENDIF

ENDPROGRAM QuadraticEquation