/ / घातीय चर के साथ नॉनलाइनियर पूर्णांक प्रोग्रामिंग को हल करना

घातीय चर के साथ nonlinear पूर्णांक प्रोग्रामिंग हल - matlab, गणितीय अनुकूलन, nonlinear- अनुकूलन, पूर्णांक प्रोग्रामिंग

हर कोई। मैं अपने शोध के लिए कुछ सूत्र तैयार करता हूं। मैं पूछना चाहता हूं कि क्या कोई उपकरण इस समस्या को हल कर सकता है। मैं कुछ टूल्स जैसे GLPK, कुछ MATLAB टूलबॉक्स… का सर्वे करता हूं लेकिन मेरा फॉर्मूला नॉनलाइन लगता है। मुझे इंटरनेट पर कुछ जानकारी मिली है, यह पूर्णांक प्रोग्रामिंग का एक विशेष मामला है जिसे 0-1 पूर्णांक प्रोग्रामिंग कहा जाता है।

मेरा शक है: क्या मैं निम्नलिखित सूत्र की तरह घातीय में द्विआधारी चर डाल सकता हूं? और क्या इस समस्या को हल करते समय "उत्पाद (पीआई)" का उपयोग करना उपलब्ध है? मैं कुछ उदाहरणों का सर्वेक्षण करता हूं, लेकिन मुझे यह दो प्रयोग नहीं मिले।

चर Xc, n, m, s, i है। और, Lc, n, Tmax, Tm, Pm, s, i, Dc, n, k, और Bm सभी ज्ञात संख्या हैं।

क्या कोई मुझे इस समस्या पर कुछ सुझाव दे सकता है? पढ़ने के लिए धन्यवाद!

मैं चित्र अपडेट करता हूं, और अपने सूत्र के लिए AMPL भाषा का उपयोग करने का प्रयास करता हूं।

यहां छवि विवरण दर्ज करें

    #AMPL model language

#known numbers
param L{c in 0..C, n in 0..N};
param Tmax;
param T{m in 0..M};
param P{m in 0..M, s in 0..S, i in 0..I};
param D{c in 0..C, n in 0..N, k in 0..K};

#binary variable
var X{c in 0..C, n in 0..N, m in 0..M, s in 0..S, i in 0..I} binary;

#objective function
maximize answer: sum{c in 0..C} r[c];

#two subjections
subject to s1{s in 0..S, i in 0..I}:
sum{c in 0..C}sum{n in 0..N}sum{m in 0..M} X[c,n,m,s,i] <= 1;

subject to s2{c in 0..C, n in 0..N}:
L[c,n]+Tmax >= sum{m in 0..M}sum{s in 0..S}sum{i in 0..I}T[m]*X[c,n,m,s,i] >= L[c,n];

#where (I am not sure is it wright to write like this? Can somebody give me a hint?)
V[c,n]=prod{k in 0..N}(prod{m in 0..M}prod{s in 0..S}prod{i in 0..I} P[m,s,i])^X[c,n,m,s,i])^D{c,n,k};
r[c]=prod{n in 0..N}V[c,n]*(sum{m in 0..M}sum{s in 0..S}sum{i in 0..I}T[m]*X[c,n,m,s,i]);

चर एक्स को घातीय से निकालने के लिए तार्किक अवरोध का उपयोग करते हुए संशोधन:

    ### model_c.mod ###
set C;
set N;
set M;
set S;
set I;
set K;

param Tmax;  #known numbers
param L{c in C, n in N};
param T{m in M};
param P{m in M, s in S, i in I};
param D{c in C, n in N, k in K};

var X{c in C, n in N, m in M, s in S, i in I} binary;  #binary variable
var Y{c in C, n in N};

maximize answer:
(sum{c in C}(prod{n in N}(prod{k in K}Y[c,n]^D[c,n,k])*(sum{m in M}sum{s in S}sum{i in I}T[m]*X[c,n,m,s,i]))); #objective function

subject to s1{c in C, n in N, m in M, s in S, i in I}:
Y[c,n]=Y[c,n]*((P[m,s,i]-1)*X[c,n,m,s,i]+1);

subject to s2{s in S, i in I}:
sum{c in C}sum{n in N}sum{m in M} X[c,n,m,s,i] <= 1;

subject to s3{c in C, n in N}:
L[c,n]+Tmax >= sum{m in M}sum{s in S}sum{i in I}T[m]*X[c,n,m,s,i] >= L[c,n];

### model_c.dat ###
data;
set C:= count1, count2;
set N:= frame1, frame2;
set M:= M1, M2;
set S:= sub1, sub2;
set I:= i1, i2;
set K:= k1, k2;

param Tmax:=30;


param L: frame1 frame2:=
count1     2      3
count2     4      5;


param T:=  M1 10
M2 20;


param P:=
[*,*,i1]: sub1 sub2 :=
M1   0.9 0.8
M2   0.7 0.6

[*,*,i2]: sub1 sub2 :=
M1   0.9 0.8
M2   0.7 0.6;


param D:=
[*,*,k1]: frame1 frame2 :=
count1 1 0
count2 0 1

[*,*,k2]: frame1 frame2 :=
count1 1 0
count2 1 1;

उत्तर:

उत्तर № 1 के लिए 1

मैं नहीं जानता, लेकिन शायद SCIP और ऑप्टी टूलबॉक्स पर एक नज़र है। (या YALMIP) - (या सिक्का)

मेरे अनुभव में, मतलाब में निर्माण करना काफी परेशानी भरा है। हो सकता है कि .lp / .mps / .whatever आउटपुट फ़ाइल बनाना और Matlab, जो फ़ाइल पार्स करता है, .exe शुरू करना आसान होगा


उत्तर № 2 के लिए 1

यह मुझे लगता है कि वास्तव में आपके मॉडल को घातीय शब्दों के बिना सुधार किया जा सकता है: शब्द $ P ^ x $ वास्तव में एक तर्क बाधा के लिए उबलते हैं जो $ x = 0 $ या $ P $ $ x 1 के लिए $ 1 के बराबर होता है। $।

इसलिए मेरा सुझाव कुछ सहायक चर $ y $ को घातीय शब्दों को बदलने के लिए पेश करना है और फिर तर्क बाधाओं को स्थापित करना है।

परिणामी मॉडल अभी भी एक बहुत बड़ा MINLP है: आपको शायद एक सॉल्वर की तरह Couenne (मुक्त) या बैरन (वाणिज्यिक) चाहिए।

अद्यतन करें:

वास्तव में यह कहना आसान है:

y_ (m, s, i) = (P_ (m, s, i) -1) x_ (c, n, m, s, i) + 1

तब आप Y_ का उपयोग उस विशाल उत्पाद में करते हैं जो V_ (c, n) को परिभाषित करता है। जैसा कि आप देखते हैं, x = 0 के लिए आपको 1 मिलता है, x = 1 के लिए आपको P मिलता है।

इस तरह आपको किसी सशर्त अड़चन की जरूरत नहीं है।

वैसे भी, अगली बार मैं आपको इस तरह के सवाल को मैथवर्टफ्लो पर पोस्ट करने का सुझाव दूंगा।