Linear And Nonlinear Programming With Mathematica 6

‫ﺑﻪ ﻧﺎم ﺧﺪا‬

‫‪ ‬‬

‫ﺑﺮﻧﺎﻣﻪ رﻳﺰي ﺧﻄﻲ و ﻏﻴﺮﺧﻄﻲ در‬ ‫ﻣﺘﻤﺘﻴﻜﺎ‪   6.0‬‬ ‫‪ ‬‬ ‫‪ ‬‬ ‫اﻣﻴﺮ ﻣﺴﻌﻮد ﻋﺒﺪل ‪ ‬‬ ‫ﺗﺎﺑﺴﺘﺎن ‪  1387‬‬

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

‫‪ ‬‬

‫‪ ‬‬

‫ﻣﻘﺪﻣﻪ‬ ‫اﻣﺮوزه ﻧﺮم اﻓﺰارﻫﺎي ﺑﺴﻴﺎري ﺑﺮاي اﻧﺠﺎم ﻋﻤﻠﻴﺎت رﻳﺎﺿﻲ ﺗﻮﻟﻴﺪ ﺷﺪه اﻧﺪ ﻛﻪ از ﺑﺮﺟﺴﺘﻪ ﺗﺮﻳﻦ و ﺳﺮﻳﻊ ﺗﺮﻳﻦ و اﻧﻌﻄﺎف‬ ‫ﭘﺬﻳﺮﺗﺮﻳﻦ آﻧﻬﺎ ﻣﻴﺘﻮان ﺑﻪ ﻣﺘﻤﺘﻴﻜﺎ‪ 1‬اﺷﺎره ﻛﺮد‪.‬‬ ‫اﻣﺮوزه ﺣﻞ ﻣﺴﺎﺋﻞ ﺧﻄﻲ و ﻏﻴﺮﺧﻄﻲ از اﻫﻤﻴﺖ ﺧﺎﺻﻲ ﺑﺮﺧﻮردار اﺳﺖ‪ ،‬ﻛﻪ اﻟﺒﺘﻪ ﺣﻞ ﻣﺴﺎﺋﻞ ﺧﻄﻲ ﻣﺪﺗﻲ اﺳﺖ ﻛﻪ ﺗﺎ‬ ‫اﻧﺘﻬﺎي راه رﻓﺘﻪ اﺳﺖ و روش ﻫﺎي ﻣﺘﻌﺪدي ﺑﺮاي آن اﺑﺪاع ﺷﺪه اﺳﺖ و در اﻛﺜﺮ ﻧﺮم اﻓﺰارﻫﺎي رﻳﺎﺿﻲ و ﻣﻬﻨﺪﺳﻲ‬ ‫اﻟﮕﻮرﻳﺘﻤﻬﺎ و ﺗﻮاﺑﻌﻲ ﻧﻴﺰ ﺑﺮاي ﺣﻞ آﻧﻬﺎ ﻗﺮار داده ﺷﺪه اﺳﺖ‪.‬‬ ‫در ﻣﺘﻤﺘﻴﻜﺎ ﻧﻴﺰ دﺳﺘﻮراﺗﻲ ﺑﺮاي ﺣﻞ اﻳﻦ دو دﺳﺘﻪ ﻣﻌﺎدﻟﻪ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ ﺑﻪ ﺗﻮﺿﻴﺢ آﻧﻬﺎ ﻣﻴﭙﺮدازﻳﻢ‪.‬‬

‫‪                                                              ‬‬ ‫‪ Mathematica ‬‬

‫‪1‬‬

‫دﺳﺘﻮر‬

‫‪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‬ﻧﺘﻮاﻧﺪ ﻣﻘﺪار ﻣﻴﻨﻴﻤﻢ را ﭘﻴﺪا ﻛﻨﺪ و ﻳﺎ ﺗﺎﺑﻊ ﻣﻴﻨﻴﻤﻢ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ ﺧﺮوﺟﻲ ﺑﻪ ﺻﻮرت‬ ‫زﻳﺮ اﺳﺖ‪  .‬‬ ‫‪ ‬ﺧﺼﻮﺻﻴﺎت زﻳﺮ ﺑﺮاي دﺳﺘﻮر در دﺳﺘﺮس ﻫﺴﺘﻨﺪ‪  :‬‬

‫‪ ‬ﻣﻘﺪار‬

‫ﺑﻪ ﻃﻮر ﭘﻴﺶ ﻓﺮض ﺑﺮاﺑﺮ‬

‫و‬

‫‪ ‬ﻣﻘﺎدﻳﺮ ﻣﺠﺎز ﺑﺮاي ‪ Method‬ﻋﺒﺎرﺗﻨﺪ از‪:‬‬

‫اﺳﺖ‪  .‬‬

‫‪"NelderMead",    "DifferentialEvolution",   ‬‬

‫‪ "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‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ‪ ،‬دارﻳﻢ‪:‬‬

‫ﻛﻪ ﺑﺎز ﻧﺸﺎن دﻫﻨﺪه اﻳﻦ اﺳﺖ ﻛﻪ ﺗﺎﺑﻊ ﺟﻮاب ﺻﺤﻴﺢ ﻧﺎﻣﻨﻔﻲ ﻧﺪارد‪  .‬‬

‫‪.3‬‬

‫ﺑﺎ روش ﺟﺴﺘﺠﻮي ﮔﺮادﻳﺎن ﻣﺴﺌﻠﻪ زﻳﺮ را ﺣﻞ ﻛﻨﻴﺪ و ﺗﺎ ‪ 4‬ﻣﺮﺣﻠﻪ و ﻧﻘﻄﻪ آﻏﺎزي‬

‫ﺣﻞ‪:‬‬

‫‪.‬‬

‫‪.4‬‬

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

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

‫‪.4‬‬

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

‫ﺣﻞ‪:‬‬