ich würde gerne wissen, was man als "Profi" in Python an meinem Code ändern würde oder was auffällig schlecht implementiert ist.
Des Weiteren habe ich ein Problem mit dem "function handle" wie es in MATLAB heißen würde. Das Einlesen einer mathematischen Funktion, die abhängig von v1 und v2 ist, funktioniert nicht so, wie das gerne hätte. Es wird immer ein Startwert benötigt und direkt ausgewertet, was bei mir aber erst innerhalb eines Loops passieren soll. Mit dem lambda Befehl hab ich es auch nicht besser hinbekommen, weshalb ich mich jetzt an euch wenden muss :K
Es geht mir primär um den Aufruf der OptimiseWith... Funktion und dem funktionierenden Programmablauf nach Aufruf.
Code: Alles auswählen
import math as m
from sympy import *
import numpy as np
class TestFunction(object):
def __init__(self, name, domain_size, discretization_step_size):
self.name = name #string
self.domain_size = domain_size #array of double [2]
self.discretization_step_size = discretization_step_size # double
print("object initialized")
def __internal_function_evaluation__(self):
# calculate something internally
P1=objective_function.design_variable1
P2=objective_function.design_variable2
L=4
qz=5
EI= 10000
EA= 100000
h= 1.5*L
L_2= L*L
h_2= h*h
L4=m.sqrt(L_2+h_2)
L5=m.sqrt((2*L)**2+h**2)
K=np.array([[(h/L4)**2*EA/L4+3*EI/L**3+12*EI/L**3 , 3*EI/L**2-6*EI/L**2, -12*EI/L**3, -6*EI/L**2],
[3*EI/L**2-6*EI/L**2, 3*EI/L+4*EI/L, 6*EI/L**2, 2*EI/L],
[-12*EI/L**3, 6*EI/L**2, 12*EI/L**3+3*EI/L**3+(h/L5)**2*EA/L5, 6*EI/L**2-3*EI/L**2],
[-6*EI/L**2, 2*EI/L, 6*EI/L**2-3*EI/L**2, 4*EI/L+3*EI/L]])
F=np.array([[5/8*qz*L+1/2*qz*L -P1*h/L4],
[qz*L**2/8-qz*L**2/12],
[5/8*qz*L+1/2*qz*L -P2*h/L5],
[qz*L**2/12-qz*L**2/8]])
Kinv=np.linalg.inv(K)
U=np.dot(Kinv,F)
return U
print("internal function called")
pass
def objective_function(self, design_variable1, design_variable2):
print("external function called")
intermediate_results = self.__internal_function_evaluation_()
# do something with intermediate_results
v1= intermediate_results(0)
v2= intermediate_results(2)
v=test_function
return v1, v2
pass
class EvaluationStrategy(object):
def __init__(self, test_function):
self.test_function = test_function
#self.test_function = (lambda v1, v2: test_function)(v1,v2)
print(self.test_function)
# save all evaluation data
# save best data
def general_strategy(self):
print(self.test_function.domain_size)
print(self.test_function.objective_function(5.0))
class OptimiseWithSteepestDescent(EvaluationStrategy):
def Optimise_With_Steepest_Descent_SB(self):
#F=self.test_function
precision=0.0001
gamma= 0.01
cur_T1=0
cur_T2=0
prev_T1=cur_T1
prev_T2=cur_T2
previous_step_size1=100
previous_step_size2=100
while previous_step_size1 > precision or previous_step_size2 > precision:
prev_T1= cur_T1
prev_T2= cur_T2
df_T1= (TestFunction.objective_function(prev_T1,prev_T2)-TestFunction.objective_function(prev_T1+precision,prev_T2))/precision
df_T2= (TestFunction.objective_function(prev_T1,prev_T2)-TestFunction.objective_function(prev_T1,prev_T2+precision))/precision
cur_T1+= -gamma *df_T1
cur_T2+= -gamma *df_T2
prev_step_size1=m.sqrt((cur_T1)**2-(prev_T1)**2)
prev_step_size2=m.sqrt((cur_T2)**2-(prev_T2)**2)
print(cur_T1)
return cur_T1, cur_T2
Problem daran ist, dass ich damit versuche meine Bachelorarbeit zu schreiben und es leider nicht anders lösen kann, es aber in der Form verlangt wird. Als Nicht-Informatiker mit neuer Programmiersprache usw. tut man sich doch relativ schwer 