import numpy
import random
import math

teta = 1
MatrizPesoEntrada = numpy.zeros((2,30))
MatrizPesoSaida = numpy.zeros((30,1))
MatrizEntrada = numpy.zeros((100, 3))
MatrizEntradaNorm = numpy.zeros((100, 3))
F = numpy.zeros(30)
F2 = numpy.zeros(1)
E = numpy.zeros(30)
saida_delta = numpy.zeros(1)
ocultos_delta = numpy.zeros(30)
U2 = numpy.zeros((100,3))

def func1(x,y):
   result = math.cos(y/100)/(1+(x/100)**2)
   return result;


def func2(x,y):
    result = (x**2+y**2)*(math.sin(x/50)+math.cos(y/50))
    return result

def normalize(v):
    norm=numpy.linalg.norm(v)
    if norm==0:
       return v
    return v/norm


def normal(V,i):
    for y in range(i):
        U = V[y,:]
        T = normalize(U)
        for j in range(3):
             U2[y][j] = T[j]
    return U2

def definir():
    MatrizEntrada = [[558. -773. 0.0038]
                     [-859. 261. -0.0115]
                     [-697. 245. -0.0155]
                     [-347. -443. -0.0213]]
    for x in range(2):
        for y in range(30):
            MatrizPesoEntrada[x][y] = random.randrange(-10,10)/10
    for x in range(30):
        for y in range(1):
            MatrizPesoSaida[x][y] = random.randrange(-10,10)/10

    MatrizEntradaNorm = normal(MatrizEntrada,100)

def sorteio():
    return random.randrange(0,100)




def propagacao(sort):
    for j in range(30):
        V = 0
        for i in range(2):
            V += MatrizPesoEntrada[i][j] * MatrizEntradaNorm[sort][i]
        V += teta
        F[j] = math.tanh(V)
    for j in range(1):
        V2 = 0
        for i in range(30):
            V2 += F[i]*MatrizPesoSaida[i][j]
        V2 += teta
        F2[j] = math.tanh(V2)


def erro(sort):
    erro = 0
    for i in range(1):
        erro = MatrizEntradaNorm[sort][2] - F2[i]
        saida_delta[i] = (1 - math.tanh(F2[i]**2))*erro
    for i in range(30):
        erro = 0
        for j in range(1):
            erro += saida_delta[j]*MatrizPesoSaida[i][j]
        ocultos_delta[i] = (1 - math.tanh(F[i]**2))*erro
    return erro

def retropropagacao(sort):
    for i in range(30):
        for j in range(1):
            change = saida_delta[j]*F[i]
            MatrizPesoSaida[i][j] = MatrizPesoSaida[i][j] + (0.5*change)
    for i in range(2):
        for j in range(30):
            change = ocultos_delta[j]*MatrizEntradaNorm[sort][i]
            MatrizPesoEntrada[i][j] = MatrizPesoEntrada[i][j] + (0.5*change)

def treinar():
   for i in range(100):
       sort = sorteio()
       propagacao(sort)
       erro1 = erro(sort)
       print("Erro Erro: ", erro1)
       retropropagacao(sort)

definir()
print(MatrizEntrada)
print("---")
print(MatrizEntradaNorm)
treinar()