menu
  Home  ==>  articles  ==>  admin  ==>  simulateur_impots_sur_le_revenu   

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 :


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

et

  • 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_refc_calcul_is;
           m_c_detail_result_listtStrings;

           m_titleString;
           m_month_countInteger;

           m_tranche_countInteger;
           m_seuil_arraym_taux_arrayArray Of double;

           m_c_key_listm_c_value_listtStringList;

           m_revenu_imposableDouble;
           m_csg_deductible_irDouble;

           m_retraitesDouble;

           m_nombre_partsDouble;

           m_IRDouble;
           m_total_csg_crdsDouble;

           m_revenu_au_taux_forfaitaireDouble;

           Constructor create_calcul_ir(p_namep_pathp_file_nameString);

           Function f_rate(p_keyString): Double;
           Function f_amount(p_keyString): Double;

           Procedure load_parameters;
           Procedure display_parameters;

           Procedure compute_ir;

           Destructor DestroyOverride;
         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_keyString): Boolean;
  Begin
    Result:= Copy(p_key, 1, 8)= 'tranche_';
  End// f_is_tranche

Procedure c_calcul_ir.load_parameters;

  Procedure _add_key_value(p_keyp_valueString);
    Begin
      m_c_key_list.Add(p_key);
      m_c_value_list.Add(p_value);
    End// _add_key_value

  Var l_keyl_seuill_tauxl_valueString;

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

    // -- a first bogus tranche "0 0"
    m_tranche_count:= 1;
    SetLength(m_seuil_arraym_tranche_count);
    SetLength(m_taux_arraym_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_valuel_taux:= f_next_value;
                  Inc(m_tranche_count);
                  SetLength(m_seuil_arraym_tranche_count);
                  SetLength(m_taux_arraym_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_keyl_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_netDouble;

  Procedure _calcul_csg_crds_loyers;
    Var l_base_flat_taxDouble;

    Procedure __display_and_add_csg(p_titleStringp_ratep_baseDouble);
      Var l_ratel_amountDouble;
      Begin
        l_amount:= p_basep_rate/ 100;
        display(Format('%-35s %10s  %5.2f   %10s',
            [p_titlef_10_2(p_base), p_ratef_10_2(l_amount)]));
        m_total_csg_crds:= m_total_csg_crdsl_amount;
      End// __display_and_add_csg

    Var l_flat_tax_csgDouble;
        l_full_flat_taxDouble;

    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_csgl_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_csgf_rate('flat_tax_taux_forfaitaire');
      __display_and_add_csg('flat_tax'l_full_flat_taxl_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_revenusDouble;

  Procedure _display_and_add_revenu(p_titleStringp_amountDouble);
    Begin
      display(f_display(p_titlep_amount));

      l_total_revenus:= l_total_revenusp_amount;
    End// _display_and_add_revenu

  Var l_total_impotsDouble;

  Procedure _display_and_add_impots(p_titleStringp_amountDouble);
    Var l_displayString;
    Begin
      l_display:= f_display(p_titlep_amount);

      If m_ir_precedent<> 0
        Then
          If pos('IR'p_title)> 0
            Then l_display:= l_displayFormat('%s [%10.2f]',
                [f_spaces(2), p_amountm_ir_precedent])
            Else
              If Pos('CSG'p_title)> 0
                Then l_display:= l_displayFormat('%s [%10.2f]',
                    [f_spaces(2), p_amountm_total_csg_crds_precedent]);

      display(l_display);

      l_total_impots:= l_total_impotsp_amount;
    End// _display_and_add_impots

  Var l_revenu_net_imposableDouble;
      l_revenu_brut_globalDouble;
      l_revenu_imposableDouble;

      l_revenu_imposable_par_partdouble;
      l_impot_par_tranchesDouble;

      l_impot_taux_forfaitaireDouble;

      l_tranche_indexInteger;
      l_basel_amountl_totalDouble;
      l_seuilString;

      l_c_save_display_stringstStrings;

  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_imposablem_csg_deductible_irm_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_imposablel_micro_foncier_net;
    l_revenu_imposable:= l_revenu_brut_globalm_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_imposablem_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_imposablem_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_partm_seuil_array[l_tranche_index- 1]
        Then Begin
            l_base:= Min(l_revenu_imposable_par_partm_seuil_array[l_tranche_index]);
            l_base:= l_basem_seuil_array[l_tranche_index- 1];
            l_amount:= l_basem_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_indexl_seuilf_10_2(l_base),
                 m_taux_array[l_tranche_index], f_10_2(l_amount)]));

            l_total:= l_totall_amount;
          End;

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

    m_IR:= l_totalm_nombre_parts;
    display_line;
    display(Format('total_pour_%1.1f_parts %s %10s  %3.2f %%',
        [m_nombre_partsf_spaces(14), f_10_2(m_IR), m_IRl_revenu_imposable] ));

    initialize_display(l_c_save_display_strings);

    display(f_display('impot_a_payer'm_IR));

    l_total:= l_impot_par_tranchesl_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




7 - Télécharger le code source Delphi

Vous pouvez télécharger: 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: fev-2020 - 247 articles, 619 .ZIP sources, 3297 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
l'Institut Pascal

John COLIBRI

+ Home
  + articles_avec_sources
    + bases_de_donnees
    + web_internet_sockets
    + services_web_
    + prog_objet_composants
    + office_com_automation
    + colibri_utilities
    + uml_design_patterns
    + graphique
    + delphi
    + outils
    + firemonkey
    + vcl_rtl
    + colibri_helpers
    + colibri_skelettons
    + admin
      – simul_charges_tns
      – simul_charges_salarie
      – simulateur_impots_societes
      – simulateur_impots_revenu
  + formations
  + developpement_delphi
  + présentations
  + pascalissime
  + livres
  + entre_nous
  – télécharger

contacts
plan_du_site
– chercher :

RSS feed  
Blog