Pour une variable, fonction qui calcule la moyenne pondérée au sein de chaque groupe.
967319
def collapsesum(data_frame, by = None, var = None):
    '''
    
    '''
    assert by is not None
    assert var is not None
    grouped = data_frame.groupby([by])
    return grouped.apply(lambda x: weighted_sum(groupe = x, var =var))
999118
public function afficheSelectSousQuartier($params = array())
    {
        $html="";
        $t=new Template('modules/archi/templates/');
        $t->set_filenames((array('listeSousQuartiers'=>'listeSousQuartiers.tpl')));


        $a = new archiAuthentification();
        $u = new archiUtilisateur();

        $sqlWhereVillesModerees = "";
        if ($a->getIdProfil()==3) { // l'utilisateur est un moderateur , on affiche que les quartiers qu'il peut moderer suivant les villes qu'il peut moderer
            $arrayIdVilles = $u->getArrayVillesModereesPar($a->getIdUtilisateur());

            if (count($arrayIdVilles)>0) {
                $sqlWhereVillesModerees = " AND idQuartier IN (SELECT idQuartier FROM quartier WHERE idVille in (".implode(",", $arrayIdVilles).")) ";
            } else {
                $sqlWhereVillesModerees = " AND idQuartier =0 "; // si le moderateur n'a pas de ville a moderer on affiche aucun quartier (sinon la requete les afficheraient tous)
            }
        }

        $identifiantUnique="";

        if (isset($params['identifiantUnique'])) {
            $identifiantUnique = $params['identifiantUnique'];
        } elseif (isset($this->variablesGet['identifiantUnique'])) {
            $identifiantUnique=$this->variablesGet['identifiantUnique'];
        }

        $t->assign_vars(array('identifiantUnique'=>$identifiantUnique));

        if ((isset($this->variablesGet['archiIdQuartier']) && $this->variablesGet['archiIdQuartier']!='') || (isset($params['idQuartier']) && $params['idQuartier']!='')) {
            $fromQuartier="";
            if (isset($params['idQuartier']) && $params['idQuartier']!='') {
                $whereQuartier = " AND idQuartier='".$params['idQuartier']."' ";
            } elseif (isset($this->variablesGet['archiIdQuartier']) && $this->variablesGet['archiIdQuartier']!='') {
                $whereQuartier = " AND idQuartier='".$this->variablesGet['archiIdQuartier']."' ";
            }

            $resQuartiers=$this->connexionBdd->requete("select idSousQuartier,nom from sousQuartier where 1=1 and nom<>'autre' ".$sqlWhereVillesModerees." ".$whereQuartier." order by nom");
            while ($fetchQuartiers = mysql_fetch_assoc($resQuartiers)) {
            // si un sousQuartier doit etre selectionne par defaut
                $selected="";
                if (isset($params['idSousQuartier']) && $params['idSousQuartier']!='' && $params['idSousQuartier']==$fetchQuartiers['idSousQuartier']) {
                    $selected = " selected ";
                }

                if ($fetchQuartiers['nom']!='autre') {
                    $t->assign_block_vars("sousQuartiers", array(
                                                            'nom'=>$fetchQuartiers['nom'],
                                                            'id'=>$fetchQuartiers['idSousQuartier'],
                                                            'selected'=>$selected
                                                    ));
                }
            }
        } else {
            echo "archiAdresses::afficheSelectQuartier => parametre archiIdVille manquant<br>";
        }

        ob_start();
        $t->pparse('listeSousQuartiers');
        $html=ob_get_contents();
        ob_end_clean();

        return $html;
    }
1017096
public function ceilf($value, $precision = null) {

        $precision        = isset($precision) ? (int)$precision : $this->config->get('price.default_precision');
        $precision_factor = $precision == 0 ? 1 : pow(10, $precision);
        $tmp              = $value * $precision_factor;
        $tmp2             = (string)$tmp;

        // Si la valeur actuelle a déjà la précision désirée.
        if (strpos($tmp2, '.') === false && strpos($tmp2, ',') === false) {
            return ($value);
        }
        if ($tmp2[strlen($tmp2) - 1] == 0) {
            return $value;
        }

        return ceil($tmp) / $precision_factor;
    }
1333220
private function buildOriginReference()
    {
        /* - Code produit (2 positions numériques) : voir annexe 12.2
         * - Numéro de colis (10 positions numériques) : ce numéro doit être unique. Vous le composez à votre
         *   guise suivant la logique qui vous convient (chrono, numéro commande…) Il pourra également vous
         *   servir pour le suivi colis
         * - Constante : 0000
         * - Pays de destination (2 positions alpha.) : idem T100
         *
         * Exemple : T8975:0200000000800000FR */

        return Service::getNumerical($this->service) .
            str_pad($this->number, 10, '0', STR_PAD_LEFT) .
            '0000' .
            $this->get(Config::T100);
    }
641648
def build_homogeneisation_caracteristiques_sociales(temporary_store = None, year = None):
     """

    assert temporary_store is not None
    assert year is not None
    # Load data
    bdf_survey_collection = SurveyCollection.load(
        collection = 'budget_des_familles', config_files_directory = config_files_directory)
    survey = bdf_survey_collection.get_survey('budget_des_familles_{}'.format(year))
    # ******************************************************************************************************************
    # * Etape n° 0-3 : HOMOGENEISATION DES CARACTERISTIQUES SOCIALES DES MENAGES
    # ******************************************************************************************************************
    # ******************************************************************************************************************

    if year == 1995:
        kept_variables = ['exdep', 'exrev', 'mena', 'v', 'ponderrd', 'nbpers', 'nbenf', 'typmen1', 'cohabpr', 'sexepr',
            'agepr', 'agecj', 'matripr', 'occuppr', 'occupcj', 'nbact', 'sitlog', 'stalog', 'mena', 'nm14a', 'typmen1']
        menage = survey.get_values(
            table = "socioscm",
            variables = kept_variables,
            )
        # cette étape permet de ne garder que les données dont on est sûr de la qualité et de la véracité
        # exdep = 1 si les données sont bien remplies pour les dépenses du ménage
        # exrev = 1 si les données sont bien remplies pour les revenus du ménage
        menage = menage[(menage.exdep == 1) & (menage.exrev == 1)]
        menage.rename(
            columns = {
                'v': 'vag',
                'mena': 'ident_men',
                'ponderrd': 'pondmen',
                'nbpers': 'npers',
                'nm14a': 'nenfants',
                'nbenf': 'nenfhors',
                'nbact': 'nactifs',
                'cohabpr': 'couplepr',
                'matripr': 'etamatri',
                'typmen1': 'typmen'
                },
            inplace = True,
            )
        # la variable vag est utilisée dans les modèles QAIDS et AIDS comme variable temporelle afin d'attibuer
        # le bon prix mensuel
        menage.agecj = menage.agecj.fillna(0)
        menage.nenfhors = menage.nenfhors.fillna(0)
        menage.vag = menage.vag.astype('int')

        menage['nadultes'] = menage['npers'] - menage['nenfants']
        menage['ocde10'] = 1 + 0.5 * numpy.maximum(0, menage['nadultes'] - 1) + 0.3 * menage['nenfants']

        # harmonisation des types de ménage sur la nomenclature 2010
        menage['typmen_'] = menage['typmen']
        menage.typmen[menage.typmen_ == 1] = 1
        menage.typmen[menage.typmen_ == 2] = 3
        menage.typmen[menage.typmen_ == 3] = 4
        menage.typmen[menage.typmen_ == 4] = 4
        menage.typmen[menage.typmen_ == 5] = 4
        menage.typmen[menage.typmen_ == 6] = 2
        menage.typmen[menage.typmen_ == 7] = 5
        del menage['typmen_']

        var_to_ints = ['couplepr', 'etamatri']
        for var_to_int in var_to_ints:
            menage[var_to_int] = menage[var_to_int].astype(int)

        #  Methode :
        #  1. on nettoite les variables (i.e. changement de nom de format)
        #  2. Reformatage des variables (réattribution des catégories pour quelles soient identiques
        #     pour les différentes années)

        menage["situacj"] = 0
        menage.situacj[menage.occupcj == 1] = 1
        menage.situacj[menage.occupcj == 3] = 3
        menage.situacj[menage.occupcj == 2] = 4
        menage.situacj[menage.occupcj == 5] = 5
        menage.situacj[menage.occupcj == 6] = 5
        menage.situacj[menage.occupcj == 7] = 6
        menage.situacj[menage.occupcj == 8] = 7
        menage.situacj[menage.occupcj == 4] = 8

        menage["situapr"] = 0
        menage.situapr[menage.occuppr == 1] = 1
        menage.situapr[menage.occuppr == 3] = 3
        menage.situapr[menage.occuppr == 2] = 4
        menage.situapr[menage.occuppr == 5] = 5
        menage.situapr[menage.occuppr == 6] = 5
        menage.situapr[menage.occuppr == 7] = 6
        menage.situapr[menage.occuppr == 8] = 7
        menage.situapr[menage.occuppr == 4] = 8

        menage["typlog"] = 0
        menage.typlog[menage.sitlog == 1] = 1
        menage.typlog[menage.sitlog != 1] = 2

        menage['stalog'] = menage['stalog'].astype(int)

        individus = survey.get_values(
            table = "individu",
            )
        variables = ['mena', 'v']
        individus.rename(
            columns = {'mena': 'identmen'},
            inplace = True,
            )
        menage.set_index('ident_men', inplace = True)

    if year == 2000:
        menage = survey.get_values(
            table = "menage",
            variables = [
                'ident', 'pondmen', 'nbact', 'nbenf1', 'nbpers', 'ocde10', 'sitlog', 'stalog', 'strate',
                'typmen1', 'zeat', 'stalog', 'vag', 'sexepr', 'sexecj', 'agecj', 'napr', 'nacj', 'cs2pr',
                'cs2cj', 'diegpr', 'dieppr', 'diespr', 'diegcj', 'diepcj', 'diescj', 'hod_nb', 'cohabpr',
                'occupapr', 'occupacj', 'occupbpr', 'occupbcj', 'occupcpr', 'occupccj', 'typmen1'
                ]
            )
        menage.rename(
            columns = {
                'cohabpr': 'couplepr',
                'hod_nb': 'nenfhors',
                'ident': 'ident_men',
                'nbact': 'nactifs',
                'nbenf1': 'nenfants',
                'nbpers': 'npers',
                'rev81': 'poste_coicop_421',
                'typmen1': 'typmen'
                },
            inplace = True,
            )
        menage.ocde10 = menage.ocde10 / 10
        # on met un numéro à chaque vague pour pouvoir faire un meilleur suivi des évolutions temporelles
        # pour le modèle de demande
        menage.agecj = menage.agecj.fillna(0)

        assert menage.notnull().all().all(), 'The following variables contains NaN values: {}'.format(
            list(menage.isnull().any()[menage.isnull().any()].index))

        menage['vag_'] = menage['vag']
        menage.vag.loc[menage.vag_ == 1] = 9
        menage.vag.loc[menage.vag_ == 2] = 10
        menage.vag.loc[menage.vag_ == 3] = 11
        menage.vag.loc[menage.vag_ == 4] = 12
        menage.vag.loc[menage.vag_ == 5] = 13
        menage.vag.loc[menage.vag_ == 6] = 14
        menage.vag.loc[menage.vag_ == 7] = 15
        menage.vag.loc[menage.vag_ == 8] = 16
        del menage['vag_']
        # harmonisation des types de ménage sur la nomenclature 2010
        menage['typmen_'] = menage['typmen']
        menage.typmen.loc[menage.typmen_ == 1] = 1
        menage.typmen.loc[menage.typmen_ == 2] = 3
        menage.typmen.loc[menage.typmen_ == 3] = 4
        menage.typmen.loc[menage.typmen_ == 4] = 4
        menage.typmen.loc[menage.typmen_ == 5] = 4
        menage.typmen.loc[menage.typmen_ == 6] = 2
        menage.typmen.loc[menage.typmen_ == 7] = 5
        del menage['typmen_']

        menage.couplepr = menage.couplepr.astype('int')
        menage["nadultes"] = menage['npers'] - menage['nenfants']

        menage.typmen = menage.typmen.astype('int')

        # occupa : 1 si la personne travaille, 2 sinon. occupb : 1 si elle travaille effectivement, 2 si congé de
        # longue durée (négligé ici). occupc : de 2 à 8 selon le statut si ne travaille pas (étudiant, retraité, etc.)
        menage["situacj"] = 0
        menage.situacj.loc[menage.occupacj == 1] = 1
        menage.situacj.loc[menage.occupccj == 3] = 3
        menage.situacj.loc[menage.occupccj == 2] = 4
        menage.situacj.loc[menage.occupccj == 5] = 5
        menage.situacj.loc[menage.occupccj == 6] = 5
        menage.situacj.loc[menage.occupccj == 7] = 6
        menage.situacj.loc[menage.occupccj == 8] = 7
        menage.situacj.loc[menage.occupccj == 4] = 8

        menage["situapr"] = 0
        menage.situapr.loc[menage.occupapr == 1] = 1
        menage.situapr.loc[menage.occupcpr == 3] = 3
        menage.situapr.loc[menage.occupcpr == 2] = 4
        menage.situapr.loc[menage.occupcpr == 5] = 5
        menage.situapr.loc[menage.occupcpr == 6] = 5
        menage.situapr.loc[menage.occupcpr == 7] = 6
        menage.situapr.loc[menage.occupcpr == 8] = 7
        menage.situapr.loc[menage.occupcpr == 4] = 8

        menage["natiocj"] = 0
        menage["natiopr"] = 0
        menage.natiocj.loc[menage.nacj == 1] = 1
        menage.natiocj.loc[menage.nacj == 2] = 1
        menage.natiocj.loc[menage.nacj == 3] = 2
        menage.natiopr.loc[menage.napr == 1] = 1
        menage.natiopr.loc[menage.napr == 2] = 1
        menage.natiopr.loc[menage.napr == 3] = 2

        menage["typlog"] = 0
        menage.typlog.loc[menage.sitlog == 1] = 1
        menage.typlog.loc[menage.sitlog != 1] = 2

        # Homogénéisation des diplômes, choix d'équivalence entre les diplômes
        menage["dip14pr"] = 999999
        menage.dip14pr.loc[menage.diegpr == 0] = 71
        menage.dip14pr.loc[menage.diegpr == 2] = 70
        menage.dip14pr.loc[menage.diegpr == 15] = 60
        menage.dip14pr.loc[menage.diegpr == 18] = 60
        menage.dip14pr.loc[menage.diegpr == 16] = 41
        menage.dip14pr.loc[menage.diegpr == 17] = 41
        menage.dip14pr.loc[menage.diegpr == 19] = 41

        menage.dip14pr.loc[menage.dieppr == 23] = 50
        menage.dip14pr.loc[menage.dieppr == 25] = 50
        menage.dip14pr.loc[menage.dieppr == 27] = 50
        menage.dip14pr.loc[menage.dieppr == 29] = 50
        menage.dip14pr.loc[menage.dieppr == 34] = 43
        menage.dip14pr.loc[menage.dieppr == 32] = 42
        menage.dip14pr.loc[menage.dieppr == 36] = 42

        menage.dip14pr.loc[menage.diespr == 41] = 30
        menage.dip14pr.loc[menage.diespr == 42] = 31
        menage.dip14pr.loc[menage.diespr == 43] = 31
        menage.dip14pr.loc[menage.diespr == 44] = 33
        menage.dip14pr.loc[menage.diespr == 46] = 20
        menage.dip14pr.loc[menage.diespr == 48] = 12
        menage.dip14pr.loc[menage.diespr == 47] = 10

        menage.set_index('ident_men', inplace = True)

        # Recodage des catégories zeat
        menage.zeat.loc[menage.zeat == 7] = 6
        menage.zeat.loc[menage.zeat == 8] = 7
        menage.zeat.loc[menage.zeat == 9] = 8

        assert menage.zeat.isin(range(1, 9)).all()

        individus = survey.get_values(
            table = "individus",
            variables = ['ident', 'matri', 'lien', 'anais']
            )

        individus = individus.loc[individus.lien == 1].copy()
        individus.rename(
            columns = {'ident': 'ident_men', 'matri': 'etamatri'},
            inplace = True,
            )
        variables_to_destring = ['anais']
        for variable_to_destring in variables_to_destring:
            individus[variable_to_destring] = individus[variable_to_destring].astype('int').copy()
        individus['agepr'] = year - individus.anais
        individus.set_index('ident_men', inplace = True)

        assert menage.notnull().all().all(), 'The following variables contains NaN values: {}'.format(
            list(menage.isnull().any()[menage.isnull().any()].index))

        menage = menage.merge(individus, left_index = True, right_index = True)

    if year == 2005:
        menage = survey.get_values(table = "menage")
        # données socio-démographiques
        socio_demo_variables = ['agpr', 'agcj', 'couplepr', 'decuc', 'ident_men', 'nactifs', 'nenfants', 'nenfhors',
            'npers', 'ocde10', 'pondmen', 'sexecj', 'sexepr', 'typmen5', 'vag', 'zeat', 'cs24pr']
        socio_demo_variables += [column for column in menage.columns if column.startswith('dip14')]
        socio_demo_variables += [column for column in menage.columns if column.startswith('natio7')]
        # activité professionnelle
        activite_prof_variables = ['situacj', 'situapr']
        activite_prof_variables += [column for column in menage.columns if column.startswith('cs42')]
        # logement
        logement_variables = ['htl', 'strate']
        menage = menage[socio_demo_variables + activite_prof_variables + logement_variables]
        menage.rename(
            columns = {
                # "agpr": "agepr",
                "agcj": "agecj",
                "typmen5": "typmen",
                "cs24pr": "cs_pr"
                },
            inplace = True,
            )
        del menage['agpr']
        menage['nadultes'] = menage.npers - menage.nenfants
        for person in ['pr', 'cj']:
            menage['natio' + person] = (menage['natio7' + person] > 2)  # TODO: changer de convention ?
            del menage['natio7' + person]

        menage.agecj = menage.agecj.fillna(0)
        menage.nenfhors = menage.nenfhors.fillna(0)
        var_to_ints = ['ocde10', 'decuc', 'nactifs', 'nenfants', 'npers', 'pondmen', 'nadultes']
        assert menage.notnull().all().all(), 'The following variables contains NaN values: {}'.format(
            list(menage.isnull().any()[menage.isnull().any()].index))

        menage.couplepr = menage.couplepr > 2  # TODO: changer de convention ?
        menage.ocde10 = menage.ocde10 / 10
        menage.set_index('ident_men', inplace = True)
        # on met un numéro à chaque vague pour pouvoir faire un meilleur suivi des évolutions temporelles
        # pour le modèle de demande
        menage['vag_'] = menage['vag']
        menage.vag.loc[menage.vag_ == 1] = 17
        menage.vag.loc[menage.vag_ == 2] = 18
        menage.vag.loc[menage.vag_ == 3] = 19
        menage.vag.loc[menage.vag_ == 4] = 20
        menage.vag.loc[menage.vag_ == 5] = 21
        menage.vag.loc[menage.vag_ == 6] = 22
        del menage['vag_']

        # Recodage des catégories zeat
        menage.zeat.loc[menage.zeat == 7] = 6
        menage.zeat.loc[menage.zeat == 8] = 7
        menage.zeat.loc[menage.zeat == 9] = 8

        assert menage.zeat.isin(range(1, 9)).all()

        stalog = survey.get_values(table = "depmen", variables = ['ident_men', 'stalog'])
        stalog['stalog'] = stalog.stalog.astype('int').copy()
        stalog['new_stalog'] = 0
        stalog.loc[stalog.stalog == 2, 'new_stalog'] = 1
        stalog.loc[stalog.stalog == 1, 'new_stalog'] = 2
        stalog.loc[stalog.stalog == 4, 'new_stalog'] = 3
        stalog.loc[stalog.stalog == 5, 'new_stalog'] = 4
        stalog.loc[stalog.stalog.isin([3, 6]), 'new_stalog'] = 5
        stalog.stalog = stalog.new_stalog.copy()
        del stalog['new_stalog']

        assert stalog.stalog.isin(range(1, 6)).all()
        stalog.set_index('ident_men', inplace = True)
        menage = menage.merge(stalog, left_index = True, right_index = True)
        menage['typlog'] = 2
        menage.loc[menage.htl.isin(['1', '5']), 'typlog'] = 1
        assert menage.typlog.isin([1, 2]).all()
        del menage['htl']

        individus = survey.get_values(table = 'individu')
        # Il y a un problème sur l'année de naissance,
        # donc on le recalcule avec l'année de naissance et la vague d'enquête
        individus['agepr'] = year - individus.anais
        individus.loc[individus.vag == 6, ['agepr']] = year + 1 - individus.anais
        individus = individus[individus.lienpref == 00].copy()
        kept_variables = ['ident_men', 'etamatri', 'agepr']
        individus = individus[kept_variables].copy()
        individus.etamatri.loc[individus.etamatri == 0] = 1
        individus['etamatri'] = individus['etamatri'].astype('int')  # MBJ TODO: define as a catagory ?
        individus.set_index('ident_men', inplace = True)
        menage = menage.merge(individus, left_index = True, right_index = True)

        individus = survey.get_values(
            table = 'individu',
            variables = ['ident_men', 'ident_ind', 'age', 'anais', 'vag', 'lienpref'],
            )
        # Il y a un problème sur l'année de naissance,
        # donc on le recalcule avec l'année de naissance et la vague d'enquête
        individus['age'] = year - individus.anais
        individus.loc[individus.vag == 6, ['age']] = year + 1 - individus.anais
        # Garder toutes les personnes du ménage qui ne sont pas la personne de référence et le conjoint
        individus = individus[(individus.lienpref != 00) & (individus.lienpref != 01)].copy()
        individus.sort_values(by = ['ident_men', 'ident_ind'], inplace = True)

        # Inspired by http://stackoverflow.com/questions/17228215/enumerate-each-row-for-each-group-in-a-dataframe
        def add_col_numero(data_frame):
            data_frame['numero'] = numpy.arange(len(data_frame)) + 3
            return data_frame

        individus = individus.groupby(by = 'ident_men').apply(add_col_numero)
        pivoted = individus.pivot(index = 'ident_men', columns = "numero", values = 'age')
        pivoted.columns = ["age{}".format(column) for column in pivoted.columns]
        menage = menage.merge(pivoted, left_index = True, right_index = True, how = 'outer')

        individus = survey.get_values(
            table = 'individu',
            variables = ['ident_men', 'ident_ind', 'agfinetu', 'lienpref'],
            )
        individus.set_index('ident_men', inplace = True)
        pr = individus.loc[individus.lienpref == 00, 'agfinetu'].copy()
        conjoint = individus.loc[individus.lienpref == 01, 'agfinetu'].copy()
        conjoint.name = 'agfinetu_cj'
        agfinetu_merged = pandas.concat([pr, conjoint], axis = 1)
        menage = menage.merge(agfinetu_merged, left_index = True, right_index = True)
        temporary_store['donnes_socio_demog_{}'.format(year)] = menage

        # label var agepr "Age de la personne de référence au 31/12/${yearrawdata}"
        # label var agecj "Age du conjoint de la PR au 31/12/${yearrawdata}"
        # label var sexepr "Sexe de la personne de référence"
        # label var sexecj "Sexe du conjoint de la PR"
        # label var cs42pr "Catégorie socio-professionnelle de la PR"
        # label var cs42cj "Catégorie socio-professionnelle du conjoint de la PR"
        # label var ocde10 "Nombre d'unités de consommation (échelle OCDE)"
        # label var ident_men "Identifiant du ménage"
        # label var pondmen "Ponderation du ménage"
        # label var npers "Nombre total de personnes dans le ménage"
        # label var nadultes "Nombre d'adultes dans le ménage"
        # label var nenfants "Nombre d'enfants dans le ménage"
        # label var nenfhors "Nombre d'enfants vivant hors domicile"
        # label var nactifs  "Nombre d'actifs dans le ménage"
        # label var couplepr "Vie en couple de la personne de référence"
        # label define typmen5 1 "Personne seule" 2 "Famille monoparentale" 3 "Couple sans enfant"
        #                      4 "Couple avec enfants" 5 "Autre type de ménage (complexe)"
        # label values typmen5 typmen5
        # label var typmen5 "Type de ménage (5 modalités)"
        # label var etamatri "Situation matrimoniale de la personne de référence"
        # label define matripr 1 "Célibataire" 2 "Marié(e)" 3 "Veuf(ve)" 4 "Divorcé(e)"
        # label values etamatri matripr
        # label define occupation 1 "Occupe un emploi" ///
        # 2 "Apprenti" ///
        # 3 "Etudiant, élève, en formation"  ///
        # 4 "Chômeur (inscrit ou non à l'ANPE)" ///
        # 5 "Retraité, préretraité ou retiré des affaires" ///
        # 6 "Au foyer"  ///
        # 7 "Autre situation (handicapé)"  ///
        # 8 "Militaire du contingent"
        # label values situapr occupation
        # label values situacj occupation
        # label var situapr "Situation d'activité de la personne de référence"
        # label var situacj "Situation d'activité du conjoint de la PR"
        # label define diplome 10 "Diplôme de 3ème cycle universitaire, doctorat" ///
        # 12 "Diplôme d'ingénieur, grande école" ///
        # 20 "Diplôme de 2nd cycle universitaire" ///
        # 30 "Diplôme de 1er cycle universitaire" ///
        # 31 "BTS, DUT ou équivalent" ///
        # 33 "Diplôme des professions sociales et de la santé niveau Bac +2" ///
        # 41 "Baccalauréat général, brevet supérieur, capacité en droit" ///
        # 42 "Baccalauréat technologique" ///
        # 43 "Baccalauréat professionnel" ///
        # 44 "Brevet professionnel ou de technicien" ///
        # 50 "CAP, BEP ou diplôme de même niveau" ///
        # 60 "Brevet des collèges, BEPC" ///
        # 70 "Certificat d'études primaires" ///
        # 71 "Aucun diplôme"
        # label values dip14pr diplome
        # label values dip14cj diplome
        # label var dip14pr "Diplôme le plus élevé de la PR"
        # label var dip14cj "Diplôme le plus élevé du conjoint de la PR"
        # label define nationalite 1 "Français, par naissance ou naturalisation" 2 "Etranger"
        # label values natiopr nationalite
        # label values natiocj nationalite
        # label var natiopr "Nationalité de la personne de référence"
        # label var natiocj "Nationalité du conjoint de la PR"
        # label define logement 1 "Maison" 2 "Appartement"
        # label values typlog logement
        # label var typlog "Type de logement"
        # label define statutlogement 1 "Propriétaire ou copropriétaire" ///
        # 2 "Accédant à la propriété (rembourse un prêt)" ///
        # 3 "Locataire" ///
        # 4 "Sous-locataire" ///
        # 5 "Logé gratuitement"
        # label values stalog statutlogement
        # label var stalog "Statut d'occupation du logement"
        # label define viecouple 1 "Vit en couple" 2 "Ne vit pas en couple"
        # label values couplepr viecouple
        #
        # /* Recodage des CSP en 12 et 8 postes à partir de classification de l'INSEE (2003, PCS niveaux 1 et 2) */
        # gen cs24pr=00
        # replace cs24pr=10 if cs42pr=="11"
        # replace cs24pr=10 if cs42pr=="12"
        # replace cs24pr=10 if cs42pr=="13"
        # replace cs24pr=21 if cs42pr=="21"
        # replace cs24pr=22 if cs42pr=="22"
        # replace cs24pr=23 if cs42pr=="23"
        # replace cs24pr=31 if cs42pr=="31"
        # replace cs24pr=32 if cs42pr=="33"
        # replace cs24pr=32 if cs42pr=="34"
        # replace cs24pr=32 if cs42pr=="35"
        # replace cs24pr=36 if cs42pr=="37"
        # replace cs24pr=36 if cs42pr=="38"
        # replace cs24pr=41 if cs42pr=="42"
        # replace cs24pr=41 if cs42pr=="43"
        # replace cs24pr=41 if cs42pr=="44"
        # replace cs24pr=41 if cs42pr=="45"
        # replace cs24pr=46 if cs42pr=="46"
        # replace cs24pr=47 if cs42pr=="47"
        # replace cs24pr=48 if cs42pr=="48"
        # replace cs24pr=51 if cs42pr=="52"
        # replace cs24pr=51 if cs42pr=="53"
        # replace cs24pr=54 if cs42pr=="54"
        # replace cs24pr=55 if cs42pr=="55"
        # replace cs24pr=56 if cs42pr=="56"
        # replace cs24pr=61 if cs42pr=="62"
        # replace cs24pr=61 if cs42pr=="63"
        # replace cs24pr=61 if cs42pr=="64"
        # replace cs24pr=61 if cs42pr=="65"
        # replace cs24pr=66 if cs42pr=="67"
        # replace cs24pr=66 if cs42pr=="68"
        # replace cs24pr=69 if cs42pr=="69"
        # replace cs24pr=71 if cs42pr=="71"
        # replace cs24pr=72 if cs42pr=="72"
        # replace cs24pr=73 if cs42pr=="74"
        # replace cs24pr=73 if cs42pr=="75"
        # replace cs24pr=76 if cs42pr=="77"
        # replace cs24pr=76 if cs42pr=="78"
        # replace cs24pr=81 if cs42pr=="81"
        # replace cs24pr=82 if cs42pr=="83"
        # replace cs24pr=82 if cs42pr=="84"
        # replace cs24pr=82 if cs42pr=="85"
        # replace cs24pr=82 if cs42pr=="86"
        # replace cs24pr=82 if cs42pr=="**"
        # replace cs24pr=82 if cs42pr=="00"
        #

        menage['cs24pr'] = 0
        csp42s_by_csp24 = {
            10: ["11", "12", "13"],
            21: ["21"],
            22: ["22"],
            23: ["23"],
            31: ["31"],
            32: ["32", "33", "34", "35"],
            36: ["37", "38"],
            41: ["42", "43", "44", "45"],
            46: ["46"],
            47: ["47"],
            48: ["48"],
            51: ["52", "53"],
            54: ["54"],
            55: ["55"],
            56: ["56"],
            61: ["62", "63", "64", "65"],
            66: ["67", "68"],
            69: ["69"],
            71: ["71"],
            72: ["72"],
            73: ["74", "75"],
            76: ["77", "78"],
            81: ["81"],
            82: ["83", "84", "85", "86", "**", "00"],
            }
        for csp24, csp42s in csp42s_by_csp24.items():
            menage.loc[menage.cs42pr.isin(csp42s), 'cs24pr'] = csp24
        assert menage.cs24pr.isin(csp42s_by_csp24.keys()).all()

        menage['cs8pr'] = numpy.floor(menage.cs24pr / 10)
        assert menage.cs8pr.isin(range(1, 9)).all()

        variables = [
            'pondmen', 'npers', 'nenfants', 'nenfhors', 'nadultes', 'nactifs', 'ocde10', 'typmen',
            'sexepr', 'agepr', 'etamatri', 'couplepr', 'situapr', 'dip14pr', 'cs42pr', 'cs24pr', 'cs8pr', 'natiopr',
            'sexecj', 'agecj', 'situacj', 'dip14cj', 'cs42cj', 'natiocj', 'typlog', 'stalog'
            ] + ["age{}".format(age) for age in range(3, 14)]

        for variable in variables:
            assert variable in menage.columns, "{} is not a column of menage data frame".format(variable)

    if year == 2011:
        variables = [
            'agecj',
            'agepr',
            'coeffuc',
            'decuc1',
            'ident_me',
            'pondmen',
            'npers',
            'nenfants',
            'nactifs',
            'sexepr',
            'sexecj',
            'dip14cj',
            'dip14pr',
            'typmen5',
            'cataeu',
            'situapr',
            'situacj',
            'zeat',
            ]

        try:
            menage = survey.get_values(table = "MENAGE", variables = variables)
        except:
            menage = survey.get_values(table = "menage", variables = variables)

        menage.rename(
            columns = {
                'ident_me': 'ident_men',
                'coeffuc': 'ocde10',
                'typmen5': 'typmen',
                'decuc1': 'decuc',
                'cataeu': 'strate'
                },
            inplace = True,
            )
        del variables
        menage.agecj = menage.agecj.fillna(0)
        # Ajout de la variable vag
        try:
            depmen = survey.get_values(table = "DEPMEN")
        except:
            depmen = survey.get_values(table = "depmen")
        depmen.rename(columns = {'ident_me': 'ident_men'}, inplace = True)
        vague = depmen[['vag', 'ident_men']].copy()
        stalog = depmen[['stalog', 'ident_men']].copy()
        del depmen

        menage.set_index('ident_men', inplace = True)
        vague.set_index('ident_men', inplace = True)
        menage = menage.merge(vague, left_index = True, right_index = True)
        # On met un numéro à chaque vague pour pouvoir faire un meilleur suivi des évolutions temporelles pour
        # le modèle de demande
        menage['vag_'] = menage['vag'].copy()
        menage.vag.loc[menage.vag_ == 1] = 23
        menage.vag.loc[menage.vag_ == 2] = 24
        menage.vag.loc[menage.vag_ == 3] = 25
        menage.vag.loc[menage.vag_ == 4] = 26
        menage.vag.loc[menage.vag_ == 5] = 27
        menage.vag.loc[menage.vag_ == 6] = 28
        del menage['vag_']

        # Homogénéisation de la variable statut du logement qui prend des valeurs différentes pour 2011
        stalog['stalog'] = stalog.stalog.astype('int').copy()
        stalog['new_stalog'] = 0
        stalog.loc[stalog.stalog == 2, 'new_stalog'] = 1
        stalog.loc[stalog.stalog == 1, 'new_stalog'] = 2
        stalog.loc[stalog.stalog == 4, 'new_stalog'] = 3
        stalog.loc[stalog.stalog == 5, 'new_stalog'] = 4
        stalog.loc[stalog.stalog.isin([3, 6]), 'new_stalog'] = 5
        stalog.stalog = stalog.new_stalog.copy()
        del stalog['new_stalog']
        assert stalog.stalog.isin(range(1, 6)).all()
        stalog.set_index('ident_men', inplace = True)
        menage = menage.merge(stalog, left_index = True, right_index = True)

        # Recodage des catégories zeat
        menage.loc[menage.zeat == 7, 'zeat'] = 6
        menage.zeat.loc[menage.zeat == 8] = 7
        menage.zeat.loc[menage.zeat == 9] = 8
        assert menage.zeat.isin(range(0, 9)).all()
        menage.index.name = 'ident_men'

    #
    assert menage.index.name == 'ident_men'
    menage['role_menage'] = 0
    temporary_store['donnes_socio_demog_{}'.format(year)] = menage
666434
def var(self):
        
        mn = self.mean
        vr = np.mean((self._mcpts - mn) ** 2)
        return vr
208531
public function init()
    {
        if ( $this->lat0 == 0 ) {
            $this->lat0 = 90; //$this->lat0 ca
        }

        /* Place parameters in static storage for common use
          ------------------------------------------------- */
        $this->temp = $this->b / $this->a;
        $this->es = 1.0 - pow( $this->temp, 2 ); // devait etre dans tmerc.js mais n y est pas donc je commente sinon retour de valeurs nulles 
        $this->e = sqrt( $this->es );
        $this->e0 = Common::e0fn( $this->es );
        $this->e1 = Common::e1fn( $this->es );
        $this->e2 = Common::e2fn( $this->es );
        $this->e3 = Common::e3fn( $this->es );
        $this->ml0 = Common::mlfn( $this->e0, $this->e1, $this->e2, $this->e3, $this->lat0 ); //si que des zeros le calcul ne se fait pas
        //if (!$this->ml0) {$this->ml0=0;}
    }
1095291
public void lire()
	{
		
		try
		{
		
		
			String adressedufichier = System.getProperty("user.dir") + "\\monfichier.txt";
			
			FileReader fr = new FileReader(adressedufichier);
			BufferedReader br = new BufferedReader(fr);
			
			String texte = "";
			int a = 0;
				while(a<2) //petite boucle 2 fois
				{
					texte = texte + br.readLine() + "\n";
					a++;		
				}
			br.close();
			
			//readLine pour lire une ligne
			//note: si il n y a rien, la fonction retournera la valeur null
			
			
			System.out.println(texte);
			//on affiche le texte
		
		}
		catch(IOException ioe){System.out.println("erreur : " + ioe);}
		
		
	
	}
1086739
public function token()
    {
        if (session_id() == '') {
            @session_start([
                    'cookie_httponly' => true,
                    'cookie_secure'   => true
            ]);
        }
        /* On génère un token totalement unique. */
        $token                    = uniqid(rand(), true);
        //Et on le stocke
        $_SESSION[ 'token' ]      = $token;
        /* On enregistre aussi le timestamp correspondant au moment de la création du token. */
        $_SESSION[ 'token_time' ] = time();

        $this->input('token', [
            'type' => 'hidden',
            'id'   => 'token',
            'attr' => [ 'value' => $token ]
        ]);

        return $this;
    }
1366427
def _le_from_ge(self, other):
    """"""
    op_result = self.__ge__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result or self == other
1226623
public function afficheStatistiques()
	{
		$t = new Template($this->getCheminPhysique().$this->cheminTemplates);
		$t->set_filenames(array('statsAccueil'=>'statistiquesAccueil.tpl'));

		// recherche du nombre d'evenements
		$reqEvenements = "SELECT DISTINCT idEvenement as nbEvenements FROM evenements;";
		$resEvenements = $this->connexionBdd->requete($reqEvenements);

		// recherche du nombre d'adresses
		$reqAdresses = "SELECT DISTINCT idAdresse as nbAdresses FROM historiqueAdresse;";
		$resAdresses = $this->connexionBdd->requete($reqAdresses);

		// recherche du nombre de photos
		$reqPhotos = "SELECT DISTINCT idImage as nbImages FROM historiqueImage;";
		$resPhotos = $this->connexionBdd->requete($reqPhotos);

		$t->assign_vars(array('architectes'=>$this->getListeArchitectesProductifs(array('sqlLimit'=>"LIMIT 10", "noPagination"=>true))));
		$t->assign_vars(array('rues'=>$this->getListeRuesCompletes(array('sqlLimit'=>"LIMIT 10", "noPagination"=>true))));

		$t->assign_vars(array('voirTousLesArchitectes'=>"<a href='".$this->creerUrl('', 'tousLesArchitectesClasses')."'>"._("Voir tous les architectes classés")."</a>"));

		$t->assign_vars(array('voirToutesLesRues'=>"<a href='".$this->creerUrl('', 'toutesLesRuesCompletesClassees')."'>"._("Voir toutes les rues classées")."</a>"));

		$t->assign_vars(array('nbAdresses'=>mysql_num_rows($resAdresses)));
		$t->assign_vars(array('nbEvenements'=>mysql_num_rows($resEvenements)));
		$t->assign_vars(array('nbPhotos'=>mysql_num_rows($resPhotos)));

		ob_start();
		$t->pparse('statsAccueil');
		$html .= ob_get_contents();
		ob_end_clean();

		return $html;
	}
423612
protected function loginWithCookie() {

        $session_id = $this->getSession()->getId();
        $container  = $this->getContainer();
        $db         = $container->get('db');

        // On récupère l'état associé à la session.
        $isGuest = $db->setQuery("SELECT guest FROM #__session WHERE session_id = " . $db->quote($session_id))->loadResult();

        // On connecte l'utilisateur par cookie, seulement s'il invité.
        if (!isset($isGuest) || $isGuest == "1") {

            $cookieName = $this->getShortHashedUserAgent();

            // On contrôle que le cookie existe.
            if ($this->input->cookie->get($cookieName)) {

                // On effectue une authentification silencieuse.
                $this->login(array('username' => ''), array('useCookie' => true, 'silent' => true));

            }

        }

    }
1182049
def allonge(f):
    
    if not f:
        return ""

    return f

    ## TODO : Implementer correctement la suite

    taille = len(f)
    # Je sais que le morceau à attacher commence par une consonne.
    if f[taille-2] in consonnes and not f[-2:].lower() in ["āe", "āu", "ēu",  "ōe"]:
        f = re.sub("[a\u0103]([" + consonnes + "])$", "\u0101\\1", f)
        f = re.sub("[e\u0115]([" + consonnes + "])$", "\u0113\\1", f)
        f = re.sub("[i\u012d]([" + consonnes + "])$", "\u012b\\1", f)
        f = re.sub("[o\u014F]([" + consonnes + "])$", "\u014d\\1", f)
        f = re.sub("[u\u016d]([" + consonnes + "])$", "\u016b\\1", f)
        f = re.sub("[y\u0233]([" + consonnes + "])$", "\u045e\\1", f)
        f = re.sub("[A\u0102]([" + consonnes + "])$", "\u0100\\1", f)
        f = re.sub("[E\u0114]([" + consonnes + "])$", "\u0112\\1", f)
        f = re.sub("[I\u012c]([" + consonnes + "])$", "\u012a\\1", f)
        f = re.sub("[O\u014e]([" + consonnes + "])$", "\u014c\\1", f)
        f = re.sub("[U\u016c]([" + consonnes + "])$", "\u016a\\1", f)
        f = re.sub("[Y\u0232]([" + consonnes + "])$", "\u040e\\1", f)
        return f
967582
private void lsUpdateGroup(final int isa, final int first, final int last) {
        final int[] SA = this.SA;

        int a, b;
        int t;

        for (a = first; a < last; ++a) {
            if (0 <= SA[a]) {
                b = a;
                do {
                    SA[isa + SA[a]] = a;
                } while (++a < last && 0 <= SA[a]);
                SA[b] = b - a;
                if (last <= a) {
                    break;
                }
            }
            b = a;
            do {
                SA[a] = ~SA[a];
            } while (SA[++a] < 0);
            t = a;
            do {
                SA[isa + SA[b]] = t;
            } while (++b <= a);
        }
    }
533987
def cal_k_vinet(p, k):
    
    v = cal_v_vinet(p, k)
    return cal_k_vinet_from_v(v, k[0], k[1], k[2])
643518
def forward(self, x):
        ''''''
        N,C,H,W = x.size()
        g = self.groups
        return x.view(N,g,C/g,H,W).permute(0,2,1,3,4).contiguous().view(N,C,H,W)
896373
protected function doExecute() {

        $container = $this->getContainer();

        // On affecte le logger si besoin.
        if ($container->has('logger')) {
            $this->setLogger($container->get('logger'));
        }

        // Config
        $container->get('config')->merge($this->config);
        $this->setConfiguration($container->get('config'));

        // On récupère la session.
        $session = $container->get('session');
        $this->setSession($session);

        // On nettoie les veilles sessions
        $this->sessionCleanUp();

        // On démarre la session.
        $session->start();

        // Si c'est une requête pour garder en vie la session, on peut quitter ici.
        if ($this->input->get('stayAlive', false, 'bool') === true) {
            echo "1";
            $this->close();
        }

        // On initialise l'état utilisateur.
        if ($session->isNew() || $session->get('state') === null) {
            $session->set('state', new Registry);
        }

        // On tente d'auto-connecter l'utilisateur.
        $this->loginWithCookie();

        // On personnalise l'environnement suivant l'utilisateur dans la session.
        $user = $session->get('user');
        if ($user) {

            $language = $user->params->get('language');
            $helper   = new LanguageHelper;

            // On s'assure que la langue de l'utilisateur existe.
            if ($language && $helper->exists($language, JPATH_ROOT)) {
                $this->set('language', $language);
            }

            $timezone = $user->params->get('timezone');
            if ($timezone) {
                $this->set('timezone', $timezone);
            }

        }

        // On définit le fuseau horaire.
        @date_default_timezone_set($this->get('timezone', 'Europe/Paris'));

        // On récupère le controller.
        $controller = $this->route();

        // On contrôle si l'utilisateur doit changer son mot de passe.
        $this->checkUserRequireReset($controller);

        // On redirige en HTTPS si besoin.
        /*if ($this->get('force_ssl') && !$this->isSSLConnection() && $controller->isSSLEnabled()) {
            $uri = new Uri($this->get('uri.request'));
            $uri->setScheme('https');
            $this->redirect((string)$uri);
        }*/

        // On sauvegarde le controller actif.
        $this->_activeController = strtolower($controller->getName());

        try {

            $profiler = $this->container->has('profiler') ? $this->container->get('profiler') : false;

            if ($profiler) {
                $profiler->mark('beforeControllerExecute');
            }

            // On exécute la logique du controller et on récupère le résultat.
            $result = $controller->execute();

            if ($profiler) {
                $profiler->mark('afterControllerExecute');
            }

            // On effectue le rendu de la page avec le résultat.
            $this->render($result);

        } catch (\Exception $e) {
            $this->raiseError($e->getMessage(), $e->getCode(), $e);
        }

    }