def function(self, simulation, period):
     residence_guadeloupe = simulation.calculate('residence_guadeloupe', period)
     residence_martinique = simulation.calculate('residence_martinique', period)
     residence_guyane = simulation.calculate('residence_guyane', period)
     residence_reunion = simulation.calculate('residence_reunion', period)
     residence_mayotte = simulation.calculate('residence_mayotte', period)
     return period, or_(or_(residence_guadeloupe, residence_martinique), or_(or_(residence_reunion, residence_guyane), residence_mayotte))

def _enceinte_fam(self, agem_holder, enceinte_holder):
    agem_enf = self.split_by_roles(agem_holder, roles = ENFS)
    enceinte = self.split_by_roles(enceinte_holder, roles = [CHEF, PART])

    benjamin = age_en_mois_benjamin(agem_enf)
    enceinte_compat = and_(benjamin < 0, benjamin > -6)
    return or_(or_(enceinte_compat, enceinte[CHEF]), enceinte[PART])

    def function_2009(self, simulation, period):
        """
        Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009)
        Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié
        en janvier, février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour
        les ex-bénéficiaires du Rmi ou de l’Api), de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api
        ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et
        d’être âgé de plus de 25 ans ou d’avoir au moins un enfant à charge).
        La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire.
        """
        period = period.start.offset("first-of", "month").period("month")
        api = simulation.calculate("api", period)
        rsa = simulation.calculate("rsa", period)
        activite_holder = simulation.compute("activite", period)
        af_nbenf = simulation.calculate("af_nbenf", period)

        aide_logement = simulation.calculate("aide_logement", period)
        P = simulation.legislation_at(period.start).minim.rmi

        activite = self.split_by_roles(activite_holder, roles=[CHEF, PART])
        dummy_api = api > 0
        dummy_rmi = rsa > 0
        dummy_al = and_(aide_logement > 0, or_(af_nbenf > 0, or_(activite[CHEF] == 0, activite[PART] == 0)))
        condition = dummy_api + dummy_rmi + dummy_al > 0
        psa = condition * P.psa
        return period, psa

    def function(self, simulation, period):
        period = period
        age_en_mois_holder = simulation.compute('age_en_mois', period)
        enceinte_holder = simulation.compute('enceinte', period)

        age_en_mois_enf = self.split_by_roles(age_en_mois_holder, roles = ENFS)
        enceinte = self.split_by_roles(enceinte_holder, roles = [CHEF, PART])

        benjamin = age_en_mois_benjamin(age_en_mois_enf)
        enceinte_compat = and_(benjamin < 0, benjamin > -6)
        return period, or_(or_(enceinte_compat, enceinte[CHEF]), enceinte[PART])

 def abbattement_chomage():
     indemnites_chomage_partiel = simulation.calculate('indemnites_chomage_partiel', previous_year)
     salaire_net = simulation.calculate_add('salaire_net', previous_year)
     chomage_last_month = simulation.calculate('chomage_net', last_month)
     condition = or_(chomage_last_month > 0, revenus_stage_formation_pro_last_month > 0)
     assiette = indemnites_chomage_partiel + salaire_net
     return condition * assiette * P.abattement_chomage

def _quaenv_2010_2011(marpac, nb_pac2, f7we, f7wf, f7wg, f7wh, f7wk, f7wq, f7sb, f7sd, f7se, f7sh, rfr, _P):
    '''
    Crédits d’impôt pour dépenses en faveur de la qualité environnementale
    (cases 7WF, 7WH, 7WK, 7WQ, 7SB, 7SD, 7SE et 7SH)
    2010-2011
    '''
    P = _P.ir.credits_impot.quaenv
    max0 = P.max * (1 + marpac) + P.pac1 * nb_pac2

    max1 = max_(0, max0 - f7wf)
    max2 = max_(0, max1 - f7se)
    max3 = max_(0, max2 - f7wk)
    max4 = max_(0, max3 - f7sd)
    max5 = max_(0, max4 - f7wh)
    max6 = max_(0, max5 - f7sb)
    max7 = max_(0, max6 - f7wq)
    return not_(f7wg) * or_(not_(f7we), (rfr < 45000)) * (
                P.taux_wf * min_(f7wf, max0) +
                P.taux_se * min_(f7se, max1) +
                P.taux_wk * min_(f7wk, max2) +
                P.taux_sd * min_(f7sd, max3) +
                P.taux_wh * min_(f7wh, max4) +
                P.taux_sb * min_(f7sb, max5) +
                P.taux_wq * min_(f7wq, max6) +
                P.taux_sh * min_(f7sh, max7))

    def function(self, simulation, period):
        period = period.this_month

        af_enfant_a_charge = simulation.calculate('af_enfant_a_charge', period)
        age = simulation.calculate('age', period)
        garde_alternee = simulation.calculate('garde_alternee', period)
        age_aine_holder = simulation.compute('af_age_aine', period)
        age_aine = self.cast_from_entity_to_roles(age_aine_holder, roles = ENFS)
        af_nbenf_holder = simulation.compute('af_nbenf', period)
        af_nbenf = self.cast_from_entity_to_roles(af_nbenf_holder, roles = ENFS)
        af_base_holder = simulation.compute('af_base', period)
        af_base = self.cast_from_entity_to_roles(af_base_holder, roles = ENFS)

        pfam = simulation.legislation_at(period.start).fam

        montant_enfant_seul = pfam.af.bmaf * (
            (pfam.af.maj_age_un_enfant.age1 <= age) * (age < pfam.af.maj_age_un_enfant.age2) * pfam.af.maj_age_un_enfant.taux1 +
            (pfam.af.maj_age_un_enfant.age2 <= age) * pfam.af.maj_age_un_enfant.taux2
            )

        montant_plusieurs_enfants = pfam.af.bmaf * (
            (pfam.af.maj_age_deux_enfants.age1 <= age) * (age < pfam.af.maj_age_deux_enfants.age2) * pfam.af.maj_age_deux_enfants.taux1 +
            (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2
            )

        montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants

        # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...)
        pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine))

        coeff_garde_alternee = where(garde_alternee, pfam.af.facteur_garde_alternee, 1)

        return period, af_enfant_a_charge * (af_base > 0) * pas_aine * montant * coeff_garde_alternee

    def function(self, simulation, period):
        period = period.this_month
        ressortissant_eee = simulation.calculate("ressortissant_eee", period)
        duree_possession_titre_sejour = simulation.calculate("duree_possession_titre_sejour", period)
        duree_min_titre_sejour = simulation.legislation_at(period.start).minim.rmi.duree_min_titre_sejour

        return period, or_(ressortissant_eee, duree_possession_titre_sejour >= duree_min_titre_sejour)

    def formula(famille, period):
        cmu_c_plafond = famille('cmu_c_plafond', period)
        cmu_base_ressources = famille('cmu_base_ressources', period)
        residence_mayotte = famille.demandeur.menage('residence_mayotte', period)
        cmu_acs_eligibilite = famille('cmu_acs_eligibilite', period)

        if period.start.date >= date(2016, 1, 1):
            eligibilite_rsa = famille('rsa', period) > 0
        else:
            # Avant 2016, seules les bénéficiaires du RSA socle avait le droit d'office à la CMU.
            rsa_socle = famille('rsa_socle', period)
            rsa_socle_majore = famille('rsa_socle_majore', period)
            rsa_forfait_logement = famille('rsa_forfait_logement', period)
            rsa_base_ressources = famille('rsa_base_ressources', period)
            socle = max_(rsa_socle, rsa_socle_majore)
            rsa = famille('rsa', period)
            eligibilite_rsa = (rsa > 0) * (rsa_base_ressources < socle - rsa_forfait_logement)

        eligibilite_basique = cmu_base_ressources <= cmu_c_plafond

        return (
            cmu_acs_eligibilite
            * not_(residence_mayotte)
            * or_(eligibilite_basique, eligibilite_rsa)
            )

    def function(self, simulation, period):
        period = period.this_month

        eligibilite_base = simulation.calculate('cf_eligibilite_base', period)
        eligibilite_dom = simulation.calculate('cf_eligibilite_dom', period)
        ressources = simulation.calculate('cf_ressources', period)
        plafond = simulation.calculate('cf_plafond', period)

        pfam = simulation.legislation_at(period.start).fam

        eligibilite_sous_condition = or_(eligibilite_base, eligibilite_dom)

        # Montant
        montant = pfam.af.bmaf * (pfam.cf.tx * eligibilite_base + pfam.cf.tx_dom * eligibilite_dom)

        # Complément familial
        eligibilite = eligibilite_sous_condition * (ressources <= plafond)

        # Complément familial différentiel
        plafond_diff = plafond + 12 * montant
        eligibilite_diff = not_(eligibilite) * eligibilite_sous_condition * (
            ressources <= plafond_diff)
        montant_diff = (plafond_diff - ressources) / 12

        return period, max_(eligibilite * montant, eligibilite_diff * montant_diff)

    def function(individu, period, legislation):
        period = period.this_month

        pfam_enfant_a_charge = individu('prestations_familiales_enfant_a_charge', period)
        age = individu('age', period)
        garde_alternee = individu('garde_alternee', period)

        af_nbenf = individu.famille('af_nbenf', period)
        af_base = individu.famille('af_base', period)
        age_aine = individu.famille('af_age_aine', period)

        pfam = legislation(period).prestations.prestations_familiales

        montant_enfant_seul = pfam.af.bmaf * (
            (pfam.af.af_dom.age_1er_enf_tranche_1_dom <= age) * (age < pfam.af.af_dom.age_1er_enf_tranche_2_dom) * pfam.af.af_dom.taux_1er_enf_tranche_1_dom +
            (pfam.af.af_dom.age_1er_enf_tranche_2_dom <= age) * pfam.af.af_dom.taux_1er_enf_tranche_2_dom
            )

        montant_plusieurs_enfants = pfam.af.bmaf * (
            (pfam.af.maj_age_deux_enfants.age1 <= age) * (age < pfam.af.maj_age_deux_enfants.age2) * pfam.af.maj_age_deux_enfants.taux1 +
            (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2
            )

        montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants

        # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...)
        pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine))

        coeff_garde_alternee = where(garde_alternee, pfam.af.facteur_garde_alternee, 1)

        return period, pfam_enfant_a_charge * (af_base > 0) * pas_aine * montant * coeff_garde_alternee

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        rfr = simulation.calculate('rfr', period.start.offset('first-of', 'year').period('year').offset(-2))
        age_holder = simulation.compute('age', period)
        scolarite_holder = simulation.compute('scolarite', period)
        P = simulation.legislation_at(period.start).bourses_education.bourse_college

        ages = self.split_by_roles(age_holder, roles = ENFS)
        nb_enfants = zeros(len(rfr))
        for age in ages.itervalues():
            nb_enfants += age >= 0

        plafond_taux_1 = P.plafond_taux_1 + P.plafond_taux_1 * nb_enfants * P.coeff_enfant_supplementaire
        plafond_taux_2 = P.plafond_taux_2 + P.plafond_taux_2 * nb_enfants * P.coeff_enfant_supplementaire
        plafond_taux_3 = P.plafond_taux_3 + P.plafond_taux_3 * nb_enfants * P.coeff_enfant_supplementaire

        eligible_taux_3 = rfr < plafond_taux_3
        eligible_taux_2 = not_(eligible_taux_3) * (rfr < plafond_taux_2)
        eligible_taux_1 = not_(or_(eligible_taux_2, eligible_taux_3)) * (rfr < plafond_taux_1)

        scolarites = self.split_by_roles(scolarite_holder, roles = ENFS)
        nb_enfants_college = zeros(len(rfr))
        for scolarite in scolarites.itervalues():
            nb_enfants_college += scolarite == SCOLARITE_COLLEGE

        montant = nb_enfants_college * (
            eligible_taux_3 * P.montant_taux_3 +
            eligible_taux_2 * P.montant_taux_2 +
            eligible_taux_1 * P.montant_taux_1
            )

        return period, montant / 12

    def formula(famille, period, parameters):
        eligibilite_base = famille('cf_eligibilite_base', period)
        eligibilite_dom = famille('cf_eligibilite_dom', period)
        ressources = famille('cf_base_ressources', period)
        plafond = famille('cf_plafond', period)

        pfam = parameters(period).prestations.prestations_familiales

        eligibilite_sous_condition = or_(eligibilite_base, eligibilite_dom)

        # Montant
        montant = (
            pfam.af.bmaf * (
                pfam.cf.taux_cf_base * eligibilite_base
                + pfam.cf.taux_base_dom * eligibilite_dom
                )
            )

        # Complément familial
        eligibilite = eligibilite_sous_condition * (ressources <= plafond)

        # Complément familial différentiel
        plafond_diff = plafond + 12 * montant

        eligibilite_diff = (
            not_(eligibilite)
            * eligibilite_sous_condition
            * (ressources <= plafond_diff)
            )

        montant_diff = (plafond_diff - ressources) / 12

        return max_(eligibilite * montant, eligibilite_diff * montant_diff)

    def function(self, simulation, period):
        # Note : Cette variable est calculée pour un an, mais si elle est demandée pour une période plus petite, elle
        # répond pour la période demandée.
        this_month = period.this_month
        this_rolling_year = this_month.start.period('year')
        if period.stop > this_rolling_year.stop:
            period = this_rolling_year
        else:
            period = this_month

        cmu_c_plafond = simulation.calculate('cmu_c_plafond', this_month)
        cmu_base_ressources = simulation.calculate('cmu_base_ressources', this_month)
        residence_mayotte = simulation.calculate('residence_mayotte', this_month)

        rsa_socle = simulation.calculate('rsa_socle', this_month)
        rsa_socle_majore = simulation.calculate('rsa_socle_majore', this_month)
        rsa_forfait_logement = simulation.calculate('rsa_forfait_logement', this_month)
        rsa_base_ressources = simulation.calculate('rsa_base_ressources', this_month)
        socle = max_(rsa_socle, rsa_socle_majore)
        rsa = simulation.calculate('rsa', this_month)

        eligibilite_basique = cmu_base_ressources <= cmu_c_plafond
        eligibilite_rsa = (rsa > 0) * (rsa_base_ressources < socle - rsa_forfait_logement)

        return period, not_(residence_mayotte) * or_(eligibilite_basique, eligibilite_rsa)

    def function(self, simulation, period):
        period = period.start.offset("first-of", "month").period("month")

        af_enfant_a_charge = simulation.calculate("af_enfant_a_charge", period)
        age = simulation.calculate("age", period)
        age_aine_holder = simulation.compute("af_age_aine", period)
        age_aine = self.cast_from_entity_to_roles(age_aine_holder, roles=ENFS)
        af_nbenf_holder = simulation.compute("af_nbenf", period)
        af_nbenf = self.cast_from_entity_to_roles(af_nbenf_holder, roles=ENFS)
        af_base_holder = simulation.compute("af_base", period)
        af_base = self.cast_from_entity_to_roles(af_base_holder, roles=ENFS)

        pfam = simulation.legislation_at(period.start).fam

        montant_enfant_seul = pfam.af.bmaf * (
            (pfam.af.maj_age_un_enfant.age1 <= age)
            * (age < pfam.af.maj_age_un_enfant.age2)
            * pfam.af.maj_age_un_enfant.taux1
            + (pfam.af.maj_age_un_enfant.age2 <= age) * pfam.af.maj_age_un_enfant.taux2
        )

        montant_plusieurs_enfants = pfam.af.bmaf * (
            (pfam.af.maj_age_deux_enfants.age1 <= age)
            * (age < pfam.af.maj_age_deux_enfants.age2)
            * pfam.af.maj_age_deux_enfants.taux1
            + (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2
        )

        montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants

        # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...)
        pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine))

        return period, af_enfant_a_charge * (af_base > 0) * pas_aine * montant

    def function(self, simulation, period):
        period = period.start.period(u'month').offset('first-of')
        depcom_entreprise = simulation.calculate('depcom_entreprise', period)
        effectif_entreprise = simulation.calculate('effectif_entreprise', period)
        categorie_salarie = simulation.calculate('categorie_salarie', period)

        seuil_effectif = simulation.legislation_at(period.start).cotsoc.versement_transport.seuil_effectif

        preload_taux_versement_transport()
        public = (categorie_salarie >= 2)
        default_value = 0.0
        taux_aot = fromiter(
            (
                taux_aot_by_depcom.get(depcom_cell, default_value)
                for depcom_cell in depcom_entreprise
                ),
            dtype = 'float',
            )
        taux_smt = fromiter(
            (
                taux_smt_by_depcom.get(depcom_cell, default_value)
                for depcom_cell in depcom_entreprise
                ),
            dtype = 'float',
            )
        # "L'entreprise emploie-t-elle plus de 9 salariés  dans le périmètre de l'Autorité organisatrice de transport
        # (AOT) suivante ou syndicat mixte de transport (SMT)"
        return period, (taux_aot + taux_smt) * or_(effectif_entreprise >= seuil_effectif, public) / 100

    def function(self, simulation, period):
        period = period.start.offset("first-of", "month").period("month")

        forf_logement = simulation.legislation_at(period.start).minim.rmi.forfait_logement
        rmi = simulation.legislation_at(period.start).minim.rmi.rmi

        rmi_nbp = simulation.calculate("rmi_nbp", period)
        statut_occupation_holder = simulation.compute("statut_occupation", period)
        aide_logement = simulation.calculate("aide_logement", period)

        statut_occupation = self.cast_from_entity_to_roles(statut_occupation_holder)
        statut_occupation = self.filter_role(statut_occupation, role=CHEF)

        avantage_nature = or_(statut_occupation == 2, statut_occupation == 6)
        avantage_al = aide_logement > 0

        montant_forfait = rmi * (
            (rmi_nbp == 1) * forf_logement.taux1
            + (rmi_nbp == 2) * forf_logement.taux2
            + (rmi_nbp >= 3) * forf_logement.taux3
        )

        montant_al = avantage_al * min_(aide_logement, montant_forfait)
        montant_nature = avantage_nature * montant_forfait

        return period, max_(montant_al, montant_nature)

    def formula(individu, period, parameters):
        depcom_entreprise = individu('depcom_entreprise', period)
        effectif_entreprise = individu('effectif_entreprise', period)
        categorie_salarie = individu('categorie_salarie', period)

        seuil_effectif = parameters(period).cotsoc.versement_transport.seuil_effectif

        preload_taux_versement_transport()
        public = (
            (categorie_salarie == TypesCategorieSalarie.public_titulaire_etat)
            + (categorie_salarie == TypesCategorieSalarie.public_titulaire_militaire)
            + (categorie_salarie == TypesCategorieSalarie.public_titulaire_territoriale)
            + (categorie_salarie == TypesCategorieSalarie.public_titulaire_hospitaliere)
            + (categorie_salarie == TypesCategorieSalarie.public_non_titulaire)
            + (categorie_salarie == TypesCategorieSalarie.non_pertinent)
            )
        taux_versement_transport = fromiter(
            (
                get_taux_versement_transport(code_commune, period)
                for code_commune in depcom_entreprise
                ),
            dtype = 'float',
            )
        # "L'entreprise emploie-t-elle plus de 9 ou 10 salariés dans le périmètre de l'Autorité organisatrice de transport
        # (AOT) suivante ou syndicat mixte de transport (SMT)"
        return taux_versement_transport * or_(effectif_entreprise >= seuil_effectif, public) / 100

    def formula_2009_04(famille, period, parameters):
        '''
        Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009)
        Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié
        en janvier, février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour
        les ex-bénéficiaires du Rmi ou de l’Api), de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api
        ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et
        d’être âgé de plus de 25 ans ou d’avoir au moins un enfant à charge).
        La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire.
        '''
        P = parameters(period).prestations.minima_sociaux.rmi
        api = famille('api', period)
        rsa = famille('rsa', period)
        af_nbenf = famille('af_nbenf', period)
        aide_logement = famille('aide_logement', period)

        personne_en_activite_i = (famille.members('activite', period) == TypesActivite.actif)
        parent_en_activite = famille.any(personne_en_activite_i, role = Famille.PARENT)

        dummy_api = api > 0
        dummy_rmi = rsa > 0
        dummy_al = and_(aide_logement > 0, or_(af_nbenf > 0, parent_en_activite))
        condition = (dummy_api + dummy_rmi + dummy_al > 0)
        psa = condition * P.psa
        return psa

    def formula(famille, period, parameters):
        eligibilite_base = famille('af_eligibilite_base', period)
        eligibilite_dom = famille('af_eligibilite_dom', period)
        af_nbenf = famille('af_nbenf', period)

        pfam = parameters(period).prestations.prestations_familiales.af

        eligibilite = or_(eligibilite_base, eligibilite_dom)

        un_seul_enfant = (
            eligibilite_dom
            * (af_nbenf == 1)
            * pfam.af_dom.taux_enfant_seul
            )

        deux_enfants = (af_nbenf >= 2) * pfam.taux.enf2
        plus_de_trois_enfants = max_(af_nbenf - 2, 0) * pfam.taux.enf3
        taux_total = un_seul_enfant + deux_enfants + plus_de_trois_enfants
        montant_base = eligibilite * round_(pfam.bmaf * taux_total, 2)
        coeff_garde_alternee = famille('af_coeff_garde_alternee', period)
        montant_base = montant_base * coeff_garde_alternee

        af_taux_modulation = famille('af_taux_modulation', period)
        montant_base_module = montant_base * af_taux_modulation

        return montant_base_module