NB: comme on m'a déjà demandé de faire une offre de crédit (), je précise: je ne suis pas banquier !!!

• Capital emprunté: C
• Intérêt annuel: IA → intéret mensuel: I = IA/12
• Nombre de mensualités=N
• Mensualité=M

On cherche à calculer n'importe lequel de ces 4 nombres à partir des 3 autres.

Chaque fin de mois k, la mensualité est composée d'une partie du capital remboursé (Ck), et des intérêts (Ik) correspondant au travail pendant un mois du capital non encore remboursé en début de mois. Et, bien sûr, toutes les mensualités sont égales.

Le 1er mois, on paye: C1 + I1 = M

• avec I1 = I * C puisqu'on n'a encore rien remboursé du capital
• donc, C1 = M - I*C

Le 2ème mois, on paye: C2 + I2 = M

• avec I2 = I * (C-C1)
• donc, C2 = M - I * (C-C1)
• et comme C1 = M-I*C → C2 = M-I*(C-M+I*C) → C2 = M-I*C+I*M-I2*C
• soit: C2 = (M-I*C)*(1+I)

le 3ème mois, on paye: C3+I3 = M

• En remplaçant I2 par sa valeur issue des équations précédentes, on trouve:
• C3 = (M-I*C)*(1+I)²

etc… jusqu'à la dernière mensualité:

• CN = (M-I*C)*(1+I)^N-1

Si on fait la somme de toutes ces formules, on trouve:

• C1+C2+C3+…+CN = C = (M-I*C)*(1+(1+I)+(1+I)²+(1+I)³+….+(1+I)^N-1)

On reconnait la somme d'une progression géométrique de raison (1+I). En effet, une progression géométrique est une liste de termes dont chacun peut être obtenu en multipliant le terme précédent par une valeur qu'on appelle la “raison” de la progression.

Par exemple pour n termes:

P = a + a*r + a*r² + a*r³ … + a*r^n-1

Et dans ce cas, on sait que la somme de cette progression est obtenue par:

S = a*(rⁿ-1)/(r-1)

En remplaçant a par (M-I*C) et r par (1+I), on trouve la formule suivante pour calculer M:

En notation mathématique:

• <m>M~=~CI lbrace{1-{1}/{1-(1+I)^N}}rbrace</m>

Et en notation Python:

• M = C*I*(1-1/(1-(1+I)**N))

Si en refaisant le calcul à la main vous trouvez <m>M~=~CI lbrace{1/{1-1/(1+I)^N}}rbrace</m>, ne vous inquiétez pas: ça donne le même résultat (essayez, ça donne en python: M = C*I*(1-(1/(1-(1+I)**N)))).

On déduit les formules suivantes

• C = M / (I*(1-(1/(1-(1+I)**N))))

• N = log(1-1/(1-M/(C*I)))/log(1+I) (log=logarithme: ici, on peut prendre les népériens ou les décimaux puisqu'ils sont en même temps au numérateur et au dénominateur)

Pour le calcul de l'intérêt, nous avons une équation implicite à résoudre, puisque I apparait plusieurs fois dans la formule. On ne peut donc pas avoir une formule de type “I=…”: il s'agit donc de trouver I par programme, tel que f(I)=0, avec par exemple la formule de M :

• M-C*I*(1-1/(1-(1+I)**N)) = 0

C'est d'ailleurs très amusant de résoudre une équation implicite telle que f(I)=0 par programme:

• on choisit une valeur arbitraire de I (tel que IA=10% par exemple, soit I=10/1200)
• on calcule un premier f(I)
• on choisit un incrément dI = I/10 par exemple
• on calcule f(I+dI)
• on compare avec le f(I) calculé avant:
• si la valeur absolue augmente, on s'éloigne du point cherché → on fait dI = -dI/2
• si les signes de f(I) et du précédent f(I)sont différents, la valeur cherchée est entre les 2: on fait dI = -dI/2
• on fait en sorte que le nouveau I et f(I) devienne les précédents pour la comparaison du calcul suivant
• et on recommence avec I = I+dI et f(I), ceci jusqu'à ce qu'on atteigne une précision donnée (notée “eps”)

Pour le calcul du tableau d'amortissement, on a déjà les formules plus haut. Ainsi, pour le mois k:

• Capital remboursé: Ck = (M-I*C)*(1+I)**(k-1)
• Intérêt remboursé: Ik = M-Ck

Voilà, c'est fini pour la théorie, il ne reste plus qu'à programmer!

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# n'oubliez pas la ligne suivante pour que la division, même entre 2 entiers, donne toujours un résultat décimal
from __future__ import division
 
def menscredit(C,IA,N):
    """menscredit(C,IA,N): mensualités M d'un prêt C à IA% d'intérêt par an, à rembourser en N mois"""
    # si le capital est nul, il n'y a rien à rembourser
    if C==0:
        M=0
        return M
    # si l'intérêt est nul, la mensualité ne dépend plus que de C et N
    if IA==0:
        M=C/N
        return M
    # calcul de la mensualité dans le cas général
    C=C
    I=IA/1200
    M=C*I*(1-1/(1-(1+I)**N))
    return M

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# n'oubliez pas la ligne suivante pour que la division, même entre 2 entiers, donne toujours un résultat décimal
from __future__ import division
 
def moiscredit(C,IA,M):
    """moiscredit(C,IA,M): nombre de mois de remboursement d'un prêt C ayant un intérêt IA%/an et une mensualité M"""
    # si le capital est nul, il n'y a rien a rembourser
    if C==0:
        N=0
        return N
    # si l'intérêt est nul, la mensualité ne dépend que de N
    if IA==0:
        N=C/M
        return N
    # calcul du nombre de mois de remboursement
    C=C
    I=IA/1200
    N=log(1-1/(1-M/(C*I)))/log(1+I)
    return N

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# n'oubliez pas la ligne suivante pour que la division, même entre 2 entiers, donne toujours un résultat décimal
from __future__ import division
 
def capcredit(IA,M,N):
    """capcredit(IA,M,N): capital emprunté à IA%/an d'intérêt, remboursé en N mois avec une mensualité de M"""
    # si l'intérêt est nul, le capital est facile à calculer!
    if IA==0:
        C=M*N
        return C
    # calcul du capital emprunté
    I=IA/1200
    M=M
    C=M/(I*(1-(1/(1-(1+I)**N))))
    return C

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# n'oubliez pas la ligne suivante pour que la division, même entre 2 entiers, donne toujours un résultat décimal
from __future__ import division
 
def intcredit(C,M,N):
    """intcredit(C,M,N): intérêt IA%/an, connaissant le capital emprunté C, la mensualité M et le nb de mois de remboursement N"""
    # cas ou l'intérêt est manifestement nul
    if N*M==C:
        IA=0
        return IA
    # calcul de IA par recherche de zéro
    IA=10.0
    DI=1.0
    eps=0.000001
    F1=M-menscredit(C,IA,N)
    F2=F1
    while (fabs(F1)>eps):
        F1=F2
        IA=IA+DI
        F2=M-menscredit(C,IA,N)
        if ((F2*F1)<0) or (fabs(F2)>fabs(F1)):
            DI=-DI/2
    return IA

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# n'oubliez pas la ligne suivante pour que la division, même entre 2 entiers, donne toujours un résultat décimal
from __future__ import division
 
def coutcredit(C,M,N,sup=0):
    """coutcredit(C,M,N,sup=0): coût d'un crédit connaissant le capital C, la mensualité M et le nb de mois de remboursement N (sup = coût supplémentaire optionnel)"""
    return M*N-C+sup