jColibri- Calcul Impots sur le Revenu des Personnes Physiques

Home

Simulateur Impôts sur les Revenus - John COLIBRI.
Calcul IR

résumé : calculateur des impôts sur les revenus. Tient compte des intérêts sur les comptes d'associés, des loyers, des dividendes

mots clé : impôt sur les revenus, IS, SARL, gérant majoritaire, barême 2020, intérêt sur les comptes d'associés, csg déductible

matériel utilisé : intel i3-8100, 3.6 gHz, 8GB memory, 128 G and 1 T hard disc

logiciel utilisé : Windows 10 pro 64 bit, Delphi 7

champ d'application : Delphi 1 à 7, 2006 à 2010, Xe_nnn, Seattle, Tokyo, Berlin, Delphi 10.3

niveau : développeur Delphi

plan :

L'impôt sur le Revenu

Calcul de l'IR

Le Projet Delphi

Améliorations

Télécharger le code source Delphi

1 - L'impôt sur le Revenu

Nous sommes actuellement (depuis 1980 !) en SARL et nous nous rémunérions uniquement sous forme de rémunération (pas de dividendes, intérêt, loyer). Pour comparer avec d'autres formes juridiques, nous souhaitions examiner les diverses impôts et charges correspondant aux autres régimes et revenus possibles.

Nous avons déjà présenté

les calculs des charges concernant les rémunérations du dirigeant (dirigeant majoritaire TNS ou directeur SAS assimilé salarié)
le calcul de l'impôt sur les sociétés

A présent nous examinons le traitement de l'impôt sur les revenus, compte tenu du choix

des salaires et montants de CSG déductible
des loyers versés au dirigeant
des intérêts sur les comptes d'associé
des dividendes

2 - Calcul de l'IR

2.1 - Les Paramètres

Nous avons placés les paramètres des charges dans un fichier .TXT. Ceci permet de faire les calculs sur des valeurs de taux différentes (si les règles de calcul ne changent pas trop)

 
          // ir_2018
 
          tranche_1           9964      0 
          tranche_2          27519     14 
          tranche_3          73779     30 
          tranche_4         156244     41 
          tranche_5         +          45
 
          flat_tax_taux_forfaitaire  12,8
 
          // taux_csg_foncier        17,2 =
 
          // taux_foncier_CSG         9,9 
          // taux_foncier_CRDS        0,5 
          // taux_foncier_social      4,5 
          // taux_foncier_additionnel 0,3 
          // taux_foncier_solidarite  2,0
 
          flat_tax_CSG                9,2 
          flat_tax_CRDS               0,5 
          flat_tax_solidarite         7,5

Nous avons présenté ici les taux 2018, car ce sont ceux utilisés pour les calculs d'IR 2019 dont nous avons reçu l'avis d'imposition 2019. C'est cet avis qui nous a permis de valider nos calculs. Il sera simple de mettre à jour ce fichier pour 2019 ou 2020

2.2 - Définitions

Quelques définitions

IS : Impôt sur les Sociétés, IR: Impôt sur les Revenus
la flat tax ou FPU Prélèvement Forfaitaire Unique (30 %) se décompose ainsi
- 17.2 % sont prélevés au titre de la CSG
- 12.8 % sont prélevés au niveau de l'Impôt personnel
SAS, directeur, assimilé salarié:
SARL, gérant majoritaire (TNS: travailleur non salarié)

2.3 - Le Calcul de l'Impôt sur le Revenu des Personnes Physiques

Les règles sont les suivantes

 
          revenus du gérant majoritaire + CSG déductible, ou salaire directeur SAS 
          + les autres revenus du foyer fiscal 
          - 10 % forfaitaire de frais professionnels ou "abattement" 
          + ajout de revenu foncier net (micro foncier: 70 % des loyers) 
          = revenus du foyer fiscal 
          - CSG déductible 
          = revenu imposable
 
          - impôts
 
          + impôt proportionnel
 
          - réductions (sur les actions, épargne etc)
 
          = impôt net

le calcul de l'impôt se fait en tenant compte des parts:
- le revenu imposable est divisé par le nombre de parts
- l'impôt par tranche se fait sur ce montant
- le résultat est re multiplié par le nombre de parts
les valeurs "impôt proportionnel" et "réductions" seront des valeurs qui devront être fournies au calculateur

2.4 - CSG, CRDS, Flat Tax

Deux cas

les loyers sont imposés à 17,2 %
les intérêts sur les comptes d'associés et les dividendes sont assujetis à la Flat Tax (30 %)

3 - Le Projet Delphi de calcul de l'IR

3.1 - La classe de calcul

Voici la définition de la classe de calcul:

Type c_calcul_ir=
         Class(c_stringlist)
           m_c_calcul_is_ref: c_calcul_is;
           m_c_detail_result_list: tStrings;

m_title: String;
m_month_count: Integer;

m_tranche_count: Integer;
m_seuil_array, m_taux_array: Array Of double;

m_c_key_list, m_c_value_list: tStringList;

m_revenu_imposable: Double;
m_csg_deductible_ir: Double;

m_retraites: Double;

m_nombre_parts: Double;

m_IR: Double;
m_total_csg_crds: Double;

m_revenu_au_taux_forfaitaire: Double;

Constructor create_calcul_ir(p_name, p_path, p_file_name: String);

Function f_rate(p_key: String): Double;
Function f_amount(p_key: String): Double;

Procedure load_parameters;
Procedure display_parameters;

Procedure compute_ir;

Destructor Destroy; Override;
End; // c_calcul_ir

Donc

deux tableaux pour le calcul des tranches, ce qui permettra d'utiliser une boucle For
deux "tStringList parallèles" pour récupérer des valeurs par mot clé

3.2 - Le Chargement des paramètres

Voici la procédure ce chargement des paramètres

Function f_is_tranche(p_key: String): Boolean;
  Begin
    Result:= Copy(p_key, 1, 8)= 'tranche_';
  End; // f_is_tranche

Procedure c_calcul_ir.load_parameters;

  Procedure _add_key_value(p_key, p_value: String);
    Begin
      m_c_key_list.Add(p_key);
      m_c_value_list.Add(p_value);
    End; // _add_key_value

Var l_key, l_seuil, l_taux, l_value: String;

  Begin // load_parameters
    stop_if_empty;
    display(m_c_stringlist.Text);

    // -- a first bogus tranche "0 0"
    m_tranche_count:= 1;
    SetLength(m_seuil_array, m_tranche_count);
    SetLength(m_taux_array, m_tranche_count);

    While Not f_end_of_file Do
    Begin
      If Not f_is_blank_or_comment
        Then Begin
            l_key:= f_next_value;

            If f_is_tranche(l_key)
              Then Begin
                  l_seuil:= f_next_value; l_taux:= f_next_value;
                  Inc(m_tranche_count);
                  SetLength(m_seuil_array, m_tranche_count);
                  SetLength(m_taux_array, m_tranche_count);
                  If l_seuil= '+'
                    Then m_seuil_array[m_tranche_count- 1]:= k_max
                    Else m_seuil_array[m_tranche_count- 1]:= StrToFloat(l_seuil);
                  m_taux_array[m_tranche_count- 1]:= StrToFloat(l_taux);

                  l_value:= l_seuil+ ' '+ l_taux;
                End
              Else Begin
                  l_value:= f_next_value;
                End  ;

            _add_key_value(l_key, l_value);
          End
        Else
          If m_title= ''
            Then m_title:= m_trimmed_line
            Else _add_key_value('','');

      read_line;
    End; // while not f_end_of_file
  End; // load_parameters

3.3 - Calcul de l'Impôt sur le Revenu

La procédure de calcul de l'Impôt est la suivante

Procedure c_calcul_ir.compute_ir;
Var l_micro_foncier_net: Double;

Procedure _calcul_csg_crds_loyers;
Var l_base_flat_tax: Double;

    Procedure __display_and_add_csg(p_title: String; p_rate, p_base: Double);
      Var l_rate, l_amount: Double;
      Begin
        l_amount:= p_base* p_rate/ 100;
        display(Format('%-35s %10s  %5.2f   %10s',
            [p_title, f_10_2(p_base), p_rate, f_10_2(l_amount)]));
        m_total_csg_crds:= m_total_csg_crds+ l_amount;
      End; // __display_and_add_csg

Var l_flat_tax_csg: Double;
l_full_flat_tax: Double;

Begin // _calcul_csg_crds_loyers
m_total_csg_crds:= 0;

display(f_display('micro_foncier_net', l_micro_foncier_net));

l_flat_tax_csg:= f_rate('flat_tax_CSG')+ f_rate('flat_tax_CRDS')
+ f_rate('flat_tax_solidarite');

display_line;
__display_and_add_csg('flat_tax_csg', l_flat_tax_csg, l_micro_foncier_net);

      l_base_flat_tax:= 0;
      display_line;
      display(f_display('interets_associes', m_c_calcul_is_ref.m_interets_compte_associe));
      display(f_display('dividendes', m_c_calcul_is_ref.m_dividendes));
      l_base_flat_tax:= m_c_calcul_is_ref.m_interets_compte_associe+  m_c_calcul_is_ref.m_dividendes;

      display_line;
      display(f_display(' = base_csg_crds', l_base_flat_tax));
      display_line;

l_full_flat_tax:= l_flat_tax_csg+ f_rate('flat_tax_taux_forfaitaire');
__display_and_add_csg('flat_tax', l_full_flat_tax, l_base_flat_tax);

      display_line;
      display(f_display_2('total_csg_flat_tax', 28, m_total_csg_crds));
    End; // _calcul_csg_crds_loyers

Var l_total_revenus: Double;

  Procedure _display_and_add_revenu(p_title: String; p_amount: Double);
    Begin
      display(f_display(p_title, p_amount));

l_total_revenus:= l_total_revenus+ p_amount;
End; // _display_and_add_revenu

Var l_total_impots: Double;

  Procedure _display_and_add_impots(p_title: String; p_amount: Double);
    Var l_display: String;
    Begin
      l_display:= f_display(p_title, p_amount);

      If m_ir_precedent<> 0
        Then
          If pos('IR', p_title)> 0
            Then l_display:= l_display+ Format('%s [%10.2f]',
                [f_spaces(2), p_amount- m_ir_precedent])
            Else
              If Pos('CSG', p_title)> 0
                Then l_display:= l_display+ Format('%s [%10.2f]',
                    [f_spaces(2), p_amount- m_total_csg_crds_precedent]);

display(l_display);

l_total_impots:= l_total_impots+ p_amount;
End; // _display_and_add_impots

  Var l_revenu_net_imposable: Double;
      l_revenu_brut_global: Double;
      l_revenu_imposable: Double;

l_revenu_imposable_par_part: double;
l_impot_par_tranches: Double;

l_impot_taux_forfaitaire: Double;

      l_tranche_index: Integer;
      l_base, l_amount, l_total: Double;
      l_seuil: String;

l_c_save_display_strings: tStrings;

  Begin // compute_ir
    display_line;
    display(m_title);
    display_line;

    display(f_display('salaires', m_revenu_imposable));
    If m_csg_deductible_ir> 0
      Then display(f_display(' + csg_deductible', m_csg_deductible_ir));
    display(f_display(' + retraites', m_retraites));
    m_revenu_imposable:= m_revenu_imposable+ m_csg_deductible_ir+ m_retraites;

display_line;

    l_revenu_net_imposable:= 0.90* m_revenu_imposable;
    l_micro_foncier_net:= m_c_calcul_is_ref.m_micro_foncier_brut* 0.70;
    l_revenu_brut_global:= l_revenu_net_imposable+ l_micro_foncier_net;
    l_revenu_imposable:= l_revenu_brut_global- m_csg_deductible_ir;

    display(f_display('=  revenu_imposable', m_revenu_imposable));
    display(f_display(' - frais_10_%% ', 0.10* m_revenu_imposable));
    display(f_display('=  revenu_net_imposable', l_revenu_net_imposable));
    display(f_display(' + micro_foncier_net', l_micro_foncier_net)
         + Format(' (0.70 * foncier %10f.3)', [m_c_calcul_is_ref.m_micro_foncier_brut]));
    display(f_display('= revenu_brut_global', l_revenu_brut_global));
    display(f_display('csg_deductible', m_csg_deductible_ir));
    display(f_display('revenu_imposable', l_revenu_imposable));
    If m_delta_net> 0
      Then display(f_display('delta_net_??? ', m_delta_net));

display_line;

l_total:= 0;
l_revenu_imposable:= l_revenu_imposable+ m_delta_net;

    l_c_save_display_strings:= s_lines;
    initialize_display(m_c_detail_result_list);
    clear_display;

    display(f_display('revenu_imposable', l_revenu_imposable));
    l_revenu_imposable_par_part:= l_revenu_imposable/ m_nombre_parts;
    display(f_display('revenu_imposable_par_part', l_revenu_imposable_par_part));
    display_line;

l_impot_par_tranches:= 0;

    For l_tranche_index:= 1 To m_tranche_count- 1 Do
      If l_revenu_imposable_par_part> m_seuil_array[l_tranche_index- 1]
        Then Begin
            l_base:= Min(l_revenu_imposable_par_part, m_seuil_array[l_tranche_index]);
            l_base:= l_base- m_seuil_array[l_tranche_index- 1];
            l_amount:= l_base* m_taux_array[l_tranche_index]/ 100;
            If m_seuil_array[l_tranche_index]= k_max
              Then l_seuil:= f_spaces(10)
              Else l_seuil:= Format('%10s', [f_10_2(m_seuil_array[l_tranche_index]) ]);
            display(Format('%d %10s  %10s  %6.2f    %10s',
                [l_tranche_index, l_seuil, f_10_2(l_base),
                 m_taux_array[l_tranche_index], f_10_2(l_amount)]));

l_total:= l_total+ l_amount;
End;

display_line;
display(Format('%-35s %10s', ['total', f_10_2(l_total)]));

    m_IR:= l_total* m_nombre_parts;
    display_line;
    display(Format('total_pour_%1.1f_parts %s %10s  %3.2f %%',
        [m_nombre_parts, f_spaces(14), f_10_2(m_IR), m_IR/ l_revenu_imposable] ));

initialize_display(l_c_save_display_strings);

display(f_display('impot_a_payer', m_IR));

l_total:= l_impot_par_tranches+ l_impot_taux_forfaitaire;

    initialize_display(m_c_detail_result_list);
    display_line;
    display_line;

_calcul_csg_crds_loyers;

    initialize_display(l_c_save_display_strings);
    display_line;
  End; // compute_ir

4 - Mini How To

Voici l'image de l'application

calcul_impots_sur_le_revenu

Donc

initialisez le fichier des paramètres. Le fichier pour 2020 est fourni dans le .ZIP
sélectionnez le fichier de paramètres dans la tFileListBox
entrez les valeurs dans les tEdits
le salaire et les charges. Pour calculer les charges à partir du salaire
cliquez "compute_"

Nous avons utilisé comme exemple une valeur permettant de calculer trois tranches d'IR

5 - Améliorations

Bien sûr, notre calcul est simplifié, dans la mesure où ne nous sommes intéressés qu'à notre cas personnel. Nous n'avons donc pas examiné le cas des revenus agricoles ou le traitement des revenus de meublés.
au niveau de la taxe des dividendes, nous avons systématiquement utilisé la flat tax (pas les autres possibilités)

6 - Liens

Simulateur Charges Sociales TNS : calculateur des charges sociales pour un travailleur indépendant
Simulateur Charges Sociales Salariales : calculateur des charges sociales salariales pour directeur SAS (assimilé salarié)
Simulateur Impôts sur les Sociétés : calculateur des impôts sur les sociétés. Tient compte des intérêts sur les comptes d'associés, des tranches d'IS

7 - Télécharger le code source Delphi

Vous pouvez télécharger:

zip_calcul_impots_sur_le_revenu.zip : le projet calculant les impôts sur les revenus et le fichier des paramètres 2020 (71 K)

Ce .ZIP qui comprend:

le .DPR, la forme principale, les formes annexes eventuelles
les fichiers de paramètres (le schéma et le batch de création)
dans chaque .ZIP, toutes les librairies nécessaires à chaque projet (chaque .ZIP est autonome)

Ces .ZIP, pour les projets en Delphi 6, contiennent des chemins RELATIFS. Par conséquent:

créez un répertoire n'importe où sur votre machine
placez le .ZIP dans ce répertoire
dézippez et les sous-répertoires nécessaires seront créés
compilez et exécutez

Ces .ZIP ne modifient pas votre PC (pas de changement de la Base de Registre, de DLL ou autre). Pour supprimer le projet, effacez le répertoire.

La notation utilisée est la notation alsacienne qui consiste à préfixer les identificateurs par la zone de compilation: K_onstant, T_ype, G_lobal, L_ocal, P_arametre, F_unction, C_lasse. Elle est présentée plus en détail dans l'article La Notation Alsacienne

Comme d'habitude:

nous vous remercions de nous signaler toute erreur, inexactitude ou problème de téléchargement en envoyant un e-mail à jcolibri@jcolibri.com. Les corrections qui en résulteront pourront aider les prochains lecteurs
tous vos commentaires, remarques, questions, critiques, suggestion d'article, ou mentions d'autres sources sur le même sujet seront de même les bienvenus à jcolibri@jcolibri.com.
plus simplement, vous pouvez taper (anonymement ou en fournissant votre e-mail pour une réponse) vos commentaires ci-dessus et nous les envoyer en cliquant "envoyer" :

Nom :

E-mail :

Commentaires * :
et si vous avez apprécié cet article, faites connaître notre site, ajoutez un lien dans vos listes de liens ou citez-nous dans vos blogs ou réponses sur les messageries. C'est très simple: plus nous aurons de visiteurs et de références Google, plus nous écrirons d'articles.

8 - L'auteur

John COLIBRI est passionné par le développement Delphi et les applications de Bases de Données. Il a écrit de nombreux livres et articles, et partage son temps entre le développement de projets (nouveaux projets, maintenance, audit, migration BDE, migration Xe_n, refactoring) pour ses clients, le conseil (composants, architecture, test) et la formation. Son site contient des articles avec code source, ainsi que le programme et le calendrier des stages de formation Delphi, base de données, programmation objet, Services Web, Tcp/Ip et UML qu'il anime personellement tous les mois, à Paris, en province ou sur site client.

Created: jan-04. Last updated: mar-2020 - 250 articles, 620 .ZIP sources, 3303 figures
Contact : John COLIBRI - Tel: 01.42.83.69.36 / 06.87.88.23.91 - email:jcolibri@jcolibri.com
Copyright © J.Colibri http://www.jcolibri.com - 2001 - 2020
Retour: Home Articles Formations Développement Delphi Livres Pascalissime Liens Download