#####################################
# PROJET OPTIMISATION
# - Yannis Benabbi
#####################################

# Définition des objets

class Fonction:
	"""
	Contient la fonction, son gradient, et sa hessienne.
	L'objet peut être appelé directement
	"""
	def __init__(self, f, grad = None, hess = None):
		self.f = f
		self.grad = grad
		self.hess = hess

	def __call__(self, x):
		return self.f(x)



class Vecteur:

	def __init__(self, v):
		if type(v) == type([]):
			self.v = v
		else:
			self.v = [v]

	def __getitem__(self, param:int):
		return self.v[param]

	def norme(self):
		return (reduce(lambda a,b: a+b**2, self.v))**0.5


# Fonctions et variables définies par l'utilisateur

def f1(x:Vecteur):
	"""
	Description :
	Fonction 1 de test sur laquelle sera appliquée les différents algorithmes

	Paramètres : Element de R3
	Sortie : Element de R
	"""
	return Vecteur(2*(x[0]+x[1]+x[2]-3)**2+(x[0]-x[1])**2+(x[1]-x[2])**2)


def f2(x:Vecteur):
	"""
	Description :
	Fonction 2 de test sur laquelle sera appliquée les différents algorithmes

	Paramètres : Element de R2
	Sortie : Element de R
	"""
	return 100*(x[1]-x[0]**2)**2 + (1-x[0])**2


def gradf1(x:Vecteur):
	"""
	Description :
	Gradient de f1

	Paramètres : Element de R3
	Sortie : Element de R3
	"""
	return [
		4*(x[0]+x[1]+x[2]-3)+2*(x[0]-x[1]),
		4*(x[0]+x[1]+x[2]-3)-2*(x[0]-x[1])+2*(x[1]-x[2]),
		4*(x[0]+x[1]+x[2]-3)-2*(x[1]-x[2])
	]

def gradf2(x:Vecteur):
	"""
	Description :
	Gradient de f2

	Paramètres : Element de R2
	Sortie : Element de R2
	"""
	return [
		-400 * x[0] * (x[1] - x[0] ** 2) + 2*x[0],
		200 * (x[1] - x[0]**2)
	]

def hessf1(x:Vecteur):
	"""
	Description :
	Gradient de f1

	Paramètres : Element de R3
	Sortie : Element de R3
	"""
	return [
		[
			6,
			2,
			4
		],
		[
			2,
			8,
			2
		],
		[
			4,
			2,
			6
		]
	]

def hessf2(x:Vecteur):
	"""
	Description :
	Gradient de f2

	Paramètres : Element de R2
	Sortie : Element de R2
	"""
	return [
		[
			-400 * (-3 * x[0]**2 + x[1]) + 2,
			-400 * x[0] * x[1]
		],
		[
			-200 *  2*x[0],
			200
		]
	]

x011 = Vecteur([1,0,0])
x012 = Vecteur([10,3,-2.2])
x021 = Vecteur([-1.2,1])
x022 = Vecteur([10, 0])
x023 = Vecteur([0,1/200 + 1/10**12])



F1 = Fonction(f1, gradf1, hessf1)
print(x012[1])


# Fonctions d'optimisation sans contraintes

def NewtonLocal(f:Fonction, x0):

	def condArret(k, xk, xkp1):

		eps1 = 0.001 * (f.grad(x0).norme() + 10**(-8))
		eps2 = 0.001 * xk.norme() + 10**(-8)
		eps3 = 0.001 * f(xk).norme() + 10**(-8)

		condArretVoulu = f.grad(xk).norme() < eps1
		condArretIterMax = k > 10000
		condArretPointe = (xkp1 - xk).norme() < eps2
		condArretPlateau = (f(xkp1) - f(xk).norme) < eps3

		return (xkp1 is None or (not condArretVoulu and not condArretIterMax and not condArretpointe and not condArretplateau))

	xk = x0
	xkp1 = None
	k = 0
	while (condArret(k,xk,xkp1)):
		k = k+1

	return 0