Python numpy.and_函数代码示例

    def function(self, simulation, period):
        period = period.this_month
        effectif_entreprise = simulation.calculate('effectif_entreprise', period)
        apprenti = simulation.calculate('apprenti', period)
        contrat_de_travail_duree = simulation.calculate('contrat_de_travail_duree', period)
        contrat_de_travail_debut = simulation.calculate('contrat_de_travail_debut', period)
        contrat_de_travail_fin = simulation.calculate('contrat_de_travail_fin', period)
        coefficient_proratisation = simulation.calculate('coefficient_proratisation', period)
        smic_proratise = simulation.calculate('smic_proratise', period)
        salaire_de_base = simulation.calculate('salaire_de_base', period)

        # Cette aide est temporaire.
        # Si toutefois elle est reconduite et modifiée pour 2017, les dates et le montant seront à implémenter comme
        # des params xml.

        # jusqu’à 1,3 fois le Smic
        eligible_salaire = salaire_de_base <= (1.3 * smic_proratise)

        # pour les PME
        eligible_effectif = effectif_entreprise < 250

        # non cumulable avec l'aide pour la première embauche
        # qui est identique, si ce n'est qu'elle couvre tous les salaires
        non_cumulee = effectif_entreprise > 1

        eligible_contrat = and_(
            contrat_de_travail_debut >= datetime64("2016-01-18"),
            contrat_de_travail_debut <= datetime64("2016-12-31")
        )

        # Si CDD, durée du contrat doit être > 1 an
        eligible_duree = or_(
            # durée indéterminée
            contrat_de_travail_duree == 0,
            # durée déterminée supérieure à 1 an
            and_(
                # CDD
                contrat_de_travail_duree == 1,
                # > 6 mois
                (contrat_de_travail_fin - contrat_de_travail_debut).astype('timedelta64[M]') >= timedelta64(6, 'M')
                )
            )

        # Valable 2 ans seulement
        eligible_date = datetime64(period.offset(-24, 'month').start) < contrat_de_travail_debut

        eligible = (
            eligible_salaire * eligible_effectif * non_cumulee * eligible_contrat * eligible_duree *
            eligible_date * not_(apprenti)
            )
        # somme sur 24 mois, à raison de 500 € maximum par trimestre
        montant_max = 4000

        # Si le salarié est embauché à temps partiel,
        # l’aide est proratisée en fonction de sa durée de travail.
        # TODO cette multiplication par le coefficient de proratisation suffit-elle pour le cas du temps partiel ?
        # A tester
        return period, eligible * (montant_max / 24) * coefficient_proratisation

    def formula_2015_06_09(individu, period, parameters):
        effectif_entreprise = individu('effectif_entreprise', period)
        apprenti = individu('apprenti', period)
        contrat_de_travail_duree = individu('contrat_de_travail_duree', period)
        TypesContratDeTravailDuree = contrat_de_travail_duree.possible_values
        contrat_de_travail_debut = individu('contrat_de_travail_debut', period)
        contrat_de_travail_fin = individu('contrat_de_travail_fin', period)
        coefficient_proratisation = individu('coefficient_proratisation', period)
        exoneration_cotisations_employeur_jei = individu('exoneration_cotisations_employeur_jei', period)

        # Cette aide est temporaire.
        # TODO : Si toutefois elle est reconduite et modifiée pour 2017, les dates et le montant seront à
        # implémenter comme des params xml.

        eligible_contrat = and_(
            contrat_de_travail_debut >= datetime64("2015-06-09"),
            contrat_de_travail_debut <= datetime64("2016-12-31")
            )

        # Si CDD, durée du contrat doit être > 1 an
        eligible_duree = or_(
            # durée indéterminée
            contrat_de_travail_duree == TypesContratDeTravailDuree.cdi,
            # durée déterminée supérieure à 1 an
            and_(
                contrat_de_travail_duree == TypesContratDeTravailDuree.cdd,
                # > 6 mois
                (contrat_de_travail_fin - contrat_de_travail_debut).astype('timedelta64[M]') >= timedelta64(6, 'M')
                # Initialement, la condition était d'un contrat >= 12 mois,
                # pour les demandes transmises jusqu'au 26 janvier.
                )
            )

        eligible_date = datetime64(period.offset(-24, 'month').start) < contrat_de_travail_debut
        eligible = \
            (effectif_entreprise == 1) * not_(apprenti) * eligible_contrat * eligible_duree * eligible_date

        # somme sur 24 mois, à raison de 500 € maximum par trimestre
        montant_max = 4000

        # non cumul avec le dispositif Jeune Entreprise Innovante (JEI)
        non_cumulee = not_(exoneration_cotisations_employeur_jei)

        # TODO comment implémenter la condition "premier employé" ? L'effectif est insuffisant en cas de rupture
        # d'un premier contrat
        # Condition : l’entreprise n’a pas conclu de contrat de travail avec un salarié,
        # au-delà de la période d’essai, dans les 12 mois précédant la nouvelle
        # embauche.

        # Si le salarié est embauché à temps partiel,
        # l’aide est proratisée en fonction de sa durée de travail.
        # TODO cette multiplication par le coefficient de proratisation suffit-elle pour le cas du temps partiel ?
        # A tester
        return eligible * (montant_max / 24) * coefficient_proratisation * non_cumulee

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

        # 1 si demandeur d'emploi
        activite = simulation.calculate('activite', period)

        # Indique que l'user a travaillé 5 ans au cours des 10 dernieres années.
        ass_precondition_remplie = simulation.calculate('ass_precondition_remplie', period)

        are_perceived_this_month = simulation.calculate('chomage_net', period)

        return period, and_(and_(activite == 1, ass_precondition_remplie), are_perceived_this_month == 0)

    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 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 _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(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')

        activite = simulation.calculate('activite', period)
        ass_precondition_remplie = simulation.calculate('ass_precondition_remplie', period)

        return period, and_(activite == 1, ass_precondition_remplie)

    def formula(famille, period):
        enceinte_i = famille.members('enceinte', period)
        parent_enceinte = famille.any(enceinte_i, role = Famille.PARENT)

        age_en_mois_i = famille.members('age_en_mois', period)
        age_en_mois_enfant = famille.min(age_en_mois_i, role = Famille.ENFANT)

        enceinte_compat = and_(age_en_mois_enfant < 0, age_en_mois_enfant > -6)
        return parent_enceinte + enceinte_compat

    def formula(individu, period, parameters):
        age_max = parameters(period).prestations.minima_sociaux.ass.age_max
        sous_age_limite = individu('age_en_mois', period) <= age_max

        demandeur_emploi_non_indemnise = and_(individu('activite', period) == TypesActivite.chomeur, individu('chomage_net', period) == 0)

        # Indique que l'individu a travaillé 5 ans au cours des 10 dernieres années.
        ass_precondition_remplie = individu('ass_precondition_remplie', period)

        return demandeur_emploi_non_indemnise * ass_precondition_remplie * sous_age_limite

    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 function(self, simulation, period):
        period = period.this_month
        chomage_net_m_1 = simulation.calculate('chomage_net', period.offset(-1))
        chomage_net_m_2 = simulation.calculate('chomage_net', period.offset(-2))
        revenus_activite_pro = simulation.calculate_add('salaire_imposable', period.n_2)
        taux_abattement = simulation.legislation_at(period.start).prestations.aides_logement.ressources.abattement_chomage_indemnise
        taux_frais_pro = simulation.legislation_at(period.start).impot_revenu.tspr.abatpro.taux

        abattement = and_(chomage_net_m_1 > 0, chomage_net_m_2 > 0) * taux_abattement * revenus_activite_pro
        abattement = round_((1 - taux_frais_pro) * abattement)

        return period, abattement

        def loyer_retenu():
            # loyer mensuel réel, multiplié par 2/3 pour les meublés
            L1 = round((statut_occupation == 5) * loyer * 2 / 3 + (statut_occupation != 5) * loyer, 2)

            # taux à appliquer sur le loyer plafond
            taux_loyer_plafond = (and_(not_(coloc), not_(chambre)) * 1
                                 + chambre * al.loyers_plafond.chambre
                                 + not_(chambre) * coloc * al.loyers_plafond.colocation)

            loyer_plafond_personne_seule = or_(personne_seule * (al_pac == 0), chambre)
            loyer_plafond_famille = not_(loyer_plafond_personne_seule) * (al_pac > 0)
            loyer_plafond_couple = and_(not_(loyer_plafond_famille), not_(loyer_plafond_personne_seule))

            z1 = al.loyers_plafond.zone1
            z2 = al.loyers_plafond.zone2
            z3 = al.loyers_plafond.zone3

            Lz1 = (
                loyer_plafond_personne_seule * z1.L1 +
                loyer_plafond_couple * z1.L2 +
                loyer_plafond_famille * (z1.L3 + (al_pac > 1) * (al_pac - 1) * z1.L4)
                )
            Lz2 = (
                loyer_plafond_personne_seule * z2.L1 +
                loyer_plafond_couple * z2.L2 +
                loyer_plafond_famille * (z2.L3 + (al_pac > 1) * (al_pac - 1) * z2.L4)
                )
            Lz3 = (
                loyer_plafond_personne_seule * z3.L1 +
                loyer_plafond_couple * z3.L2 +
                loyer_plafond_famille * (z3.L3 + (al_pac > 1) * (al_pac - 1) * z3.L4)
                )

            L2 = Lz1 * (zone_apl == 1) + Lz2 * (zone_apl == 2) + Lz3 * (zone_apl == 3)
            L2 = round(L2 * taux_loyer_plafond, 2)

            # loyer retenu
            L = min_(L1, L2)

            return L

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        two_years_ago = period.start.offset('first-of', 'year').period('year').offset(-2)
        chomage_net_m_1 = simulation.calculate('chonet', period.offset(-1))
        chomage_net_m_2 = simulation.calculate('chonet', period.offset(-2))
        revenus_activite_pro = simulation.calculate('salaire_imposable', two_years_ago)
        taux_abattement = simulation.legislation_at(period.start).al.ressources.abattement_chomage_indemnise

        abattement = and_(chomage_net_m_1 > 0, chomage_net_m_2 > 0) * taux_abattement * revenus_activite_pro

        params_abattement_frais_pro = simulation.legislation_at(period.start).ir.tspr.abatpro
        abattement = round((1 - params_abattement_frais_pro.taux) * abattement)

        return period, abattement

def _psa(api, rsa, activite, af_nbenf, al, _P, _option = {"activite" : [CHEF, PART]}):
    '''
    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.
    dummy_api = api > 0
    dummy_rmi = rsa > 0
    dummy_al = and_(al > 0, or_(af_nbenf > 0, or_(activite[CHEF] == 0, activite[PART] == 0)))

    condition = (dummy_api + dummy_rmi + dummy_al > 0)

    P = _P.minim.rmi
    psa = condition * P.psa

    return psa

def _nbI(self, alt, inv, quifoy):
    enfant_a_charge_garde_alternee_invalide = and_(quifoy >= 2, inv, alt)
    return self.sum_by_entity(enfant_a_charge_garde_alternee_invalide.astype(int16))