Python numpy.max_函数代码示例

 def attribution(self, assiette, getT = False):
     '''
     renvoie un vecteur associant les bonnes valeurs de la variable (selon génération)
     '''
     k = self.nb
     n = len(assiette)
     if not self._linear_taux_moy:
         assi = np.tile(assiette, (k, 1)).T
         seui = np.tile(np.hstack((self.seuils, np.inf)), (n, 1))
         a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0)
         i = np.dot(self.taux, a.T)
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i
     else:
         if len(self.tauxM) == 1:
             i = assiette * self.tauxM[0]
         else:
             assi = np.tile(assiette, (k - 1, 1)).T
             seui = np.tile(np.hstack(self.seuils), (n, 1))
             k = self.t_x().T
             a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:])
             A = np.dot(a, self.t_x().T)
             B = np.dot(a, np.array(self.seuils[1:]))
             C = np.dot(a, np.array(self.tauxM[:-1]))
             i = assiette * (A * (assiette - B) + C) + max_(assiette - self.seuils[-1], 0) * self.tauxM[-1] + (assiette >= self.seuils[-1]) * self.seuils[-1] * self.tauxM[-2]
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i

def _aefa(age, smic55, af_nbenf, nb_par, ass ,aer, api, rsa, _P, _option = {'age': ENFS, 'smic55': ENFS}):
    '''
    Aide exceptionelle de fin d'année (prime de Noël)
    '''
    # Insituée en 1998        
    # Apparaît sous le nom de complément de rmi dans les ERF    
    P = _P
    dummy_ass = ass > 0
    dummy_aer = aer > 0
    dummy_api = api > 0
    dummy_rmi = rsa > 0

    # Le montant de l’aide mentionnée à l’article 1er versée aux bénéficiaires de l’allocation de solidarité
    # spécifique à taux majoré servie aux allocataires âgés de cinquante-cinq ans ou plus justifiant de vingt années
    # d’activité salariée, aux allocataires âgés de cinquante-sept ans et demi ou plus justifiant de dix années d’activité
    # salariée ainsi qu’aux allocataires justifiant d’au moins 160 trimestres validés dans les régimes d’assurance
    # vieillesse ou de périodes reconnues équivalentes est égal à        
    maj = 0  # TODO
    
    condition = (dummy_ass+dummy_aer+dummy_api+dummy_rmi > 0)
    
    if hasattr(P.fam.af,"age3"): nbPAC = nb_enf(age, smic55, P.fam.af.age1,P.fam.af.age3)
    else: nbPAC = af_nbenf
    # TODO check nombre de PAC pour une famille
    P = _P.minim
    aefa = condition*P.aefa.mon_seul*(1 + (nb_par==2)*P.aefa.tx_2p
              + nbPAC*P.aefa.tx_supp*(nb_par<=2)
              + nbPAC*P.aefa.tx_3pac*max_(nbPAC-2,0))
    
    if _P.datesim.year==2008: aefa += condition*P.aefa.forf2008
               
    aefa_maj  = P.aefa.mon_seul*maj
    aefa = max_(aefa_maj,aefa)   
    return aefa 

 def calculate(self, base, getT = False):
     '''
     Computes the tax using a a nonlinear tax scale using marginal tax rates
     Note: base is the base of the tax, in column
     '''
     k = self.nb
     n = len(base)
     if not self._linear_avg_rate:
         assi = np.tile(base, (k, 1)).T
         seui = np.tile(np.hstack((self.thresholds, np.inf)), (n, 1))
         a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0)
         i = np.dot(self.rates, a.T)
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i
     else:
         if len(self.rates_average) == 1:
             i = base * self.rates_average[0]
         else:
             assi = np.tile(base, (k - 1, 1)).T
             seui = np.tile(np.hstack(self.thresholds), (n, 1))
             k = self.t_x().T
             a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:])
             A = np.dot(a, self.t_x().T)
             B = np.dot(a, np.array(self.thresholds[1:]))
             C = np.dot(a, np.array(self.rates_average[:-1]))
             i = base * (A * (base - B) + C) + max_(base - self.thresholds[-1], 0) * self.rates_average[-1] + (base >= self.thresholds[-1]) * self.thresholds[-1] * self.rates_average[-2]
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i

    def function(self, simulation, period):
        period = period.this_month
        rev_coll_holder = simulation.compute('rev_coll', period.n_2)
        rev_coll = self.sum_by_entity(rev_coll_holder)
        biact = simulation.calculate('biact', period)
        Pr = simulation.legislation_at(period.start).al.ressources
        br_pf_i_holder = simulation.compute('br_pf_i', period)
        br_pf_parents = self.sum_by_entity(br_pf_i_holder, roles = [CHEF, PART])
        abattement_chomage_indemnise_holder = simulation.compute('aide_logement_abattement_chomage_indemnise', period)
        abattement_chomage_indemnise = self.sum_by_entity(abattement_chomage_indemnise_holder, roles = [CHEF, PART])
        abattement_depart_retraite_holder = simulation.compute('aide_logement_abattement_depart_retraite', period)
        abattement_depart_retraite = self.sum_by_entity(abattement_depart_retraite_holder, roles = [CHEF, PART])
        neutralisation_rsa = simulation.calculate('aide_logement_neutralisation_rsa', period)
        abattement_ressources_enfant = simulation.legislation_at(period.n_2.stop).minim.aspa.plaf_seul * 1.25
        br_enfants = self.sum_by_entity(
            max_(0, br_pf_i_holder.array - abattement_ressources_enfant), roles = ENFS)
        ressources = (
            br_pf_parents + br_enfants + rev_coll -
            (abattement_chomage_indemnise + abattement_depart_retraite + neutralisation_rsa)
        )

        # Abattement forfaitaire pour double activité
        abattement_double_activite = biact * Pr.dar_1

        # Arrondi aux 100 euros supérieurs
        result = max_(ressources - abattement_double_activite, 0)

        return period, result

    def function_2009__(self, simulation, period):
        period = period.this_year
        age_holder = simulation.compute('age', period)
        smic55_holder = simulation.compute('smic55', period, accept_other_period = True)
        af_nbenf = simulation.calculate('af_nbenf', period)
        nb_par = simulation.calculate('nb_par', period)
        ass = simulation.calculate_add('ass', period)
        aer_holder = simulation.compute('aer', period)
        api = simulation.calculate_add('api', period)
        rsa = simulation.calculate_add('rsa', period)
        P = simulation.legislation_at(period.start).minim.aefa
        af = simulation.legislation_at(period.start).fam.af

        age = self.split_by_roles(age_holder, roles = ENFS)
        aer = self.sum_by_entity(aer_holder)
        smic55 = self.split_by_roles(smic55_holder, roles = ENFS)
        dummy_ass = ass > 0
        dummy_aer = aer > 0
        dummy_api = api > 0
        dummy_rmi = rsa > 0
        maj = 0  # TODO
        condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0)
        if hasattr(af, "age3"):
            nbPAC = nb_enf(age, smic55, af.age1, af.age3)
        else:
            nbPAC = af_nbenf
        # TODO check nombre de PAC pour une famille
        aefa = condition * P.mon_seul * (
            1 + (nb_par == 2) * P.tx_2p +
            nbPAC * P.tx_supp * (nb_par <= 2) +
            nbPAC * P.tx_3pac * max_(nbPAC - 2, 0)
            )
        aefa_maj = P.mon_seul * maj
        aefa = max_(aefa_maj, aefa)
        return period, aefa

def _apje(br_pf, age, smic55, isol, biact, _P, _option={'age': ENFS, 'smic55': ENFS}):
    '''
    Allocation pour jeune enfant
    '''
    # TODO: APJE courte voir doc ERF 2006
    P = _P.fam
    nbenf = nb_enf(age, smic55, 0, P.apje.age - 1)
    bmaf = P.af.bmaf
    bmaf_n_2 = P.af.bmaf_n_2
    base = round(P.apje.taux * bmaf, 2)
    base2 = round(P.apje.taux * bmaf_n_2, 2)

    plaf_tx = (nbenf > 0) + P.apje.plaf_tx1 * min_(nbenf, 2) + P.apje.plaf_tx2 * max_(nbenf - 2, 0)
    majo = isol | biact
    plaf = P.apje.plaf * plaf_tx + P.apje.plaf_maj * majo
    plaf2 = plaf + 12 * base2

    apje = (nbenf >= 1) * ((br_pf <= plaf) * base
                            + (br_pf > plaf) * max_(plaf2 - br_pf, 0) / 12.0)

    # Pour bénéficier de cette allocation, il faut que tous les enfants du foyer soient nés, adoptés, ou recueillis en vue d’une adoption avant le 1er janvier 2004, et qu’au moins l’un d’entre eux ait moins de 3 ans.
    # Cette allocation est verséE du 5ème mois de grossesse jusqu’au mois précédant le 3ème anniversaire de l’enfant.

    # Non cumul APE APJE CF
    #  - L’allocation parentale d’éducation (APE), sauf pour les femmes enceintes.
    #    L’APJE est alors versée du 5ème mois de grossesse jusqu’à la naissance de l’enfant.
    #  - Le CF
    return 12*apje  # annualisé

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'month').period('month')
        apl = simulation.calculate('apl', period)
        als = simulation.calculate('als', period)
        alf = simulation.calculate('alf', period)

        return period, max_(max_(apl, als), alf)

    def function(self, simulation, period):
        period = period.this_month
        chomage_brut = simulation.calculate('chomage_brut', period)
        csg_deductible_chomage = simulation.calculate('csg_deductible_chomage', period)
        csg_imposable_chomage = simulation.calculate('csg_imposable_chomage', period)
        taux_csg_remplacement = simulation.calculate('taux_csg_remplacement', period)
        law = simulation.legislation_at(period.start)

        smic_h_b = law.cotsoc.gen.smic_h_b
        # salaire_mensuel_reference = chomage_brut / .7
        # heures_mensuelles = min_(salaire_mensuel_reference / smic_h_b, 35 * 52 / 12)  # TODO: depuis 2001 mais avant ?
        heures_mensuelles = 35 * 52 / 12
        cho_seuil_exo = law.csg.chomage.min_exo * heures_mensuelles * smic_h_b

        montant_crds = montant_csg_crds(
            base_avec_abattement = chomage_brut,
            law_node = law.crds.activite,
            plafond_securite_sociale = law.cotsoc.gen.plafond_securite_sociale,
            ) * (2 <= taux_csg_remplacement)

        crds_chomage = max_(
            -montant_crds - max_(
                cho_seuil_exo - (chomage_brut + csg_imposable_chomage + csg_deductible_chomage + montant_crds), 0
                ), 0
            )
        return period, -crds_chomage

    def function__2008_(self, simulation, period):
        period = period.this_year
        af_nbenf = simulation.calculate('af_nbenf', period)
        nb_parents = simulation.calculate('nb_parents', period)
        ass = simulation.calculate_add('ass', period)
        aer_holder = simulation.compute('aer', period)
        api = simulation.calculate_add('api', period)
        rsa = simulation.calculate('rsa', period)
        P = simulation.legislation_at(period.start).prestations.minima_sociaux.aefa
        af = simulation.legislation_at(period.start).prestations.prestations_familiales.af

        aer = self.sum_by_entity(aer_holder)
        dummy_ass = ass > 0
        dummy_aer = aer > 0
        dummy_api = api > 0
        dummy_rmi = rsa > 0
        maj = 0  # TODO
        condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0)
        if hasattr(af, "age3"):
            nbPAC = nb_enf(simulation.famille, period, af.age1, af.age3)
        else:
            nbPAC = af_nbenf
        # TODO check nombre de PAC pour une famille
        aefa = condition * P.mon_seul * (
            1 + (nb_parents == 2) * P.tx_2p +
            nbPAC * P.tx_supp * (nb_parents <= 2) +
            nbPAC * P.tx_3pac * max_(nbPAC - 2, 0)
            )
        aefa_maj = P.mon_seul * maj
        aefa = max_(aefa_maj, aefa)
        return period, aefa

    def function(self, simulation, period):
        period = period.start.offset('first-of', 'year').period('year')
        frag_impo = simulation.calculate('frag_impo', period)
        nrag_impg = simulation.calculate('nrag_impg', period)
        nbic_impn = simulation.calculate('nbic_impn', period)
        nbic_imps = simulation.calculate('nbic_imps', period)
        nbic_defn = simulation.calculate('nbic_defn', period)
        nbic_defs = simulation.calculate('nbic_defs', period)
        nacc_impn = simulation.calculate('nacc_impn', period)
        nacc_meup = simulation.calculate('nacc_meup', period)
        nacc_defn = simulation.calculate('nacc_defn', period)
        nacc_defs = simulation.calculate('nacc_defs', period)
        nbnc_impo = simulation.calculate('nbnc_impo', period)
        nbnc_defi = simulation.calculate('nbnc_defi', period)
        P = simulation.legislation_at(period.start).ir.rpns

        nbic_timp = (nbic_impn + nbic_imps) - (nbic_defn + nbic_defs)

        # C revenus industriels et commerciaux non professionnels
        # (revenus accesoires du foyers en nomenclature INSEE)
        nacc_timp = max_(0, (nacc_impn + nacc_meup) - (nacc_defn + nacc_defs))

        # régime de la déclaration contrôlée ne bénéficiant pas de l'abattement association agréée
        nbnc_timp = nbnc_impo - nbnc_defi

        # Totaux
        ntimp = nrag_impg + nbic_timp + nacc_timp + nbnc_timp

        return period, max_(0, P.cga_taux2 * (ntimp + frag_impo))

def _cf(age, br_pf, isol, biact, smic55, _P, _option={'age': ENFS, 'smic55': ENFS}):
    """
    Complément familial
    Vous avez au moins 3 enfants à charge tous âgés de plus de 3 ans.
    Vos ressources ne dépassent pas certaines limites.
    Vous avez peut-être droit au Complément Familial à partir du mois
    suivant les 3 ans du 3ème, 4ème, etc. enfant.

    # TODO:
    # En théorie, il faut comparer les revenus de l'année n-2 à la bmaf de
    # l'année n-2 pour déterminer l'éligibilité avec le cf_seuil. Il faudrait
    # pouvoir déflater les revenus de l'année courante pour en tenir compte.
    """
    P = _P.fam
    bmaf = P.af.bmaf
    bmaf2 = P.af.bmaf_n_2
    cf_nbenf = nb_enf(age, smic55, P.cf.age1, P.cf.age2)

    cf_base_n_2 = P.cf.tx * bmaf2
    cf_base = P.cf.tx * bmaf

    cf_plaf_tx = 1 + P.cf.plaf_tx1 * min_(cf_nbenf, 2) + P.cf.plaf_tx2 * max_(cf_nbenf - 2, 0)
    cf_majo = isol | biact
    cf_plaf = P.cf.plaf * cf_plaf_tx + P.cf.plaf_maj * cf_majo
    cf_plaf2 = cf_plaf + 12 * cf_base_n_2

    cf = (cf_nbenf >= 3) * ((br_pf <= cf_plaf) * cf_base +
                             (br_pf > cf_plaf) * max_(cf_plaf2 - br_pf, 0) / 12.0)
    return 12 * cf

 def calc(self, assiette, getT = False):
     '''
     Calcule un impôt selon le barême non linéaire exprimé en tranches de taux marginaux.
     'assiette' est l'assiette de l'impôt, en colonne
     '''
     k = self.nb
     n = len(assiette)
     if not self._linear_taux_moy:
         assi = np.tile(assiette, (k, 1)).T
         seui = np.tile(np.hstack((self.seuils, np.inf)), (n, 1))
         a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0)
         i = np.dot(self.taux, a.T)
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i
     else:
         if len(self.tauxM) == 1:
             i = assiette * self.tauxM[0]
         else:
             assi = np.tile(assiette, (k - 1, 1)).T
             seui = np.tile(np.hstack(self.seuils), (n, 1))
             k = self.t_x().T
             a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:])
             A = np.dot(a, self.t_x().T)
             B = np.dot(a, np.array(self.seuils[1:]))
             C = np.dot(a, np.array(self.tauxM[:-1]))
             i = assiette * (A * (assiette - B) + C) + max_(assiette - self.seuils[-1], 0) * self.tauxM[-1] + (assiette >= self.seuils[-1]) * self.seuils[-1] * self.tauxM[-2]
         if getT:
             t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0))
             return i, t
         else:
             return i

def _prcomp(f7wm, f7wn, f7wo, f7wp, _P):
    """
    Prestations compensatoires
    2002-2010
    """
    P = _P.ir.reductions_impots.prcomp
    div = (f7wo == 0) * 1 + f7wo  # Pour éviter les divisions par zéro

    return (
        (f7wm == 0)
        * (
            (f7wn == f7wo) * P.taux * min_(f7wn, P.seuil)
            + (f7wn < f7wo) * (f7wo <= P.seuil) * P.taux * f7wn
            + max_(0, (f7wn < f7wo) * (f7wo > P.seuil) * P.taux * P.seuil * f7wn / div)
            + P.taux * f7wp
        )
        + (f7wm != 0)
        * (
            (f7wn == f7wm) * (f7wo <= P.seuil) * P.taux * f7wm
            + max_(0, (f7wn == f7wm) * (f7wo >= P.seuil) * P.taux * f7wm / div)
            + (f7wn > f7wm) * (f7wo <= P.seuil) * P.taux * f7wn
            + max_(0, (f7wn > f7wm) * (f7wo >= P.seuil) * P.taux * f7wn / div)
        )
        + P.taux * f7wp
    )

def _ars(self, age_holder, af_nbenf, smic55_holder, br_pf, P = law.fam):
    '''
    Allocation de rentrée scolaire brute de CRDS
    '''
    # TODO: convention sur la mensualisation
    # On tient compte du fait qu'en cas de léger dépassement du plafond, une allocation dégressive
    # (appelée allocation différentielle), calculée en fonction des revenus, peut être versée.
    age = self.split_by_roles(age_holder, roles = ENFS)
    smic55 = self.split_by_roles(smic55_holder, roles = ENFS)

    bmaf = P.af.bmaf
    # On doit prendre l'âge en septembre
    enf_05 = nb_enf(age, smic55, P.ars.agep - 1, P.ars.agep - 1)  # 5 ans et 6 ans avant le 31 décembre
    # enf_05 = 0
    # Un enfant scolarisé qui n'a pas encore atteint l'âge de 6 ans
    # avant le 1er février 2012 peut donner droit à l'ARS à condition qu'il
    # soit inscrit à l'école primaire. Il faudra alors présenter un
    # certificat de scolarité.
    enf_primaire = enf_05 + nb_enf(age, smic55, P.ars.agep, P.ars.agec - 1)
    enf_college = nb_enf(age, smic55, P.ars.agec, P.ars.agel - 1)
    enf_lycee = nb_enf(age, smic55, P.ars.agel, P.ars.ages)

    arsnbenf = enf_primaire + enf_college + enf_lycee

    # Plafond en fonction du nb d'enfants A CHARGE (Cf. article R543)
    ars_plaf_res = P.ars.plaf * (1 + af_nbenf * P.ars.plaf_enf_supp)
    arsbase = bmaf * (P.ars.tx0610 * enf_primaire +
                     P.ars.tx1114 * enf_college +
                     P.ars.tx1518 * enf_lycee)
    # Forme de l'ARS  en fonction des enfants a*n - (rev-plaf)/n
    # ars_diff = (ars_plaf_res + arsbase - br_pf) / arsnbenf
    ars = (arsnbenf > 0) * max_(0, arsbase - max_(0, (br_pf - ars_plaf_res) / max_(1, arsnbenf)))
    # Calcul net de crds : ars_net = (P.ars.enf0610 * enf_primaire + P.ars.enf1114 * enf_college + P.ars.enf1518 * enf_lycee)

    return ars * (ars >= P.ars.seuil_nv)

    def function(self, simulation, period):
        period = period.this_month
        biactivite = simulation.calculate('biactivite', period)
        Pr = simulation.legislation_at(period.start).prestations.aides_logement.ressources
        base_ressources_holder = simulation.compute('prestations_familiales_base_ressources_individu', period)
        base_ressources_parents = self.sum_by_entity(base_ressources_holder, roles = [CHEF, PART])
        abattement_chomage_indemnise_holder = simulation.compute('aide_logement_abattement_chomage_indemnise', period)
        abattement_chomage_indemnise = self.sum_by_entity(abattement_chomage_indemnise_holder, roles = [CHEF, PART])
        abattement_depart_retraite_holder = simulation.compute('aide_logement_abattement_depart_retraite', period)
        abattement_depart_retraite = self.sum_by_entity(abattement_depart_retraite_holder, roles = [CHEF, PART])
        neutralisation_rsa = simulation.calculate('aide_logement_neutralisation_rsa', period)
        abattement_ressources_enfant = simulation.legislation_at(period.n_2.stop).prestations.minima_sociaux.aspa.plafond_ressources_seul * 1.25
        br_enfants = self.sum_by_entity(
            max_(0, base_ressources_holder.array - abattement_ressources_enfant), roles = ENFS)

        # Revenus du foyer fiscal
        rev_coll = simulation.famille.demandeur.foyer_fiscal('rev_coll', period.n_2)

        ressources = (
            base_ressources_parents + br_enfants + rev_coll -
            (abattement_chomage_indemnise + abattement_depart_retraite + neutralisation_rsa)
            )

        # Abattement forfaitaire pour double activité
        abattement_double_activite = biactivite * Pr.dar_1

        # Arrondi aux 100 euros supérieurs
        result = max_(ressources - abattement_double_activite, 0)

        return period, result