‫‪ ‬‬ ‫ﺑﻪ ﻧﺎم ﺧﺪا‬

‫ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺧﻄﻲ و ﻏﻴﺮﺧﻄﻲ در‬

‫ﻣﺘﻤﺘﻴﻜﺎ‪   6.0‬‬
‫‪ ‬‬
‫‪ ‬‬
‫اﻣﻴﺮ ﻣﺴﻌﻮد ﻋﺒﺪل ‪ ‬‬
‫ﺗﺎﺑﺴﺘﺎن ‪  1387‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬ ‫‪ ‬‬

‫‪ ‬‬
 ‫ﻣﻘﺪﻣﻪ‬
‫اﻣﺮوزه ﻧﺮم اﻓﺰارﻫﺎي ﺑﺴﻴﺎري ﺑﺮاي اﻧﺠﺎم ﻋﻤﻠﻴﺎت رﻳﺎﺿﻲ ﺗﻮﻟﻴﺪ ﺷﺪه اﻧﺪ ﻛﻪ از ﺑﺮﺟﺴﺘﻪ ﺗﺮﻳﻦ و ﺳﺮﻳﻊ ﺗﺮﻳﻦ و اﻧﻌﻄﺎف‬
‫ﭘﺬﻳﺮﺗﺮﻳﻦ آﻧﻬﺎ ﻣﻴﺘﻮان ﺑﻪ ﻣﺘﻤﺘﻴﻜﺎ‪ 1‬اﺷﺎره ﻛﺮد‪.‬‬

‫اﻣﺮوزه ﺣﻞ ﻣﺴﺎﺋﻞ ﺧﻄﻲ و ﻏﻴﺮﺧﻄﻲ از اﻫﻤﻴﺖ ﺧﺎﺻﻲ ﺑﺮﺧﻮردار اﺳﺖ‪ ،‬ﻛﻪ اﻟﺒﺘﻪ ﺣﻞ ﻣﺴﺎﺋﻞ ﺧﻄﻲ ﻣﺪﺗﻲ اﺳﺖ ﻛﻪ ﺗﺎ‬
‫اﻧﺘﻬﺎي راه رﻓﺘﻪ اﺳﺖ و روش ﻫﺎي ﻣﺘﻌﺪدي ﺑﺮاي آن اﺑﺪاع ﺷﺪه اﺳﺖ و در اﻛﺜﺮ ﻧﺮم اﻓﺰارﻫﺎي رﻳﺎﺿﻲ و ﻣﻬﻨﺪﺳﻲ‬
‫اﻟﮕﻮرﻳﺘﻤﻬﺎ و ﺗﻮاﺑﻌﻲ ﻧﻴﺰ ﺑﺮاي ﺣﻞ آﻧﻬﺎ ﻗﺮار داده ﺷﺪه اﺳﺖ‪.‬‬

‫در ﻣﺘﻤﺘﻴﻜﺎ ﻧﻴﺰ دﺳﺘﻮراﺗﻲ ﺑﺮاي ﺣﻞ اﻳﻦ دو دﺳﺘﻪ ﻣﻌﺎدﻟﻪ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ ﺑﻪ ﺗﻮﺿﻴﺢ آﻧﻬﺎ ﻣﻴﭙﺮدازﻳﻢ‪.‬‬

‫‪                                                              ‬‬
‫‪1‬‬ ‫‪ Mathematica ‬‬
 ‫‪LinearProgramming‬‬ ‫دﺳﺘﻮر‬
‫ﺑﻪ ‪ 7‬روش ﻓﺮاﺧﻮاﻧﻲ ﻣﻴﺸﻮد ﻛﻪ ﺑﻪ ﺗﻮﺿﺢ آﻧﻬﺎ ﻣﻴﭙﺮدازﻳﻢ‪:‬‬ ‫دﺳﺘﻮر‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ﺑﺎ ‪ 3‬ورودي ﻓﺮاﺧﻮاﻧﻲ ﻣﻴﺸﻮد ﻛﻪ ‪ c‬ﺿﺮاﻳﺐ ﺗﺎﺑﻊ ﻫﺪف اﺳﺖ‪،‬‬ ‫‪.1‬‬
‫‪ m‬ﻣﺎﺗﺮﻳﺴﻲ ﻛﻪ ﻧﺸﺎن دﻫﻨﺪه ﺿﺮاﺋﺐ ﻣﺤﺪودﻳﺖ ﻫﺎ و ‪ b‬ﻧﺸﺎن دﻫﻨﺪه ﻃﺮف راﺳﺖ ﻣﺤﺪودﻳﺘﻬﺎ اﺳﺖ‪.‬‬

‫‪.‬‬ ‫و‬ ‫را ﺑﺎ اﺳﺘﻔﺎده از ﻣﺤﺪودﻳﺘﻬﺎ‬ ‫و ﺧﺮوﺟﻲ دﺳﺘﻮر ﺑﺮداري اﺳﺖ ﻛﻪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ ﺷﺪه ﻣﺴﺌﻠﻪ‬
‫ﺑﺮاي ﻣﺜﺎل‪:‬‬

‫و ﻣﺘﻐﻴﺮﻫﺎي ﻧﺎﻣﻨﻔﻲ‪:‬‬ ‫ﺑﺎ ﻣﺤﺪودﻳﺘﻬﺎي‬ ‫ﺑﺮاي ﻣﻴﻨﻤﻴﻤﻢ ﻛﺮدن ﻣﺴﺌﻠﻪ‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ﺣﺎﻟﺖ ﺗﻜﻤﻴﻞ ﺷﺪه اي ﺑﺮاي‬ ‫‪.2‬‬

‫دﺳﺘﻮر ﺑﺎﻻ اﺳﺖ ﻛﻪ اﻣﻜﺎن اﻧﺘﺨﺎب ﻧﻮع ﻧﺎﻣﺴﺎوي را ﺑﺮاي ﻣﺤﺪوﻳﺘﻬﺎ ﺑﻪ ﻣﺎ ﻣﻴﺪﻫﺪ‪ ،‬ﺑﻪ اﻳﻦ ﻣﻌﻨﺎ ﻛﻪ ﻣﻴﺘﻮاﻧﻴﻢ ﺑﺮاي ﻫﺮﻳﻚ‬
‫از ﻣﺤﺪودﻳﺘﻬﺎ ﻣﻌﻴﻦ ﻛﻨﻴﻢ ﻛﻪ ﻧﺎﻣﺴﺎوي ﻛﻮﭼﻜﺘﺮ ﻣﺴﺎوي اﺳﺖ ﻳﺎ ﺑﺰرﮔﺘﺮ ﻣﺴﺎوي و ﻳﺎ ﻣﺴﺎوي‪ .‬ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﻣﻴﺒﻴﻨﻴﺪ ‪2‬‬
‫ﻣﺎﻧﻨﺪ ﺑﺎﻻ وﺟﻮد دارﻧﺪ و ﻫﻤﺎن ﻣﻌﻨﺎ را ﻧﻴﺰ دارﻧﺪ وﻟﻲ ﺑﺮاي وارد ﻛﺮدن ﻃﺮف راﺳﺖ ﻣﺤﺪودﻳﺘﻬﺎ ﻛﻪ در‬ ‫و‬ ‫ورودي‬
‫ﺑﺎﻻ ﻫﻤﮕﻲ ﺑﻪ ﺻﻮرت ﺑﺰرﮔﺘﺮ و ﻣﺴﺎوي ﺑﻮدﻧﺪ و ﻓﻘﻂ ﻳﻚ ﺑﺮدار آﻧﻬﺎ را ﻣﺸﺨﺺ ﻣﻴﻜﺮد روش دﻳﮕﺮي ﺑﻴﺎن ﺷﺪه اﺳﺖ‪.‬‬
‫اﺳﺖ‬ ‫ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ ﺑﺮدار را ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﺎﺗﺮﻳﺲ ‪ n‬در ‪ 2‬وارد ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﻫﺮ ﺳﻄﺮ آن ﺑﻪ ﺻﻮرت‬
‫ﻛﻪ ﻣﻮﻟﻔﻪ اول ﻧﺸﺎن دﻫﻨﺪه ﻣﻘﺪار ﻃﺮف راﺳﺖ ﻣﺤﺪودﻳﺖ ‪j‬ام و ﻣﻮﻟﻔﻪ دوم ﻧﺸﺎن دﻫﻨﺪه ﻧﻮع ﻣﺤﺪودﻳﺖ اﺳﺖ‪ ،‬ﺑﺮاي‬
‫ﺑﺰرﮔﺘﺮ و ﻧﺎﻣﺴﺎوي ﻋﺪد ‪1‬؛ ﺑﺮاي ﻣﺴﺎوي ‪0‬؛ و ﺑﺮاي ﻛﻮﭼﻜﺘﺮ و ﻣﺴﺎوي ‪ -1‬را وارد ﻣﻴﻜﻨﻴﻢ‪ .‬ﻣﺜﻼً‪:‬‬

‫دﺳﺘﻮري ﺑﻪ ﺻﻮرت زﻳﺮ را دارﻳﻢ‪:‬‬ ‫ﺑﺎ ﻣﺤﺪودﻳﺖ‬ ‫ﺑﺮاي ﺣﻞ ﻣﺴﺌﻠﻪ‬

‫ﺑﺎﺷﺪ دﺳﺘﻮر ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻴﺸﻮد‪:‬‬ ‫و ﻳﺎ اﮔﺮ ﻣﺤﺪوﻳﺖ ﺑﻪ ﺻﻮرت‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ﻧﻴﺰ ﺷﺒﺎﻫﺖ ﺑﺴﻴﺎري ﺑﺎ دﺳﺘﻮر اول دارد و ﺗﻨﻬﺎ ﺗﻔﺎوت‬ ‫‪.3‬‬
‫ﺑﻪ ﺟﻤﻊ ورودي ﻫﺎ اﺳﺖ ﻛﻪ ﻫﻤﺎﻧﻄﻮر ﻛﻪ در روﻧﺪ ﭘﻴﺸﺮﻓﺖ دﺳﺘﻮرﻫﺎ ﻣﺸﺎﻫﺪه ﻛﺮدﻳﺪ‪ ،‬ﻫﺮ‬ ‫اﺿﺎﻓﻪ ﺷﺪن ورودي‬
‫ﺑﺮاي وارد ﻛﺮدن ﻣﻘﺪار ﻗﺎﺑﻞ ﻗﺒﻮل ﺑﺮاي ﻣﺘﻐﻴﻴﺮﻫﺎي‬ ‫دﺳﺘﻮر اﻣﻜﺎن ﺑﻴﺸﺘﺮي را ﺑﺮاي ﭘﻴﺎده ﻛﺮدن ﻣﺪل ﺑﻪ ﻣﺎ ﻣﻴﺪﻫﺪ‪،‬‬
‫ﻫﻤﻪ ﻣﺘﻐﻴﻴﺮﻫﺎ ﻣﻘﺪار ﺑﺰرﮔﺘﺮ از آن ﻣﻘﺪار را‬ ‫ﻣﻮﺟﻮد اﺳﺖ‪ ،‬ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ ﺑﺎ وارد ﻛﺮدن ﻋﺪدي ﺣﻘﻴﻘﻲ ﺑﻪ ﺟﺎي‬
‫‪.‬‬ ‫ﻗﺒﻮل ﻣﻴﻜﻨﻨﺪ‪ ،‬ﻳﻌﻨﻲ‪:‬‬
 ‫ﻣﺜﻼً ﺑﺮاي ﻣﺜﺎل ﻣﻄﺮح ﺷﺪه در ﺣﺎﻟﺖ اول اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﻣﺘﻐﻴﻴﺮﻫﺎ اﻋﺪادي ﺑﺰرﮔﺘﺮ از ‪ -2‬را اﺧﺘﻴﺎر ﻛﻨﻨﺪ دﺳﺘﻮر را ﺑﻪ‬
‫ﺻﻮرت زﻳﺮ ﺗﻐﻴﻴﺮ ﻣﻴﺪﻫﻴﻢ‪:‬‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ﺑﻬﻴﻨﻪ ﺷﺪه دﺳﺘﻮر ﺑﺎﻻ اﺳﺖ ﻛﻪ اﻣﻜﺎن ﻣﻴﺪﻫﺪ‬ ‫‪.4‬‬
‫ﻛﻪ ﻣﻘﺪار اوﻟﻴﻪ ﻫﺮ ﻣﺘﻐﻴﻴﺮ را ﺑﺮاي آن ﺑﻪ ﻃﻮر ﺧﺎص ﻣﺸﺨﺺ ﻛﻨﻴﻢ‪ ،‬ﻳﻌﻨﻲ ﻫﺮ ﻛﺪام از ﻫﺎ ﻧﺸﺎن ﺗﺸﻜﻴﻞ دﻫﻨﺪه ﻧﺎﻣﻌﺎدﻟﻪ‬
‫آﻧﮕﺎه دارﻳﻢ‪:‬‬ ‫و‬ ‫ﻫﺴﺘﻨﺪ‪ .‬ﺑﺮاي ﻣﺜﺎل ﻓﻮق اﮔﺮ ﺑﺨﻮاﻳﻢ‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ﺗﻮاﻧﺎﻳﻲ ﺑﺴﻴﺎر ﻣﻔﻴﺪي را ﺑﺮاي‬ ‫‪.5‬‬

‫ﻣﺎ ﺑﻪ ارﻣﻐﺎن ﻣﻲ آورد ﻛﻪ ﻣﺎ را در ﭘﻴﺎده ﺳﺎزي ﻣﺪﻟﻬﺎي ﭘﻴﭽﻴﺪه ﺗﺮ ﺗﻮاﻧﺎﺗﺮ ﻣﻴﻜﻨﺪ‪ ،‬ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ ﺑﻌﺪ از وارد ﻛﺮدن‬
‫ﻣﺘﻐﻴﻴﺮﻫﺎي اﺻﻠﻲ ﻳﻌﻨﻲ ‪ c,m,b‬ﻣﺎ ﻣﺎﺗﺮﻳﺴﻲ را ﺑﺎ ‪ 2‬ﺳﺘﻮن ﻫﻤﺎﻧﻨﺪ ﺣﺎﻟﺖ ‪ 2‬وارد ﻣﻴﻜﻨﻴﻢ‪ ،‬اﻟﺒﺘﻪ اﻳﻨﺒﺎر ﺑﻪ ﺟﺎي‬
‫ﻛﻪ اﻣﻜﺎن وارد ﻛﺮدن ﻳﻚ ﺑﺎزه را ﺑﻪ ﻣﺎ ﺑﺮاي ﻫﺮﻳﻚ از ﻣﺘﻐﻴﻴﺮﻫﺎ ﺑﻪ ﻣﺎ ﻣﻴﺪﻫﺪ‪ ،‬ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ‬
‫ﺧﻮاﻫﺪ ﺑﻮد‪ .‬و اﻳﻦ ﻛﺎر را ﻣﻴﺘﻮاﻧﻴﻢ ﺑﺮاي ﻫﺮﻳﻚ از ﻣﺘﻐﻴﻴﺮﻫﺎ اﻧﺠﺎم دﻫﻴﻢ‪.‬‬ ‫ﻧﺸﺎن دﻫﻨﺪه ﻣﻌﺎدﻟﻪ‬

‫ﺣﻞ ﻛﻨﻴﻢ‪ ،‬آﻧﮕﺎه دارﻳﻢ‪:‬‬ ‫و‬ ‫ﺑﺮاي ﻣﺜﺎل ﻓﺮض ﻛﻨﻴﺪ ﻣﺴﺌﻠﻪ دﺳﺘﻮر اول را ﺑﺎ دو ﺷﺮط‬

‫‪ ‬‬
‫ﺗﺬﻛﺮ‪ :‬ﺑﺮاي ﻧﺸﺎن دادن ﻣﻘﺪار ﺑﻴﻨﻬﺎﻳﺖ در ﻣﺘﻤﺘﻴﻜﺎ از ﻋﺒﺎرت ‪ Infinity‬اﺳﺘﻔﺎده ﻣﻴﺸﻮد‪ ،‬ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ ﺑﺮاي اﻳﻨﻜﻪ‬
‫را ﺟﺎﻳﮕﺰﻳﻦ‬ ‫در دﺳﺘﻮر ‪ 5‬ﻋﺒﺎرت‬ ‫و‬ ‫ﻧﺸﺎن دﻫﻴﻢ ﻛﻪ‬
‫ﻣﻴﻜﻨﻴﻢ‪.‬‬

‫دارﻳﻢ‪:‬‬ ‫و‬ ‫ﺑﺎ ﺷﺮوط‬ ‫ﻣﺜﻼً ﺑﺮاي ﺣﻞ ﻣﺴﺌﻠﻪ‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ورودي ﻫﺎي اﺻﻠﻲ را ﺑﻪ ﻃﻮر ﻛﺎﻣﻞ دارد و در‬ ‫‪.6‬‬
‫اﻧﺘﻬﺎ ﻣﻘﺪار ورودي ‪ dom‬را ﻧﻴﺰ اﺿﺎﻓﻪ ﻛﺮده اﺳﺖ ﻛﻪ ﻧﺸﺎن دﻫﻨﺪه داﻣﻨﻪ اﻧﺘﺨﺎب ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮﻫﺎ اﺳﺖ‪ ،‬ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ ﻛﻪ‬
‫ﺟﻮاب دﺳﺘﮕﺎه از ﭼﻪ ﻧﻮع داده اي ﺑﺎﺷﺪ‪ Reals ،‬ﺑﺎﺷﺪ و ﻳﺎ ‪ .Integers‬ﻛﻪ در ﺻﻮرت اﻧﺘﺨﺎب ‪ Integers‬ﻣﺎ ﺑﺮﻧﺎﻣﻪ‬
‫رﻳﺰي ﺧﻄﻲ ﺻﺤﻴﺢ را ﺧﻮاﻫﻴﻢ داﺷﺖ‪.‬‬

‫ﺗﺬﻛﺮ‪ :‬اﻧﻮاع داده اي در ﻣﺘﻤﺘﻴﻜﺎ ﺑﻪ ﺻﻮرت ‪ Reals, Integers, Rationals, Complex‬ﻫﺴﺘﻨﺪ ﻛﻪ در اﻳﻨﺠﺎ دو ﻣﻘﺪار‬

‫‪ Real‬و ‪ Integer‬ﻣﻮرد ﻗﺒﻮل ﻫﺴﺘﻨﺪ‪.‬‬
‫ﺑﻪ ﻃﻮري ﻛﻪ ﺟﻮاب ﺻﺤﻴﺢ‬ ‫ﺑﺎ ﻣﺤﺪودﻳﺖ‬ ‫ﺑﺮاي ﻣﺜﺎل‪ :‬ﺑﺮاي ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﻪ ﺻﻮرت ﻣﻴﻨﻴﻤﻢ ﺳﺎزي‬
‫ﺑﺎﺷﺪ دارﻳﻢ‪:‬‬

‫‪ : ‬اﻳﻦ دﺳﺘﻮر ﻫﻤﺎﻧﻨﺪ ﻧﻤﻮﻧﻪ ﻫﺎي ﮔﺬﺷﺘﻪ ﻣﻜﻤﻞ‬ ‫‪.7‬‬

‫دﺳﺘﻮر ﺑﺎﻻﻳﻲ ﺧﻮد اﺳﺖ ﻛﻪ اﻣﻜﺎن ﺗﻌﻴﻴﻦ ﻛﺮدن ﻧﻮع داده اي را ﺑﺮاي ﺗﻚ ﺗﻚ ﻣﺘﻐﻴﻴﺮﻫﺎ ﺑﻪ ﻣﺎ ﻣﻴﺪﻫﺪ‪ .‬ﻫﺮ ﻛﺪام از‬
‫‪dom‬ﻫﺎ ﻧﺸﺎن دﻫﻨﺪه ﻧﻮع داده ﻣﻮرد ﻗﺒﻮل ﺑﺮاي ﻣﺘﻐﻴﻴﺮ ﻣﻮرد اﺷﺎره اﻧﺪﻳﺲ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻣﺜﺎل‪ :‬ﻣﺜﻼً اﮔﺮ ﻣﺜﺎل ﺑﺎﻻ را ﺑﺨﻮاﻫﻴﻢ ﻃﻮري ﺣﻞ ﻛﻨﻴﻢ ﻛﻪ ‪ x‬ﻣﻘﺪار ﺣﻘﻴﻘﻲ و ‪ y‬ﻣﻘﺪار ﺻﺤﻴﺢ را ﺑﭙﺬﻳﺮد دارﻳﻢ‪:‬‬

‫‪ ‬‬
‫ﻧﻜﺎت‬
‫ﺗﻮﺿﻴﺢ داده ﺷﺪه‪ ،‬ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﻣﺸﺎﻫﺪه ﻛﺮدﻳﺪ اﻳﻦ دﺳﺘﻮر اﻣﻜﺎن ﭘﻴﺎده‬ ‫‪ 7‬ﺣﺎﻟﺖ دﺳﺘﻮر‬
‫ﻛﺮدن ﻣﺪﻟﻬﺎي ﺑﺴﻴﺎري را ﺑﺮاي ﻣﺎ ﻓﺮاﻫﻢ ﺧﻮاﻫﺪ ﻛﺮد‪ .‬ﻫﺮ ‪ 7‬دﺳﺘﻮر ﻓﻮق ﻣﻴﺘﻮاﻧﻨﺪ ﺑﺎ ﻫﻢ ﺗﺮﻛﻴﺐ ﺷﻮﻧﺪ‪ .‬و ﺣﺎﻟﺖ ﻛﻠﻲ از‬
‫ﺗﺮﻛﻴﺐ ﻫﻤﻪ آﻧﻬﺎ ﺑﻪ دﺳﺖ ﻣﻲ آﻳﺪ در زﻳﺮ ﺑﻪ ﭼﻨﺪ ﺗﺬﻛﺮ در ﻣﻮرد اﻳﻦ دﺳﺘﻮر و ﻫﻤﻴﻨﻄﻮر ﻧﻜﺎت ﺑﻴﺸﺘﺮ ﻣﻴﭙﺮدازﻳﻢ‪.‬‬

‫‪ ‬ﺗﻤﺎم اﻋﺪاد وارد ﺷﺪه در ﻣﺘﻐﻴﻴﺮﻫﺎي ورودي ﺑﺎﻳﺪ از ﻧﻮع ‪ Reals‬ﺑﺎﺷﻨﺪ‪ .‬اﻟﺒﺘﻪ ﻧﻮع داده اي ‪ Reals‬ﻧﻮع‬
‫‪ Integers‬را ﻧﻴﺰ در ﺑﺮ ﻣﻴﮕﻴﺮد‪  .‬‬
‫را اﺧﺘﻴﺎر ﻛﻨﻨﺪ‪  .‬‬ ‫و‬ ‫ﻣﻴﺘﻮاﻧﻨﺪ ﻣﻘﺎدﻳﺮ‬ ‫و‬ ‫ﺣﺪود‬ ‫‪‬‬
‫‪ ‬ﺑﺮاي ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺪون ﻣﺤﺪودﻳﺖ از ﻋﺒﺎرت ‪ None‬ﺑﻌﺪ از وارد ﻛﺮدن ‪ c‬اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ‪  .‬‬
‫‪  ‬ﻣﻘﺪار ﻛﺴﺮي و ﻳﺎ ﺻﺤﻴﺢ را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ اﮔﺮ ﺗﻤﺎم ورودﻳﻬﺎ ﺑﻪ ﻃﻮر دﻗﻴﻖ‬ ‫‪ ‬دﺳﺘﻮر‬
‫ﺑﻪ ﺻﻮرت ﻛﺴﺮي و ﻳﺎ ﺻﺤﻴﺢ وارد ﺷﻮﻧﺪ‪  .‬‬
‫در ﺻﻮرﺗﻲ ﻛﻪ ﻧﺘﻮاﻧﺪ ﺟﻮاﺑﻲ ﺑﺮاي ﻣﺴﺌﻠﻪ وارد ﺷﺪه ﭘﻴﺪا ﻛﻨﺪ ﺑﻪ ﺻﻮرت‬ ‫‪ ‬دﺳﺘﻮر‬
‫ﻛﺎﻣﻞ و ﻫﻤﺎﻧﻄﻮر ﻛﻪ وارد ﺷﺪه ﺑﺮﮔﺸﺖ داده ﻣﻴﺸﻮد‪  .‬‬
‫ﻣﻘﺪار ﺗﻘﺮﻳﺒﻲ را ﺑﺮاي ﺟﻮاب ﻣﺪل وارد ﺷﺪه ﭘﻴﺪا ﻣﻴﻜﻨﺪ‪ ،‬ﺧﺼﻮﺻﻴﺘﻲ در‬ ‫‪ ‬دﺳﺘﻮر‬
‫وﺟﻮد دارد ﻛﻪ ﻣﻘﺪار ﺗﻘﺮﻳﺐ ﺑﺮاي ﺟﻮاب را ﻣﻌﻴﻦ ﻣﻴﻜﻨﺪ‪ ،‬واژه‬ ‫اﻳﻦ دﺳﺘﻮر ﺑﻪ ﻧﺎم‬
‫ﺑﻪ ﻣﻌﻨﺎي داﻣﻨﻪ ﺗﻐﻴﻴﺮات و ﻳﺎ ﺧﻄﺎ اﺳﺖ ﻛﻪ ﻣﻘﺪار ورودي ﺑﺮاي آن ﺗﻌﺪاد اﻋﺪاد ﺑﺎ ﻣﻌﻨﻲ را در‬
‫اﺳﺖ‪ .‬ﻛﻪ ﻳﺎ ﺑﺎ‬ ‫ﻗﺴﻤﺖ اﻋﺸﺎر ﺑﺮاي ﺧﺮوﺟﻲ ﻣﻌﻠﻮم ﻣﻴﻜﻨﺪ‪ ،‬ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض ﺑﺮاي اﻳﻦ ﺧﺼﻮﺻﻴﺖ‬
‫در‬ ‫وارد ﻧﻜﺮدن اﻳﻦ ﺧﺼﻮﺻﻴﺖ اﻋﻤﺎل ﻣﻴﺸﻮد و ﻳﺎ ﺑﺎ وارد ﻛﺮدن ﻋﺒﺎرت‬
‫اﻧﺘﻬﺎي ورودﻳﻬﺎي اﺻﻠﻲ‪  .‬‬
‫اﻣﻜﺎن ﺗﻌﻴﻴﻦ روش ﻣﺤﺎﺳﺒﻪ ﻧﻴﺰ وﺟﻮد دارد‪ ،‬ﻣﺜﻼً اﺳﺘﻔﺎده از روش‬ ‫‪ ‬در دﺳﺘﻮر‬
‫‪ .Simplex‬ﻛﻪ اﻳﻦ اﻋﻤﺎل ﺗﻮﺳﻂ ﺧﺎﺻﻴﺖ ‪ Method‬اﻋﻤﺎل ﻣﻴﺸﻮد‪  .‬‬

‫ﺑﺮاي ﻫﺮﻳﻚ از ﻧﻜﺎت ﺑﻴﺎن ﺷﺪه ﻣﺜﺎﻟﻲ آورده ﻣﻴﺸﻮد‪.‬‬

‫اﺳﺘﻔﺎده از ‪:Method‬‬
‫و‬ ‫و‬ ‫اﻣﻜﺎن ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺎ ‪ 3‬روش‬ ‫دﺳﺘﻮر‬
‫را دارد‪ ،‬ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ روش ﻧﻘﺎط دروﻧﻲ‪ ،‬روش ﺳﻴﻤﭙﻠﻜﺲ و روش ﺳﻴﻤﭙﻠﻜﺲ اﺻﻼح ﺷﺪه‬
‫ﻫﺴﺘﻨﺪ‪ .‬روش ﻧﻘﺎط دروﻧﻲ ﺳﺮﻳﻌﺘﺮ ازدو روش ﺳﻴﻤﭙﻠﻜﺲ ﻋﻤﻞ ﻣﻴﻜﻨﺪ‪ ..‬ﺑﺮاي ﻧﺸﺎن دادن ﺳﺮﻋﺖ روﺷﻬﺎ و ﻧﺤﻮه‬
‫اﺳﺘﻔﺎده از دﺳﺘﻮر ﻣﺪل ﺑﺰرﮔﻲ را ﺗﻮﻟﻴﺪ و ﺑﺎ ﻫﺮﻳﻚ از رو‪.‬ﺷﻬﺎ ﺣﻞ ﻣﻴﻜﻨﻴﻢ‪.‬‬

‫ﻣﺪل ﻋﺒﺎرت اﺳﺖ از ﻳﻚ ﺗﺎﺑﻊ ﻫﺪف ﺑﺎ ‪ 200‬ﻣﺘﻐﻴﻴﺮ ﻛﻪ ﻣﻴﻨﻴﻤﻢ ﻣﻴﺸﻮد و ﻣﺎﺗﺮﻳﺲ ﻣﺤﺪوﻳﺘﻲ ‪ 3‬ﻗﻄﺮي ﻛﻪ ﻗﻄﺮ ﺑﺎﻻي ﻗﻄﺮ‬
‫اﺻﻠﻲ آن ﺻﻔﺮ‪ ،‬ﻗﻄﺮ اﺻﻠﻲ ‪ 1‬و ﻗﻄﺮ زﻳﺮ ﻗﻄﺮ اﺻﻠﻲ ‪ 2‬اﺳﺖ‪ .‬اﻳﻦ دﺳﺘﮕﺎه را ﺑﺎ دﺳﺘﻮرات ﻣﺘﻤﺘﻴﻜﺎ ﺗﻮﻟﻴﺪ ﻣﻴﻜﻨﻴﻢ و در‬
‫آﺧﺮ زﻣﺎن اﺟﺮاي دﺳﺘﻮر را اﻧﺪازه ﻣﻴﮕﻴﺮﻳﻢ‪:‬‬

‫ﻛﻪ زﻣﺎن اﺟﺮاي دﺳﺘﻮر ﺑﺮاﺑﺮﺑﺎ ‪ 0.291‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ ﺑﻮده اﺳﺖ‪.‬‬

‫ﺣﺎل دﺳﺘﻮر زﻳﺮ را وارد ﻣﻴﻜﻨﻴﻢ‪:‬‬

‫ﻣﻘﺪار زﻣﺎن اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ ‪ 0.02‬اﻧﺪازه ﮔﻴﺮي ﺷﺪه اﺳﺖ‪.‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ ﺳﺮﻋﺖ اﺟﺮاي اﻟﮕﻮرﻳﺘﻢ ﺑﺎ روش ﻧﻘﺎط ﻣﻴﺎﻧﻲ ﺑﺴﻴﺎر ﺳﺮﻳﻌﺘﺮ از روش ﺳﻴﻤﭙﻠﻜﺲ اﺳﺖ‪.‬‬

‫‪:‬‬ ‫اﺳﺘﻔﺎده از‬

‫ﻧﻴﺰ دﺳﺘﮕﺎﻫﻲ ﺑﺰرﮔﺘﺮ را ﺗﻮﻟﻴﺪ ﻣﻴﻜﻨﻴﻢ و ﺑﺎز زﻣﺎن اﺟﺮاي دﺳﺘﻮر را ﺑﺎ‬ ‫ﺑﺮاي ﻧﺸﺎن دادن روش اﺳﺘﻔﺎده از‬
‫‪ 2‬دﻗﺖ ﻣﺘﻔﺎوت اﻧﺪازه ﻣﻴﮕﻴﺮﻳﻢ‪ ،‬اﻳﻨﺒﺎر دﺳﺘﮕﺎﻫﻲ ﺑﺎ ﺗﺎﺑﻊ ﻫﺪﻓﻲ ﺑﺎ ‪ 20000‬ﻣﺘﻐﻴﺮ در ﻧﻈﺮ ﻣﻴﮕﻴﺮﻳﻢ‪ .‬و ﻣﺤﺪودﻳﺘﻬﺎ را ﻧﻴﺰ‬
‫ﻣﺎﻧﻨﺪ ﺑﺎﻻ وﻟﻲ ﺑﻪ ﺗﻌﺪاد ﻣﺘﻐﻴﻴﺮﻫﺎي ﺗﺎﺑﻊ ﻫﺪف ﺗﻮﻟﻴﺪ ﻣﻴﻜﻨﻴﻢ‪ .‬در اﻳﻦ ﺻﻮرت دارﻳﻢ‪:‬‬

‫زﻣﺎن ﻻزم ﺑﺮاي اﺟﺮاي دﺳﺘﻮر ‪ 1.311‬ﻣﻴﻠﻲ ﺛﺎﻧﻴﻪ ﺑﻮده اﺳﺖ و ﻋﺪه اي از ﺟﻮاﺑﻬﺎ ﻋﺒﺎرﺗﻨﺪ از‪:‬‬
 ‫را ﻣﺸﺨﺺ ﻧﻜﺮدﻳﻢ و ﺑﻪ ﻃﻮر ﭘﻴﺶ‬ ‫اﺳﺖ‪ .‬دﻗﺖ ﻛﻨﻴﺪ ﻛﻪ ﻣﻘﺪار‬ ‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﻣﻴﺒﻴﻨﻴﺪ دﻗﺖ اﻋﺪاد‬
‫در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺷﺪ‪.‬‬ ‫ﻓﺮض‬

‫اﺟﺮا ﻣﻴﻜﻨﻴﻢ‪ ،‬ﻳﻌﻨﻲ دﻗﺖ اﻋﺪاد ‪ 1‬رﻗﻢ اﻋﺸﺎر ﺑﺎﺷﺪ‪ ،‬اﻧﺘﻈﺎر ﺳﺮﻋﺖ ﺑﻴﺸﺘﺮي‬ ‫ﺣﺎل ﻫﻤﻴﻦ دﺳﺘﻮر را ﺑﺎ‬
‫را در اﺟﺮاي دﺳﺘﻮر دارﻳﻢ‪.‬‬

‫زﻣﺎن اﺟﺮاي دﺳﺘﻮر ‪ 0.521‬اﺳﺖ‪.‬‬

‫و‬ ‫و‬ ‫ارﺗﺒﺎط ﻧﺰدﻳﻜﻲ ﺑﺎ دﺳﺘﻮرات‬ ‫ﻧﻜﺘﻪ‪ :‬دﺳﺘﻮر‬

‫دارد‪ ،‬ﻛﻪ اﻟﺒﺘﻪ اﻳﻦ دﺳﺘﻮرات ﺑﺮاي ﺣﻞ ﻣﺴﺎﺋﻞ ﻏﻴﺮ ﺧﻄﻲ ﺑﻪ روﺷﻬﺎي ﻋﺪدي و ‪ ...‬ﺑﻪ ﻛﺎر ﻣﻴﺮوﻧﺪ‪ .‬ﺑﻪ ﻃﻮر ﻣﺜﺎل اﻳﻦ ‪3‬‬
‫دﺳﺘﻮر را ﺑﺎ ﻫﻢ ﻣﻘﺎﻳﺴﻪ ﻣﻴﻜﻨﻴﻢ‪:‬‬

‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬
‫‪ ‬‬

‫ﻗﺪرت ﺑﻴﺸﺘﺮي در ﺣﻞ‬ ‫و‬ ‫و‬ ‫ﻫﺮ ‪ 3‬ﻣﻘﺪار ﺑﺎ ﻫﻢ ﺑﺮاﺑﺮﻧﺪ‪ .‬وﻟﻲ دﺳﺘﻮرات‬
‫ﻣﺴﺎﺋﻞ ﻏﻴﺮﺧﻄﻲ دارﻧﺪ‪.‬‬
 ‫ﺣﻞ ﻣﺴﺌﻠﻪ ‪:Klee Minty‬‬
‫ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر ‪ LinearProgramming‬ﻣﻴﺘﻮان ﻣﺴﺌﻠﻪ ﻣﻌﺮوف ‪ Klee Minty‬را ﺣﻞ ﻛﺮد ﻛﻪ ﻋﺒﺎرت اﺳﺖ از‪:‬‬

‫اﻳﻦ ﻣﺴﺌﻠﻪ ﺑﻪ ﻣﺴﺌﻠﻪ ‪ Klee Minty‬از ﻣﺮﺗﺒﻪ ‪ n‬ﻣﻮﺳﻮم اﺳﺖ ﻛﻪ ﺑﺮاي ﺣﺎﻟﺖ ‪ n=3‬ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬

‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ از ﺻﻮرت ﻣﺴﺌﻠﻪ ﺑﺮ ﻣﻲ آﻳﺪ ﻣﻴﺘﻮان آن را ﺑﺎ ﺳﻴﻤﭙﻠﻜﺲ و روﺷﻬﺎي ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺧﻄﻲ ﺣﻞ ﻛﺮد‪ ..‬ﻣﺎ ﺑﺮاي‬
‫ﺳﺎﺧﺘﻦ اﻳﻦ ﻣﺴﺌﻠﻪ ﻳﻚ ﺗﺎﺑﻊ در ﻣﺘﻤﺘﻴﻜﺎ ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﺧﺮوﺟﻲ آن ورودﻳﻬﺎي دﺳﺘﻮر ‪LinearProgramming‬‬
‫ﺑﺎﺷﺪ و ﺗﺎﺑﻊ را ﺑﻪ ﻧﺎم ‪ KleeMinty‬ﺑﺎ ﻳﻚ ورودي ﻛﻪ ﻣﻘﺪار‪ n  ‬اﺳﺖ ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﻴﻢ‪:‬‬

‫ﺑﺎ ﺧﺮوﺟﻲ ‪ 3‬ﻣﺎﺗﺮﻳﺲ ‪ c,m,b‬اﺳﺖ ﻛﻪ ورودﻳﻬﺎي دﺳﺘﻮر ‪ LinearProgramming ‬ﻫﺴﺘﻨﺪ‪.‬و ﺑﺮاي اﻋﻤﺎل دﺳﺘﻮر‪:‬‬

‫ﻣﺎ ﻳﻚ ﻣﺴﺌﻠﻪ ﺑﺎ ‪ n=16‬را ﺗﻮﻟﻴﺪ ﻛﺮده اﻳﻢ و ﺧﺮوﺟﻲ ‪ 16‬ﻣﻘﺪار ﺑﺮاي ﻣﺘﻐﻴﻴﺮﻫﺎ را ﺑﻪ ﻣﺎ ﻣﻴﺪﻫﺪ و ﻫﻤﻴﻨﻄﻮر زﻣﺎن ﺻﺮف‬
‫ﺷﺪه ﺑﺮاي ﻣﺤﺎﺳﺒﻪ‪:‬‬
 ‫‪ ‬‬ ‫‪NMinimize‬‬ ‫ﺣﻞ ﻣﺴﺎﺋﻞ ﻏﻴﺮ ﺧﻄﻲ ﺑﺎ اﺳﺘﻔﺎده از‬
‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻜﻲ از ﻗﺪرﺗﻤﻨﺪﺗﺮﻳﻦ ﺗﻮاﺑﻊ در ﻣﺘﻤﺘﻴﻜﺎ اﺳﺖ ﻛﻪ اﻣﻜﺎن ﻣﻴﻨﻴﻤﻢ ﻛﺮدن ﻳﻚ ﻋﺒﺎرت ﺧﻄﻲ و ﻏﻴﺮﺧﻄﻲ را ﺑﻪ‬
‫ﺳﺎدﮔﻲ ﺑﺮاي ﻛﺎﺑﺮ ﻓﺮاﻫﻢ ﻣﻴﻜﻨﺪ و ﻫﻤﭽﻨﻴﻦ اﻣﻜﺎن ﻣﺤﺎﺳﺒﻪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ را ﺑﺎ اﻋﻤﺎل ﻣﺤﺪوﻳﺘﻬﺎ ﻧﻴﺰ دارا ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫ﻣﺸﺎﺑﻪ اﻳﻦ ﺗﺎﺑﻊ ‪ NMaximize‬اﺳﺖ ﻛﻪ ﻫﻤﻪ ﺧﺼﻮﺻﻴﺎت اﻳﻦ ﺗﺎﺑﻊ را دارا ﻣﻴﺒﺎﺷﺪ و ﺑﺮاي ﻣﺎﻛﺰﻳﻤﻢ ﻛﺮدن ﺗﻮاﺑﻪ ﺑﻪ ﻛﺎر‬
‫ﻣﻴﺮود‪ .‬رد زﻳﺮ ﺑﻪ ﺗﻮﺿﻴﺤﻲ دﻗﻴﻖ در ﻣﻮرد اﻳﻦ ﺗﺎﺑﻊ ﻣﻴﭙﺮدازﻳﻢ‪.‬‬

‫ﺗﺎﺑﻊ ﺑﻪ دو ﺻﻮرت‬

‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻴﺸﻮد‪ ،‬ﻟﻴﺴﺖ ﻗﺮار ﮔﺮﻓﺘﻪ در اﻧﺘﻬﺎي ﻓﺮاﺧﻮاﻧﻲ دﺳﺘﻮر ﻣﺘﻐﻴﻴﺮﻫﺎﻳﻲ را ﻣﺸﺨﺺ ﻣﻴﻜﻨﺪ ﻛﻪ دﺳﺘﻮر ﺑﺮاي ﻣﻴﻨﻴﻤﻢ‬
‫اﺳﺖ اﻣﻜﺎن اﻋﻤﺎل‬ ‫ﺑﻪ آﻧﻬﺎ ﺗﻮﺟﻪ ﻣﻴﻜﻨﺪ‪ .‬ﻓﺮاﺧﻮاﻧﻲ دوم دﺳﺘﻮر ‪ NMinimize‬ﻛﻪ ﺑﻪ ﺻﻮرت‬ ‫ﻛﺮدن‬
‫ﻣﺤﺪودﻳﺘﻬﺎ را ﺑﻪ ﻛﺎرﺑﺮ ﻣﻴﺪﻫﺪ‪ .‬در ﻣﺜﺎﻟﻬﺎي زﻳﺮ ﺑﻪ اﻳﻦ دﺳﺘﻮر ﺗﻮﺟﻪ ﺑﻴﺸﺘﺮي ﻣﻴﻜﻨﻴﻢ‪.‬‬

‫ﻧﻜﺎت‬
‫‪ ‬ﺧﺮوﺟﻲ ﺗﺎﺑﻊ از دو ﻗﺴﻤﺖ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ ﻛﻪ ﻗﺴﻤﺖ اول ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ ﺗﺎﺑﻊ اﺳﺖ و ﻗﺴﻤﺖ دوم‬
‫ﺧﺮوﺟﻲ ﻧﺸﺎن دﻫﻨﺪه ﻣﻘﺪاري از ﻣﺘﻐﻴﻴﺮﻫﺎﺳﺖ ﻛﻪ ﺗﺎﺑﻊ ﺑﺎ آﻧﻬﺎ ﻣﻴﻨﻴﻤﻢ ﻣﻴﺸﻮد‪  .‬‬
‫ﻣﻴﺘﻮاﻧﺪ ﻣﺴﺎوي‪ ،‬ﻧﺎﻣﺴﺎوي ﺗﺮﻛﻴﺐ ﻣﻨﻄﻘﻲ از آﻧﻬﺎ ﺑﺎﺷﻨﺪ‪  .‬‬ ‫‪‬‬
‫‪ ‬ﺗﺎﺑﻊ ‪ NMinimize‬ﻫﻤﻮاره ﺗﻼش ﻣﻴﻜﻨﺪ ﻛﻪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ ﺗﺎﺑﻊ را ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﺤﺪودﻳﺘﻬﺎ ﺑﺪﺳﺖ آورد‪  .‬‬
‫‪ ‬ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻫﻤﻪ ﻣﺘﻐﻴﻴﺮﻫﺎ ﺑﻪ ﺻﻮرت ‪ Reals‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻴﺸﻮﻧﺪ‪  .‬‬
‫در ﻟﻴﺴﺖ اﻧﺘﻬﺎي دﺳﺘﻮر ﺑﺮاي ﻣﺸﺨﺺ ﻛﺮدن اﻳﻨﻜﻪ ﻣﻘﺪار ‪ x‬ﺑﺎﻳﺪ ﺻﺤﻴﺢ‬ ‫‪ ‬ﻣﻴﺘﻮان از ﻋﺒﺎرت‬
‫اﺧﺘﻴﺎر ﺷﻮد اﺳﺘﻔﺎده ﺷﻮد‪  .‬‬
‫ﺗﻮاﺑﻊ ﺧﻄﻲ ﺑﺎﺷﻨﺪ ﺗﺎﺑﻊ ‪ NMinimize‬ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ را ﻫﻢ ﺑﻪ ﺻﻮرت اﻋﺪاد ﺣﻘﻴﻘﻲ‬ ‫و‬ ‫‪ ‬اﮔﺮ ﻫﻢ ﺗﺎﺑﻊ‬
‫و ﻫﻢ ﺻﺤﻴﺢ ﺑﺪﺳﺖ ﻣﻴ‪Ĥ‬ورد‪  .‬‬
‫‪ NMinimize ‬در ﺑﻴﺸﺘﺮ اوﻗﺎت ﻣﻴﻨﻴﻤﻢ ﻧﺴﺒﻲ را ﺑﺪﺳﺖ ﻣﻴ‪Ĥ‬ورد‪  .‬‬
‫‪ ‬اﮔﺮ ﺗﺎﺑﻊ ‪ NMinimize‬ﻧﺘﻮاﻧﺪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ را ﭘﻴﺪا ﻛﻨﺪ و ﻳﺎ ﺗﺎﺑﻊ ﻣﻴﻨﻴﻤﻢ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ ﺧﺮوﺟﻲ ﺑﻪ ﺻﻮرت‬
‫زﻳﺮ اﺳﺖ‪  .‬‬
‫‪ ‬ﺧﺼﻮﺻﻴﺎت زﻳﺮ ﺑﺮاي دﺳﺘﻮر در دﺳﺘﺮس ﻫﺴﺘﻨﺪ‪  :‬‬
‫اﺳﺖ‪  .‬‬ ‫ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺮاﺑﺮ‬ ‫و‬ ‫‪ ‬ﻣﻘﺪار‬
‫‪"NelderMead",    "DifferentialEvolution",   ‬‬ ‫‪ ‬ﻣﻘﺎدﻳﺮ ﻣﺠﺎز ﺑﺮاي ‪ Method‬ﻋﺒﺎرﺗﻨﺪ از‪:‬‬
‫‪ "SimulatedAnnealing" ‬و"‪.  "RandomSearch‬‬

‫ﻣﺜﺎل زﻳﺮ ﺗﺎﺑﻊ‪ 1‬ﻣﺘﻐﻴﻴﺮه را ﺑﺪون در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻣﺤﺪودﻳﺖ ﻣﻴﻨﻴﻤﻢ ﻣﻴﻜﻨﺪ‪.‬‬

‫ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ ﺗﺎﺑﻊ ﺑﺮاﺑﺮ ﺑﺎ ‪ -1.07023‬اﺳﺖ و اﻳﻦ ﻣﻘﺪار ﺑﻪ ازاء ‪ x=1.1309‬ﺑﺪﺳﺖ ﻣﻴ‪Ĥ‬ﻳﺪ‪.‬‬

‫ﻣﻴﻨﻴﻤﻢ ﻣﻴﻜﻨﺪ ﻛﻪ ﻣﺴﺌﻠﻪ ﺑﺪﺳﺖ آﻣﻮردن‬ ‫را ﺑﺎ اﻋﻤﺎل ﻣﺤﺪودﻳﺖ‬ ‫ﻣﺜﺎل زﻳﺮ ﺗﺎﺑﻊ‬
‫ﻣﻴﻨﻴﻤﻢ ﺷﻜﻞ زﻳﺮ اﺳﺖ ﻛﻪ ﺑﺎ اﻋﻤﺎل ﻣﺤﺪودﻳﺖ ﺑﺪﺳﺖ آﻣﺪه اﺳﺖ‪.‬‬

‫و ﻳﺎ ﻣﺴﺌﻠﻪ زﻳﺮ ﻛﻪ ﺑﺴﻴﺎر ﭘﻴﭽﻴﺪه اﺳﺖ‪.‬‬

 ‫ﺣﻞ ﻣﺴﺎﺋﻠﻲ ﺑﻪ اﻳﻦ ﭘﻴﭽﻴﺪﮔﻲ ﻧﺸﺎن دﻫﻨﺪه ﻗﺪرت اﻳﻦ دﺳﺘﻮر در ﺣﻞ ﻣﺴﺎﺋﻞ ﻏﻴﺮ ﺧﻄﻲ اﺳﺖ‪.‬‬

‫دورﻧﻤﺎ‬
‫ﺗﺎﺑﻊ ‪ NMinimize‬ﺑﺮاي در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻣﺤﺪودﻳﺘﻬﺎ از ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ اﺳﺘﻔﺎده ﻣﻴﻜﻨﺪ‪ ،‬ﻳﻌﻨﻲ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﭼﻨﺪﻳﻦ‬
‫ﻣﺤﺪودﻳﺖ را ﺑﺮاي ﻣﻴﻨﻴﻤﻢ ﻛﺮدن اﻋﻤﺎل ﻛﻨﻴﻢ ﺑﺎ اﺳﺘﻔﺎده از ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ "ﻳﺎ" و "و" ﺑﻪ ﺻﻮرت || و &&‬
‫ﻋﻤﻠﮕﺮﻫﺎ را وارد ﻣﻴﻜﻨﻴﻢ‪ .‬ﻣﺜﻼً‪:‬‬

‫در ﻧﻈﺮ‬ ‫ﻳﺎ‬ ‫ﺑﻪ ﻃﻮري ﻛﻪ ﻣﺤﺪودﻳﺖ‬ ‫‪ .1‬ﺑﺮاي ﻣﻴﻨﻴﻤﻢ ﻛﺮدن‬

‫ﮔﺮﻓﺘﻪ ﺷﻮد ﺑﻪ ﺻﻮرت زﻳﺮ ﻧﻮﺷﺘﻪ ﻣﻴﺸﻮد‪  .‬‬

‫‪ ‬‬
‫‪ .2‬اﮔﺮ ﺗﺎﺑﻊ ﻫﺪف و ﻣﺤﺪودﻳﺘﻬﺎ ﺧﻄﻲ ﺑﺎﺷﻨﺪ‪ ،‬دارﻳﻢ‪  :‬‬

‫‪ ‬‬
‫‪ .3‬ﺑﺮاي ﺣﻞ ﻣﺴﺎﺋﻞ ﻏﻴﺮ ﺧﻄﻲ ﺑﻪ ﺻﻮرت ﺻﺤﻴﺢ‪  :‬‬

‫ﻫﻢ ﺑﻪ ﺻﻮرت ﻳﻚ ﻣﺤﺪودﻳﺖ ﻳﺎد ﺷﺪه اﺳﺖ‪  .‬‬ ‫ﻫﻤﺎﻧﻄﻮر ﻛﻪ دﻳﺪه ﻣﻴﺸﻮد از ﻋﺒﺎرت‬
‫‪ .4‬و ﻳﺎ‪  :‬‬
 ‫‪FindMinimum‬‬ ‫دﺳﺘﻮر‬
‫اﻳﻦ دﺳﺘﻮر ﻛﺎري ﺑﺴﻴﺎر ﺷﺒﻴﻪ ﺑﻪ ﻛﺎر دﺳﺘﻮر ‪ NMinimize‬اﻧﺠﺎم ﻣﻴﺪﻫﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ اﻳﻦ دﺳﺘﻮر اﻣﻜﺎﻧﺎت‬
‫ﺑﻴﺸﺘﺮي ﺑﺮاي اﻧﺘﺨﺎب روﺷﻬﺎي ﻣﺨﺘﻠﻒ دارد و در ﺿﻤﻦ ﻣﻴﺘﻮاﻧﺪ اﻃﻼﻋﺎت اوﻟﻴﻪ ﻣﺎ را ﻧﺴﺒﺖ ﺑﻪ ﻣﺴﺌﻠﻪ درﻣﺪل و‬
‫ﻣﺤﺎﺳﺒﺎت داﺧﻠﻲ ﺧﻮد دﺧﻴﻞ ﻛﻨﺪ‪.‬‬

‫اﻳﻦ دﺳﺘﻮر ﺑﻪ ‪ 3‬روش ﻛﻠﻲ ﻓﺮاﺧﻮاﻧﻲ ﻣﻴﺸﻮد ﻛﻪ ﻋﺒﺎرﺗﻨﺪ از‪:‬‬

‫ﺑﻪ ﺳﻤﺖ ﻣﻴﻨﻴﻤﻢ ﺷﺪن‬ ‫ﺑﺎ ﺷﺮوع از ﻧﻘﻄﻪ‬ ‫‪ :‬در اﻳﻦ ﻧﻮع ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ‬ ‫‪.1‬‬
‫ﺣﺮﻛﺖ داده ﻣﻴﺸﻮد و در ﺻﻮرت وﺟﻮد ﻣﻴﻨﻴﻤﻢ ﺧﺮوﺟﻲ ﺗﺎﺑﻊ ﻣﺎﻧﻨﺪ ﺗﺎﺑﻊ ‪ NMinimize‬ﻧﻘﻄﻪ اي اﺳﺖ ﻛﻪ ﺗﺎﺑﻊ در آن‬
‫ﻣﻴﻨﻴﻤﻢ ﺷﺪه و ﻫﻤﻴﻨﻄﻮر ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ ﺗﺎﺑﻊ در آن ﻧﻘﻄﻪ‪.‬‬

‫ﻛﻪ ﺗﻨﻬﺎ ﺗﻔﺎوت‬ ‫ﺣﺎﻟﺖ ﺗﻜﻤﻴﻞ ﺷﺪه اﻳﻦ دﺳﺘﻮر ﻋﺒﺎرت اﺳﺖ از‬
‫را ﻣﻴﻨﻴﻤﻢ‬ ‫آن ﺑﺎ دﺳﺘﻮر ﺑﺎﻻ در ﺗﻌﺪاد ﻣﺘﻐﻴﻴﺮﻫﺎي ﺗﺎﺑﻊ ﻫﺪف ﻣﻴﺒﺎﺷﺪ‪ .‬ﺑﺮاي ﻣﺜﺎل ﻓﺮض ﻛﻨﻴﺪ ﻣﻴﺨﻮاﻫﻴﻢ ﺗﺎﺑﻊ‬
‫ﻛﻨﻴﻢ و ﻣﻴﻨﻴﻤﻢ آن را از ﻧﻘﻄﻪ ‪ x=2‬ﺑﻪ ﺑﻌﺪ ﺑﻪ دﺳﺖ آورﻳﻢ‪ ،‬در اﻳﻦ ﺻﻮرت دارﻳﻢ‪:‬‬

‫‪ : ‬در اﻳﻦ ﻧﻮع ﻓﺮاﺧﻮاﻧﻲ ﻋﻼوه ﺑﺮ ﻣﻘﺎدﻳﺮ اﺑﺘﺪاﻳﻲ‬ ‫‪.2‬‬

‫ﺑﺮاي ﺗﻌﺪاد دﻟﺨﻮاه ﻣﺘﻐﻴﻴﺮﻫﺎ ﻣﻴﺘﻮان ﻣﺤﺪودﻳﺘﻬﺎﻳﻲ را ﻧﻴﺰ اﻋﻤﺎل ﻛﺮد‪ .‬ﺑﻪ ﻃﻮر ﻣﺜﺎل ﻓﺮض ﻛﻨﻴﺪ ﻣﻴﺨﻮاﻫﻴﻢ ﺗﺎﺑﻊ‬
‫ﺑﺮاي ‪ x‬ﻣﻴﻨﻴﻤﻢ ﻛﻨﻴﻢ‪ .‬در اﻳﻦ ﺻﻮرت دارﻳﻢ‪:‬‬ ‫را ﻫﻤﺮاه ﺑﺎ ﻣﺤﺪودﻳﺖ‬

‫‪ : ‬اﻳﻦ ﻓﺮاﺧﻮاﻧﻲ از ﺗﺎﺑﻊ ﺷﺒﺎﻫﺖ زﻳﺎدي ﺑﻪ ‪ NMinimize‬دارد‬ ‫‪.3‬‬

‫ﻓﻘﻂ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﺑﺎز ﻧﻘﺎط اﺑﺘﺪاﻳﻲ ﺑﺮاي ﺷﺮوع ﺣﺮﻛﺖ را ﻧﻴﺎز دارد وﻟﻲ اﻳﻦ ﻧﻘﺎط را ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻘﺎط اﺑﺘﺪاﻳﻲ ﻣﺮز‬
‫ﺑﺎ ﻣﺤﺪوﻳﺘﻬﺎي ﺧﻄﻲ و ﺑﺪون ﺗﻌﻴﻴﻦ ﻧﻘﺎط‬ ‫ﻣﺤﺪودﻳﺘﻬﺎ ﺧﻮد ﺗﺎﺑﻊ اﻧﺘﺨﺎب ﻣﻴﻜﻨﺪ‪ .‬ﻣﺜﻼً ﺑﺮاي ﻣﻴﻨﻴﻤﻢ ﻛﺮدن ﺗﺎﺑﻊ‬
‫ﺷﺮوع دارﻳﻢ‪:‬‬

‫ﻧﻜﺎت‬
‫ﻳﻚ ﻟﻴﺴﺖ از ‪ 2‬ﻗﺴﻤﺖ اﺳﺖ ﻛﻪ ﻗﺴﻤﺖ اول ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ ﺗﺎﺑﻊ و ﻗﺴﻤﺖ‬ ‫‪ ‬ﺧﺮوﺟﻲ دﺳﺘﻮر‬
‫دوم ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮﻫﺎي ﺗﺎﺑﻊ ﻫﺪف ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ را ﺗﻮﻟﻴﺪ ﻛﺮده اﻧﺪ‪  .‬‬
‫ﻣﻴﺘﻮاﻧﺪ ﻣﺴﺎوي‪ ،‬ﻧﺎﻣﺴﺎوي ﺗﺮﻛﻴﺐ ﻣﻨﻄﻘﻲ از آﻧﻬﺎ ﺑﺎﺷﻨﺪ‪  .‬‬ ‫‪‬‬
‫ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ اﺑﺘﺪا ﻣﻘﺪار ﺗﺎﺑﻊ را ﺑﻪ ازاء ﻧﻘﺎط اﺑﺘﺪاﻳﻲ ﻣﺤﺎﺳﺒﻪ ﻣﻴﻜﻨﺪ و‬ ‫‪ ‬دﺳﺘﻮر‬
‫در اداﻣﻪ ﻣﻘﺪار را ﺑﺎ اﺳﺘﻔﺎده از ﻣﻘﺪاﻳﺮ ﺑﺪﺳﺖ آﻣﺪه ﻣﻘﺎﻳﺴﻪ ﻣﻴﻜﻨﺪ و اﻳﻦ ﻛﺎر را ﺑﻪ ﺻﻮرت ﻋﺪدي اداﻣﻪ ﻣﻴﺪﻫﺪ‬
‫ﺗﺎ ﺑﻪ ﻣﻴﻨﻴﻤﻢ ﺑﺮﺳﺪ‪  .‬‬
‫ﻣﻴﺘﻮاﻧﺪ دو ﻣﻘﺪار اﺑﺘﺪاﻳﻲ را ﺑﺮاي ﻣﺤﺎﺳﺒﺎت ﺧﻮد در ﻧﻈﺮ ﺑﮕﻴﺮد ﺑﻪ اﻳﻦ ﺻﻮرت ﻛﻪ‬ ‫‪ ‬دﺳﺘﻮر‬
‫‪ ‬‬ ‫ﻣﺤﺎﺳﺒﻪ ﻣﻴﻜﻨﺪ‪.‬‬ ‫و‬ ‫دو ﻣﻘﺪار اول را ﺑﺎ‬
‫ﻣﻌﻴﻴﻦ ﻛﻨﻨﺪه اﻳﻦ اﺳﺖ ﻛﻪ ﺗﺎﺑﻊ اوﻟﻴﻦ ﻣﻘﺪار را‬ ‫‪ ‬ﻓﺮاﺧﻮاﻧﻲ‬
‫ﺑﺮود ﻋﻤﻠﻴﺎت را ﻣﺘﻮﻗﻒ ﻣﻴﻜﻨﺪ‪  .‬‬ ‫در ﻧﻈﺮ ﺑﮕﻴﺮد و در ﺻﻮرﺗﻲ ﻛﻪ ﻣﻘﺪار ‪ x‬ﺧﺎرج از‬
‫ﻓﻘﻂ ﻣﻴﻨﻴﻤﻤﻬﺎي‬ ‫‪ ‬اﮔﺮ ﺗﺎﺑﻊ ﻫﺪف و ﻣﺤﺪدﻳﺘﻬﺎ ﻫﻤﮕﻲ ﺧﻄﻲ ﺑﺎﺳﻨﺪ آﻧﮕﺎه ﻣﻤﻜﻦ اﺳﺖ دﺳﺘﻮر‬
‫ﻧﺴﺒﻲ را ﭘﻴﺪا ﻛﻨﺪ و ﻣﻴﻨﻴﻤﻤﻬﺎي ﻣﻄﻠﻖ را در ﻧﻈﺮ ﻧﮕﻴﺮد‪  .‬‬
‫‪ ‬ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﻫﻤﻪ ﻣﻘﺎدﻳﺮ ﺣﻘﻴﻘﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻴﺸﻮﻧﺪ‪  .‬‬
‫‪ ‬اﮔﺮ ﺗﺎﺑﻊ ﻫﺪف و ﻣﺤﺪودﻳﺘﻬﺎ ﻫﺮدو ﺧﻄﻲ ﺑﺎﺷﻨﺪ و در ﻣﺤﺪودﻳﺘﻬﺎ ﻣﺤﺪودﻳﺘﻲ ﺑﻪ ﺻﻮرت‬
‫اﺗﺨﺎذ ﺷﻮد دﺳﺘﮕﺎه ﺑﻪ ﺻﻮرت ﺻﺤﻴﺢ ﺣﻞ ﺧﻮاﻫﺪ ﺷﺪ‪  .‬‬
‫‪ ‬ﺧﺼﻮﺻﻴﺎت زﻳﺮ ﻣﻴﺘﻮاﻧﻨﺪ اﻋﻤﺎل ﺷﻮﻧﺪ‪  :‬‬

‫‪ ‬‬ ‫‪‬‬
‫ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺮاﺑﺮ‬ ‫و‬ ‫‪ ‬ﻣﻘﺪار‬
‫اﺳﺖ‪  .‬‬
‫‪    ,"ConjugateGradient"  "Gradient", ‬‬ ‫ﻋﺒﺎرﺗﻨﺪ از‪:‬‬ ‫‪ ‬روﺷﻬﺎي ﻣﻮرد اﺳﺘﻔﺎده در دﺳﺘﻮر‬
‫‪"LevenbergMarquardt",    "Newton",    "QuasiNewton",    "InteriorPoint" ‬و "‪    "LinearProgramming‬ﻛﻪ‬
‫روﺷﻬﺎي "ﮔﺮادﻳﺎن ﺗﻮام" و "ﮔﺮادﻳﺎن" و "ﻧﻘﺎط ﻣﻴﺎﻧﻲ" و ﻧﻴﻮﺗﻦ" و "ﺷﺒﻪ ﻧﻴﻮﺗﻦ" و "ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺧﻄﻲ" و‬
‫"ﻟﻮﻧﺒﺮگ"‪.‬‬

‫ﭼﻨﺪ ﻣﺜﺎل‪:‬‬
 ‫ﺑﺮاي ﺗﺎﺑﻊ دو ﻣﺘﻐﻴﻴﺮه دارﻳﻢ‪:‬‬

‫اﮔﺮ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺤﺪودﻳﺖ‬

‫و در اداﻣﻪ‬

‫و در ﺻﻮرت ﺧﻄﻲ ﺑﻮدن ﺑﻪ ﻣﺴﺌﻠﻪ ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺧﻄﻲ ﺗﺒﺪﻳﻞ ﻣﻴﺸﻮد‪:‬‬

‫ﺑﻪ ﻣﺤﺪودﻳﺘﻬﺎ اﺿﺎﻓﻪ ﺷﻮد ﻣﺴﺌﻠﻪ ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺻﺤﻴﺢ ﺧﻮاﻫﺪ ﺑﻮد‪:‬‬ ‫و اﮔﺮ ﻋﺒﺎرت‬

‫و در ﻧﻬﺎﻳﺖ ﻳﻚ ﻣﺤﺪودﻳﺖ ﺑﺎ ﻋﺒﺎرت ﻣﻨﻄﻘﻲ "ﻳﺎ"‬

‫روش ﮔﺮادﻳﺎن‪:‬‬
‫ﺑﺮاي اﺳﺘﻔﺎده از روش ﮔﺮادﻳﺎﻧﺖ ﺑﺎﻳﺪ ﮔﺮادﻳﺎن ﺗﺎﺑﻊ را ﺣﺴﺎب ﻛﺮده و آن را ﺑﻪ ﻋﻨﻮان ورودي ﺑﻪ ﺗﺎﺑﻊ ﺑﺪﻫﻴﻢ‪ ،‬ﺑﻪ ﺻﻮرت‬
‫زﻳﺮ‪:‬‬
 ‫اﻳﻦ ﻣﻌﺎدﻟﻪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﮔﺮادﻳﺎن از روش ﻧﻴﻮﺗﻦ ﻣﻘﺪارﻣﻴﻨﻴﻤﻢ را ﺣﺴﺎب ﻣﻴﻜﻨﺪ‪.‬‬

‫در روش ﻧﻴﻮﺗﻦ اﮔﺮ ﻣﺎﺗﺮﻳﺲ "ﻫﺴﻴﻦ" ﺗﺎﺑﻊ ﻫﺪف را ﻧﻴﺰ ﺑﻪ دﺳﺘﻮر ﺑﻪ ﻋﻨﻮان ورودي ﺑﺪﻫﻴﻢ ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬

‫‪ ‬‬
 ‫ﭘﻴﺪا ﻛﺮدن ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر ‪:FindShortestTour‬‬
‫ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻛﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ در ﺑﻴﻦ ﻧﻘﺎط ﺻﻔﺤﻪ راﻫﻬﺎي ﻣﺘﻔﺎوﺗﻲ وﺟﻮد دارد و اﻳﻦ دﺳﺘﻮر ﺑﻴﺸﺘﺮ اﻳﻦ اﻟﮕﻮرﻳﺘﻤﻬﺎ را‬
‫ر دﺳﺘﺮس ﻗﺮار ﻣﻴﺪﻫﺪ‪ .‬اﻳﻦ دﺳﺘﻮر ﺑﺎ درﻳﺎﻓﺖ ﻟﻴﺴﺘﻲ از ﻧﻘﺎط ‪ 2‬ﺧﺮوﺟﻲ را ﺑﺮﻣﻴﮕﺮداﻧﺪ ﻛﻪ ﻳﻜﻲ ﻣﻴﺰان اﻧﺪازه ﻛﻤﺘﺮﻳﻦ‬
‫ﻣﺴﻴﺮ و دوﻣﻴﻦ ﺧﺮوﺟﻲ ﺗﺮﺗﻴﺐ ﻃﻲ ﻛﺮدن ﻧﻘﺎط اﺳﺖ ﺗﺎ اﻳﻦ ﻛﻤﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺑﻪ دﺳﺖ آﻳﺪ‪ .‬اﻟﺒﺘﻪ اﻳﻦ دﺳﺘﻮر اﻳﻦ ﺷﺮط را‬
‫ﻛﻪ ﻫﻤﻪ ﻧﻘﺎط ﻃﻲ ﺷﻮﻧﺪ را ﻧﻴﺰ در ﻧﻈﺮ ﻣﻴﮕﻴﺮد‪.‬‬

‫ﻣﺨﺘﺼﺎت ﻳﻚ ﻧﻘﻄﻪ در‬ ‫‪  ‬ﻫﺮﻛﺪام از‬ ‫دﺳﺘﻮر در ﺣﺎﻟﺖ ﻛﻠﻲ ﺑﻪ ﺻﻮرت ‪ ‬‬
‫ﺻﻔﺤﻪ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻣﺜﺎل‪:‬‬

‫دﺳﺘﻮر ﺑﺎﻻ ﻣﻴﺰان ﻛﻤﺘﺮﻳﻦ ﻣﺴﺎﻓﺖ و ﺗﺮﺗﻴﺐ ﻧﻘﺎط را ﺑﺮاي ﻃﻲ ﻛﺮدن ﻣﺴﻴﺮ در ﺑﻴﻦ ﻧﻘﺎط داده ﺷﺪه را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‪:‬‬

‫ﺑﻪ ﻣﺜﺎل دﻳﮕﺮي ﻛﻪ اﻧﺪﻛﻲ از اﻧﻌﻄﺎف ﭘﺬﻳﺮي ﻣﺘﻤﺘﻴﻜﺎ را ﻧﻴﺰ ﻧﺸﺎن ﻣﻴﺪﻫﺪ ﺗﻮﺟﻪ ﻛﻨﻴﺪ‪ ،‬ﻣﺎ ﻛﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ را ﺑﺎ اﺳﺘﻔﺎده از‬
‫اﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﺑﻪ دﺳﺖ ﻣﻴ‪Ĥ‬ورﻳﻢ و ﺑﺎ اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ ﮔﺮاﻓﻴﻜﻲ ﻣﺘﻤﺘﻴﻜﺎ اﻳﻦ ﻣﺴﻴﺮ را رﺳﻢ ﻣﻴﻜﻨﻴﻢ‪.‬‬

‫ﺗﻮاﻧﺎﻳﻲ ﭘﻴﺪا ﻛﺮدن ﻛﻤﺘﺮﻳﻦ ﻣﺴﻴﺮ در ﻓﻀﺎ را ﻧﻴﺰ دارد‪.‬‬ ‫ﻧﻜﺘﻪ‪ :‬ﺗﺎﺑﻊ‬
 ‫ﺧﺼﻮﺻﻴﺖ ‪:Method‬‬
‫از ﭼﻨﺪﻳﻦ روش ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻛﻤﺘﺮﻳﻦ ﻣﺴﻴﺮ اﺳﺘﻔﺎده ﻣﻴﻜﻨﺪ‪ ،‬ﺑﺮاي ﻧﺸﺎن دادن ﻫﺮﻛﺪام از‬ ‫ﺗﺎﺑﻊ‬
‫اﻳﻦ روﺷﻬﺎ ﻣﺎ ﻣﺜﺎﻟﻲ را ﻛﻪ ﺧﻮاﺳﺘﺎر ﭘﻴﺪا ﻛﺮدن ﻛﻤﺘﺮﻳﻦ ﻣﺴﻴﺮ در ﺑﻴﻦ ﻧﻘﺎط ‪2‬ﺑﻪ‪ 2‬ﻧﺴﺒﺖ ﺑﻪ ﻫﻢ اول ﻛﻮﭼﻜﺘﺮ از ‪10‬‬
‫ﻫﺴﺘﻨﺪ اﺟﺮا ﻣﻴﻜﻨﻴﻢ‪ ،‬ﻛﻪ ﻋﺒﺎرﺗﻨﺪ از‪:‬‬

‫‪ :‬روش ﭘﻴﺶ ﻓﺮض ﺑﺮاي ﭘﻴﺪا ﻛﺮدن ﻛﻤﺮﻳﻦ ﻣﺴﻴﺮ در ﺻﻔﺤﻪ‪  .‬‬ ‫‪‬‬

‫‪ ‬‬
‫‪ :‬روش ﭘﻴﺶ ﻓﺮض ﺑﺮاي ﻧﻘﺎط در ﻓﻀﺎ‪  .‬‬ ‫‪‬‬

‫‪ ‬‬
‫‪ :‬روﺷﻲ ﻛﻪ از ﻛﻤﺘﺮﻳﻦ ﻣﺴﻴﺮ را ﺑﺪون ﺗﻘﺎﻃﻊ ﺑﺪﺳﺖ ﻣﻴ‪Ĥ‬ورد‪  .‬‬ ‫‪‬‬

‫‪ ‬‬
‫‪ :‬روﺷﻲ ﻛﻪ ﻛﻤﺘﺮﻳﻦ ﺗﺪاﺧﻞ و زاوﻳﻪ را اﻧﺘﺨﺎب ﻣﻴﻜﻨﺪ‪  .‬‬ ‫‪‬‬

‫‪ ‬‬
‫‪ :‬روﺷﻲ ﻛﻪ از ﻳﻚ ﻧﻘﻄﻪ ﺑﻪ ﻧﺰدﻳﻜﺘﺮﻳﻦ ﻧﻘﻄﻪ ﺧﺎﻟﻲ ﺧﻮد ﻣﻴﺮود‪  .‬‬ ‫‪‬‬
‫‪ ‬‬
‫ﻛﻪ ﻃﻮﻻﻧﻴﺘﺮﻳﻦ ﻣﺴﻴﺮ را اﻧﺘﺨﺎب ﻣﻴﻜﻨﺪ‪  .‬‬ ‫‪ :‬ﻧﻮﻋﻲ از روش‬ ‫‪‬‬

‫‪ ‬‬
‫‪ :‬‬ ‫‪‬‬
‫‪ ‬‬
 ‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﻄﺎﻟﺐ ﺑﺎﻻ ﻣﻴﺘﻮان ﻣﺴﺎﺋﻞ زﻳﺮ را ﺣﻞ ﻛﺮد‪:‬‬
‫ﻣﺴﺌﻠﻪ زﻳﺮ را ﺣﻞ ﻛﻨﻴﺪ‪.‬‬ ‫‪.1‬‬

‫ﺣﻞ‪:‬‬

‫را اﻋﻤﺎل ﻛﻨﻴﻢ‪ ،‬دﺳﺘﻮر ﺟﻮاب ﻧﻤﻴﺪﻫﺪ‪:‬‬ ‫اﮔﺮ ﻣﺤﺪودﻳﺘﻬﺎي‬

 ‫ﻧﺸﺎن دﻫﻴﺪ ﻫﻴﭻ ﺟﻮاب ﺷﺪﻧﻲ ﻧﺪارد‪.‬‬ ‫‪.2‬‬

‫ﺟﻮاب ﺑﻬﻴﻨﻪ دﺳﺘﮕﺎه‪:‬‬

‫اﮔﺮ دﺳﺘﻮر را ﻣﺠﺎب ﻛﻨﻴﻢ ﻛﻪ ﺟﻮاب ﺻﺤﻴﺢ ﺑﺮﮔﺮداﻧﺪ ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬

‫اﮔﺮ از دﺳﺘﻮر ‪ NMinimize‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪ ،‬دارﻳﻢ‪:‬‬

‫ﻛﻪ ﺑﺎز ﻧﺸﺎن دﻫﻨﺪه اﻳﻦ اﺳﺖ ﻛﻪ ﺗﺎﺑﻊ ﺟﻮاب ﺻﺤﻴﺢ ﻧﺎﻣﻨﻔﻲ ﻧﺪارد‪  .‬‬
‫‪.‬‬ ‫ﺑﺎ روش ﺟﺴﺘﺠﻮي ﮔﺮادﻳﺎن ﻣﺴﺌﻠﻪ زﻳﺮ را ﺣﻞ ﻛﻨﻴﺪ و ﺗﺎ ‪ 4‬ﻣﺮﺣﻠﻪ و ﻧﻘﻄﻪ آﻏﺎزي‬ ‫‪.3‬‬

‫ﺣﻞ‪:‬‬
 ‫ﻣﺴﺌﻠﻪ زﻳﺮ را ﺑﺎ ‪ 3‬ﺗﻜﺮار ﺣﻞ ﻛﻨﻴﺪ‪.‬‬ ‫‪.4‬‬

‫ﺣﻞ‪:‬‬

‫ﺑﺎ اﺳﺘﻔﺎده از دو دﺳﺘﻮر زﻳﺮ ﻣﺴﺌﻠﻪ را ﺣﻞ ﻣﻴﻜﻨﻴﻢ‪:‬‬

‫ﻣﺴﺌﻠﻪ زﻳﺮ را ﺑﺎ ﺣﻞ ﻛﻨﻴﺪ‪.‬‬ ‫‪.4‬‬

‫ﺣﻞ‪:‬‬