#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Dec 13 07:46:12 2023

@author: i.bachy
"""
import numpy as np
import matplotlib.pyplot as plt
import random as rd
import numpy.random as nr

################################################
#   SUITES ET SOMMES
################################################

##Ex2

#1. calcul du terme de rang n de la suite (un)
def suite(n):
    u=10
    for k in range(n):
        u=1/2*(u+2/u)
    return u

#2. Liste des n+1 premiers termes de la suite (un)
def liste_u(n):
    u=10
    L=[u]
    for k in range(n):
        u=1/2*(u+2/u)
	L/append(u)
    return L

#3. représentation graphique des n+1 premiers termes 
def graphe_suite(n):
	L=liste_suite(n)
	plt.grid()
	plt.plot(L,’+’)
	plt.show()

##Ex3 

#1. 
def fibo(n):
	u,v=1,1
	for k in range(n) : 
		u,v=v,u+v
	return u

#2. Suite affichant le ration Fn+1/Fn :
def ratio_fibo(n):
	return fibo(n+1)/fibo(n)

##Ex4 

#1. calcul du terme de rang n de la suite des sommes partielles d'une série de Riemann
def somme(alpha,n):
    S=0
    for k in range(n):
        S=S+1/(k+1)**(alpha)
    return S

#2. Liste des n premiers termes de la suite (S_n(alpha)) : 
def riemann_liste(alpha,n):
    L=[]
    for k in range(1,n+1):
        L.append(riemann(alpha, n))
    return L

#3. Représentation graphique 
	L=riemann_liste(alpha, n)
	plt.grid()
	plt.plot(L,’+’)
	plt.show()

#4. affichage de 3 comportements différents pour les séries de Riemann et comparaison avec des suites usuelles

def diff_riemann(n):
    y1=riemann_liste(1/2,n)
    z1=[np.sqrt(k+1) for k in range(n)]
    y2=riemann_liste(1,n)
    z2=[np.log(k+1) for k in range(n)]
    y3=riemann_liste(2,n)
    z3=[1.7 for k in range(n)]

    f, (ax1, ax2,ax3) = plt.subplots(1, 3, sharey=False)
    f.suptitle('Comportement des sommes partielles de 3 séries de Riemann')
    ax1.plot(y1)
    ax1.plot(z1)
    ax1.set_title('alpha<1')
    ax2.plot(y2)
    ax2.plot(z2)
    ax2.set_title('alpha=1')
    ax3.plot(y3)
    ax3.plot(z3)
    ax3.set_title('alpha>1')

## Ex5 

def seuil():
	u=2
	n=0
	while u<10**(-5):
		u=(u+np.log(u))*np.exp(u-1)
		n=n+1
	return n

## Ex6

def val_appro(p):
	u=-1
	n=0
	while 1/np.exp(2**n-1)>10**(-p):
		u=(u+1+2*np.exp(u))/(1+2np.exp(u))
		n=n+1
	return u

## Ex7

#1. 
def suite_u(n):
	u=0
	for k in range(1,n):
		u=u+1/k
	return u-np.log(n)

#2. On utilise le fait que vn - un = 1/n donne une estimation de l’encadrement de gamma et qu’on a donc np.abs(un - gamma)<10^(-4) dès que 1/n <10^(-4) soit n>10^(-4) :

suite_u(10**4) est donc une approximation de gamma à 10^(-4) près