def quadraticMinSearcherTestWithoutGamma( repeats , f ): eps = 0.01 notUnique = 0 singDiffMatrix = 0 fails = 0 while repeats > 0: repeats -= 1 P = rP.getRandomPolygon( 5 ) cD = cV.getConeVol( P ) result = quadraticMinSearcher( cD , [ f , eps ] )[0] if M.dist( result , P[0]) > 0.1: value = M.dist(cV.getConeVolIterator( cD , result ) , result) if value < eps: print( 'not unique solution' ) print( P ) print(result) notUnique += 1 break else: if f( result , cD ) < 0.01: print(" singular diff matrix ") print(P) print(result) print( f( result , cD ) ) singDiffMatrix += 1 else: print('quadratic searcher failed by') print(P) print(result) fails += 1 return [notUnique , singDiffMatrix , fails]
def getNearestNegGrad( orderedGrid , cD , params_posGrad): transGridMid( orderedGrid , params_posGrad ) result = [ ] for point in orderedGrid: while (True): try: if scalGrad( point, cD ) <= 0: if len(result) == 0 or M.dist( point , params_posGrad ) < M.dist( result , params_posGrad ) : result = point break except ZeroDivisionError: # print('zero division at',pair) break return result
def coneVolumeDescendBFGSApprox(cD, params_new, params_prev, crease, efficiency, beta_1, beta_2): A_k = M.idMatrix(2) n = 0 while (cV.phi(params_new, cD) > eps_descend): while (True): try: A_k = BFGS.getBFGSApprox(cD, params_new, params_prev, A_k) break except ZeroDivisionError: print('es geht nicht besser mit BFGSApprox') return params_new break antiGrad = M.scaleVek(-1, cV.gradPhiApprox(params_new, cD, 0.0001)) d = A_k.lgsSolve(antiGrad) d = M.scaleVek(1.0 / M.norm(d), d) alpha = sS.stepSizeArmijo(cD, params_new, d, crease, efficiency, beta_1, beta_2) d = M.scaleVek(alpha, d) params_prev = [params_new[0], params_new[1]] params_new = M.addVek(params_new, d) if (M.dist(params_new, params_prev) < minimalStep_BFGSApprox): print(' distance is lower than minimalStep of BFGSApprox ') break n = n + 1 return params_new
def coneVolumeDescendArmijo(cD, start, crease, efficiency, beta_1, beta_2): result = start n = 0 previous = [-1, -1] print('gehe in while schleife ') while (cV.phi(result, cD) > eps_descend): if M.dist(previous, result) > minimalStep_descendArmijo: previous[0] = result[0] previous[1] = result[1] d = M.scaleVek(-1, cV.gradPhi(result, cD)) #d = M.scaleVek( 1 / M.norm(d) , d ) alpha = sS.stepSizeArmijo(cD, result, d, crease, efficiency, beta_1, beta_2) result = M.addVek(result, M.scaleVek(alpha, d)) else: print('versuche es mit BFGS und BFGSApprox') result_1 = coneVolumeDescendBFGSApprox(cD, result, previous, crease, efficiency, beta_1, beta_2) result_2 = coneVolumeDescendBFGS(cD, result, previous, crease, efficiency, beta_1, beta_2) if cV.phi(result_1, cD) < cV.phi(result_2, cD): return result_1 else: return result_2 n = n + 1 return result
def quadraticMinSearcherTest( repeats , f ): eps = 0.00001 fails = 0 while repeats > 0: print( repeats ) repeats -= 1 P = rP.getRandomPolygon( 5 ) cD = cV.getConeVol( P ) result = quadraticMinSearcher( cD , [ f , eps ] )[0] if M.dist( cV.gamma( cD , result) , P[0]) > 0.1: if cV.sigma( result , cD ) < eps: print( 'not unique solution' ) print( P ) print(result) print( cV.gamma( cD , result ) ) fails += 1 break else: print('quadratic searcher failed by by') print( cV.sigma( result , cD ) ) print(P) print(result) print(cV.gamma(cD, result)) fails += 1 return fails
def coneVolTest(polygon, coneVolume, eps): diff = 0 coneData = cV.getConeVol(polygon) for i in range(len(polygon)): diff += M.dist(coneData[i - 1], coneVolume[i - 1])**2 if diff >= eps: print('coneVolTest failed with polygon') print(polygon)
def hMethodConeVolIteratorCheck(cD, point, eps, h): while (True): try: vektor = cV.coneVolIterator(cD, point) break except ZeroDivisionError: return True break diff = cV.diffConeVolumeIterator(cD, point) e_1 = [1, 0] e_2 = [0, 1] diff_1 = diff.image(e_1) diff_2 = diff.image(e_2) point_diff11 = M.addVek(point, M.scaleVek(h, e_1)) point_diff12 = M.subVek(point, M.scaleVek(h, e_1)) quotient_diff1 = M.subVek( M.scaleVek(1 / (2 * h), cV.coneVolIterator(cD, point_diff11)), M.scaleVek(1 / (2 * h), cV.coneVolIterator(cD, point_diff12))) point_diff21 = M.addVek(point, M.scaleVek(h, e_2)) point_diff22 = M.subVek(point, M.scaleVek(h, e_2)) quotient_diff2 = M.subVek( M.scaleVek(1 / (2 * h), cV.coneVolIterator(cD, point_diff21)), M.scaleVek(1 / (2 * h), cV.coneVolIterator(cD, point_diff22))) difference_1 = M.dist(quotient_diff1, diff_1) difference_2 = M.dist(quotient_diff2, diff_2) print(' the differences equals') print(diff_1) print(quotient_diff1) print(diff_2) print(quotient_diff2) if difference_1 >= eps or difference_2 >= eps: print(' the differences equals') print(difference_1) print(difference_2) return False return True
def coneVoliteratorTest(cD, firstPointOfPolygon, eps): vector = cV.getConeVolIterator(cD, firstPointOfPolygon) if M.dist(vector, firstPointOfPolygon) >= eps: print( ' error at coneVolIterator Test with first polygon vertex and cD :' ) print(firstPointOfPolygon) print(cD) return False return True
def getMinForSupport2(v, w, u): u_1 = u u_2 = M.subVek(v, w) #print(u_1) U = M.Matrix([u_1, u_2]).copyTrans() #U.list() result = U.lgsSolve2x2(v) # my lgsSolver returns a 'solution' even if v is not in im(M) . Therefore the if-check needs to get adjusted if (M.dist(U.image(result), v) > 0.0001): return -math.inf return result[0]
def hMethodNextVertexCheck(u, V, point, eps, h): nextVektor = cV.getNextVertex(u, V, point) while (True): try: nextVektor = cV.getNextVertex(u, V, point) break except ZeroDivisionError: return True break diff = cV.diffGetNextVertex(u, V, point) e_1 = [1, 0] e_2 = [0, 1] diff_1 = diff.image(e_1) diff_2 = diff.image(e_2) point_diff1 = M.addVek(point, M.scaleVek(h, e_1)) quotient_diff1 = M.subVek( M.scaleVek(1 / h, cV.getNextVertex(u, V, point_diff1)), M.scaleVek(1 / h, cV.getNextVertex(u, V, point))) point_diff2 = M.addVek(point, M.scaleVek(h, e_2)) quotient_diff2 = M.subVek( M.scaleVek(1 / h, cV.getNextVertex(u, V, point_diff2)), M.scaleVek(1 / h, cV.getNextVertex(u, V, point))) difference_1 = M.dist(quotient_diff1, diff_1) difference_2 = M.dist(quotient_diff2, diff_2) print(' the differences equals') print(difference_1) print(difference_2) if difference_1 >= eps or difference_2 >= eps: print(' the differences euqal') print(difference_1) print(difference_2) return False return True
def coneVolumeDescend(cD, start): result = start previous = [-1, -1] n = 0 print('gehe in while schleife ') while (cV.phi(result, cD) > eps_descend): if M.dist(previous, result) > 0.1: previous[0] = result[0] previous[1] = result[1] d = M.scaleVek(-1, cV.gradPhiApprox(result, cD, 0.0001)) # d = M.scaleVek( 1 / M.norm(d) , d ) alpha = sS.stepSize_posGrad(cD, result, d, n) result = M.addVek(result, M.scaleVek(alpha, d)) n = n + 1 else: print('versuche es mit BFGS und BFGSApprox, Start bei:') print(cV.gamma(cD, result)) result_2 = coneVolumeDescendBFGS(cD, result, previous, crease_test, efficiency_test, beta_1test, beta_2test) print('BFGS ist fertig mit:') print(cV.gamma(cD, result_2)) result_1 = coneVolumeDescendBFGSApprox(cD, result, previous, crease_test, efficiency_test, beta_1test, beta_2test) print('BFGS Approx ist fertig!') if cV.phi(result_1, cD) < cV.phi(result_2, cD): return result_1 else: return result_2 return result
def coneVolumeDescendBFGS(cD, params_new, params_prev, crease, efficiency, beta_1, beta_2): A_k = M.idMatrix(2) n = 0 while (cV.phi(params_new, cD) > eps_descend): # ICH VERÄNDERE HIER MEIN CREASE... crease = 0.000001 #cV.phi( params_new , cD) * 0.00000001 while (True): try: A_k = BFGS.getBFGS(cD, params_new, params_prev, A_k) break except ZeroDivisionError: print('es geht nicht besser') return params_new break antiGrad = M.scaleVek(-1, cV.gradPhi(params_new, cD)) d = A_k.lgsSolve(antiGrad) d = M.scaleVek(1.0 / M.norm(d), d) alpha = sS.stepSize_posGrad( cD, params_new, d, n) # crease , efficiency , beta_1 , beta_2 ) d = M.scaleVek(alpha, d) params_prev = [params_new[0], params_new[1]] params_new = M.addVek(params_new, d) if (M.dist(params_new, params_prev) < minimalStep_BFGS): print(' distance is lower than minimalStep of BFGS ') break n = n + 1 return params_new
eps_test) sigma_result = cV.sigma(result, cD_test) if (sigma_result < eps_test): noFail += 1 else: if (sigma_result < eps_test * 100): fail_soft += 1 else: if (sigma_result < eps_test * 100 * 100): fail_medium += 1 else: fail_hard += 1 if M.dist(cV.gamma(cD_test, result), P_test[0]) > 0.01: if sigma_result < eps_test: print( ' not unique!!! polygon, result, gamma result , phi value, sigma value:' ) print(P_test) print(result) print(cV.gamma(cD_test, result)) print(cV.phi(result, cD_test)) print(cV.sigma(result, cD_test)) else: print( ' FAIL!! polygon, result, gamma result , phi value, sigma value:' ) print(P_test)
def makeVertexDistTest(polygon, epsilon): n = len(polygon) for i in range(n): if M.dist(polygon[i % n], polygon[i - 1]) >= epsilon: return False return True
if math.fabs(beta - math.sqrt(2)) > 0.00000001: print(' Fehler bei supportCartesianCentered function test ') print(beta) Trapez = [[1, 1], [0, 1], [-3, -1], [0, -1]] a = Trapez[3][0] - Trapez[2][0] b = Trapez[0][0] - Trapez[1][0] h = Trapez[1][1] - Trapez[2][1] e = Trapez[0][0] - Trapez[2][0] center = rP.getCenter(Trapez) # center form wikipedia formula for center of trapez center2 = [(a**2 - b**2 + e * (a + 2.0 * b)) / (3.0 * (a + b)) + Trapez[2][0], h * (a + 2.0 * b) / (3.0 * (a + b)) + Trapez[2][1]] if M.dist(center, center2) > 0.00001: print('fehler bei getCenter for trapez') print(center) print(center2) print(a) print(b) print(h) print(e) plotPoly(Trapez, 'r') #rP.makeCentered( test ) #plotPoly( test , 'b') #support_test = [ [ 0 , 1] , [ 0.5 * math.pi , 1 ] , [ 1.5 * math.pi , 1 ] ]
d = M.scaleVek(2 * volume / M.scal(point, u), orth) temp = M.addVek(point, d) point[0] = temp[0] point[1] = temp[1] def getNextVertex(u, volume, point): result = [] nextVertex(u, volume, point) for x in point: result.append(x) return result nextPoint_test = getNextVertex([1, 0], 1, point_test) if M.dist(nextPoint_test, [1, 1]) > 0.00001: print(nextPoint_test) print('Fehler bei NextPoint') def domain(start, end, step): result = [] i = 0 while (start + i * step <= end): result.append(start + i * step) i += 1 return result # IMPORTANT: does nextVertex work with local variable rules of python? def coneVolIterator(coneData, point):
def polyFunct2(point, coneData): return M.dist(point, getConeVolIterator(coneData, point))**2
return result[0] def printRationalPolygon(rationalPolygon): string_result = ' [ ' for point in rationalPolygon: frac0 = point[0] frac1 = point[1] if rationalPolygon.index(point) < len(rationalPolygon) - 1: string_result = string_result + ' [ %d/%d , %d/%d ] ,' % ( frac0.numerator, frac0.denominator, frac1.numerator, frac1.denominator) else: string_result = string_result + ' [ %d/%d , %d/%d ] ' % ( frac0.numerator, frac0.denominator, frac1.numerator, frac1.denominator) print(string_result + ' ] ') M_test = M.Matrix([[f.Fraction(0, 1), f.Fraction(2, 1)], [f.Fraction(2, 1), f.Fraction(0, 1)]]) b_test = [f.Fraction(10, 1), f.Fraction(8, 1)] solutuion_test = M_test.lgsSolve(b_test) exspectedSolution_test = [f.Fraction(4, 1), f.Fraction(5, 1)] if M.dist(exspectedSolution_test, solutuion_test) > 0.001: print(exspectedSolution_test) print(solutuion_test) print(' Fehler in lgs solve für rationale Zahlen')