Commit eb26d35d authored by Equipe IR-CALCUL DGFiP's avatar Equipe IR-CALCUL DGFiP
Browse files

Ajout des sources pour l'impôt sur le revenu 2019 sur les revenus de 2018

parent e4efeb88
......@@ -10,7 +10,7 @@ Ces fichiers sont publiés avec le statut "publié" du guide Etalab d'ouverture
Les contributions extérieures ne seront donc pas traitées.
Ces versions sont respectivement :
* la 6.7 pour l'imposition des revenus 2018 (4e émission et batch de réactivité fiscale)
* la 6.3 pour l'imposition des revenus 2018 (3 premières émissions de l'impôt sur le revenu)
* la 6.10 pour l'imposition des revenus 2017
* la 4.5 pour l'imposition des revenus 2016
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
#*************************************************************************************************************************
#
#Copyright or © or Copr.[DGFIP][2019]
#
#Ce logiciel a été initialement développé par la Direction Générale des
#Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2019
#au titre des revenus perçus en 2018. La présente version a permis la
#génération du moteur de calcul des chaînes de taxation des rôles d'impôt
#sur le revenu de ce millésime.
#
#Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français
#et respectant les principes de diffusion des logiciels libres. Vous pouvez
#utiliser, modifier et/ou redistribuer ce programme sous les conditions de
#la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur
#le site "http://www.cecill.info".
#
#Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
#connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes.
#
#**************************************************************************************************************************
# ======================================================================
# Chapitre 52 : Calcul des droits simples résultant du taux progressif
# ======================================================================
regle 521000:
application : bareme , iliad ;
TXBAR0 = TX_MOD0 * FLAG_BAREM + TX_BAR0 * (1 - FLAG_BAREM) ;
TXBAR1 = TX_MOD1 * FLAG_BAREM + TX_BAR1 * (1 - FLAG_BAREM) ;
TXBAR2 = TX_MOD2 * FLAG_BAREM + TX_BAR2 * (1 - FLAG_BAREM) ;
TXBAR3 = TX_MOD3 * FLAG_BAREM + TX_BAR3 * (1 - FLAG_BAREM) ;
TXBAR4 = TX_MOD4 * FLAG_BAREM + TX_BAR4 * (1 - FLAG_BAREM) ;
TXBAR5 = TX_MOD5 * FLAG_BAREM + TX_BAR5 * (1 - FLAG_BAREM) ;
TXBAR6 = TX_MOD6 * FLAG_BAREM + TX_BAR6 * (1 - FLAG_BAREM) ;
TXBAR7 = TX_MOD7 * FLAG_BAREM + TX_BAR7 * (1 - FLAG_BAREM) ;
TXBAR8 = TX_MOD8 * FLAG_BAREM + TX_BAR8 * (1 - FLAG_BAREM) ;
TXBAR9 = TX_MOD9 * FLAG_BAREM + TX_BAR9 * (1 - FLAG_BAREM) ;
TAUX1 = positif(TXBAR1) * (TXBAR1 - TXBAR0) ;
TAUX2 = positif(TXBAR2) * (TXBAR2 - TXBAR1) ;
TAUX3 = positif(TXBAR3) * (TXBAR3 - TXBAR2) ;
TAUX4 = positif(TXBAR4) * (TXBAR4 - TXBAR3) ;
TAUX5 = positif(TXBAR5) * (TXBAR5 - TXBAR4) ;
TAUX6 = positif(TXBAR6) * (TXBAR6 - TXBAR5) ;
TAUX7 = positif(TXBAR7) * (TXBAR7 - TXBAR6) ;
TAUX8 = positif(TXBAR8) * (TXBAR8 - TXBAR7) ;
TAUX9 = positif(TXBAR9) * (TXBAR9 - TXBAR8) ;
TAUX10 = positif(TX_BAR10) * (TX_BAR10 - TX_BAR9) ;
TAUX11 = positif(TX_BAR11) * (TX_BAR11 - TX_BAR10) ;
TAUX12 = positif(TX_BAR12) * (TX_BAR12 - TX_BAR11) ;
TAUX13 = positif(TX_BAR13) * (TX_BAR13 - TX_BAR12) ;
TAUX14 = positif(TX_BAR14) * (TX_BAR14 - TX_BAR13) ;
TAUX15 = positif(TX_BAR15) * (TX_BAR15 - TX_BAR14) ;
TAUX16 = positif(TX_BAR16) * (TX_BAR16 - TX_BAR15) ;
TAUX17 = positif(TX_BAR17) * (TX_BAR17 - TX_BAR16) ;
TAUX18 = positif(TX_BAR18) * (TX_BAR18 - TX_BAR17) ;
TAUX19 = positif(TX_BAR19) * (TX_BAR19 - TX_BAR18) ;
TAUX20 = positif(TX_BAR20) * (TX_BAR20 - TX_BAR19) ;
LIMINFBAR1 = LIM_INF_MOD1 * FLAG_BAREM + LIM_INF_BAR1 * (1 - FLAG_BAREM) ;
LIMINFBAR2 = LIM_INF_MOD2 * FLAG_BAREM + LIM_INF_BAR2 * (1 - FLAG_BAREM) ;
LIMINFBAR3 = LIM_INF_MOD3 * FLAG_BAREM + LIM_INF_BAR3 * (1 - FLAG_BAREM) ;
LIMINFBAR4 = LIM_INF_MOD4 * FLAG_BAREM + LIM_INF_BAR4 * (1 - FLAG_BAREM) ;
LIMINFBAR5 = LIM_INF_MOD5 * FLAG_BAREM + LIM_INF_BAR5 * (1 - FLAG_BAREM) ;
LIMINFBAR6 = LIM_INF_MOD6 * FLAG_BAREM + LIM_INF_BAR6 * (1 - FLAG_BAREM) ;
LIMINFBAR7 = LIM_INF_MOD7 * FLAG_BAREM + LIM_INF_BAR7 * (1 - FLAG_BAREM) ;
LIMINFBAR8 = LIM_INF_MOD8 * FLAG_BAREM + LIM_INF_BAR8 * (1 - FLAG_BAREM) ;
LIMINFBAR9 = LIM_INF_MOD9 * FLAG_BAREM + LIM_INF_BAR9 * (1 - FLAG_BAREM) ;
LIMSUPBAR1 = LIM_SUP_MOD1 * FLAG_BAREM + LIM_SUP_BAR1 * (1 - FLAG_BAREM) ;
LIMSUPBAR2 = LIM_SUP_MOD2 * FLAG_BAREM + LIM_SUP_BAR2 * (1 - FLAG_BAREM) ;
LIMSUPBAR3 = LIM_SUP_MOD3 * FLAG_BAREM + LIM_SUP_BAR3 * (1 - FLAG_BAREM) ;
LIMSUPBAR4 = LIM_SUP_MOD4 * FLAG_BAREM + LIM_SUP_BAR4 * (1 - FLAG_BAREM) ;
LIMSUPBAR5 = LIM_SUP_MOD5 * FLAG_BAREM + LIM_SUP_BAR5 * (1 - FLAG_BAREM) ;
LIMSUPBAR6 = LIM_SUP_MOD6 * FLAG_BAREM + LIM_SUP_BAR6 * (1 - FLAG_BAREM) ;
LIMSUPBAR7 = LIM_SUP_MOD7 * FLAG_BAREM + LIM_SUP_BAR7 * (1 - FLAG_BAREM) ;
LIMSUPBAR8 = LIM_SUP_MOD8 * FLAG_BAREM + LIM_SUP_BAR8 * (1 - FLAG_BAREM) ;
LIMSUPBAR9 = LIM_SUP_MOD9 * FLAG_BAREM + LIM_SUP_BAR9 * (1 - FLAG_BAREM) ;
regle 521010:
application : bareme , iliad ;
pour x=0,5;y=1,2;z=1,2:
DSxyz = somme(i=1..9: max(QFxyz - LIMINFBARi, 0) * (TAUXi / 100)) + somme(i=10..20: max(QFxyz - LIMINFBARi, 0) * (TAUXi / 100));
regle 521020:
application : iliad ;
WTXMARJ = (RB51) / ( NBPT * null(PLAFQF) + (1 + BOOL_0AM + BOOL_0AZ * V_0AV) *null(1-PLAFQF)) ;
VARTMPTAB1[NOMBRE0] = 0;
pour i=1-NB_TRANCHES_BAR:
VARTMPTAB1[NOMBREi] = positif(WTXMARJ - LIMINFBARi) * TXBARi;
VARTMP1 = max(0, multimax(NB_TRANCHES_BAR+1, VARTMPTAB1));
TXMARJ = VARTMP1
* ( 1 - positif (
present ( NRBASE )
+ present ( NRINET )
+ present ( IPTEFP )
+ present ( IPTEFN )
+ present ( PRODOM )
+ present ( PROGUY )
)
)
* (1- V_CNR)
* positif(IN01+IPQ1001);
TXMARJBA = VARTMP1
* positif(IN01+IPQ1001);
VARTMP1 = 0 ;
regle 521030:
application : bareme , iliad ;
pour y=1,2:
DS0y4 = somme(i=1..9: max(QF0y4 - LIMINFBARi, 0) * (TAUXi / 100)) + somme(i=10..20: max(QF0y4 - LIMINFBARi, 0) * (TAUXi / 100));
pour x=0,5;y=1,2:
DSxy5 = somme(i=1..9: max(QFxy5 - LIMINFBARi, 0) * (TAUXi / 100)) + somme(i=10..20: max(QFxy5 - LIMINFBARi, 0) * (TAUXi / 100));
pour y=1,2:
DS0y6 = somme(i=1..9: max(QF0y6 - LIMINFBARi, 0) * (TAUXi / 100)) + somme(i=10..20: max(QF0y6 - LIMINFBARi, 0) * (TAUXi / 100));
regle 521040:
application : bareme , iliad ;
NBYV1 = NBPT;
NBYV2 = 1 + BOOL_0AM + BOOL_0AZ * V_0AV;
regle 521050:
application : bareme , iliad ;
QF011 = arr(RB01) / NBYV1;
QF021 = arr(RB01) / NBYV2;
QF012 = arr(RB02) / NBYV1;
QF022 = arr(RB02) / NBYV2;
QF511 = arr(RB51) / NBYV1;
QF521 = arr(RB51) / NBYV2;
QF512 = arr(RB52) / NBYV1;
QF522 = arr(RB52) / NBYV2;
QF014 = arr(RB04) / NBYV1;
QF024 = arr(RB04) / NBYV2;
QF015 = arr(RB05) / NBYV1;
QF515 = arr(RB55) / NBYV1;
QF025 = arr(RB05) / NBYV2;
QF525 = arr(RB55) / NBYV2;
QF016 = arr(RB06) / NBYV1;
QF026 = arr(RB06) / NBYV2;
regle corrective 521070:
application : iliad ;
CFRIAHP = ARESTIMO + ALOGDOM + ADUFREPFI + ADUFREPFK + ADUFREPFR + ADUFLOEKL + ADUFLOGIH + APIREPAI
+ APIREPBI + APIREPCI + APIREPDI + APIREPBZ + APIREPCZ + APIREPDZ + APIREPEZ
+ APIQOP + APIQMN + APIQKL + APIQIJ + APIQGH + APIQEF + APIQCD + APIQAB + ATOURREP
+ ATOUREPA
+ ACELRREDLM + ACELRREDLN + ACELRREDLG + ACELRREDLK
+ ACELRREDLS + ACELRREDLT + ACELRREDLH + ACELRREDLL + ACELRREDLZ
+ ACELRREDLX + ACELRREDLI + ACELRREDLO + ACELRREDMG + ACELRREDMH + ACELRREDLJ + ACELRREDLP
+ ACELREPHU + ACELREPHT + ACELREPHZ + ACELREPHX + ACELREPHW
+ ACELREPHV + ACELREPHF + ACELREPHD + ACELREPHA + ACELREPGU + ACELREPGS
+ ACELREPGL + ACELREPGJ + ACELREPYH + ACELREPYF
+ ACELREPYD + ACELREPYB + ACELREPYP + ACELREPYS + ACELREPYO
+ ACELREPYR + ACELREPYN + ACELREPYQ + ACELREPYM + ACELREPYW + ACELREPYZ + ACELREPYV
+ ACELREPYY + ACELREPYU + ACELREPYX + ACELREPYT
+ AILMIY + AILMPA + AILMPF + AILMPK + AINVRED + AILMJC + AILMPB
+ AILMPG + AILMPL + AILMJI + AILMPC + AILMPH + AILMPM + AILMJS + AILMPD + AILMPI
+ AILMPN + AILMPE + AILMPJ + AILMPO + APROREP + AREPNPRO + AREPMEU + AILMIC + AILMIB
+ AILMIA + AILMJY + AILMJX + AILMJW + AILMJV + AILMOE + AILMOD + AILMOC + AILMOB + AILMOA
+ AILMOJ + AILMOI + AILMOH + AILMOG + AILMOF + AILMOO + AILMON + AILMOM + AILMOL + AILMOK
+ ARESIVIEU + ARESINEUV + ALOCIDEFG + ACODJTJU + ACODOU + ACODOV + ACODOW + ACODOX + ACODOY ;
CFRIRHP = RRESTIMO + RLOGDOM + RDUFREPFI + RDUFREPFK + RDUFREPFR + RDUFLOEKL + RDUFLOGIH + RPIREPAI + RPIREPBI
+ RPIREPCI + RPIREPDI + RPIREPBZ + RPIREPCZ + RPIREPDZ + RPIREPEZ
+ RPIQKL + RPIQIJ + RPIQGH + RPIQEF + RPIQCD + RPIQAB + RTOURREP + RTOUREPA
+ RCELRREDLM + RCELRREDLN + RCELRREDLG + RCELRREDLK
+ RCELRREDLS + RCELRREDLT + RCELRREDLH + RCELRREDLL + RCELRREDLZ
+ RCELRREDLX + RCELRREDLI + RCELRREDLO + RCELRREDMG + RCELRREDMH + RCELRREDLJ + RCELRREDLP
+ RCELREPHU + RCELREPHT + RCELREPHZ + RCELREPHX + RCELREPHW
+ RCELREPHV + RCELREPHF + RCELREPHD + RCELREPHA + RCELREPGU + RCELREPGS
+ RCELREPGL + RCELREPGJ + RCELREPYH + RCELREPYF
+ RCELREPYD + RCELREPYB + RCELREPYP + RCELREPYS + RCELREPYO
+ RCELREPYR + RCELREPYN + RCELREPYQ + RCELREPYM + RCELREPYW + RCELREPYZ + RCELREPYV
+ RCELREPYY + RCELREPYU + RCELREPYX + RCELREPYT
+ RILMIY + RILMPA + RILMPF + RILMPK + RINVRED + RILMJC + RILMPB
+ RILMPG + RILMPL + RILMJI + RILMPC + RILMPH + RILMPM + RILMJS + RILMPD + RILMPI
+ RILMPN + RILMPE + RILMPJ + RILMPO + RPROREP + RREPNPRO + RREPMEU + RILMIC + RILMIB
+ RILMIA + RILMJY + RILMJX + RILMJW + RILMJV + RILMOE + RILMOD + RILMOC + RILMOB + RILMOA
+ RILMOJ + RILMOI + RILMOH + RILMOG + RILMOF + RILMOO + RILMON + RILMOM + RILMOL + RILMOK
+ RILMOT + RILMOS + RILMOR + RILMOQ + RILMOP
+ RRESIVIEU + RRESINEUV + RLOCIDEFG + RCODJTJU + RCODOU + RCODOV + RCODOW + RCODOX + RCODOY ;
CFRIADON = AREPA + ADONS;
CFRIRDON = RREPA + RDONS;
CFRIAENF = APRESCOMP;
CFRIRENF = RPRESCOMP + RRETU;
CFRIADEP = AHEBE ;
CFRIRDEP = RHEBE ;
CFRIAFOR = BFCPI + ACOMP + AFOREST + AFORET + ANOUV + ALOCENT + ALOGSOC + ACOLENT + ACOTFOR + ADOMSOC1 + AFIPDOM;
CFRIRFOR = RINNO + RCOMP + RFOREST + RFORET + RNOUV + RLOCENT + RLOGSOC + RCOLENT + RCOTFOR + RDOMSOC1 + RFIPDOM;
CFRIAVIE = ASURV;
CFRIRVIE = RSURV;
CFRIAAUTRE = AFIPC + ADIFAGRI + ASOCREPR + ASOUFIP + ARIRENOV + APATNAT + APATNAT3 ;
CFRIRAUTRE = RFIPC + RDIFAGRI + RSOCREPR + RSOUFIP + RRIRENOV + RPATNAT + RPATNAT3 ;
CFCIDIV = CIGARD + CISYND + CIADCRE + CIFORET;
TOTDEFRCM = DFRCM1 + DFRCM2+DFRCM3 +DFRCM4 +DFRCM5 +DFRCMN;
TOTDEFLOC = DEFLOC1 + DEFLOC2 +DEFLOC3 +DEFLOC4 +DEFLOC5 +DEFLOC6 +DEFLOC7 +DEFLOC8 +DEFLOC9 +DEFLOC10;
TOTMIBV = MIBRNETV + MIBNPRNETV + MIBNPPVV + MIBPVV - BICPMVCTV - MIBNPDCT;
TOTMIBC = MIBRNETC + MIBNPRNETC + MIBNPPVC + MIBPVC - BICPMVCTC -COD5RZ;
TOTMIBP = MIBRNETP + MIBNPRNETP + MIBNPPVP + MIBPVP - BICPMVCTP - COD5SZ;
TOTBNCV = SPENETPV + SPENETNPV + BNCPROPVV - BNCPMVCTV + BNCNPPVV - BNCNPDCT;
TOTBNCC = SPENETPC + SPENETNPC + BNCPROPVC - BNCPMVCTC + BNCNPPVC;
TOTBNCP = SPENETPP + SPENETNPP + BNCPROPVP - BNCPMVCTP + BNCNPPVP;
TOTSPEREP = SPEDREPV + SPEDREPC +SPEDREPP;
TOTSPEREPNP = SPEDREPNPV + SPEDREPNPC +SPEDREPNPP;
IRNINCFIR = IAN+AVFISCOPTER-IRE;
#*************************************************************************************************************************
#
#Copyright or © or Copr.[DGFIP][2019]
#
#Ce logiciel a été initialement développé par la Direction Générale des
#Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2019
#au titre des revenus perçus en 2018. La présente version a permis la
#génération du moteur de calcul des chaînes de taxation des rôles d'impôt
#sur le revenu de ce millésime.
#
#Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français
#et respectant les principes de diffusion des logiciels libres. Vous pouvez
#utiliser, modifier et/ou redistribuer ce programme sous les conditions de
#la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur
#le site "http://www.cecill.info".
#
#Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
#connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes.
#
#**************************************************************************************************************************
# ======================================================================
# Chapitre 6 : Calcul du nombre de parts
# ======================================================================
regle 601000:
application : iliad ;
NBPT = ((NSM + NPA + NIN + NSP + NBQAR)* 10)/10 ;
NBPOTE = V_0CF + V_0CH + V_0CR + V_0DJ + V_0DN + V_0DP ;
NBFOTH = (1 + BOOL_0AM) + V_0CF + (V_0CH/2) + V_0CR + V_0DJ + V_0DN ;
regle 601010:
application : bareme ;
NBPT = (1 - present(V_9VV)) * ((NSM + NPA + NIN + NSP + NBQAR)* 10)/10 + V_9VV ;
regle 601020:
application : bareme , iliad ;
NSM = 1 + BOOL_0AM + V_0AV * min(BOOL_0AZ + EAC + V_0CH + V_0CR, 1 ) +
( V_0AV * BOOL_0AZ * V_0AW * (1 - V_0AP) * (1 - V_0AF) / 2 ) ;
regle 601030:
application : bareme , iliad ;
NPA = PAC - 0.5 * min( PAC, 2 ) ;
regle 601040:
application : bareme , iliad ;
PAC = EAC + V_0CR ;
regle 601050:
application : bareme ;
EAC = ((V_0CF + V_0DJ) * (1 - present(V_9XX))) + V_9XX ;
regle 601060:
application : iliad ;
EAC = (V_0CF + V_0DJ) ;
regle 601070:
application : bareme , iliad ;
NIN = (V_0AP + V_0AF + V_0CG + V_0CR) * 0.5 ;
regle 601080:
application : bareme , iliad ;
NSP = NPS + NSA + NCC ;
regle 601090:
application : bareme , iliad ;
NCC = V_0AS * BOOL_0AM * (1 - positif(V_0AP + V_0AF)) * 0.5 *
positif(max( AGV + 1 - LIM_AGE_LET_S, AGC + 1 - LIM_AGE_LET_S ));
regle 601100:
application : bareme , iliad ;
NPS = positif(PAC) * V_0BT * positif( 2 - NSM ) * 0.5 ;
regle 601110:
application : bareme , iliad ;
NSA = (1 - positif(PAC+V_0CH))
* min( V_0AG
+ (V_0AL * (1 - positif (V_0AN))) * ( 1 - positif(positif(V_0AW)*positif_ou_nul(AGV-LIM_AGE_LET_S)))
+ V_0AW * positif(max(AGV + 1 - LIM_AGE_LET_S, AGC + 1 - LIM_AGE_LET_S))
, 1 )
* ( 1 - V_0AP ) * positif(2 - NSM) * 0.5;
NSA2 = min( (1 - positif(PAC+V_0CH))
*
(null(SFUTILE - 14)
+ null (SFUTILE - 7)
+ null (SFUTILE - 15) * (1-positif(NIN))
)
+
null(SFUTILE -7) * BOOL_0AZ * V_0AV
, 1)
* 0.5 ;
regle 601120:
application : bareme , iliad ;
BOOL_0BT = positif ( V_0BT+0 ) * positif ( V_0AC + V_0AD + 0);
NBQAR1 = null (V_0CF+V_0CR+V_0DJ+0) * ( 1/2 * (V_0CH-2) * positif (V_0CH- 2)
+ 1/4 * positif (V_0CH+0)
+ 1/4 * positif(V_0CH-1)
);
NBQAR2 = null(V_0CF+V_0CR+V_0DJ-1) * (1/2 * (V_0CH -1 ) * positif(V_0CH -1)
+ 1/4 * positif (V_0CH+0)
);
NBQAR3 = positif_ou_nul(V_0CF+V_0CR+V_0DJ-2) * 1/2 * V_0CH ;
NBQAR4 = 1/4 * V_0CI ;
NBQART = BOOL_0BT * null(V_0CF+V_0CR+V_0DJ+0)
* (1/4 * null (V_0CH -1) + 1/2 * positif_ou_nul (V_0CH - 2)) ;
NBQAR = NBQAR1 + NBQAR2 + NBQAR3 + NBQAR4 + NBQART ;
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
#*************************************************************************************************************************
#
#Copyright or © or Copr.[DGFIP][2019]
#
#Ce logiciel a été initialement développé par la Direction Générale des
#Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2019
#au titre des revenus perçus en 2018. La présente version a permis la
#génération du moteur de calcul des chaînes de taxation des rôles d'impôt
#sur le revenu de ce millésime.
#
#Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français
#et respectant les principes de diffusion des logiciels libres. Vous pouvez
#utiliser, modifier et/ou redistribuer ce programme sous les conditions de
#la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur
#le site "http://www.cecill.info".
#
#Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
#connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes.
#
#**************************************************************************************************************************
# =================================================================================
# Chapitre 83 : Revenu catégoriels nets : Revenus fonciers
# =================================================================================
regle 831000:
application : iliad ;
RRFI = positif(RFON + DRCF + RFMIC - MICFR -max(0,RFDANT - DEFRFNONI)*(1-positif(RFON))) * (RFON + DRCF + max(0,RFMIC - MICFR -max(0,RFDANT - DEFRFNONI)*(1-positif(RFON))))
+ (1-positif(RFON + DRCF + RFMIC - MICFR -max(0,RFDANT - DEFRFNONI)*(1-positif(RFON)))) * (positif(RFDANT-DEFRFNONI)*(1-positif(RFON)) * DEFRFNONI+DRCF+RFON) ;
RRFIPS = RRFI ;
regle 831010:
application : iliad ;
MICFR=arr(RFMIC*TX_MICFON/100);
regle 831020:
application : iliad ;
RMF = RFMIC - MICFR ;
RMFN = max(0 , RMF - RFDANT * (1-positif(DEFRFNONI)) - min(RFDANT , max(0 , RFDANT - DEFRFNONI)) * positif(DEFRFNONI)) ;
PASRFASS = positif(RMF - RFDANT) * (RMFN - (COD4BK - arr(COD4BK * TX_MICFON/100) - arr(COD4BK * RFDANT/RFMIC)) * positif(RMFN)) ;
regle 831030:
application : iliad ;
RFCD = RFORDI + FONCI + REAMOR ;
regle 831040:
application : iliad ;
RFCE = max(0,RFCD- RFDORD* (1-positif(DEFRFNONI))
- min(RFDORD, max(0,RFDORD+RFDHIS+RFDANT-DEFRFNONI)) * positif(DEFRFNONI));
RFCEAPS = max(0,RFORDI- RFDORD* (1-positif(DEFRFNONI))
- min(RFDORD, max(0,RFDORD+RFDHIS+RFDANT-DEFRFNONI)) * positif(DEFRFNONI));
RFCEPS = max(0,RFCD-RFDORD* (1-positif(DEFRFNONI))
- min(RFDORD, max(0,RFDORD+RFDHIS+RFDANT-DEFRFNONI)) * positif(DEFRFNONI));
DFCE = min(0,RFCD- RFDORD* (1-positif(DEFRFNONI))
- min(RFDORD, max(0,RFDORD+RFDHIS+RFDANT-DEFRFNONI)) * positif(DEFRFNONI));
RFCF = max(0,RFCE-RFDHIS);
RFCFPS = (RFCEPS-RFDHIS);
RFCFAPS = max(0,RFCEAPS-RFDHIS);
DRCF = min(0,RFCE-RFDHIS);
RFCG = max(0,RFCF- RFDANT* (1-positif(DEFRFNONI))
- min(RFDANT, max(0,RFDANT-DEFRFNONI)) * positif(DEFRFNONI));
DFCG = min(0,RFCF- RFDANT* (1-positif(DEFRFNONI))
- min(RFDANT, max(0,RFDANT-DEFRFNONI)) * positif(DEFRFNONI));
regle 831050:
application : iliad ;
RFON = arr(RFCG*RFORDI/RFCD);
2REVF = min( arr ((RFCG)*(FONCI)/RFCD) , RFCG-RFON) ;
3REVF = min( arr (RFCG*(REAMOR)/RFCD) , RFCG-RFON-2REVF) ;
RFQ = FONCI + REAMOR ;
regle 831055:
application : iliad ;
RFDANT4BA = max(0,RFORDI - RFON);
RFDANTRBA = max(0,FONCI - 2REVF);
RFDANTSBA = max(0,REAMOR - 3REVF);
PASRF = (1 - positif(-DFCG)) * max(0 , present(RFORDI) * (RFON - (COD4BL - arr(COD4BL * RFDANT4BA/RFORDI)))) ;
regle 831060:
application : iliad ;
DEF4BB = min(RFDORD,RFORDI + RFMIC * 0.70 + FONCI + REAMOR) ;
DEFRF4BB = min(RFDORD,max(DEF4BB1731,max(DEF4BB_P,DEF4BBP2))) * positif(SOMMERF_2) * (1-PREM8_11) ;
regle 831070:
application : iliad ;
DEF4BD = min(RFDANT,RFORDI + RFMIC * 0.70 + FONCI + REAMOR-RFDORD - RFDHIS) ;
DEFRF4BD = min(RFDANT,max(DEF4BD1731,max(DEF4BD_P,DEF4BDP2)))* positif(SOMMERF_2) * (1-PREM8_11) ;
regle 831080:
application : iliad ;
DEF4BC = max(0, RFORDI + RFMIC * 0.70 + FONCI + REAMOR - RFDORD) ;
DEFRF4BC = max(0,RFDHIS-max(DEF4BC1731,max(DEF4BC_P,DEF4BCP2))) * positif(DFANTIMPU)*(1-positif(PREM8_11))
+ RFDHIS * positif(DFANTIMPU)*positif(PREM8_11);
regle 834210:
application : iliad ;
RFREVENU = (RFORDI + RFMIC * 0.70 + FONCI + REAMOR);
regle 834215:
application : iliad ;
DEFRFNONIBIS = min(RFDORD,RFORDI + RFMIC * 0.70 + FONCI + REAMOR) + max(0,min(RFDANT,RFORDI + RFMIC * 0.70 + FONCI + REAMOR-RFDORD - RFDHIS));
regle 831090:
application : iliad ;
DEFRFNONI1 = RFDORD + RFDANT - DEFRFNONIBIS;
DEFRFNONI2 = positif(SOMMERF_2) * null(PREM8_11) *
(max(0,RFDORD + RFDANT - max(DEFRFNONI1731,max(DEFRFNONI_P,DEFRFNONIP2))
- max(0,RFREVENU - RFREVENUP3)))
+ PREM8_11 * positif(RFORDI + RFMIC * 0.70 + FONCI + REAMOR) * DEFRFNONIBIS
+ 0;
DEFRFNONI = positif(null(PREM8_11) * positif(DEFRFNONI2-DEFRFNONI1)) * DEFRFNONI2 + 0
+ PREM8_11 * positif(DEFRFNONI2) * (DEFRFNONI2+DEFRFNONI1) + 0;
regle 831095:
application : iliad ;
4BB4BA =arr(RFDORD*(RFORDI/RFCD));
R14BA = RFORDI-4BB4BA;
4BC4BA =arr( RFDHIS*(R14BA/RFCE));
R24BA = R14BA -4BC4BA;
R2BA = RFCE - RFDHIS ;
4BD4BA =arr( RFDANT * (R24BA/R2BA));
R3BA = max (0, R2BA-RFDANT);
D3BA = min (0,R2BA-RFDANT);
R34BA = R24BA -4BD4BA ;
4BBRBA = max (0,arr(RFDORD*(FONCI/RFCD)));
R1RBA =max(0, FONCI- 4BBRBA);
4BCRBA =max(0,arr( RFDHIS*(R1RBA/RFCE)));
R2RBA =max(0, R1RBA - 4BCRBA);
4BDRBA =max (0,arr(RFDANT*( R2RBA/R2BA)));
R3RBA = max(0,arr(R2RBA - 4BDRBA)) ;
4BBSBA =max (0,arr( RFDORD-(4BB4BA+4BBRBA)));
R1SBA =max(0, REAMOR-4BBSBA);
4BCSBA = max(0,RFDHIS-(4BC4BA+4BCRBA));
R2SBA =max(0,R1SBA-4BCSBA);
4BDSBA =max(0, RFDANT-(4BD4BA+4BDRBA));
R3SBA =max (0,R2SBA - 4BDSBA);
R4BL = (positif (D3BA))*0
+ (positif(R3BA))*( arr(COD4BL-(COD4BL*4BD4BA/RFORDI)));
RRBT =(positif(R3BA))*max(0,arr( CODRBT - arr((4BBRBA+4BCRBA+4BDRBA)*CODRBT/FONCI)))
+ positif(D3BA)*(0) ;
regle 831096:
application : iliad ;
REVORDIRF = RRFI - R4BL ;
REVQUOTRF = REVRF -RRBT;
RFTXFOYER =(1-positif(COD4BN))* max(0,REVORDIRF + REVQUOTRF)
+positif(COD4BN)*(0);
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment