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')