def SGD(U0,X0):
#-----------------------------------------------------------
#variáveis globais
#-----------------------------------------------------------
glob = GlobalVariables()
ganhoAlpha = glob.getGanhoAlpha()
#global ganhoAlpha
#-----------------------------------------------------------
#cálculo do gradiente da função
#-----------------------------------------------------------
G = gradienteFuncao(X0,U0)
g1 = G[0,0]
g2 = G[1,0]
g3 = G[2,0]
g4 = G[3,0]
#-----------------------------------------------------------
#atualizando o valor do vetor de controle - U SGD
#-----------------------------------------------------------
u1 = U0[0,0] - ganhoAlpha*g1
u2 = U0[1,0] - ganhoAlpha*g2
u3 = U0[2,0] - ganhoAlpha*g3
u4 = U0[3,0] - ganhoAlpha*g4
u5 = U0[4,0]
#-----------------------------------------------------------
#Valor atualizado
#-----------------------------------------------------------
U = np.array([[u1],[u2],[u3],[u4],[u5]])
return U
def adagrad(U0, X0, G0):
#-----------------------------------------------------------
#variáveis globais
#-----------------------------------------------------------
glob = GlobalVariables()
ganhoAlpha = glob.getGanhoAlpha()
#X0 = np.array((6,1))
#global ganhoAlpha
h = 10**(-8)
#-----------------------------------------------------------
#valor do ganho anterior
#-----------------------------------------------------------
G1 = G0[0, 0]
G2 = G0[1, 0]
G3 = G0[2, 0]
G4 = G0[3, 0]
#-----------------------------------------------------------
#cálculo do gradiente da função
#-----------------------------------------------------------
G = gradienteFuncao(X0, U0)
g1 = G[0, 0]
g2 = G[1, 0]
g3 = G[2, 0]
g4 = G[3, 0]
#-----------------------------------------------------------
#cálculo do novo ganho
#-----------------------------------------------------------
G1 = G1 + g1 * g1
G2 = G2 + g2 * g2
G3 = G3 + g3 * g3
G4 = G4 + g4 * g4
G0 = np.array([[G1], [G2], [G3], [G4]])
#-----------------------------------------------------------
#atualizando o valor do vetor de controle - U
#-----------------------------------------------------------
u1 = U0[0, 0] - (ganhoAlpha / (mt.sqrt(G1 + h))) * g1
u2 = U0[1, 0] - (ganhoAlpha / (mt.sqrt(G2 + h))) * g2
u3 = U0[2, 0] - (ganhoAlpha / (mt.sqrt(G3 + h))) * g3
u4 = U0[3, 0] - (ganhoAlpha / (mt.sqrt(G4 + h))) * g4
u5 = U0[4, 0]
#-----------------------------------------------------------
#Valor atualizado
#-----------------------------------------------------------
U = np.array([[u1], [u2], [u3], [u4], [u5]])
return U, G0
def NAG(U0, X0, vt):
#-----------------------------------------------------------
#variáveis globais
#-----------------------------------------------------------
glob = GlobalVariables()
ganhoAlpha = glob.getGanhoAlpha()
gamma = glob.getGamma()
#global ganhoAlpha, gamma
#-----------------------------------------------------------
#cálculando o valor com o ganho anterior
#-----------------------------------------------------------
y1 = U0[0, 0] - gamma * vt[0, 0]
y2 = U0[1, 0] - gamma * vt[1, 0]
y3 = U0[2, 0] - gamma * vt[2, 0]
y4 = U0[3, 0] - gamma * vt[3, 0]
y5 = U0[4, 0]
Y0 = np.array([[y1], [y2], [y3], [y4], [y5]])
#-----------------------------------------------------------
#cálculo do gradiente da função
#-----------------------------------------------------------
G = gradienteFuncao(X0, Y0)
g1 = G[0, 0]
g2 = G[1, 0]
g3 = G[2, 0]
g4 = G[3, 0]
#-----------------------------------------------------------
#cálculando o valor com o ganho atual
#-----------------------------------------------------------
vt[0, 0] = gamma * vt[0, 0] + ganhoAlpha * g1
vt[1, 0] = gamma * vt[1, 0] + ganhoAlpha * g2
vt[2, 0] = gamma * vt[2, 0] + ganhoAlpha * g3
vt[3, 0] = gamma * vt[3, 0] + ganhoAlpha * g4
u1 = U0[0, 0] - vt[0, 0]
u2 = U0[1, 0] - vt[1, 0]
u3 = U0[2, 0] - vt[2, 0]
u4 = U0[3, 0] - vt[3, 0]
u5 = U0[4, 0]
#-----------------------------------------------------------
#Valor atualizado
#-----------------------------------------------------------
U = np.array([[u1], [u2], [u3], [u4], [u5]])
return U, vt
def SGDMomento(U0, X0, vt):
#-----------------------------------------------------------
#variáveis globais
#-----------------------------------------------------------
glob = GlobalVariables()
ganhoAlpha = glob.getGanhoAlpha()
gamma = glob.getGamma()
#global ganhoAlpha, gamma
#-----------------------------------------------------------
#cálculo do gradiente da função
#-----------------------------------------------------------
G = gradienteFuncao(X0, U0)
g1 = G[0, 0]
g2 = G[1, 0]
g3 = G[2, 0]
g4 = G[3, 0]
#-----------------------------------------------------------
#cálculo do momento da função
#-----------------------------------------------------------
vt = np.zeros((4, 1))
vt[0, 0] = gamma * vt[0, 0] + ganhoAlpha * g1
vt[1, 0] = gamma * vt[1, 0] + ganhoAlpha * g2
vt[2, 0] = gamma * vt[2, 0] + ganhoAlpha * g3
vt[3, 0] = gamma * vt[3, 0] + ganhoAlpha * g4
#-----------------------------------------------------------
#atualizando o valor do vetor de controle - U
#-----------------------------------------------------------
u1 = U0[0, 0] - vt[0, 0]
u2 = U0[1, 0] - vt[1, 0]
u3 = U0[2, 0] - vt[2, 0]
u4 = U0[3, 0] - vt[3, 0]
u5 = U0[4, 0]
#-----------------------------------------------------------
#Valor atualizado
#-----------------------------------------------------------
U = np.array([[u1], [u2], [u3], [u4], [u5]])
return U, vt
#global m, L, g, lstep, pfa, thetaM, phiM, KM, expK, BSSM glob = GlobalVariables() #massa do corpo m = glob.getM() #tamanho da perna L = glob.getL() #gravidade g = glob.getG() #posição do pé de suporte em MS pfa = glob.getPfa() #----------------------------------------------------------- #Numero maximo de iterações para o metodo do gradiente #----------------------------------------------------------- #global maxNGrad, ganhoAlpha, gamma, h, hEdo maxNGrad = glob.getMaxNGrad() #número máximo de iterações método ganhoAlpha = glob.getGanhoAlpha() #ganho do fator de ganho para cada passo gamma = glob.getGamma() #ganho para os método gradiente(momento) h = glob.getH() #passo para o calculo das derivadas #calculado (comparado com a função do matlab) hEdo = glob.getHEDO() #passo para o calculo das derivadas #----------------------------------------------------------- #condição inicial para MS #----------------------------------------------------------- #hubo 2 + velocidade maxima 0.4 m/s # xod = 0.00 # yod = 0.05 # zod = 0.6 # dxod = 0.4 # dyod = 0.00 # dzod = 0.00