## example10_4 from powell import * from numarray import array from math import sqrt def F(x): lam = 1.0 # Penalty multiplier c = x[0]*x[1] - 5.0 # Constraint equation return distSq(x) + lam*c**2 # Penalized merit function def distSq(x): return (x[0] - 5)**2 + (x[1] - 8)**2 xStart = array([1.0,5.0]) x,numIter = powell(F,xStart,0.01) print "Intersection point =",x print "Minimum distance =", sqrt(distSq(x)) print "xy =", x[0]*x[1] print "Number of cycles =",numIter raw_input ("Press return to exit")
def powellConstr(F, x0in, constrains=[], deltas=[], thetas=[], cMin=0.01, iterations=100, m2=10, m1=0.25, bracketStep=0.001, goldenSearchWindow=0.001, epsilon=1.0e-6, bracketing=True, epsilonGoldenSearch=1.0e-6): x0 = deepcopy(x0in) x0list = [] locThetas = [] locDeltas = [] c0 = 1e6 cOutList = [] stopValueList = [] stopNormList = [] nIterList = [] for theta in thetas: locThetas.append(theta) for delta in deltas: locDeltas.append(delta) def H(sum): if sum > 0: return 1 if sum <= 0: return 0 #--------------------------------------------------------------------------------# # TUTAJ BEZ OGRANICZEN POLICZY if len(constrains) == 0: #print("Nie ma ograniczen!") x0, nIter, success, stopValue, stopNorm = powell( F, x0, epsilon=epsilon, iterations=iterations, bracketing=bracketing, bracketStep=bracketStep, goldenSearchWindow=goldenSearchWindow, epsilonGoldenSearch=epsilonGoldenSearch) if not success: return False, x0list, stopValue, stopNorm, nIter, cOutList #print("Pkt minimum:", x0) #print("F(x):", F(x0)) x0list.append(x0) cOutList.append(0) stopValueList.append(stopValue) stopNormList.append(stopNorm) nIterList.append(nIter) return True, x0list, stopValueList, stopNormList, nIterList, cOutList #--------------------------------------------------------------------------------# # WPROWADZANIE OGRANICZEN c = 0 sixStep = False for k in range(iterations): # Allow for 100 cycles as default: #print("_"*80) #print("Step: ", k) #print("Deltas:", locDeltas) #print("Thetas:", locThetas) #print("X0:", x0) def sumOfConstr(x): value = 0 for i in range(len(constrains)): value += locDeltas[i] * ( constrains[i](x) + locThetas[i])**2 * H(constrains[i](x) + locThetas[i]) return value def f(x): return F(x) + sumOfConstr(x) # F in direction of v # 2 Dokonaj minimalizacji funkcji oraz uzyskany pkt ekstremalny podstaw w miejsce x0, a ponadto c w miejsce c0 x0, nIter, success, stopValue, stopNorm = powell( f, x0, epsilon=epsilon, iterations=iterations, bracketing=bracketing, bracketStep=bracketStep, goldenSearchWindow=goldenSearchWindow, epsilonGoldenSearch=epsilonGoldenSearch) if not success: return False, x0list, stopValueList, stopNormList, nIterList, cOutList x0list.append(x0) stopValueList.append(stopValue) stopNormList.append(stopNorm) nIterList.append(nIter) # print("x0 w trakcie:", x0) c0 = c # 3 Oblicz w punkcie ekstremalnym wartoœæ ograniczeñ gi(x) dla i=1,...,m oraz now¹ wartoœæ c w myœl zasady constrViolation = [] for i in range(len(constrains)): temp = constrains[i](x0) + locThetas[i] if temp > 0: #print("Violation of constraint", i) constrViolation.append(abs(constrains[i](x0))) # Nale¿y siê upewniæ, ¿e jest ograniczenie, ktore nie zostalo spelnione if len(constrViolation) > 0: c = max(constrViolation) cOutList.append(c) #print("The largest violation of constraints:", c) # 4 zbadaj czy zosta³o spe³nione kryterium na "minimum" tzn. czy c<cMin. if c < cMin: #print('zostalo spelnione kryterium na "minimum" tzn. czy c<cMi') #print(f(x0)) #print ("Xmin:", x0) return True, x0list, stopValueList, stopNormList, nIterList, cOutList # Jeœli tak to zakoñcz dzia³anie procedury, natomiast jeœli nie to kolejne kroki. # 5 Zbadaj czy po minimalizacji (krok 2) nastapilo zmniejszenie naruszenia ograniczen, # tzn. czy c<c0. Jesli tak, to przejdz do wykonania kroku (8), if c < c0: # Tutaj jest robiony krok 8 # 8 Jesli k=0 lub w poprzedniej iteracji byl krok 6 to if k == 0 or sixStep: # To jest krok 8a, zmien wartosci theta w mysl zasady: for i in range(len(locThetas)): locThetas[i] = min(constrains[i](x0) + locThetas[i], 0) sixStep = False # nie bylo 6 kroku w tej iteracji continue else: # Krok 8b if c <= m1 * c0: # Wykonaj krok 8a, zmien wartosci theta w mysl zasady: for i in range(len(locThetas)): locThetas[i] = min(constrains[i](x0) + locThetas[i], 0) else: # Wykonaj krok 6: sixStep = True modifiedIndexes = [] for i in range(len(locDeltas)): if (abs((constrains[i](x0)) > m1 * c0) and (constrains[i](x0) + locThetas[i] > 0)): modifiedIndexes.append(i) for i in modifiedIndexes: locDeltas[i] *= m2 locThetas[i] /= m2 continue # Natomiast w przecinwym razie podstaw na miejsce c jego wartosc przed minimalizacja, tzn c=c0 else: c = c0 # 6 Zmien wartosc parametriw delta i theta wedlug reguly: delta = m2*delta, theta = theta/m2 modifiedIndexes = [] for i in range(len(locDeltas)): if (abs((constrains[i](x0)) > m1 * c0) and (constrains[i](x0) + locThetas[i] > 0)): modifiedIndexes.append(i) for i in modifiedIndexes: locDeltas[i] *= m2 locThetas[i] /= m2 return True, x0list, stopValueList, stopNormList, nIterList, cOutList
def powellConstr(F, x0, constrains=[], deltas=[], thetas=[], cMin=0.01, iterations=100, m2=10, m1=0.25): print("Number of constraints:", len(constrains)) c = 0.01 locThetas = [] locDeltas = [] for theta in thetas: locThetas.append(theta) for delta in deltas: locDeltas.append(delta) print("Deltas:", deltas) print("Thetas:", thetas) def H(sum): if sum > 0: return 1 if sum <= 0: return 0 for j in range(iterations): # Allow for 100 cycles as default: print("_"*80) print("Step: ", j) print("Deltas:", locDeltas) def sumOfConstr(x): value = 0 for i in range(len(constrains)): value += locDeltas[i]*(constrains[i](x)+locThetas[i])**2*H(constrains[i](x)+locThetas[i]) return value def f(x): return F(x) + sumOfConstr(x) # F in direction of v # 2 Dokonaj minimalizacji funkcji oraz uzyskany pkt ekstremalny podstaw w miejsce x0, a ponadto c w miejsce c0 x0, nIter, success = powell(f, x0) print("x0 w trakcie:", x0) c0 = c # 3 Oblicz w punkcie ekstremalnym wartoœæ ograniczeñ gi(x) dla i=1,...,m oraz now¹ wartoœæ c w myœl zasady constrViolation = [] for i in range(len(constrains)): temp = constrains[i](x0) + locThetas[i] if temp > 0: print("Violation of constraint", i) constrViolation.append(abs(constrains[i](x0))) # Nale¿y siê upewniæ, ¿e jest ograniczenie, ktore nie zostalo spelnione if len(constrViolation) > 0: c = max(constrViolation) print("The largest violation of constraints:", c) # 4 zbadaj czy zosta³o spe³nione kryterium na "minimum" tzn. czy c<cMin. if c < cMin: print('zostalo spelnione kryterium na "minimum" tzn. czy c<cMi') print(f(x0)) print ("Xmin:", x0) return x0 # Jeœli tak to zakoñcz dzia³anie procedury, natomiast jeœli nie to kolejne kroki. modifiedIndexes = [] for i in range(len(deltas)): if (abs((constrains[i](x0)) > m1*c0) and (constrains[i](x0) + locThetas[i] > 0)): modifiedIndexes.append(i) for i in modifiedIndexes: locDeltas[i] *= m2 locThetas[i] /= m2
## example10_3 from powell import * import numpy def F(x): return 100.0 * (x[1] - x[0]**2)**2 + (1 - x[0])**2 xStart = numpy.array([-1.0, 1.0]) xMin, nIter = powell(F, xStart) print "x =", xMin print "F(x) =", F(xMin) print "Number of cycles =", nIter raw_input("Press return to exit")
#!/usr/bin/python ## example10_5 from powell import * from numpy import array from math import sqrt from gaussElimin import * def F(x): global v, weight lam = 100.0 c = 2.0*sqrt(2.0) A = array([[c*x[1] + x[2], -x[2], x[2]] [-x[2], x[2], -x[2]], [ x[2], -x[2], c*x[0] + x[2]]])/c b = array([0.0, -1.0, 0.0]) v = gaussElimin(A,b) weight = x[0] + x[1] + sqrt(2.0)*x[2] penalty = max(0.0,abs(v[1]) - 1.0)**2 + max(0.0,-x[0])**2 + max(0.0,-x[1])**2 + max(0.0,-x[2])**2 return weight + penalty*lam xStart = array([1.0, 1.0, 1.0]) x,numIter = powell(F,xStart) print("x = ",x) print("v = ",v) print("Relative weight F = ",weight) print("Number of cycles = ",numIter) input("Press return to exit")
## example10_3 from powell import * from numarray import array def F(x): return 100.0*(x[1] - x[0]**2)**2 + (1 - x[0])**2 xStart = array([-1.0, 1.0]) xMin,nIter = powell(F,xStart) print "x =",xMin print "F(x) =",F(xMin) print "Number of cycles =",nIter raw_input ("Press return to exit")
def powellConstr(F, x0in, constrains=[], deltas=[], thetas=[], cMin=0.01, iterations=100, m2=10, m1=0.25, bracketStep=0.001, goldenSearchWindow=0.001, epsilon=1.0e-6, bracketing=True, epsilonGoldenSearch=1.0e-6): x0 = deepcopy(x0in) x0list = [] locThetas = [] locDeltas = [] c0 = 1e6 cOutList = [] stopValueList = [] stopNormList = [] nIterList = [] for theta in thetas: locThetas.append(theta) for delta in deltas: locDeltas.append(delta) def H(sum): if sum > 0: return 1 if sum <= 0: return 0 #--------------------------------------------------------------------------------# # TUTAJ BEZ OGRANICZEN POLICZY if len(constrains) == 0: #print("Nie ma ograniczen!") x0, nIter, success, stopValue, stopNorm = powell(F, x0, epsilon=epsilon, iterations=iterations, bracketing=bracketing, bracketStep=bracketStep, goldenSearchWindow=goldenSearchWindow, epsilonGoldenSearch=epsilonGoldenSearch) if not success: return False, x0list, stopValue, stopNorm, nIter, cOutList #print("Pkt minimum:", x0) #print("F(x):", F(x0)) x0list.append(x0) cOutList.append(0) stopValueList.append(stopValue) stopNormList.append(stopNorm) nIterList.append(nIter) return True, x0list, stopValueList, stopNormList, nIterList, cOutList #--------------------------------------------------------------------------------# # WPROWADZANIE OGRANICZEN c = 0 sixStep = False for k in range(iterations): # Allow for 100 cycles as default: #print("_"*80) #print("Step: ", k) #print("Deltas:", locDeltas) #print("Thetas:", locThetas) #print("X0:", x0) def sumOfConstr(x): value = 0 for i in range(len(constrains)): value += locDeltas[i]*(constrains[i](x)+locThetas[i])**2*H(constrains[i](x)+locThetas[i]) return value def f(x): return F(x) + sumOfConstr(x) # F in direction of v # 2 Dokonaj minimalizacji funkcji oraz uzyskany pkt ekstremalny podstaw w miejsce x0, a ponadto c w miejsce c0 x0, nIter, success, stopValue, stopNorm = powell(f, x0, epsilon=epsilon, iterations=iterations, bracketing=bracketing, bracketStep=bracketStep, goldenSearchWindow=goldenSearchWindow, epsilonGoldenSearch=epsilonGoldenSearch) if not success: return False, x0list, stopValueList, stopNormList, nIterList, cOutList x0list.append(x0) stopValueList.append(stopValue) stopNormList.append(stopNorm) nIterList.append(nIter) # print("x0 w trakcie:", x0) c0 = c # 3 Oblicz w punkcie ekstremalnym wartoœæ ograniczeñ gi(x) dla i=1,...,m oraz now¹ wartoœæ c w myœl zasady constrViolation = [] for i in range(len(constrains)): temp = constrains[i](x0) + locThetas[i] if temp > 0: #print("Violation of constraint", i) constrViolation.append(abs(constrains[i](x0))) # Nale¿y siê upewniæ, ¿e jest ograniczenie, ktore nie zostalo spelnione if len(constrViolation) > 0: c = max(constrViolation) cOutList.append(c) #print("The largest violation of constraints:", c) # 4 zbadaj czy zosta³o spe³nione kryterium na "minimum" tzn. czy c<cMin. if c < cMin: #print('zostalo spelnione kryterium na "minimum" tzn. czy c<cMi') #print(f(x0)) #print ("Xmin:", x0) return True, x0list, stopValueList, stopNormList, nIterList, cOutList # Jeœli tak to zakoñcz dzia³anie procedury, natomiast jeœli nie to kolejne kroki. # 5 Zbadaj czy po minimalizacji (krok 2) nastapilo zmniejszenie naruszenia ograniczen, # tzn. czy c<c0. Jesli tak, to przejdz do wykonania kroku (8), if c < c0: # Tutaj jest robiony krok 8 # 8 Jesli k=0 lub w poprzedniej iteracji byl krok 6 to if k == 0 or sixStep: # To jest krok 8a, zmien wartosci theta w mysl zasady: for i in range(len(locThetas)): locThetas[i] = min(constrains[i](x0) + locThetas[i], 0) sixStep = False # nie bylo 6 kroku w tej iteracji continue else: # Krok 8b if c <= m1*c0: # Wykonaj krok 8a, zmien wartosci theta w mysl zasady: for i in range(len(locThetas)): locThetas[i] = min(constrains[i](x0) + locThetas[i], 0) else: # Wykonaj krok 6: sixStep = True modifiedIndexes = [] for i in range(len(locDeltas)): if (abs((constrains[i](x0)) > m1*c0) and (constrains[i](x0) + locThetas[i] > 0)): modifiedIndexes.append(i) for i in modifiedIndexes: locDeltas[i] *= m2 locThetas[i] /= m2 continue # Natomiast w przecinwym razie podstaw na miejsce c jego wartosc przed minimalizacja, tzn c=c0 else: c = c0 # 6 Zmien wartosc parametriw delta i theta wedlug reguly: delta = m2*delta, theta = theta/m2 modifiedIndexes = [] for i in range(len(locDeltas)): if (abs((constrains[i](x0)) > m1*c0) and (constrains[i](x0) + locThetas[i] > 0)): modifiedIndexes.append(i) for i in modifiedIndexes: locDeltas[i] *= m2 locThetas[i] /= m2 return True, x0list, stopValueList, stopNormList, nIterList, cOutList