├── LICENSE ├── README.md └── src ├── chap-1.m ├── chap-2.m ├── chap-3.m ├── chap-4.m ├── chap-51.m ├── chap-52.m ├── chap-6.m ├── chap-7.m ├── chap-81.m ├── chap-82.m ├── chap-83.m ├── chap-84.m ├── chap-85.m ├── chap-86.m ├── chap-87.m ├── chap-88.m ├── chap-aff.m ├── chap-cinr.m ├── chap-cmajo.m ├── chap-cor.m ├── chap-ctl.m ├── chap-ini.m ├── chap-inr.m ├── chap-isf.m ├── chap-majo.m ├── chap-perp.m ├── chap-plaf.m ├── chap-teff.m ├── chap-thr.m ├── chap-tl.m ├── coc1.m ├── coc2.m ├── coc3.m ├── coc4.m ├── coc5.m ├── coc7.m ├── coi1.m ├── coi2.m ├── coi3.m ├── errH.m ├── horizoc.m ├── horizoi.m ├── res-ser1.m ├── res-ser2.m └── tgvH.m /README.md: -------------------------------------------------------------------------------- 1 | # Code source des impôts sur les revenus 2 | 3 | ## Contenu 4 | 5 | Les fichiers contenus dans l'archive sont l'ensemble des fichiers de paramétrage utilisés par les services informatiques de la Direction Générale des Finances Publiques pour réaliser la taxation des foyers fiscaux (IR, ISF, CSG). 6 | 7 | Ces fichiers sont développés sous licence CeCILL 2.1 soumise au droit français et respectant les principes de diffusion des logiciels libres. 8 | 9 | Cette version est la 2.5 qui a servi au cours de l'année 2015 pour produire les avis d'impôt sur les revenus 2014. 10 | 11 | Les fichiers contenus dans le répertoire `src` sont : 12 | 13 | - [`tgvH.m`](src/tgvH.m) : Tableau général des variables qui assure la correspondance entre les codes issus de la 2042 et les variables internes au calcul, les variables de calcul et les variables restituées par la calculette IR 14 | - [`errH.m`](src/errH.m) : Fichier décrivant les différentes anomalies 15 | - `coiX.m`, `cocX.m`, [`horizoc.m`](src/horizoc.m), [`horizoi.m`](src/horizoi.m) : Fichiers de gestion des anomalies de la calculette 16 | - `chap-X.m`, [`res-ser1.m`](src/res-ser1.m), [`res-ser2.m`](src/res-ser2.m) : Fichiers comportant les différentes règles de calcul pour un ensemble fonctionnel cohérent. 17 | 18 | ## The missing manual 19 | 20 | Cette section contient des informations devinées en lisant les fichiers du code source, durant le processus d'écriture du [parser](https://git.framasoft.org/openfisca/calculette-impots-m-language-parser) et du [compilateur en Python](https://git.framasoft.org/openfisca/calculette-impots-python). 21 | 22 | Un tag `FIXME` est placé lorsqu'une information est manquante et qu'il faut la compléter. 23 | 24 | ### Applications 25 | 26 | Les règles déclarées sont qualifiées par un ou plusieurs noms d'application. 27 | 28 | Exemple : 29 | 30 | ```impots-m 31 | regle 700: 32 | application : bareme , iliad , batch ; 33 | pour z=1,2: 34 | RB5z = max( 0, RB0z + TETONEQUO1) ; 35 | RB55 = max( 0, RB05 + TETONEQUOM1) ; 36 | ``` 37 | 38 | Les applications identifiées jusque là sont : 39 | 40 | - `batch` est utilisée pour le calcul primitif de l'impôt 41 | - `iliad` est utilisée pour le calcul correctif de l'impôt 42 | - `FIXME` les autres applications 43 | 44 | ### Variables 45 | 46 | Les variables sont de plusieurs types : 47 | 48 | - Les variables saisies correspondent aux cases de la déclaration des revenus (par exemple `1AJ`). 49 | - Les variables calculées ont une formule qui renvoie la valeur de la variable. 50 | - Les variables calculées de base sont des variables qui peuvent être affectées avant le début du calcul. 51 | 52 | Le fichier [`tgvH.m`](src/tgvH.m) définit des variables via plusieurs champs qui varient selon le type. 53 | 54 | Exemples : 55 | 56 | ```impots-m 57 | 10MINS1 : calculee : "deductions hors droits d'auteur plafonnees" ; 58 | 10MINS1TOUT : calculee base : "10 pourcent TS dernier evt pour calcul de DEFRI" ; 59 | 4BACREP : saisie revenu classe = 2 priorite = 10 categorie_TL = 20 cotsoc = 5 ind_abat = 0 acompte = 1 avfisc = 0 rapcat = 8 sanction = 2 nat_code = 0 alias CJC : "BA exceptionnels sous CGA - Quotient 4 - PAC" ; 60 | ``` 61 | 62 | ### Formules 63 | 64 | Quelques exemples de fichiers contenant des formules : 65 | 66 | - [`chap-1.m`](src/chap-1.m) contient les règles de calcul du montant net à payer 67 | - [`chap-2.m`](src/chap-2.m) contient les règles de calcul du montant net à payer 68 | - [`chap-51.m`](src/chap-51.m) contient les règles de calcul des droits simples résultant du taux progressif 69 | - [`chap-55.m`](src/chap-55.m) contient les règles de calcul des droits simples résultant du taux progressif 70 | - [`chap-6.m`](src/chap-6.m) contient les règles de calcul du nombre de parts 71 | - [`chap-isf.m`](src/chap-isf.m) contient les règles de calcul de l'ISF 72 | - [`chap-perp.m`](src/chap-perp.m) contient les règles de calcul des déductions pour verserment sur un Plan d'Epargne Retraite Populaire 73 | inr intérêts de retard (correctif) 74 | cinr cumul (correctif) 75 | majo majorations (correctif) 76 | cmajo cumul majorations (correctif) 77 | 78 | coc => contrôle bloquant 79 | coi => informatif 80 | 81 | TL => tolérance légale 82 | 83 | calculée base => correctif pour éviter d'écraser les valeurs issues de batch, et stockées en base de données 84 | 85 | ### Erreurs 86 | 87 | Le fichier [`errH.m`](src/errH.m) définit des erreurs via plusieurs champs : 88 | 89 | - `code` (`string`, unique) : le code unique de l'erreur 90 | - `type` (`enum(anomalie, discordance, informative)`) : le type d'erreur 91 | - `type_code` (`enum(A, D, I)`) : le code du type d'erreur (semble redondant avec `type`) 92 | 93 | Exemple : 94 | 95 | ```impots-m 96 | A000:anomalie :"A":"000":"00":"SAISIE D UN MONTANT NEGATIF":"N"; 97 | ``` 98 | 99 | ### Vérifications 100 | 101 | - [`coi1.m`](src/coi1.m) décleche uniquement des erreurs de type `discordance` 102 | - [`coi2.m`](src/coi2.m) et [`coi3.m`](src/coi3.m) déclechent uniquement des erreurs de type `informative` 103 | - `coc*.m` déclechent uniquement des erreurs de type `anomalie` 104 | - [`horizoc.m`](src/horizoc.m) et [`horizoi.m`](src/horizoi.m) déclechent uniquement des erreurs de type `anomalie`, et les vérifications concernent uniquement l'application `iliad` 105 | 106 | ### Variables remarquables 107 | 108 | Variables calculées : 109 | 110 | - `IRN` : Impot net ou restitution nette 111 | 112 | Variables saisies : 113 | 114 | - `TSHALLOV` (`1AJ`) : Salaires - Declarant 1 115 | 116 | ### Questions métier 117 | 118 | - qu'est-ce que le calcul correctif horizontal ? (cf `horizoc.m`: `verif corrective horizontale 760`) 119 | -------------------------------------------------------------------------------- /src/chap-2.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | # 22 | # CHAPITRE 2. CALCUL DU NET A PAYER 23 | # 24 | # 25 | # 26 | regle 20100: 27 | application : batch, iliad ; 28 | NAPINI = ( IRN + PIR - IRANT )* (1 - INDTXMIN) *(1 - INDTXMOY) 29 | + min(0, IRN + PIR - IRANT) * (INDTXMIN + INDTXMOY) 30 | + max(0, IRN + PIR - IRANT) * 31 | (INDTXMIN*positif((IAVIMBIS-NAPCRPAVIM)-SEUIL_61 ) 32 | + INDTXMOY* positif((IAVIMO-NAPCRPAVIM)-SEUIL_61)) 33 | + RASAR * V_CR2; 34 | RC1INI = positif( NAPINI + 1 - SEUIL_12 ) ; 35 | regle 20101: 36 | application : batch, iliad ; 37 | NAPTOT = IRCUM + TAXACUM + PCAPCUM + TAXLOYCUM + HAUTREVCUM - RECUMIR; 38 | regle 20103: 39 | application : iliad ,batch; 40 | NAPTOTA = V_IRPSANT - V_ANTRE; 41 | NAPTOTAIR = V_TOTIRANT - V_ANTREIR; 42 | TOTCRA = V_ANTCR ; 43 | TOTIRPSANT = V_IRPSANT - V_NONMERANT + V_NONRESTANT - V_ANTRE; 44 | regle 20104: 45 | application : iliad ; 46 | OCEDIMP = IRNIN ; 47 | regle 20105: 48 | application : batch, iliad ; 49 | IRNIN = (IRN - IRANT) * positif(IRN - IRANT) ; 50 | regle isf 201050: 51 | application : batch, iliad ; 52 | ISF4BASE = ISF4BIS * positif_ou_nul(ISF4BIS - SEUIL_12); 53 | ISFIN = ISF4BASE ; 54 | regle 201051: 55 | application : batch, iliad; 56 | IRNIN_INR = max(0,IRN - IRANT - IR9YI) * positif(IRN - IRANT) ; 57 | CSBASE_INR = max(0,CSG - CSGIM - CS9YP); 58 | RDBASE_INR = max(0,RDSN - CRDSIM - RD9YP); 59 | PSBASE_INR = max(0,PRS - PRSPROV - PS9YP); 60 | CVNBASE_INR = max(0,CVNSALC - COD8YT - CVN9YP); 61 | CDISBASE_INR = max(0,CDIS - CDISPROV - CDIS9YP); 62 | GLOBASE_INR = max(0,CGLOA - COD8YL - GLO9YP); 63 | REGVBASE_INR = max(0,BREGV - REGV9YP); 64 | RSE1BASE_INR = max(0,RSE1N - CSPROVYD - RSE19YP); 65 | RSE2BASE_INR = max(0, max(0, RSE8TV - CIRSE8TV - CSPROVYF) + max(0, RSE8SA -CIRSE8SA - CSPROVYN) - RSE29YP); 66 | RSE3BASE_INR = max(0,RSE3N - CSPROVYG - RSE39YP); 67 | RSE4BASE_INR = max(0, max(0, RSE8TX - CIRSE8TX - CSPROVYH) + max(0, RSE8SB -CIRSE8SB - CSPROVYP) - RSE49YP); 68 | RSE5BASE_INR = max(0,RSE5N - CSPROVYE - RSE59YP); 69 | TAXABASE_INR = arr(max(TAXASSUR - TAXA9YI + min(0,IRN - IRANT),0)) * positif(IAMD1 + 1 - SEUIL_61); 70 | PCAPBASE_INR = arr(max(IPCAPTAXT - CAP9YI + min(0,IRN - IRANT + TAXASSUR),0)) * positif(IAMD1 + 1 - SEUIL_61); 71 | LOYBASE_INR = arr(max(TAXLOY - LOY9YI + min(0,IRN - IRANT + TAXASSUR+IPCAPTAXT),0)) * positif(IAMD1 + 1 - SEUIL_61); 72 | CHRBASE_INR = arr(max(IHAUTREVT - CHR9YI + min(0,IRN - IRANT + TAXASSUR+IPCAPTAXT+TAXLOY),0)) * positif(IAMD1 + 1 - SEUIL_61); 73 | CSBASE = CSG - CSGIM ; 74 | RDBASE = RDSN - CRDSIM ; 75 | PSBASE = PRS - PRSPROV ; 76 | CVNBASE = CVNSALC - COD8YT ; 77 | CDISBASE = CDIS - CDISPROV ; 78 | GLOBASE = CGLOA - COD8YL ; 79 | RSE1BASE = RSE1N - CSPROVYD; 80 | RSE2BASE = max(0, RSE8TV - CIRSE8TV - CSPROVYF) + max(0, RSE8SA - CIRSE8SA - CSPROVYN) ; 81 | RSE3BASE = RSE3N - CSPROVYG; 82 | RSE4BASE = max(0, RSE8TX - CIRSE8TX - CSPROVYH) + max(0, RSE8SB -CIRSE8SB - CSPROVYP) ; 83 | RSE5BASE = RSE5N - CSPROVYE; 84 | REGVBASE = BREGV; 85 | TAXABASE = arr(max(TAXASSUR + min(0,IRN - IRANT),0)) * positif(IAMD1 + 1 - SEUIL_61); 86 | PCAPBASE = arr(max(IPCAPTAXT + min(0,IRN - IRANT + TAXASSUR),0)) * positif(IAMD1 + 1 - SEUIL_61); 87 | LOYBASE = arr(max(TAXLOY + min(0,IRN - IRANT + TAXASSUR+IPCAPTAXT),0)) * positif(IAMD1 + 1 - SEUIL_61); 88 | CHRBASE = arr(max(IHAUTREVT + min(0,IRN - IRANT + TAXASSUR+IPCAPTAXT+TAXLOY),0)) * positif(IAMD1 + 1 - SEUIL_61); 89 | 90 | IRBASE_I = (IRN -IRANT)*positif(IRN+1-SEUIL_12); 91 | 92 | IRBASE_N = (IRN - IRANT)*(1 - positif (IRN-IRANT + TAXABASE_IRECT+CAPBASE_IRECT+HRBASE_IRECT)) 93 | + (IAN - min( IAN , IRE )) * positif (IRN-IRANT + TAXABASE_IRECT+CAPBASE_IRECT+HRBASE_IRECT); 94 | TAXABASE_I = TAXASSUR * positif(IAMD1 + 1 - SEUIL_61); 95 | TAXABASE_N = arr(max(TAXASSUR + min(0,IRN - IRANT),0)) * positif(IAMD1 + 1 - SEUIL_61); 96 | CAPBASE_I = IPCAPTAXT * positif(IAMD1 + 1 - SEUIL_61); 97 | CAPBASE_N = arr(max(IPCAPTAXT + min(0,IRN - IRANT + TAXASSUR),0)) * positif(IAMD1 + 1 - SEUIL_61); 98 | LOYBASE_I = TAXLOY * positif(IAMD1 + 1 - SEUIL_61); 99 | LOYBASE_N = arr(max(TAXLOY + min(0,IRN - IRANT + TAXASSUR+IPCAPTAXT),0)) * positif(IAMD1 + 1 - SEUIL_61); 100 | HRBASE_I = IHAUTREVT * positif(IAMD1 + 1 - SEUIL_61); 101 | HRBASE_N = arr(max(IHAUTREVT + min(0,IRN - IRANT + TAXASSUR+IPCAPTAXT+TAXLOY),0)) * positif(IAMD1 + 1 - SEUIL_61); 102 | 103 | IRNN = IRNIN; 104 | 105 | regle 20106: 106 | application : iliad; 107 | PIR = ( 108 | INCIR_NET 109 | + NMAJ1 + NMAJ3 + NMAJ4 110 | + arr((BTOINR) * TXINT / 100)* (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) 111 | ; 112 | PPRS = ( 113 | INCPS_NET 114 | + NMAJP1 + NMAJP4 115 | + arr(max(0,PRS-PRSPROV-PS9YP) * TXINT / 100)* (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 116 | PCSG = ( 117 | INCCS_NET 118 | + NMAJC1 + NMAJC4 119 | + arr(max(0,CSG-CSGIM-CS9YP) * TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 120 | PRDS = ( 121 | INCRD_NET 122 | + NMAJR1 + NMAJR4 123 | + arr(max(0,RDSN-CRDSIM-RD9YP) * TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 124 | PCVN = ( 125 | INCCVN_NET 126 | + NMAJCVN1 + NMAJCVN4 127 | + arr(max(0,(CVNSALC - COD8YT)-CVN9YP) * TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 128 | PREGV = ( 129 | INCREGV_NET 130 | + NMAJREGV1 + NMAJREGV4 131 | + arr( max(0,BREGV - REGV9YP) * TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 132 | 133 | PTAXA = ( 134 | INCTAXA_NET 135 | + NMAJTAXA1 + NMAJTAXA3 + NMAJTAXA4 136 | + arr(max(0,TAXASSUR- min(TAXASSUR+0,max(0,INE-IRB+AVFISCOPTER))+min(0,IRN - IRANT)-TAXA9YI) * TXINT / 100)* (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) ; 137 | PPCAP = ( 138 | INCPCAP_NET 139 | + NMAJPCAP1 + NMAJPCAP3 + NMAJPCAP4 140 | + arr(max(0,IPCAPTAXT- min(IPCAPTAXT+0,max(0,INE-IRB+AVFISCOPTER-TAXASSUR))+min(0,IRN - IRANT+TAXASSUR)-CAP9YI) * TXINT / 100)* (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) ; 141 | PTAXLOY = ( 142 | INCLOY_NET 143 | + NMAJLOY1 + NMAJLOY3 + NMAJLOY4 144 | + arr(max(0,LOYELEV- min(LOYELEV+0,max(0,INE-IRB+AVFISCOPTER-TAXASSUR-IPCAPTAXT))+min(0,IRN - IRANT+TAXASSUR+IPCAPTAXT)-LOY9YI) * TXINT / 100)* (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) ; 145 | PHAUTREV = ( 146 | INCCHR_NET 147 | + NMAJCHR1 + NMAJCHR3 + NMAJCHR4 148 | + arr(max(0,IHAUTREVT+min(0,IRN - IRANT+TAXASSUR+IPCAPTAXT+LOYELEV)-CHR9YI) * TXINT / 100)* (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) ; 149 | PGLOA = ( 150 | INCGLOA_NET 151 | + NMAJGLO1 + NMAJGLO4 152 | + arr((max(0,CGLOA - COD8YL-GLO9YP)* TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT)))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 153 | PRSE1 = ( 154 | INCRSE1_NET 155 | + NMAJRSE11 + NMAJRSE14 156 | + arr(max(0,RSE1 -CIRSE1 -CSPROVYD-RSE19YP)* TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 157 | PRSE2 = ( 158 | INCRSE2_NET 159 | + NMAJRSE21 + NMAJRSE24 160 | + arr(max(0,(max(0,RSE8TV -CIRSE8TV -CSPROVYF)+ max(0, RSE8SA -CIRSE8SA - CSPROVYN)-RSE29YP)) * TXINT / 100 161 | ) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT)) 162 | ) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 163 | PRSE3 = ( 164 | INCRSE3_NET 165 | + NMAJRSE31 + NMAJRSE34 166 | + arr(max(0,RSE3 -CIRSE3 -CSPROVYG-RSE39YP)* TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 167 | PRSE4 = ( 168 | INCRSE4_NET 169 | + NMAJRSE41 + NMAJRSE44 170 | + arr(max(0,max(0,RSE8TX -CIRSE8TX -CSPROVYH)+ max(0, RSE8SB -CIRSE8SB - CSPROVYP)-RSE49YP) * TXINT / 100 171 | ) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT)) 172 | ) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 173 | PRSE5 = ( 174 | INCRSE5_NET 175 | + NMAJRSE51 + NMAJRSE54 176 | + arr(max(0,RSE5 -CIRSE5 -CSPROVYE-RSE59YP)* TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 177 | PCDIS = ( 178 | INCCDIS_NET 179 | + NMAJCDIS1 + NMAJCDIS4 180 | + arr(max(0,CDIS-CDISPROV-CDIS9YP) * TXINT / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) * positif_ou_nul(CSTOTSSPENA - SEUIL_61); 181 | 182 | PDEG = max(0,PIR_A + PTAXA_A + PPCAP_A - PTAXLOY_A - PCHR_A - PIR - PTAXA - PPCAP - PTAXLOY - PHAUTREV); 183 | 184 | regle 201061: 185 | application : batch , iliad ; 186 | PTOTIRCS = PIR + PTAXA + PTAXLOY + PHAUTREV + PPCAP + 187 | PPRS + PCSG + PRDS + PCDIS + PREGV + PCVN + 188 | PGLOA + PRSE1 + PRSE2 + PRSE3 + PRSE4 + PRSE5 ; 189 | 190 | TOTPENIR = PIR + PTAXA + PTAXLOY + PHAUTREV + PPCAP ; 191 | 192 | TOTPENCS = PPRS+ PCSG + PRDS + PCVN + PREGV + PCDIS + PGLOA + PRSE1 + PRSE2 + PRSE3 + PRSE4 + PRSE5; 193 | 194 | INCTOTIR = RETIR + RETTAXA + RETPCAP + RETLOY + RETHAUTREV ; 195 | 196 | INCTOTCS = RETCS+RETRD+RETPS+RETCVN+RETREGV+RETCDIS+RETGLOA 197 | +RETRSE1+RETRSE2+RETRSE3+RETRSE4+RETRSE5 ; 198 | 199 | RETIRCSTOT = INCTOTIR + INCTOTCS ; 200 | 201 | regle 20107: 202 | application : batch ; 203 | PIR = PTOIR * positif_ou_nul(IAMD1 - SEUIL_61) ; 204 | PPRS = PTOPRS ; 205 | PCSG = PTOCSG ; 206 | PRSE1 = PTORSE1 ; 207 | PRSE2 = PTORSE2 ; 208 | PRSE3 = PTORSE3 ; 209 | PRSE4 = PTORSE4 ; 210 | PRSE5 = PTORSE5 ; 211 | PREGV = PTOREGV ; 212 | PRDS = PTORDS ; 213 | PTAXA = PTOTAXA ; 214 | PPCAP = PTOTPCAP ; 215 | PTAXLOY = PTOTLOY ; 216 | PHAUTREV = PTOTCHR ; 217 | PCVN = PTOCVN ; 218 | PCDIS = PTOCDIS ; 219 | PGLOA = PTOGLOA ; 220 | 221 | regle 20109: 222 | application : iliad , batch ; 223 | PTOT = PIR ; 224 | regle 20110: 225 | application : iliad ; 226 | ILI_SYNT_IR = positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR) * max(0 , IRCUM - NONMER + NONREST - PIR) 227 | + (1 - positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR)) * (TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR) ; 228 | 229 | PIRNEG = abs(min(0 , IRCUM - NONMER + NONREST - PIR)) ; 230 | 231 | ILI_SYNT_TAXA = positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR) * max(0,TAXACUM - PTAXA - PIRNEG) 232 | + (1 - positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR)) * 0 ; 233 | 234 | PTAXANEG = abs(min(0 , TAXACUM - PTAXA - PIRNEG)) ; 235 | 236 | ILI_SYNT_CAP = positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR) * max(0 , PCAPCUM - PPCAP - PTAXANEG) 237 | + (1 - positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR)) * 0 ; 238 | 239 | PPCAPNEG = abs(min(0 , PCAPCUM - PPCAP - PTAXANEG)) ; 240 | 241 | ILI_SYNT_LOY = positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR) * max(0 , TAXLOYCUM - PTAXLOY - PPCAPNEG) 242 | + (1 - positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR)) * 0 ; 243 | 244 | PTAXLOYNEG = abs(min(0 , TAXLOYCUM - PTAXLOY - PPCAPNEG)) ; 245 | 246 | ILI_SYNT_CHR = positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR) * max(0 , HAUTREVCUM - PHAUTREV - PTAXLOYNEG) 247 | + (1 - positif(TOTIRCUM - NONMER - RECUMIR + NONREST - TOTPENIR)) * 0 ; 248 | 249 | ILI_SYNT_TOTIR = ILI_SYNT_IR + ILI_SYNT_TAXA + ILI_SYNT_CAP + ILI_SYNT_LOY + ILI_SYNT_CHR ; 250 | 251 | regle 201101: 252 | application : iliad , batch ; 253 | 254 | ILIIRNET = positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR) * max(0,IRCUM-PIR) 255 | + (1 - positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR)) * (TOTIRCUM - RECUMIR - TOTPENIR); 256 | 257 | PIRNETNEG = max(0,PIR-IRCUM); 258 | 259 | ILITAXANET = positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR) * max(0,TAXACUM - PTAXA - PIRNETNEG) 260 | + (1 - positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR)) * 0; 261 | 262 | PTAXANETNEG = max(0,PIR+PTAXA-IRCUM-TAXACUM); 263 | 264 | ILICAPNET = positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR) * max(0,PCAPCUM -PPCAP-PTAXANETNEG) 265 | + (1 - positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR)) * 0; 266 | 267 | PPCAPNETNEG = max(0,PIR+PTAXA+PPCAP-IRCUM-TAXACUM-PCAPCUM); 268 | 269 | ILILOYNET = positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR) * max(0,TAXLOYCUM-PTAXLOY-PPCAPNETNEG) 270 | + (1 - positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR)) * 0; 271 | 272 | PTAXLOYNETNEG = max(0,PIR+PTAXA+PPCAP+PTAXLOY-IRCUM-TAXACUM-PCAPCUM-TAXLOYCUM); 273 | 274 | ILICHRNET = positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR) * max(0,HAUTREVCUM-PHAUTREV-PTAXLOYNETNEG) 275 | + (1 - positif_ou_nul(TOTIRCUM - RECUMIR - TOTPENIR)) * 0; 276 | 277 | ILITOTIRNET = ILIIRNET + ILITAXANET + ILICAPNET + ILILOYNET + ILICHRNET; 278 | 279 | ILITOTPSNET = max(0, NAPCR61 - TOTPENCS) ; 280 | 281 | TOTIRE = IREP - ITRED - IRE - INE ; 282 | 283 | TOTTP = TTPVQ + REVTP ; 284 | 285 | regle 201102: 286 | application : batch ; 287 | 288 | 289 | MAJOTOT28IR = NMAJ1 + 290 | NMAJTAXA1 + 291 | NMAJPCAP1 + 292 | NMAJLOY1 + 293 | NMAJCHR1 ; 294 | 295 | MAJOTOT28PS = NMAJC1 + 296 | NMAJR1 + 297 | NMAJP1 + 298 | NMAJCVN1 + 299 | NMAJREGV1 + 300 | NMAJCDIS1 + 301 | NMAJGLO1 + 302 | NMAJRSE11 + 303 | NMAJRSE21 + 304 | NMAJRSE31 + 305 | NMAJRSE41 + 306 | NMAJRSE51 ; 307 | 308 | MAJO1728TOT = MAJOTOT28IR + MAJOTOT28PS ; 309 | 310 | regle 20111: 311 | application : iliad ; 312 | DEC_CGA_AGA = BAFV + BAFC + BAFP 313 | + BAHREV - (BAHDEV * (1 - positif(ART1731BIS) )) 314 | + BAHREC - (BAHDEC * (1 - positif(ART1731BIS) )) 315 | + BAHREP - (BAHDEP * (1 - positif(ART1731BIS) )) 316 | + BIHNOV - (BIHDNV * (1 - positif(ART1731BIS) )) 317 | + BIHNOC - (BIHDNC * (1 - positif(ART1731BIS) )) 318 | + BIHNOP - (BIHDNP * (1 - positif(ART1731BIS) )) 319 | + BICHREV - (min(BICHDEV,BICHDEV1731+0) * positif(ART1731BIS) + BICHDEV * (1 - ART1731BIS)) 320 | + BICHREC - (min(BICHDEC,BICHDEC1731+0) * positif(ART1731BIS) + BICHDEC * (1 - ART1731BIS)) 321 | + BICHREP - (min(BICHDEP,BICHDEP1731+0) * positif(ART1731BIS) + BICHDEP * (1 - ART1731BIS)) 322 | + BNHREV - (BNHDEV * (1 - positif(ART1731BIS) )) 323 | + BNHREC - (BNHDEC * (1 - positif(ART1731BIS) )) 324 | + BNHREP - (BNHDEP * (1 - positif(ART1731BIS) )) 325 | + ANOCEP - (min(DNOCEP,DNOCEP1731+0) * positif(ART1731BIS) + DNOCEP * (1 - ART1731BIS)) 326 | + ANOVEP - (min(DNOCEPC,DNOCEPC1731+0) * positif(ART1731BIS) + DNOCEPC * (1 - ART1731BIS)) 327 | + ANOPEP - (min(DNOCEPP,DNOCEPP1731+0) * positif(ART1731BIS) + DNOCEPP * (1 - ART1731BIS)) 328 | ; 329 | MAJ_CGA_AGA = arr(SUPREV * (BAFV + BAFC + BAFP)) 330 | + arr(SUPREV * max(0,BAHREV - (BAHDEV * (1 - positif(ART1731BIS) )))) 331 | + arr(SUPREV * max(0,BAHREC - (BAHDEC * (1 - positif(ART1731BIS) )))) 332 | + arr(SUPREV * max(0,BAHREP - (BAHDEP * (1 - positif(ART1731BIS) )))) 333 | + arr(SUPREV * max(0,BIHNOV - (BIHDNV * (1 - positif(ART1731BIS) )) )) 334 | + arr(SUPREV * max(0,BIHNOC - (BIHDNC * (1 - positif(ART1731BIS) )) )) 335 | + arr(SUPREV * max(0,BIHNOP - (BIHDNP * (1 - positif(ART1731BIS) )) )) 336 | + arr(SUPREV * max(0,BICHREV - (min(BICHDEV,BICHDEV1731+0) * positif(ART1731BIS) + BICHDEV * (1 - ART1731BIS)) )) 337 | + arr(SUPREV * max(0,BICHREC - (min(BICHDEC,BICHDEC1731+0) * positif(ART1731BIS) + BICHDEC * (1 - ART1731BIS)) )) 338 | + arr(SUPREV * max(0,BICHREP - (min(BICHDEP,BICHDEP1731+0) * positif(ART1731BIS) + BICHDEP * (1 - ART1731BIS)) )) 339 | + arr(SUPREV * max(0,BNHREV - (BNHDEV * (1 - positif(ART1731BIS) )))) 340 | + arr(SUPREV * max(0,BNHREC - (BNHDEC * (1 - positif(ART1731BIS) )))) 341 | + arr(SUPREV * max(0,BNHREP - (BNHDEP * (1 - positif(ART1731BIS) )))) 342 | + arr(SUPREV * max(0,ANOCEP - (min(DNOCEP,DNOCEP1731+0) * positif(ART1731BIS) + DNOCEP * (1 - ART1731BIS)))) 343 | + arr(SUPREV * max(0,ANOVEP - (min(DNOCEPC,DNOCEPC1731+0) * positif(ART1731BIS) + DNOCEPC * (1 - ART1731BIS)))) 344 | + arr(SUPREV * max(0,ANOPEP - (min(DNOCEPP,DNOCEPP1731+0) * positif(ART1731BIS) + DNOCEPP * (1 - ART1731BIS)))) 345 | ; 346 | TOT_CGA_AGA = DEC_CGA_AGA + MAJ_CGA_AGA; 347 | -------------------------------------------------------------------------------- /src/chap-52.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 507: 22 | application : bareme , iliad , batch ; 23 | 24 | TAUX1 = ((TX_BAR1 * (1 - V_ANC_BAR) + TX_BAR1A * V_ANC_BAR) - TX_BAR0 ) ; 25 | TAUX2 = (TX_BAR2 - (TX_BAR1 * (1 - V_ANC_BAR) + TX_BAR1A * V_ANC_BAR)) ; 26 | TAUX3 = (TX_BAR3 - TX_BAR2 ) ; 27 | TAUX4 = (TX_BAR4 - TX_BAR3 ) ; 28 | TAUX5 = (TX_BAR5 - TX_BAR4 ) ; 29 | 30 | regle 50700: 31 | application : bareme , iliad , batch ; 32 | pour x=0,5;y=1,2;z=1,2: 33 | DSxyz = max( QFxyz - (LIM_BAR1 * (1 - V_ANC_BAR) + LIM_BAR1A * V_ANC_BAR) , 0 ) * (TAUX1 / 100) 34 | + max( QFxyz - (LIM_BAR2 * (1 - V_ANC_BAR) + LIM_BAR2A * V_ANC_BAR) , 0 ) * (TAUX2 / 100) 35 | + max( QFxyz - (LIM_BAR3 * (1 - V_ANC_BAR) + LIM_BAR3A * V_ANC_BAR) , 0 ) * (TAUX3 / 100) 36 | + max( QFxyz - (LIM_BAR4 * (1 - V_ANC_BAR) + LIM_BAR4A * V_ANC_BAR) , 0 ) * (TAUX4 / 100) 37 | + max( QFxyz - (LIM_BAR5 * (1 - V_ANC_BAR) + LIM_BAR5A * V_ANC_BAR) , 0 ) * (TAUX5 / 100); 38 | 39 | regle 50702: 40 | application : iliad , batch ; 41 | WTXMARJ = (RB51) / ( NB1 * null(PLAFQF) + NB2 *null(1-PLAFQF)) ; 42 | TXMARJ = max ( positif (WTXMARJ - (LIM_BAR1 * (1 - V_ANC_BAR) + LIM_BAR1A * V_ANC_BAR)) * (TX_BAR1 * (1 - V_ANC_BAR) + TX_BAR1A * V_ANC_BAR) , 43 | max ( positif (WTXMARJ - (LIM_BAR2 * (1 - V_ANC_BAR) + LIM_BAR2A * V_ANC_BAR)) * TX_BAR2 , 44 | max ( positif (WTXMARJ - (LIM_BAR3 * (1 - V_ANC_BAR) + LIM_BAR3A * V_ANC_BAR)) * TX_BAR3 , 45 | max ( positif (WTXMARJ - (LIM_BAR4 * (1 - V_ANC_BAR) + LIM_BAR4A * V_ANC_BAR)) * TX_BAR4 , 46 | max ( positif (WTXMARJ - (LIM_BAR5 * (1 - V_ANC_BAR) + LIM_BAR5A * V_ANC_BAR)) * TX_BAR5 , 0 47 | ) 48 | ) 49 | ) 50 | ) 51 | ) 52 | 53 | * ( 1 - positif ( 54 | present ( NRBASE ) 55 | + present ( NRINET ) 56 | + present ( IPTEFP ) 57 | + present ( IPTEFN ) 58 | + present ( PRODOM ) 59 | + present ( PROGUY ) 60 | ) 61 | ) 62 | * (1- null(2 - V_REGCO)) 63 | * positif(IDRS2+IPQ1); 64 | 65 | 66 | 67 | regle 5071: 68 | application : bareme , iliad , batch ; 69 | pour y=1,2: 70 | DS0y4 = max( QF0y4 - (LIM_BAR1 * (1 - V_ANC_BAR) + LIM_BAR1A * V_ANC_BAR) , 0 ) * (TAUX1 /100) 71 | + max( QF0y4 - (LIM_BAR2 * (1 - V_ANC_BAR) + LIM_BAR2A * V_ANC_BAR) , 0 ) * (TAUX2 /100) 72 | + max( QF0y4 - (LIM_BAR3 * (1 - V_ANC_BAR) + LIM_BAR3A * V_ANC_BAR) , 0 ) * (TAUX3 /100) 73 | + max( QF0y4 - (LIM_BAR4 * (1 - V_ANC_BAR) + LIM_BAR4A * V_ANC_BAR) , 0 ) * (TAUX4 /100) 74 | + max( QF0y4 - (LIM_BAR5 * (1 - V_ANC_BAR) + LIM_BAR5A * V_ANC_BAR) , 0 ) * (TAUX5 /100); 75 | pour x=0,5;y=1,2: 76 | DSxy5 = max( QFxy5 - (LIM_BAR1 * (1 - V_ANC_BAR) + LIM_BAR1A * V_ANC_BAR) , 0 ) * (TAUX1 /100) 77 | + max( QFxy5 - (LIM_BAR2 * (1 - V_ANC_BAR) + LIM_BAR2A * V_ANC_BAR) , 0 ) * (TAUX2 /100) 78 | + max( QFxy5 - (LIM_BAR3 * (1 - V_ANC_BAR) + LIM_BAR3A * V_ANC_BAR) , 0 ) * (TAUX3 /100) 79 | + max( QFxy5 - (LIM_BAR4 * (1 - V_ANC_BAR) + LIM_BAR4A * V_ANC_BAR) , 0 ) * (TAUX4 /100) 80 | + max( QFxy5 - (LIM_BAR5 * (1 - V_ANC_BAR) + LIM_BAR5A * V_ANC_BAR) , 0 ) * (TAUX5 /100); 81 | pour y=1,2: 82 | DS0y6 = max( QF0y6 - (LIM_BAR1 * (1 - V_ANC_BAR) + LIM_BAR1A * V_ANC_BAR) , 0 ) * (TAUX1 /100) 83 | + max( QF0y6 - (LIM_BAR2 * (1 - V_ANC_BAR) + LIM_BAR2A * V_ANC_BAR) , 0 ) * (TAUX2 /100) 84 | + max( QF0y6 - (LIM_BAR3 * (1 - V_ANC_BAR) + LIM_BAR3A * V_ANC_BAR) , 0 ) * (TAUX3 /100) 85 | + max( QF0y6 - (LIM_BAR4 * (1 - V_ANC_BAR) + LIM_BAR4A * V_ANC_BAR) , 0 ) * (TAUX4 /100) 86 | + max( QF0y6 - (LIM_BAR5 * (1 - V_ANC_BAR) + LIM_BAR5A * V_ANC_BAR) , 0 ) * (TAUX5 /100); 87 | regle 508: 88 | application : bareme , iliad , batch ; 89 | NB1 = NBPT ; 90 | NB2 = 1 + BOOL_0AM + BOOL_0AZ * V_0AV ; 91 | regle 5080: 92 | application : bareme , iliad , batch ; 93 | pour y=1,2;z=1,2: 94 | QF0yz = arr(RB0z) / NBy; 95 | pour y=1,2;z=1,2: 96 | QF5yz = arr(RB5z) / NBy; 97 | pour y=1,2: 98 | QF0y4 = arr(RB04) / NBy; 99 | pour x=0,5;y=1,2: 100 | QFxy5 = arr(RBx5) / NBy; 101 | pour y=1,2: 102 | QF0y6 = arr(RB06) / NBy; 103 | 104 | regle 66991: 105 | application : iliad, batch ; 106 | 107 | RNIBAR13 = ( (13465 * positif(positif(V_ANREV - V_0DA - 65) + positif(V_0AP + 0)) 108 | + 12353 * (1 - positif(positif(V_ANREV - V_0DA - 65) + positif(V_0AP + 0)))) * null(NBPT - 1) 109 | + 14414 * null(NBPT - 1.25) 110 | + 15917 * null(NBPT - 1.5) 111 | + 17420 * null(NBPT - 1.75) 112 | + 18922 * null(NBPT - 2) 113 | + 20425 * null(NBPT - 2.25) 114 | + 21928 * null(NBPT - 2.5) 115 | + (23581 * positif(positif(V_ANREV - V_0DA - 65) + positif(V_0AP + 0)) * (1 - BOOL_0AM) 116 | + 23431 * (1 - positif(positif(V_ANREV - V_0DA - 65) + positif(V_0AP + 0)))) * null(NBPT - 2.75) 117 | + 24933 * null(NBPT - 3) 118 | + 26436 * null(NBPT - 3.25) 119 | + 27939 * null(NBPT - 3.5) 120 | + 29442 * null(NBPT - 3.75) 121 | + 30944 * null(NBPT - 4) 122 | + 32447 * null(NBPT - 4.25) 123 | + 33950 * null(NBPT - 4.5) 124 | + 35453 * null(NBPT - 4.75) 125 | + 36955 * null(NBPT - 5) 126 | + 38458 * null(NBPT - 5.25) 127 | + 39961 * null(NBPT - 5.5) 128 | + 41464 * null(NBPT - 5.75) 129 | + 42966 * null(NBPT - 6) 130 | + 44470 * null(NBPT - 6.25) 131 | + 45980 * null(NBPT - 6.5) 132 | + 47476 * null(NBPT - 6.75) 133 | + 48980 * null(NBPT - 7) 134 | + 50480 * null(NBPT - 7.25) 135 | + 51985 * null(NBPT - 7.5) 136 | + 53487 * null(NBPT - 7.75) 137 | + 54990 * null(NBPT - 8) 138 | + 56493 * null(NBPT - 8.25) 139 | + 57995 * null(NBPT - 8.5) 140 | + 59497 * null(NBPT - 8.75) 141 | + 61000 * null(NBPT - 9) 142 | + 62504 * null(NBPT - 9.25) 143 | + 64005 * null(NBPT - 9.5) 144 | + 65515 * null(NBPT - 9.75) 145 | + 67010 * null(NBPT - 10) ) ; 146 | 147 | CODMESGOUV = positif(NBPT - 10) + positif(LIG74 + LIGTTPVQ) + null(2 - V_REGCO) + null(4 - V_REGCO) + positif(CESSASSV + CESSASSC + PCAPTAXV + PCAPTAXC + LOYELEV + 0) 148 | + positif(IPROP + AVFISCOPTER + IPREP + IPPRICORSE) ; 149 | 150 | MESGOUV = ( 1 * null(IDRS3 - IDEC) * positif_ou_nul(RNI - RNIBAR13) 151 | + 2 * positif(IDRS3 - IDEC + 0) * positif(IDEC + 0)) * (1 - positif(CODMESGOUV)) * (1 - positif(RNIBAR13 - RNI)) 152 | + 3 * positif(CODMESGOUV + positif(RNIBAR13 - RNI) + (1 - positif(null(IDRS3 - IDEC) * positif_ou_nul(RNI - RNIBAR13) + positif(IDRS3 - IDEC + 0) * positif(IDEC + 0)))) ; 153 | 154 | MESGOUV2 = ( 4 * null(IDRS3 - IDEC) * positif_ou_nul(RNI - RNIBAR13) 155 | + 5 * positif(IDRS3 - IDEC + 0) * positif(IDEC + 0) 156 | + 6 * positif(RNIBAR13 - RNI)) * (1 - positif(CODMESGOUV)) 157 | + 7 * positif(CODMESGOUV + (1 - positif(null(IDRS3 - IDEC) * positif_ou_nul(RNI - RNIBAR13) + positif(IDRS3 - IDEC + 0) * positif(IDEC + 0) + positif(RNIBAR13 - RNI)))) ; 158 | 159 | 160 | -------------------------------------------------------------------------------- /src/chap-6.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | # 22 | 23 | #### # # ## ##### # ##### ##### ###### ##### 24 | # # # # # # # # # # # # # # 25 | # ###### # # # # # # # # ##### # #### 26 | # # # ###### ##### # # ##### # # # 27 | # # # # # # # # # # # # # # 28 | #### # # # # # # # # # ###### #### ##### 29 | # 30 | # 31 | # 32 | # 33 | # 34 | # 35 | # 36 | # 37 | # CALCUL DU NOMBRE DE PARTS 38 | # 39 | # 40 | # 41 | # 42 | # 43 | regle 601: 44 | application : batch , iliad ; 45 | NBPT = ((NSM + NPA + NIN + NSP + NBQAR)* 10)/10 ; 46 | 47 | NBPOTE = V_0CF + V_0CH + V_0CR + V_0DJ + V_0DN + V_0DP ; 48 | 49 | NBFOTH = (1 + BOOL_0AM) + V_0CF + (V_0CH/2) + V_0CR + V_0DJ + V_0DN ; 50 | 51 | regle 6010: 52 | application : bareme ; 53 | NBPT = (1 - present(V_9VV)) * ((NSM + NPA + NIN + NSP + NBQAR)* 10)/10 54 | + V_9VV ; 55 | regle 6011: 56 | application : bareme , iliad , batch ; 57 | NSM = 1 + BOOL_0AM + V_0AV * min(BOOL_0AZ + EAC + V_0CH + V_0CR, 1 ) + 58 | ( V_0AV * BOOL_0AZ * V_0AW * (1 - V_0AP) * (1 - V_0AF) / 2 ) ; 59 | regle 6012: 60 | application : bareme , iliad , batch ; 61 | NPA = PAC - 0.5 * min( PAC, 2 ) ; 62 | regle 60121: 63 | application : bareme , iliad , batch ; 64 | PAC = EAC + V_0CR; 65 | regle 60122: 66 | application : bareme ; 67 | EAC = ((V_0CF + V_0DJ) * (1 - present(V_9XX))) + V_9XX ; 68 | regle 601220: 69 | application : batch , iliad ; 70 | EAC = (V_0CF + V_0DJ) ; 71 | regle 6013: 72 | application : bareme , iliad , batch ; 73 | NIN = ( V_0AP + V_0AF + V_0CG + V_0CR ) * 0.5; 74 | regle 6014: 75 | application : bareme , iliad , batch ; 76 | NSP = NPS + NSA + NCC; 77 | regle 60141: 78 | application : bareme , iliad , batch ; 79 | NCC = V_0AS * BOOL_0AM * (1 - positif(V_0AP + V_0AF)) * 0.5 * 80 | positif(max( AGV + 1 - LIM_AGE_LET_S, AGC + 1 - LIM_AGE_LET_S )); 81 | regle 60142: 82 | application : bareme , iliad , batch ; 83 | NPS = positif(PAC) * V_0BT * positif( 2 - NSM ) * 0.5 ; 84 | regle 60143: 85 | application : bareme , iliad , batch ; 86 | NSA = (1 - positif(PAC+V_0CH)) 87 | * min( V_0AG 88 | + (V_0AL * (1 - positif (V_0AN))) * ( 1 - positif(positif(V_0AW)*positif_ou_nul(AGV-LIM_AGE_LET_S))) 89 | + V_0AW * positif(max(AGV + 1 - LIM_AGE_LET_S, AGC + 1 - LIM_AGE_LET_S)) 90 | , 1 ) 91 | * ( 1 - V_0AP ) * positif(2 - NSM) * 0.5; 92 | 93 | NSA2 = min( (1 - positif(PAC+V_0CH)) 94 | * 95 | (null(SFUTILE - 14) 96 | + null (SFUTILE - 7) 97 | + null (SFUTILE - 15) * (1-positif(NIN)) 98 | ) 99 | + 100 | null(SFUTILE -7) * BOOL_0AZ * V_0AV 101 | , 1) 102 | * 0.5; 103 | regle 60200: 104 | application : bareme , iliad , batch ; 105 | 106 | 107 | BOOL_0BT = positif ( V_0BT+0 ) * positif ( V_0AC + V_0AD + 0); 108 | 109 | NBQAR1 = null (V_0CF+V_0CR+V_0DJ+0) * ( 1/2 * (V_0CH-2) * positif (V_0CH- 2) 110 | + 1/4 * positif (V_0CH+0) 111 | + 1/4 * positif(V_0CH-1) 112 | ); 113 | NBQAR2 = null(V_0CF+V_0CR+V_0DJ-1) * (1/2 * (V_0CH -1 ) * positif(V_0CH -1) 114 | + 1/4 * positif (V_0CH+0) 115 | ); 116 | NBQAR3 = positif_ou_nul(V_0CF+V_0CR+V_0DJ-2) * 1/2 * V_0CH ; 117 | 118 | NBQAR4 = 1/4 * V_0CI ; 119 | 120 | NBQART = BOOL_0BT * null(V_0CF+V_0CR+V_0DJ+0) 121 | * (1/4 * null (V_0CH -1) + 1/2 * positif_ou_nul (V_0CH - 2)) ; 122 | 123 | NBQAR = NBQAR1 + NBQAR2 + NBQAR3 + NBQAR4 + NBQART; 124 | -------------------------------------------------------------------------------- /src/chap-81.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | # 22 | # REVENUS CATEGORIELS NETS 23 | # 24 | # 25 | regle 811: 26 | application : iliad , batch ; 27 | pour i=V,C,1,2,3,4: 28 | TSBNi = TSHALLOi + ALLOi; 29 | TSHALLOP=TSHALLO1+TSHALLO2+TSHALLO3+TSHALLO4; 30 | ALLOP=ALLO1+ALLO2+ALLO3+ALLO4; 31 | TSBNP=TSHALLOP+ALLOP; 32 | 33 | pour i=V,C: 34 | 2TSNi = CARTSi + REMPLAi; 35 | pour i=1,2,3,4: 36 | 2TSNi = CARTSPi + REMPLAPi; 37 | EXTSV = TSBNV + BPCOSAV + GLDGRATV + 2TSNV; 38 | EXTSC = TSBNC + BPCOSAC + GLDGRATC + 2TSNC; 39 | GATASAV = BPCOSAV + GLDGRATV ; 40 | GATASAC = BPCOSAC + GLDGRATC ; 41 | 42 | pour i=1..4: 43 | EXTSi = TSBNi + 2TSNi; 44 | TSBV = EXTSV + somme(x=1..3:GLDxV)+CODDAJ+CODEAJ; 45 | TSBC = EXTSC + somme(x=1..3:GLDxC)+CODDBJ+CODEBJ; 46 | pour i=1,2,3,4: 47 | TSBi = EXTSi; 48 | TSBP = somme(i=1..4:TSBi); 49 | pour i=V,C,1..4: 50 | PRBi = PRBRi + PALIi + PENINi; 51 | 52 | 2PRBV = CARPEV + PENSALV + CODRAZ; 53 | 2PRBC = CARPEC + PENSALC + CODRBZ; 54 | 2PRB1 = CARPEP1 + PENSALP1 + CODRCZ; 55 | 2PRB2 = CARPEP2 + PENSALP2 + CODRDZ; 56 | 2PRB3 = CARPEP3 + PENSALP3 + CODREZ; 57 | 2PRB4 = CARPEP4 + PENSALP4 + CODRFZ; 58 | pour i=V,C: 59 | EXPRi = PRBi + 2PRBi + PEBFi; 60 | pour i=1..4: 61 | EXPRi = PRBi + 2PRBi + PEBFi; 62 | pour i = V,C,1..4: 63 | EXSPBi = EXTSi + EXPRi ; 64 | regle 812: 65 | application : iliad , batch ; 66 | pour i = V,C,1..4: 67 | TPS10i = arr (TSBi * TX_DEDFORFTS /100); 68 | pour i = V,C,P: 69 | PTPS10i = arr (PERPSALi * TX_DEDFORFTS /100); 70 | pour i = V,C,1..4: 71 | DFNi = min( PLAF_DEDFORFTS , TPS10i ); 72 | pour i = V,C,P: 73 | PDFNi = min( PLAF_DEDFORFTS , PTPS10i ); 74 | regle 813: 75 | application : iliad , batch ; 76 | pour i = V,C,1..4: 77 | DEDMINi = positif(DETSi)* MIN_DEMEMPLOI + (1- positif(DETSi))* MIN_DEDSFORFTS; 78 | pour i = V,C: 79 | PDEDMINi = DEDMINi; 80 | PDEDMINP = positif(DETS1)* MIN_DEMEMPLOI 81 | + (1- positif(DETS1))* MIN_DEDSFORFTS; 82 | 83 | pour i = V,C,1..4: 84 | 10MINSi= max( min(TSBi,DEDMINi) , DFNi ); 85 | pour i = V,C,P: 86 | P10MINSi= max( min(PERPSALi,PDEDMINi) , PDFNi ); 87 | pour i = V,C,1..4: 88 | IND_10MIN_0i = positif(DEDMINi - DFNi ) * positif (TSBi ); 89 | pour i = V,C,P: 90 | PIND_10MIN_0i = positif(PDEDMINi - PDFNi ) * positif (PERPSALi ); 91 | pour i = V,C,1..4 : 92 | IND_MINi = 1 - positif( IND_10MIN_0i ); 93 | pour i = V,C,P : 94 | PIND_MINi = 1 - positif( PIND_10MIN_0i ); 95 | regle 814: 96 | application : iliad , batch ; 97 | 98 | FRNP = FRN1 + FRN2 + FRN3 + FRN4; 99 | 10MINSP = 10MINS1 + 10MINS2 + 10MINS3 + 10MINS4; 100 | FRDPROVV = TSBNV + PRV + PALIV - APRV; 101 | FRDPROVC = TSBNC + PRC + PALIC - APRC; 102 | FRDPROV1 = TSBN1 + PRBR1 + PALI1 - APR1; 103 | FRDPROV2 = TSBN2 + PRBR2 + PALI2 - APR2; 104 | FRDPROV3 = TSBN3 + PRBR3 + PALI3 - APR3; 105 | FRDPROV4 = TSBN4 + PRBR4 + PALI4 - APR4; 106 | FRDPROVP = FRDPROV1 +FRDPROV2 +FRDPROV3 +FRDPROV4; 107 | FRDP = (1-positif(PREM8_11)) * FRNP * positif(FRNP - 10MINSP) 108 | + null(4-V_IND_TRAIT) * positif(PREM8_11) * min(FRNP,FRDPROVP) 109 | + null(5-V_IND_TRAIT) * positif(PREM8_11) * min(FRNP,max(FRDPROVPP2,FRDPROVP1731)); 110 | pour i = V,C: 111 | FRDi = (1-positif(PREM8_11)) * FRNi * positif(FRNi - 10MINSi) 112 | + null(4-V_IND_TRAIT) * positif(PREM8_11) * min(FRNi,FRDPROVi) 113 | + null(5-V_IND_TRAIT) * positif(PREM8_11) * min(FRNi,min(FRDPROVi,max(FRDPROViP2,FRDPROVi1731))); 114 | FRD1 = (1-positif(PREM8_11)) * FRN1 * positif(FRN1 - 10MINS1) 115 | + null(4-V_IND_TRAIT) * (positif(PREM8_11) * min(FRN1,FRDPROV1) * positif(FRN2+FRN3+FRN4) 116 | + positif(PREM8_11) * max(0,FRDP) * (1-positif(FRN2+FRN3+FRN4))) 117 | + null(5-V_IND_TRAIT) * (positif(PREM8_11) * min(FRN1,min(FRDPROV1,max(FRDPROV1P2,FRDPROV11731))) * positif(FRN2+FRN3+FRN4) 118 | + positif(PREM8_11) * max(0,FRDP) * (1-positif(FRN2+FRN3+FRN4))); 119 | FRD2 = (1-positif(PREM8_11)) * FRN2 * positif(FRN2 - 10MINS2) 120 | + null(4-V_IND_TRAIT) * (positif(PREM8_11) * min(FRN2,FRDPROV2) * positif(FRN3+FRN4) 121 | + positif(PREM8_11) * max(0,FRDP-FRD1) * (1-positif(FRN3+FRN4))) 122 | + null(5-V_IND_TRAIT) * (positif(PREM8_11) * min(FRN2,min(FRDPROV2,max(FRDPROV2P2,FRDPROV21731))) * positif(FRN3+FRN4) 123 | + positif(PREM8_11) * max(0,FRDP-FRD1) * (1-positif(FRN3+FRN4))); 124 | FRD3 = (1-positif(PREM8_11)) * FRN3 * positif(FRN3 - 10MINS3) 125 | + null(4-V_IND_TRAIT) * (positif(PREM8_11) * min(FRN3,FRDPROV3) * positif(FRN4) 126 | + positif(PREM8_11) * max(0,FRDP-FRD1-FRD2) * (1-positif(FRN4))) 127 | + null(5-V_IND_TRAIT) * (positif(PREM8_11) * min(FRN3,min(FRDPROV3,max(FRDPROV3P2,FRDPROV31731))) * positif(FRN4) 128 | + positif(PREM8_11) * max(0,FRDP-FRD1-FRD2) * (1-positif(FRN4))) 129 | ; 130 | FRD4 = max(0,FRDP - FRD1 - FRD2 - FRD3); 131 | pour i = V,C,1..4: 132 | FRDAi = FRNi * positif (FRNi - 10MINSi); 133 | PFRDV = (FRDV+COD1AE) * positif ((FRDV+COD1AE) - P10MINSV); 134 | PFRDC = (FRDC+COD1BE) * positif ((FRDC+COD1BE) - P10MINSC); 135 | PFRDP = (FRD1+COD1CE) * positif ((FRD1+COD1CE) - P10MINSP); 136 | pour i = V,C,1..4: 137 | IND_10i = positif_ou_nul( 10MINSi - FRDi) ; 138 | PIND_10V = positif_ou_nul( P10MINSV - (FRDV+COD1AE)) ; 139 | PIND_10C = positif_ou_nul( P10MINSC - (FRDC+COD1BE)) ; 140 | PIND_10P = positif_ou_nul( P10MINSP - (FRD1+COD1CE)) ; 141 | pour i = V,C,1..4: 142 | FPTi = max(FRDi, 10MINSi); 143 | pour i = V,C,1..4: 144 | INDEFTSi = positif_ou_nul(TSBi - FRDi); 145 | pour i = V,C,P: 146 | PFPTi = max(PFRDi, P10MINSi); 147 | pour i = V,C,1..4: 148 | D10Mi = IND_MINi *DFNi 149 | + (1 - IND_MINi)* 10MINSi ; 150 | pour i = V,C,P: 151 | PD10Mi = PIND_MINi *PDFNi 152 | + (1 - PIND_MINi)* P10MINSi ; 153 | pour i = V,C,1..4: 154 | REP10i = IND_10i * D10Mi + (1-IND_10i) * FPTi ; 155 | pour i = V,C,P: 156 | PREP10i = PIND_10i * PD10Mi + (1-PIND_10i) * PFPTi ; 157 | ABTS1AJ=positif(TSHALLOV) * arr(REP10V*(TSHALLOV)/TSBV); 158 | ABTS1AP=positif(ALLOV) * ( 159 | positif(BPCOSAV+GLDGRATV+CARTSV+REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V) * arr(REP10V*(ALLOV)/TSBV) 160 | + (1-positif(BPCOSAV+GLDGRATV+CARTSV+REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTS1AJ) 161 | ); 162 | ABTS3VJ=positif(BPCOSAV) * ( 163 | positif(GLDGRATV+CARTSV+REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V) * arr(REP10V*(BPCOSAV)/TSBV) 164 | + (1-positif(GLDGRATV+CARTSV+REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTS1AJ-ABTS1AP) 165 | ); 166 | ABTS1TT=positif(GLDGRATV) *( 167 | positif(CARTSV+REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V) * arr(REP10V*(GLDGRATV)/TSBV) 168 | + (1-positif(CARTSV+REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTS1AJ-ABTS1AP-ABTS3VJ) 169 | ); 170 | ABTSRAJ=positif(CARTSV) *( 171 | positif(REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V) * arr(REP10V*(CARTSV)/TSBV) 172 | + (1-positif(REMPLAV+CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTS1AJ-ABTS1AP-ABTS3VJ-ABTS1TT) 173 | ); 174 | ABTSRAP=positif(REMPLAV) * ( 175 | positif(CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V) * arr(REP10V*(REMPLAV)/TSBV) 176 | + (1-positif(CODDAJ+CODEAJ+GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTS1AJ-ABTS1AP-ABTS1TT-ABTS3VJ-ABTSRAJ) 177 | ); 178 | ABTSV = ABTS1AJ + ABTS1AP +ABTS3VJ +ABTS1TT +ABTSRAJ+ABTSRAP; 179 | ABDOMDAJ = positif(CODDAJ) * 180 | (positif(CODEAJ+GLD1V+GLD2V+GLD3V) * arr(REP10V*CODDAJ/TSBV) 181 | + (1-positif(CODEAJ+GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTSV))+0; 182 | ABDOMEAJ = positif(CODEAJ) * 183 | (positif(GLD1V+GLD2V+GLD3V) * arr(REP10V*CODEAJ/TSBV) 184 | + (1-positif(GLD1V+GLD2V+GLD3V)) * max(0,REP10V-ABTSV-ABDOMDAJ))+0; 185 | ABGL1V = positif(GLD1V) * 186 | (positif(GLD2V+GLD3V) * arr(REP10V*GLD1V/TSBV) 187 | + (1-positif(GLD2V+GLD3V)) * max(0,REP10V-ABTSV-ABDOMDAJ-ABDOMEAJ))+0; 188 | ABGL2V = positif(GLD2V) * 189 | (positif(GLD3V) * arr(REP10V*GLD2V/TSBV) 190 | + (1-positif(GLD3V)) * max(0,REP10V-ABTSV-ABDOMDAJ-ABDOMEAJ-ABGL1V))+0; 191 | ABGL3V = max(0,REP10V-ABTSV-ABDOMDAJ-ABDOMEAJ-ABGL1V-ABGL2V)+0; 192 | ABTS1BJ=arr(REP10C*(TSHALLOC)/TSBC); 193 | ABTS1BP=positif(ALLOC) * ( 194 | positif(BPCOSAC+GLDGRATC+CARTSC+REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C) * arr(REP10C*(ALLOC)/TSBC) 195 | + (1-positif(BPCOSAC+GLDGRATC+CARTSC+REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTS1BJ) 196 | ); 197 | ABTS3VK=positif(BPCOSAC) * ( 198 | positif(GLDGRATC+CARTSC+REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C) * arr(REP10C*(BPCOSAC)/TSBC) 199 | + (1-positif(GLDGRATC+CARTSC+REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTS1BJ-ABTS1BP) 200 | ); 201 | ABTS1UT=positif(GLDGRATC) * ( 202 | positif(CARTSC+REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C) * arr(REP10C*(GLDGRATC)/TSBC) 203 | + (1-positif(CARTSC+REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTS1BJ-ABTS1BP-ABTS3VK) 204 | ); 205 | ABTSRBJ=positif(CARTSC) * ( 206 | positif(REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C) * arr(REP10C*(CARTSC)/TSBC) 207 | + (1-positif(REMPLAC+CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTS1BJ-ABTS1BP-ABTS3VK-ABTS1UT) 208 | ); 209 | ABTSRBP=positif(REMPLAC) * ( 210 | positif(CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C) * arr(REP10C*(REMPLAC)/TSBC) 211 | + (1-positif(CODDBJ+CODEBJ+GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTS1BJ-ABTS1BP-ABTS3VK-ABTS1UT-ABTSRBJ) 212 | ); 213 | ABTSC = ABTS1BJ + ABTS1BP +ABTS3VK +ABTS1UT +ABTSRBJ+ABTSRBP; 214 | ABDOMDBJ = positif(CODDBJ) * 215 | (positif(CODEBJ+GLD1C+GLD2C+GLD3C) * arr(REP10C*CODDBJ/TSBC) 216 | + (1-positif(CODEBJ+GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTSC))+0; 217 | ABDOMEBJ = positif(CODEBJ) * 218 | (positif(GLD1C+GLD2C+GLD3C) * arr(REP10C*CODEBJ/TSBC) 219 | + (1-positif(GLD1C+GLD2C+GLD3C)) * max(0,REP10C-ABTSC-ABDOMDBJ))+0; 220 | ABGL1C = positif(GLD1C) * 221 | (positif(GLD2C+GLD3C) * arr(REP10C*GLD1C/TSBC) 222 | + (1-positif(GLD2C+GLD3C)) * max(0,REP10C-ABTSC-ABDOMDBJ-ABDOMEBJ))+0; 223 | ABGL2C = positif(GLD2C) * 224 | (positif(GLD3C) * arr(REP10C*GLD2C/TSBC) 225 | + (1-positif(GLD3C)) * max(0,REP10C-ABTSC-ABDOMDBJ-ABDOMEBJ-ABGL1C))+0; 226 | ABGL3C = max(0,REP10C-ABTSC-ABDOMDBJ-ABDOMEBJ-ABGL1C-ABGL2C)+0; 227 | ABTS1CJ=arr(REP101*(TSHALLO1)/TSB1); 228 | ABTS1CP=positif(ALLO1) * ( 229 | positif(CARTSP1+REMPLAP1) * arr(REP101*(ALLO1)/TSB1) 230 | + (1-positif(CARTSP1+REMPLAP1)) * max(0,REP101-ABTS1CJ)); 231 | ABTSRCJ=positif(CARTSP1) * ( 232 | positif(REMPLAP1) * arr(REP101*(CARTSP1)/TSB1) 233 | + (1-positif(REMPLAP1)) * max(0,REP101-ABTS1CJ-ABTS1CP)); 234 | ABTSRCP=max(0,REP101 - (ABTS1CJ +ABTS1CP +ABTSRCJ))+0; 235 | ABTS1DJ=arr(REP102*(TSHALLO2)/TSB2); 236 | ABTS1DP=positif(ALLO2) * ( 237 | positif(CARTSP2+REMPLAP2) * arr(REP102*(ALLO2)/TSB2) 238 | + (1-positif(CARTSP2+REMPLAP2)) * max(0,REP102-ABTS1DJ)); 239 | ABTSRDJ=positif(CARTSP2) * ( 240 | positif(REMPLAP2) * arr(REP102*(CARTSP2)/TSB2) 241 | + (1-positif(REMPLAP2)) * max(0,REP102-ABTS1DJ-ABTS1DP)); 242 | ABTSRDP=max(0,REP102 - (ABTS1DJ +ABTS1DP +ABTSRDJ))+0; 243 | ABTS1EJ=arr(REP103*(TSHALLO3)/TSB3); 244 | ABTS1EP=positif(ALLO3) * ( 245 | positif(CARTSP3+REMPLAP3) * arr(REP103*(ALLO3)/TSB3) 246 | + (1-positif(CARTSP3+REMPLAP3)) * max(0,REP103-ABTS1EJ)); 247 | ABTSREJ=positif(CARTSP3) * ( 248 | positif(REMPLAP3) * arr(REP103*(CARTSP3)/TSB3) 249 | + (1-positif(REMPLAP3)) * max(0,REP103-ABTS1EJ-ABTS1EP)); 250 | ABTSREP=max(0,REP103 - (ABTS1EJ +ABTS1EP +ABTSREJ)) +0; 251 | ABTS1FJ=arr(REP104*(TSHALLO4)/TSB4); 252 | ABTS1FP=positif(ALLO4) * ( 253 | positif(CARTSP4+REMPLAP4) * arr(REP104*(ALLO4)/TSB4) 254 | + (1-positif(CARTSP4+REMPLAP4)) * max(0,REP104-ABTS1FJ)); 255 | ABTSRFJ=positif(CARTSP4) * ( 256 | positif(REMPLAP4) * arr(REP104*(CARTSP4)/TSB4) 257 | + (1-positif(REMPLAP4)) * max(0,REP104-ABTS1FJ-ABTS1FP)); 258 | ABTSRFP=max(0,REP104 - (ABTS1FJ +ABTS1FP +ABTSRFJ))+0; 259 | regle 817: 260 | application : iliad , batch ; 261 | ABGLTV = somme (x=1..3: ABGLxV)+ABDOMDAJ + ABDOMEAJ; 262 | ABGLTC = somme (x=1..3: ABGLxC)+ABDOMDBJ + ABDOMEBJ; 263 | regle 8178888: 264 | application : iliad , batch ; 265 | TSN1AJ = TSHALLOV - ABTS1AJ; 266 | TSN1AP = ALLOV - ABTS1AP; 267 | TSN3VJ = BPCOSAV - ABTS3VJ; 268 | TSN1TT = GLDGRATV - ABTS1TT; 269 | TSNRAJ = (CARTSV - ABTSRAJ) ; 270 | TSNRAP = (REMPLAV - ABTSRAP); 271 | TSNDAJ = (CODDAJ - ABDOMDAJ); 272 | TSNEAJ = (CODEAJ - ABDOMEAJ); 273 | TSNGL1V = (GLD1V - ABGL1V); 274 | TSNGL2V = (GLD2V - ABGL2V); 275 | TSNGL3V = (GLD3V - ABGL3V); 276 | TSN1BJ = TSHALLOC - ABTS1BJ; 277 | TSN1BP = ALLOC - ABTS1BP; 278 | TSN3VK = BPCOSAC - ABTS3VK; 279 | TSN1UT = GLDGRATC - ABTS1UT; 280 | TSNRBJ = (CARTSC - ABTSRBJ); 281 | TSNRBP = (REMPLAC - ABTSRBP); 282 | TSNDBJ = (CODDBJ - ABDOMDBJ); 283 | TSNEBJ = (CODEBJ - ABDOMEBJ); 284 | TSNGL1C = (GLD1C - ABGL1C); 285 | TSNGL2C = (GLD2C - ABGL2C); 286 | TSNGL3C = (GLD3C - ABGL3C); 287 | TSN1CJ = TSHALLO1 - ABTS1CJ; 288 | TSN1CP = ALLO1 - ABTS1CP; 289 | TSNRCJ = (CARTSP1 - ABTSRCJ); 290 | TSNRCP = (REMPLAP1 - ABTSRCP); 291 | TSN1DJ = TSHALLO2 - ABTS1DJ; 292 | TSN1DP = ALLO2 - ABTS1DP; 293 | TSNRDJ = (CARTSP2 - ABTSRDJ); 294 | TSNRDP = (REMPLAP2 - ABTSRDP); 295 | TSN1EJ = TSHALLO3 - ABTS1EJ; 296 | TSN1EP = ALLO3 - ABTS1EP; 297 | TSNREJ = (CARTSP3 - ABTSREJ); 298 | TSNREP = (REMPLAP3 - ABTSREP); 299 | TSN1FJ = TSHALLO4 - ABTS1FJ; 300 | TSN1FP = ALLO4 - ABTS1FP; 301 | TSNRFJ = (CARTSP4 - ABTSRFJ); 302 | TSNRFP = (REMPLAP4 - ABTSRFP); 303 | regle 818: 304 | application : iliad , batch ; 305 | pour i = V,C,1,2,3,4: 306 | PLRi = min ( MIN_DEDPR , EXPRi ); 307 | pour i = V,C,1,2,3,4: 308 | APBi = max( PLRi , (EXPRi*TX_DEDPER/100)); 309 | pour i = V,C,1,2,3,4: 310 | IND_APBi = positif_ou_nul(PLRi- (EXPRi * TX_DEDPER/100)); 311 | PL_PB = arr(PLAF_DEDPRFOYER -somme (i=V,C,1..4: APBi * IND_APBi)); 312 | regle 819: 313 | application : iliad , batch ; 314 | pour i = V,C,1,2,3,4: 315 | ABPRi = arr ( (1 - IND_APBi) * 316 | min(APBi,(PL_PB * APBi / somme(x=V,C,1..4:APBx * (1 - IND_APBx)))) 317 | + IND_APBi * APBi ); 318 | regle 8110: 319 | application : iliad , batch ; 320 | APRV = IND_APBV * ABPRV 321 | + (1-IND_APBV)* min ( ABPRV , PL_PB); 322 | APRC = IND_APBC * ABPRC 323 | + (1-IND_APBC)* min ( ABPRC , PL_PB - (1-IND_APBV)*APRV ); 324 | APR1 = IND_APB1 * ABPR1 325 | + (1-IND_APB1)* min ( ABPR1 , PL_PB - (1-IND_APBV)*APRV 326 | - (1-IND_APBC)*APRC); 327 | APR2 = IND_APB2 * ABPR2 328 | + (1-IND_APB2)* min ( ABPR2 , PL_PB - (1-IND_APBV)*APRV 329 | - (1-IND_APBC)*APRC - (1-IND_APB1)*APR1 ); 330 | APR3 = IND_APB3 * ABPR3 331 | + (1-IND_APB3)* min ( ABPR3 , PL_PB - (1-IND_APBV)*APRV 332 | - (1-IND_APBC)*APRC - (1-IND_APB1)*APR1 333 | - (1-IND_APB2)*APR2 ); 334 | APR4 = IND_APB4 * ABPR4 335 | + (1-IND_APB4)* min ( ABPR4 , PL_PB - (1-IND_APBV)*APRV 336 | - (1-IND_APBC)*APRC - (1-IND_APB1)*APR1 337 | - (1-IND_APB2)*APR2 - (1-IND_APB3)*APR3 ); 338 | regle 8111: 339 | application : iliad , batch ; 340 | pour i = V,C,1,2,3,4: 341 | PRNNi = EXPRi - APRi; 342 | PRNNP = PRNN1 + PRNN2 + PRNN3 + PRNN4; 343 | regle 8112: 344 | application : iliad , batch ; 345 | TSNTV = TSN1AJ+TSN1AP+TSN3VJ+TSN1TT+TSNRAJ+TSNRAP 346 | +TSNDAJ+TSNEAJ+TSNGL1V+TSNGL2V+TSNGL3V ; 347 | TSNTC = TSN1BJ+TSN1BP+TSN3VK+TSN1UT+TSNRBJ+TSNRBP 348 | +TSNDBJ+TSNEBJ+TSNGL1C+TSNGL2C+TSNGL3C ; 349 | TSNT1 = TSN1CJ + TSN1CP + TSNRCJ + TSNRCP; 350 | TSNT2 = TSN1DJ + TSN1DP + TSNRDJ + TSNRDP; 351 | TSNT3 = TSN1EJ+ TSN1EP+ TSNREJ+ TSNREP ; 352 | TSNT4 = TSN1FJ+ TSN1FP+ TSNRFJ+ TSNRFP ; 353 | regle 8113: 354 | application : iliad , batch ; 355 | pour i =V,C,1,2,3,4: 356 | TSNi = positif (-TSNTi) * min (0 , TSNTi + PRNNi) 357 | + positif_ou_nul (TSNTi) * TSNTi; 358 | pour i =V,C,1,2,3,4: 359 | PRNi = positif (-TSNTi) * positif (TSNTi + PRNNi) * (TSNTi + PRNNi) 360 | + positif_ou_nul (TSNTi) * PRNNi; 361 | 362 | FRDVREP = positif(ART1731BIS) * max(0,FRNV - FRDV) * null(IND_10V) 363 | + max(0,FRNV1731 - 10MINSV) * IND_10V * positif(FRNV1731) 364 | ; 365 | FRDCREP = positif(ART1731BIS) * max(0,FRNC - FRDC) * null(IND_10C) 366 | + max(0,FRNC1731 - 10MINSC) * IND_10C * positif(FRNC1731) 367 | ; 368 | FRD1REP = positif(ART1731BIS) * max(0,(max(0,(FRN1-FRD1)) - PRN1 * (1-positif(FRN1-FRD1)))* null(IND_101) 369 | +(max(0,(FRN2-FRD2)) - PRN2 * (1-positif(FRN2-FRD2)) )* null(IND_102) 370 | +(max(0,(FRN3-FRD3)) - PRN3 * (1-positif(FRN3-FRD3)))* null(IND_103) 371 | +(max(0,(FRN4-FRD4)) - PRN4 * (1-positif(FRN4-FRD4)))* null(IND_104) 372 | + max(0,FRN11731 - 10MINS1) * IND_101 * positif(FRN11731) 373 | + max(0,FRN21731 - 10MINS2) * IND_102 * positif(FRN21731) 374 | + max(0,FRN31731 - 10MINS3) * IND_103 * positif(FRN31731) 375 | + max(0,FRN41731 - 10MINS4) * IND_104 * positif(FRN41731)) 376 | ; 377 | FRDREPTOT = positif(ART1731BIS) * (FRDAV - FRDV + FRDAC - FRDC + FRDA1 - FRD1 + FRDA2 - FRD2 378 | + FRDA3 - FRD3 + FRDA4 - FRD4); 379 | -------------------------------------------------------------------------------- /src/chap-82.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 82000: 22 | application : iliad , batch ; 23 | RCMRABD = arr(RCMABD * 40/100); 24 | 25 | 2RCMRABD = arr(REVACT * 40/100); 26 | 27 | TRCMRABD = RCMRABD + 2RCMRABD; 28 | RCMRTNC = arr(RCMTNC * 40/100); 29 | 30 | 2RCMRTNC = arr(REVPEA * 40/100); 31 | 32 | TRCMRTNC = RCMRTNC + 2RCMRTNC; 33 | RCMRNABD = RCMABD - RCMRABD; 34 | 35 | 2RCMRNABD = REVACT - 2RCMRABD; 36 | RCMRNTNC = RCMTNC - RCMRTNC ; 37 | 38 | 2RCMRNTNC = REVPEA - 2RCMRTNC ; 39 | REGPRIVM = arr(REGPRIV * MAJREV); 40 | 41 | 2REGPRIVM = arr(RESTUC * MAJREV); 42 | TRCMABD = RCMABD + REVACT; 43 | RCMAB = RCMRNABD + 2RCMRNABD ; 44 | DRTNC = RCMTNC + REVPEA; 45 | RTNC = RCMRNTNC + 2RCMRNTNC ; 46 | RAVC = RCMAV + PROVIE; 47 | RCMNAB = RCMHAD + DISQUO ; 48 | RTCAR = RCMHAB + INTERE; 49 | RCMPRIV = REGPRIV + RESTUC; 50 | RCMPRIVM = REGPRIVM + 2REGPRIVM ; 51 | RCMFRTEMP = min(RCMAB + RTNC + RAVC + RCMNAB + RTCAR + RCMPRIVM,RCMFR); 52 | BRCMBIS = RCMAB + RTNC + RAVC + RCMNAB + RTCAR + RCMPRIVM; 53 | regle 82001: 54 | application : iliad , batch ; 55 | FRAN = positif(RCMABD) * 56 | (null(4-V_IND_TRAIT) * ( 57 | positif(REVACT+RTCAR+RCMNAB) * 58 | arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) * RCMABD / max (1,TRCMABD + RTCAR+RCMNAB)) 59 | + (1 - positif(REVACT+RTCAR+RCMNAB)) * 60 | (RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) 61 | ) 62 | + null(5-V_IND_TRAIT) * ( 63 | positif(REVACT+RTCAR+RCMNAB) * 64 | arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS 65 | ) * RCMABD / max (1,TRCMABD + RTCAR+RCMNAB) 66 | ) 67 | + (1 - positif(REVACT+RTCAR+RCMNAB)) * 68 | (RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) 69 | ) 70 | ) ; 71 | 72 | 73 | 2FRAN = positif(REVACT) * ( 74 | null(4-V_IND_TRAIT) * ( 75 | positif(RTCAR+RCMNAB) * 76 | arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) * REVACT/ max (1,TRCMABD + RTCAR+RCMNAB) ) 77 | + (1 - positif(RTCAR+RCMNAB)) * 78 | ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) - FRAN) 79 | ) 80 | + null(5-V_IND_TRAIT) * ( 81 | positif(RTCAR+RCMNAB)* 82 | arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P+0),BRCMTOT1731+0))*ART1731BIS 83 | ) * REVACT/ max (1,TRCMABD + RTCAR+RCMNAB) 84 | ) 85 | + (1 - positif(RTCAR+RCMNAB)) * 86 | ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P+0),BRCMTOT1731+0))*ART1731BIS) - FRAN) 87 | ) 88 | ); 89 | 90 | FRAR = positif(RCMHAB) * ( 91 | null(4-V_IND_TRAIT) * ( 92 | positif(INTERE+RCMNAB) * arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) * RCMHAB / max (1,TRCMABD + RTCAR+RCMNAB) ) + 93 | (1 - positif(INTERE+RCMNAB)) 94 | * ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) - FRAN - 2FRAN)) 95 | + null(5-V_IND_TRAIT) * ( 96 | positif(INTERE+RCMNAB) * arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) * RCMHAB / max (1,TRCMABD + RTCAR+RCMNAB) ) + 97 | (1 - positif(INTERE+RCMNAB)) 98 | * ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) - FRAN - 2FRAN))); 99 | 2FRAR = positif(INTERE) * ( 100 | null(4-V_IND_TRAIT) * ( 101 | positif(RCMNAB)* arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) * INTERE/ max (1,TRCMABD + RTCAR+RCMNAB) ) + 102 | (1 - positif(RCMNAB)) * ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) -FRAN-2FRAN-FRAR)) 103 | + null(5-V_IND_TRAIT) * ( 104 | positif(RCMNAB)* arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) * INTERE/ max (1,TRCMABD + RTCAR+RCMNAB) ) + 105 | (1 - positif(RCMNAB)) * ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) -FRAN-2FRAN-FRAR))); 106 | FRAU = positif(RCMHAD) * ( 107 | null(4-V_IND_TRAIT) * ( 108 | positif(DISQUO) * arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) * RCMHAD / max (1,TRCMABD + RTCAR + RCMNAB)) 109 | + (1 - positif(DISQUO)) * ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) - FRAN - 2FRAN - FRAR - 2FRAR)) 110 | 111 | + null(5-V_IND_TRAIT) * ( 112 | positif(DISQUO) * arr((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS 113 | ) * RCMHAD / max (1,TRCMABD + RTCAR + RCMNAB) 114 | ) 115 | + (1 - positif(DISQUO)) * ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) 116 | - FRAN - 2FRAN - FRAR - 2FRAR 117 | ) 118 | ) 119 | ); 120 | 2FRAU = null(4-V_IND_TRAIT) * (((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,BRCMTOT+0)*ART1731BIS) - FRAN - 2FRAN - FRAR - 2FRAR - FRAU ) * positif(DISQUO)) 121 | + null(5-V_IND_TRAIT) * ( 122 | ((RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS) - FRAN - 2FRAN - FRAR - 2FRAR - FRAU ) * positif(DISQUO)); 123 | 124 | regle 82002: 125 | application : iliad , batch ; 126 | 1RAN = (1 - positif(EXFR)) * (RCMRNABD - FRAN) 127 | + positif(EXFR) * 0; 128 | 2RAN = (1 - positif(EXFR)) * (2RCMRNABD - 2FRAN) 129 | + positif(EXFR) * 0; 130 | TRAN = 1RAN + 2RAN ; 131 | 1RAR = (1 - positif(EXFR)) * (RCMHAB - FRAR) 132 | + positif(EXFR) * 0; 133 | 2RAR = (1 - positif(EXFR)) * (INTERE - 2FRAR) + positif(EXFR) * 0; 134 | TRAR = 1RAR + 2RAR ; 135 | 1RAU = (1 - positif(EXFR)) * (RCMHAD - FRAU) 136 | + positif(EXFR) * 0; 137 | 2RAU = (1 - positif(EXFR)) * (DISQUO - 2FRAU) + positif(EXFR) * 0; 138 | TRAU = 1RAU + 2RAU ; 139 | regle 82003: 140 | application : iliad , batch ; 141 | ABRCM2 = min( ABTAV , RAVC); 142 | regle 82007: 143 | application : iliad , batch ; 144 | ABAVC = positif(RCMAV) * arr( ABRCM2 * RCMAV / RAVC ); 145 | 2ABAVC = positif(PROVIE) * min(arr( ABRCM2 * PROVIE / RAVC ) , ABRCM2 - ABAVC); 146 | TABAVC = ABAVC + 2ABAVC ; 147 | regle 82008: 148 | application : iliad , batch ; 149 | RNTNC = RTNC ; 150 | RNAVC = RAVC - TABAVC; 151 | regle 820091: 152 | application : iliad , batch ; 153 | RCMFRART1731 = null(4- V_IND_TRAIT)* PREM8_11 * max( 0, min(RCMFR,BRCMBIS)) 154 | + null(5-V_IND_TRAIT) * max( 0, min(RCMFR,max(BRCM1731,max(BRCM_P,BRCMP2)))); 155 | regle 820093: 156 | application : iliad , batch ; 157 | EXFR = max( 0, RCMFR*(1-positif(ART1731BIS))+min(RCMFR,max(max(BRCMTOTP2,BRCMTOT_P),BRCMTOT1731+0))*ART1731BIS - RCMAB - RTCAR - RCMNAB); 158 | regle 82010: 159 | application : iliad , batch ; 160 | 1RIA = 1RAN ; 161 | 2RIA = 2RAN ; 162 | 1RNC = RCMRNTNC ; 163 | 2RNC = 2RCMRNTNC ; 164 | RCAV = max ( 0 , RCMAV-ABAVC) ; 165 | 2RCAV = max ( 0 , PROVIE-2ABAVC) ; 166 | 1RAO = max( 0 , REGPRIVM); 167 | 2RAO = max( 0 , 2REGPRIVM); 168 | R2FA = max(0,COD2FA); 169 | TRCM1 = 1RNC + RCAV + 1RAO; 170 | TRCM = TRCM1 + 2RNC + 2RCAV + 2RAO ; 171 | regle 82011: 172 | application : iliad , batch ; 173 | FRG1 = positif(EXFR) * arr( (EXFR * TRCM1)/ TRCM) 174 | + (1 - positif(EXFR)) * 0 ; 175 | FRG2 = positif(EXFR) * min(arr(EXFR * 2RNC/ TRCM), EXFR - FRG1) 176 | + (1 - positif(EXFR)) * 0 ; 177 | FRG3 = positif(EXFR) * min(arr(EXFR * 2RCAV/ TRCM), EXFR - FRG1 - FRG2) 178 | + (1 - positif(EXFR)) * 0 ; 179 | FRG5 = positif(EXFR) * max(0,EXFR - FRG1 -FRG2 - FRG3) 180 | + (1 - positif(EXFR)) * 0 ; 181 | regle 82012: 182 | application : iliad , batch ; 183 | DFRCMNBIS = (positif(RCMAB + RTCAR + RCMNAB) 184 | * (1 - positif(RTNC+RAVC+RCMPRIVM)) 185 | * max(0, RCMFR 186 | - RCMAB 187 | - RTCAR 188 | - RCMNAB) 189 | 190 | + (1 - positif(RCMAB + RTCAR + RCMNAB)) 191 | * positif(RTNC+RAVC+RCMPRIVM) 192 | * max(0, RCMFR 193 | - RTNC 194 | - (RAVC - TABAVC) 195 | - RCMPRIVM) 196 | + positif(RCMAB + RTCAR + RCMNAB) 197 | * positif(RTNC+RAVC+RCMPRIVM) 198 | * max(0, RCMFR 199 | - RCMAB 200 | - RCMNAB 201 | - RTNC 202 | - (RAVC - TABAVC) 203 | - RTCAR 204 | - RCMPRIVM) 205 | + (1 - positif(RCMAB + RTCAR + RCMNAB)) 206 | * (1 - positif(RTNC+RAVC+RCMPRIVM)) 207 | * max(0, RCMFR)) ; 208 | DFRCMN = DFRCMNBIS * (1-positif(ART1731BIS)) 209 | + (RCMFR - RCMFRART1731) * positif(ART1731BIS) ; 210 | regle 82013: 211 | application : iliad , batch ; 212 | 1RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7) ) 213 | alors (((1-positif(DFRCMN)) * (1RIA+1RNC+1RAR+1RAU+1RAO+RCAV-FRG1) -positif(DFRCMN)*0 ) * (1-positif(ART1731BIS)) 214 | + (positif(ART1731BIS) * (1RIA+1RNC+1RAR+1RAU+1RAO+RCAV-FRG1) -positif(DFRCMN)*0)) 215 | sinon (0) 216 | finsi; 217 | 218 | 2RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7)) 219 | alors ((1- positif(DFRCMN)) * 2RIA * (1-positif(ART1731BIS)) 220 | + 2RIA * positif(ART1731BIS)) 221 | sinon (0) 222 | finsi; 223 | 3RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7)) 224 | alors ((1- positif(DFRCMN)) * (2RNC-FRG2) * (1-positif(ART1731BIS)) 225 | + (2RNC-FRG2) * positif(ART1731BIS)) 226 | sinon (0) 227 | finsi; 228 | 4RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7)) 229 | alors ((1- positif(DFRCMN)) * (2RCAV-FRG3) * (1-positif(ART1731BIS)) 230 | + (2RCAV-FRG3) * positif(ART1731BIS)) 231 | sinon (0) 232 | finsi; 233 | 5RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7)) 234 | alors ((1- positif(DFRCMN)) * 2RAU * (1-positif(ART1731BIS)) 235 | + 2RAU * positif(ART1731BIS)) 236 | sinon (0) 237 | finsi; 238 | 6RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7)) 239 | alors ((1- positif(DFRCMN)) * (2RAO-FRG5) * (1-positif(ART1731BIS)) 240 | + (2RAO-FRG5) * positif(ART1731BIS)) 241 | sinon (0) 242 | finsi; 243 | 7RCM_I = si( (V_REGCO + 0) dans (1,3,5,6,7)) 244 | alors ((1- positif(DFRCMN)) * 2RAR * (1-positif(ART1731BIS)) 245 | + 2RAR * positif(ART1731BIS)) 246 | sinon (0) 247 | finsi; 248 | RCM_I = 1RCM_I + 2RCM_I + 3RCM_I + 4RCM_I + 5RCM_I + 6RCM_I + 7RCM_I; 249 | regle 82014: 250 | application : iliad , batch ; 251 | REPRCM = (DEFRCM + DEFRCM2 + DEFRCM3 + DEFRCM4 + DEFRCM5 + DEFRCM6); 252 | REPRCMB = max(0,BRCM + BRCMQ - RCMFR); 253 | REPRCMBIS = (DEFRCM + DEFRCM2 + DEFRCM3 + DEFRCM4 + DEFRCM5 + DEFRCM6) * (1-positif(ART1731BIS)) 254 | + min(DEFRCM + DEFRCM2 + DEFRCM3 + DEFRCM4 + DEFRCM5 + DEFRCM6,max(REPRCM1731,max(REPRCM_P,REPRCMP2))) * ART1731BIS * (1-PREM8_11) 255 | + 0 * ART1731BIS * PREM8_11; 256 | REPRCM1 = positif(REPRCMBIS) * arr( (REPRCMBIS * 1RCM_I)/ RCM_I) 257 | + (1 - positif(REPRCMBIS)) * 0 ; 258 | REPRCM2 = positif(REPRCMBIS) * min(arr((REPRCMBIS * 2RCM_I)/ RCM_I), REPRCMBIS - REPRCM1) 259 | + (1 - positif(REPRCMBIS)) * 0 ; 260 | REPRCM3 = positif(REPRCMBIS) * min(arr((REPRCMBIS * 3RCM_I)/ RCM_I), REPRCMBIS - REPRCM1 - REPRCM2) 261 | + (1 - positif(REPRCMBIS)) * 0 ; 262 | REPRCM4 = positif(REPRCMBIS) * min(arr((REPRCMBIS * 4RCM_I)/ RCM_I), REPRCMBIS - REPRCM1 - REPRCM2 - REPRCM3) 263 | + (1 - positif(REPRCMBIS)) * 0 ; 264 | REPRCM5 = positif(REPRCMBIS) * min(arr((REPRCMBIS * 5RCM_I)/ RCM_I), REPRCMBIS - REPRCM1 - REPRCM2 - REPRCM3 - REPRCM4) 265 | + (1 - positif(REPRCMBIS)) * 0 ; 266 | REPRCM6 = positif(REPRCMBIS) * min(arr((REPRCMBIS * 6RCM_I)/ RCM_I), REPRCMBIS - REPRCM1 - REPRCM2 - REPRCM3 - REPRCM4 - REPRCM5) 267 | + (1 - positif(REPRCMBIS)) * 0 ; 268 | REPRCM7 = positif(REPRCMBIS) * max(0,REPRCMBIS - REPRCM1 -REPRCM2 - REPRCM3 - REPRCM4 - REPRCM5 - REPRCM6 ) 269 | + (1 - positif(REPRCMBIS)) * 0 ; 270 | regle 82015: 271 | application : iliad , batch ; 272 | DFRCM5 = (DEFRCM6 * positif(DFRCMN) 273 | + DEFRCM6 * positif(DEFRCM+DEFRCM2+DEFRCM3+DEFRCM4+DEFRCM5- RCM_I) * (1-positif(DFRCMN)) 274 | + max( 0, DEFRCM6 - (RCM_I -DEFRCM- DEFRCM2-DEFRCM3-DEFRCM4-DEFRCM5)) 275 | * positif_ou_nul(RCM_I -DEFRCM-DEFRCM2-DEFRCM3-DEFRCM4-DEFRCM5) * (1-positif(DFRCMN))) 276 | * (1-positif(ART1731BIS)) 277 | + min(DEFRCM6,REPRCM - REPRCMBIS) * positif(ART1731BIS*(1-PREM8_11)) 278 | + DEFRCM6 * positif(ART1731BIS*PREM8_11); 279 | DFRCM4 = (DEFRCM5 * positif(DFRCMN) 280 | + DEFRCM5 * positif(DEFRCM+DEFRCM2+DEFRCM3+DEFRCM4- RCM_I) * (1-positif(DFRCMN)) 281 | + max( 0, DEFRCM5 - (RCM_I -DEFRCM- DEFRCM2-DEFRCM3-DEFRCM4)) 282 | * positif_ou_nul(RCM_I -DEFRCM- DEFRCM2-DEFRCM3-DEFRCM4) * (1-positif(DFRCMN))) 283 | * (1-positif(ART1731BIS)) 284 | + min(DEFRCM5,REPRCM - REPRCMBIS - DFRCM5 ) * positif(ART1731BIS*(1-PREM8_11)) 285 | + DEFRCM5 * positif(ART1731BIS*PREM8_11); 286 | DFRCM3 = (DEFRCM4 * positif(DFRCMN) 287 | + DEFRCM4 * positif(DEFRCM+DEFRCM2+DEFRCM3- RCM_I) * (1-positif(DFRCMN)) 288 | + max( 0, DEFRCM4 - (RCM_I -DEFRCM)) * positif_ou_nul(RCM_I -DEFRCM-DEFRCM2-DEFRCM3) * (1-positif(DFRCMN))) 289 | * (1-positif(ART1731BIS)) 290 | + min(DEFRCM4,REPRCM - REPRCMBIS - DFRCM5 - DFRCM4 ) * positif(ART1731BIS*(1-PREM8_11)) 291 | + DEFRCM4 * positif(ART1731BIS*PREM8_11); 292 | DFRCM2 = (DEFRCM3 * positif(DFRCMN) 293 | + DEFRCM3 * positif(DEFRCM+DEFRCM2- RCM_I) * (1-positif(DFRCMN)) 294 | + max( 0, DEFRCM3 - (RCM_I -DEFRCM)) * positif_ou_nul(RCM_I -DEFRCM-DEFRCM2) * (1-positif(DFRCMN))) 295 | * (1-positif(ART1731BIS)) 296 | + min(DEFRCM3,REPRCM - REPRCMBIS - DFRCM5 - DFRCM4-DFRCM3) * positif(ART1731BIS*(1-PREM8_11)) 297 | + DEFRCM3 * positif(ART1731BIS*PREM8_11); 298 | DFRCM1 = (DEFRCM2 * positif(DFRCMN) 299 | + DEFRCM2 * positif(DEFRCM - RCM_I) * (1-positif(DFRCMN)) 300 | + max( 0, DEFRCM2 - (RCM_I-DEFRCM)) * positif_ou_nul(RCM_I-DEFRCM) * (1-positif(DFRCMN))) 301 | * (1-positif(ART1731BIS)) 302 | + min(DEFRCM2,REPRCM - REPRCMBIS - DFRCM5 - DFRCM4-DFRCM3-DFRCM2) * positif(ART1731BIS*(1-PREM8_11)) 303 | + DEFRCM2 * positif(ART1731BIS*PREM8_11); 304 | regle 82016: 305 | application : iliad , batch ; 306 | RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 307 | alors (( (1-positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(1RCM_I-REPRCM1)) 308 | -positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)*0 309 | ) * (1-positif(ART1731BIS)) 310 | + positif(ART1731BIS) * max(0,(1RCM_I-REPRCM1)) 311 | ) 312 | sinon (0) 313 | finsi; 314 | RCM2FA = COD2FA * (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))); 315 | 2RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 316 | alors (( (1- positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(2RCM_I-REPRCM2)) 317 | ) * (1-positif(ART1731BIS)) 318 | + positif(ART1731BIS) * max(0,(2RCM_I-REPRCM2)) 319 | ) 320 | sinon (0) 321 | finsi; 322 | 3RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 323 | alors (( (1- positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(3RCM_I-REPRCM3)) 324 | ) * (1-positif(ART1731BIS)) 325 | + positif(ART1731BIS) * max(0,(3RCM_I-REPRCM3)) 326 | ) 327 | sinon (0) 328 | finsi; 329 | 4RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 330 | alors (( (1- positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(4RCM_I-REPRCM4)) 331 | ) * (1-positif(ART1731BIS)) 332 | + positif(ART1731BIS) * max(0,(4RCM_I-REPRCM4)) 333 | ) 334 | sinon (0) 335 | finsi; 336 | 5RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 337 | alors (( (1- positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(5RCM_I-REPRCM5)) 338 | ) * (1-positif(ART1731BIS)) 339 | + positif(ART1731BIS) * max(0,(5RCM_I-REPRCM5)) 340 | ) 341 | sinon (0) 342 | finsi; 343 | 6RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 344 | alors (( (1- positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(6RCM_I-REPRCM6)) 345 | ) * (1-positif(ART1731BIS)) 346 | + positif(ART1731BIS) * max(0,(6RCM_I-REPRCM6)) 347 | ) 348 | sinon (0) 349 | finsi; 350 | 7RCM = si( (V_REGCO + 0) dans (1,3,5,6,7)) 351 | alors (( (1- positif(DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5)) * max(0,(7RCM_I-REPRCM7)) 352 | ) * (1-positif(ART1731BIS)) 353 | + positif(ART1731BIS) * max(0,(7RCM_I-REPRCM7)) 354 | ) 355 | sinon (0) 356 | finsi; 357 | DFRCM = (DFRCMN + DFRCM1+DFRCM2+DFRCM3+DFRCM4+DFRCM5) * (1-positif(null(2-V_REGCO)+null(4-V_REGCO))); 358 | RCMEXCREF = max(0,TRCMRABD + TRCMRTNC) * (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))); 359 | regle 82100: 360 | application : iliad , batch ; 361 | ABTAV = PLAF_RCMAV1 * (1 + BOOL_0AM) ; 362 | regle 82107: 363 | application : iliad , batch ; 364 | BPLIB = (min( RCMLIB, max(0 , ABTAV - RAVC) ) * (1 - V_CNR)); 365 | regle 82110: 366 | application : iliad , batch ; 367 | EPAV = arr(BPLIB * TX_PREVLIB/100); 368 | regle 82111: 369 | application : iliad , batch ; 370 | VAREPRCM = min(DEFRCM + DEFRCM2 + DEFRCM3 + DEFRCM4 + DEFRCM5 + DEFRCM6,1RCM_I + 2RCM_I +3RCM_I +4RCM_I +5RCM_I +6RCM_I +7RCM_I ); 371 | -------------------------------------------------------------------------------- /src/chap-83.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 831: 22 | application : iliad , batch ; 23 | RRFI = (RFON + DRCF + max(0,RFMIC - MICFR - RFDANT )) * (1-positif(ART1731BIS)) 24 | + (RFON + DRCF + max(0,RFMIC - MICFR - DEFRF4BD )) * positif(ART1731BIS); 25 | RRFIPS = RRFI; 26 | regle 8312: 27 | application : iliad , batch ; 28 | MICFR = present(RFMIC) * arr(RFMIC * TX_MICFON/100); 29 | regle 8316: 30 | application : iliad , batch ; 31 | RMF = max(0,RFMIC - MICFR); 32 | RMFN = max(0,RFMIC - MICFR - RFDANT )* (1 - positif(ART1731BIS)) 33 | + max(0,RFMIC - MICFR - DEFRF4BD) * positif(ART1731BIS); 34 | regle 832: 35 | application : iliad , batch ; 36 | RFCD = RFORDI + FONCI + REAMOR; 37 | regle 833: 38 | application : iliad , batch ; 39 | VARRFDORD = min(RFCD,RFDORD); 40 | RFCE = max(0,RFCD- RFDORD) * (1 - positif(ART1731BIS)) 41 | + max(0,RFCD- DEFRF4BB) * positif(ART1731BIS); 42 | RFCEAPS = max(0,RFORDI- RFDORD) * (1 - positif(ART1731BIS)) 43 | + max(0,RFORDI- DEFRF4BB) * positif(ART1731BIS); 44 | RFCEPS = max(0,RFCD-RFDORD)* (1 - positif(ART1731BIS)) 45 | + max(0,RFCD-DEFRF4BB) * positif(ART1731BIS); 46 | 47 | DFCE = min(0,RFCD- RFDORD) * (1 - positif(ART1731BIS)) 48 | + min(0,RFCD- DEFRF4BB) * positif(ART1731BIS); 49 | 50 | RFCF = max(0,RFCE-(RFDHIS * (1 - positif(PREM8_11)))); 51 | RFCFPS = (RFCEPS-RFDHIS* (1 - positif(PREM8_11))); 52 | RFCFAPS = max(0,RFCEAPS-(RFDHIS * (1 - positif(PREM8_11)))); 53 | 54 | DRCF = min(0,RFCE-(RFDHIS * (1 - positif(PREM8_11)))); 55 | VARRFDANT = min(RFCF+RFMIC - MICFR,RFDANT); 56 | RFCG = max(0,RFCF- RFDANT) * (1 - positif(ART1731BIS)) 57 | + max(0,RFCF- DEFRF4BD) * positif(ART1731BIS); 58 | DFCG = min(0,RFCF- RFDANT) * (1 - positif(ART1731BIS)) 59 | + min(0,RFCF- DEFRF4BD) * positif(ART1731BIS); 60 | regle 834: 61 | application : iliad , batch ; 62 | RFON = arr(RFCG*RFORDI/RFCD); 63 | 2REVF = min( arr ((RFCG)*(FONCI)/RFCD) , RFCG-RFON); 64 | 3REVF = min( arr (RFCG*(REAMOR)/RFCD) , RFCG-RFON-2REVF); 65 | RFQ = FONCI + REAMOR; 66 | regle 834113: 67 | application : iliad ; 68 | DEF4BB = RFORDI + RFMIC * 0.70 + FONCI + REAMOR - max(0,RFORDI+ RFMIC * 0.70 + FONCI + REAMOR - RFDORD); 69 | DEFRF4BB = min(RFDORD,max(DEF4BB1731,max(DEF4BB_P,DEF4BBP2))) * DEFRIRF * (1-PREM8_11) ; 70 | regle 834115: 71 | application : iliad ; 72 | DEF4BD = RFORDI + RFMIC * 0.70 + FONCI + REAMOR-RFDORD - RFDHIS- max(0,RFORDI+ RFMIC * 0.70 + FONCI + REAMOR-RFDORD - RFDHIS-RFDANT); 73 | DEFRF4BD = min(RFDANT,max(DEF4BD1731,max(DEF4BD_P,DEF4BDP2)))* DEFRIRF * (1-PREM8_11) ; 74 | DEF4BC = max(0, RFORDI-RFDORD); 75 | DEFRF4BC = max(0,min(RFDHIS,-max(DEF4BC1731,max(DEF4BC_P,DEF4BCP2))+RFDHIS)) * positif(DEFRIGLOBINF+DEFRIGLOBSUP) * (1-PREM8_11); 76 | regle 834117: 77 | application : iliad ; 78 | DEFRFNONI = max(0,RFDORD + RFDANT - DEFRF4BB - DEFRF4BD); 79 | 80 | -------------------------------------------------------------------------------- /src/chap-84.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 801 : 22 | application : iliad , batch ; 23 | BA1AF = BAF1AP + BAF1AC + BAF1AV ; 24 | regle 840 : 25 | application : iliad , batch ; 26 | BARSV = BAHREV + 4BAHREV - BAHDEV * (1 - positif(ART1731BIS*PREM8_11)); 27 | BARSREVV = BAHREV +4BAHREV; 28 | BARSC = BAHREC + 4BAHREC - BAHDEC * (1 - positif(ART1731BIS*PREM8_11)); 29 | BARSREVC = BAHREC +4BAHREC; 30 | BARSP = BAHREP + 4BAHREP - BAHDEP * (1 - positif(ART1731BIS*PREM8_11)); 31 | BARSREVP = BAHREP +4BAHREP; 32 | BARAV = BACREV + 4BACREV - BACDEV * (1 - positif(ART1731BIS*PREM8_11)); 33 | BARREVAV = BACREV + 4BACREV; 34 | BARAC = BACREC + 4BACREC - BACDEC * (1 - positif(ART1731BIS*PREM8_11)); 35 | BARREVAC = BACREC + 4BACREC; 36 | BARAP = BACREP + 4BACREP -BACDEP * (1 - positif(ART1731BIS*PREM8_11)); 37 | BARREVAP = BACREP + 4BACREP; 38 | regle 8421: 39 | application : iliad , batch ; 40 | pour i =V,C,P: 41 | DEFBACREi = positif(4BACREi) * arr((((BACDEi * (1 - positif(ART1731BIS*PREM8_11)))) * BACREi) / BARREVAi) 42 | + (1 - positif(4BACREi)) * (BACDEi * (1 - positif(ART1731BIS*PREM8_11))) ; 43 | pour i =V,C,P: 44 | 4DEFBACREi = positif(4BACREi) * (((BACDEi * (1 - positif(ART1731BIS*PREM8_11)))) - DEFBACREi); 45 | regle 8422234: 46 | application : iliad ; 47 | SOMBARET = 4BACREV + 4BACREC + 4BACREP + (4BAHREV + 4BAHREC +4BAHREP) * MAJREV; 48 | SOMBARREVT = 4BAQV + 4BAQC +4BAQP ; 49 | PROQDEFBAT = (max(0,SOMBARET-SOMBARREVT) / DEFBANIF ) * positif(DEFBANIF); 50 | regle 84211: 51 | application : iliad , batch ; 52 | BANV = (BACREV - DEFBACREV) * positif_ou_nul(BARAV) + BARAV * (1-positif(BARAV)); 53 | BANC = (BACREC - DEFBACREC) * positif_ou_nul(BARAC) + BARAC * (1-positif(BARAC)); 54 | BANP = (BACREP - DEFBACREP) * positif_ou_nul(BARAP) + BARAP * (1-positif(BARAP)); 55 | BAEV = (4BACREV - 4DEFBACREV) * positif_ou_nul(BARAV) + 0; 56 | BAEC = (4BACREC - 4DEFBACREC) * positif_ou_nul(BARAC) + 0; 57 | BAEP = (4BACREP - 4DEFBACREP) * positif_ou_nul(BARAP) + 0; 58 | regle 842111: 59 | application : iliad , batch ; 60 | pour i =V,C,P: 61 | DEFBAHREi = positif(4BAHREi) * arr(((BAHDEi * (1 - positif(ART1731BIS*PREM8_11))) * BAHREi) / BARSREVi) 62 | + (1 - positif(4BAHREi)) * (BAHDEi * (1 - positif(ART1731BIS*PREM8_11))) ; 63 | pour i =V,C,P: 64 | 4DEFBAHREi = positif(4BAHREi) * ((BAHDEi * (1 - positif(ART1731BIS*PREM8_11) )) - DEFBAHREi) ; 65 | regle 843: 66 | application : iliad , batch ; 67 | BAMV = arr((BAHREV - DEFBAHREV) * MAJREV) * positif_ou_nul(BARSV) + BARSV * (1-positif(BARSV)); 68 | BAMC = arr((BAHREC - DEFBAHREC) * MAJREV) * positif_ou_nul(BARSC) + BARSC * (1-positif(BARSC)); 69 | BAMP = arr((BAHREP - DEFBAHREP) * MAJREV) * positif_ou_nul(BARSP) + BARSP * (1-positif(BARSP)); 70 | BAEMV = (arr((4BAHREV - 4DEFBAHREV)* MAJREV)) * positif_ou_nul(BARSV) + 0; 71 | BAEMC = (arr((4BAHREC - 4DEFBAHREC)* MAJREV)) * positif_ou_nul(BARSC) + 0; 72 | BAEMP = (arr((4BAHREP - 4DEFBAHREP)* MAJREV)) * positif_ou_nul(BARSP) + 0; 73 | regle 844: 74 | application : iliad , batch ; 75 | BAFORV = arr(BAFV*MAJREV)+BAFORESTV+BAFPVV; 76 | BAFORC = arr(BAFC*MAJREV)+BAFORESTC+BAFPVC; 77 | BAFORP = arr(BAFP*MAJREV)+BAFORESTP+BAFPVP; 78 | regle 8441: 79 | application : iliad , batch ; 80 | BAHQV = BANV + BAMV + BAFORV; 81 | BAHQC = BANC + BAMC + BAFORC; 82 | BAHQP = BANP + BAMP + BAFORP; 83 | regle 845: 84 | application : iliad , batch ; 85 | 4BAQV = max(0,(4BACREV - 4DEFBACREV))*positif_ou_nul(BARAV)+arr(max(0,(4BAHREV - 4DEFBAHREV))*MAJREV) * positif_ou_nul(BARSV); 86 | 4BAQC = max(0,(4BACREC - 4DEFBACREC))*positif_ou_nul(BARAC)+arr(max(0,(4BAHREC - 4DEFBAHREC))*MAJREV) * positif_ou_nul(BARSC); 87 | 4BAQP = max(0,(4BACREP - 4DEFBACREP))*positif_ou_nul(BARAP)+arr(max(0,(4BAHREP - 4DEFBAHREP))*MAJREV) * positif_ou_nul(BARSP); 88 | regle 8451: 89 | application : iliad , batch ; 90 | BAQV = BAEV + BAEMV; 91 | BAQC = BAEC + BAEMC; 92 | BAQP = BAEP + BAEMP; 93 | regle 84551: 94 | application : iliad , batch ; 95 | BA1V = BA1AV + BAF1AV ; 96 | BA1C = BA1AC + BAF1AC ; 97 | BA1P = BA1AP + BAF1AP ; 98 | regle 84552: 99 | application : iliad , batch ; 100 | BAHQT=BAHQV+BAHQC+BAHQP; 101 | regle 8455299: 102 | application : iliad , batch ; 103 | DAGRIIMP = max(0,min(BAHQV+BAHQC+BAHQP + BAQV + BAQC + BAQP,DAGRI6 +DAGRI5 +DAGRI4 + DAGRI3 + DAGRI2 + DAGRI1)); 104 | TOTDAGRI = min(DAGRI6 +DAGRI5 +DAGRI4 + DAGRI3 + DAGRI2 + DAGRI1 ,max(DAGRIIMP1731,max(DAGRIIMP_P,DAGRIIMPP2))) * positif(ART1731BIS*(1-PREM8_11)) 105 | + DAGRIIMP * (1-positif(ART1731BIS)) 106 | + 0 * positif(ART1731BIS*PREM8_11); 107 | regle 845529: 108 | application : iliad , batch ; 109 | BAHQTOT=BAHQV+BAHQC+BAHQP-TOTDAGRI*(1-ART1731BIS); 110 | BAHQTOTMAXP=positif_ou_nul(BAHQT) * (max(0,BAHQV+BAHQC+BAHQP-TOTDAGRI)); 111 | regle 8455255: 112 | application : iliad , batch; 113 | BAHQTOTMAXN=positif_ou_nul(BAHQT) * min(0,BAHQV+BAHQC+BAHQP-TOTDAGRI*(1-ART1731BIS)); 114 | BAHQTOTMIN=positif(-BAHQT) * BAHQT; 115 | regle 84513: 116 | application : iliad , batch ; 117 | BAQT = BAQV + BAQC + BAQP; 118 | BAQTOT = max(0,BAQV + BAQC + BAQP + BAHQTOTMAXN); 119 | BAQTOTN = min(0,BAQV + BAQC + BAQP + BAHQTOTMAXN); 120 | BAQTOTMIN = min(0,BAQV + BAQC + BAQP + BAHQTOTMIN); 121 | BAQTOTAV = positif_ou_nul(BAQT + BAHQT) * BAQTOT + (1 - positif(BAQT + BAHQT)) * 0; 122 | regle 845138: 123 | application : iliad , batch ; 124 | 4BAQTOT = somme(x=V,C,P: 4BAQx) ; 125 | 4BAQTOTNET = positif(4BAQTOT) * ( 126 | max(0, 4BAQTOT + (BAHQTOTMIN + BAHQTOTMAXN) ) * positif((1-ART1731BIS)+(1-positif(DEFRIBASUP+DEFRIGLOBSUP))*(1-PREM8_11)) 127 | + max(0,min(4BAQV+4BAQC+4BAQP+arr(DEFBANIF*PROQDEFBAT) 128 | ,4BACREV+4BACREC+4BACREP+(4BAHREV+4BAHREC+4BAHREP)*MAJREV ))* positif(DEFRIBASUP+DEFRIGLOBSUP)*(1-PREM8_11)); 129 | regle 845111: 130 | application : iliad , batch ; 131 | BA1 = BA1V + BA1C + BA1P; 132 | regle 846: 133 | application : iliad , batch ; 134 | BANOR = (BAHQTOTMAXP + BAQTOTMIN) * (1-ART1731BIS) 135 | + (BAHQTOTMAXP + BAQTOTMIN + arr(DEFBANIF * (1-PROQDEFBAT))) * ART1731BIS * (1-PREM8_11) 136 | + (BAHQTOTMAXP + BAQTOTMIN) * ART1731BIS * PREM8_11; 137 | 138 | regle 847: 139 | application : iliad , batch ; 140 | 141 | DEFBA2 = ((1-positif(BAHQT+BAQT)) * (DAGRI1) 142 | + positif(BAHQT+BAQT) * 143 | abs(min(max(BAHQT+BAQT-DAGRI6-DAGRI5-DAGRI4-DAGRI3-DAGRI2,0)-DAGRI1,DAGRI1)) 144 | * positif_ou_nul(DAGRI1-max(BAHQT+BAQT-DAGRI6-DAGRI5-DAGRI4-DAGRI3-DAGRI2,0)) 145 | * (1 - positif(IPVLOC))) 146 | * (1-positif(ART1731BIS)) 147 | + min(DAGRI1,DAGRI-DBAIP) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 148 | + DAGRI1 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 149 | DEFBA3 = ((1-positif(BAHQT+BAQT)) * (DAGRI2) 150 | + positif(BAHQT+BAQT) * 151 | abs(min(max(BAHQT+BAQT-DAGRI6-DAGRI5-DAGRI4-DAGRI3,0)-DAGRI2,DAGRI2)) 152 | * positif_ou_nul(DAGRI2-max(BAHQT+BAQT-DAGRI6-DAGRI5-DAGRI4-DAGRI3,0)) 153 | * (1 - positif(IPVLOC))) 154 | * (1-positif(ART1731BIS)) 155 | + min(DAGRI2,DAGRI-DBAIP-DEFBA2) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 156 | + DAGRI2 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 157 | DEFBA4 = ((1-positif(BAHQT+BAQT)) * (DAGRI3) 158 | + positif(BAHQT+BAQT) * 159 | abs(min(max(BAHQT+BAQT-DAGRI6-DAGRI5-DAGRI4,0)-DAGRI3,DAGRI3)) 160 | * positif_ou_nul(DAGRI3-max(BAHQT+BAQT-DAGRI6-DAGRI5-DAGRI4,0)) 161 | * (1 - positif(IPVLOC))) 162 | * (1-positif(ART1731BIS)) 163 | + min(DAGRI3,DAGRI-DBAIP-DEFBA2-DEFBA3) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 164 | + DAGRI3 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 165 | DEFBA5 = ((1-positif(BAHQT+BAQT)) * (DAGRI4) 166 | + positif(BAHQT+BAQT) * 167 | abs(min(max(BAHQT+BAQT-DAGRI6-DAGRI5,0)-DAGRI4,DAGRI4)) 168 | * positif_ou_nul(DAGRI4-max(BAHQT+BAQT-DAGRI6-DAGRI5,0)) 169 | * (1 - positif(IPVLOC))) 170 | * (1-positif(ART1731BIS)) 171 | + min(DAGRI4,DAGRI-DBAIP-DEFBA2-DEFBA3-DEFBA4) *positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 172 | + DAGRI4 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 173 | 174 | DEFBA6 = ((1-positif(BAHQT+BAQT)) * (DAGRI5) 175 | + positif(BAHQT+BAQT) * 176 | abs(min(max(BAHQT+BAQT-DAGRI6,0)-DAGRI5,DAGRI5)) 177 | * positif_ou_nul(DAGRI5-max(BAHQT+BAQT-DAGRI6,0)) 178 | * (1 - positif(IPVLOC))) 179 | * (1-positif(ART1731BIS)) 180 | + min(DAGRI5,DAGRI-DBAIP-DEFBA2-DEFBA3-DEFBA4-DEFBA5)* positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 181 | + DAGRI5 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 182 | DEFBA1 = ((1-positif(BAHQT+BAQT)) * (abs(BAHQT+BAQT)-abs(DEFIBA)) 183 | + positif(BAHQT+BAQT) * 184 | positif_ou_nul(DAGRI5+DAGRI4+DAGRI3+DAGRI2+DAGRI1-BAHQT-BAQT) 185 | * (DAGRI5+DAGRI4+DAGRI3+DAGRI2+DAGRI1-BAHQT-BAQT) 186 | * null(DEFBA2+DEFBA3+DEFBA4+DEFBA5+DEFBA6) 187 | * (1 - positif(IPVLOC))) 188 | * (1-positif(ART1731BIS)) 189 | + DEFBANIF * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 190 | + (BACDEV +BACDEC +BACDEP +BAHDEV +BAHDEC +BAHDEP) * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ))*(1-positif(SEUIL_IMPDEFBA + 1 - SHBA - (REVTP-BA1) - REVQTOTQHT)); 191 | regle 848: 192 | application : iliad , batch ; 193 | DEFIBAANT = positif_ou_nul(BAQT+BAHQTOT-(min(DAGRI1,DAGRI11731+0) * positif(ART1731BIS) + DAGRI1 * (1 - ART1731BIS)) 194 | -(min(DAGRI2,DAGRI21731+0) * positif(ART1731BIS) + DAGRI2 * (1 - ART1731BIS)) 195 | -(min(DAGRI3,DAGRI31731+0) * positif(ART1731BIS) + DAGRI3 * (1 - ART1731BIS)) 196 | -(min(DAGRI4,DAGRI41731+0) * positif(ART1731BIS) + DAGRI4 * (1 - ART1731BIS)) 197 | -(min(DAGRI5,DAGRI51731+0) * positif(ART1731BIS) + DAGRI5 * (1 - ART1731BIS)) 198 | -(min(DAGRI6,DAGRI61731+0) * positif(ART1731BIS) + DAGRI6 * (1 - ART1731BIS))) 199 | * ((min(DAGRI1,DAGRI11731+0) * positif(ART1731BIS) + DAGRI1 * (1 - ART1731BIS)) 200 | -(min(DAGRI2,DAGRI21731+0) * positif(ART1731BIS) + DAGRI2 * (1 - ART1731BIS)) 201 | -(min(DAGRI3,DAGRI31731+0) * positif(ART1731BIS) + DAGRI3 * (1 - ART1731BIS)) 202 | -(min(DAGRI4,DAGRI41731+0) * positif(ART1731BIS) + DAGRI4 * (1 - ART1731BIS)) 203 | -(min(DAGRI5,DAGRI51731+0) * positif(ART1731BIS) + DAGRI5 * (1 - ART1731BIS)) 204 | -(min(DAGRI6,DAGRI61731+0) * positif(ART1731BIS) + DAGRI6 * (1 - ART1731BIS))) 205 | + positif_ou_nul((min(DAGRI1,DAGRI11731+0) * positif(ART1731BIS) + DAGRI1 * (1 - ART1731BIS)) 206 | +(min(DAGRI2,DAGRI21731+0) * positif(ART1731BIS) + DAGRI2 * (1 - ART1731BIS)) 207 | +(min(DAGRI3,DAGRI31731+0) * positif(ART1731BIS) + DAGRI3 * (1 - ART1731BIS)) 208 | +(min(DAGRI4,DAGRI41731+0) * positif(ART1731BIS) + DAGRI4 * (1 - ART1731BIS)) 209 | +(min(DAGRI5,DAGRI51731+0) * positif(ART1731BIS) + DAGRI5 * (1 - ART1731BIS)) 210 | +(min(DAGRI6,DAGRI61731+0) * positif(ART1731BIS) + DAGRI6 * (1 - ART1731BIS))-BAQT-BAHQTOT) 211 | * (BAQT+BAHQTOT); 212 | regle 849: 213 | application : iliad , batch ; 214 | DAGRI = DAGRI1+DAGRI2+DAGRI3+DAGRI4+DAGRI5+DAGRI6; 215 | VAREDAGRI = min(DAGRI,BAHQV+BAHQC+BAHQP); 216 | regle 850: 217 | application : iliad , batch ; 218 | BAQTOTAVIS = 4BAQTOTNET; 219 | regle 8509: 220 | application : iliad , batch ; 221 | SOMDEFBANI = BACDEV+BAHDEV+BACDEC+BAHDEC+BACDEP+BAHDEP; 222 | DEFBANI = (BAHQV+BAHQC+BAHQP-TOTDAGRI+4BAQV+4BAQC+4BAQP +DBAIP+SOMDEFBANI); 223 | DEFBANIF = positif(DEFRIBASUP+DEFRIGLOBSUP) * (1-PREM8_11) * max(0,min(SOMDEFBANI, 224 | -(max(DEFBANI1731,max(DEFBANI_P,DEFBANIP2))-SOMDEFBANI))); 225 | -------------------------------------------------------------------------------- /src/chap-86.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 8610 : 22 | application : iliad , batch ; 23 | BNNSV = positif(BNHREV - (BNHDEV * (1 - positif(ART1731BIS*PREM8_11)))) 24 | * arr((BNHREV-(BNHDEV * (1 - positif(ART1731BIS*PREM8_11))))*MAJREV) 25 | + (1-positif_ou_nul(BNHREV-(BNHDEV * (1 - positif(ART1731BIS*PREM8_11))))) 26 | *(BNHREV-(BNHDEV * (1 - positif(ART1731BIS*PREM8_11) ))); 27 | 28 | BNNSC = positif(BNHREC - (BNHDEC * (1 - positif(ART1731BIS*PREM8_11)))) 29 | * arr((BNHREC-(BNHDEC * (1 - positif(ART1731BIS*PREM8_11))))*MAJREV) 30 | + (1-positif_ou_nul(BNHREC-(BNHDEC * (1 - positif(ART1731BIS*PREM8_11))))) 31 | *(BNHREC-(BNHDEC * (1 - positif(ART1731BIS*PREM8_11) ))); 32 | 33 | BNNSP = positif(BNHREP - (BNHDEP * (1 - positif(ART1731BIS*PREM8_11) ))) 34 | * arr((BNHREP-(BNHDEP * (1 - positif(ART1731BIS*PREM8_11))))*MAJREV) 35 | + (1-positif_ou_nul(BNHREP-(BNHDEP * (1 - positif(ART1731BIS*PREM8_11))))) 36 | *(BNHREP-(BNHDEP * (1 - positif(ART1731BIS*PREM8_11) ))); 37 | 38 | BNNAV = (BNCREV - BNCDEV * (1 - positif(ART1731BIS*PREM8_11))) ; 39 | BNNAC = (BNCREC - BNCDEC * (1 - positif(ART1731BIS*PREM8_11))) ; 40 | BNNAP = (BNCREP - BNCDEP * (1 - positif(ART1731BIS*PREM8_11))) ; 41 | BNNAAV = (BNCAABV - BNCAADV * (1 - positif(ART1731BIS*PREM8_11))) ; 42 | BNNAAC = (BNCAABC - BNCAADC * (1 - positif(ART1731BIS*PREM8_11))) ; 43 | BNNAAP = (BNCAABP - BNCAADP * (1 - positif(ART1731BIS*PREM8_11))) ; 44 | regle 862: 45 | application : iliad , batch ; 46 | VARDNOCEPV = min(max(DNOCEP,max(DNOCEP_P,DNOCEPP2)),ANOCEP); 47 | VARDNOCEPC = min(max(DNOCEPC,max(DNOCEPC_P,DNOCEPCP2)),ANOVEP); 48 | VARDNOCEPP = min(max(DNOCEPP,max(DNOCEPP_P,DNOCEPPP2)),ANOPEP); 49 | NOCEPV = ANOCEP - DNOCEP + (BNCAABV - BNCAADV); 50 | 51 | NOCEPC = ANOVEP - DNOCEPC + (BNCAABC - BNCAADC); 52 | 53 | NOCEPP = ANOPEP - DNOCEPP + (BNCAABP - BNCAADP); 54 | 55 | NOCEPIMPV = positif(ANOCEP - DNOCEP * (1 - positif(ART1731BIS*PREM8_11))) 56 | *arr((ANOCEP- DNOCEP * (1 - positif(ART1731BIS*PREM8_11)))*MAJREV) 57 | + positif_ou_nul(DNOCEP * (1 - positif(ART1731BIS*PREM8_11))-ANOCEP) 58 | *(ANOCEP- DNOCEP * (1 - positif(ART1731BIS*PREM8_11)))+BNNAAV; 59 | 60 | NOCEPIMPC = positif(ANOVEP - DNOCEPC * (1 - positif(ART1731BIS*PREM8_11))) 61 | *arr((ANOVEP- DNOCEPC * (1 - positif(ART1731BIS*PREM8_11)))*MAJREV) 62 | + positif_ou_nul(DNOCEPC * (1 - positif(ART1731BIS*PREM8_11))-ANOVEP) 63 | *(ANOVEP- DNOCEPC * (1 - positif(ART1731BIS*PREM8_11)))+BNNAAC; 64 | 65 | NOCEPIMPP = positif(ANOPEP - DNOCEPP * (1 - positif(ART1731BIS*PREM8_11))) 66 | *arr((ANOPEP- DNOCEPP * (1 - positif(ART1731BIS*PREM8_11)))*MAJREV) 67 | + positif_ou_nul(DNOCEPP * (1 - positif(ART1731BIS*PREM8_11))-ANOPEP) 68 | *(ANOPEP- DNOCEPP * (1 - positif(ART1731BIS*PREM8_11)))+BNNAAP; 69 | 70 | NOCEPIMP = NOCEPIMPV+NOCEPIMPC+NOCEPIMPP; 71 | 72 | TOTDABNCNP = null(4-V_IND_TRAIT) * (DABNCNP6 + DABNCNP5 + DABNCNP4 + DABNCNP3 + DABNCNP2 + DABNCNP1) * (1-positif(ART1731BIS*PREM8_11)) 73 | + null(5-V_IND_TRAIT) * max(0,min(DABNCNP6 + DABNCNP5 + DABNCNP4 + DABNCNP3 + DABNCNP2 + DABNCNP1,TOTDABNCNP1731*ART1731BIS*(1-PREM8_11)+ 74 | (DABNCNP6 + DABNCNP5 + DABNCNP4 + DABNCNP3 + DABNCNP2 + DABNCNP1) * (1-positif(ART1731BIS*PREM8_11)))); 75 | 76 | regle 862019: 77 | application : iliad ,batch ; 78 | BNN = (somme(i=V,C,P:BNRi) + SPENETPF + max(0,SPENETNPF + NOCEPIMP - TOTDABNCNP)) * (1-ART1731BIS) 79 | + (somme(i=V,C,P:BNRi) + SPENETPF + max(0,SPENETNPF + NOCEPIMP - DIDABNCNP+DEFBNCNPF)) * ART1731BIS*(1-PREM8_11) 80 | + (somme(i=V,C,P:BNRi) + SPENETPF + max(0,SPENETNPF + NOCEPIMP)) * ART1731BIS*PREM8_11 81 | ; 82 | regle 8621: 83 | application : iliad , batch ; 84 | pour i = V,C,P: 85 | BNNi = BNRi + SPENETi; 86 | regle 86211: 87 | application : iliad , batch ; 88 | pour i = V,C,P: 89 | BNRi = BNNSi + BNNAi; 90 | BNRTOT = BNRV + BNRC + BNRP; 91 | regle 863: 92 | application : iliad , batch ; 93 | BN1 = somme(i=V,C,P:BN1i); 94 | regle 8631: 95 | application : iliad , batch ; 96 | pour i = V,C,P: 97 | BN1i = BN1Ai + PVINiE + INVENTi; 98 | regle 864: 99 | application : iliad , batch ; 100 | pour i = V,C,P: 101 | SPETOTi = BNCPROi + BNCNPi; 102 | regle 8641: 103 | application : iliad , batch ; 104 | pour i = V,C,P: 105 | SPEBASABi=SPETOTi; 106 | pour i = V,C,P: 107 | SPEABi = arr((max(MIN_SPEBNC,(SPEBASABi * SPETXAB/100))) * 108 | positif_ou_nul(SPETOTi - MIN_SPEBNC)) + 109 | arr((min(MIN_SPEBNC,SPEBASABi )) * 110 | positif(MIN_SPEBNC - SPETOTi)); 111 | regle 86411: 112 | application : iliad , batch ; 113 | pour i = V,C,P: 114 | SPEABPi = arr((SPEABi * BNCPROi)/SPETOTi); 115 | pour i = V,C,P: 116 | SPEABNPi = SPEABi - SPEABPi; 117 | regle 8642: 118 | application : iliad , batch ; 119 | pour i = V,C,P: 120 | SPENETPi = max (0,(BNCPROi - SPEABPi)); 121 | pour i = V,C,P: 122 | SPENETNPi = max (0,(BNCNPi - SPEABNPi)); 123 | pour i = V,C,P: 124 | SPENETi = SPENETPi + SPENETNPi; 125 | SPENET = somme(i=V,C,P:(SPENETi)); 126 | regle 8650: 127 | application : iliad , batch ; 128 | SPENETCT = BNCPROPVV + BNCPROPVC + BNCPROPVP - BNCPMVCTV - BNCPMVCTC - BNCPMVCTP ; 129 | SPENETNPCT = BNCNPPVV + BNCNPPVC + BNCNPPVP - BNCNPDCT; 130 | regle 8660: 131 | application : iliad , batch ; 132 | SPENETPF = somme(i=V,C,P:SPENETPi) + SPENETCT; 133 | SPENETNPF = somme(i=V,C,P:SPENETNPi) + SPENETNPCT; 134 | BNCNPTOT = SPENETPF + SPENETNPF; 135 | regle 8680: 136 | application : iliad , batch ; 137 | pour i = V,C,P: 138 | SPEPVPi = BNCPRO1Ai - BNCPRODEi; 139 | pour i = V,C,P: 140 | SPEPVNPi = BNCNP1Ai - BNCNPDEi; 141 | SPEPV = somme(i=V,C,P:max(0,SPEPVPi + SPEPVNPi)); 142 | 143 | regle 8690: 144 | application : iliad , batch ; 145 | 146 | DCTSPE = positif_ou_nul(BNRTOT+SPENETPF) * BNCPMVCTV 147 | + ( 1 - positif_ou_nul(BNRTOT+SPENETPF)) * (BNCPMVCTV-abs(BNRTOT+SPENETPF)) 148 | + ( 1 - positif_ou_nul(BNRTOT+SPENETPF)) * null(BNCPMVCTV-abs(BNRTOT+SPENETPF))* BNCPMVCTV 149 | ; 150 | DCTSPENP = positif_ou_nul(NOCEPIMP+SPENETNPF) * BNCNPDCT 151 | + ( 1 - positif_ou_nul(NOCEPIMP+SPENETNPF)) * (BNCNPDCT-abs(NOCEPIMP+SPENETNPF)) 152 | + ( 1 - positif_ou_nul(NOCEPIMP+SPENETNPF)) * null(BNCNPDCT-abs(NOCEPIMP+SPENETNPF)) * BNCNPDCT 153 | ; 154 | regle 8691: 155 | application : iliad , batch ; 156 | 157 | BNCDF1 = ((1-positif_ou_nul(NOCEPIMP+SPENETNPF)) * abs(NOCEPIMP+SPENETNPF) 158 | + positif_ou_nul(NOCEPIMP+SPENETNPF) 159 | * positif_ou_nul(DABNCNP5+DABNCNP4+DABNCNP3+DABNCNP2+DABNCNP1-NOCEPIMP-SPENETNPF) 160 | * (DABNCNP5+DABNCNP4+DABNCNP3+DABNCNP2+DABNCNP1-NOCEPIMP-SPENETNPF) 161 | * null(BNCDF6+BNCDF5+BNCDF4+BNCDF3+BNCDF2)) 162 | * (1-positif(ART1731BIS)) 163 | + DEFBNCNPF * positif(ART1731BIS*(1-PREM8_11)) 164 | + (DNOCEP +DNOCEPC +DNOCEPP +BNCAADV +BNCAADC +BNCAADP) * positif(ART1731BIS*PREM8_11); 165 | regle 86911: 166 | application : iliad , batch ; 167 | BNCDF2 = ((1-positif_ou_nul(NOCEPIMP+SPENETNPF)) * (DABNCNP1) 168 | + positif_ou_nul(NOCEPIMP+SPENETNPF) 169 | * min(max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5-DABNCNP4-DABNCNP3-DABNCNP2,0)-DABNCNP1,DABNCNP1)*(-1) 170 | * positif_ou_nul(DABNCNP1-max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5-DABNCNP4-DABNCNP3-DABNCNP2,0))) 171 | * (1-positif(ART1731BIS)) 172 | + min(DABNCNP1,DABNCNP - DIDABNCNP) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 173 | + DABNCNP1 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 174 | 175 | 176 | regle 86912: 177 | application : iliad , batch ; 178 | BNCDF3 = ((1 - positif_ou_nul(NOCEPIMP+SPENETNPF)) * (DABNCNP2) 179 | + positif_ou_nul(NOCEPIMP+SPENETNPF) 180 | * min(max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5-DABNCNP4-DABNCNP3,0)-DABNCNP2,DABNCNP2)*(-1) 181 | * positif_ou_nul(DABNCNP2-max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5-DABNCNP4-DABNCNP3,0))) 182 | * (1-positif(ART1731BIS)) 183 | + min(DABNCNP2,DABNCNP - DIDABNCNP-BNCDF2) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 184 | + DABNCNP2 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 185 | regle 86913: 186 | application : iliad , batch ; 187 | BNCDF4 = ((1 - positif_ou_nul(NOCEPIMP+SPENETNPF)) * (DABNCNP3) 188 | + positif_ou_nul(NOCEPIMP+SPENETNPF) 189 | * min(max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5-DABNCNP4,0)-DABNCNP3,DABNCNP3)*(-1) 190 | * positif_ou_nul(DABNCNP3-max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5-DABNCNP4,0))) 191 | * (1-positif(ART1731BIS)) 192 | + min(DABNCNP3,DABNCNP - DIDABNCNP-BNCDF2-BNCDF3) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 193 | + DABNCNP3 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 194 | 195 | regle 86914: 196 | application : iliad , batch ; 197 | BNCDF5 = ((1 - positif_ou_nul(NOCEPIMP+SPENETNPF)) * (DABNCNP4) 198 | + positif_ou_nul(NOCEPIMP+SPENETNPF) 199 | * min(max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5,0)-DABNCNP4,DABNCNP4)*(-1) 200 | * positif_ou_nul(DABNCNP4-max(NOCEPIMP+SPENETNPF-DABNCNP6-DABNCNP5,0))) 201 | * (1-positif(ART1731BIS)) 202 | + min(DABNCNP4,DABNCNP - DIDABNCNP-BNCDF2-BNCDF3-BNCDF4) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 203 | + DABNCNP4 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 204 | regle 86915: 205 | application : iliad , batch ; 206 | BNCDF6 = ((1 - positif_ou_nul(NOCEPIMP+SPENETNPF)) * (DABNCNP5) 207 | + positif_ou_nul(NOCEPIMP+SPENETNPF) 208 | * min(max(NOCEPIMP+SPENETNPF-DABNCNP6,0)-DABNCNP5,DABNCNP5)*(-1) 209 | * positif_ou_nul(DABNCNP5-max(NOCEPIMP+SPENETNPF-DABNCNP6,0))) 210 | * (1-positif(ART1731BIS)) 211 | + min(DABNCNP5,DABNCNP - DIDABNCNP-BNCDF2-BNCDF3-BNCDF4-BNCDF5) * positif(ART1731BIS*(1-positif(PREM8_11+null(8-CMAJ)+null(11-CMAJ)))) 212 | + DABNCNP5 * positif(positif(ART1731BIS*PREM8_11)+null(8-CMAJ)+null(11-CMAJ)); 213 | 214 | regle 8692: 215 | application : iliad , batch ; 216 | DABNCNP = DABNCNP1 + DABNCNP2 + DABNCNP3 + DABNCNP4 + DABNCNP5 + DABNCNP6; 217 | VAREDABNCNP = min(DABNCNP,SPENETNPF + NOCEPIMP); 218 | DEFBNCNP = (NOCEPIMP+SPENETNPF+DIDABNCNP+DNOCEP+DNOCEPC+DNOCEPP+BNCAADV+BNCAADC+BNCAADP ); 219 | DEFBNCNPF = DEFRIBNC * (1-PREM8_11) * max(0,min(DNOCEP+DNOCEPC+DNOCEPP+BNCAADV+BNCAADC+BNCAADP,-(max(DEFBNCNP1731,max(DEFBNCNP_P,DEFBNCNPP2))-DNOCEP-DNOCEPC-DNOCEPP-BNCAADV-BNCAADC-BNCAADP))); 220 | -------------------------------------------------------------------------------- /src/chap-87.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 8740: 22 | application : iliad , batch ; 23 | XFORFAIT = somme(i=V,C,P: FEXi); 24 | regle 8741: 25 | application : iliad , batch ; 26 | XACCESS = somme(i=V,C,P: XACCESSi); 27 | regle 8745: 28 | application : iliad , batch ; 29 | pour i = V,P,C: 30 | XBAi = BAHEXi + BAEXi ; 31 | pour i = V,P,C: 32 | XBIPi = BIHEXi + BICEXi; 33 | pour i = V,P,C: 34 | XBINPi = BICNPHEXi + BICNPEXi; 35 | pour i = V,P,C: 36 | XBNi = BNHEXi + BNCEXi ; 37 | pour i = V,P,C: 38 | XBNNPi = BNCNPREXi+BNCNPREXAAi ; 39 | regle 872: 40 | application : iliad , batch ; 41 | pour i=V,C,P: 42 | XBICHDi = (BICEXi + BICNOi) ; 43 | pour i=V,C,P: 44 | XBICNETi = XBICHDi - (BICDNi * (1 - positif(ART1731BIS) )) ; 45 | pour i=V,C,P: 46 | XBICSi = XBICNETi + BA1Ai ; 47 | pour i=V,C,P: 48 | XBICNPHDi = BICNPEXi + BICREi ; 49 | pour i=V,C,P: 50 | XBICNPNETi = XBICNPHDi - (min(BICDEi,BICDEi1731+0) * positif(ART1731BIS) + BICDEi * (1 - ART1731BIS)); 51 | pour i=V,C,P: 52 | XBICNPSi = XBICNPNETi + BI2Ai ; 53 | pour i = V,C,P: 54 | XBITi = max (0 , XBICNETi + max (0,XBICNPNETi )); 55 | pour i = V,C,P: 56 | XBISi = positif(max(0,XBICNETi + max(0,XBICNPNETi))) 57 | * ( BI2Ai + BI1Ai ); 58 | 59 | pour i=V,C,P: 60 | XBICIMPi = XBICHDi + XBICNPHDi ; 61 | regle 8728: 62 | application : iliad , batch ; 63 | pour i=V,C: 64 | XTSBi = somme(x=1..3:GLDxi) + TSBNi + BPCOSAi + TSASSUi + XETRANi + EXOCETi 65 | + GLDGRATi; 66 | 67 | pour i=1,2,3,4: 68 | XTSBi = TSBNi ; 69 | pour i=V,C: 70 | XEXTSi = XTSBi + CARTSi + REMPLAi; 71 | pour i=1,2,3,4: 72 | XEXTSi = XTSBi + CARTSPi + REMPLAPi; 73 | regle 8731: 74 | application : iliad , batch ; 75 | pour i = V,C,1,2,3,4: 76 | XTPS10i = arr (XEXTSi * TX_DEDFORFTS /100); 77 | pour i = V,C,1,2,3,4: 78 | XDFNi = min( PLAF_DEDFORFTS , XTPS10i ); 79 | regle 8729: 80 | application : iliad , batch ; 81 | pour i = V,C,1,2,3,4: 82 | X10MINSi= max( min(XTSBi,DEDMINi) , XDFNi ); 83 | pour i = V,C,1,2,3,4: 84 | XIND_10i= positif_ou_nul(X10MINSi-FRNi); 85 | pour i = V,C,1,2,3,4: 86 | XDFi = X10MINSi ; 87 | pour i = V,C,1,2,3,4: 88 | XFPTi = XDFi * XIND_10i + FRDi * (1 - XIND_10i); 89 | pour i = V,C,1,2,3,4: 90 | XTSNTi = XEXTSi - XFPTi; 91 | regle 8734: 92 | application : iliad , batch ; 93 | pour i = V,C,1,2,3,4: 94 | XTSNi = positif (-XTSNTi) * min (0 , XTSNTi) 95 | + positif_ou_nul (XTSNTi) * XTSNTi; 96 | regle 8735: 97 | application : iliad , batch ; 98 | pour i = V,C: 99 | XTSi = XTSNi - somme(x=1..3: max(0,GLDxi - ABGLxi)); 100 | pour i = V,C: 101 | XTSNNi = arr( positif(XTSNi) * 102 | XTSNi 103 | * (TSASSUi/XEXTSi)) * XIND_10i 104 | + (1-XIND_10i) * TSASSUi; 105 | pour i = V,C: 106 | XETSNNi = arr( positif(XTSNi) * 107 | XTSNi 108 | * (XETRANi/XEXTSi)) * XIND_10i 109 | + (1-XIND_10i) * XETRANi; 110 | pour i = V,C: 111 | XEXOCETi = arr( positif(XTSNi) * 112 | XTSNi 113 | * (EXOCETi/XEXTSi)) * XIND_10i 114 | + (1-XIND_10i) * EXOCETi; 115 | XEXOCET = somme(i=V,C:XEXOCETi); 116 | 117 | regle 876: 118 | application : iliad , batch ; 119 | XELU = ELURASC + ELURASV ; 120 | regle 880: 121 | application : iliad , batch ; 122 | 123 | PVTAUX = (BPVSJ + BPVSK + BPV18V + BPV18C + BPCOPTV + BPCOPTC + BPV40V + BPV40C + PEA + GAINPEA); 124 | regle 875: 125 | application : iliad , batch ; 126 | GLN2NET = arr(GLN2 * GL2 / REV2); 127 | GLN3NET = arr(GLN3 * GL3 / REV3); 128 | QUOKIRE = TEGL1 + TEGL2 + TEGL3 + RPQ4 129 | + somme (x=V,C,1..4 : TERPQPRRx+TERPQPRRZx+ TEGLFx+ TERPQTSx+ TERPQTSREMPx+TERPQPALIMx) 130 | + TERPQRF1 + TEGLRF2 + TERPQRCMDC + TERPQRCMFU + TERPQRCMCH 131 | + TERPQRCMTS + TERPQRCMGO + TERPQRCMTR + TERPQRVO + TERPQRVO5 + TERPQRVO6 + TERPQRVO7; 132 | regle 8727: 133 | application : iliad , batch ; 134 | 135 | VARREVKIRE = BPCAPTAXV + BPCAPTAXC 136 | + somme( i=V,C,P: XBAi+XBIPi+XBINPi+XBNi+XBNNPi) 137 | + somme (i=V,C,P: MIBEXi + MIBNPEXi + BNCPROEXi + XSPENPi) 138 | + somme (i=V,C,P: BNCCRi) 139 | + somme (i=V,C,P: BNCCRFi) 140 | + somme (i=V,C: XETSNNi) 141 | + somme (i=V,C: XEXOCETi) 142 | + somme (i=V,C: XTSNNi) 143 | + somme (i=V,C: XTSNNTYi) 144 | + somme (i=V,C,1,2,3,4: XHSUPTSNNi) 145 | + XFORFAIT + XACCESS 146 | + RCMLIB + PPLIB 147 | + GAINABDET 148 | + RCMEXCREF 149 | + RCM2FA 150 | + XELU 151 | + RCMIMPAT 152 | + PVIMMO 153 | + PVMOBNR 154 | + PVTITRESOC 155 | + BTP3A 156 | + (1 - positif( IPVLOC )) * (1-positif(present(TAX1649)+present(RE168))) * ( 157 | PVTAUX ) 158 | ; 159 | PVTXEFF2 = max(0,(BPVRCM + COD3SG + COD3SL + ABDETPLUS + ABIMPPV) - (DPVRCM + COD3SH + COD3SM + ABDETMOINS + ABIMPMV)) ; 160 | PVTXEFF = (PVTAXSB + BPVRCM - PVTXEFF2) * positif(present(IPTEFN) + present(IPTEFP)) ; 161 | REVKIRE = (1-null(IND_TDR)) * 162 | arr ( 163 | max ( 0, ( 164 | (1-positif((max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 165 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF)) * (RI1RFR) 166 | + positif((max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 167 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF) 168 | * (max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 169 | + positif((max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 170 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF) 171 | * positif(- TEFFN - DRBG - RNIDF + (APERPV + APERPC + APERPP)* (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))) + QUOKIRE)* 172 | ( (APERPV + APERPC + APERPP)* (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))) 173 | + QUOKIRE 174 | ) 175 | + max(0,TEFFREVTOTRFR*INDTEFF) * (1-positif((max(0,VARIPTEFP- PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)))) 176 | ) 177 | * (1-present(IND_TDR)) 178 | + 179 | IND_TDR 180 | + (1-positif((max(0,VARIPTEFP - PVTXEFF)* positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 181 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+PVTXEFF*present(IPTEFN))* (1 - ART1731BIS))+INDTEFF)) * 182 | (QUOKIRE + (APERPV + APERPC + APERPP)* (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))) ) 183 | + VARREVKIRE 184 | ) 185 | ) 186 | ; 187 | 188 | pour i=V,C,P: 189 | BNCCREAi = BNCCRi + BNCCRFi ; 190 | QUOKIREHR = TGL1 + TGL2 + TGL3 + TGL4 191 | + somme (x=V,C,1..4 : TGLPRRx+TGLPRRZx+ TGLFx+ TGLTSx+ TGLTSREMPx+TGLPALIMx) 192 | + TGLRF1 + TGLRF2 + TGLRCMDC + TGLRCMFU + TGLRCMCH 193 | + TGLRCMTS + TGLRCMGO + TGLRCMTR + TGLRVO + TGLRVO5 + TGLRVO6 + TGLRVO7; 194 | REVKIREHR = ((1-null(IND_TDR)) * 195 | arr ( 196 | max ( 0, ( 197 | (1-positif((max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 198 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+ PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF)) * (RI1RFRHR) 199 | + positif((max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 200 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+ PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF) 201 | * (max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 202 | + positif((max(0,VARIPTEFP-PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 203 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF) 204 | * positif(- TEFFN - DRBG - RNIDF + (APERPV + APERPC + APERPP)* (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))) + QUOKIREHR)* 205 | ( (APERPV + APERPC + APERPP)* (1 - positif(null(2-V_REGCO) + null(4-V_REGCO))) 206 | + QUOKIREHR 207 | ) 208 | + max(0,TEFFREVTOTRFRHR*INDTEFF) * (1-positif((max(0,VARIPTEFP- PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)))) 209 | ) 210 | * (1-present(IND_TDR)) 211 | + 212 | IND_TDR 213 | + (1-positif((max(0,VARIPTEFP- PVTXEFF) * positif(ART1731BIS) + max(0,IPTEFP-PVTXEFF) * (1 - ART1731BIS)) 214 | +((VARIPTEFN+PVTXEFF*present(IPTEFN)) * positif(ART1731BIS) + (IPTEFN+PVTXEFF*present(IPTEFN)) * (1 - ART1731BIS))+INDTEFF)) * 215 | (QUOKIREHR + (APERPV + APERPC + APERPP)* (1 - positif(null(2-V_REGCO) + null(4-V_REGCO)))) 216 | + VARREVKIRE 217 | ) 218 | ) 219 | ) * (1-present(COD8YM)) + COD8YM ; 220 | regle 410 : 221 | application : batch, iliad; 222 | CDEVDUR_NBJ = PPENBJ; 223 | CKIREDUR = arr(REVKIRE * 360/CDEVDUR_NBJ); 224 | REVKIREDUR2 = CKIREDUR ; 225 | 226 | 227 | -------------------------------------------------------------------------------- /src/chap-88.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 881: 22 | application : iliad , batch ; 23 | pour i = V,C;x=1..3: 24 | GLNAVxi = max (GLDxi - ABGLxi,0) * INDEFTSi; 25 | GLDOMAVDAJV = max (CODDAJ - ABDOMDAJ,0) * INDEFTSV; 26 | GLDOMAVEAJV = max (CODEAJ - ABDOMEAJ,0) * INDEFTSV; 27 | GLDOMAVDBJC = max (CODDBJ - ABDOMDBJ,0) * INDEFTSC; 28 | GLDOMAVEBJC = max (CODEBJ - ABDOMEBJ,0) * INDEFTSC; 29 | GLN1V = max (GLD1V - ABGL1V,0) * INDEFTSV; 30 | GLN2V = max (GLD2V - ABGL2V,0) * INDEFTSV; 31 | GLN3V = max (GLD3V - ABGL3V,0) * INDEFTSV; 32 | GLN4DAJV = max(CODDAJ - ABDOMDAJ,0) * INDEFTSV; 33 | GLN4V = (max(CODDAJ - ABDOMDAJ,0)+max(CODEAJ - ABDOMEAJ,0)) * INDEFTSV; 34 | GLN1C = max (GLD1C - ABGL1C,0) * INDEFTSC; 35 | GLN2C = max (GLD2C - ABGL2C,0) * INDEFTSC; 36 | GLN3C = max (GLD3C - ABGL3C,0) * INDEFTSC; 37 | GLN4DBJC = max(CODDBJ - ABDOMDBJ,0) * INDEFTSC; 38 | GLN4C = (max(CODDBJ - ABDOMDBJ,0)+max(CODEBJ - ABDOMEBJ,0)) * INDEFTSC; 39 | regle 882: 40 | application : iliad , batch ; 41 | TSV = TSNV - somme(x=1..3: max(0,GLDxV - ABGLxV))-max(CODDAJ - ABDOMDAJ,0)-max(CODEAJ - ABDOMEAJ,0); 42 | TSC = TSNC - somme(x=1..3: max(0,GLDxC - ABGLxC))-max(CODDBJ - ABDOMDBJ,0)-max(CODEBJ - ABDOMEBJ,0); 43 | pour i=1..4: 44 | TSi = TSNi; 45 | pour i=V,C: 46 | TPRi = TSNi + PRNi - somme(x=1..3: GLNxi); 47 | pour i=1..4: 48 | TPRi = TSNi + PRNi; 49 | pour i = V,C : 50 | TSNNi = positif(TSi) *arr(TSi *(TSBNi + BPCOSAi + GLDGRATi)/EXTSi ) 51 | + (1 -positif(TSi)) * TSi ; 52 | pour i = 1..4 : 53 | TSNNi = (positif(TSi) * arr(TSi * TSBNi /EXTSi ) 54 | + (1 -positif(TSi)) * TSi) ; 55 | pour i = V,C : 56 | TSNN2i = ( positif(TSi) 57 | * ( positif(CARTSi+REMPLAi) 58 | * arr(TSi * 2TSNi / EXTSi ) 59 | + (1 -positif(CARTSi+REMPLAi)) 60 | * (TSi - TSNNi))); 61 | TSNN2VAFF = ( positif(TSV) 62 | * ( positif(CARTSV+REMPLAV) 63 | * arr(TSV * 2TSNV / EXTSV ) 64 | + (1 -positif(CARTSV+REMPLAV)) 65 | * (TSV - TSNNV)) 66 | + positif(CODDAJ + CODEAJ) * (max(CODDAJ - ABDOMDAJ,0)+max(CODEAJ - ABDOMEAJ,0))) ; 67 | TSNN2CAFF = ( positif(TSC) 68 | * ( positif(CARTSC+REMPLAC) 69 | * arr(TSC * 2TSNC / EXTSC ) 70 | + (1 -positif(CARTSC+REMPLAC)) 71 | * (TSC - TSNNC)) 72 | + positif(CODDBJ + CODEBJ) * (max(CODDBJ - ABDOMDBJ,0)+max(CODEBJ - ABDOMEBJ,0))) ; 73 | pour i = 1..4 : 74 | TSNN2i = ( positif(TSi) 75 | * ( positif(CARTSPi+REMPLAPi) 76 | * arr(TSi * 2TSNi /EXTSi ) 77 | + (1 -positif(CARTSPi+REMPLAPi)) 78 | * (TSi - TSNNi))) ; 79 | pour i = 1..4 : 80 | TSNN2iAFF = ( positif(TSi) 81 | * ( positif(CARTSPi+REMPLAPi) 82 | * arr(TSi * 2TSNi /EXTSi ) 83 | + (1 -positif(CARTSPi+REMPLAPi)) 84 | * (TSi - TSNNi))) ; 85 | 86 | TSNN2PAFF = somme(i=1..4:TSNN2iAFF) ; 87 | 88 | pour i = V,C : 89 | TSNN2TSi = ( positif(TSi) 90 | * ( positif(REMPLAi) 91 | * arr(TSi * CARTSi / EXTSi ) 92 | + (1 -positif(REMPLAi)) 93 | * (TSi - TSNNi))) ; 94 | pour i = 1..4 : 95 | TSNN2TSi = ( positif(TSi) 96 | * ( positif(REMPLAPi) 97 | * arr(TSi * CARTSPi /EXTSi ) 98 | + (1 -positif(REMPLAPi)) 99 | * (TSi - TSNNi))) ; 100 | pour i = V,C : 101 | TSNN2REMPi = (positif(TSi) * (TSi - TSNNi-TSNN2TSi)) ; 102 | pour i = 1..4 : 103 | TSNN2REMPi = (positif(TSi) * (TSi - TSNNi-TSNN2TSi)) ; 104 | 105 | regle 883: 106 | application : iliad , batch ; 107 | pour i = V,C,1..4: 108 | PRRi = arr(PRNi * PRBi / EXPRi); 109 | PRR2V = positif(PEBFV+PENSALV+CODRAZ) * arr(PRNV * CARPEV / EXPRV) 110 | + (1 -positif(PEBFV+PENSALV+CODRAZ)) * (PRNV -PRRV) ; 111 | PRR2C = positif(PEBFC+PENSALC+CODRBZ) * arr(PRNC * CARPEC / EXPRC) 112 | + (1 -positif(PEBFC+PENSALC+CODRBZ)) * (PRNC -PRRC) ; 113 | PRR21 = positif(PEBF1+PENSALP1+CODRCZ) * arr(PRN1 * CARPEP1 / EXPR1 ) 114 | + (1 -positif(PEBF1+PENSALP1+CODRCZ)) * (PRN1 -PRR1); 115 | PRR22 = positif(PEBF2+PENSALP2+CODRDZ) * arr(PRN2 * CARPEP2 / EXPR2 ) 116 | + (1 -positif(PEBF2+PENSALP2+CODRDZ)) * (PRN2 -PRR2); 117 | PRR23 = positif(PEBF3+PENSALP3+CODREZ) * arr(PRN3 * CARPEP3 / EXPR3 ) 118 | + (1 -positif(PEBF3+PENSALP3+CODREZ)) * (PRN3 -PRR3); 119 | PRR24 = positif(PEBF4+PENSALP4+CODRFZ) * arr(PRN4 * CARPEP4 / EXPR4 ) 120 | + (1 -positif(PEBF4+PENSALP4+CODRFZ)) * (PRN4 -PRR4); 121 | PRR2ZV = positif(PEBFV+PENSALV) * arr(PRNV * CODRAZ / EXPRV) 122 | + (1 -positif(PEBFV+PENSALV)) * (PRNV -PRRV-PRR2V) ; 123 | PRR2ZC = positif(PEBFC+PENSALC) * arr(PRNC * CODRBZ / EXPRC) 124 | + (1 -positif(PEBFC+PENSALC)) * (PRNC -PRRC-PRR2C) ; 125 | PRR2Z1 = positif(PEBF1+PENSALP1) * arr(PRN1 * CODRCZ / EXPR1 ) 126 | + (1 -positif(PEBF1+PENSALP1)) * (PRN1 -PRR1-PRR21); 127 | PRR2Z2 = positif(PEBF2+PENSALP2) * arr(PRN2 * CODRDZ / EXPR2 ) 128 | + (1 -positif(PEBF2+PENSALP2)) * (PRN2 -PRR2-PRR22); 129 | PRR2Z3 = positif(PEBF3+PENSALP3) * arr(PRN3 * CODREZ / EXPR3 ) 130 | + (1 -positif(PEBF3+PENSALP3)) * (PRN3 -PRR3-PRR23); 131 | PRR2Z4 = positif(PEBF4+PENSALP4) * arr(PRN4 * CODRFZ / EXPR4 ) 132 | + (1 -positif(PEBF4+PENSALP4)) * (PRN4 -PRR4-PRR24); 133 | PRR2ZP = PRR2Z1 + PRR2Z2 + PRR2Z3 + PRR2Z4; 134 | pour i = V,C: 135 | PENFi = positif(PENSALi) * arr(PRNi * PEBFi / EXPRi) 136 | + (1 - positif(PENSALi)) * max(0,(PRNi -PRRi -PRR2i-PRR2Zi)); 137 | pour i = 1..4: 138 | PENFi = positif(PENSALPi) * arr(PRNi * PEBFi / EXPRi) 139 | + (1- positif(PENSALPi)) * (PRNi -PRRi -PRR2i-PRR2Zi); 140 | pour i = V,C: 141 | PENALIMi = positif(EXPRi) * (PRNi -PRRi -PRR2i -PRR2Zi- PENFi) ; 142 | pour i = 1..4: 143 | PENALIMi = positif(EXPRi) * (PRNi -PRRi -PRR2i -PRR2Zi- PENFi) ; 144 | regle 884: 145 | application : iliad , batch ; 146 | pour i = 1,2,3,4: 147 | RVi = arr(RVBi * TXRVTi / 100); 148 | RVTOT = RV1 + RV2 + RV3 + RV4; 149 | regle 885: 150 | application : iliad , batch ; 151 | 2RV1 = arr(RENTAX * TXRVT1 / 100); 152 | 2RV2 = arr(RENTAX5 * TXRVT2 / 100); 153 | 2RV3 = arr(RENTAX6 * TXRVT3 / 100); 154 | 2RV4 = arr(RENTAX7 * TXRVT4 / 100); 155 | T2RV = 2RV1 + 2RV2 + 2RV3 + 2RV4; 156 | regle 886: 157 | application : iliad , batch ; 158 | RVBCSG = arr((RVB1 + RENTAX) * TXRVT1 / 100) 159 | + arr((RVB2 + RENTAX5) * TXRVT2 / 100) 160 | + arr((RVB3 + RENTAX6) * TXRVT3 / 100) 161 | + arr((RVB4 + RENTAX7) * TXRVT4 / 100) ; 162 | 163 | regle 887: 164 | application : iliad , batch ; 165 | TSPR = TSPRT + RVTOT ; 166 | regle 888: 167 | application : iliad , batch ; 168 | pour i=V,C,1..4: 169 | TSPRi = (TSNNi + PRRi) * (1-PREM8_11) + max(0,TSNNi + PRRi) * PREM8_11; 170 | pour i=V,C,1..4: 171 | TSPRDi = min(0,TSNNi + PRRi)* ART1731BIS ; 172 | TSPRP = somme(i=1..4:TSPRi) * (1-PREM8_11) + max(0,TSNN1+PRR1+TSNN2+PRR2+TSNN3+PRR3+TSNN4+PRR4) * PREM8_11 ; 173 | TSPRTOT = somme(i=V,C,1..4:TSPRi)*(1-ART1731BIS) + max(0,TSNNV+PRRV+TSNNC+PRRC+TSNN1+PRR1+TSNN2+PRR2+TSNN3+PRR3+TSNN4+PRR4)*ART1731BIS; 174 | TSPRDP = somme(i=1..4:TSPRDi) ; 175 | TSNNT = abs(TSNNV + PRRV 176 | + TSNNC + PRRC 177 | + TSNN1 + PRR1 178 | + TSNN2 + PRR2 179 | + TSNN3 + PRR3 180 | + TSNN4 + PRR4) 181 | * (1-positif(TSNNV + PRRV + TSNNC + PRRC+ TSNN1 + PRR1 + TSNN2 + PRR2 + TSNN3 + PRR3 + TSNN4 + PRR4 )); 182 | regle 8887: 183 | application : iliad , batch ; 184 | pour i=V,C,1..4: 185 | FRNRETENUi = max(0,FRNRETi + TSPRDi); 186 | regle 8810: 187 | application : iliad , batch ; 188 | TSNN2P = somme(i=1..4: TSNN2i); 189 | PRR2P =somme(i=1..4: PRR2i); 190 | PENFP = PENF1 + PENF2 + PENF3 + PENF4 ; 191 | PENALIMP = PENALIM1 + PENALIM2 + PENALIM3 + PENALIM4; 192 | 193 | regle 8811: 194 | application : iliad , batch ; 195 | TSQVO = 2TSNV+CODDAJ+CODEAJ; 196 | TSQCJ = 2TSNC+CODDBJ+CODEBJ; 197 | TSQPC = somme(i=1..4: 2TSNi ) ; 198 | PRQVO = CARPEV + PEBFV; 199 | PRQCJ = CARPEC + PEBFC; 200 | PRQPC = CARPEP1+PEBF1 201 | + CARPEP2+PEBF2 202 | + CARPEP3+PEBF3 203 | + CARPEP4+PEBF4; 204 | PRQZV = CODRAZ; 205 | PRQZC = CODRBZ; 206 | PRQZP = CODRCZ +CODRDZ+CODREZ+CODRFZ; 207 | PENSALP = PENSALP1 + PENSALP2 + PENSALP3 + PENSALP4; 208 | regle 8812: 209 | application : iliad , batch ; 210 | PRQNV = 2PRBV; 211 | PRQNC = 2PRBC; 212 | PRQNP = somme(i=1..4: 2PRBi) ; 213 | PENSTOTV = PRR2V + PRR2ZV + PENALIMV; 214 | PENSTOTC = PRR2C + PRR2ZC + PENALIMC; 215 | PENSTOTP = PRR2P + PRR2Z1 + PRR2Z2 + PRR2Z3 + PRR2Z4 + PENALIMP; 216 | regle 8815: 217 | application : iliad , batch ; 218 | pour i=V,C: 219 | BPCAPTAXi = PCAPTAXi - arr(PCAPTAXi * TX_DEDPER/100); 220 | pour i=V,C: 221 | IPCAPTAXi = arr(BPCAPTAXi * T_PCAPTAX/100); 222 | IPCAPTAXTOT = somme(i=V,C:IPCAPTAXi); 223 | regle 8816: 224 | application : iliad , batch ; 225 | IPCAPTAXT = IPCAPTAXTOT - CICAP; 226 | -------------------------------------------------------------------------------- /src/chap-cor.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | 22 | regle corrective base_INITIAL 1080: 23 | application : iliad ; 24 | PRS_P = PRS; 25 | CSG_P = CSG; 26 | RDS_P = RDSN; 27 | IRNIN_P = IRN ; 28 | IRNIN_INR_P = IRNIN_INR; 29 | CSBASE_INR_P = CSBASE_INR; 30 | PSBASE_INR_P = PSBASE_INR; 31 | RDBASE_INR_P = RDBASE_INR; 32 | CDISBASE_INR_P = CDISBASE_INR; 33 | CVNBASE_INR_P = CVNBASE_INR; 34 | GLOBASE_INR_P = GLOBASE_INR; 35 | RSE1BASE_INR_P = RSE1BASE_INR; 36 | RSE2BASE_INR_P = RSE2BASE_INR; 37 | RSE3BASE_INR_P = RSE3BASE_INR; 38 | RSE4BASE_INR_P = RSE4BASE_INR; 39 | RSE5BASE_INR_P = RSE5BASE_INR; 40 | TAXABASE_INR_P = TAXABASE_INR; 41 | PCAPBASE_INR_P = PCAPBASE_INR; 42 | LOYBASE_INR_P = LOYBASE_INR; 43 | CHRBASE_INR_P = CHRBASE_INR; 44 | REGVBASE_INR_P = REGVBASE_INR; 45 | CSREC_P = CSREC; 46 | NAPCR_P = NAPCR; 47 | TAXA_P = TAXABASE ; 48 | CHR_P = CHRBASE ; 49 | TAXABRUT_P = TAXASSUR ; 50 | PCAPBRUT_P = IPCAPTAXT ; 51 | CHRBRUT_P = IHAUTREVT ; 52 | PCAP_P = PCAPBASE ; 53 | RSE1_P = RSE1BASE ; 54 | RSE2_P = RSE2BASE ; 55 | RSE3_P = RSE3BASE ; 56 | RSE4_P = RSE4BASE ; 57 | CDIS_P = CDISBASE ; 58 | VAR7WY_P = DEPCHOBAS; 59 | VAR7WZ_P = DEPMOBIL; 60 | VAR7WD_P = COD7WD; 61 | ISF_P = ISF4BASE; 62 | 63 | ACOTFOR_P = ACOTFOR ; 64 | RCOTFOR_P = RCOTFOR ; 65 | AREPA_P = AREPA ; 66 | RREPA_P = RREPA ; 67 | AAIDE_P = AAIDE ; 68 | RAIDE_P = RAIDE ; 69 | ADIFAGRI_P = ADIFAGRI ; 70 | RDIFAGRI_P = RDIFAGRI ; 71 | AFORET_P = AFORET ; 72 | RFORET_P = RFORET ; 73 | AFIPDOM_P = AFIPDOM ; 74 | RFIPDOM_P = RFIPDOM ; 75 | AFIPC_P = AFIPC ; 76 | RFIPC_P = RFIPC ; 77 | ACINE_P = ACINE ; 78 | RCINE_P = RCINE ; 79 | ARESTIMO_P = ARESTIMO ; 80 | RRESTIMO_P = RRESTIMO ; 81 | ASOCREPR_P = ASOCREPR ; 82 | RSOCREPR_P = RSOCREPR ; 83 | APRESCOMP_P = APRESCOMP ; 84 | RRPRESCOMP_P = RRPRESCOMP ; 85 | AHEBE_P = AHEBE ; 86 | RHEBE_P = RHEBE ; 87 | ASURV_P = ASURV ; 88 | RSURV_P = RSURV ; 89 | BFCPI_P = BFCPI ; 90 | RINNO_P = RINNO ; 91 | ASOUFIP_P = ASOUFIP ; 92 | RSOUFIP_P = RSOUFIP ; 93 | ARIRENOV_P = ARIRENOV ; 94 | RRIRENOV_P = RRIRENOV ; 95 | ALOGDOM_P = ALOGDOM ; 96 | RLOGDOM_P = RLOGDOM ; 97 | ACREAT_P = ACREAT ; 98 | RCREAT_P = RCREAT ; 99 | ACOMP_P = ACOMP ; 100 | RCOMP_P = RCOMP ; 101 | RRETU_P = RRETU ; 102 | ADONS_P = ADONS ; 103 | RDONS_P = RDONS ; 104 | ADUFLOGIH_P = ADUFLOGIH ; 105 | RDUFLOGIH_P = RDUFLOGIH ; 106 | ANOUV_P = ANOUV ; 107 | RNOUV_P = RNOUV ; 108 | AFOREST_P = AFOREST ; 109 | RFOR_P = RFOR ; 110 | ATOURREP_P = ATOURREP ; 111 | RTOURREP_P = RTOURREP ; 112 | ATOUHOTR_P = ATOUHOTR ; 113 | RTOUHOTR_P = RTOUHOTR ; 114 | ATOUREPA_P = ATOUREPA ; 115 | RTOUREPA_P = RTOUREPA ; 116 | ACELRREDLA_P = ACELRREDLA ; 117 | RCELRREDLA_P = RCELRREDLA ; 118 | ACELRREDLB_P = ACELRREDLB ; 119 | RCELRREDLB_P = RCELRREDLB ; 120 | ACELRREDLE_P = ACELRREDLE ; 121 | RCELRREDLE_P = RCELRREDLE ; 122 | ACELRREDLM_P = ACELRREDLM ; 123 | RCELRREDLM_P = RCELRREDLM ; 124 | ACELRREDLC_P = ACELRREDLC ; 125 | RCELRREDLC_P = RCELRREDLC ; 126 | ACELRREDLD_P = ACELRREDLD ; 127 | RCELRREDLD_P = RCELRREDLD ; 128 | ACELRREDLS_P = ACELRREDLS ; 129 | RCELRREDLS_P = RCELRREDLS ; 130 | ACELRREDLF_P = ACELRREDLF ; 131 | RCELRREDLF_P = RCELRREDLF ; 132 | ACELRREDLZ_P = ACELRREDLZ ; 133 | RCELRREDLZ_P = RCELRREDLZ ; 134 | ACELRREDMG_P = ACELRREDMG ; 135 | RCELRREDMG_P = RCELRREDMG ; 136 | ACELREPHS_P = ACELREPHS ; 137 | RCELREPHS_P = RCELREPHS ; 138 | ACELREPHR_P = ACELREPHR ; 139 | RCELREPHR_P = RCELREPHR ; 140 | ACELREPHU_P = ACELREPHU ; 141 | RCELREPHU_P = RCELREPHU ; 142 | ACELREPHT_P = ACELREPHT ; 143 | RCELREPHT_P = RCELREPHT ; 144 | ACELREPHZ_P = ACELREPHZ ; 145 | RCELREPHZ_P = RCELREPHZ ; 146 | ACELREPHX_P = ACELREPHX ; 147 | RCELREPHX_P = RCELREPHX ; 148 | ACELREPHW_P = ACELREPHW ; 149 | RCELREPHW_P = RCELREPHW ; 150 | ACELREPHV_P = ACELREPHV ; 151 | RCELREPHV_P = RCELREPHV ; 152 | ACELREPHF_P = ACELREPHF ; 153 | RCELREPHF_P = RCELREPHF ; 154 | ACELREPHE_P = ACELREPHE ; 155 | RCELREPHE_P = RCELREPHE ; 156 | ACELREPHD_P = ACELREPHD ; 157 | RCELREPHD_P = RCELREPHD ; 158 | ACELREPHH_P = ACELREPHH ; 159 | RCELREPHH_P = RCELREPHH ; 160 | ACELREPHG_P = ACELREPHG ; 161 | RCELREPHG_P = RCELREPHG ; 162 | ACELREPHB_P = ACELREPHB ; 163 | RCELREPHB_P = RCELREPHB ; 164 | ACELREPHA_P = ACELREPHA ; 165 | RCELREPHA_P = RCELREPHA ; 166 | ACELREPGU_P = ACELREPGU ; 167 | RCELREPGU_P = RCELREPGU ; 168 | ACELREPGX_P = ACELREPGX ; 169 | RCELREPGX_P = RCELREPGX ; 170 | ACELREPGT_P = ACELREPGT ; 171 | RCELREPGT_P = RCELREPGT ; 172 | ACELREPGS_P = ACELREPGS ; 173 | RCELREPGS_P = RCELREPGS ; 174 | ACELREPGW_P = ACELREPGW ; 175 | RCELREPGW_P = RCELREPGW ; 176 | ACELREPGP_P = ACELREPGP ; 177 | RCELREPGP_P = RCELREPGP ; 178 | ACELREPGL_P = ACELREPGL ; 179 | RCELREPGL_P = RCELREPGL ; 180 | ACELREPGV_P = ACELREPGV ; 181 | RCELREPGV_P = RCELREPGV ; 182 | ACELREPGK_P = ACELREPGK ; 183 | RCELREPGK_P = RCELREPGK ; 184 | ACELREPGJ_P = ACELREPGJ ; 185 | RCELREPGJ_P = RCELREPGJ ; 186 | ACELHM_P = ACELHM ; 187 | RCELHM_P = RCELHM ; 188 | 189 | 190 | ACELHL_P = ACELHL ; 191 | RCELHL_P = RCELHL ; 192 | ACELHNO_P = ACELHNO ; 193 | RCELHNO_P = RCELHNO ; 194 | ACELHJK_P = ACELHJK ; 195 | RCELHJK_P = RCELHJK ; 196 | ACELNQ_P = ACELNQ ; 197 | RCELNQ_P = RCELNQ ; 198 | ACELNBGL_P = ACELNBGL ; 199 | RCELNBGL_P = RCELNBGL ; 200 | ACELCOM_P = ACELCOM ; 201 | RCELCOM_P = RCELCOM ; 202 | ACEL_P = ACEL ; 203 | RCEL_P = RCEL ; 204 | ACELJP_P = ACELJP ; 205 | RCELJP_P = RCELJP ; 206 | ACELJBGL_P = ACELJBGL ; 207 | RCELJBGL_P = RCELJBGL ; 208 | ACELJOQR_P = ACELJOQR ; 209 | RCELJOQR_P = RCELJOQR ; 210 | ACEL2012_P = ACEL2012 ; 211 | RCEL2012_P = RCEL2012 ; 212 | ACELFD_P = ACELFD ; 213 | RCELFD_P = RCELFD ; 214 | ACELFABC_P = ACELFABC ; 215 | RCELFABC_P = RCELFABC ; 216 | AREDMEUB_P = AREDMEUB ; 217 | RREDMEUB_P = RREDMEUB ; 218 | AREDREP_P = AREDREP ; 219 | RREDREP_P = RREDREP ; 220 | AILMIX_P = AILMIX ; 221 | RILMIX_P = RILMIX ; 222 | AILMIY_P = AILMIY ; 223 | RILMIY_P = RILMIY ; 224 | AINVRED_P = AINVRED ; 225 | RINVRED_P = RINVRED ; 226 | AILMIH_P = AILMIH ; 227 | RILMIH_P = RILMIH ; 228 | AILMJC_P = AILMJC ; 229 | RILMJC_P = RILMJC ; 230 | AILMIZ_P = AILMIZ ; 231 | RILMIZ_P = RILMIZ ; 232 | AILMJI_P = AILMJI ; 233 | RILMJI_P = RILMJI ; 234 | AILMJS_P = AILMJS ; 235 | RILMJS_P = RILMJS ; 236 | AMEUBLE_P = AMEUBLE ; 237 | RMEUBLE_P = RMEUBLE ; 238 | APROREP_P = APROREP ; 239 | RPROREP_P = RPROREP ; 240 | AREPNPRO_P = AREPNPRO ; 241 | RREPNPRO_P = RREPNPRO ; 242 | AREPMEU_P = AREPMEU ; 243 | RREPMEU_P = RREPMEU ; 244 | AILMIC_P = AILMIC ; 245 | RILMIC_P = RILMIC ; 246 | AILMIB_P = AILMIB ; 247 | RILMIB_P = RILMIB ; 248 | AILMIA_P = AILMIA ; 249 | RILMIA_P = RILMIA ; 250 | AILMJY_P = AILMJY ; 251 | RILMJY_P = RILMJY ; 252 | AILMJX_P = AILMJX ; 253 | RILMJX_P = RILMJX ; 254 | AILMJW_P = AILMJW ; 255 | RILMJW_P = RILMJW ; 256 | AILMJV_P = AILMJV ; 257 | RILMJV_P = RILMJV ; 258 | ARESIMEUB_P = ARESIMEUB ; 259 | RRESIMEUB_P = RRESIMEUB ; 260 | RCODIW_P = RCODIW ; 261 | RCODIM_P = RCODIM ; 262 | RCODIL_P = RCODIL ; 263 | RCODIN_P = RCODIN ; 264 | RCODIV_P = RCODIV ; 265 | RCODIJ_P = RCODIJ ; 266 | RCODIE_P = RCODIE ; 267 | RCODIF_P = RCODIF ; 268 | RCODIG_P = RCODIG ; 269 | RCODID_P = RCODID ; 270 | RCODJU_P = RCODJU ; 271 | RCODJT_P = RCODJT ; 272 | APATNAT1_P = APATNAT1 ; 273 | RPATNAT1_P = RPATNAT1 ; 274 | APATNAT2_P = APATNAT2 ; 275 | RPATNAT2_P = RPATNAT2 ; 276 | APATNAT3_P = APATNAT3 ; 277 | RPATNAT3_P = RPATNAT3 ; 278 | APATNAT_P = APATNAT ; 279 | RPATNAT_P = RPATNAT ; 280 | ADOMSOC1_P = ADOMSOC1 ; 281 | RDOMSOC1_P = RDOMSOC1 ; 282 | ALOGSOC_P = ALOGSOC ; 283 | RLOGSOC_P = RLOGSOC ; 284 | DIDOMPRO_P = DIDOMPRO ; 285 | RIDOMPROE3_P = RIDOMPROE3 ; 286 | ACOLENT_P = ACOLENT ; 287 | RCOLENT_P = RCOLENT ; 288 | ALOCENT_P = ALOCENT ; 289 | RLOCENT_P = RLOCENT ; 290 | 291 | ITRED_P = ITRED ; 292 | BICREV_P = BICREV; 293 | BICREC_P = BICREC; 294 | BICREP_P = BICREP; 295 | BICHREV_P = BICHREV; 296 | BICHREC_P = BICHREC; 297 | BICHREP_P = BICHREP; 298 | DNOCEP_P = DNOCEP; 299 | DNOCEPC_P = DNOCEPC; 300 | DNOCEPP_P = DNOCEPP; 301 | BNCAADV_P = BNCAADV; 302 | BNCDEC_P = BNCDEC; 303 | BNCDEP_P = BNCDEP; 304 | BNCDEV_P = BNCDEV; 305 | BNCAADC_P = BNCAADC; 306 | BNCAADP_P = BNCAADP; 307 | BAHDEV_P = VARBAHDEV; 308 | BAHDEC_P = VARBAHDEC; 309 | BAHDEP_P = VARBAHDEP; 310 | BACDEV_P = VARBACDEV; 311 | BACDEC_P = VARBACDEC; 312 | BACDEP_P = VARBACDEP; 313 | RCMFR_P = min(RCMAB + RTNC + RAVC + RCMNAB + RTCAR + RCMPRIVM,RCMFR); 314 | RCMFRNET_P = max(0,RCMFR - RCMAB - RTNC - RAVC - RCMNAB - RTCAR - RCMPRIVM); 315 | TSNNV_P = abs(TSNNV) * min(0,TSNNV); 316 | TSNNC_P = abs(TSNNC) * min(0,TSNNC); 317 | TSNN1_P = abs(TSNN1) * min(0,TSNN1); 318 | TSNN2_P = abs(TSNN2) * min(0,TSNN2); 319 | TSNN3_P = abs(TSNN3) * min(0,TSNN3); 320 | TSNN4_P = abs(TSNN4) * min(0,TSNN4); 321 | TSNNT_P = abs(TSNNT) * min(0,TSNNT); 322 | FRDV_P = FRDV; 323 | FRDC_P = FRDC; 324 | FRD1_P = FRD1; 325 | FRD2_P = FRD2; 326 | FRD3_P = FRD3; 327 | FRD4_P = FRD4; 328 | TFRDV_P = TFRDV; 329 | TFRDC_P = TFRDC; 330 | TFRD1_P = TFRD1; 331 | TFRD2_P = TFRD2; 332 | TFRD3_P = TFRD3; 333 | TFRD4_P = TFRD4; 334 | SOMMEBA_P = SOMMEBA; 335 | SOMMEBIC_P = SOMMEBIC; 336 | SOMMELOC_P = SOMMELOC; 337 | SOMMEBNC_P = SOMMEBNC; 338 | SOMMERF_P = SOMMERF; 339 | SOMMERCM_P = SOMMERCM; 340 | TSBV_P = TSBV; 341 | TSBC_P = TSBC; 342 | TSB1_P = TSB1; 343 | TSB2_P = TSB2; 344 | TSB3_P = TSB3; 345 | TSB4_P = TSB4; 346 | TSBP_P = TSB1 +TSB2 +TSB3 + TSB4; 347 | TTSBV_P = TTSBV; 348 | TTSBC_P = TTSBC; 349 | TTSB1_P = TTSB1; 350 | TTSB2_P = TTSB2; 351 | TTSB3_P = TTSB3; 352 | TTSB4_P = TTSB4; 353 | RRCM_P = RRCM; 354 | REVRCM_P = REVRCM; 355 | RRFI_P = RRFI; 356 | REVRF_P = REVRF; 357 | RBAT_P = RBAT; 358 | BAQTOTAVIS_P = BAQTOTAVIS; 359 | BICNPF_P = BICNPF; 360 | BNCIF_P = BNCIF; 361 | BAHREV_P = BAHREV; 362 | 4BAHREV_P = 4BAHREV; 363 | BAHREC_P = BAHREC; 364 | 4BAHREC_P = 4BAHREC; 365 | BAHREP_P = BAHREP; 366 | 4BAHREP_P = 4BAHREP; 367 | BACREV_P = BACREV; 368 | 4BACREV_P = 4BACREV; 369 | BACREC_P = BACREC; 370 | 4BACREC_P = 4BACREC; 371 | BACREP_P = BACREP; 372 | 4BACREP_P = 4BACREP; 373 | LOCPROCGAV_P = LOCPROCGAV; 374 | LOCPROCGAC_P = LOCPROCGAC; 375 | LOCPROCGAP_P = LOCPROCGAP; 376 | LOCPROV_P = LOCPROV; 377 | LOCPROC_P = LOCPROC; 378 | LOCPROP_P = LOCPROP; 379 | LOCNPCGAV_P = LOCNPCGAV; 380 | LOCGITCV_P = LOCGITCV; 381 | LOCNPCGAC_P = LOCNPCGAC; 382 | LOCGITCC_P = LOCGITCC; 383 | LOCNPCGAPAC_P = LOCNPCGAPAC; 384 | LOCGITCP_P = LOCGITCP; 385 | LOCNPV_P = LOCNPV; 386 | LOCNPC_P = LOCNPC; 387 | LOCNPPAC_P = LOCNPPAC; 388 | BNHREV_P = BNHREV; 389 | BNHREC_P = BNHREC; 390 | BNHREP_P = BNHREP; 391 | BNCREV_P = BNCREV; 392 | BNCREC_P = BNCREC; 393 | BNCREP_P = BNCREP; 394 | BNCAABV_P = BNCAABV; 395 | BNCAABC_P = BNCAABC; 396 | BNCAABP_P = BNCAABP; 397 | LOCGITHCV_P = LOCGITHCV; 398 | LOCGITHCC_P = LOCGITHCC; 399 | LOCGITHCP_P = LOCGITHCP; 400 | RFDHIS_P = RFDHIS; 401 | DFRCMNBIS_P = DFRCMNBIS; 402 | TSPRV_P = TSPRV; 403 | TSPRC_P = TSPRC; 404 | TSPRP_P = TSPRP; 405 | ESFP_P = ESFP; 406 | TSPR_P = TSPR; 407 | RCM_P = RCM; 408 | BIN_P = BIN; 409 | BNN_P = BNN; 410 | PLOCNETF_P = PLOCNETF; 411 | NPLOCNETF_P = NPLOCNETF; 412 | BRCMTOT_P = BRCMTOT; 413 | DFBICNPF_P = DFBICNPF; 414 | DEFNPI_P = DEFNPI; 415 | DEFLOCNP_P = DEFLOCNP; 416 | DNPLOCIMPU_P = DNPLOCIMPU; 417 | DEFBNCNP_P = DEFBNCNP; 418 | DIDABNCNP1_P = DIDABNCNP1; 419 | DEFBANI_P = DEFBANI; 420 | REPRCM_P = REPRCMB; 421 | BRCM_P = BRCMBIS; 422 | BRCMQ_P = BRCMQ; 423 | DEF4BB_P = DEF4BB; 424 | DEF4BD_P = DEF4BD; 425 | DFANTPROV_P = DFANTPROV; 426 | DAGRIIMP_P = DAGRIIMP; 427 | TOTALQUO_P = TOTALQUO; 428 | 429 | regle corrective base_anterieure_cor 11: 430 | application : iliad ; 431 | ANTINDIRPS = INDIRPS ; 432 | ANTPPETOT = PPETOTX ; 433 | ANTPPEREST2A = PPEREST2A ; 434 | ANTPPEIMP2A = PPEIMP2A ; 435 | IND_PASSAGE_A = IND_PASSAGE; 436 | IND_PASSR9901_A = IND_PASSR9901; 437 | INR_GLO_TARDIF_A=INR_GLO_TARDIF; 438 | TXINR_A=TXINR; 439 | TXINRRED_A=TXINRRED; 440 | TXINRREDISF_A=TXINRREDISF; 441 | TXINR_PA_A = TXINR_PA; 442 | TXINRISF_PA_A = TXINRISF_PA; 443 | TINR_A=TINR; 444 | TXINRISF_A=TXINRISF; 445 | RETXISF_A=RETXISF; 446 | TINR_1_A=TINR_1; 447 | NBREMOISCS2_A=NBREMOISCS2; 448 | NBREMOISCS222_A=NBREMOISCS222; 449 | NBREMOIS2_A=NBREMOIS2; 450 | NBREMOIS222_A=NBREMOIS222; 451 | NBREMOIS2ISF_A=NBREMOIS2ISF; 452 | NBREMOIS222ISF_A=NBREMOIS222ISF; 453 | INDACOINR_A=present(ACODELAISINR); 454 | IND_PASSAGEISF_A = IND_PASSAGEISF; 455 | IND_PASSR9901ISF_A = IND_PASSR9901ISF; 456 | 457 | -------------------------------------------------------------------------------- /src/chap-ctl.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle corrective base_tl_init 1202: 22 | application : iliad ; 23 | 24 | 25 | TL_MF = IND_TL_MF; 26 | RNI_INIT = RNI * (1 - positif(TEFFP)) * (1 - positif(IPTEFN + RMOND)) ; 27 | EFF_INIT = TEFFP ; 28 | PVQ_INIT = TTPVQ ; 29 | PV_INIT = BPTP3 + BPTP2 + BPTP4 + BPTP40 + BPTP18 + BPTPD + BPTPG + BPTP19 + BPTP24 ; 30 | RI_INIT = (REDTL + CIMPTL) * (1-V_CNR) ; 31 | CRDS_INIT = BCSG ; 32 | BRDS_INIT = BRDS ; 33 | BPRS_INIT = BPRS ; 34 | TAXAGA_INIT = BASSURV + BASSURC ; 35 | PCAP_INIT = BPCAPTAXV + BPCAPTAXC ; 36 | LOY_INIT = LOYELEV ; 37 | CHR_INIT = REVKIREHR + (RFRH2 + RFRH1) * positif(HRCONDTHEO) ; 38 | CVN_INIT = CVNSALAV + CVNSALAC + GLDGRATV + GLDGRATC ; 39 | CDIS_INIT = GSALV + GSALC ; 40 | GLO_INIT = GLDGRATV + GLDGRATC ; 41 | RSE1_INIT = BRSE1 ; 42 | RSE2_INIT = BRSE2 ; 43 | RSE3_INIT = BRSE3 ; 44 | RSE4_INIT = BRSE4 ; 45 | RSE5_INIT = BRSE5 ; 46 | 47 | regle corrective base_tl 1204: 48 | application : iliad ; 49 | 50 | 51 | RNI_TL = RNI * (1 - positif(TEFFP)) * (1 - positif(IPTEFN + RMOND)) ; 52 | EFF_TL = TEFFP ; 53 | PVQ_TL = TTPVQ ; 54 | PV_TL = BPTP3 + BPTP2 + BPTP4 + BPTP40 + BPTP18 + BPTPD + BPTPG + BPTP19 + BPTP24 ; 55 | RI_TL = (REDTL + CIMPTL) * (1 - V_CNR) ; 56 | RDS_TL = BCSG ; 57 | BRDS_TL = BRDS ; 58 | BPRS_TL = BPRS ; 59 | TAXAGA_TL = BASSURV + BASSURC ; 60 | PCAP_TL = BPCAPTAXV + BPCAPTAXC ; 61 | LOYA_TL = LOYELEV ; 62 | CHR_TL = REVKIREHR + (RFRH2 + RFRH1) * positif(HRCONDTHEO) ; 63 | CVNA_TL = CVNSALAV + CVNSALAC + GLDGRATV + GLDGRATC ; 64 | CDISA_TL = GSALV + GSALC; 65 | GLOA_TL = GLDGRATV + GLDGRATC ; 66 | RSE1A_TL = BRSE1 ; 67 | RSE2A_TL = BRSE2 ; 68 | RSE3A_TL = BRSE3 ; 69 | RSE4A_TL = BRSE4 ; 70 | RSE5A_TL = BRSE5 ; 71 | 72 | regle corrective base_tl_rect 1206: 73 | application : iliad ; 74 | 75 | 76 | RNI_RECT = RNI * (1 - positif(TEFFP)) * (1 - positif(IPTEFN + RMOND)) ; 77 | EFF_RECT = TEFFP ; 78 | PVQ_RECT = TTPVQ ; 79 | PV_RECT = BPTP3 + BPTP2 + BPTP4 + BPTP40 + BPTP18 + BPTPD + BPTPG + BPTP19 + BPTP24 ; 80 | RI_RECT = RI_INIT - (REDTL + CIMPTL) * (1-V_CNR) ; 81 | CRDS_RECT = BCSG ; 82 | BRDS_RECT = BRDS ; 83 | BPRS_RECT = BPRS ; 84 | TAXAGA_RECT = BASSURV + BASSURC ; 85 | PCAP_RECT = BPCAPTAXV + BPCAPTAXC ; 86 | LOY_RECT = LOYELEV ; 87 | CHR_RECT = REVKIREHR + (RFRH2 + RFRH1) * positif(HRCONDTHEO) ; 88 | CVN_RECT = CVNSALAV + CVNSALAC + GLDGRATV + GLDGRATC ; 89 | CDIS_RECT = GSALV + GSALC ; 90 | GLO_RECT = GLDGRATV + GLDGRATC ; 91 | RSE1_RECT = BRSE1 ; 92 | RSE2_RECT = BRSE2 ; 93 | RSE3_RECT = BRSE3 ; 94 | RSE4_RECT = BRSE4 ; 95 | RSE5_RECT = BRSE5 ; 96 | 97 | CSG_RECT = CSG ; 98 | PS_RECT = PRS ; 99 | 100 | -------------------------------------------------------------------------------- /src/chap-isf.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle isf 77001: 22 | application : iliad , batch ; 23 | DISFBASE = ISFBASE; 24 | 25 | regle isf 77010: 26 | application : iliad , batch ; 27 | TR2_ISF = arr( max(0, min( DISFBASE , LIM_TR2_ISF ) - (LIM_TR1_ISF)) * (TX_TR2_ISF/10000)) ; 28 | TR3_ISF = arr( max(0, min( DISFBASE , LIM_TR3_ISF ) - (LIM_TR2_ISF)) * (TX_TR3_ISF/10000)) ; 29 | TR4_ISF = arr( max(0, min( DISFBASE , LIM_TR4_ISF ) - (LIM_TR3_ISF)) * (TX_TR4_ISF/100)) ; 30 | TR5_ISF = arr( max(0, min( DISFBASE , LIM_TR5_ISF ) - (LIM_TR4_ISF)) * (TX_TR5_ISF/10000)) ; 31 | TR6_ISF = arr( max(0, DISFBASE - LIM_TR5_ISF) * (TX_TR6_ISF/1000)) ; 32 | 33 | ISF1 = TR2_ISF + TR3_ISF + TR4_ISF + TR5_ISF + TR6_ISF; 34 | 35 | regle isf 77015: 36 | application : iliad , batch ; 37 | ISFDEC = arr((17500 - ( (TX_TR5_ISF/10000) * ISFBASE)) 38 | * positif(ISFBASE-LIM_ISFINF)*positif(LIM_ISFDEC - ISFBASE)) 39 | * positif(ISF1); 40 | 41 | DISFDEC = ISFDEC; 42 | 43 | regle isf 77020: 44 | application : iliad , batch ; 45 | ISFBRUT = arr((ISF1 - ISFDEC) * positif( LIM_ISFDEC - 1 - ISFBASE ) 46 | + ISF1 * (1-positif(LIM_ISFDEC - 1 - ISFBASE))) ; 47 | 48 | regle isf 77030: 49 | application : iliad , batch ; 50 | DISFPMED = ISFPMEDI ; 51 | DISFPMEI = ISFPMEIN ; 52 | AISFPMED = arr(ISFPMEDI * (TX50/100)) ; 53 | AISFPMEI = arr(ISFPMEIN * (TX50/100)) ; 54 | RISFPMED_1 = min(45000, AISFPMED); 55 | RISFPMEI_1 = max(0, min(45000 - RISFPMED_1, AISFPMEI)); 56 | 57 | 58 | DISFFIP = ISFFIP ; 59 | DISFFCPI = ISFFCPI ; 60 | AISFFIP = arr(ISFFIP * (TX50/100)) ; 61 | AISFFCPI = arr(ISFFCPI * (TX50/100)) ; 62 | RISFFIP_1 = min(18000, AISFFIP); 63 | RISFFCPI_1 = max(0, min(18000 - RISFFIP_1, AISFFCPI)); 64 | 65 | regle isf 77040: 66 | application : iliad , batch ; 67 | PLAF_ISFRED = 50000 * (1-positif(ISFPMEDI+ISFPMEIN+ISFFIP+ISFFCPI)) 68 | + 45000 * positif(ISFPMEDI+ISFPMEIN+ISFFIP+ISFFCPI) ; 69 | 70 | DISFDONF = ISFDONF ; 71 | DISFDONCEE = ISFDONEURO ; 72 | 73 | AISFDONF =arr(ISFDONF * (TX75/100)) ; 74 | AISFDONCEE = arr(ISFDONEURO * (TX75/100)) ; 75 | 76 | RISFDONF_1 = min( PLAF_ISFRED , AISFDONF); 77 | RISFDONCEE_1 = max(0, min( PLAF_ISFRED - RISFDONF_1, AISFDONCEE)); 78 | 79 | regle isf 77050: 80 | application : iliad , batch ; 81 | RISFDONF_2 = min(PLAF_ISFRED, RISFDONF_1); 82 | RISFDONCEE_2 = max(0, min(PLAF_ISFRED - RISFDONF_1, RISFDONCEE_1)); 83 | RISFPMED_2 = max(0, min(PLAF_ISFRED - RISFDONF_1 - RISFDONCEE_1, RISFPMED_1)); 84 | RISFPMEI_2 = max(0, min(PLAF_ISFRED - RISFDONF_1 - RISFDONCEE_1 - RISFPMED_1, RISFPMEI_1)); 85 | RISFFIP_2 = max(0, min(PLAF_ISFRED - RISFDONF_1 - RISFDONCEE_1 - RISFPMED_1 - RISFPMEI_1, 86 | RISFFIP_1)); 87 | RISFFCPI_2 = max(0, min(PLAF_ISFRED - RISFDONF_1 - RISFDONCEE_1 - RISFPMED_1 - RISFPMEI_1 88 | - RISFFIP_1, RISFFCPI_1 )); 89 | 90 | 91 | 92 | 93 | 94 | RISFDONF = max( min( RISFDONF_2, ISFBRUT) , 0) 95 | * positif(( 1 - null( CODE_2042 - 8 )) * ( 1 - null( CMAJ_ISF - 8)) * ( 1 - null( CMAJ_ISF -34))) 96 | + max( min( RISFDONF_2, ISFBRUT) , 0) 97 | * (1 - positif(( 1-null( CODE_2042 - 8 )) * ( 1-null( CMAJ_ISF - 8)) * ( 1-null( CMAJ_ISF -34)))) * COD9ZA ; 98 | 99 | 100 | RISFDONCEE = max( min( RISFDONCEE_2, ISFBRUT - RISFDONF), 0) 101 | * positif(( 1 - null( CODE_2042 - 8 )) * ( 1 - null( CMAJ_ISF - 8)) * ( 1 - null( CMAJ_ISF -34))) 102 | + max( min( RISFDONCEE_2, ISFBRUT - RISFDONF), 0) 103 | * (1 - positif(( 1-null( CODE_2042 - 8 )) * ( 1-null( CMAJ_ISF - 8)) * ( 1-null( CMAJ_ISF -34)))) * COD9ZA ; 104 | 105 | 106 | 107 | RISFPMED = max( min( RISFPMED_2, ISFBRUT - RISFDONF - RISFDONCEE), 0) 108 | * positif(( 1 - null( CODE_2042 - 8 )) * ( 1 - null( CMAJ_ISF - 8)) * ( 1 - null( CMAJ_ISF -34))) 109 | + max( min( RISFPMED_2, ISFBRUT - RISFDONF - RISFDONCEE), 0) 110 | * (1 - positif(( 1-null( CODE_2042 - 8 )) * ( 1-null( CMAJ_ISF - 8)) * ( 1-null( CMAJ_ISF -34)))) * COD9ZA ; 111 | 112 | 113 | 114 | 115 | RISFPMEI = max( min( RISFPMEI_2, ISFBRUT - RISFDONF - RISFDONCEE - RISFPMED), 0) 116 | * positif(( 1 - null( CODE_2042 - 8 )) * ( 1 - null( CMAJ_ISF - 8)) * ( 1 - null( CMAJ_ISF -34))) 117 | + max( min( RISFPMEI_2, ISFBRUT - RISFDONF - RISFDONCEE - RISFPMED), 0) 118 | * (1 - positif(( 1-null( CODE_2042 - 8 )) * ( 1-null( CMAJ_ISF - 8)) * ( 1-null( CMAJ_ISF -34)))) * COD9ZA ; 119 | 120 | 121 | 122 | RISFFIP = max( min( RISFFIP_2, ISFBRUT - RISFDONF - RISFDONCEE - RISFPMED - RISFPMEI), 0) 123 | * positif(( 1 - null( CODE_2042 - 8 )) * ( 1 - null( CMAJ_ISF - 8)) * ( 1 - null( CMAJ_ISF -34))) 124 | + max( min( RISFFIP_2, ISFBRUT - RISFDONF - RISFDONCEE - RISFPMED - RISFPMEI), 0) 125 | * (1 - positif(( 1-null( CODE_2042 - 8 )) * ( 1-null( CMAJ_ISF - 8)) * ( 1-null( CMAJ_ISF -34)))) * COD9ZA ; 126 | 127 | 128 | 129 | RISFFCPI = max( min( RISFFCPI_2, ISFBRUT - RISFDONF - RISFDONCEE 130 | - RISFPMED - RISFPMEI - RISFFIP ), 0) 131 | * positif(( 1 - null( CODE_2042 - 8 )) * ( 1 - null( CMAJ_ISF - 8)) * ( 1 - null( CMAJ_ISF -34))) 132 | + max( min( RISFFCPI_2, ISFBRUT - RISFDONF - RISFDONCEE 133 | - RISFPMED - RISFPMEI - RISFFIP ), 0) 134 | * (1 - positif(( 1-null( CODE_2042 - 8 )) * ( 1-null( CMAJ_ISF - 8)) * ( 1-null( CMAJ_ISF -34)))) * COD9ZA ; 135 | 136 | 137 | 138 | regle isf 77066: 139 | application : iliad , batch ; 140 | REDISF = RISFDONF + RISFDONCEE + RISFPMED 141 | + RISFPMEI + RISFFIP + RISFFCPI ; 142 | 143 | TXTOISF = RETXISF + COPETOISF ; 144 | 145 | regle isf 77065: 146 | application : iliad , batch ; 147 | ISFTRED = RISFDONF + RISFDONCEE + RISFPMED 148 | + RISFPMEI + RISFFIP + RISFFCPI + RISFE ; 149 | 150 | regle isf 77070: 151 | application : iliad , batch ; 152 | ISFNETRED = max(0, ISFBRUT - RISFDONF - RISFDONCEE - RISFPMED - RISFPMEI - RISFFIP - RISFFCPI) ; 153 | 154 | regle isf 77075: 155 | application : iliad , batch ; 156 | DISFPLAF = ISFPLAF ; 157 | 158 | RISFPLAF = max(0, ISFNETRED * positif(ISFPLAF - ISFNETRED) 159 | + ISFPLAF * (1-positif(ISFPLAF - ISFNETRED))); 160 | 161 | regle isf 77076: 162 | application : iliad , batch ; 163 | ISFPOSTPLAF = max(0, ISFNETRED - RISFPLAF); 164 | 165 | regle isf 77080: 166 | application : iliad , batch ; 167 | DISFE = ISFETRANG ; 168 | 169 | RISFE = positif(DISFBASE)*positif(ISFETRANG)*( min(ISFPOSTPLAF , ISFETRANG)); 170 | 171 | regle isf 77090: 172 | application : iliad , batch ; 173 | 174 | ISF5 = max(0, ISFPOSTPLAF - RISFE) ; 175 | 176 | regle isf 77200: 177 | application : iliad , batch ; 178 | 179 | COPETOISF = si (CMAJ_ISF = 7 ou CMAJ_ISF = 17 ou CMAJ_ISF = 18) 180 | alors (10) 181 | sinon 182 | ( si (CMAJ_ISF = 8 ou CMAJ_ISF = 34) 183 | alors (40) 184 | finsi ) 185 | finsi; 186 | 187 | NMAJISF1 = max (0, MAJO1728ISF + arr(ISF5 * COPETOISF/100) * positif_ou_nul(ISF5 - SEUIL_12) 188 | + FLAG_TRTARDIF * MAJOISFTARDIF_D 189 | + FLAG_TRTARDIF_F * MAJOISFTARDIF_D 190 | - FLAG_TRTARDIF_F * ( positif(FLAG_RECTIF) * MAJOISFTARDIF_R 191 | + (1 - positif(FLAG_RECTIF)) * MAJOISFTARDIF_A) 192 | ); 193 | 194 | 195 | 196 | TXPF1728ISF =si (V_CODPF1728ISF=07 ou V_CODPF1728ISF=17 ou V_CODPF1728ISF=18) 197 | alors (10) 198 | sinon 199 | (si (V_CODPF1728ISF=08 ou V_CODPF1728ISF=34) 200 | alors (40) 201 | finsi) 202 | finsi ; 203 | 204 | 205 | MAJTXISF1 = (1 - positif(V_NBCOD1728ISF)) 206 | * ((1 - positif(CMAJ_ISF)) * positif(NMAJISF1) * TXPF1728ISF + positif(CMAJ_ISF) * COPETOISF) 207 | + positif(V_NBCOD1728ISF) * (-1) ; 208 | regle isf 77210: 209 | application : iliad , batch ; 210 | INTMSISF = inf( MOISAN_ISF / 10000 ); 211 | INTANISF = (( MOISAN_ISF/10000 - INTMSISF )*10000) * present(MOISAN_ISF) ; 212 | TXINTISF = (max(0, (INTANISF - (V_ANREV+1) )* 12 + INTMSISF - 6 ) * TXMOISRETARD2) 213 | * present(MOISAN_ISF); 214 | PTOISF = arr(ISF5 * COPETOISF / 100) + arr(ISF5 * TXINTISF / 100) ; 215 | RETISF = (RETISF2 + arr(ISF5 * TXINTISF/100))* positif_ou_nul(ISF4BIS - SEUIL_12) ; 216 | RETXISF = positif(CMAJ_ISF) * TXINTISF 217 | + (TXINRISF * (1-positif(TXINRISF_A)) + (-1) * positif(TXINRISF_A) * positif(TXINRISF) 218 | * positif(positif(TXINRISF - TXINRISF_A)+positif(TXINRISF_A-TXINRISF))) 219 | + (TXINRISF * positif(TXINRISF_A) * null(TXINRISF - TXINRISF_A)) 220 | ; 221 | 222 | 223 | NATMAJISF = positif(positif(RETISF) * positif(NMAJISF1)+positif(NMAJISF1)) 224 | + 2 * positif(RETISF) * (1-positif(NMAJISF1)); 225 | 226 | regle isf 77215: 227 | application : iliad , batch ; 228 | 229 | 230 | 231 | PISF = ( INCISF_NET 232 | + NMAJISF1 233 | + arr(ISF5 * TXINTISF / 100) * (1-positif(FLAG_PRIM+FLAG_RETARD+FLAG_DEFAUT))) ; 234 | 235 | regle isf 77219 : 236 | application : iliad , batch ; 237 | 238 | NAPISFTOT = ISF5 + PISF ; 239 | 240 | regle isf 77220: 241 | application : iliad , batch ; 242 | 243 | ISFNET = NAPISFTOT ; 244 | 245 | regle isf 77221: 246 | application : iliad , batch ; 247 | 248 | ISFNAP = ISFCUM - V_ANTISF ; 249 | 250 | regle isf 77230: 251 | application : iliad, batch ; 252 | 253 | ILI_SYNT_ISF = (1 - positif_ou_nul(ISF4BIS - SEUIL_12)) * null(V_ANTISF+0) * ISF4BIS 254 | + positif_ou_nul(ISF4BIS - SEUIL_12) * ISF4BIS ; 255 | 256 | 257 | regle isf 77270: 258 | application : iliad, batch ; 259 | 260 | 261 | ISF4BIS= max( 0, ISF5 ) ; 262 | 263 | -------------------------------------------------------------------------------- /src/chap-thr.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 80000: 22 | application : iliad , batch ; 23 | HRBTRFR1 = V_BTRFRHR1 * (1-positif_ou_nul(RFRH1)) + RFRH1; 24 | HRBTRFR2 = V_BTRFRHR2 * (1-positif_ou_nul(RFRH2)) + RFRH2; 25 | HRNBTRFR = positif_ou_nul(V_BTRFRHR1 * (1-positif(RFRH1)) + RFRH1) + positif_ou_nul(V_BTRFRHR2 * (1-positif(RFRH2)) + RFRH2); 26 | HRMOYBTRFR = arr((HRBTRFR1 + HRBTRFR2) /2); 27 | HRLIM15 = positif_ou_nul(REVKIREHR - (1.5 * HRMOYBTRFR)); 28 | HRLIMBTRFR2 = positif_ou_nul(LIMHR1 * (1+BOOL_0AM) - HRBTRFR2); 29 | HRLIMBTRFR1 = positif_ou_nul(LIMHR1 * (1+BOOL_0AM) - HRBTRFR1); 30 | HRCONDTHEO = positif(null(2-HRNBTRFR)*positif(HRLIM15)*positif(HRLIMBTRFR1*HRLIMBTRFR2)* (1-positif(CASECHR+0))); 31 | HRBASEFRAC = arr((REVKIREHR - HRMOYBTRFR) / 2); 32 | HRBASELISSE = HRBASEFRAC + HRMOYBTRFR; 33 | CHRREEL1 = positif_ou_nul(LIMHRTX1 * (1+BOOL_0AM)-REVKIREHR) * ((REVKIREHR - LIMHR1 * (1+BOOL_0AM))*TXHR1/100) 34 | + (LIMHR1 * (1+BOOL_0AM) * TXHR1/100) * positif(REVKIREHR - LIMHRTX1 * (1+BOOL_0AM)); 35 | CHRREEL2 = max(0,(REVKIREHR - LIMHR2*(1+BOOL_0AM))*TXHR2/100); 36 | CHRREELTOT = arr(max(0,CHRREEL1 + CHRREEL2)); 37 | CHRTHEO11 = arr(positif_ou_nul(LIMHRTX1 * (1+BOOL_0AM)-HRBASELISSE) * ((HRBASELISSE - LIMHR1 * (1+BOOL_0AM))*TXHR1/100) 38 | + (LIMHR1 * (1+BOOL_0AM) * TXHR1/100)* positif(HRBASELISSE - LIMHRTX1 * (1+BOOL_0AM))); 39 | CHRTHEO21 = arr(max(0,(HRBASELISSE - LIMHR2*(1+BOOL_0AM))*TXHR2/100)); 40 | CHRTHEOTOT = arr(max(0,CHRTHEO11 + CHRTHEO21)*2); 41 | BHAUTREV = max(0 , REVKIREHR - LIMHR1 * (1 + BOOL_0AM)) ; 42 | CHRAVANT = (max(0,min(CHRREELTOT,CHRTHEOTOT)) * HRCONDTHEO 43 | + CHRREELTOT * (1-HRCONDTHEO) ) ; 44 | CHRTEFF = arr(CHRAVANT * (REVKIREHR - TEFFHRC+COD8YJ)/ REVKIREHR); 45 | CHRAPRES = CHRAVANT * (1-positif(positif(IPMOND)+positif(INDTEFF))) + CHRTEFF * positif(positif(IPMOND)+positif(INDTEFF)); 46 | regle 80005: 47 | application : iliad , batch ; 48 | IHAUTREVT = max(0,CHRAPRES - CICHR); 49 | -------------------------------------------------------------------------------- /src/chap-tl.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | regle 21700: 22 | application : iliad ; 23 | 24 | 25 | RAP_RNI = RNI_TL - RNI_INIT ; 26 | RAP_EFF = EFF_TL - EFF_INIT ; 27 | RAP_PVQ = PVQ_TL - PVQ_INIT ; 28 | RAP_PV = PV_TL - PV_INIT ; 29 | RAP_RI = - RI_TL + RI_INIT ; 30 | RAP_CI = CI_TL ; 31 | RAP_CRDS = RDS_TL - CRDS_INIT ; 32 | RAP_RDS = BRDS_TL - BRDS_INIT ; 33 | RAP_PRS = BPRS_TL - BPRS_INIT ; 34 | RAP_TAXAGA = TAXAGA_TL - TAXAGA_INIT ; 35 | RAP_CAP = PCAP_TL - PCAP_INIT ; 36 | RAP_LOY = LOYA_TL - LOY_INIT ; 37 | RAP_CHR = CHR_TL - CHR_INIT ; 38 | RAP_CVN = CVNA_TL - CVN_INIT ; 39 | RAP_CDIS = CDISA_TL - CDIS_INIT ; 40 | RAP_GLO = GLOA_TL - GLO_INIT ; 41 | RAP_RSE1 = RSE1A_TL - RSE1_INIT ; 42 | RAP_RSE2 = RSE2A_TL - RSE2_INIT ; 43 | RAP_RSE3 = RSE3A_TL - RSE3_INIT ; 44 | RAP_RSE4 = RSE4A_TL - RSE4_INIT ; 45 | RAP_RSE5 = RSE5A_TL - RSE5_INIT ; 46 | 47 | 48 | NUM_IR_TL = max(0 , RAP_RNI 49 | + RAP_EFF 50 | + RAP_PVQ 51 | + RAP_PV 52 | + RAP_RI 53 | + RAP_CI) ; 54 | 55 | NUM_CS_TL = max(0 , RAP_CRDS) ; 56 | NUM_RD_TL = max(0 , RAP_RDS) ; 57 | NUM_PS_TL = max(0 , RAP_PRS) ; 58 | 59 | NUM_TAXAGA_TL = max(0 , RAP_TAXAGA) ; 60 | NUM_CAP_TL = max(0 , RAP_CAP) ; 61 | NUM_LOY_TL = max(0 , RAP_LOY) ; 62 | NUM_CHR_TL = max(0 , RAP_CHR) ; 63 | 64 | NUM_CVN_TL = max(0 , RAP_CVN) ; 65 | NUM_CDIS_TL = max(0 , RAP_CDIS) ; 66 | NUM_GLO_TL = max(0 , RAP_GLO) ; 67 | 68 | NUM_RSE1_TL = max(0 , RAP_RSE1) ; 69 | NUM_RSE2_TL = max(0 , RAP_RSE2) ; 70 | NUM_RSE3_TL = max(0 , RAP_RSE3) ; 71 | NUM_RSE4_TL = max(0 , RAP_RSE4) ; 72 | NUM_RSE5_TL = max(0 , RAP_RSE5) ; 73 | 74 | regle 21710 : 75 | application : iliad ; 76 | 77 | 78 | DEN_IR_TL = max(0 , RNI_RECT 79 | + EFF_RECT 80 | + PVQ_RECT 81 | + PV_RECT 82 | + RI_RECT 83 | + CI_RECT) ; 84 | 85 | DEN_CS_TL = max(0 , CRDS_RECT) ; 86 | DEN_RD_TL = max(0 , BRDS_RECT) ; 87 | DEN_PS_TL = max(0 , BPRS_RECT) ; 88 | 89 | DEN_TAXAGA_TL = max(0 , TAXAGA_RECT) ; 90 | DEN_CAP_TL = max(0 , PCAP_RECT) ; 91 | DEN_LOY_TL = max(0 , LOY_RECT) ; 92 | DEN_CHR_TL = max(0 , CHR_RECT) ; 93 | 94 | DEN_CVN_TL = max(0 , CVN_RECT) ; 95 | DEN_CDIS_TL = max(0 , CDIS_RECT) ; 96 | DEN_GLO_TL = max(0 , GLO_RECT) ; 97 | 98 | DEN_RSE1_TL = max(0 , RSE1_RECT) ; 99 | DEN_RSE2_TL = max(0 , RSE2_RECT) ; 100 | DEN_RSE3_TL = max(0 , RSE3_RECT) ; 101 | DEN_RSE4_TL = max(0 , RSE4_RECT) ; 102 | DEN_RSE5_TL = max(0 , RSE5_RECT) ; 103 | 104 | regle 21720 : 105 | application : iliad ; 106 | enchaineur : ENCH_TL ; 107 | 108 | RETARPRIM = null(V_IND_TRAIT - 4) * null(CMAJ - 7) ; 109 | 110 | TL_IR = (1 - positif(TL_MF*positif(MFIR+0)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT+PASS_TLIR)) 111 | * positif(positif (NUM_IR_TL+0) * positif (DEN_IR_TL+0) * positif(NUM_IR_TL / DEN_IR_TL - 0.05)) 112 | + positif(TL_MF*positif(MFIR+0) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT + PASS_TLIR) ; 113 | 114 | TL_CS = (1 - positif(TL_MF*positif(MFCS) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * positif(NUM_CS_TL / DEN_CS_TL - 0.05) 115 | + positif(TL_MF*positif(MFCS) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 116 | 117 | TL_RD = (1 - positif(TL_MF*positif(MFRD) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * positif(NUM_RD_TL / DEN_RD_TL - 0.05) 118 | + positif(TL_MF*positif(MFRD) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 119 | 120 | TL_PS = (1 - positif(TL_MF*positif(MFPS) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * positif(NUM_PS_TL / DEN_PS_TL - 0.05) 121 | + positif(TL_MF*positif(MFPS) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 122 | 123 | 124 | TL_TAXAGA = ( 1 - positif(TL_MF * positif(MFTAXAGA) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * (positif(TL_MF * positif(MFTAXAGA) + positif(NUM_TAXAGA_TL / DEN_TAXAGA_TL - 0.05))) 125 | + positif(TL_MF * positif(MFTAXAGA) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 126 | 127 | TL_CAP = ( 1 - positif(TL_MF * positif(MFPCAP) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * (positif(TL_MF * positif(MFPCAP) + positif(NUM_CAP_TL / DEN_CAP_TL - 0.05))) 128 | + positif(TL_MF * positif(MFPCAP) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 129 | 130 | TL_LOY = ( 1 - positif(TL_MF * positif(MFLOY) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * (positif(TL_MF * positif(MFLOY) + positif(NUM_LOY_TL / DEN_LOY_TL - 0.05))) 131 | + positif(TL_MF * positif(MFLOY) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 132 | 133 | TL_CHR = ( 1 - positif(TL_MF * positif(MFIR + MFPCAP) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT)) * (positif(TL_MF * positif(MFIR + MFPCAP) + positif(NUM_CHR_TL / DEN_CHR_TL - 0.05))) 134 | + positif(TL_MF * positif(MFIR + MFPCAP) * (1 - null(MFCHR7)) + RETARPRIM + FLAG_RETARD + FLAG_DEFAUT) ; 135 | 136 | TL_CVN = (1 - positif(TL_MF * positif(MFCVN)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFCVN) + positif (NUM_CVN_TL / DEN_CVN_TL - 0.05 )) ) 137 | + positif(TL_MF * positif(MFCVN)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 138 | 139 | TL_CDIS = (1 - positif(TL_MF * positif(MFCDIS)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFCDIS) + positif (NUM_CDIS_TL / DEN_CDIS_TL - 0.05 )) ) 140 | + positif(TL_MF * positif(MFCDIS)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 141 | 142 | TL_GLO = (1 - positif(TL_MF * positif(MFGLO)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFGLO) + positif (NUM_GLO_TL / DEN_GLO_TL - 0.05 )) ) 143 | + positif(TL_MF * positif(MFGLO)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 144 | 145 | TL_RSE1 = (1 - positif(TL_MF * positif(MFRSE1)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFRSE1) + positif (NUM_RSE1_TL / DEN_RSE1_TL - 0.05 )) ) 146 | + positif(TL_MF * positif(MFRSE1)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 147 | 148 | TL_RSE2 = (1 - positif(TL_MF * positif(MFRSE2)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFRSE2) + positif (NUM_RSE2_TL / DEN_RSE2_TL - 0.05 )) ) 149 | + positif(TL_MF * positif(MFRSE2)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 150 | 151 | TL_RSE3 = (1 - positif(TL_MF * positif(MFRSE3)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFRSE3) + positif (NUM_RSE3_TL / DEN_RSE3_TL - 0.05 )) ) 152 | + positif(TL_MF * positif(MFRSE3)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 153 | 154 | TL_RSE4 = (1 - positif(TL_MF * positif(MFRSE4)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFRSE4) + positif (NUM_RSE4_TL / DEN_RSE4_TL - 0.05 )) ) 155 | + positif(TL_MF * positif(MFRSE4)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 156 | 157 | TL_RSE5 = (1 - positif(TL_MF * positif(MFRSE5)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT)) * (positif(TL_MF * positif(MFRSE5) + positif (NUM_RSE5_TL / DEN_RSE5_TL - 0.05 )) ) 158 | + positif(TL_MF * positif(MFRSE5)+RETARPRIM+FLAG_RETARD+FLAG_DEFAUT) ; 159 | 160 | TL_REGV = 1 ; 161 | 162 | -------------------------------------------------------------------------------- /src/coc3.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | verif 320: 22 | application : iliad , batch ; 23 | 24 | si 25 | DPVRCM > 0 26 | et 27 | BPVRCM + PEA + GAINPEA > 0 28 | 29 | alors erreur A320 ; 30 | verif 321: 31 | application : iliad , batch ; 32 | 33 | si 34 | 35 | positif(ABDETPLUS + 0) + positif(ABDETMOINS + 0) = 2 36 | 37 | alors erreur A321; 38 | verif 323: 39 | application : iliad , batch ; 40 | 41 | si 42 | positif(ABIMPPV + 0) = 1 43 | et 44 | positif(ABIMPMV + 0) = 1 45 | 46 | alors erreur A323 ; 47 | verif 325: 48 | application : iliad , batch ; 49 | 50 | si 51 | V_IND_TRAIT > 0 52 | et 53 | positif(PVSURSI + 0) + positif(COD3WM + 0) = 1 54 | 55 | alors erreur A325 ; 56 | verif 326: 57 | application : iliad , batch ; 58 | 59 | si 60 | V_IND_TRAIT > 0 61 | et 62 | positif(PVIMPOS + 0) + positif(ABPVNOSURSIS + 0) = 1 63 | 64 | alors erreur A326 ; 65 | verif 3271: 66 | application : iliad , batch ; 67 | 68 | si 69 | V_IND_TRAIT > 0 70 | et 71 | positif(CODRVG + 0) + positif(CODNVG + 0) = 1 72 | 73 | alors erreur A32701 ; 74 | verif 3272: 75 | application : iliad , batch ; 76 | 77 | si 78 | V_IND_TRAIT > 0 79 | et 80 | positif(CODNVG + 0) = 1 81 | et 82 | null(4 - CODNVG) = 0 83 | 84 | alors erreur A32702 ; 85 | verif 3281: 86 | application : iliad , batch ; 87 | 88 | si 89 | V_IND_TRAIT > 0 90 | et 91 | positif(CODRWA + 0) + positif(CODNWA + 0) = 1 92 | 93 | alors erreur A32801 ; 94 | verif 3282: 95 | application : iliad , batch ; 96 | 97 | si 98 | V_IND_TRAIT > 0 99 | et 100 | positif(CODNWA + 0) = 1 101 | et 102 | null(4 - CODNWA) = 0 103 | 104 | alors erreur A32802 ; 105 | verif 3291: 106 | application : iliad , batch ; 107 | 108 | si 109 | V_IND_TRAIT > 0 110 | et 111 | positif(CODRWB + 0) + positif(CODNWB + 0) = 1 112 | 113 | alors erreur A32901 ; 114 | verif 3292: 115 | application : iliad , batch ; 116 | 117 | si 118 | V_IND_TRAIT > 0 119 | et 120 | positif(CODNWB + 0) = 1 121 | et 122 | null(4 - CODNWB) = 0 123 | 124 | alors erreur A32902 ; 125 | verif 420: 126 | application : batch , iliad ; 127 | 128 | si 129 | RFMIC > 0 130 | et 131 | (RFORDI > 0 ou RFDORD > 0 ou RFDHIS > 0 ou FONCI > 0 ou REAMOR > 0 et FONCINB > 0 ou REAMORNB > 0) 132 | 133 | alors erreur A420 ; 134 | verif 421: 135 | application : batch , iliad; 136 | 137 | si 138 | V_IND_TRAIT > 0 139 | et 140 | RFMIC > LIM_MICFON 141 | 142 | alors erreur A421 ; 143 | verif 422: 144 | application : batch , iliad ; 145 | 146 | si 147 | LOYIMP > 0 et ( present(RFORDI) = 0 148 | et 149 | present(FONCI) = 0 150 | et 151 | present(FONCINB) = 0 152 | et 153 | present(REAMOR) = 0 154 | et 155 | present(REAMORNB) = 0 156 | et 157 | present(RFDORD) = 0 158 | et 159 | present(RFDHIS) = 0 160 | et 161 | present(RFMIC) = 0) 162 | 163 | alors erreur A422 ; 164 | verif 423: 165 | application : batch , iliad ; 166 | 167 | si 168 | RFROBOR > 0 169 | et 170 | RFDANT > 0 171 | et 172 | present(RFORDI) = 0 173 | et 174 | present(RFDORD) = 0 175 | et 176 | present(RFDHIS) = 0 177 | 178 | alors erreur A423 ; 179 | verif 424: 180 | application : batch , iliad ; 181 | 182 | si 183 | RFROBOR > 0 184 | et 185 | (FONCI > 0 186 | ou 187 | REAMOR > 0) 188 | 189 | alors erreur A424 ; 190 | verif 4251: 191 | application : iliad , batch ; 192 | 193 | si 194 | (V_IND_TRAIT = 4 195 | et 196 | (FONCINB < 2 ou FONCINB > 30)) 197 | ou 198 | (V_IND_TRAIT = 5 199 | et 200 | (FONCINB = 1 ou FONCINB > 30)) 201 | 202 | alors erreur A42501 ; 203 | verif 4252: 204 | application : iliad , batch ; 205 | 206 | si 207 | (V_IND_TRAIT = 4 208 | et 209 | positif(FONCI) + present(FONCINB) = 1) 210 | ou 211 | (V_IND_TRAIT = 5 212 | et 213 | positif(FONCI) + positif(FONCINB) = 1) 214 | 215 | alors erreur A42502 ; 216 | verif 4261: 217 | application : iliad , batch ; 218 | 219 | si 220 | (V_IND_TRAIT = 4 221 | et 222 | (REAMORNB < 2 ou REAMORNB > 14)) 223 | ou 224 | (V_IND_TRAIT = 5 225 | et 226 | (REAMORNB = 1 ou REAMORNB > 14)) 227 | 228 | alors erreur A42601 ; 229 | verif 4262: 230 | application : iliad , batch ; 231 | 232 | si 233 | (V_IND_TRAIT = 4 234 | et 235 | positif(REAMOR) + present(REAMORNB) = 1) 236 | ou 237 | (V_IND_TRAIT = 5 238 | et 239 | positif(REAMOR) + positif(REAMORNB) = 1) 240 | 241 | alors erreur A42602 ; 242 | verif 534: 243 | application : batch , iliad ; 244 | 245 | si 246 | APPLI_COLBERT + APPLI_OCEANS = 0 247 | et 248 | positif_ou_nul(NAPT) = 0 249 | et 250 | (V_BTNATIMP+0) dans (1,11,71,81) 251 | et 252 | (positif(V_FORVA + 0) = 1 253 | ou 254 | positif(V_FORCA + 0) = 1 255 | ou 256 | positif(V_FORPA + 0) = 1) 257 | 258 | alors erreur A534 ; 259 | verif 538: 260 | application : iliad , batch ; 261 | 262 | si 263 | (RCSV > 0 et SOMMEA538VB = 0) 264 | ou 265 | (RCSC > 0 et SOMMEA538CB = 0) 266 | ou 267 | (RCSP > 0 et SOMMEA538PB = 0) 268 | 269 | alors erreur A538 ; 270 | verif 542: 271 | application : batch , iliad ; 272 | 273 | si 274 | APPLI_OCEANS = 0 275 | et 276 | ( 277 | (PPEACV+0 > 0 et PPENJV+0 > 0) 278 | ou 279 | (PPEACC+0 > 0 et PPENJC+0 > 0) 280 | ou 281 | (PPEACP+0 > 0 et PPENJP+0 > 0) 282 | ) 283 | 284 | alors erreur A542 ; 285 | verif 600: 286 | application : iliad , batch ; 287 | 288 | si 289 | APPLI_OCEANS = 0 290 | et 291 | positif(PERPIMPATRIE+0) != 1 292 | et 293 | V_REGCO+0 != 2 et V_REGCO+0 != 4 294 | et 295 | V_CNR+0 != 1 296 | et 297 | ((positif(PERP_COTV+0) > 0 et 298 | present(PERPPLAFCV)*present(PERPPLAFNUV1)*present(PERPPLAFNUV2)*present(PERPPLAFNUV3) = 0) 299 | ou 300 | (positif(PERP_COTC+0) > 0 et 301 | present(PERPPLAFCC)*present(PERPPLAFNUC1)*present(PERPPLAFNUC2)*present(PERPPLAFNUC3) = 0) 302 | ou 303 | (positif(PERP_COTP+0) > 0 et 304 | present(PERPPLAFCP)*present(PERPPLAFNUP1)*present(PERPPLAFNUP2)*present(PERPPLAFNUP3) = 0)) 305 | 306 | alors erreur A600 ; 307 | verif 601: 308 | application : iliad , batch ; 309 | 310 | si 311 | APPLI_OCEANS = 0 312 | et 313 | V_REGCO+0 != 2 et V_REGCO+0 != 4 314 | et 315 | positif(PERPIMPATRIE+0) != 1 316 | et 317 | (PERPPLAFCV > LIM_PERPMAXBT 318 | ou 319 | PERPPLAFCC > LIM_PERPMAXBT) 320 | 321 | alors erreur A601 ; 322 | verif 602: 323 | application : iliad , batch ; 324 | 325 | si 326 | APPLI_OCEANS = 0 327 | et 328 | V_REGCO+0 != 2 et V_REGCO+0 != 4 329 | et 330 | ((positif(RACCOTV+0) > 0 et positif(PERP_COTV+0) = 0) 331 | ou 332 | (positif(RACCOTC+0) > 0 et positif(PERP_COTC+0) = 0) 333 | ou 334 | (positif(RACCOTP+0) > 0 et positif(PERP_COTP+0) = 0)) 335 | 336 | alors erreur A602 ; 337 | verif 603: 338 | application : iliad , batch ; 339 | 340 | si 341 | APPLI_OCEANS = 0 342 | et 343 | positif(PERPIMPATRIE + 0) != 1 344 | et 345 | positif(V_CALCULIR + 0) = 0 346 | et 347 | V_REGCO+0 != 2 et V_REGCO+0 != 4 348 | et 349 | ( 350 | (positif_ou_nul(PLAF_PERPV) = 1 et 351 | (present(PERPPLAFCV) = 0 et present(PERPPLAFNUV1) = 0 352 | et present(PERPPLAFNUV2) = 0 et present(PERPPLAFNUV3) = 0 )) 353 | ou 354 | (positif_ou_nul(PLAF_PERPC) = 1 et 355 | (present(PERPPLAFCC) = 0 et present(PERPPLAFNUC1) = 0 356 | et present(PERPPLAFNUC2) = 0 et present(PERPPLAFNUC3) = 0 )) 357 | ou 358 | (positif_ou_nul(PLAF_PERPP) = 1 et 359 | (present(PERPPLAFCP) = 0 et present(PERPPLAFNUP1) = 0 360 | et present(PERPPLAFNUP2) = 0 et present(PERPPLAFNUP3) = 0 )) 361 | ou 362 | (positif_ou_nul(PLAF_PERPV) = 1 363 | et (PERPPLAFCV+PERPPLAFNUV1+PERPPLAFNUV2+PERPPLAFNUV3 = 364 | V_BTPERPV+V_BTPERPNUV1+V_BTPERPNUV2+V_BTPERPNUV3) ) 365 | ou 366 | (positif_ou_nul(PLAF_PERPC) = 1 367 | et (PERPPLAFCC+PERPPLAFNUC1+PERPPLAFNUC2+PERPPLAFNUC3 = 368 | V_BTPERPC+V_BTPERPNUC1+V_BTPERPNUC2+V_BTPERPNUC3) ) 369 | ou 370 | (positif_ou_nul(PLAF_PERPP) = 1 371 | et (PERPPLAFCP+PERPPLAFNUP1+PERPPLAFNUP2+PERPPLAFNUP3 = 372 | V_BTPERPP+V_BTPERPNUP1+V_BTPERPNUP2+V_BTPERPNUP3) ) 373 | ) 374 | alors erreur A603 ; 375 | verif 604: 376 | application : iliad , batch ; 377 | 378 | si 379 | APPLI_OCEANS = 0 380 | et 381 | (positif(PERPMUTU) = 1 et (V_0AM + V_0AO = 1) et ((V_REGCO+0) dans (1,3,5,6,7)) 382 | et positif(PERPIMPATRIE+0) = 0 383 | et (present(PERPPLAFCV) = 0 ou present(PERPPLAFNUV1) = 0 384 | ou present(PERPPLAFNUV2) = 0 ou present(PERPPLAFNUV3) = 0 385 | ou present(PERPPLAFCC) = 0 ou present(PERPPLAFNUC1) = 0 386 | ou present(PERPPLAFNUC2) = 0 ou present(PERPPLAFNUC3) =0)) 387 | alors erreur A604 ; 388 | verif 6051: 389 | application : iliad , batch ; 390 | 391 | si 392 | APPLI_OCEANS = 0 393 | et 394 | V_IND_TRAIT > 0 395 | et 396 | PERPV + 0 < EXOCETV + 0 397 | et 398 | positif(EXOCETV + 0) = 1 399 | 400 | alors erreur A60501 ; 401 | verif 6052: 402 | application : iliad , batch ; 403 | 404 | si 405 | APPLI_OCEANS = 0 406 | et 407 | V_IND_TRAIT > 0 408 | et 409 | PERPC + 0 < EXOCETC + 0 410 | et 411 | positif(EXOCETC + 0) = 1 412 | 413 | alors erreur A60502 ; 414 | -------------------------------------------------------------------------------- /src/coc4.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | verif 700: 22 | application : iliad ,batch ; 23 | 24 | si 25 | RDCOM > 0 26 | et 27 | SOMMEA700 = 0 28 | 29 | alors erreur A700 ; 30 | verif 702: 31 | application : batch , iliad ; 32 | 33 | si 34 | (V_REGCO+0) dans (1,3,5,6,7) 35 | et 36 | INTDIFAGRI * positif(INTDIFAGRI) + 0 > RCMHAB * positif(RCMHAB) + COD2FA * positif(COD2FA) + 0 37 | 38 | alors erreur A702 ; 39 | verif 703: 40 | application : batch , iliad ; 41 | 42 | si 43 | ( 44 | ( (positif(PRETUD+0) = 1 ou positif(PRETUDANT+0) = 1) 45 | et 46 | V_0DA < 1979 47 | et 48 | positif(BOOL_0AM+0) = 0 ) 49 | ou 50 | ( (positif(PRETUD+0) = 1 ou positif(PRETUDANT+0) = 1) 51 | et 52 | positif(BOOL_0AM+0) = 1 53 | et 54 | V_0DA < 1979 55 | et 56 | V_0DB < 1979 ) 57 | ) 58 | alors erreur A703 ; 59 | verif 704: 60 | application : batch , iliad ; 61 | 62 | si 63 | (positif(CASEPRETUD + 0) = 1 et positif(PRETUDANT + 0) = 0) 64 | ou 65 | (positif(CASEPRETUD + 0) = 0 et positif(PRETUDANT + 0) = 1) 66 | 67 | alors erreur A704 ; 68 | verif 705: 69 | application : batch , iliad ; 70 | 71 | si 72 | CONVCREA + 0 > 15 73 | et 74 | V_IND_TRAIT > 0 75 | 76 | alors erreur A705 ; 77 | verif 706: 78 | application : batch , iliad ; 79 | 80 | si 81 | CONVHAND + 0 > CONVCREA + 0 82 | et 83 | V_IND_TRAIT > 0 84 | 85 | alors erreur A706 ; 86 | verif 2610: 87 | application : batch , iliad ; 88 | 89 | si 90 | RDENS + RDENL + RDENU > V_0CF + V_0DJ + V_0DN + 0 91 | 92 | alors erreur A70701 ; 93 | verif 2615: 94 | application : batch , iliad ; 95 | 96 | si 97 | RDENSQAR + RDENLQAR + RDENUQAR > V_0CH + V_0DP + 0 98 | 99 | alors erreur A70702 ; 100 | verif 2642: 101 | application : iliad , batch; 102 | 103 | si 104 | V_IND_TRAIT > 0 105 | et 106 | ( 107 | RINVLOCINV + 0 > LIMLOC2 108 | ou 109 | RINVLOCREA + 0 > LIMLOC2 110 | ou 111 | INVLOCHOTR + 0 > LIMLOC2 112 | ou 113 | REPINVTOU + 0 > LIMLOC2 114 | ou 115 | INVLOGREHA + 0 > LIMLOC2 116 | ou 117 | INVLOGHOT + 0 > LIMLOC2 118 | ou 119 | INVLOCXN + 0 > LIMLOC2 120 | ou 121 | INVLOCXV + 0 > LIMLOC2 122 | ou 123 | COD7UY + 0 > LIMLOC2 124 | ou 125 | COD7UZ + 0 > LIMLOC2 126 | ) 127 | 128 | alors erreur A708 ; 129 | verif 7091: 130 | application : batch , iliad ; 131 | 132 | si 133 | SOMMEA709 > 1 134 | 135 | alors erreur A70901 ; 136 | verif 7092: 137 | application : batch , iliad ; 138 | 139 | si 140 | V_IND_TRAIT > 0 141 | et 142 | positif(INVLOCHOTR) + positif(INVLOGHOT) > 1 143 | 144 | alors erreur A70902 ; 145 | verif 710: 146 | application : batch , iliad ; 147 | 148 | si 149 | V_IND_TRAIT > 0 150 | et 151 | positif(CREAIDE + 0) * positif(RVAIDE + 0) = 1 152 | 153 | alors erreur A710 ; 154 | verif 7111: 155 | application : batch , iliad ; 156 | 157 | si 158 | V_IND_TRAIT > 0 159 | et 160 | INAIDE > 0 161 | et 162 | positif(RVAIDE + RVAIDAS + CREAIDE + 0) = 0 163 | 164 | alors erreur A71101 ; 165 | verif 7112: 166 | application : batch , iliad ; 167 | 168 | si 169 | V_IND_TRAIT > 0 170 | et 171 | positif(ASCAPA + 0) + positif(RVAIDAS + 0) = 1 172 | 173 | alors erreur A71102 ; 174 | verif 7113: 175 | application : batch , iliad ; 176 | 177 | si 178 | V_IND_TRAIT > 0 179 | et 180 | PREMAIDE > 0 181 | et 182 | positif(RVAIDE + RVAIDAS + CREAIDE + 0) = 0 183 | 184 | alors erreur A71103 ; 185 | verif 712: 186 | application : batch , iliad ; 187 | 188 | si 189 | PRESCOMP2000 + 0 > PRESCOMPJUGE 190 | et 191 | positif(PRESCOMPJUGE) = 1 192 | 193 | alors erreur A712 ; 194 | verif non_auto_cc 2698: 195 | application : batch , iliad ; 196 | 197 | si 198 | (PRESCOMPJUGE + 0 > 0 et PRESCOMP2000 + 0 = 0) 199 | ou 200 | (PRESCOMPJUGE + 0 = 0 et PRESCOMP2000 + 0 > 0) 201 | 202 | alors erreur A713 ; 203 | verif 714: 204 | application : batch , iliad ; 205 | 206 | si 207 | RDPRESREPORT + 0 > 0 208 | et 209 | PRESCOMPJUGE + PRESCOMP2000 + 0 > 0 210 | 211 | alors erreur A714 ; 212 | verif 715: 213 | application : batch , iliad ; 214 | 215 | si 216 | V_IND_TRAIT > 0 217 | et 218 | RDPRESREPORT + 0 > LIM_REPCOMPENS 219 | 220 | alors erreur A715 ; 221 | verif 716: 222 | application : batch , iliad ; 223 | 224 | si 225 | V_IND_TRAIT > 0 226 | et 227 | ((SUBSTITRENTE < PRESCOMP2000 + 0) 228 | ou 229 | (SUBSTITRENTE > 0 et present(PRESCOMP2000) = 0)) 230 | 231 | alors erreur A716 ; 232 | verif 7171: 233 | application : batch , iliad ; 234 | 235 | si 236 | V_IND_TRAIT > 0 237 | et 238 | positif(CELLIERFA) + positif(CELLIERFB) + positif(CELLIERFC) + positif(CELLIERFD) > 1 239 | 240 | alors erreur A71701 ; 241 | verif 7172: 242 | application : batch , iliad ; 243 | 244 | si 245 | V_IND_TRAIT > 0 246 | et 247 | SOMMEA71701 > 1 248 | 249 | alors erreur A71702 ; 250 | verif 7173: 251 | application : batch , iliad ; 252 | 253 | si 254 | V_IND_TRAIT > 0 255 | et 256 | SOMMEA71702 > 1 257 | 258 | alors erreur A71703 ; 259 | verif 7174: 260 | application : batch , iliad ; 261 | 262 | si 263 | V_IND_TRAIT > 0 264 | et 265 | positif(CELLIERHJ) + positif(CELLIERHK) + positif(CELLIERHN) + positif(CELLIERHO) > 1 266 | 267 | alors erreur A71704 ; 268 | verif 7175: 269 | application : batch , iliad ; 270 | 271 | si 272 | V_IND_TRAIT > 0 273 | et 274 | positif(CELLIERHL) + positif(CELLIERHM) > 1 275 | 276 | alors erreur A71705 ; 277 | verif 718: 278 | application : batch , iliad ; 279 | 280 | si 281 | CIAQCUL > 0 282 | et 283 | SOMMEA718 = 0 284 | 285 | alors erreur A718 ; 286 | verif 719: 287 | application : batch , iliad ; 288 | 289 | si 290 | RDMECENAT > 0 291 | et 292 | SOMMEA719 = 0 293 | 294 | alors erreur A719 ; 295 | verif 7301: 296 | application : batch , iliad ; 297 | 298 | si 299 | V_IND_TRAIT > 0 300 | et 301 | REPFOR + 0 > 0 302 | et 303 | REPSINFOR1 + 0 > 0 304 | 305 | alors erreur A73001 ; 306 | verif 7302: 307 | application : batch , iliad ; 308 | 309 | si 310 | V_IND_TRAIT > 0 311 | et 312 | REPFOR1 + 0 > 0 313 | et 314 | REPSINFOR2 + 0 > 0 315 | 316 | alors erreur A73002 ; 317 | verif 7303: 318 | application : batch , iliad ; 319 | 320 | si 321 | V_IND_TRAIT > 0 322 | et 323 | REPFOR2 + 0 > 0 324 | et 325 | REPSINFOR3 + 0 > 0 326 | 327 | alors erreur A73003 ; 328 | verif 7304: 329 | application : batch , iliad ; 330 | 331 | si 332 | V_IND_TRAIT > 0 333 | et 334 | REPFOR3 + 0 > 0 335 | et 336 | REPSINFOR4 + 0 > 0 337 | 338 | alors erreur A73004 ; 339 | verif 731: 340 | application : batch , iliad ; 341 | 342 | si 343 | V_IND_TRAIT > 0 344 | et 345 | CASEPRETUD + 0 > 5 346 | 347 | alors erreur A731 ; 348 | verif 732: 349 | application : batch , iliad ; 350 | 351 | si 352 | V_IND_TRAIT > 0 353 | et 354 | present(V_0SA) = 0 355 | et 356 | positif(V_BTRFRN1 + RFRN1 + 0) * positif(V_BTRFRN2 + RFRN2 + 0) = 0 357 | et 358 | positif(COD7RX + 0) = 0 359 | et 360 | positif(CIBOIBAIL + CINRJBAIL + CRENRJ + TRAMURWC + CINRJ + TRATOIVG + CIDEP15 361 | + MATISOSI + TRAVITWT + MATISOSJ + VOLISO + PORENT + CHAUBOISN + POMPESP 362 | + POMPESR + CHAUFSOL + POMPESQ + ENERGIEST + DIAGPERF + RESCHAL + 0) = 1 363 | et 364 | BQTRAV = 0 365 | 366 | alors erreur A732 ; 367 | verif 734: 368 | application : batch , iliad ; 369 | 370 | si 371 | positif(PTZDEVDUR + 0) = 1 372 | et 373 | positif(PTZDEVDURN + 0) = 1 374 | 375 | alors erreur A734 ; 376 | verif 735: 377 | application : batch , iliad ; 378 | 379 | si 380 | positif(PTZDEVDUR + 0) + positif(PTZDEVDURN + 0) = 1 381 | et 382 | positif(CIBOIBAIL + CINRJBAIL + CRENRJ + TRAMURWC + CINRJ + TRATOIVG + CIDEP15 + MATISOSI + TRAVITWT + MATISOSJ 383 | + VOLISO + PORENT + CHAUBOISN + POMPESP + POMPESQ + POMPESR + CHAUFSOL + ENERGIEST + DIAGPERF + RESCHAL 384 | + COD7SA + COD7SB + COD7SC + COD7WB + COD7RG + COD7VH + COD7RH + COD7RI + COD7WU + COD7RJ + COD7RK + COD7RL 385 | + COD7RN + COD7RP + COD7RR + COD7RS + COD7RQ + COD7RT + COD7TV + COD7TW + COD7RV + COD7RW + COD7RZ + 0) = 0 386 | 387 | alors erreur A735 ; 388 | verif 736: 389 | application : batch , iliad ; 390 | 391 | si 392 | V_IND_TRAIT > 0 393 | et 394 | positif(DUFLOEK) + positif(DUFLOEL) + positif(PINELQA) + positif(PINELQB) + positif(PINELQC) + positif(PINELQD) + 0 > 2 395 | 396 | alors erreur A736 ; 397 | verif 737: 398 | application : batch , iliad ; 399 | 400 | si 401 | V_IND_TRAIT > 0 402 | et 403 | positif(COD7RX + V_0AX + V_0AY + V_0AZ + V_BTXYZ1 + V_BTXYZ2 + 0) = 1 404 | et 405 | 1 - positif_ou_nul(COD7WX) = 1 406 | et 407 | positif(CIBOIBAIL + CINRJBAIL + CRENRJ + TRAMURWC + CINRJ + TRATOIVG + CIDEP15 408 | + MATISOSI + TRAVITWT + MATISOSJ + VOLISO + PORENT + CHAUBOISN + POMPESP 409 | + POMPESR + CHAUFSOL + POMPESQ + ENERGIEST + DIAGPERF + RESCHAL + 0) = 1 410 | et 411 | BQTRAV = 0 412 | 413 | alors erreur A737 ; 414 | verif 739: 415 | application : batch , iliad ; 416 | 417 | si 418 | positif(OPTPLAF15 + 0) = 1 419 | et 420 | SOMMEA739 = 0 421 | 422 | alors erreur A739 ; 423 | verif 7401: 424 | application : batch , iliad ; 425 | 426 | si 427 | V_IND_TRAIT > 0 428 | et 429 | (CODHAE + CODHAJ + 0) > PLAF_INVDOM5 430 | et 431 | positif(CODHAO + CODHAT + CODHAY + CODHBG + 0) = 0 432 | 433 | alors erreur A74001 ; 434 | verif 7402: 435 | application : batch , iliad ; 436 | 437 | si 438 | V_IND_TRAIT > 0 439 | et 440 | (CODHAO + CODHAT + CODHAY + CODHBG + 0) > PLAF_INVDOM6 441 | et 442 | positif(CODHAE + CODHAJ + 0) = 0 443 | 444 | alors erreur A74002 ; 445 | verif 7403: 446 | application : batch , iliad ; 447 | 448 | si 449 | V_IND_TRAIT > 0 450 | et 451 | positif(CODHAE + CODHAJ + 0) = 1 452 | et 453 | positif(CODHAO + CODHAT + CODHAY + CODHBG + 0) = 1 454 | et 455 | (CODHAE + CODHAJ + CODHAO + CODHAT + CODHAY + CODHBG + 0) > PLAF_INVDOM6 456 | 457 | alors erreur A74003 ; 458 | verif 741: 459 | application : batch , iliad ; 460 | 461 | si 462 | V_IND_TRAIT > 0 463 | et 464 | ((CELREPHR + 0 > PLAF_99999) 465 | ou 466 | (CELREPHS + 0 > PLAF_99999) 467 | ou 468 | (CELREPHT + 0 > PLAF_99999) 469 | ou 470 | (CELREPHU + 0 > PLAF_99999) 471 | ou 472 | (CELREPHV + 0 > PLAF_99999) 473 | ou 474 | (CELREPHW + 0 > PLAF_99999) 475 | ou 476 | (CELREPHX + 0 > PLAF_99999) 477 | ou 478 | (CELREPHZ + 0 > PLAF_99999)) 479 | 480 | alors erreur A741 ; 481 | verif 743: 482 | application : batch , iliad ; 483 | 484 | si 485 | V_IND_TRAIT > 0 486 | et 487 | (REPMEUBLE + 0 > PLAF_99999 488 | ou 489 | INVREPMEU + 0 > PLAF_99999 490 | ou 491 | INVREPNPRO + 0 > PLAF_99999 492 | ou 493 | INVNPROREP + 0 > PLAF_99999) 494 | 495 | alors erreur A743 ; 496 | verif 744: 497 | application : batch , iliad ; 498 | 499 | si 500 | V_IND_TRAIT > 0 501 | et 502 | RISKTEC + 0 > PLAF_TEC 503 | 504 | alors erreur A744 ; 505 | verif 7461: 506 | application : batch , iliad ; 507 | 508 | si 509 | V_IND_TRAIT > 0 510 | et 511 | CODHAE * positif(CODHAE + 0) > CODHAD * positif(CODHAD + 0) + 0 512 | 513 | alors erreur A74601 ; 514 | verif 7462: 515 | application : batch , iliad ; 516 | 517 | si 518 | V_IND_TRAIT > 0 519 | et 520 | CODHAJ * positif(CODHAJ + 0) > CODHAI * positif(CODHAI + 0) + 0 521 | 522 | alors erreur A74602 ; 523 | verif 7463: 524 | application : batch , iliad ; 525 | 526 | si 527 | V_IND_TRAIT > 0 528 | et 529 | CODHAO * positif(CODHAO + 0) > CODHAN * positif(CODHAN + 0) + 0 530 | 531 | alors erreur A74603 ; 532 | verif 7464: 533 | application : batch , iliad ; 534 | 535 | si 536 | V_IND_TRAIT > 0 537 | et 538 | CODHAT * positif(CODHAT + 0) > CODHAS * positif(CODHAS + 0) + 0 539 | 540 | alors erreur A74604 ; 541 | verif 7465: 542 | application : batch , iliad ; 543 | 544 | si 545 | V_IND_TRAIT > 0 546 | et 547 | CODHAY * positif(CODHAY + 0) > CODHAX * positif(CODHAX + 0) + 0 548 | 549 | alors erreur A74605 ; 550 | verif 7466: 551 | application : batch , iliad ; 552 | 553 | si 554 | V_IND_TRAIT > 0 555 | et 556 | CODHBG * positif(CODHBG + 0) > CODHBF * positif(CODHBF + 0) + 0 557 | 558 | alors erreur A74606 ; 559 | verif 747: 560 | application : iliad , batch ; 561 | 562 | si 563 | FIPDOMCOM + 0 > 0 564 | et 565 | V_EAD + V_EAG + 0 = 0 566 | 567 | alors erreur A747 ; 568 | verif 748: 569 | application : iliad , batch ; 570 | 571 | si 572 | V_IND_TRAIT > 0 573 | et 574 | positif(CRECHOBOI + 0) = 1 575 | et 576 | positif(CIBOIBAIL + CINRJBAIL + CRENRJ + TRAMURWC + CINRJ + TRATOIVG + CIDEP15 + MATISOSI + TRAVITWT + MATISOSJ 577 | + VOLISO + PORENT + CHAUBOISN + POMPESP + POMPESQ + POMPESR + CHAUFSOL + ENERGIEST + DIAGPERF + RESCHAL 578 | + COD7SA + COD7SB + COD7SC + COD7WB + COD7RG + COD7VH + COD7RH + COD7RI + COD7WU + COD7RJ + COD7RK + COD7RL 579 | + COD7RN + COD7RP + COD7RR + COD7RS + COD7RQ + COD7RT + COD7TV + COD7TW + COD7RV + COD7RW + COD7RZ + 0) = 0 580 | 581 | alors erreur A748 ; 582 | verif 7491: 583 | application : iliad , batch ; 584 | 585 | si 586 | V_IND_TRAIT > 0 587 | et 588 | V_REGCO+0 != 2 et V_REGCO+0 != 4 589 | et 590 | positif(CRECHOBOI + 0) = 0 591 | et 592 | COD7WX + 0 > (CIBOIBAIL + CINRJBAIL + CRENRJ + TRAMURWC + CINRJ + TRATOIVG + CIDEP15 + MATISOSI + TRAVITWT + MATISOSJ 593 | + VOLISO + PORENT + CHAUBOISN + POMPESP + POMPESQ + POMPESR + CHAUFSOL + ENERGIEST + DIAGPERF + RESCHAL + 0) 594 | 595 | alors erreur A74901 ; 596 | verif 7492: 597 | application : iliad , batch ; 598 | 599 | si 600 | V_IND_TRAIT > 0 601 | et 602 | V_REGCO+0 != 2 et V_REGCO+0 != 4 603 | et 604 | positif(CRECHOBOI + 0) = 1 605 | et 606 | COD7WX + 0 > (CIBOIBAIL + CINRJBAIL + CRENRJ + TRAMURWC + CINRJ + TRATOIVG + CIDEP15 + MATISOSI 607 | + CHAUBOISN + POMPESP + POMPESQ + POMPESR + CHAUFSOL + ENERGIEST + DIAGPERF + RESCHAL + 0) 608 | 609 | alors erreur A74902 ; 610 | verif 7511: 611 | application : iliad , batch ; 612 | 613 | si 614 | V_IND_TRAIT > 0 615 | et 616 | positif(TRAVITWT + 0) + positif(MATISOSJ + 0) > 1 617 | 618 | alors erreur A75101 ; 619 | verif 7512: 620 | application : iliad , batch ; 621 | 622 | si 623 | V_IND_TRAIT > 0 624 | et 625 | positif(COD7WU + 0) + positif(COD7RJ + 0) > 1 626 | 627 | alors erreur A75102 ; 628 | verif 7513: 629 | application : iliad , batch ; 630 | 631 | si 632 | V_IND_TRAIT > 0 633 | et 634 | positif(TRAMURWC + 0) + positif(CINRJ + 0) > 1 635 | 636 | alors erreur A75103 ; 637 | verif 7514: 638 | application : iliad , batch ; 639 | 640 | si 641 | V_IND_TRAIT > 0 642 | et 643 | positif(COD7WB + 0) + positif(COD7RG + 0) > 1 644 | 645 | alors erreur A75104 ; 646 | verif 7515: 647 | application : iliad , batch ; 648 | 649 | si 650 | V_IND_TRAIT > 0 651 | et 652 | positif(TRATOIVG + 0) + positif(CIDEP15 + 0) > 1 653 | 654 | alors erreur A75105 ; 655 | verif 7516: 656 | application : iliad , batch ; 657 | 658 | si 659 | V_IND_TRAIT > 0 660 | et 661 | positif(COD7VH + 0) + positif(COD7RH + 0) > 1 662 | 663 | alors erreur A75106 ; 664 | -------------------------------------------------------------------------------- /src/coc5.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | verif 800: 22 | application : iliad , batch ; 23 | 24 | si 25 | RG + 2 < PRODOM + PROGUY 26 | 27 | alors erreur A800 ; 28 | verif 8021: 29 | application : iliad , batch ; 30 | 31 | si 32 | (V_NOTRAIT >= 20 33 | et 34 | IPTEFP > 0 35 | et 36 | IPTEFN > 0) 37 | ou 38 | (V_NOTRAIT + 0 < 20 39 | et 40 | IPTEFP >= 0 41 | et 42 | IPTEFN >= 0 43 | et 44 | V_ROLCSG+0 < 40) 45 | 46 | alors erreur A80201 ; 47 | verif 8022: 48 | application : iliad , batch ; 49 | 50 | si 51 | ( 52 | V_NOTRAIT + 0 < 20 53 | et 54 | IPTEFP + IPTEFN >= 0 55 | et 56 | PRODOM + PROGUY + CODDAJ + CODDBJ + CODEAJ + CODEBJ >= 0 57 | ) 58 | ou 59 | ( 60 | V_NOTRAIT >= 20 61 | et 62 | IPTEFP + IPTEFN > 0 63 | et 64 | PRODOM + PROGUY + CODDAJ + CODDBJ + CODEAJ + CODEBJ > 0 65 | ) 66 | 67 | alors erreur A80202 ; 68 | verif 8023: 69 | application : iliad , batch ; 70 | si 71 | ( 72 | V_NOTRAIT + 0 < 20 73 | et 74 | SOMMEA802 > 0 75 | et 76 | PRODOM + PROGUY + CODDAJ + CODDBJ + CODEAJ + CODEBJ >= 0 77 | ) 78 | ou 79 | ( 80 | V_NOTRAIT >= 20 81 | et 82 | SOMMEA802 > 0 83 | et 84 | PRODOM + PROGUY + CODDAJ + CODDBJ + CODEAJ + CODEBJ > 0 85 | ) 86 | 87 | alors erreur A80203 ; 88 | verif 803: 89 | application : iliad , batch ; 90 | 91 | si 92 | V_IND_TRAIT > 0 93 | et 94 | positif(CODDAJ + CODDBJ + CODEAJ + CODEBJ + 0) = 1 95 | et 96 | V_REGCO + 0 != 1 97 | 98 | alors erreur A803 ; 99 | verif 804: 100 | application : iliad , batch ; 101 | 102 | si 103 | PROGUY + PRODOM + CODDAJ + CODEAJ + CODDBJ + CODEBJ+ 0 > 0 104 | et 105 | SOMMEA804 > 0 106 | 107 | alors erreur A804 ; 108 | verif 805: 109 | application : iliad , batch ; 110 | 111 | si 112 | V_IND_TRAIT > 0 113 | et 114 | positif(TREVEX) = 1 115 | et 116 | SOMMEA805 = 0 117 | 118 | alors erreur A805 ; 119 | verif 806: 120 | application : iliad , batch ; 121 | 122 | si 123 | V_IND_TRAIT > 0 124 | et 125 | positif(PROGUY + PRODOM + CODDAJ + CODEAJ + CODDBJ + CODEBJ + 0) = 1 126 | et 127 | ((positif(CARTSNBAV + 0) = 1 128 | et 129 | null(CARTSNBAV - 4) = 0) 130 | ou 131 | (positif(CARTSNBAC + 0) = 1 132 | et 133 | null(CARTSNBAC - 4) = 0)) 134 | 135 | alors erreur A806 ; 136 | verif 807: 137 | application : iliad , batch ; 138 | 139 | si 140 | V_IND_TRAIT > 0 141 | et 142 | positif(PRELIBXT + 0) = 1 143 | et 144 | positif(PCAPTAXV + PCAPTAXC + 0) = 0 145 | 146 | alors erreur A807 ; 147 | verif 821: 148 | application : iliad , batch ; 149 | 150 | si 151 | (V_IND_TRAIT > 0 ) 152 | et 153 | present(BASRET) + present(IMPRET) = 1 154 | 155 | alors erreur A821 ; 156 | verif corrective 850: 157 | application : iliad ; 158 | 159 | si 160 | APPLI_OCEANS = 0 161 | et 162 | V_NOTRAIT > 20 163 | et 164 | (positif(CSPROVYD) = 1 165 | ou 166 | positif(CSPROVYE) = 1 167 | ou 168 | positif(CSPROVYF) = 1 169 | ou 170 | positif(CSPROVYG) = 1 171 | ou 172 | positif(CSPROVYH) = 1 173 | ou 174 | positif(COD8YL) = 1 175 | ou 176 | positif(CSPROVYN) = 1 177 | ou 178 | positif(CSPROVYP) = 1 179 | ou 180 | positif(COD8YT) = 1 181 | ou 182 | positif(CDISPROV) = 1 183 | ou 184 | positif(IRANT) = 1 185 | ou 186 | positif(CRDSIM) = 1 187 | ou 188 | positif(CSGIM) = 1 189 | ou 190 | positif(DCSGIM) = 1 191 | ou 192 | positif(PRSPROV) = 1) 193 | 194 | alors erreur A850 ; 195 | verif corrective 851: 196 | application : iliad ; 197 | 198 | si 199 | APPLI_OCEANS = 0 200 | et 201 | V_NOTRAIT > 20 202 | et 203 | positif(CRDSIM) = 1 204 | 205 | alors erreur A851 ; 206 | verif corrective 852: 207 | application : iliad ; 208 | 209 | si 210 | APPLI_OCEANS = 0 211 | et 212 | present(CSGIM) = 1 213 | et 214 | V_NOTRAIT > 20 215 | 216 | alors erreur A852 ; 217 | verif corrective 853: 218 | application : iliad ; 219 | 220 | si 221 | APPLI_OCEANS = 0 222 | et 223 | present(PRSPROV) = 1 224 | et 225 | V_NOTRAIT > 20 226 | 227 | alors erreur A853 ; 228 | verif 858: 229 | application : iliad , batch ; 230 | 231 | si 232 | COD8TL + COD8UW + 0 > 0 233 | et 234 | SOMMEA858 = 0 235 | 236 | alors erreur A858 ; 237 | verif 859: 238 | application : iliad , batch ; 239 | 240 | si 241 | PRESINTER > 0 242 | et 243 | SOMMEA859 = 0 244 | 245 | alors erreur A859 ; 246 | verif 862: 247 | application : iliad , batch ; 248 | 249 | si 250 | AUTOVERSLIB > 0 251 | et 252 | SOMMEA862 = 0 253 | 254 | alors erreur A862 ; 255 | verif corrective 8630: 256 | application : iliad ; 257 | 258 | si 259 | APPLI_OCEANS = 0 260 | et 261 | positif(AUTOVERSSUP + 0) = 1 262 | et 263 | positif(AUTOBICVV + AUTOBICPV + AUTOBNCV 264 | + AUTOBICVC + AUTOBICPC + AUTOBNCC 265 | + AUTOBICVP + AUTOBICPP + AUTOBNCP + 0) = 0 266 | 267 | alors erreur A863 ; 268 | verif 864: 269 | application : iliad , batch ; 270 | 271 | si 272 | V_IND_TRAIT > 0 273 | et 274 | COD8YL + 0 > CGLOA + 0 275 | 276 | alors erreur A864 ; 277 | verif 865: 278 | application : iliad , batch ; 279 | 280 | si 281 | V_IND_TRAIT > 0 282 | et 283 | COD8YT + 0 > CVNSALC + 0 284 | 285 | alors erreur A865 ; 286 | verif 8661: 287 | application : iliad , batch ; 288 | 289 | si 290 | V_IND_TRAIT > 0 291 | et 292 | CSPROVYD + 0 > max(0 , RSE1 + PRSE1 - CIRSE1) + 0 293 | 294 | alors erreur A86601 ; 295 | verif 8662: 296 | application : iliad , batch ; 297 | 298 | si 299 | V_IND_TRAIT > 0 300 | et 301 | CSPROVYE + 0 > max(0 , RSE5 + PRSE5 - CIRSE5) + 0 302 | 303 | alors erreur A86602 ; 304 | verif 8663: 305 | application : iliad , batch ; 306 | 307 | si 308 | V_IND_TRAIT > 0 309 | et 310 | CSPROVYF + 0 > max(0 , RSE8TV + arr(max(0 , RSE8TV - CIRSE8TV - CSPROVYF) * TXINT/100) - CIRSE8TV) + 0 311 | 312 | alors erreur A86603 ; 313 | verif 8664: 314 | application : iliad , batch ; 315 | 316 | si 317 | V_IND_TRAIT > 0 318 | et 319 | CSPROVYG + 0 > max(0 , RSE3 + PRSE3 - CIRSE3) + 0 320 | 321 | alors erreur A86604 ; 322 | verif 8665: 323 | application : iliad , batch ; 324 | 325 | si 326 | V_IND_TRAIT > 0 327 | et 328 | CSPROVYH + 0 > max(0 , RSE8TX + arr(max(0 , RSE8TX - CIRSE8TX - CSPROVYH) * TXINT/100) - CIRSE8TX) + 0 329 | 330 | alors erreur A86605 ; 331 | verif 8666: 332 | application : iliad , batch ; 333 | 334 | si 335 | V_IND_TRAIT > 0 336 | et 337 | CSPROVYN + 0 > max(0 , RSE8SA + arr(max(0 , RSE8SA - CIRSE8SA - CSPROVYN) * TXINT/100) - CIRSE8SA) + 0 338 | 339 | alors erreur A86606 ; 340 | verif 8667: 341 | application : iliad , batch ; 342 | 343 | si 344 | V_IND_TRAIT > 0 345 | et 346 | CSPROVYP + 0 > max(0 , RSE8SB + arr(max(0 , RSE8SB - CIRSE8SB - CSPROVYP) * TXINT/100) - CIRSE8SB) + 0 347 | 348 | alors erreur A86607 ; 349 | verif 868: 350 | application : batch , iliad ; 351 | 352 | si 353 | V_IND_TRAIT + 0 > 0 354 | et 355 | (CDISPROV + 0 > CDIS + 0 356 | ou 357 | (positif(CDISPROV + 0) = 1 et positif(GSALV + GSALC + 0) = 0)) 358 | 359 | alors erreur A868 ; 360 | verif 870: 361 | application : batch , iliad ; 362 | 363 | si 364 | positif(DCSGIM) = 1 365 | et 366 | positif(CSGIM + 0) != 1 367 | 368 | alors erreur A870 ; 369 | verif 871: 370 | application : batch , iliad ; 371 | 372 | si 373 | CRDSIM > RDSN 374 | 375 | alors erreur A871 ; 376 | verif 872: 377 | application : iliad , batch ; 378 | 379 | si 380 | V_IND_TRAIT + 0 > 0 381 | et 382 | PRSPROV > PRS 383 | 384 | alors erreur A872 ; 385 | verif 873: 386 | application : iliad , batch ; 387 | 388 | si 389 | APPLI_OCEANS = 0 390 | et 391 | CSGIM > CSG 392 | 393 | alors erreur A873 ; 394 | verif 874: 395 | application : iliad , batch ; 396 | 397 | si 398 | IPSOUR >= 0 399 | et 400 | V_CNR + 0 = 0 401 | et 402 | SOMMEA874 = 0 403 | 404 | alors erreur A874 ; 405 | verif 875: 406 | application : iliad , batch ; 407 | 408 | si 409 | max(0 , IRB + TAXASSUR + IPCAPTAXT + TAXLOY + IHAUTREVT + PTOTD 410 | - IAVT - RCMAVFT - CICA - I2DH - CICORSE - CIRECH - CICAP 411 | - CICHR - CICULTUR - CREREVET - CIGLO - CIDONENTR) < IRANT 412 | 413 | alors erreur A875 ; 414 | verif 877: 415 | application : iliad , batch ; 416 | 417 | si 418 | (IPRECH + 0 > 0 ou IPCHER + 0 > 0) 419 | et 420 | SOMMEA877 = 0 421 | 422 | alors erreur A877 ; 423 | verif 8781: 424 | application : batch , iliad ; 425 | 426 | si 427 | V_IND_TRAIT > 0 428 | et 429 | positif(REVCSXA + 0) = 1 430 | et 431 | positif(SALECS + 0) = 0 432 | 433 | alors erreur A87801 ; 434 | verif 8782: 435 | application : batch , iliad ; 436 | 437 | si 438 | V_IND_TRAIT > 0 439 | et 440 | positif(REVCSXB + 0) = 1 441 | et 442 | positif(SALECSG + 0) = 0 443 | 444 | alors erreur A87802 ; 445 | verif 8783: 446 | application : batch , iliad ; 447 | 448 | si 449 | V_IND_TRAIT > 0 450 | et 451 | positif(REVCSXC + 0) = 1 452 | et 453 | positif(ALLECS + 0) = 0 454 | 455 | alors erreur A87803 ; 456 | verif 8784: 457 | application : batch , iliad ; 458 | 459 | si 460 | V_IND_TRAIT > 0 461 | et 462 | positif(REVCSXD + 0) = 1 463 | et 464 | positif(INDECS + 0) = 0 465 | 466 | alors erreur A87804 ; 467 | verif 8785: 468 | application : batch , iliad ; 469 | 470 | si 471 | V_IND_TRAIT > 0 472 | et 473 | positif(REVCSXE + 0) = 1 474 | et 475 | positif(PENECS + 0) = 0 476 | 477 | alors erreur A87805 ; 478 | verif 8786: 479 | application : batch , iliad ; 480 | 481 | si 482 | V_IND_TRAIT > 0 483 | et 484 | positif(COD8XI + 0) = 1 485 | et 486 | positif(COD8SA + 0) = 0 487 | 488 | alors erreur A87806 ; 489 | verif 8787: 490 | application : batch , iliad ; 491 | 492 | si 493 | V_IND_TRAIT > 0 494 | et 495 | positif(COD8XJ + 0) = 1 496 | et 497 | positif(COD8SB + 0) = 0 498 | 499 | alors erreur A87807 ; 500 | verif 879: 501 | application : iliad , batch ; 502 | 503 | si 504 | CIINVCORSE + CICORSENOW + 0 > 0 505 | et 506 | SOMMEA879 = 0 507 | 508 | alors erreur A879 ; 509 | verif 880: 510 | application : iliad , batch ; 511 | 512 | si 513 | CRIGA > 0 514 | et 515 | SOMMEA880 = 0 516 | 517 | alors erreur A880 ; 518 | verif 881: 519 | application : iliad , batch ; 520 | 521 | si 522 | CREFAM > 0 523 | et 524 | SOMMEA881 = 0 525 | 526 | alors erreur A881 ; 527 | verif 8821: 528 | application : iliad , batch ; 529 | 530 | si 531 | ( 532 | IPMOND > 0 533 | et 534 | (present(IPTEFP) = 0 et present(IPTEFN) = 0) 535 | ) 536 | ou 537 | ( 538 | (present(IPTEFP) = 1 ou present(IPTEFN) = 1) 539 | et 540 | present(IPMOND) = 0 541 | ) 542 | 543 | alors erreur A88201 ; 544 | verif 8822: 545 | application : iliad , batch ; 546 | 547 | si 548 | (present(IPMOND) 549 | + present(SALEXTV) + present(SALEXTC) + present(SALEXT1) + present(SALEXT2) + present(SALEXT3) + present(SALEXT4) 550 | + present(COD1AH) + present(COD1BH) + present(COD1CH) + present(COD1DH) + present(COD1EH) + present(COD1FH)) = 0 551 | et 552 | positif_ou_nul(TEFFHRC + COD8YJ) = 1 553 | 554 | alors erreur A88202 ; 555 | verif 883: 556 | application : iliad , batch ; 557 | 558 | si 559 | IPBOCH > 0 560 | et 561 | CIIMPPRO + CIIMPPRO2 + REGCI + PRELIBXT + COD8XF + COD8XG + COD8XH + COD8XV + COD8XY + 0 = 0 562 | 563 | alors erreur A883 ; 564 | verif 884: 565 | application : iliad , batch ; 566 | 567 | si 568 | REGCI + COD8XY > 0 569 | et 570 | SOMMEA884 = 0 571 | 572 | alors erreur A884 ; 573 | verif 8851: 574 | application : iliad , batch ; 575 | 576 | si 577 | positif(CIIMPPRO2 + 0) = 1 578 | et 579 | present(BPVSJ) = 0 580 | 581 | alors erreur A88501 ; 582 | verif 8852: 583 | application : iliad , batch ; 584 | 585 | si 586 | positif(COD8XV + 0) = 1 587 | et 588 | present(COD2FA) = 0 589 | 590 | alors erreur A88502 ; 591 | verif 8853: 592 | application : iliad , batch ; 593 | 594 | si 595 | positif(CIIMPPRO + 0) = 1 596 | et 597 | somme(i=V,C,P:present(BA1Ai) + present(BI1Ai) + present(BN1Ai)) = 0 598 | 599 | alors erreur A88503 ; 600 | verif 8854: 601 | application : iliad , batch ; 602 | 603 | si 604 | positif(COD8XF + 0) = 1 605 | et 606 | present(BPV18V) + present(BPV18C) = 0 607 | 608 | alors erreur A88504 ; 609 | verif 8855: 610 | application : iliad , batch ; 611 | 612 | si 613 | positif(COD8XG + 0) = 1 614 | et 615 | present(BPCOPTV) + present(BPCOPTC) = 0 616 | 617 | alors erreur A88505 ; 618 | verif 8856: 619 | application : iliad , batch ; 620 | 621 | si 622 | positif(COD8XH + 0) = 1 623 | et 624 | present(BPV40V) + present(BPV40C) = 0 625 | 626 | alors erreur A88506 ; 627 | verif 886: 628 | application : iliad , batch ; 629 | 630 | si 631 | IPPNCS > 0 632 | et 633 | positif(REGCI + CIIMPPRO + CIIMPPRO2 + COD8XV + COD8XF + COD8XG + COD8XH + COD8PA + 0) != 1 634 | 635 | alors erreur A886 ; 636 | verif 887: 637 | application : iliad , batch ; 638 | 639 | si 640 | APPLI_OCEANS = 0 641 | et 642 | REGCI + 0 > IPBOCH + 0 643 | 644 | alors erreur A887 ; 645 | verif 888: 646 | application : iliad , batch ; 647 | 648 | si 649 | IPELUS > 0 650 | et 651 | positif(present(TSHALLOV) + present(TSHALLOC) + present(CARTSV) + present(CARTSC) + present(CARTSNBAV) + present(CARTSNBAC)) = 0 652 | et 653 | positif(present(ALLOV) + present(ALLOC) + present(REMPLAV) + present(REMPLAC) + present(REMPLANBV) + present(REMPLANBC)) = 0 654 | 655 | alors erreur A888 ; 656 | verif 889: 657 | application : iliad , batch ; 658 | 659 | si 660 | (APPLI_OCEANS = 0) 661 | et 662 | REVFONC + 0 > IND_TDR + 0 663 | et 664 | present(IND_TDR) = 0 665 | 666 | alors erreur A889 ; 667 | verif 890: 668 | application : iliad , batch ; 669 | 670 | si 671 | CREAPP > 0 672 | et 673 | SOMMEA890 = 0 674 | 675 | alors erreur A890 ; 676 | verif 891: 677 | application : iliad , batch ; 678 | 679 | si 680 | CREPROSP > 0 681 | et 682 | SOMMEA891 = 0 683 | 684 | alors erreur A891 ; 685 | verif 893: 686 | application : iliad , batch ; 687 | 688 | si 689 | CREFORMCHENT > 0 690 | et 691 | SOMMEA893 = 0 692 | 693 | alors erreur A893 ; 694 | verif 894: 695 | application : iliad , batch ; 696 | 697 | si 698 | CREINTERESSE > 0 699 | et 700 | SOMMEA894 = 0 701 | 702 | alors erreur A894 ; 703 | verif 895: 704 | application : iliad , batch ; 705 | 706 | si 707 | CREAGRIBIO > 0 708 | et 709 | SOMMEA895 = 0 710 | 711 | alors erreur A895 ; 712 | verif 896: 713 | application : iliad , batch ; 714 | 715 | si 716 | CREARTS > 0 717 | et 718 | SOMMEA896 = 0 719 | 720 | alors erreur A896 ; 721 | verif 898: 722 | application : iliad , batch ; 723 | 724 | si 725 | CRECONGAGRI > 0 726 | et 727 | SOMMEA898 = 0 728 | 729 | alors erreur A898 ; 730 | verif 899: 731 | application : iliad , batch ; 732 | 733 | si 734 | CRERESTAU > 0 735 | et 736 | SOMMEA899 = 0 737 | 738 | alors erreur A899 ; 739 | -------------------------------------------------------------------------------- /src/coi2.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | verif 2500: 22 | application : iliad , batch ; 23 | si 24 | APPLI_OCEANS = 0 25 | et 26 | FRNV > (TSHALLOV + ALLOV) * 0.10 27 | et 28 | RDSYVO > 0 29 | et 30 | PRBRV + CARPEV + PENINV + CODRAZ + PALIV + PENSALV + 0 = 0 31 | 32 | alors erreur I00101 ; 33 | verif 2501: 34 | application : iliad , batch ; 35 | si 36 | APPLI_OCEANS = 0 37 | et 38 | FRNC > (TSHALLOC + ALLOC) * 0.10 39 | et 40 | RDSYCJ > 0 41 | et 42 | PRBRC + CARPEC + PENINC + CODRBZ + PALIC + PENSALC + 0 = 0 43 | 44 | alors erreur I00102 ; 45 | verif 2502: 46 | application : iliad, batch ; 47 | si 48 | APPLI_OCEANS = 0 49 | et 50 | ( 51 | ( 52 | ( 53 | ( FRN1 > (TSHALLO1 + ALLO1) *0.10) 54 | et (PRBR1 + CARPEP1 + PENIN1 + CODRCZ + PALI1 + PENSALP1 + 0 = 0) 55 | ) 56 | ou 57 | ( 58 | ( FRN2 > (TSHALLO2 + ALLO2) *0.10) 59 | et (PRBR2 + CARPEP2 + PENIN2 + CODRDZ + PALI2 + PENSALP2 + 0 = 0) 60 | ) 61 | ou 62 | ( 63 | ( FRN3 > (TSHALLO3 + ALLO3) *0.10) 64 | et (PRBR3 + CARPEP3 + PENIN3 + CODREZ + PALI3 + PENSALP3 + 0 = 0) 65 | ) 66 | ou 67 | ( 68 | ( FRN4 > (TSHALLO4 + ALLO4) *0.10) 69 | et (PRBR4 + CARPEP4 + PENIN4 + CODRFZ + PALI4 + PENSALP4 + 0 = 0) 70 | ) 71 | ) et RDSYPP > 0 72 | ) 73 | alors erreur I00103 ; 74 | verif 2566: 75 | application : batch , iliad ; 76 | 77 | si 78 | APPLI_COLBERT + APPLI_BATCH + APPLI_ILIAD = 1 79 | et 80 | CHRFAC > 0 81 | et 82 | CHNFAC + 0 = 0 83 | et 84 | positif(NATIMP) = 1 85 | et 86 | V_CNR = 0 87 | 88 | alors erreur I008 ; 89 | verif 2565: 90 | application : batch , iliad ; 91 | 92 | si 93 | APPLI_COLBERT + APPLI_BATCH + APPLI_ILIAD = 1 94 | et 95 | RDCOM > 0 96 | et 97 | NBACT + 0 = 0 98 | et 99 | positif(NATIMP) = 1 100 | 101 | alors erreur I009 ; 102 | verif 3301: 103 | application : iliad, batch ; 104 | 105 | si 106 | APPLI_OCEANS = 0 107 | et 108 | ( 109 | V_0AV = 1 110 | et 111 | ( 112 | ( 113 | positif(XETRANC) + positif(EXOCETC) + positif(FRNC) 114 | + positif(PENINC) + positif(CODRBZ) 115 | + positif(TSHALLOC) + positif(CODDBJ) + positif(CODEBJ) + positif(ALLOC) 116 | + positif(SALEXTC) + positif(COD1BD) + positif(COD1BE) + positif(PPEXTC) + positif(COD1BH) 117 | + positif(PRBC) + somme(i=2..4:positif(iPRBC)) + positif(PEBFC) 118 | + positif(CARTSC) + positif(REMPLAC) + positif(CARPEC) + positif(PENSALC) 119 | + somme (i=1..3: positif (GLDiC)) + somme (i=A: positif(BiFC) + somme(j=A: positif(Bi1jC))) 120 | + somme (i=H,C: 121 | somme(j= A,N: somme(k=R,D: positif(BjikEC))) + 122 | somme(j=N: positif(BIiDjC)) + positif(BIiNOC) 123 | ) 124 | + positif(BICREC) + positif(BI2AC) + positif(BICDEC) 125 | + positif(TSASSUC) 126 | + positif(PPETPC) + positif(PPENHC) 127 | + positif(GSALC) + positif(PCAPTAXC) 128 | 129 | + positif( FEXC ) + positif( BAFC ) + positif( BAFORESTC ) + positif( BAFPVC ) + positif( BAF1AC ) 130 | + positif( BAEXC ) + positif( BACREC ) + positif( 4BACREC ) + positif( BA1AC ) 131 | + positif(BACDEC) 132 | + positif( BAHEXC ) + positif( BAHREC ) + positif( 4BAHREC ) 133 | + positif( BAHDEC ) + positif( BAPERPC ) + positif( BANOCGAC ) 134 | + positif( AUTOBICVC ) + positif( AUTOBICPC ) + positif( MIBEXC ) + positif( MIBVENC ) 135 | + positif( MIBPRESC ) + positif( MIBPVC ) + positif( MIB1AC ) + positif( MIBDEC ) 136 | + positif( BICEXC ) + positif( BICNOC ) + positif( LOCPROCGAC ) 137 | + positif( BI1AC ) + positif(BICDNC ) 138 | + positif( LOCDEFPROCGAC ) 139 | + positif( BIHEXC ) + positif( BIHNOC ) + positif( LOCPROC ) 140 | + positif( BIHDNC ) + positif( BIPERPC ) 141 | + positif( LOCDEFPROC ) 142 | + positif( MIBMEUC ) + positif( MIBGITEC ) + positif( MIBNPEXC ) + positif( MIBNPVENC ) 143 | + positif( MIBNPPRESC ) + positif( MIBNPPVC ) + positif( MIBNP1AC ) + positif( MIBNPDEC ) 144 | + positif( BICNPEXC ) + positif( BICREC ) + positif( LOCNPCGAC ) 145 | + positif( BI2AC ) + positif( LOCDEFNPCGAC) 146 | + positif( BICNPHEXC ) + positif( BICHREC ) + positif( LOCNPC ) 147 | + positif( BICHDEC) 148 | + positif(LOCDEFNPC) 149 | + positif( AUTOBNCC ) + positif( BNCPROEXC ) + positif( BNCPROC ) 150 | + positif( BNCPROPVC ) + positif( BNCPRO1AC ) + positif( BNCPRODEC ) 151 | + positif( BNCEXC ) + positif( BNCREC ) + positif( BN1AC ) 152 | + positif( BNCDEC ) 153 | + positif( BNHEXC ) + positif( BNHREC ) + positif( BNHDEC ) 154 | + positif ( BNCCRC ) + positif ( CESSASSC ) + positif( XHONOAAC ) + positif( XHONOC ) 155 | + positif( BNCNPC ) + positif( BNCNPPVC ) + positif( BNCNP1AC ) + positif( BNCNPDEC ) 156 | + positif( BNCNPREXAAC ) + positif( BNCAABC ) + positif( BNCNPREXC ) + positif( ANOVEP ) 157 | + positif( INVENTC ) + positif( PVINCE ) + positif( BNCAADC) 158 | + positif( DNOCEPC ) + positif( BNCCRFC ) 159 | + positif( RCSC ) + positif( BANOCGAC ) + positif( PVSOCC ) + positif( PPEACC ) + positif( PPENJC ) 160 | 161 | + positif( PERPC ) + positif( PERP_COTC ) + positif( RACCOTC ) + positif( PLAF_PERPC ) 162 | + positif ( PERPPLAFCC ) + positif ( PERPPLAFNUC1 ) + positif ( PERPPLAFNUC2 ) + positif ( PERPPLAFNUC3 ) 163 | + positif ( RDSYCJ ) 164 | + positif( ELURASC ) 165 | ) 166 | > 0 167 | ) 168 | ) 169 | alors erreur I010 ; 170 | verif 3210: 171 | application : iliad , batch ; 172 | 173 | si 174 | APPLI_OCEANS = 0 175 | et 176 | (V_0AM + V_0AO + 0 = 1) et V_0AS = 1 et V_0AP+0 = 0 et V_0AF+0 = 0 177 | et 178 | V_ANREV - V_0DA < 75 179 | et 180 | V_ANREV - V_0DB < 75 181 | 182 | alors erreur I011 ; 183 | verif 3221: 184 | application : batch , iliad ; 185 | 186 | si 187 | APPLI_OCEANS = 0 188 | et 189 | (V_0AM + V_0AO + 0 = 0 ) 190 | et 191 | V_0AZ + 0 = 0 192 | et 193 | V_0AP + 0 = 0 194 | et 195 | V_0AW = 1 196 | et 197 | V_ANREV - V_0DA < 75 198 | 199 | alors erreur I012 ; 200 | verif 3214: 201 | application : batch , iliad ; 202 | 203 | si 204 | APPLI_OCEANS + APPLI_COLBERT = 0 205 | et 206 | ( 207 | V_BT0CF >0 208 | et V_0CH >0 209 | et positif(V_0CF+0) != 1 210 | et V_BT0CF + 0 = somme(i=0..5:positif(V_BT0Fi+0)) 211 | et V_BT0CH + 0 = somme(i=0..5:positif(V_BT0Hi+0)) 212 | et V_0CF + 0 = somme(i=0..5:positif(V_0Fi+0)) 213 | et V_0CH + 0 = somme(i=0..5:positif(V_0Hi+0)) 214 | et (( V_0CH < V_BT0CF ) 215 | ou 216 | ( V_0CH = V_BT0CF 217 | et somme(i=0..5:V_0Hi+0) != somme(i=0..5:V_BT0Fi+0) ) 218 | ou 219 | ( V_0CH = V_BT0CF 220 | et somme(i=0..5:V_0Hi+0) = somme(i=0..5:V_BT0Fi+0) 221 | et somme(i=0..5: (1/V_0Hi)) != somme(i=0..5: (1/V_BT0Fi)) ) 222 | ou 223 | ( V_0CH > V_BT0CF 224 | et somme(i=0..5:positif(somme(j=0..5:null(V_0Hj - V_BT0Fi)))*V_BT0Fi) != somme(i=0..5:V_BT0Fi) 225 | ) 226 | ou 227 | ( V_0CH > V_BT0CF 228 | et somme(i=0..5:positif(somme(j=0..5:null(V_0Hj - V_BT0Fi)))*V_BT0Fi) = somme(i=0..5:V_BT0Fi) 229 | et somme(i=0..5:positif(somme(j=0..5:null(V_0Hi - V_BT0Fj)))*V_0Hi) < somme(i=0..5:V_BT0Fi) 230 | ) 231 | ) 232 | ) 233 | et 234 | V_IND_TRAIT = 4 235 | 236 | alors erreur I014 ; 237 | verif 3216: 238 | application : batch , iliad ; 239 | si 240 | V_IND_TRAIT = 4 241 | et 242 | V_REGCO != 2 243 | et 244 | V_REGCO != 4 245 | et 246 | ( 247 | DEFRCM + 0 > V_BTDFRCM1 + PLAF_PRECONS * (1 - positif(V_BTDFRCM1)) 248 | ou 249 | DEFRCM2 + 0 > V_BTDFRCM2 + PLAF_PRECONS * (1 - positif(V_BTDFRCM2)) 250 | ou 251 | DEFRCM3 + 0 > V_BTDFRCM3 + PLAF_PRECONS * (1 - positif(V_BTDFRCM3)) 252 | ou 253 | DEFRCM4 + 0 > V_BTDFRCM4 + PLAF_PRECONS * (1 - positif(V_BTDFRCM4)) 254 | ou 255 | DEFRCM5 + 0 > V_BTDFRCM5 + PLAF_PRECONS * (1 - positif(V_BTDFRCM5)) 256 | ou 257 | DEFRCM6 + 0 > V_BTDFRCM6 + PLAF_PRECONS * (1 - positif(V_BTDFRCM6))) 258 | 259 | alors erreur I015 ; 260 | verif 3217: 261 | application : batch , iliad ; 262 | 263 | si 264 | V_IND_TRAIT > 0 265 | et 266 | V_REGCO != 2 267 | et 268 | V_REGCO != 4 269 | et 270 | positif(PVSURSI + PVIMPOS + CODRWA + CODRWB + 0) = 1 271 | 272 | alors erreur I016 ; 273 | -------------------------------------------------------------------------------- /src/coi3.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | verif 1301: 22 | application : iliad ; 23 | 24 | si 25 | APPLI_OCEANS = 0 26 | et 27 | V_IND_TRAIT > 0 28 | et 29 | (BAFV > PLAF_FORFBA 30 | ou 31 | BAFC > PLAF_FORFBA 32 | ou 33 | BAFP > PLAF_FORFBA) 34 | 35 | alors erreur IM02 ; 36 | verif 2205: 37 | application : batch , iliad ; 38 | 39 | si 40 | APPLI_COLBERT + APPLI_OCEANS + APPLI_ILIAD = 1 41 | et 42 | V_IND_TRAIT > 0 43 | et 44 | CREFAM + 0 > 500000 45 | 46 | alors erreur IM03 ; 47 | verif 2504: 48 | application : batch , iliad ; 49 | 50 | si 51 | APPLI_COLBERT + APPLI_ILIAD + APPLI_OCEANS = 1 52 | et 53 | V_IND_TRAIT > 0 54 | et 55 | CREPROSP > LIM_PROSP 56 | 57 | alors erreur IM08 ; 58 | verif 2009: 59 | application : iliad ; 60 | 61 | si 62 | APPLI_OCEANS = 0 63 | et 64 | present (V_BTCO2044P) = 1 65 | et 66 | present (CO2044P) = 0 67 | et 68 | V_IND_TRAIT = 4 69 | 70 | alors erreur IM09 ; 71 | verif 3110: 72 | application : iliad ; 73 | 74 | si 75 | APPLI_OCEANS = 0 76 | et 77 | present(V_CALCULIR) = 0 78 | et 79 | V_0CF+0 != somme (i = 0..7: positif(V_0Fi+0)) 80 | 81 | alors erreur IM1101 ; 82 | verif 3111: 83 | application : iliad ; 84 | 85 | si 86 | APPLI_OCEANS = 0 87 | et 88 | present(V_CALCULIR) = 0 89 | et 90 | V_0CG != somme (i = 0, 1, 2, 3: positif(V_0Gi+0)) 91 | 92 | alors erreur IM1102 ; 93 | verif 3118: 94 | application : iliad ; 95 | 96 | si 97 | APPLI_OCEANS = 0 98 | et 99 | present(V_CALCULIR) = 0 100 | et 101 | V_0CH != somme (i = 0,1,2,3,4,5: positif(V_0Hi+0)) 102 | 103 | alors erreur IM1103 ; 104 | verif 3116: 105 | application : iliad ; 106 | 107 | si 108 | APPLI_OCEANS = 0 109 | et 110 | present(V_CALCULIR) = 0 111 | et 112 | V_0CI != somme (i = 0, 1, 2, 3: positif(V_0Ii+0)) 113 | 114 | alors erreur IM1104 ; 115 | verif 3112: 116 | application : iliad ; 117 | 118 | si 119 | APPLI_OCEANS = 0 120 | et 121 | present(V_CALCULIR) = 0 122 | et 123 | V_0CR != somme (i = 0, 1, 2, 3: positif(V_0Ri+0)) 124 | 125 | alors erreur IM1105 ; 126 | verif 3113: 127 | application : iliad ; 128 | 129 | si 130 | APPLI_OCEANS = 0 131 | et 132 | present(V_CALCULIR) = 0 133 | et 134 | V_0DJ != somme (i = 0, 1, 2, 3: positif(V_0Ji+0)) 135 | 136 | alors erreur IM1106 ; 137 | verif 3114: 138 | application : iliad ; 139 | 140 | si 141 | APPLI_OCEANS = 0 142 | et 143 | present(V_CALCULIR) = 0 144 | et 145 | V_0DN != somme (i = 0, 1, 2, 3: positif(V_0Ni+0)) 146 | 147 | alors erreur IM1107 ; 148 | verif 3117: 149 | application : iliad ; 150 | 151 | si 152 | APPLI_OCEANS = 0 153 | et 154 | present(V_CALCULIR) = 0 155 | et 156 | V_0DP != positif(V_0P0+0) 157 | 158 | alors erreur IM1108 ; 159 | verif 3215: 160 | application : iliad ; 161 | 162 | si 163 | APPLI_OCEANS = 0 164 | et 165 | positif(null(V_NOTRAIT - 23) + null(V_NOTRAIT - 33) + null(V_NOTRAIT - 43) + null(V_NOTRAIT - 53) + null(V_NOTRAIT - 63)) = 0 166 | et 167 | IREST >= LIM_RESTIT 168 | 169 | alors erreur IM14 ; 170 | verif 1108: 171 | application : iliad ; 172 | 173 | si 174 | APPLI_OCEANS = 0 175 | et 176 | V_IND_TRAIT + 0 = 4 177 | et 178 | V_NOTRAIT + 0 < 14 179 | et 180 | ((RCMAVFT > PLAF_AF 181 | et 182 | RCMABD + REVACT + RCMHAD + DISQUO + RCMHAB + INTERE + RCMTNC + REVPEA + COD2FA > 0 183 | et 184 | RCMAVFT > arr(40 * (RCMABD + REVACT + RCMHAD + DISQUO + RCMHAB + INTERE + RCMTNC + REVPEA + COD2FA) / 100)) 185 | ou 186 | (DIREPARGNE > PLAF_AF 187 | et 188 | PPLIB + RCMLIB + RCMHAD + DISQUO + RCMHAB + INTERE + COD2FA + BPVRCM > 0 189 | et 190 | DIREPARGNE > arr(60 * (PPLIB + RCMLIB + RCMHAD + DISQUO + RCMHAB + INTERE + COD2FA + BPVRCM) / 100))) 191 | 192 | alors erreur IM1501 ; 193 | verif 1109: 194 | application : iliad ; 195 | 196 | si 197 | APPLI_OCEANS = 0 198 | et 199 | V_NOTRAIT + 0 >= 14 200 | et 201 | ((RCMAVFT > PLAF_AF 202 | et 203 | RCMAVFT <= PLAF_AF2 204 | et 205 | RCMABD + REVACT + RCMHAD + DISQUO + RCMHAB + INTERE + RCMTNC + REVPEA + COD2FA > 0 206 | et 207 | RCMAVFT > arr(40 * (RCMABD + REVACT + RCMHAD + DISQUO + RCMHAB + INTERE + RCMTNC + REVPEA + COD2FA) / 100)) 208 | ou 209 | (DIREPARGNE > PLAF_AF 210 | et 211 | DIREPARGNE <= PLAF_AF2 212 | et 213 | PPLIB + RCMLIB + RCMHAD + DISQUO + RCMHAB + INTERE + COD2FA + BPVRCM > 0 214 | et 215 | DIREPARGNE > arr(60 * (PPLIB + RCMLIB + RCMHAD + DISQUO + RCMHAB + INTERE + COD2FA + BPVRCM) / 100))) 216 | 217 | alors erreur IM1502 ; 218 | verif 5060: 219 | application : iliad ; 220 | 221 | si 222 | APPLI_OCEANS = 0 223 | et 224 | V_ZDC+0 = 0 225 | et 226 | V_BTMUL+0 = 0 227 | et 228 | V_0AX+0 = 0 et V_0AY+0 = 0 et V_0AZ+0 = 0 et V_0AO+0 = 0 229 | et 230 | V_BTRNI > LIM_BTRNI 231 | et 232 | RNI > V_BTRNI * 9 233 | et 234 | RNI < 100000 235 | et 236 | V_IND_TRAIT = 4 237 | 238 | alors erreur IM1601 ; 239 | verif 5061: 240 | application : iliad ; 241 | 242 | si 243 | APPLI_OCEANS = 0 244 | et 245 | V_ZDC+0 = 0 246 | et 247 | V_BTMUL+0 = 0 248 | et 249 | V_0AX+0 = 0 et V_0AY+0 = 0 et V_0AZ+0 = 0 et V_0AO+0 = 0 250 | et 251 | V_BTRNI > LIM_BTRNI 252 | et 253 | RNI > V_BTRNI * 5 254 | et 255 | RNI >= 100000 256 | et 257 | V_IND_TRAIT = 4 258 | 259 | alors erreur IM1602 ; 260 | verif 5101: 261 | application : iliad ; 262 | 263 | si 264 | APPLI_OCEANS = 0 265 | et 266 | V_BTIMP > LIM_BTIMP 267 | et 268 | IINET >= V_BTIMP * 2 269 | et 270 | V_ZDC+0 = 0 271 | et 272 | V_IND_TRAIT = 4 273 | 274 | alors erreur IM17 ; 275 | verif 5102: 276 | application : iliad ; 277 | 278 | si 279 | APPLI_OCEANS = 0 280 | et 281 | V_BTIMP > LIM_BTIMP 282 | et 283 | IINET <= V_BTIMP / 2 284 | et 285 | V_ZDC+0 = 0 286 | et 287 | V_IND_TRAIT = 4 288 | 289 | alors erreur IM18 ; 290 | verif 3620: 291 | application : iliad ; 292 | si 293 | APPLI_OCEANS = 0 294 | et 295 | (V_IND_TRAIT = 4 296 | et V_BT0CF + 0 = somme(i=0..5:positif(V_BT0Fi+0)) 297 | et V_BT0CH + 0 = somme(i=0..5:positif(V_BT0Hi+0)) 298 | et V_0CF + 0 = somme(i=0..5:positif(V_0Fi+0)) 299 | et V_0CH + 0 = somme(i=0..5:positif(V_0Hi+0)) 300 | et 301 | ( 302 | V_BT0CH + V_BT0CF + 0 > V_0CH + V_0CF 303 | ou 304 | (V_BT0CF = 1 et V_0CF =1 et V_0CH + 0 = 0 et pour un i dans 0,1: V_0Fi = V_ANREV ) 305 | ou 306 | (V_BT0CF = 1 et V_0CH =1 et V_0CF + 0 = 0 et pour un i dans 0,1: V_0Hi = V_ANREV ) 307 | ou 308 | (V_BT0CH = 1 et V_0CH =1 et V_0CF + 0 = 0 et pour un i dans 0,1: V_0Hi = V_ANREV ) 309 | ou 310 | (V_BT0CH = 1 et V_0CF =1 et V_0CH + 0 = 0 et pour un i dans 0,1: V_0Fi = V_ANREV ) 311 | ) 312 | ) 313 | alors erreur IM19 ; 314 | verif 5100: 315 | application : iliad ; 316 | 317 | si 318 | APPLI_OCEANS = 0 319 | et 320 | V_NOTRAIT + 0 != 14 321 | et 322 | V_BTANC + 0 = 1 323 | et 324 | ((V_BTNI1+0 )non dans (50,92)) 325 | et 326 | V_BTIMP + 0 <= 0 327 | et 328 | IINET > LIM_BTIMP * 2 329 | et 330 | V_ZDC + 0 = 0 331 | et 332 | V_IND_TRAIT = 4 333 | 334 | alors erreur IM20 ; 335 | verif 20091: 336 | application : iliad ; 337 | 338 | si 339 | APPLI_OCEANS = 0 340 | et 341 | V_IND_TRAIT > 0 342 | et 343 | positif(ANNUL2042) = 1 344 | 345 | alors erreur IM40 ; 346 | verif 4380: 347 | application : iliad ; 348 | si 349 | (FLAGDERNIE+0 = 1) et ((DEFRI = 1) et (PREM8_11=1) et (((VARR30+0=0)et (VARR32+0=0)) ou ((DEFRIGLOB=0) et (RIDEFRI=0)))) 350 | alors erreur IM42 ; 351 | 352 | verif 4382: 353 | application : iliad ; 354 | si 355 | (FLAGDERNIE+0 = 1) et ((DEFRI = 1) et (PREM8_11=0) et (VARR10+0=0) et (ANO1731=0)) 356 | alors erreur IM42 ; 357 | -------------------------------------------------------------------------------- /src/horizoc.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | verif corrective horizontale 760 : 22 | application : iliad ; 23 | si ( 24 | V_IND_TRAIT > 0 25 | et 26 | SENS_RAPPEL non dans (1, 2, 3, 4) 27 | ) 28 | alors erreur A760; 29 | verif corrective horizontale 770 : 30 | application : iliad ; 31 | si ( 32 | V_IND_TRAIT > 0 33 | et 34 | SENS_RAPPEL = 4 35 | et 36 | PEN_RAPPEL non dans (07, 08, 09, 10, 11, 12, 17, 18, 31) 37 | ) 38 | alors erreur A770; 39 | verif corrective horizontale 780 : 40 | application : iliad ; 41 | si 42 | ( 43 | V_IND_TRAIT > 0 44 | et 45 | ( 46 | ANNEE_RAPPEL <= V_ANREV 47 | ou 48 | MOIS_RAPPEL non dans ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ) 49 | ) 50 | ) 51 | 52 | alors erreur A780; 53 | -------------------------------------------------------------------------------- /src/horizoi.m: -------------------------------------------------------------------------------- 1 | #************************************************************************************************************************* 2 | # 3 | #Copyright or © or Copr.[DGFIP][2015] 4 | # 5 | #Ce logiciel a été initialement développé par la Direction Générale des 6 | #Finances Publiques pour permettre le calcul de l'impôt sur le revenu 2015 7 | #au titre des revenus perçus en 2014. La présente version a permis la 8 | #génération du moteur de calcul des chaînes de taxation des rôles d'impôt 9 | #sur le revenu de ce millésime. 10 | # 11 | #Ce logiciel est régi par la licence CeCILL 2.1 soumise au droit français 12 | #et respectant les principes de diffusion des logiciels libres. Vous pouvez 13 | #utiliser, modifier et/ou redistribuer ce programme sous les conditions de 14 | #la licence CeCILL 2.1 telle que diffusée par le CEA, le CNRS et l'INRIA sur 15 | #le site "http://www.cecill.info". 16 | # 17 | #Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris 18 | #connaissance de la licence CeCILL 2.1 et que vous en avez accepté les termes. 19 | # 20 | #************************************************************************************************************************** 21 | 22 | verif corrective horizontale 19 : 23 | application : iliad ; 24 | si 25 | ( 26 | ( COD_RAPPEL = 1 et MONT_RAPPEL > 19) ou 27 | ( COD_RAPPEL = 2 et MONT_RAPPEL > 19) ou 28 | ( COD_RAPPEL = 3 et MONT_RAPPEL > 19) ou 29 | ( COD_RAPPEL = 4 et MONT_RAPPEL > 19) ou 30 | ( COD_RAPPEL = 5 et MONT_RAPPEL > 19) ou 31 | ( COD_RAPPEL = 6 et MONT_RAPPEL > 19) ou 32 | ( COD_RAPPEL = 7 et MONT_RAPPEL > 19) ou 33 | ( COD_RAPPEL = 8 et MONT_RAPPEL > 19) 34 | ) 35 | alors erreur A019; 36 | verif corrective horizontale 1401 : 37 | application : iliad ; 38 | si 39 | ( 40 | COD_RAPPEL = 1401 et MONT_RAPPEL > 45 41 | ) 42 | alors erreur A14001; 43 | verif corrective horizontale 1411 : 44 | application : iliad ; 45 | si 46 | ( 47 | COD_RAPPEL = 1411 et MONT_RAPPEL > 25 48 | ) 49 | alors erreur A14101; 50 | verif corrective horizontale 20200 : 51 | application : iliad ; 52 | si 53 | ( 54 | COD_RAPPEL = 2020 et MONT_RAPPEL > 9 55 | 56 | ) 57 | alors erreur A00101; 58 | --------------------------------------------------------------------------------