def adjustr4WithDiscreteVariables(wr4, p): for i in p._discreteVarsNumList: v = p._freeVarsList[i] if v.domain is bool or v.domain is 'bool': wr4[:, i] = where(wr4[:, i]<0.5, 0, 1) else: tmp = wr4[:, i] d = v.domain if isPyPy: d2 = d.tolist() ind = atleast_1d([bisect_left(d2, val) for val in tmp]) ind2 = atleast_1d([bisect_right(d2, val) for val in tmp]) else: ind = searchsorted(d, tmp, side='left') ind2 = searchsorted(d, tmp, side='right') ind3 = where(ind!=ind2)[0] Tmp = tmp[ind3].copy() ind[ind==d.size] -= 1 # may be due to roundoff errors ind[ind==1] = 0 ind2[ind2==d.size] -=1 ind2[ind2==0] = 1 # may be due to roundoff errors tmp1 = asarray(d[ind], p.solver.dataType) tmp2 = asarray(d[ind2], p.solver.dataType) if Tmp.size!=0: if str(tmp1.dtype).startswith('int'): Tmp = asarray(Tmp, p.solver.dataType) tmp2[ind3] = Tmp.copy() tmp1[ind3] = Tmp.copy() tmp = where(abs(tmp-tmp1)<abs(tmp-tmp2), tmp1, tmp2) #print max(abs(tmp-tmp1)), max(abs(tmp-tmp2)) wr4[:, i] = tmp
def adjustr4WithDiscreteVariables(wr4, p): for i in p._discreteVarsNumList: v = p._freeVarsList[i] if v.domain is bool or v.domain is 'bool': wr4[:, i] = where(wr4[:, i] < 0.5, 0, 1) else: tmp = wr4[:, i] d = v.domain if isPyPy: d2 = d.tolist() ind = atleast_1d([bisect_left(d2, val) for val in tmp]) ind2 = atleast_1d([bisect_right(d2, val) for val in tmp]) else: ind = searchsorted(d, tmp, side='left') ind2 = searchsorted(d, tmp, side='right') ind3 = where(ind != ind2)[0] Tmp = tmp[ind3].copy() ind[ind == d.size] -= 1 # may be due to roundoff errors ind[ind == 1] = 0 ind2[ind2 == d.size] -= 1 ind2[ind2 == 0] = 1 # may be due to roundoff errors tmp1 = asarray(d[ind], p.solver.dataType) tmp2 = asarray(d[ind2], p.solver.dataType) if Tmp.size != 0: if str(tmp1.dtype).startswith('int'): Tmp = asarray(Tmp, p.solver.dataType) tmp2[ind3] = Tmp.copy() tmp1[ind3] = Tmp.copy() tmp = where(abs(tmp - tmp1) < abs(tmp - tmp2), tmp1, tmp2) #print max(abs(tmp-tmp1)), max(abs(tmp-tmp2)) wr4[:, i] = tmp
def _correct_box_constraints(lb, ub, pop): diff_lb = pop - lb check_lb = diff_lb < 0.0 scale = 1.0 while np.any(check_lb): check_lb = check_lb*1 pop = pop - (1+scale)*check_lb*diff_lb diff_lb = pop - lb check_lb = diff_lb < 0.0 scale /= 2 diff_ub = pop - ub check_ub = diff_ub > 0.0 scale = 1.0 while np.any(check_ub): check_ub = check_ub*1 pop = pop - (1+scale)*check_ub*diff_ub diff_ub = pop - ub check_ub = diff_ub > 0.0 scale /= 2 # temporary fix ind = where(pop<lb) if ind[0].size: pop[ind] = lb[ind[1]] ind = where(pop>ub) if ind[0].size: pop[ind] = ub[ind[1]] return pop
def func9(an, fo, g, p): #ind = searchsorted(ar, fo, side='right') if p.probType in ('NLSP', 'SNLE') and p.maxSolutions != 1: mino = atleast_1d([node.key for node in an]) ind = mino > 0 if not any(ind): return an, g else: g = nanmin((g, nanmin(mino[ind]))) ind2 = where(logical_not(ind))[0] #an = take(an, ind2, axis=0, out=an[:ind2.size]) #an = asarray(an[ind2]) an = [an[i] for i in ind2] return an, g elif p.solver.dataHandling == 'sorted': #OLD mino = [node.key for node in an] ind = bisect_right(mino, fo) if ind == len(mino): return an, g else: g = nanmin((g, nanmin(atleast_1d(mino[ind])))) return an[:ind], g elif p.solver.dataHandling == 'raw': #NEW mino = atleast_1d([node.key for node in an]) r10 = mino > fo if not any(r10): return an, g else: ind = where(r10)[0] g = nanmin((g, nanmin(atleast_1d(mino)[ind]))) #an = asarray(an) ind2 = where(logical_not(r10))[0] #an = take(an, ind2, axis=0, out=an[:ind2.size]) an = [an[i] for i in ind2] return an, g # NEW 2 # curr_tnlh = [node.tnlh_curr for node in an] # import warnings # warnings.warn('! fix g') return an, g else: assert 0, 'incorrect nodes remove approach'
def func13(o, a): m, n = o.shape n /= 2 # if case == 1: # U1, U2 = a[:, :n].copy(), a[:, n:] # #TODO: mb use nanmax(concatenate((U1,U2),3),3) instead? # U1 = where(logical_or(U1<U2, isnan(U1)), U2, U1) # return nanmin(U1, 1) L1, L2, U1, U2 = o[:, :n], o[:, n:], a[:, :n], a[:, n:] # if case == 2: U = where(logical_or(U1 < U2, isnan(U1)), U2, U1) L = where(logical_or(L2 < L1, isnan(L1)), L2, L1) return nanmax(U - L, 1)
def func13(o, a): m, n = o.shape n /= 2 # if case == 1: # U1, U2 = a[:, :n].copy(), a[:, n:] # #TODO: mb use nanmax(concatenate((U1,U2),3),3) instead? # U1 = where(logical_or(U1<U2, isnan(U1)), U2, U1) # return nanmin(U1, 1) L1, L2, U1, U2 = o[:, :n], o[:, n:], a[:, :n], a[:, n:] # if case == 2: U = where(logical_or(U1<U2, isnan(U1)), U2, U1) L = where(logical_or(L2<L1, isnan(L1)), L2, L1) return nanmax(U-L, 1)
def getPrimevalDilationMatrixWRTlinEqConstraints(self, p): n, Aeq, beq = p.n, p.Aeq, p.beq nLinEq = len(p.beq) ind_fixed = where(p.lb == p.ub)[0] arr = ones(n, dtype=self.T) arr[ind_fixed] = 0 b = diag(arr) if hasattr(Aeq, 'tocsc'): Aeq = Aeq.tocsc() for i in range(nLinEq): vec = Aeq[i] #raise 0 if hasattr(vec, 'toarray'): vec = vec.toarray().flatten() g = economyMult(b.T, vec) if not any(g): continue #ind_nnz = nonzero(g)[0] ng = norm(g) g = (g / ng).reshape(-1, 1) vec1 = p.matmult(b, g) # TODO: remove economyMult, use dot? vec2 = -g.T b += p.matmult(vec1, vec2) # if len(ind_nnz) > 0.7 * g.size: # b += p.matmult(vec1, vec2) # else: # ind_nnz1 = nonzero(vec1)[0] # ind_nnz2 = nonzero(vec2)[1] # r = dot(vec1[ind_nnz1, :], vec2[:, ind_nnz2]) # if p.debug: # assert abs(norm(p.matmult(vec1, vec2).flatten()) - norm(r.flatten())) < 1e-5 # b[ix_(ind_nnz1, ind_nnz2)] += r return b
def finalTextOutput(p, r): if type(p.msg) == ndarray: # from fmincon etc msg = asarray(p.msg.flatten(), int).tolist() p.msg = ''.join(chr(c) for c in msg) if p.iprint >= 0: if len(p.msg): p.disp("istop: " + str(r.istop) + ' (' + p.msg + ')') else: p.disp("istop: " + str(r.istop)) p.disp('Solver: Time Elapsed = ' + str(r.elapsed['solver_time']) + ' \tCPU Time Elapsed = ' + str(r.elapsed['solver_cputime'])) if p.plot: p.disp('Plotting: Time Elapsed = ' + str(r.elapsed['plot_time']) + ' \tCPU Time Elapsed = ' + str(r.elapsed['plot_cputime'])) if p.probType == 'MOP': msg = '%d solutions have been obtained' % len(p.solutions.coords) p.disp(msg) return # TODO: add output of NaNs number in constraints (if presernt) if p.useScaledResidualOutput: rMsg = 'max(residuals/requiredTolerances) = %g' % (r.rf / p.contol) else: rMsg = 'MaxResidual = %g' % r.rf if not p.isFeasible: nNaNs = (len(where(isnan(p.c(p.xf)))[0]) if p.c is not None and type(p.c)!=list else 0) \ + (len(where(isnan(p.h(p.xf)))[0]) if p.h is not None and type(p.h)!=list else 0) if nNaNs == 0: nNaNsMsg = '' elif nNaNs == 1: nNaNsMsg = '1 constraint is equal to NaN, ' else: nNaNsMsg = ('%d constraints are equal to NaN, ' % nNaNs) p.disp( 'NO FEASIBLE SOLUTION has been obtained (%s%s, objFunc = %0.8g)' % (nNaNsMsg, rMsg, r.ff)) else: if p.maxSolutions == 1: msg = "objFunValue: " + (p.finalObjFunTextFormat % r.ff) if not p.isUC: msg += ' (feasible, %s)' % rMsg else: msg = '%d solutions have been obtained' % len(p.solutions) p.disp(msg)
def _eval_pop(pop, p): NP = pop.shape[0] constr_vals = np.zeros(NP) vals = p.f(pop).flatten() if vals.size == 1: vals = np.array([vals]*NP) vals[np.isnan(vals)] = np.inf if p.__isNoMoreThanBoxBounded__(): best_i = vals.argmin() best = (vals[best_i], 0, pop[best_i]) else: # new = 1 # # if new:# and p.isFDmodel: # TODO: handle nanPenalty * newPoint.nNaNs() #vals = np.empty(pop.shape[0]) #vals.fill(np.nan) P = p.point(pop) constr_vals = P.mr(checkBoxBounds = False) + nanPenalty * P.nNaNs() ind = constr_vals < p.contol if not np.any(ind): j = np.argmin(constr_vals) bestPoint = p.point(pop[j]) #bestPoint.i = j else: IND = where(ind)[0] #print(IND, pop.shape) try: P2 = np.atleast_2d(pop[IND]) F = np.atleast_1d(vals[IND]) except: # PyPy P2 = np.atleast_2d([pop[j] for j in IND]) F = np.atleast_1d([vals[j] for j in IND]) J = np.nanargmin(F) bestPoint = p.point(P2[J], f=F[J])# TODO: other fields #bestPoint.i = IND[J] #bestPoint.i = where(ind)[0] best = (bestPoint.f(), bestPoint.mr() + nanPenalty * bestPoint.nNaNs(), bestPoint.x) # print(vals, constr_vals) # from openopt.kernel.ooMisc import isSolved # raise isSolved return best, vals, constr_vals
def func2(y, e, t, vv): #, tnlhf_curr): #assert y.size != 0 if y.size == 0: return y.copy(), e.copy() # especially for PyPy new_y, new_e = y.copy(), e.copy() m, n = y.shape w = arange(m) #!!!! TODO: omit or imporove it for all-float problems th = (new_y[w, t] + new_e[w, t]) / 2 ### !!!!!!!!!!!!!!!!!!!!! # TODO: rework it for integer dataType BoolVars = [(v.domain is bool or v.domain is 'bool') for v in vv] if not str(th.dtype).startswith('float') and any(BoolVars): indBool = where(BoolVars)[0] if len(indBool) != n: #boolCoords = list(set(indBool) & set(t)) boolCoords = where([t[j] in indBool for j in range(m)])[0] new_y[w, t] = th new_e[w, t] = th new_y[boolCoords, t[boolCoords]] = 1 new_e[boolCoords, t[boolCoords]] = 0 else: new_y[w, t] = 1 new_e[w, t] = 0 else: # print new_y.shape, w.shape, t.shape, th.shape new_y[w, t] = th new_e[w, t] = th new_y = vstack((y, new_y)) new_e = vstack((new_e, e)) # if tnlhf_curr is not None: # tnlhf_curr_local = hstack((tnlhf_curr[w, t], tnlhf_curr[w, n+t])) # else: # tnlhf_curr_local = None return new_y, new_e #, tnlhf_curr_local
def func2(y, e, t, vv):#, tnlhf_curr): #assert y.size != 0 if y.size == 0: return y.copy(), e.copy() # especially for PyPy new_y, new_e = y.copy(), e.copy() m, n = y.shape w = arange(m) #!!!! TODO: omit or imporove it for all-float problems th = (new_y[w, t] + new_e[w, t]) / 2 ### !!!!!!!!!!!!!!!!!!!!! # TODO: rework it for integer dataType BoolVars = [(v.domain is bool or v.domain is 'bool') for v in vv] if not str(th.dtype).startswith('float') and any(BoolVars): indBool = where(BoolVars)[0] if len(indBool) != n: #boolCoords = list(set(indBool) & set(t)) boolCoords = where([t[j] in indBool for j in range(m)])[0] new_y[w, t] = th new_e[w, t] = th new_y[boolCoords, t[boolCoords]] = 1 new_e[boolCoords, t[boolCoords]] = 0 else: new_y[w, t] = 1 new_e[w, t] = 0 else: # print new_y.shape, w.shape, t.shape, th.shape new_y[w, t] = th new_e[w, t] = th new_y = vstack((y, new_y)) new_e = vstack((new_e, e)) # if tnlhf_curr is not None: # tnlhf_curr_local = hstack((tnlhf_curr[w, t], tnlhf_curr[w, n+t])) # else: # tnlhf_curr_local = None return new_y, new_e#, tnlhf_curr_local
def func7(y, e, o, a, _s, indT, nlhc, residual): r10 = logical_and(all(isnan(o), 1), all(isnan(a), 1)) if any(r10): j = where(logical_not(r10))[0] lj = j.size y = take(y, j, axis=0, out=y[:lj]) e = take(e, j, axis=0, out=e[:lj]) o = take(o, j, axis=0, out=o[:lj]) a = take(a, j, axis=0, out=a[:lj]) _s = _s[j] if indT is not None: indT = indT[j] if nlhc is not None: nlhc = take(nlhc, j, axis=0, out=nlhc[:lj]) if residual is not None: residual = take(residual, j, axis=0, out=residual[:lj]) return y, e, o, a, _s, indT, nlhc, residual
def adjustDiscreteVarBounds(y, e, _s, indT, p): #n = p.n # TODO: remove the cycle, use vectorization for i in p._discreteVarsNumList: v = p._freeVarsList[i] #y += 100 adjust_lx_WithDiscreteDomain(y[:, i], v) adjust_ux_WithDiscreteDomain(e[:, i], v) Ind = any(y > e, 1) # TODO: is it triggered? // updated: can be from MOP or cons if any(Ind): ind = where(logical_not(Ind))[0] s = ind.size y = take(y, ind, axis=0, out=y[:s]) e = take(e, ind, axis=0, out=e[:s]) _s = _s[ind] if indT is not None: indT = indT[ind] return y, e, _s, indT
def adjustDiscreteVarBounds(y, e, _s, indT, p): #n = p.n # TODO: remove the cycle, use vectorization for i in p._discreteVarsNumList: v = p._freeVarsList[i] #y += 100 adjust_lx_WithDiscreteDomain(y[:, i], v) adjust_ux_WithDiscreteDomain(e[:, i], v) Ind = any(y>e, 1) # TODO: is it triggered? // updated: can be from MOP or cons if any(Ind): ind = where(logical_not(Ind))[0] s = ind.size y = take(y, ind, axis=0, out=y[:s]) e = take(e, ind, axis=0, out=e[:s]) _s = _s[ind] if indT is not None: indT = indT[ind] return y, e, _s, indT
def func5(an, nn, g, p): m = len(an) if m <= nn: return an, g mino = np.array([node.key for node in an]) if nn == 1: # box-bound probs with exact interval analysis ind = argmin(mino) assert ind in (0, 1), 'error in interalg engine' g = nanmin((mino[1-ind], g)) an = [an[i] for i in ind] elif m > nn: if p.solver.dataHandling == 'raw': ind = argsort(mino) th = mino[ind[nn]] ind2 = where(mino < th)[0] g = nanmin((th, g)) #an = take(an, ind2, axis=0, out=an[:ind2.size]) an = [an[i] for i in ind2]#an[ind2] else: g = nanmin((mino[nn], g)) an = an[:nn] return an, g
def func5(an, nn, g, p): m = len(an) if m <= nn: return an, g mino = np.array([node.key for node in an]) if nn == 1: # box-bound probs with exact interval analysis ind = argmin(mino) assert ind in (0, 1), 'error in interalg engine' g = nanmin((mino[1 - ind], g)) an = [an[i] for i in ind] elif m > nn: if p.solver.dataHandling == 'raw': ind = argsort(mino) th = mino[ind[nn]] ind2 = where(mino < th)[0] g = nanmin((th, g)) #an = take(an, ind2, axis=0, out=an[:ind2.size]) an = [an[i] for i in ind2] #an[ind2] else: g = nanmin((mino[nn], g)) an = an[:nn] return an, g
def func12(an, maxActiveNodes, p, Solutions, vv, varTols, fo): solutions, r6 = Solutions.solutions, Solutions.coords if len(an) == 0: return array([]), array([]), array([]), array([]) _in = an if r6.size != 0: r11, r12 = r6 - varTols, r6 + varTols y, e, S = [], [], [] Tnlhf_curr_local = [] n = p.n N = 0 maxSolutions = p.maxSolutions # new = 1 # # new # if new and p.probType in ('MOP', 'SNLE', 'GLP', 'NLP', 'MINLP') and p.maxSolutions == 1: # # # return y, e, _in, _s while True: an1Candidates, _in = func3(_in, maxActiveNodes, p.solver.dataHandling) #print nanmax(2**(-an1Candidates[0].tnlh_curr)) , nanmax(2**(-an1Candidates[-1].tnlh_curr)) yc, ec, oc, ac, SIc = asarray([t.y for t in an1Candidates]), \ asarray([t.e for t in an1Candidates]), \ asarray([t.o for t in an1Candidates]), \ asarray([t.a for t in an1Candidates]), \ asarray([t._s for t in an1Candidates]) if p.probType == 'MOP': tnlhf_curr = asarray([t.tnlh_all for t in an1Candidates]) tnlhf = None elif p.solver.dataHandling == 'raw': tnlhf = asarray([t.tnlhf for t in an1Candidates]) tnlhf_curr = asarray([t.tnlh_curr for t in an1Candidates]) else: tnlhf, tnlhf_curr = None, None if p.probType != 'IP': #nlhc = asarray([t.nlhc for t in an1Candidates]) #residual = asarray([t.residual for t in an1Candidates]) residual = None indT = func4(p, yc, ec, oc, ac, fo, tnlhf_curr) if an1Candidates[0].indtc is not None: indtc = asarray([t.indtc for t in an1Candidates]) indT = logical_or(indT, indtc) else: residual = None indT = None t, _s, indD = func1(tnlhf, tnlhf_curr, residual, yc, ec, oc, ac, SIc, p, indT) new = 0 nn = 0 if new and p.probType in ('MOP', 'SNLE', 'NLSP', 'GLP', 'NLP', 'MINLP') and p.maxSolutions == 1: arr = tnlhf_curr if p.solver.dataHandling == 'raw' else oc M = arr.shape[0] w = arange(M) Midles = 0.5 * (yc[w, t] + ec[w, t]) arr_1, arr2 = arr[w, t], arr[w, n + t] Arr = hstack((arr_1, arr2)) ind = np.argsort(Arr) Ind = set(ind[:maxActiveNodes]) tag_all, tag_1, tag_2 = [], [], [] sn = [] # TODO: get rid of the cycles for i in range(M): cond1, cond2 = i in Ind, (i + M) in Ind if cond1: if cond2: tag_all.append(i) else: tag_1.append(i) else: if cond2: tag_2.append(i) else: sn.append(an1Candidates[i]) list_lx, list_ux = [], [] _s_new = [] updateTC = an1Candidates[0].indtc is not None isRaw = p.solver.dataHandling == 'raw' for i in tag_1: node = an1Candidates[i] I = t[i] # if node.o[n+I] >= node.o[I]: # print '1' # else: # print i, I, node.o[n+I] , node.o[I], node.key, node.a[n+I] , node.a[I], node.nlhc[n+I], node.nlhc[I] node.key = node.o[n + I] node._s = _s[i] if isRaw: node.tnlh_curr[I] = node.tnlh_curr[n + I] node.tnlh_curr_best = nanmin(node.tnlh_curr) #assert node.o[n+I] >= node.o[I] #lx, ux = node.y, node.e lx, ux = yc[i], ec[i] if nn: #node.o[I], node.a[I] = node.o[n+I], node.a[n+I] node.o[I], node.a[I] = node.o[n + I], node.a[n + I] node.o[node.o < node.o[n + I]], node.a[ node.a > node.a[n + I]] = node.o[n + I], node.a[n + I] else: node.o[n + I], node.a[n + I] = node.o[I], node.a[I] node.o[node.o < node.o[I]], node.a[ node.a > node.a[I]] = node.o[I], node.a[I] # if p.solver.dataHandling == 'raw': for Attr in ('nlhf', 'nlhc', 'tnlhf', 'tnlh_curr', 'tnlh_all'): r = getattr(node, Attr, None) if r is not None: if nn: r[I] = r[n + I] else: r[n + I] = r[I] mx = ux.copy() mx[I] = Midles[i] #0.5*(lx[I] + ux[I]) list_lx.append(lx) list_ux.append(mx) node.y = lx.copy() node.y[I] = Midles[i] #0.5*(lx[I] + ux[I]) if updateTC: node.indtc = True _s_new.append(node._s) sn.append(node) for i in tag_2: node = an1Candidates[i] I = t[i] node.key = node.o[I] node._s = _s[i] # for raw only if isRaw: node.tnlh_curr[n + I] = node.tnlh_curr[I] node.tnlh_curr_best = nanmin(node.tnlh_curr) #assert node.o[I] >= node.o[n+I] #lx, ux = node.y, node.e lx, ux = yc[i], ec[i] if nn: node.o[n + I], node.a[n + I] = node.o[I], node.a[I] node.o[node.o < node.o[I]], node.a[ node.a > node.a[I]] = node.o[I], node.a[I] else: node.o[I], node.a[I] = node.o[n + I], node.a[n + I] node.o[node.o < node.o[n + I]], node.a[ node.a > node.a[n + I]] = node.o[n + I], node.a[n + I] for Attr in ('nlhf', 'nlhc', 'tnlhf', 'tnlh_curr', 'tnlh_all'): r = getattr(node, Attr, None) if r is not None: if nn: r[n + I] = r[I] else: r[I] = r[n + I] mx = lx.copy() mx[I] = Midles[i] #0.5*(lx[I] + ux[I]) list_lx.append(mx) list_ux.append(ux) node.e = ux.copy() node.e[I] = Midles[i] #0.5*(lx[I] + ux[I]) if updateTC: node.indtc = True _s_new.append(node._s) sn.append(node) for i in tag_all: node = an1Candidates[i] I = t[i] #lx, ux = node.y, node.e lx, ux = yc[i], ec[i] mx = ux.copy() mx[I] = Midles[i] #0.5 * (lx[I] + ux[I]) list_lx.append(lx) list_ux.append(mx) mx = lx.copy() mx[I] = Midles[i] #0.5 * (lx[I] + ux[I]) #mx[n+ t] = 0.5 * (lx[n + t] + ux[n + t]) list_lx.append(mx) list_ux.append(ux) #_s_new += [_s[i]] * 2 _s_new.append(_s[i]) _s_new.append(_s[i]) # print 'y_new:', vstack(list_lx) # print 'e_new:', vstack(list_ux) # print '_s_new:', hstack(_s) _in = sn + _in.tolist() if p.solver.dataHandling == 'sorted': _in.sort(key=lambda obj: obj.key) else: #pass _in.sort(key=lambda obj: obj.tnlh_curr_best) # print 'tag 1:', len(tag_1), 'tag 2:', len(tag_2), 'tag all:', len(tag_all) # print 'lx:', list_lx # print 'sn lx:', [node.y for node in sn] # print 'ux:', list_ux # print 'sn ux:', [node.e for node in sn] # print '-'*10 #print '!', vstack(list_lx), vstack(list_ux), hstack(_s_new) NEW_lx, NEW_ux, NEW__in, NEW__s = \ vstack(list_lx), vstack(list_ux), array(_in), hstack(_s_new) return NEW_lx, NEW_ux, NEW__in, NEW__s NewD = 1 if NewD and indD is not None: s4d = _s[indD] sf = _s[logical_not(indD)] _s = hstack((s4d, s4d, sf)) yf, ef = yc[logical_not(indD)], ec[logical_not(indD)] yc, ec = yc[indD], ec[indD] t = t[indD] else: _s = tile(_s, 2) #yc, ec, tnlhf_curr_local = func2(yc, ec, t, vv, tnlhf_curr) yc, ec = func2(yc, ec, t, vv) if NewD and indD is not None: yc = vstack((yc, yf)) ec = vstack((ec, ef)) if maxSolutions == 1 or len(solutions) == 0: #y, e, Tnlhf_curr_local = yc, ec, tnlhf_curr_local y, e = yc, ec break # TODO: change cycle variable if len(solutions) >> maxActiveNodes for i in range(len(solutions)): ind = logical_and(all(yc >= r11[i], 1), all(ec <= r12[i], 1)) if any(ind): j = where(logical_not(ind))[0] lj = j.size yc = take(yc, j, axis=0, out=yc[:lj]) ec = take(ec, j, axis=0, out=ec[:lj]) _s = _s[j] # if tnlhf_curr_local is not None: # tnlhf_curr_local = tnlhf_curr_local[j] y.append(yc) e.append(ec) S.append(_s) #Tnlhf_curr_local.append(tnlhf_curr_local) N += yc.shape[0] if len(_in) == 0 or N >= maxActiveNodes: y, e, _s = vstack(y), vstack(e), hstack(S) #Tnlhf_curr_local = hstack(Tnlhf_curr_local) break # if Tnlhf_curr_local is not None and len(Tnlhf_curr_local) != 0 and Tnlhf_curr_local[0] is not None: # #print len(where(isfinite(Tnlhf_curr_local))[0]), Tnlhf_curr_local.size # pass # print 'y_prev:', y # print 'e_prev:', e # print '_s_prev:', hstack(_s) #print 'prev!', y, e, _s # from numpy import array_equal # if not array_equal(NEW_lx.sort(), y.sort()): # pass # if not array_equal(NEW_ux.sort(), e.sort()): # pass # if not array_equal(NEW__s.sort(), _s.sort()): # pass #, NEW_ux, NEW__in, NEW__s return y, e, _in, _s
def func11(y, e, nlhc, indTC, residual, o, a, _s, p): m, n = y.shape if p.probType == "IP": w = arange(m) # TODO: omit recalculation from func1 ind = nanargmin(a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:], 1) sup_inf_diff = 0.5 * (a[w, ind] - o[w, ind] + a[w, n + ind] - o[w, n + ind]) diffao = a - o minres_ind = nanargmin(diffao, 1) minres = diffao[w, minres_ind] complementary_minres = diffao[w, where(minres_ind < n, minres_ind + n, minres_ind - n)] volume = prod(e - y, 1) volumeResidual = volume * sup_inf_diff F = 0.25 * (a[w, ind] + o[w, ind] + a[w, n + ind] + o[w, n + ind]) return [ si(IP_fields, sup_inf_diff[i], minres[i], minres_ind[i], complementary_minres[i], y[i], e[i], o[i], a[i], _s[i], F[i], volume[i], volumeResidual[i]) for i in range(m) ] else: residual = None isSNLE = p.probType in ('SNLE', 'NLSP') if 1 or not isSNLE: o, a = asarray(o), asarray(a) a[a == inf] = 1e300 o[o == -inf] = -1e300 tmp = a - o tmp[tmp < 1e-300] = 1e-300 # ind_uf_inf = where(a==inf)[0] # if ind_uf_inf.size: # Tmp = o[ind_uf_inf] # Tmp[Tmp==-inf] = -1e100 # M = nanmax(abs(Tmp)) # if M is nan or M == 0.0: # M = 1.0 # tmp[ind_uf_inf] = 1e200 * (1.0 + Tmp/M) nlhf = log2(tmp) #-log2(p.fTol) # nlhf[a==inf] = 1e300# to make it not inf and nan # nlhf[o==-inf] = 1e300# to make it not inf and nan if p.probType == "MOP": if nlhf.ndim == 3: # in MOP nlhf = nlhf.sum(axis=1) else: assert 0, 'bug in interalg' # make correct o,a wrt each target return [ si(MOP_Fields, y[i], e[i], nlhf[i], nlhc[i] if nlhc is not None else None, indTC[i] if indTC is not None else None, residual[i] if residual is not None else None, [o[i][k] for k in range(p.nf)], [a[i][k] for k in range(p.nf)], _s[i]) for i in range(m) ] else: assert p.probType in ('GLP', 'NLP', 'NSP', 'SNLE', 'NLSP', 'MINLP', 'QP', 'LP', 'MILP') if 0 and isSNLE: nlhf = Tmp = o = a = [None] * m else: s, q = o[:, 0:n], o[:, n:2 * n] Tmp = nanmax(where(q < s, q, s), 1) nlhf[logical_and(isinf(a), isinf(nlhf))] = 1e300 # residual = None return [ si(Fields, Tmp[i], y[i], e[i], nlhf[i], nlhc[i] if nlhc is not None else None, indTC[i] if indTC is not None else None, residual[i] if residual is not None else None, o[i], a[i], _s[i]) for i in range(m) ]
def func12(an, maxActiveNodes, p, Solutions, vv, varTols, fo): solutions, r6 = Solutions.solutions, Solutions.coords if len(an) == 0: return array([]), array([]), array([]), array([]) _in = an if r6.size != 0: r11, r12 = r6 - varTols, r6 + varTols y, e, S = [], [], [] Tnlhf_curr_local = [] n = p.n N = 0 maxSolutions = p.maxSolutions # new = 1 # # new # if new and p.probType in ('MOP', 'SNLE', 'GLP', 'NLP', 'MINLP') and p.maxSolutions == 1: # # # return y, e, _in, _s while True: an1Candidates, _in = func3(_in, maxActiveNodes, p.solver.dataHandling) #print nanmax(2**(-an1Candidates[0].tnlh_curr)) , nanmax(2**(-an1Candidates[-1].tnlh_curr)) yc, ec, oc, ac, SIc = asarray([t.y for t in an1Candidates]), \ asarray([t.e for t in an1Candidates]), \ asarray([t.o for t in an1Candidates]), \ asarray([t.a for t in an1Candidates]), \ asarray([t._s for t in an1Candidates]) if p.probType == 'MOP': tnlhf_curr = asarray([t.tnlh_all for t in an1Candidates]) tnlhf = None elif p.solver.dataHandling == 'raw': tnlhf = asarray([t.tnlhf for t in an1Candidates]) tnlhf_curr = asarray([t.tnlh_curr for t in an1Candidates]) else: tnlhf, tnlhf_curr = None, None if p.probType != 'IP': #nlhc = asarray([t.nlhc for t in an1Candidates]) #residual = asarray([t.residual for t in an1Candidates]) residual = None indT = func4(p, yc, ec, oc, ac, fo, tnlhf_curr) if an1Candidates[0].indtc is not None: indtc = asarray([t.indtc for t in an1Candidates]) indT = logical_or(indT, indtc) else: residual = None indT = None t, _s, indD = func1(tnlhf, tnlhf_curr, residual, yc, ec, oc, ac, SIc, p, indT) new = 0 nn = 0 if new and p.probType in ('MOP', 'SNLE', 'NLSP','GLP', 'NLP', 'MINLP') and p.maxSolutions == 1: arr = tnlhf_curr if p.solver.dataHandling == 'raw' else oc M = arr.shape[0] w = arange(M) Midles = 0.5*(yc[w, t] + ec[w, t]) arr_1, arr2 = arr[w, t], arr[w, n+t] Arr = hstack((arr_1, arr2)) ind = np.argsort(Arr) Ind = set(ind[:maxActiveNodes]) tag_all, tag_1, tag_2 = [], [], [] sn = [] # TODO: get rid of the cycles for i in range(M): cond1, cond2 = i in Ind, (i+M) in Ind if cond1: if cond2: tag_all.append(i) else: tag_1.append(i) else: if cond2: tag_2.append(i) else: sn.append(an1Candidates[i]) list_lx, list_ux = [], [] _s_new = [] updateTC = an1Candidates[0].indtc is not None isRaw = p.solver.dataHandling == 'raw' for i in tag_1: node = an1Candidates[i] I = t[i] # if node.o[n+I] >= node.o[I]: # print '1' # else: # print i, I, node.o[n+I] , node.o[I], node.key, node.a[n+I] , node.a[I], node.nlhc[n+I], node.nlhc[I] node.key = node.o[n+I] node._s = _s[i] if isRaw: node.tnlh_curr[I] = node.tnlh_curr[n+I] node.tnlh_curr_best = nanmin(node.tnlh_curr) #assert node.o[n+I] >= node.o[I] #lx, ux = node.y, node.e lx, ux = yc[i], ec[i] if nn: #node.o[I], node.a[I] = node.o[n+I], node.a[n+I] node.o[I], node.a[I] = node.o[n+I], node.a[n+I] node.o[node.o<node.o[n+I]], node.a[node.a>node.a[n+I]] = node.o[n+I], node.a[n+I] else: node.o[n+I], node.a[n+I] = node.o[I], node.a[I] node.o[node.o<node.o[I]], node.a[node.a>node.a[I]] = node.o[I], node.a[I] # if p.solver.dataHandling == 'raw': for Attr in ('nlhf','nlhc', 'tnlhf', 'tnlh_curr', 'tnlh_all'): r = getattr(node, Attr, None) if r is not None: if nn: r[I] = r[n+I] else: r[n+I] = r[I] mx = ux.copy() mx[I] = Midles[i]#0.5*(lx[I] + ux[I]) list_lx.append(lx) list_ux.append(mx) node.y = lx.copy() node.y[I] = Midles[i]#0.5*(lx[I] + ux[I]) if updateTC: node.indtc = True _s_new.append(node._s) sn.append(node) for i in tag_2: node = an1Candidates[i] I = t[i] node.key = node.o[I] node._s = _s[i] # for raw only if isRaw: node.tnlh_curr[n+I] = node.tnlh_curr[I] node.tnlh_curr_best = nanmin(node.tnlh_curr) #assert node.o[I] >= node.o[n+I] #lx, ux = node.y, node.e lx, ux = yc[i], ec[i] if nn: node.o[n+I], node.a[n+I] = node.o[I], node.a[I] node.o[node.o<node.o[I]], node.a[node.a>node.a[I]] = node.o[I], node.a[I] else: node.o[I], node.a[I] = node.o[n+I], node.a[n+I] node.o[node.o<node.o[n+I]], node.a[node.a>node.a[n+I]] = node.o[n+I], node.a[n+I] for Attr in ('nlhf','nlhc', 'tnlhf', 'tnlh_curr', 'tnlh_all'): r = getattr(node, Attr, None) if r is not None: if nn: r[n+I] = r[I] else: r[I] = r[n+I] mx = lx.copy() mx[I] = Midles[i]#0.5*(lx[I] + ux[I]) list_lx.append(mx) list_ux.append(ux) node.e = ux.copy() node.e[I] = Midles[i]#0.5*(lx[I] + ux[I]) if updateTC: node.indtc = True _s_new.append(node._s) sn.append(node) for i in tag_all: node = an1Candidates[i] I = t[i] #lx, ux = node.y, node.e lx, ux = yc[i], ec[i] mx = ux.copy() mx[I] = Midles[i]#0.5 * (lx[I] + ux[I]) list_lx.append(lx) list_ux.append(mx) mx = lx.copy() mx[I] = Midles[i]#0.5 * (lx[I] + ux[I]) #mx[n+ t] = 0.5 * (lx[n + t] + ux[n + t]) list_lx.append(mx) list_ux.append(ux) #_s_new += [_s[i]] * 2 _s_new.append(_s[i]) _s_new.append(_s[i]) # print 'y_new:', vstack(list_lx) # print 'e_new:', vstack(list_ux) # print '_s_new:', hstack(_s) _in = sn + _in.tolist() if p.solver.dataHandling == 'sorted': _in.sort(key = lambda obj: obj.key) else: #pass _in.sort(key = lambda obj: obj.tnlh_curr_best) # print 'tag 1:', len(tag_1), 'tag 2:', len(tag_2), 'tag all:', len(tag_all) # print 'lx:', list_lx # print 'sn lx:', [node.y for node in sn] # print 'ux:', list_ux # print 'sn ux:', [node.e for node in sn] # print '-'*10 #print '!', vstack(list_lx), vstack(list_ux), hstack(_s_new) NEW_lx, NEW_ux, NEW__in, NEW__s = \ vstack(list_lx), vstack(list_ux), array(_in), hstack(_s_new) return NEW_lx, NEW_ux, NEW__in, NEW__s NewD = 1 if NewD and indD is not None: s4d = _s[indD] sf = _s[logical_not(indD)] _s = hstack((s4d, s4d, sf)) yf, ef = yc[logical_not(indD)], ec[logical_not(indD)] yc, ec = yc[indD], ec[indD] t = t[indD] else: _s = tile(_s, 2) #yc, ec, tnlhf_curr_local = func2(yc, ec, t, vv, tnlhf_curr) yc, ec = func2(yc, ec, t, vv) if NewD and indD is not None: yc = vstack((yc, yf)) ec = vstack((ec, ef)) if maxSolutions == 1 or len(solutions) == 0: #y, e, Tnlhf_curr_local = yc, ec, tnlhf_curr_local y, e = yc, ec break # TODO: change cycle variable if len(solutions) >> maxActiveNodes for i in range(len(solutions)): ind = logical_and(all(yc >= r11[i], 1), all(ec <= r12[i], 1)) if any(ind): j = where(logical_not(ind))[0] lj = j.size yc = take(yc, j, axis=0, out=yc[:lj]) ec = take(ec, j, axis=0, out=ec[:lj]) _s = _s[j] # if tnlhf_curr_local is not None: # tnlhf_curr_local = tnlhf_curr_local[j] y.append(yc) e.append(ec) S.append(_s) #Tnlhf_curr_local.append(tnlhf_curr_local) N += yc.shape[0] if len(_in) == 0 or N >= maxActiveNodes: y, e, _s = vstack(y), vstack(e), hstack(S) #Tnlhf_curr_local = hstack(Tnlhf_curr_local) break # if Tnlhf_curr_local is not None and len(Tnlhf_curr_local) != 0 and Tnlhf_curr_local[0] is not None: # #print len(where(isfinite(Tnlhf_curr_local))[0]), Tnlhf_curr_local.size # pass # print 'y_prev:', y # print 'e_prev:', e # print '_s_prev:', hstack(_s) #print 'prev!', y, e, _s # from numpy import array_equal # if not array_equal(NEW_lx.sort(), y.sort()): # pass # if not array_equal(NEW_ux.sort(), e.sort()): # pass # if not array_equal(NEW__s.sort(), _s.sort()): # pass #, NEW_ux, NEW__in, NEW__s return y, e, _in, _s
def func1(tnlhf, tnlhf_curr, residual, y, e, o, a, _s_prev, p, indT): m, n = y.shape w = arange(m) if p.probType == 'IP': oc_modL, oc_modU = o[:, :n], o[:, n:] ac_modL, ac_modU = a[:, :n], a[:, n:] # # TODO: handle nans mino = where(oc_modL < oc_modU, oc_modL, oc_modU) maxa = where(ac_modL < ac_modU, ac_modU, ac_modL) # Prev tmp = a[:, 0:n]-o[:, 0:n]+a[:, n:]-o[:, n:] t = nanargmin(tmp,1) d = 0.5*tmp[w, t] #New # tmp = a - o # t_ = nanargmin(tmp,1) # t = t_% n # d = tmp[w, t_] # ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64') ind = 2**(1.0/n) * d >= _s_prev #new # ind = 2**(1.0/n) * d >= nanmax(maxa-mino, 1) #ind = 2**(-n) >= (_s_prev - _s)/asarray(_s, 'float64') #s2 = nanmin(maxa - mino, 1) #print (abs(s2/_s)) # Prev _s = nanmin(maxa - mino, 1) # New #_s = nanmax(maxa - mino, 1) # _s = nanmax(a - o, 1) #ind = _s_prev <= _s + ((2**-n / log(2)) if n > 15 else log2(1+2**-n)) indD = logical_not(ind) indD = ind indD = None #print len(where(indD)[0]), len(where(logical_not(indD))[0]) # elif p.probType == 'MOP': # # raise 'unimplemented' else: if p.solver.dataHandling == 'sorted': _s = func13(o, a) t = nanargmin(a, 1) % n d = nanmax([a[w, t] - o[w, t], a[w, n+t] - o[w, n+t]], 0) ## !!!! Don't replace it by (_s_prev /d- 1) to omit rounding errors ### #ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64') #NEW ind = d >= _s_prev / 2 ** (1.0e-12/n) #ind = d >= _s_prev / 2 ** (1.0/n) indD = empty(m, bool) indD.fill(True) #ind.fill(False) ################################################### elif p.solver.dataHandling == 'raw': if p.probType == 'MOP': t = p._t[:m] p._t = p._t[m:] d = _s = p.__s[:m] p.__s = p.__s[m:] else: # tnlh_1, tnlh_2 = tnlhf[:, 0:n], tnlhf[:, n:] # TNHLF_min = where(logical_or(tnlh_1 > tnlh_2, isnan(tnlh_1)), tnlh_2, tnlh_1) # # Set _s # _s = nanmin(TNHLF_min, 1) T = tnlhf_curr tnlh_curr_1, tnlh_curr_2 = T[:, 0:n], T[:, n:] TNHL_curr_min = where(logical_or(tnlh_curr_1 < tnlh_curr_2, isnan(tnlh_curr_2)), tnlh_curr_1, tnlh_curr_2) t = nanargmin(TNHL_curr_min, 1) T = tnlhf d = nanmin(vstack(([T[w, t], T[w, n+t]])), 0) _s = d #OLD #!#!#!#! Don't replace it by _s_prev - d <= ... to omit inf-inf = nan !#!#!# #ind = _s_prev <= d + ((2**-n / log(2)) if n > 15 else log2(1+2**-n)) #ind = _s_prev - d <= ((2**-n / log(2)) if n > 15 else log2(1+2**-n)) #NEW if any(_s_prev < d): pass ind = _s_prev <= d + 1.0/n # T = TNHL_curr_min #ind2 = nanmin(TNHL_curr_min, 0) indQ = d >= _s_prev - 1.0/n #indQ = logical_and(indQ, False) indD = logical_or(indQ, logical_not(indT)) # print '------' # print indQ[:10] # print indD[:10] # print _s_prev[:2], d[:2] #print len(where(indD)[0]), len(where(indQ)[0]), len(where(indT)[0]) #print _s_prev - d ################################################### #d = ((tnlh[w, t]* tnlh[w, n+t])**0.5) else: assert 0 if any(ind): r10 = where(ind)[0] #print('r10:', r10) # print _s_prev # print ((_s_prev -d)*n)[r10] # print('ind length: %d' % len(where(ind)[0])) # print where(ind)[0].size #bs = e[ind] - y[ind] #t[ind] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well bs = e[r10] - y[r10] t[r10] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well return t, _s, indD
def func11(y, e, nlhc, indTC, residual, o, a, _s, p): m, n = y.shape if p.probType == "IP": w = arange(m) # TODO: omit recalculation from func1 ind = nanargmin(a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:], 1) sup_inf_diff = 0.5*(a[w, ind] - o[w, ind] + a[w, n+ind] - o[w, n+ind]) diffao = a - o minres_ind = nanargmin(diffao, 1) minres = diffao[w, minres_ind] complementary_minres = diffao[w, where(minres_ind<n, minres_ind+n, minres_ind-n)] volume = prod(e-y, 1) volumeResidual = volume * sup_inf_diff F = 0.25 * (a[w, ind] + o[w, ind] + a[w, n+ind] + o[w, n+ind]) return [si(IP_fields, sup_inf_diff[i], minres[i], minres_ind[i], complementary_minres[i], y[i], e[i], o[i], a[i], _s[i], F[i], volume[i], volumeResidual[i]) for i in range(m)] else: residual = None isSNLE = p.probType in ('SNLE', 'NLSP') if 1 or not isSNLE: o, a = asarray(o), asarray(a) a[a==inf] = 1e300 o[o==-inf] = -1e300 tmp = a - o tmp[tmp<1e-300] = 1e-300 # ind_uf_inf = where(a==inf)[0] # if ind_uf_inf.size: # Tmp = o[ind_uf_inf] # Tmp[Tmp==-inf] = -1e100 # M = nanmax(abs(Tmp)) # if M is nan or M == 0.0: # M = 1.0 # tmp[ind_uf_inf] = 1e200 * (1.0 + Tmp/M) nlhf = log2(tmp)#-log2(p.fTol) # nlhf[a==inf] = 1e300# to make it not inf and nan # nlhf[o==-inf] = 1e300# to make it not inf and nan if p.probType == "MOP": if nlhf.ndim == 3: # in MOP nlhf = nlhf.sum(axis=1) else: assert 0, 'bug in interalg' # make correct o,a wrt each target return [si(MOP_Fields, y[i], e[i], nlhf[i], nlhc[i] if nlhc is not None else None, indTC[i] if indTC is not None else None, residual[i] if residual is not None else None, [o[i][k] for k in range(p.nf)], [a[i][k] for k in range(p.nf)], _s[i]) for i in range(m)] else: assert p.probType in ('GLP', 'NLP', 'NSP', 'SNLE', 'NLSP', 'MINLP', 'QP', 'LP', 'MILP') if 0 and isSNLE: nlhf = Tmp = o = a = [None]*m else: s, q = o[:, 0:n], o[:, n:2*n] Tmp = nanmax(where(q<s, q, s), 1) nlhf[logical_and(isinf(a), isinf(nlhf))] = 1e300 # residual = None return [si(Fields, Tmp[i], y[i], e[i], nlhf[i], nlhc[i] if nlhc is not None else None, indTC[i] if indTC is not None else None, residual[i] if residual is not None else None, o[i], a[i], _s[i]) for i in range(m)]
def func1(tnlhf, tnlhf_curr, residual, y, e, o, a, _s_prev, p, indT): m, n = y.shape w = arange(m) if p.probType == 'IP': oc_modL, oc_modU = o[:, :n], o[:, n:] ac_modL, ac_modU = a[:, :n], a[:, n:] # # TODO: handle nans mino = where(oc_modL < oc_modU, oc_modL, oc_modU) maxa = where(ac_modL < ac_modU, ac_modU, ac_modL) # Prev tmp = a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:] t = nanargmin(tmp, 1) d = 0.5 * tmp[w, t] #New # tmp = a - o # t_ = nanargmin(tmp,1) # t = t_% n # d = tmp[w, t_] # ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64') ind = 2**(1.0 / n) * d >= _s_prev #new # ind = 2**(1.0/n) * d >= nanmax(maxa-mino, 1) #ind = 2**(-n) >= (_s_prev - _s)/asarray(_s, 'float64') #s2 = nanmin(maxa - mino, 1) #print (abs(s2/_s)) # Prev _s = nanmin(maxa - mino, 1) # New #_s = nanmax(maxa - mino, 1) # _s = nanmax(a - o, 1) #ind = _s_prev <= _s + ((2**-n / log(2)) if n > 15 else log2(1+2**-n)) indD = logical_not(ind) indD = ind indD = None #print len(where(indD)[0]), len(where(logical_not(indD))[0]) # elif p.probType == 'MOP': # # raise 'unimplemented' else: if p.solver.dataHandling == 'sorted': _s = func13(o, a) t = nanargmin(a, 1) % n d = nanmax([a[w, t] - o[w, t], a[w, n + t] - o[w, n + t]], 0) ## !!!! Don't replace it by (_s_prev /d- 1) to omit rounding errors ### #ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64') #NEW ind = d >= _s_prev / 2**(1.0e-12 / n) #ind = d >= _s_prev / 2 ** (1.0/n) indD = empty(m, bool) indD.fill(True) #ind.fill(False) ################################################### elif p.solver.dataHandling == 'raw': if p.probType == 'MOP': t = p._t[:m] p._t = p._t[m:] d = _s = p.__s[:m] p.__s = p.__s[m:] else: # tnlh_1, tnlh_2 = tnlhf[:, 0:n], tnlhf[:, n:] # TNHLF_min = where(logical_or(tnlh_1 > tnlh_2, isnan(tnlh_1)), tnlh_2, tnlh_1) # # Set _s # _s = nanmin(TNHLF_min, 1) T = tnlhf_curr tnlh_curr_1, tnlh_curr_2 = T[:, 0:n], T[:, n:] TNHL_curr_min = where( logical_or(tnlh_curr_1 < tnlh_curr_2, isnan(tnlh_curr_2)), tnlh_curr_1, tnlh_curr_2) t = nanargmin(TNHL_curr_min, 1) T = tnlhf d = nanmin(vstack(([T[w, t], T[w, n + t]])), 0) _s = d #OLD #!#!#!#! Don't replace it by _s_prev - d <= ... to omit inf-inf = nan !#!#!# #ind = _s_prev <= d + ((2**-n / log(2)) if n > 15 else log2(1+2**-n)) #ind = _s_prev - d <= ((2**-n / log(2)) if n > 15 else log2(1+2**-n)) #NEW if any(_s_prev < d): pass ind = _s_prev <= d + 1.0 / n # T = TNHL_curr_min #ind2 = nanmin(TNHL_curr_min, 0) indQ = d >= _s_prev - 1.0 / n #indQ = logical_and(indQ, False) indD = logical_or(indQ, logical_not(indT)) # print '------' # print indQ[:10] # print indD[:10] # print _s_prev[:2], d[:2] #print len(where(indD)[0]), len(where(indQ)[0]), len(where(indT)[0]) #print _s_prev - d ################################################### #d = ((tnlh[w, t]* tnlh[w, n+t])**0.5) else: assert 0 if any(ind): r10 = where(ind)[0] #print('r10:', r10) # print _s_prev # print ((_s_prev -d)*n)[r10] # print('ind length: %d' % len(where(ind)[0])) # print where(ind)[0].size #bs = e[ind] - y[ind] #t[ind] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well bs = e[r10] - y[r10] t[r10] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well return t, _s, indD
def r14MOP(p, nlhc, residual, definiteRange, y, e, vv, asdf1, C, r40, g, nNodes, \ r41, fTol, Solutions, varTols, _in, dataType, \ maxNodes, _s, indTC, xRecord): assert p.probType == 'MOP' if len(p._discreteVarsNumList): y, e, _s, indTC = adjustDiscreteVarBounds(y, e, _s, indTC, p) if p.nProc != 1 and getattr(p, 'pool', None) is None: p.pool = Pool(processes = p.nProc) elif p.nProc == 1: p.pool = None ol, al = [], [] targets = p.targets # TODO: check it m, n = y.shape ol, al = [[] for k in range(m)], [[] for k in range(m)] for i, t in enumerate(targets): o, a, definiteRange, exactRange = func82(y, e, vv, t.func, dataType, p) o, a = o.reshape(2*n, m).T, a.reshape(2*n, m).T for j in range(m): ol[j].append(o[j]) al[j].append(a[j]) #ol.append(o.reshape(2*n, m).T.tolist()) #al.append(a.reshape(2*n, m).T.tolist()) nlhf = r43(targets, Solutions.F, ol, al, p.pool, p.nProc) fo_prev = 0 # TODO: remove NaN nodes here if y.size == 0: return _in, g, fo_prev, _s, Solutions, xRecord, r41, r40 nodes = func11(y, e, nlhc, indTC, residual, ol, al, _s, p) #y, e = func4(y, e, o, a, fo) assert p.solver.dataHandling == 'raw', '"sorted" mode is unimplemented for MOP yet' if nlhf is None: new_nodes_tnlh_all = nlhc elif nlhc is None: new_nodes_tnlh_all = nlhf else: new_nodes_tnlh_all = nlhf + nlhc asdf1 = [t.func for t in p.targets] r5F, r5Coords = getr4Values(vv, y, e, new_nodes_tnlh_all, asdf1, C, p.contol, dataType, p) nIncome, nOutcome = r44(Solutions, r5Coords, r5F, targets, p.solver.sigma) fo = 0 # unused for MOP # TODO: better of nlhc for unconstrained probs # if len(_in) != 0: # an = hstack((nodes, _in)) # else: # an = atleast_1d(nodes) an = nodes + _in hasNewParetoNodes = False if nIncome == 0 else True if hasNewParetoNodes: ol2 = [node.o for node in an] al2 = [node.a for node in an] nlhc2 = [node.nlhc for node in an] nlhf2 = r43(targets, Solutions.F, ol2, al2, p.pool, p.nProc) tnlh_all = asarray(nlhc2) if nlhf2 is None else nlhf2 if nlhc2[0] is None else asarray(nlhc2) + nlhf2 else: tnlh_all = vstack([new_nodes_tnlh_all] + [node.tnlh_all for node in _in]) if len(_in) != 0 else new_nodes_tnlh_all for i, node in enumerate(nodes): node.tnlh_all = tnlh_all[i] r10 = logical_not(any(isfinite(tnlh_all), 1)) if any(r10): ind = where(logical_not(r10))[0] # an = asarray(an[ind]) an = [an[i] for i in ind] tnlh_all = take(tnlh_all, ind, axis=0, out=tnlh_all[:ind.size]) # else: # tnlh_all = hstack([node.tnlh_all for node in an]) T1, T2 = tnlh_all[:, :tnlh_all.shape[1]/2], tnlh_all[:, tnlh_all.shape[1]/2:] T = where(logical_or(T1 < T2, isnan(T2)), T1, T2) t = nanargmin(T, 1) w = arange(t.size) NN = T[w, t].flatten() for i, node in enumerate(an): node.tnlh_all = tnlh_all[i] node.tnlh_curr_best = NN[i] astnlh = argsort(NN) # an = an[astnlh] an = [an[i] for i in astnlh] p._t = t # TODO: form _s in other level (for active nodes only), to reduce calculations if len(an) != 0: T = asarray([node.nlhf for node in an]) # nlhc_fixed = asarray([node.nlhc for node in an]) if an[0].nlhc is not None: T += asarray([node.nlhc for node in an]) # T = nlhf_fixed + nlhc_fixed if nlhc_fixed[0] is not None else nlhf_fixed p.__s = \ nanmin(vstack(([T[w, t], T[w, n+t]])), 0) else: p.__s = array([]) # p._nObtainedSolutions = len(solutions) # if p._nObtainedSolutions > maxSolutions: # solutions = solutions[:maxSolutions] # p.istop = 0 # p.msg = 'user-defined maximal number of solutions (p.maxSolutions = %d) has been exeeded' % p.maxSolutions # return an, g, fo, None, solutions, coords, xRecord, r41, r40 # TODO: fix it p._frontLength = len(Solutions.F) p._nIncome = nIncome p._nOutcome = nOutcome p.iterfcn(p.x0) #print('iter: %d (%d) frontLenght: %d' %(p.iter, itn, len(Solutions.coords))) if p.istop != 0: return an, g, fo, None, Solutions, xRecord, r41, r40 #an, g = func9(an, fo, g, p) nn = maxNodes#1 if asdf1.isUncycled and all(isfinite(o)) and p._isOnlyBoxBounded and not p.probType.startswith('MI') else maxNodes an, g = func5(an, nn, g, p) nNodes.append(len(an)) return an, g, fo, _s, Solutions, xRecord, r41, r40
def truncateByPlane(y, e, indT, A, b): #!!!!!!!!!!!!!!!!!!! # TODO: vectorize it by matrix A #!!!!!!!!!!!!!!!!!!! ind_trunc = True assert np.asarray(b).size <= 1, 'unimplemented yet' m, n = y.shape if m == 0: assert e.size == 0, 'bug in interalg engine' return y, e, indT, ind_trunc ind_positive = where(A > 0)[0] ind_negative = where(A < 0)[0] A1 = A[ind_positive] S1 = A1 * y[:, ind_positive] A2 = A[ind_negative] S2 = A2 * e[:, ind_negative] s1, s2 = np.sum(S1, 1), np.sum(S2, 1) S = s1 + s2 if ind_positive.size != 0: S1_ = b - S.reshape(-1, 1) + S1 Alt_ub = S1_ / A1 # ind = e[:, ind_positive] > Alt_ub # #e[:, ind_positive[ind]] = Alt_ub[ind] # e[:, np.tile(ind_positive,(ind.shape[0],1))[ind]] = Alt_ub[ind] # #e[:, ind_positive.reshape(ind.shape)[ind]] = Alt_ub[ind] # # indT[np.any(ind, 1)] = True for _i, i in enumerate(ind_positive): #s = S - S1[:, _i] #alt_ub = (b - s) / A[i] #alt_ub = S1_[:, _i] / A[i] alt_ub = Alt_ub[:, _i] ind = e[:, i] > alt_ub Ind = where(ind)[0] if Ind.size: e[Ind, i] = alt_ub[Ind] indT[Ind] = True if ind_negative.size != 0: S2_ = b - S.reshape(-1, 1) + S2 Alt_lb = S2_ / A2 for _i, i in enumerate(ind_negative): #s = S - S2[:, _i] #alt_lb = (b - s) / A[i] #alt_lb = S2_[:, _i] / A[i] alt_lb = Alt_lb[:, _i] ind = y[:, i] < alt_lb Ind = where(ind)[0] if Ind.size: y[Ind, i] = alt_lb[Ind] indT[Ind] = True ind = np.all(e >= y, 1) if not np.all(ind): ind_trunc = where(ind)[0] lj = ind_trunc.size y = take(y, ind_trunc, axis=0, out=y[:lj]) e = take(e, ind_trunc, axis=0, out=e[:lj]) indT = indT[ind_trunc] return y, e, indT, ind_trunc
def r14IP(p, nlhc, residual, definiteRange, y, e, vv, asdf1, C, CBKPMV, g, nNodes, \ frc, fTol, Solutions, varTols, _in, dataType, \ maxNodes, _s, indTC, xRecord): required_sigma = p.ftol * 0.99 # to suppress roundoff effects m, n = y.shape ip = func10(y, e, vv) ip.dictOfFixedFuncs = p.dictOfFixedFuncs ip.surf_preference = True tmp = asdf1.interval(ip, ia_surf_level=2) # print(type(tmp)) if hasattr(tmp, 'resolve'):#type(tmp) == boundsurf: # print('b') #adjustr4WithDiscreteVariables(wr4, p) if 1: # changes val_l, val_u = zeros(2*n*m), zeros(2*n*m) val_l += tmp.l.c # may be array <- scalar val_u += tmp.u.c for v in tmp.dep: ind = p._oovarsIndDict[v] ts, te = ip[v]#y[:, ind], e[:, ind] A, B = (te**2 + te*ts + ts**2) / 3.0, 0.5 * (te + ts) #A, B, C = (te**3 - ts**3) / 3.0, 0.5 * (te**2 - ts**2), te - ts b = tmp.l.d.get(v, 0.0) val_l += b * B if tmp.level == 2: a = tmp.l.d2.get(v, 0.0) val_l += a * A b= tmp.u.d.get(v, 0.0) val_u += b * B if tmp.level == 2: a = tmp.u.d2.get(v, 0.0) val_u += a * A #r20 = val_u - val_l #approx_value = 0.5 * (val_l + val_u) o, a = val_l, val_u # changes end else: cs = oopoint((v, asarray(0.5*(val[0] + val[1]), dataType)) for v, val in ip.items()) cs.dictOfFixedFuncs = p.dictOfFixedFuncs o, a = tmp.values(cs) definiteRange = tmp.definiteRange else: o, a, definiteRange = tmp.lb, tmp.ub, tmp.definiteRange if not all(definiteRange): p.err(''' numerical integration with interalg is implemented for definite (real) range only, no NaN values in integrand are allowed''') o, a = o.reshape(2*n, m).T, a.reshape(2*n, m).T nodes = func11(y, e, None, indTC, None, o, a, _s, p) #an = nodes if len(_in) == 0 else hstack((_in, nodes)).tolist() an = nodes + _in if 1: an.sort(key = lambda obj: obj.key, reverse=False) #an.sort(key = lambda obj: obj.minres, reverse=False) else: an.sort(key=lambda obj: obj.volumeResidual, reverse=False) ao_diff = array([node.key for node in an]) volumes = array([node.volume for node in an]) r10 = ao_diff <= 0.95*(required_sigma-p._residual) / (prod(p.ub-p.lb) - p._volume) ind = where(r10)[0] # TODO: use true_sum v = volumes[ind] p._F += sum(array([an[i].F for i in ind]) * v) residuals = ao_diff[ind] * v p._residual += residuals.sum() p._volume += v.sum() #an = asarray(an, object) #an = an[where(logical_not(r10))[0]] an = [elem for i, elem in enumerate(an) if not r10[i]] nNodes.append(len(an)) p.iterfcn(xk=array(nan), fk=p._F, rk = 0)#TODO: change rk to something like p._r0 - p._residual if p.istop != 0: ao_diff = array([node.key for node in an]) volumes = array([node.volume for node in an]) p._residual += sum(ao_diff * volumes) _s = None #an, g = func9(an, fo, g, 'IP') #nn = 1 if asdf1.isUncycled and all(isfinite(a)) and all(isfinite(o)) and p._isOnlyBoxBounded else maxNodes #an, g = func5(an, nn, g) return an, g, inf, _s, Solutions, xRecord, frc, CBKPMV
def r14IP(p, nlhc, residual, definiteRange, y, e, vv, asdf1, C, CBKPMV, g, nNodes, \ frc, fTol, Solutions, varTols, _in, dataType, \ maxNodes, _s, indTC, xRecord): required_sigma = p.ftol * 0.99 # to suppress roundoff effects m, n = y.shape ip = func10(y, e, vv) ip.dictOfFixedFuncs = p.dictOfFixedFuncs ip.surf_preference = True tmp = asdf1.interval(ip, ia_surf_level=2) # print(type(tmp)) if hasattr(tmp, 'resolve'): #type(tmp) == boundsurf: # print('b') #adjustr4WithDiscreteVariables(wr4, p) if 1: # changes val_l, val_u = zeros(2 * n * m), zeros(2 * n * m) val_l += tmp.l.c # may be array <- scalar val_u += tmp.u.c for v in tmp.dep: ind = p._oovarsIndDict[v] ts, te = ip[v] #y[:, ind], e[:, ind] A, B = (te**2 + te * ts + ts**2) / 3.0, 0.5 * (te + ts) #A, B, C = (te**3 - ts**3) / 3.0, 0.5 * (te**2 - ts**2), te - ts b = tmp.l.d.get(v, 0.0) val_l += b * B if tmp.level == 2: a = tmp.l.d2.get(v, 0.0) val_l += a * A b = tmp.u.d.get(v, 0.0) val_u += b * B if tmp.level == 2: a = tmp.u.d2.get(v, 0.0) val_u += a * A #r20 = val_u - val_l #approx_value = 0.5 * (val_l + val_u) o, a = val_l, val_u # changes end else: cs = oopoint((v, asarray(0.5 * (val[0] + val[1]), dataType)) for v, val in ip.items()) cs.dictOfFixedFuncs = p.dictOfFixedFuncs o, a = tmp.values(cs) definiteRange = tmp.definiteRange else: o, a, definiteRange = tmp.lb, tmp.ub, tmp.definiteRange if not all(definiteRange): p.err(''' numerical integration with interalg is implemented for definite (real) range only, no NaN values in integrand are allowed''' ) o, a = o.reshape(2 * n, m).T, a.reshape(2 * n, m).T nodes = func11(y, e, None, indTC, None, o, a, _s, p) #an = nodes if len(_in) == 0 else hstack((_in, nodes)).tolist() an = nodes + _in if 1: an.sort(key=lambda obj: obj.key, reverse=False) #an.sort(key = lambda obj: obj.minres, reverse=False) else: an.sort(key=lambda obj: obj.volumeResidual, reverse=False) ao_diff = array([node.key for node in an]) volumes = array([node.volume for node in an]) r10 = ao_diff <= 0.95 * (required_sigma - p._residual) / (prod(p.ub - p.lb) - p._volume) ind = where(r10)[0] # TODO: use true_sum v = volumes[ind] p._F += sum(array([an[i].F for i in ind]) * v) residuals = ao_diff[ind] * v p._residual += residuals.sum() p._volume += v.sum() #an = asarray(an, object) #an = an[where(logical_not(r10))[0]] an = [elem for i, elem in enumerate(an) if not r10[i]] nNodes.append(len(an)) p.iterfcn(xk=array(nan), fk=p._F, rk=0) #TODO: change rk to something like p._r0 - p._residual if p.istop != 0: ao_diff = array([node.key for node in an]) volumes = array([node.volume for node in an]) p._residual += sum(ao_diff * volumes) _s = None #an, g = func9(an, fo, g, 'IP') #nn = 1 if asdf1.isUncycled and all(isfinite(a)) and all(isfinite(o)) and p._isOnlyBoxBounded else maxNodes #an, g = func5(an, nn, g) return an, g, inf, _s, Solutions, xRecord, frc, CBKPMV
def __solver__(self, p): alp, h0, nh, q1, q2 = self.alp, self.h0, self.nh, self.q1, self.q2 if isPyPy: if p.nc != 0 or p.nh != 0: p.warn( "in PyPy ralg may work incorrectly with nonlinear constraints yet" ) if p.nbeq != 0 or any(p.lb == p.ub): p.err( 'in PyPy ralg cannot handle linear equality constraints yet' ) if type(q1) == str: if p.probType == 'NLP' and p.isUC: q1 = 0.9 else: q1 = 1.0 T = self.T # alternatively instead of alp=self.alp etc you can use directly self.alp etc n = p.n x0 = p.x0 if p.nbeq == 0 or any( abs(p._get_AeqX_eq_Beq_residuals(x0)) > p.contol ): # TODO: add "or Aeqconstraints(x0) out of contol" x0[x0 < p.lb] = p.lb[x0 < p.lb] x0[x0 > p.ub] = p.ub[x0 > p.ub] ind_box_eq = where(p.lb == p.ub)[0] nEQ = ind_box_eq.size if nEQ != 0: initLenBeq = p.nbeq Aeq, beq, nbeq = copy(p.Aeq), copy(p.beq), p.nbeq p.Aeq = zeros([Len(p.beq) + nEQ, p.n]) p.beq = zeros(Len(p.beq) + nEQ) p.beq[:Len(beq)] = beq p.Aeq[:Len(beq)] = Aeq for i in range(len(ind_box_eq)): p.Aeq[initLenBeq + i, ind_box_eq[i]] = 1 p.beq[initLenBeq + i] = p.lb[ind_box_eq[ i]] # = p.ub[indEQ[i]], because they are the same p.nbeq += nEQ if not self.newLinEq or p.nbeq == 0: #needProjection = False B0 = eye(n, dtype=T) restoreProb = lambda *args: 0 Aeq_r, beq_r, nbeq_r = None, None, 0 else: #needProjection = True B0 = self.getPrimevalDilationMatrixWRTlinEqConstraints(p) #Aeq, beq, nbeq = p.Aeq, p.beq, p.nbeq if any(abs(p._get_AeqX_eq_Beq_residuals(x0)) > p.contol / 16.0): #p.debugmsg('old point Aeq residual:'+str(norm(dot(Aeq, x0)-beq))) try: x0 = self.linEqProjection(x0, p.Aeq, p.beq) except LinAlgError: s = 'Failed to obtain projection of start point to linear equality constraints subspace, probably the system is infeasible' p.istop, p.msg = -25, s return #p.debugmsg('new point Aeq residual:'+str(norm(dot(Aeq, x0)-beq))) if nEQ == 0: Aeq_r, beq_r, nbeq_r = p.Aeq, p.beq, p.nbeq else: Aeq_r, beq_r, nbeq_r = Aeq, beq, nbeq p.Aeq, p.beq, p.nbeq = None, None, 0 # TODO: return prob with unmodified Aeq, beq def restoreProb(): p.Aeq, p.beq, p.nbeq = Aeq_r, beq_r, nbeq_r #if nEQ != 0: restore lb, ub b = B0.copy() if self.B is None else self.B # B_f = diag(ones(n)) # B_constr = diag(ones(n)) hs = asarray(h0, T) if self.innerState is not None: hs = self.innerState['hs'] b = self.innerState['B'] ls_arr = [] w = asarray(1.0 / alp - 1.0, T) """ Shor r-alg engine """ bestPoint = p.point(array(copy(x0).tolist(), T)) # tolist() for PyPy compatibility prevIter_best_ls_point = bestPoint prevIter_PointForDilation = bestPoint g = bestPoint._getDirection(self.approach) prevDirectionForDilation = g moveDirection = g if not any(g) and all(isfinite(g)): # TODO: create ENUMs p.iterfcn(bestPoint) restoreProb() p.istop = 14 if bestPoint.isFeas(False) else -14 p.msg = 'move direction has all-zero coords' return HS = [] LS = [] #SwitchEncountered = False selfNeedRej = False #doScale = False #directionVectorsList = [] # #pass-by-ref! not copy! # if p.isFeas(p.x0): b = B_f # else: b = B_constr # if p.debug and hasattr(p, 'x_opt'): # import scipy # exactDirection = x0-p.x_opt # asdf_0 = exactDirection * (0.2+scipy.rand(n)) # #asdf = asdf_0.copy() #fTol = p.fTol if p.fTol is not None else 15*p.ftol # CHANGES if self.penalties: oldVal = p.f(p.x0) newVal = inf x = p.x0 #H, DH = p.h, p.dh if p.nh != 0: #S = 1.0 _Aeq = p.dh(x) _beq = -p.h(x) df = p.df(x) if n >= 150 and not scipyInstalled: p.pWarn(scipyAbsentMsg) if n > 100 and scipyInstalled: from scipy.sparse import eye as Eye # to prevent numpy.eye overwrite HH = Eye(n, n) else: HH = eye(n) qp = openopt.QP(H=HH, f=df, Aeq=_Aeq, beq=_beq) QPsolver = openopt.oosolver('cvxopt_qp', iprint=-1) if not QPsolver.isInstalled: S = None else: r = qp.solve(QPsolver) S = 10.0 * sum(abs(r.duals)) if r.istop > 0 else None while any(p.h(x)) > p.contol: if S is not None: p2 = getattr(openopt, p.probType)(p.f, x) p.fill(p2) p2.x0 = x p2.h = p2.dh = None p2.userProvided.h = p2.userProvided.dh = False p2.nh = 0 p2.f = lambda *args, **kwargs: p.f( *args, **kwargs) + sum( abs(S * p.h(*args, **kwargs))) p2.df = lambda *args, **kwargs: p.df( *args, **kwargs) + dot( S * sign(p.h(*args, **kwargs)), p.dh(*args, **kwargs)) #p2.iterfcn = p.iterfcn # def df2(*args, **kwargs): # r1 = p.df(*args, **kwargs) # r2 = S * dot(p.dh(*args, **kwargs).reshape(-1, 1), sign(p.h(*args, **kwargs))).flatten() # #raise 0 # return r1+r2 # #p2.df = lambda *args, **kwargs: p.df(*args, **kwargs) + S * dot(p.dh(x).reshape(-1, 1), sign(p.h(*args, **kwargs))).flatten() # p2.df = df2 # #raise 0 r2 = p2.solve(p.solver, iprint=10) if r2.stopcase >= 0: x = r2.xf p.solver.innerState = r2.extras['innerState'] oldVal, newVal = newVal, r2.ff else: if r2.istop == IS_LINE_SEARCH_FAILED: # TODO: custom S as raising penalties pass if p.isFeas(p2.xk): p.xf = p.xk = p2.xk p.istop, p.msg = p2.istop, p2.msg return else: S *= 50 #print('max residual:%0.2e'% r2.rf) else: # failed to solve QP break # CHANGES END """ Ralg main cycle """ for itn in range(p.maxIter + 10): doDilation = True lastPointOfSameType = None # to prevent possible bugs alp_addition = 0.0 iterStartPoint = prevIter_best_ls_point x = iterStartPoint.x.copy() g_tmp = economyMult(b.T, moveDirection) if any(g_tmp): g_tmp /= p.norm(g_tmp) g1 = p.matmult(b, g_tmp) # norm_moveDirection = p.norm(g1) # if doScale: # g1 *= (norm_moveDirection_prev/norm_moveDirection) ** 0.5 # norm_moveDirection_prev = norm_moveDirection # if p.debug and hasattr(p, 'x_opt'): # cos_phi_0 = p.matmult(moveDirection, prevIter_best_ls_point.x - p.x_opt)/p.norm(moveDirection)/p.norm(prevIter_best_ls_point.x - p.x_opt) # cos_phi_1 = p.matmult(g1, prevIter_best_ls_point.x - p.x_opt)/p.norm(g1)/p.norm(prevIter_best_ls_point.x - p.x_opt) # print('beforeDilation: %f afterDilation: %f' % (cos_phi_0, cos_phi_1) ) # asdf = asdf_0.copy() # g_tmp = economyMult(b.T, asdf) # # #g_tmp = p.matmult(b.T, asdf) # # if any(g_tmp): g_tmp /= p.norm(g_tmp) # asdf = p.matmult(b, g_tmp) # cos_phi = dot(asdf, exactDirection) / p.norm(asdf) / p.norm(exactDirection) # p.debugmsg('cos_phi:%f' % cos_phi) # assert cos_phi >0 """ Forward line search """ hs_cumsum = 0 hs_start = hs for ls in range(p.maxLineSearch): hs_mult = 1.0 if ls > 20: hs_mult = 2.0 elif ls > 10: hs_mult = 1.5 elif ls > 2: hs_mult = 1.05 hs *= hs_mult x -= hs * g1 hs_cumsum += hs newPoint = p.point(x) if ls == 0 else iterStartPoint.linePoint( hs_cumsum / (hs_cumsum - hs), oldPoint) # TODO: take ls into account? if not p.isUC: if newPoint.isFeas(True) == iterStartPoint.isFeas(True): lastPointOfSameType = newPoint if self.show_nnan: p.info('ls: %d nnan: %d' % (ls, newPoint.__nnan__())) if ls == 0: oldPoint = prevIter_best_ls_point #prevIterPoint oldoldPoint = oldPoint #if not self.checkTurnByGradient: if newPoint.betterThan(oldPoint, altLinInEq=True): if newPoint.betterThan(bestPoint, altLinInEq=False): bestPoint = newPoint oldoldPoint = oldPoint oldPoint, newPoint = newPoint, None else: if not itn % 4: for fn in ['_lin_ineq', '_lin_eq']: if hasattr(newPoint, fn): delattr(newPoint, fn) break hs /= hs_mult if ls == p.maxLineSearch - 1: p.istop, p.msg = IS_LINE_SEARCH_FAILED, 'maxLineSearch (' + str( p.maxLineSearch ) + ') has been exceeded, the problem seems to be unbounded' restoreProb() return #iterPoint = newPoint PointForDilation = newPoint #best_ls_point = newPoint if ls == 0 else oldPoint #if p.debug and ls != 0: assert not oldPoint.betterThan(best_ls_point) """ Backward line search """ mdx = max((150, 1.5 * p.n)) * p.xtol if itn == 0: mdx = max((hs / 128.0, 128 * p.xtol)) # TODO: set it after B rej as well ls_backward = 0 maxLS = 3 if ls == 0 else 1 # if ls <=3 or ls > 20: if self.doBackwardSearch: if self.new_bs: best_ls_point, PointForDilation, ls_backward = \ getBestPointAfterTurn(oldoldPoint, newPoint, maxLS = maxLS, maxDeltaF = 150*p.ftol, \ maxDeltaX = mdx, altLinInEq = True, new_bs = True) if PointForDilation.isFeas(True) == iterStartPoint.isFeas( True): lastPointOfSameType = PointForDilation # elif best_ls_point.isFeas(altLinInEq=True) == iterStartPoint.isFeas(altLinInEq=True): # lastPointOfSameType = best_ls_point else: best_ls_point, ls_backward = \ getBestPointAfterTurn(oldoldPoint, newPoint, maxLS = maxLS, altLinInEq = True, new_bs = False) PointForDilation = best_ls_point # TODO: extract last point from backward search, that one is better than iterPoint if best_ls_point.betterThan(bestPoint): bestPoint = best_ls_point #p.debugmsg('ls_backward:%d' % ls_backward) if ls == 0 and ls_backward == -maxLS: #pass alp_addition += 0.25 #hs *= 0.9 if ls_backward <= -1 and itn != 0: # TODO: mb use -1 or 0 instead? pass #alp_addition -= 0.25*ls_backward # ls_backward less than zero #hs *= 2 ** min((ls_backward+1, 0)) else: pass #hs *= 0.95 best_ls_point = PointForDilation # elseware lots of difficulties """ Updating hs """ step_x = p.norm(PointForDilation.x - prevIter_PointForDilation.x) step_f = abs(PointForDilation.f() - prevIter_PointForDilation.f()) HS.append(hs_start) assert ls >= 0 LS.append(ls) if itn > 3: mean_ls = (3 * LS[-1] + 2 * LS[-2] + LS[-3]) / 6.0 j0 = 3.3 if mean_ls > j0: hs = (mean_ls - j0 + 1)**0.5 * hs_start else: #hs = (ls/j0) ** 0.5 * hs_start hs = hs_start if ls == 0 and ls_backward == -maxLS: shift_x = step_x / p.xtol RD = log10(shift_x + 1e-100) if PointForDilation.isFeas( True) or prevIter_PointForDilation.isFeas( True): RD = min( (RD, asscalar( asarray(log10(step_f / p.ftol + 1e-100))))) if RD > 1.0: mp = (0.5, (ls / j0)**0.5, 1 - 0.2 * RD) hs *= max(mp) #from numpy import argmax #print argmax(mp), mp """ Handling iterPoints """ best_ls_point = PointForDilation #if not SwitchEncountered and p.nh != 0 and PointForDilation.isFeas(altLinInEq=False) != prevIter_PointForDilation.isFeas(altLinInEq=False): #SwitchEncountered = True #selfNeedRej = True involve_lastPointOfSameType = False if lastPointOfSameType is not None and PointForDilation.isFeas( True) != prevIter_PointForDilation.isFeas(True): # TODO: add middle point for the case ls = 0 assert self.dilationType == 'plain difference' #directionForDilation = lastPointOfSameType._getDirection(self.approach) PointForDilation = lastPointOfSameType involve_lastPointOfSameType = True #directionForDilation = newPoint.__getDirection__(self.approach) # used for dilation direction obtaining # if not self.new_bs or ls != 0: # moveDirection = iterPoint.__getDirection__(self.approach) # else: # moveDirection = best_ls_point.__getDirection__(self.approach) #directionForDilation = pointForDilation.__getDirection__(self.approach) # cos_phi = -p.matmult(moveDirection, prevIterPoint.__getDirection__(self.approach)) # assert cos_phi.size == 1 # if cos_phi> 0: # g2 = moveDirection#pointForDilation.__getDirection__(self.approach) # else: # g2 = pointForDilation.__getDirection__(self.approach) if itn == 0: p.debugmsg('hs: ' + str(hs)) p.debugmsg('ls: ' + str(ls)) if self.showLS: p.info('ls: ' + str(ls)) if self.show_hs: p.info('hs: ' + str(hs)) if self.show_nnan: p.info('nnan: ' + str(best_ls_point.__nnan__())) if self.showRes: r, fname, ind = best_ls_point.mr(True) p.info(fname + str(ind)) """ Set dilation direction """ #if sum(p.dotmult(g, g2))>0: #p.debugmsg('ralg warning: slope angle less than pi/2. Mb dilation for the iter will be omitted.') #doDilation = False # CHANGES # if lastPointOfSameType is None: # if currIterPointIsFeasible and not prevIterPointIsFeasible: # alp_addition += 0.1 # elif prevIterPointIsFeasible and not currIterPointIsFeasible: # alp_addition -= 0.0 # CHANGES END # r_p, ind_p, fname_p = prevIter_best_ls_point.mr(1) # r_, ind_, fname_ = PointForDilation.mr(1) #else: #print itn,'>>>>>>>>>', currIterPointIsFeasible """ Excluding derivatives switched to/from NaN """ if self.skipPrevIterNaNsInDilation: c_prev, c_current = prevIter_PointForDilation.c( ), PointForDilation.c() h_prev, h_current = prevIter_PointForDilation.h( ), PointForDilation.h() """ Handling switch to NaN """ NaN_derivatives_excluded = False if self.skipPrevIterNaNsInDilation: assert self.approach == 'all active' if not prevIter_PointForDilation.isFeas(True): """ processing NaNs in nonlin inequality constraints """ ind_switch_ineq_to_nan = where( logical_and(isnan(c_current), c_prev > 0))[0] if len(ind_switch_ineq_to_nan) != 0: NaN_derivatives_excluded = True tmp = prevIter_PointForDilation.dc( ind_switch_ineq_to_nan) if hasattr(tmp, 'toarray'): tmp = tmp.A if len(ind_switch_ineq_to_nan) > 1: tmp *= (c_prev[ind_switch_ineq_to_nan] / sqrt( (tmp**2).sum(1))).reshape(-1, 1) else: tmp *= c_prev[ind_switch_ineq_to_nan] / norm(tmp) if tmp.ndim > 1: tmp = tmp.sum(0) if not isinstance(tmp, ndarray) or isinstance( tmp, matrix): tmp = tmp.A.flatten() # dense or sparse matrix #print '1: excluded:', norm(tmp), norm(prevDirectionForDilation) prevDirectionForDilation -= tmp #print '1: result=', norm(prevDirectionForDilation) """ processing NaNs in nonlin equality constraints """ ind_switch_eq_to_nan = where( logical_and(isnan(h_current), h_prev > 0))[0] if len(ind_switch_eq_to_nan) != 0: NaN_derivatives_excluded = True tmp = prevIter_PointForDilation.dh( ind_switch_eq_to_nan) if tmp.ndim > 1: tmp = tmp.sum(0) if not isinstance(tmp, ndarray) or isinstance( tmp, matrix): tmp = tmp.A.flatten() # dense or sparse matrix prevDirectionForDilation -= tmp ind_switch_eq_to_nan = where( logical_and(isnan(h_current), h_prev < 0))[0] if len(ind_switch_eq_to_nan) != 0: NaN_derivatives_excluded = True tmp = prevIter_PointForDilation.dh( ind_switch_eq_to_nan) if tmp.ndim > 1: tmp = tmp.sum(0) if not isinstance(tmp, ndarray) or isinstance( tmp, matrix): tmp = tmp.A.flatten() # dense or sparse matrix prevDirectionForDilation += tmp directionForDilation = PointForDilation._getDirection( self.approach) """ Handling switch from NaN """ if self.skipPrevIterNaNsInDilation: if not PointForDilation.isFeas(True): """ processing NaNs in nonlin inequality constraints """ ind_switch_ineq_from_nan = where( logical_and(isnan(c_prev), c_current > 0))[0] if len(ind_switch_ineq_from_nan) != 0: NaN_derivatives_excluded = True tmp = PointForDilation.dc(ind_switch_ineq_from_nan) if hasattr(tmp, 'toarray'): tmp = tmp.A if len(ind_switch_ineq_from_nan) > 1: tmp *= (c_current[ind_switch_ineq_from_nan] / sqrt( (tmp**2).sum(1))).reshape(-1, 1) else: tmp *= c_current[ind_switch_ineq_from_nan] / norm( tmp) if tmp.ndim > 1: tmp = tmp.sum(0) if not isinstance(tmp, ndarray) or isinstance( tmp, matrix): tmp = tmp.A.flatten() # dense or sparse matrix #print '2: excluded:', norm(tmp), norm(directionForDilation) directionForDilation -= tmp #print '2: result=', norm(directionForDilation) """ processing NaNs in nonlin equality constraints """ ind_switch_eq_from_nan = where( logical_and(isnan(h_prev), h_current > 0))[0] if len(ind_switch_eq_from_nan) != 0: NaN_derivatives_excluded = True tmp = PointForDilation.dh(ind_switch_eq_from_nan) if tmp.ndim > 1: tmp = tmp.sum(0) if not isinstance(tmp, ndarray) or isinstance( tmp, matrix): tmp = tmp.A.flatten() # dense or sparse matrix directionForDilation -= tmp ind_switch_eq_from_nan = where( logical_and(isnan(h_prev), h_current < 0))[0] if len(ind_switch_eq_from_nan) != 0: NaN_derivatives_excluded = True tmp = PointForDilation.dh(ind_switch_eq_from_nan) if tmp.ndim > 1: tmp = tmp.sum(0) if not isinstance(tmp, ndarray) or isinstance( tmp, matrix): tmp = tmp.A.flatten() # dense or sparse matrix directionForDilation += tmp # # CHANGES # gn = g2/norm(g2) # if len(directionVectorsList) == 0 or n < 3: pass # else: # if len(directionVectorsList) == 1 or abs(dot(directionVectorsList[-1], directionVectorsList[-2]))>0.999: # projectionComponentLenght = abs(dot(directionVectorsList[-1], gn)) # restLength = sqrt(1 - min((1, projectionComponentLenght))**2) # else: # e1 = directionVectorsList[-1] # e2 = directionVectorsList[-2] - dot(directionVectorsList[-1], directionVectorsList[-2]) * directionVectorsList[-1] # e2 /= norm(e2) # # proj1, proj2 = dot(e1, gn), dot(e2, gn) # rest = gn - proj1 * e1 - proj2 * e2 # restLength = norm(rest) # if restLength > 1+1e-5: p.pWarn('possible error in ralg solver: incorrect restLength, exceeds 1.0') # # # TODO: make it parameters of ralg # commonCoeff, alp_add_coeff = 0.5, 1.0 # # if restLength < commonCoeff * (n - 2.0) / n: # #pass # alpAddition = 0.5+(arctan((n - 2.0) / (n * restLength)) - pi / 4.0) / (pi / 2.0) * alp_add_coeff # #p.debugmsg('alpAddition:' + str(alpAddition)) # assert alpAddition > 0 # if someone incorrectly modifies commonCoeff it can be less than zero # alp_addition += alpAddition # #p.debugmsg('alp_addition:' + str(alp_addition)) # # directionVectorsList.append(gn) # if len(directionVectorsList) > 2: directionVectorsList = directionVectorsList[:-2] # # CHANGES END if self.dilationType == 'normalized' and (not fname_p in ('lb', 'ub', 'lin_eq', 'lin_ineq') \ or not fname_ in ('lb', 'ub', 'lin_eq', 'lin_ineq')) and (fname_p != fname_ or ind_p != ind_): G2, G = directionForDilation / norm( directionForDilation), prevDirectionForDilation / norm( prevDirectionForDilation) else: G2, G = directionForDilation, prevDirectionForDilation if prevIter_PointForDilation.isFeas( True) == PointForDilation.isFeas(True): g1 = G2 - G elif prevIter_PointForDilation.isFeas(True): g1 = G2.copy() else: g1 = G.copy() alp_addition += 0.05 #print p.getMaxResidual(PointForDilation.x, 1) ############################################## # the case may be occured when # 1) lastPointOfSameType is used # or # 2) some NaN from constraints have been excluded if norm(G2 - G) < 1e-12 * min( (norm(G2), norm(G))) and (involve_lastPointOfSameType or NaN_derivatives_excluded): p.debugmsg("ralg: 'last point of same type gradient' is used") g1 = G2 ############################################## #g1 = -G.copy() # signum doesn't matter here # changes wrt infeas constraints # if prevIterPoint.nNaNs() != 0: # cp, hp = prevIterPoint.c(), prevIterPoint.h() # ind_infeas_cp, ind_infeas_hp = isnan(cp), isnan(hp) # # c, h = iterPoint.c(), iterPoint.h() # ind_infeas_c, ind_infeas_h = isnan(c), isnan(h) # # ind_goodChange_c = logical_and(ind_infeas_cp, logical_not(ind_infeas_c)) # ind_goodChange_h = logical_and(ind_infeas_hp, logical_not(ind_infeas_h)) # # any_c, any_h = any(ind_goodChange_c), any(ind_goodChange_h) # altDilation = zeros(n) # if any_c: # altDilation += sum(atleast_2d(iterPoint.dc(where(ind_goodChange_c)[0])), 0) # assert not any(isnan(altDilation)) # if any_h: # altDilation += sum(atleast_2d(iterPoint.dh(where(ind_goodChange_h)[0])), 0) # if any_c or any_h: # #print '!>', altDilation # #g1 = altDilation # pass # changes end """ Perform dilation """ # CHANGES # g = economyMult(b.T, g1) # gn = g/norm(g) # if len(directionVectorsList) == 0 or n < 3 or norm(g1) < 1e-20: pass # else: # if len(directionVectorsList) == 1 or abs(dot(directionVectorsList[-1], directionVectorsList[-2]))>0.999: # projectionComponentLenght = abs(dot(directionVectorsList[-1], gn)) # restLength = sqrt(1 - min((1, projectionComponentLenght))**2) # else: # e1 = directionVectorsList[-1] # e2 = directionVectorsList[-2] - dot(directionVectorsList[-1], directionVectorsList[-2]) * directionVectorsList[-1] # print dot(directionVectorsList[-1], directionVectorsList[-2]) # e2 /= norm(e2) # proj1, proj2 = dot(e1, gn), dot(e2, gn) # rest = gn - proj1 * e1 - proj2 * e2 # restLength = norm(rest) # assert restLength < 1+1e-5, 'error in ralg solver: incorrect restLength' # # # TODO: make it parameters of ralg # commonCoeff, alp_add_coeff = 0.5, 1.0 # # if restLength < commonCoeff * (n - 2.0) / n: # #pass # alpAddition = 0.5+(arctan((n - 2.0) / (n * restLength)) - pi / 4.0) / (pi / 2.0) * alp_add_coeff # #p.debugmsg('alpAddition:' + str(alpAddition)) # assert alpAddition > 0 # if someone incorrectly modifies commonCoeff it can be less than zero # alp_addition += alpAddition # #p.debugmsg('alp_addition:' + str(alp_addition)) # # directionVectorsList.append(gn) # if len(directionVectorsList) > 2: directionVectorsList = directionVectorsList[:-2] # CHANGES END if doDilation: g = economyMult(b.T, g1) ng = p.norm(g) if self.needRej(p, b, g1, g) or selfNeedRej: selfNeedRej = False if self.showRej or p.debug: p.info( 'debug msg: matrix B restoration in ralg solver') b = B0.copy() hs = p.norm(prevIter_best_ls_point.x - best_ls_point.x) # TODO: iterPoint = projection(iterPoint,Aeq) if res_Aeq > 0.75*contol if ng < 1e-40: hs *= 0.9 p.debugmsg('small dilation direction norm (%e), skipping' % ng) if all(isfinite(g)) and ng > 1e-50 and doDilation: g = (g / ng).reshape(-1, 1) vec1 = economyMult(b, g).reshape( -1, 1) # TODO: remove economyMult, use dot? #if alp_addition != 0: p.debugmsg('alp_addition:' + str(alp_addition)) w = asarray(1.0 / (alp + alp_addition) - 1.0, T) vec2 = w * g.T b += p.matmult(vec1, vec2) """ Call OO iterfcn """ if hasattr(p, '_df'): delattr(p, '_df') if best_ls_point.isFeas(False) and hasattr(best_ls_point, '_df'): p._df = best_ls_point.df().copy() p.iterfcn(best_ls_point) """ Check stop criteria """ cond_same_point = array_equal(best_ls_point.x, prevIter_best_ls_point.x) if cond_same_point and not p.istop: p.istop = 14 p.msg = 'X[k-1] and X[k] are same' p.stopdict[SMALL_DELTA_X] = True restoreProb() self.innerState = {'B': b, 'hs': hs} return s2 = 0 if p.istop and not p.userStop: if p.istop not in p.stopdict: p.stopdict[ p. istop] = True # it's actual for converters, TODO: fix it if SMALL_DF in p.stopdict: if best_ls_point.isFeas(False): s2 = p.istop p.stopdict.pop(SMALL_DF) if SMALL_DELTA_F in p.stopdict: # TODO: implement it more properly if best_ls_point.isFeas( False ) and prevIter_best_ls_point.f() != best_ls_point.f(): s2 = p.istop p.stopdict.pop(SMALL_DELTA_F) if SMALL_DELTA_X in p.stopdict: if best_ls_point.isFeas( False) or not prevIter_best_ls_point.isFeas( False) or cond_same_point: s2 = p.istop p.stopdict.pop(SMALL_DELTA_X) # if s2 and (any(isnan(best_ls_point.c())) or any(isnan(best_ls_point.h()))) \ # and not p.isNaNInConstraintsAllowed\ # and not cond_same_point: # s2 = 0 if not s2 and any(p.stopdict.values()): for key, val in p.stopdict.items(): if val == True: s2 = key break p.istop = s2 for key, val in p.stopdict.items(): if key < 0 or key in set([ FVAL_IS_ENOUGH, USER_DEMAND_STOP, BUTTON_ENOUGH_HAS_BEEN_PRESSED ]): p.iterfcn(bestPoint) self.innerState = {'B': b, 'hs': hs} return """ If stop required """ if p.istop: # if self.needRej(p, b, g1, g) or not feasiblePointWasEncountered: # b = B0.copy() # hs = max((p.norm(prevIter_best_ls_point.x - best_ls_point.x) , 128*p.xtol)) # p.istop = 0 # else: restoreProb() p.iterfcn(bestPoint) #p.istop, p.msg = istop, msg self.innerState = {'B': b, 'hs': hs} return """ Some final things for ralg main cycle """ # p.debugmsg('new point Aeq residual:'+str(norm(dot(Aeq, iterPoint.x)-beq))) # if needProjection and itn!=0: # #pass # x2 = self.linEqProjection(iterPoint.x, Aeq, beq) # p.debugmsg('norm(delta):' + str(norm(iterPoint.x-x2))) # iterPoint = p.point(x2) # p.debugmsg('2: new point Aeq residual:'+str(norm(dot(Aeq, iterPoint.x)-beq))) #p.hs.append(hs) #g = moveDirection.copy() #prevDirectionForDilation = directionForDilation #iterPoint = None #doScale = self.new_s and prevIter_PointForDilation.isFeas(True) != best_ls_point.isFeas(True) #print doScale prevIter_best_ls_point = best_ls_point prevIter_PointForDilation = best_ls_point prevDirectionForDilation = best_ls_point._getDirection( self.approach) moveDirection = best_ls_point._getDirection(self.approach)
def truncateByPlane(y, e, indT, A, b): #!!!!!!!!!!!!!!!!!!! # TODO: vectorize it by matrix A #!!!!!!!!!!!!!!!!!!! ind_trunc = True assert np.asarray(b).size <= 1, 'unimplemented yet' m, n = y.shape if m == 0: assert e.size == 0, 'bug in interalg engine' return y, e, indT, ind_trunc ind_positive = where(A > 0)[0] ind_negative = where(A < 0)[0] A1 = A[ind_positive] S1 = A1 * y[:, ind_positive] A2 = A[ind_negative] S2 = A2 * e[:, ind_negative] s1, s2 = np.sum(S1, 1), np.sum(S2, 1) S = s1 + s2 if ind_positive.size != 0: S1_ = b - S.reshape(-1, 1) + S1 Alt_ub = S1_ / A1 # ind = e[:, ind_positive] > Alt_ub # #e[:, ind_positive[ind]] = Alt_ub[ind] # e[:, np.tile(ind_positive,(ind.shape[0],1))[ind]] = Alt_ub[ind] # #e[:, ind_positive.reshape(ind.shape)[ind]] = Alt_ub[ind] # # indT[np.any(ind, 1)] = True for _i, i in enumerate(ind_positive): #s = S - S1[:, _i] #alt_ub = (b - s) / A[i] #alt_ub = S1_[:, _i] / A[i] alt_ub = Alt_ub[:, _i] ind = e[:, i] > alt_ub Ind = where(ind)[0] if Ind.size: e[Ind, i] = alt_ub[Ind] indT[Ind] = True if ind_negative.size != 0: S2_ = b - S.reshape(-1, 1) + S2 Alt_lb = S2_ / A2 for _i, i in enumerate(ind_negative): #s = S - S2[:, _i] #alt_lb = (b - s) / A[i] #alt_lb = S2_[:, _i] / A[i] alt_lb = Alt_lb[:, _i] ind = y[:, i] < alt_lb Ind = where(ind)[0] if Ind.size: y[Ind, i] = alt_lb[Ind] indT[Ind] = True ind = np.all(e>=y, 1) if not np.all(ind): ind_trunc = where(ind)[0] lj = ind_trunc.size y = take(y, ind_trunc, axis=0, out=y[:lj]) e = take(e, ind_trunc, axis=0, out=e[:lj]) indT = indT[ind_trunc] return y, e, indT, ind_trunc
def truncateByPlane2(cs, centerValues, y, e, indT, gradient, fo, p): ind_trunc = True assert np.asarray(fo).size <= 1, 'unimplemented yet' m, n = y.shape if m == 0: assert e.size == 0, 'bug in interalg engine' return y, e, indT, ind_trunc oovarsIndDict = p._oovarsIndDict ind = np.array([oovarsIndDict[oov][0] for oov in gradient.keys()]) y2, e2 = y[:, ind], e[:, ind] A = np.vstack( [np.asarray(elem).reshape(1, -1) for elem in gradient.values()]).T cs = 0.5 * (y2 + e2) b = np.sum(A * cs, 1) - centerValues.view(np.ndarray) + fo # ind_positive = where(A > 0) # ind_negative = where(A < 0) A_positive = where(A > 0, A, 0) A_negative = where(A < 0, A, 0) #S1 = A[ind_positive] * y2[ind_positive] #S2 = A[ind_negative] * e2[ind_negative] S1 = A_positive * y2 S2 = A_negative * e2 s1, s2 = np.sum(S1, 1), np.sum(S2, 1) S = s1 + s2 alt_fo1 = where(A_positive != 0, (b.reshape(-1, 1) - S.reshape(-1, 1) + S1) / A_positive, np.inf) ind1 = logical_and(e2 > alt_fo1, A_positive != 0) e2[ind1] = alt_fo1[ind1] alt_fo2 = where(A_negative != 0, (b.reshape(-1, 1) - S.reshape(-1, 1) + S2) / A_negative, -np.inf) ind2 = logical_and(y2 < alt_fo2, A_negative != 0) y2[ind2] = alt_fo2[ind2] # TODO: check it y[:, ind], e[:, ind] = y2, e2 # TODO: check indT indT[np.any(ind1, 1)] = True indT[np.any(ind2, 1)] = True # for _i, i in enumerate(ind_positive): # s = S - S1[:, _i] # alt_ub = (b - s) / A[i] # ind = e[:, i] > alt_ub # e[ind, i] = alt_ub[ind] # indT[ind] = True # # for _i, i in enumerate(ind_negative): # s = S - S2[:, _i] # alt_lb = (b - s) / A[i] # ind = y[:, i] < alt_lb # y[ind, i] = alt_lb[ind] # indT[ind] = True ind = np.all(e >= y, 1) if not np.all(ind): ind_trunc = where(ind)[0] lj = ind_trunc.size y = take(y, ind_trunc, axis=0, out=y[:lj]) e = take(e, ind_trunc, axis=0, out=e[:lj]) indT = indT[ind_trunc] return y, e, indT, ind_trunc
from numpy import empty, logical_and, logical_not, take, zeros, isfinite, any, \ asarray, ndarray, bool_#where from interalgT import adjustDiscreteVarBounds, truncateByPlane import numpy as np # for PyPy from openopt.kernel.nonOptMisc import where hasPoint = lambda y, e, point:\ True if y.size != 0 and any([(np.all(y[i]<=point) and np.all(e[i]>=point)) for i in range(y.shape[0])]) else False pointInd = lambda y, e, point:\ where([(np.all(y[i]<=point) and np.all(e[i]>=point)) for i in range(y.shape[0])])[0].tolist() def processConstraints(C0, y, e, _s, p, dataType): #P = np.array([ 7.64673334e-01, 4.35551807e-01, 5.93869991e+02, 5.00000000e+00]) # P = np.array([-0.63521194458007812, -0.3106536865234375, 0.0905609130859375, 0.001522064208984375, -0.69999999999999996, -0.99993896484375, 0.90000152587890625, 1.0, 4.0]) # print('c-1', p.iter, hasPoint(y, e, P), pointInd(y, e, P)) n = p.n m = y.shape[0] indT = empty(m, bool) indT.fill(False) # isSNLE = p.probType in ('NLSP', 'SNLE') for i in range(p.nb): y, e, indT, ind_trunc = truncateByPlane(y, e, indT, p.A[i], p.b[i]+p.contol) if ind_trunc is not True: _s = _s[ind_trunc] for i in range(p.nbeq): # TODO: handle it via one func y, e, indT, ind_trunc = truncateByPlane(y, e, indT, p.Aeq[i], p.beq[i]+p.contol)
def r44(Solutions, r5Coords, r5F, targets, sigma): # print Solutions.F # if len(Solutions.F) != Solutions.coords.shape[0]: # raise 0 # TODO: rework it #sf = asarray(Solutions.F) nIncome, nOutcome = 0, 0 m= len(r5Coords) #n = len(r5Coords[0]) # TODO: mb use inplace r5Coords / r5F modification instead? for j in range(m): if isnan(r5F[0][0]): continue if Solutions.coords.size == 0: Solutions.coords = array(r5Coords[j]).reshape(1, -1) Solutions.F.append(r5F[0]) nIncome += 1 continue M = Solutions.coords.shape[0] r47 = empty(M, bool) r47.fill(False) # r48 = empty(M, bool) # r48.fill(False) for i, target in enumerate(targets): f = r5F[j][i] # TODO: rewrite it F = asarray([Solutions.F[k][i] for k in range(M)]) #d = f - F # vector-matrix val, tol = target.val, target.tol Tol = sigma * tol if val == inf: r52 = f > F + Tol # r36olution_better = f <= F#-tol elif val == -inf: r52 = f < F - Tol # r36olution_better = f >= F#tol else: r52 = abs(f - val) < abs(F - val) - Tol # r36olution_better = abs(f - val) >= abs(Solutions.F[i] - val)#-tol # abs(Solutions.F[i] - target) < abs(f[i] - target) + tol r47 = logical_or(r47, r52) # r48 = logical_or(r48, r36olution_better) accept_c = all(r47) #print sum(asarray(Solutions.F))/asarray(Solutions.F).size if accept_c: nIncome += 1 #new r48 = empty(M, bool) r48.fill(False) for i, target in enumerate(targets): f = r5F[j][i] F = asarray([Solutions.F[k][i] for k in range(M)]) val, tol = target.val, target.tol if val == inf: r36olution_better = f < F elif val == -inf: r36olution_better = f > F else: r36olution_better = abs(f - val) > abs(F - val) r48 = logical_or(r48, r36olution_better) r49 = logical_not(r48) remove_s = any(r49) if remove_s: r50 = where(r49)[0] nOutcome += r50.size Solutions.coords[r50[0]] = r5Coords[j] Solutions.F[r50[0]] = r5F[j] if r50.size > 1: r49[r50[0]] = False indLeft = logical_not(r49) indLeftPositions = where(indLeft)[0] newSolNumber = Solutions.coords.shape[0] - r50.size + 1 Solutions.coords = take(Solutions.coords, indLeftPositions, axis=0, out = Solutions.coords[:newSolNumber]) Solutions.F = [Solutions.F[i] for i in indLeftPositions] else: Solutions.coords = vstack((Solutions.coords, r5Coords[j])) Solutions.F.append(r5F[j]) return nIncome, nOutcome
def processConstraints(C0, y, e, _s, p, dataType): #P = np.array([ 7.64673334e-01, 4.35551807e-01, 5.93869991e+02, 5.00000000e+00]) # P = np.array([-0.63521194458007812, -0.3106536865234375, 0.0905609130859375, 0.001522064208984375, -0.69999999999999996, -0.99993896484375, 0.90000152587890625, 1.0, 4.0]) # print('c-1', p.iter, hasPoint(y, e, P), pointInd(y, e, P)) n = p.n m = y.shape[0] indT = empty(m, bool) indT.fill(False) # isSNLE = p.probType in ('NLSP', 'SNLE') for i in range(p.nb): y, e, indT, ind_trunc = truncateByPlane(y, e, indT, p.A[i], p.b[i]+p.contol) if ind_trunc is not True: _s = _s[ind_trunc] for i in range(p.nbeq): # TODO: handle it via one func y, e, indT, ind_trunc = truncateByPlane(y, e, indT, p.Aeq[i], p.beq[i]+p.contol) if ind_trunc is not True: _s = _s[ind_trunc] y, e, indT, ind_trunc = truncateByPlane(y, e, indT, -p.Aeq[i], -p.beq[i]+p.contol) if ind_trunc is not True: _s = _s[ind_trunc] DefiniteRange = True if len(p._discreteVarsNumList): y, e, _s, indT = adjustDiscreteVarBounds(y, e, _s, indT, p) m = y.shape[0] nlh = zeros((m, 2*n)) nlh_0 = zeros(m) fullOutput = False#isSNLE and not p.hasLogicalConstraints residual = zeros((m, 2*n)) if fullOutput else None residual_0 = zeros(m) if fullOutput else None for itn, (c, f, lb, ub, tol) in enumerate(C0): # print ('c_1', itn, c.dep, hasPoint(y, e, P)) m = y.shape[0] # is changed in the cycle if m == 0: return y.reshape(0, n), e.reshape(0, n), nlh.reshape(0, 2*n), residual, True, False, _s #return y.reshape(0, n), e.reshape(0, n), nlh.reshape(0, 2*n), residual.reshape(0, 2*n), True, False, _s assert nlh.shape[0] == y.shape[0] if fullOutput: (T0, Res0), (res, R_res), DefiniteRange2 = c.nlh(y, e, p, dataType, fullOutput = True) residual_0 += Res0 else: # may be logical constraint and doesn't have kw fullOutput at all T0, res, DefiniteRange2 = c.nlh(y, e, p, dataType) DefiniteRange = logical_and(DefiniteRange, DefiniteRange2) assert T0.ndim <= 1, 'unimplemented yet' nlh_0 += T0 assert nlh.shape[0] == m # TODO: rework it for case len(p._freeVarsList) >> 1 for v, tmp in res.items(): j = p._freeVarsDict.get(v) nlh[:, n+j] += tmp[:, tmp.shape[1]/2:].flatten() - T0 nlh[:, j] += tmp[:, :tmp.shape[1]/2].flatten() - T0 if fullOutput: Tmp = R_res[v] residual[:, n+j] += Tmp[:, Tmp.shape[1]/2:].flatten() - Res0 residual[:, j] += Tmp[:, :Tmp.shape[1]/2].flatten() - Res0 assert nlh.shape[0] == m ind = where(logical_and(any(isfinite(nlh), 1), isfinite(nlh_0)))[0] lj = ind.size if lj != m: y = take(y, ind, axis=0, out=y[:lj]) e = take(e, ind, axis=0, out=e[:lj]) nlh = take(nlh, ind, axis=0, out=nlh[:lj]) nlh_0 = nlh_0[ind] # residual = take(residual, ind, axis=0, out=residual[:lj]) indT = indT[ind] _s = _s[ind] if fullOutput: residual_0 = residual_0[ind] residual = take(residual, ind, axis=0, out=residual[:lj]) if asarray(DefiniteRange).size != 1: DefiniteRange = take(DefiniteRange, ind, axis=0, out=DefiniteRange[:lj]) # print ('c_2', itn, c.dep, hasPoint(y, e, P)) assert nlh.shape[0] == y.shape[0] ind = logical_not(isfinite(nlh)) if any(ind): indT[any(ind, 1)] = True ind_l, ind_u = ind[:, :ind.shape[1]/2], ind[:, ind.shape[1]/2:] tmp_l, tmp_u = 0.5 * (y[ind_l] + e[ind_l]), 0.5 * (y[ind_u] + e[ind_u]) y[ind_l], e[ind_u] = tmp_l, tmp_u # TODO: mb implement it if len(p._discreteVarsNumList): if tmp_l.ndim > 1: # shouldn't reduce y,e shape here, so output values doesn't matter l1 = len(_s) tmp_l, tmp_u, _s2, indT2 = adjustDiscreteVarBounds(tmp_l, tmp_u, _s, indT, p) l2 = len(_s2) if l1 != l2: print('Warning: possible bug in interalg constraints processing, inform developers') else: y, e, _s, indT = adjustDiscreteVarBounds(y, e, _s, indT, p) nlh_l, nlh_u = nlh[:, nlh.shape[1]/2:], nlh[:, :nlh.shape[1]/2] # copy() is used because += and -= operators are involved on nlh in this cycle and probably some other computations nlh_l[ind_u], nlh_u[ind_l] = nlh_u[ind_u].copy(), nlh_l[ind_l].copy() if fullOutput: residual_l, residual_u = residual[:, residual.shape[1]/2:], residual[:, :residual.shape[1]/2] residual_l[ind_u], residual_u[ind_l] = residual_u[ind_u].copy(), residual_l[ind_l].copy() # print ('c_3', itn, c.dep, hasPoint(y, e, P)) if nlh.size != 0: if DefiniteRange is False: nlh_0 += 1e-300 elif type(DefiniteRange) == ndarray and not all(DefiniteRange): nlh_0[logical_not(DefiniteRange)] += 1e-300 else: assert type(DefiniteRange) in (bool, bool_, ndarray) # !! matrix - vector nlh += nlh_0.reshape(-1, 1) if fullOutput: # !! matrix - vector residual += residual_0.reshape(-1, 1) residual[residual_0>=1e300] = 1e300 #print('c2', p.iter, hasPoint(y, e, P), pointInd(y, e, P)) return y, e, nlh, residual, DefiniteRange, indT, _s
def truncateByPlane2(cs, centerValues, y, e, indT, gradient, fo, p): ind_trunc = True assert np.asarray(fo).size <= 1, 'unimplemented yet' m, n = y.shape if m == 0: assert e.size == 0, 'bug in interalg engine' return y, e, indT, ind_trunc oovarsIndDict = p._oovarsIndDict ind = np.array([oovarsIndDict[oov][0] for oov in gradient.keys()]) y2, e2 = y[:, ind], e[:, ind] A = np.vstack([np.asarray(elem).reshape(1, -1) for elem in gradient.values()]).T cs = 0.5 * (y2 + e2) b = np.sum(A * cs, 1) - centerValues.view(np.ndarray) + fo # ind_positive = where(A > 0) # ind_negative = where(A < 0) A_positive = where(A>0, A, 0) A_negative = where(A<0, A, 0) #S1 = A[ind_positive] * y2[ind_positive] #S2 = A[ind_negative] * e2[ind_negative] S1 = A_positive * y2 S2 = A_negative * e2 s1, s2 = np.sum(S1, 1), np.sum(S2, 1) S = s1 + s2 alt_fo1 = where(A_positive != 0, (b.reshape(-1, 1) - S.reshape(-1, 1) + S1) / A_positive, np.inf) ind1 = logical_and(e2 > alt_fo1, A_positive != 0) e2[ind1] = alt_fo1[ind1] alt_fo2 = where(A_negative != 0, (b.reshape(-1, 1) - S.reshape(-1, 1) + S2) / A_negative, -np.inf) ind2 = logical_and(y2 < alt_fo2, A_negative != 0) y2[ind2] = alt_fo2[ind2] # TODO: check it y[:, ind], e[:, ind] = y2, e2 # TODO: check indT indT[np.any(ind1, 1)] = True indT[np.any(ind2, 1)] = True # for _i, i in enumerate(ind_positive): # s = S - S1[:, _i] # alt_ub = (b - s) / A[i] # ind = e[:, i] > alt_ub # e[ind, i] = alt_ub[ind] # indT[ind] = True # # for _i, i in enumerate(ind_negative): # s = S - S2[:, _i] # alt_lb = (b - s) / A[i] # ind = y[:, i] < alt_lb # y[ind, i] = alt_lb[ind] # indT[ind] = True ind = np.all(e>=y, 1) if not np.all(ind): ind_trunc = where(ind)[0] lj = ind_trunc.size y = take(y, ind_trunc, axis=0, out=y[:lj]) e = take(e, ind_trunc, axis=0, out=e[:lj]) indT = indT[ind_trunc] return y, e, indT, ind_trunc