######################################################################
# SUITES - DÉFINITION EXPLICITE : U_N = 2^N SIN(PI/2^N), UN SEUL TERME
######################################################################

from math import *

def u(n):
    return 2**n * sin(pi/2**n)

print(u(10))


######################################################################
# SUITES - DÉFINITION EXPLICITE : LISTE DES 11 PREMIERS TERMES (ARRONDIS)
######################################################################

from math import *

def u(n):
    return 2**n * sin(pi/2**n)

print([round(u(k), 4) for k in range(11)])


######################################################################
# SUITES - RÉCURRENCE D'ORDRE 1 : SUITE DE HÉRON
######################################################################

a = 155
u = a

for _ in range(10):
  u = (u + a/u) / 2

print(u)


######################################################################
# SUITES - RÉCURRENCE D'ORDRE 1 : NOMBRES DE CATALAN
######################################################################

def C(n):
    u = 1
    for k in range(n):
        u = u*(4*k+2) // (k+2)
    return u

print(C(9))


######################################################################
# SUITES - RÉCURRENCE D'ORDRE 2 : VERSION CORRECTE (AFFECTATION SIMULTANÉE)
######################################################################

u, v = 1, 5

for _ in range(6):
    print(u)
    u, v = v, 3*v - 2*u


######################################################################
# SUITES - RÉCURRENCE D'ORDRE 2 : VERSION FAUSSE (CONTRE-EXEMPLE, U EST ÉCRASÉ TROP TÔT)
######################################################################

u = 1
v = 5

for _ in range(6):
    print(u)
    u = v
    v = 3*v - 2*u


######################################################################
# SUITES - RÉCURRENCE LINÉAIRE D'ORDRE P : MATRICE COMPAGNON AVEC NUMPY
######################################################################

import numpy as np

U = np.mat('[-3 ; 2 ; 5]')
A = np.mat('[0 1 0] ; [0 0 1] ; [3 -1 4]')
L = []    # liste des termes

for _ in range(10):
    L.append(U[0, 0])
    U = A@U

print(L)


######################################################################
# SÉRIES - DÉFINITION EXPLICITE : SOMME DE U_K = LN(K) E^SQRT(K) / K!
######################################################################

print(sum([log(k)* e**sqrt(k) / factorial(k) for k in range(1, 101)]))


######################################################################
# SÉRIES - DÉFINITION EXPLICITE : SOMME DE V_K = (-1)^K / (4K + (-1)^K)
######################################################################

print(sum([(-1)**k/(4*k+(-1)**k) for k in range(1001)]))


######################################################################
# SÉRIES - INDICES PAIRS ET IMPAIRS
######################################################################

Sp = sum([1/(4*k+1) for k in range(0, 1001, 2)])
Si = sum([1/(4*k-1) for k in range(1, 1001, 2)])

print(Sp-Si)


######################################################################
# SÉRIES - SÉRIE DÉFINIE PAR RÉCURRENCE : S(N)
######################################################################

def S(n):
    s = 0
    u = 0
    for k in range(n+1):
        s += u
        u = u + 3*k**2 + 3*k + 1
    return s

print(S(10))


######################################################################
# SÉRIES - DÉVELOPPEMENT LIMITÉ DE EXP
######################################################################

from math import *

def exp(x, N=15):
    return sum([x**k/factorial(k) for k in range(N+1)])

print(exp(1))
print(e)


######################################################################
# SÉRIES - DÉVELOPPEMENT LIMITÉ DE SIN
######################################################################

from math import *

def sinus(x, N=15):
    return sum([(-1)**k*x**(2*k+1)/factorial(2*k+1) for k in range(floor((N-1)/2))])

print(sinus(pi/4))
print(sqrt(2)/2)


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - REPRÉSENTER UNE SUITE AVEC MATPLOTLIB
######################################################################

import matplotlib.pyplot as plt

Y = [(-1)**n/(n+1) for n in range(11)]

plt.plot(Y)
plt.show()


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - STYLE DES POINTS ET DES LIGNES (ÉCRITURE DÉTAILLÉE)
######################################################################

# Points rouges, sans ligne
plt.plot(Y, linestyle='', color='red', marker='o')

# Pointillés noirs avec croix
plt.plot(Y, linestyle='--', color='black', marker='x', markersize='16')


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - STYLE DES POINTS ET DES LIGNES (ÉCRITURE ABRÉGÉE)
######################################################################

# Points rouges, sans ligne
plt.plot(Y, 'ro')

# Pointillés noirs avec croix
plt.plot(Y, '--xk', ms='16')


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - GRILLE, AXE HORIZONTAL ET GRADUATIONS
######################################################################

plt.plot(Y, 'gD')
plt.grid(axis='y', ls='--', lw=0.5, c='gray')
plt.axhline(0, c='r', lw=2)
plt.xticks(range(10))


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - ENREGISTRER LA FIGURE
######################################################################

plt.savefig("suite.svg")


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - RETIRER LES MARGES
######################################################################

plt.figure(figsize=(5.5, 4.0))

...

plt.tight_layout(pad=0)


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - ÉVOLUTION D'UNE SOMME PARTIELLE
######################################################################

from math import *
import matplotlib.pyplot as plt

def v(k):
    return (-1)**k/(k*sqrt(k-9))

X = [k for k in range(10, 41)]
Y = []
s = 0

for k in X:
    s += v(k)
    Y.append(s)

plt.plot(X, Y)
plt.show()


######################################################################
# REPRÉSENTATIONS GRAPHIQUES - AJOUTER LA LIMITE APPROCHÉE (À INSÉRER DANS LE CODE PRÉCÉDENT)
######################################################################

...
for k in range(41, 5001):
    s += v(k)

plt.axhline(s, c='r')
plt.text(5, s, round(s, 4), c='r')
...


######################################################################
# SUITES RÉCURRENTES PAR UNE FONCTION - ESCALIER / COLIMAÇON POUR F1 (CODE COMPLET)
######################################################################

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return 6 - 9 / (x + 1.5)

X = np.linspace(0, 5, 101)

plt.figure(figsize=(5, 5))
plt.rcParams['font.size'] = 14

plt.plot(X, X, 'k-')
plt.plot(X, f(X), 'b-')

u = 0.35

for n in range(4):
    # Escalier
    plt.plot([u, u], [u, f(u)], 'g-')
    plt.plot([u, f(u)], [f(u), f(u)], 'g-')
    # Abscisses
    plt.plot([u, u], [0, u], 'g--')
    plt.text(u, -0.5, f"$u_{n}$", c='g')

    # Ordonnées
    plt.plot([0, f(u)], [f(u), f(u)], 'g--')
    plt.text(-0.9, f(u), f"$f(u_{n})$", c='g')

    u = f(u)

plt.grid(True)
plt.xlim(0, 5)
plt.ylim(0, 5)
plt.tight_layout(pad=1)
plt.show()


######################################################################
# SUITES RÉCURRENTES PAR UNE FONCTION - VARIANTE POUR F2 (À ADAPTER DANS LE CODE PRÉCÉDENT)
######################################################################

def f(x):
    return -1.5 - 9 / (x - 6)
...
u = 4.1


######################################################################
# SUITES RÉCURRENTES PAR UNE FONCTION - VARIANTE POUR F3 (À ADAPTER DANS LE CODE PRÉCÉDENT)
######################################################################

def f(x):
    return 6 / (x + 1)
...
u = 0.8


######################################################################
# ACCÉLÉRATION DE CONVERGENCE - PROBLÈME DE BÂLE : SOMME DIRECTE
######################################################################

from math import *

n = 3*10**6
S = sum([1/k**2 for k in range(1, n+1)])

print(S)
print(pi**2/6)


######################################################################
# ACCÉLÉRATION DE CONVERGENCE - PROBLÈME DE BÂLE : FORMULE D'EULER-MACLAURIN
######################################################################

from math import *

n = 20
S = sum([1/k**2 for k in range(1, n+1)])

S = S + 1/n - 1/(2*n**2) + 1/(6*n**3) - 1/(30*n**5) + 1/(42*n**7) - 1/(30*n**9)

print(S)
print(pi**2/6)


######################################################################
# ACCÉLÉRATION DE CONVERGENCE - PROCÉDÉ DELTA-2 D'AITKEN
######################################################################

from math import *

n = 2000
s, u = 0, []

for k in range(0, n+3):
    s += (-1)**k/(k+1)
    u.append(s)

vn = u[n] - (u[n+1]-u[n])**2 / (u[n+2]-2*u[n+1]+u[n])

print(f"u{n}  =", u[-3])
print(f"v{n}  =", vn)
print("ln 2   =", log(2))


######################################################################
# SOLUTIONS (SÉRIES) - COMPARAISON AVEC LE DL DE 1/(1+X)
######################################################################

def f(x, n=10):
    return sum([(-1)**k * x**k for k in range(n+1)])


######################################################################
# SOLUTIONS (SÉRIES) - DÉRANGEMENTS PARTIELS D(N, K)
######################################################################

def d(n, k):
    return int(factorial(n)/factorial(k)*sum([(-1)**i/factorial(i) for i in range(n-k+1)]))


######################################################################
# SOLUTIONS (ACCÉLÉRATION) - MODIFICATIONS DE LA LIGNE DE CALCUL DE S DANS LE CODE D'AITKEN
######################################################################

# Exercice 1 : u_n = somme de (-1)^k / (2k+1)
s += (-1)**k/(2*k+1)

# Exercice 2 : u_n = somme de 1 / k^2
s += 1/(k+1)**2