Python numpy.or_函数代码示例

 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