Discussion :

[popsmelove]

Bonjour,

j'essaye de trouver un moyen de calculer efficacement les quantiles d'une série de double.

Pour l'instant j'utilise la librairie Statistic qui me permet de calculer les frontières de quantiles, et voici comment je l'utilise pour le moment :

PS : la fonction qui permet de calculer les frontières est Qi (cf code)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 public class GQDQuantil
    {
        DataTable dt_ = new DataTable();
        string axe_;
        List<int> quantil_ = new List<int>();
        List<double> frontier_ = new List<double>();
 
        public DataTable dt { get { return dt_; } }
        public List<int> quantil { get { return quantil_; } }
        public List<double> frontier { get { return frontier_; } }
 
        public GQDQuantil()
        {
        }
 
        public GQDQuantil(DataTable dt, string axe, double step)
        {
            axe_ = axe;
            dt_ = dt.Clone();
            double[] tmp = new double[dt.Rows.Count]; 
            int i=0;
            foreach (DataRow currow in dt.Rows)
            {
                dt_.ImportRow(currow);
                tmp[i] = Convert.ToDouble(currow[axe]);
                i++;
            }
 
            GQDstatistic.statistics Res = new GQDstatistic.statistics(tmp);
 
            for (double k = 0 + 1/step; k < 1; k=  k + 1/step)
                frontier_.Add(Res.Qi(k));
 
            dt_.Columns.Add("quantil");
            foreach (DataRow currow in dt_.Rows)
            {
                int j = 0;
                foreach (double f in frontier_)
                {
                    if (Convert.ToDouble(currow[axe]) < f)
                    {
                        currow["quantil"] = Convert.ToString(j + 1);
                        break;
                    }
                    else 
                    { 
                        j++;
                        currow["quantil"] = Convert.ToString(j + 1);
                    }
                }
            }
        }
 
    }

Comme vous le voyez c'est très lourd, du coup dés que je prend un step à 100 (pour calculer un percentile) avec une grosse datatable c'est la cata !!

alors si vous avez une meilleur solution je suis preneur

Merci

[Guulh]

avec une grosse datatable c'est la cata !!

C'est à dire ? T'as des problèmes de perf ? Je suppose que oui ; si c'est le cas, qu'est ce qui prend du temps : ton code ou la lib que t'utilises ?

Un peu de google m'amène là: je suppose que c'est ça que t'utilises ? Le code a pas l'air formidable, notamment y'a un algo de tri qui est implémenté, alors que c'est dans le framework... Remplace la méthode sort par Array.Sort, et les perfs devraient aller mieux (n log n au lieu de n²)

[popsmelove]

C'est mes deux boucles foreach imbriquées qui prennent du temps mais pour l'instant j'ai ps trouvé d'autres solutions...

Après si une autre librairie calcul directement le quantil alors ce serait peut-être mieux ... ? librairie que je n'ai pas réussi à trouver

[theMonz31]

ca prend du temps parce que tu travailles avec beaucoup de string et donc, ca prend un peu de temps...


Tu peux basculer tes foreach en for(;, mais bon, le gain de temps ne sera pas forcément très conséquent...

A priori, on lisant tes remarques, ce n'est pas le calcul qui prend du temps mais la population de tes datarow qui est long...

[popsmelove]

ca prend du temps parce que tu travailles avec beaucoup de string et donc, ca prend un peu de temps...


Tu peux basculer tes foreach en for(;, mais bon, le gain de temps ne sera pas forcément très conséquent...

A priori, on lisant tes remarques, ce n'est pas le calcul qui prend du temps mais la population de tes datarow qui est long...

MERCI ! c'était exactement ça, c'est bcp plus rapide maintenant que je ne boucle plus sur la datable mais sur un array de double.

C'est résolu !

[popsmelove]

La pour le coût ça me dépasse, je ne sais pas faire de la dichotomie dans un code