Histogramme utilisant gnuplot?

Je sais comment créer un histogramme (utilisez simplement "avec des boîtes") dans gnuplot si mon fichier .dat contient déjà des données correctement regroupées. Existe-t-il un moyen de prendre une liste de nombres et de demander à gnuplot de fournir un histogramme basé sur les plages et les tailles de bacs fournies par l'utilisateur?

oui, et c'est rapide et simple mais très caché:

binwidth=5
bin(x,width)=width*floor(x/width)

plot 'datafile' using (bin($1,binwidth)):(1.0) smooth freq with boxes

vérifiez help smooth freqpourquoi ce qui précède fait un histogramme

pour gérer les plages, il suffit de définir la variable xrange.

J'ai quelques corrections / ajouts à la réponse très utile de Born2Smile:

1. Des bacs vides ont provoqué une extension incorrecte de la boîte du bac adjacent dans son espace; éviter cela en utilisantset boxwidth binwidth
2. Dans la version de Born2Smile, les bacs sont rendus comme centrés sur leur limite inférieure. Strictement, ils devraient s'étendre de la limite inférieure à la limite supérieure. Cela peut être corrigé en modifiant la binfonction:bin(x,width)=width*floor(x/width) + width/2.0

Soyez très prudent: toutes les réponses sur cette page prennent implicitement la décision de commencer le binning - le bord gauche du bac le plus à gauche, si vous le souhaitez - hors des mains de l'utilisateur. Si l'utilisateur combine l'une de ces fonctions pour le binning des données avec sa propre décision sur le début du binning (comme cela se fait sur le blog lié ci-dessus), les fonctions ci-dessus sont toutes incorrectes. Avec un point de départ arbitraire pour le binning 'Min', la fonction correcte est:

bin(x) = width*(floor((x-Min)/width)+0.5) + Min

Vous pouvez voir pourquoi cela est correct séquentiellement (cela aide à dessiner quelques bacs et un point quelque part dans l'un d'eux). Soustrayez Min de votre point de données pour voir dans quelle mesure il se trouve dans la plage de regroupement. Ensuite, divisez par la largeur de bin afin que vous travailliez efficacement en unités de «bacs». Ensuite, `` plancher '' le résultat pour aller au bord gauche de ce bac, ajoutez 0,5 pour aller au milieu du bac, multipliez par la largeur de sorte que vous ne travaillez plus en unités de bacs mais à une échelle absolue encore une fois, puis ajoutez à nouveau le décalage Min que vous avez soustrait au début.

Considérez cette fonction en action:

Min = 0.25 # where binning starts
Max = 2.25 # where binning ends
n = 2 # the number of bins
width = (Max-Min)/n # binwidth; evaluates to 1.0
bin(x) = width*(floor((x-Min)/width)+0.5) + Min

Par exemple, la valeur 1.1 tombe vraiment dans le bac de gauche:

• cette fonction la mappe correctement au centre du bac gauche (0,75);
• La réponse de Born2Smile, bin (x) = width * floor (x / width), la mappe incorrectement à 1;
• La réponse de mas90, bin (x) = width * floor (x / width) + binwidth / 2.0, la mappe incorrectement à 1.5.

La réponse de Born2Smile n'est correcte que si les limites de bin se produisent à (n + 0,5) * binwidth (où n court sur des entiers). La réponse de mas90 n'est correcte que si les limites de bin se produisent à n * binwidth.

Voulez-vous tracer un graphique comme celui-ci? Oui? Ensuite, vous pouvez consulter mon article de blog: http://gnuplot-surprising.blogspot.com/2011/09/statistic-analysis-and-histogram.html

Lignes clés du code:

n=100 #number of intervals
max=3. #max value
min=-3. #min value
width=(max-min)/n #interval width
#function used to map a value to the intervals
hist(x,width)=width*floor(x/width)+width/2.0
set boxwidth width*0.9
set style fill solid 0.5 # fill style

#count and plot
plot "data.dat" u (hist($1,width)):(1.0) smooth freq w boxes lc rgb"green" notitle

Comme d'habitude, Gnuplot est un outil fantastique pour tracer des graphiques à l'aspect doux et il peut être fait pour effectuer toutes sortes de calculs. Cependant , il est destiné à tracer des données plutôt qu'à servir de calculatrice et il est souvent plus facile d'utiliser un programme externe (par exemple Octave) pour effectuer les calculs les plus "compliqués", enregistrer ces données dans un fichier, puis utiliser Gnuplot pour produire le graphique. Pour le problème ci-dessus, vérifiez que la fonction "hist" utilise Octave [freq,bins]=hist(data), puis tracez ceci dans Gnuplot en utilisant

set style histogram rowstacked gap 0
set style fill solid 0.5 border lt -1
plot "./data.dat" smooth freq with boxes

J'ai trouvé cette discussion extrêmement utile, mais j'ai rencontré des problèmes d'arrondi.

Plus précisément, en utilisant une largeur de bin de 0,05, j'ai remarqué qu'avec les techniques présentées ci-dessus, les points de données qui lisent 0,1 et 0,15 tombent dans le même bin. Cela (comportement manifestement indésirable) est très probablement dû à la fonction «plancher».

Ci-après ma petite contribution pour tenter de contourner cela.

bin(x,width,n)=x<=n*width? width*(n-1) + 0.5*binwidth:bin(x,width,n+1)
binwidth = 0.05
set boxwidth binwidth
plot "data.dat" u (bin($1,binwidth,1)):(1.0) smooth freq with boxes

Cette méthode récursive est pour x> = 0; on pourrait généraliser cela avec des instructions plus conditionnelles pour obtenir quelque chose d'encore plus général.

Nous n'avons pas besoin d'utiliser de méthode récursive, cela peut être lent. Ma solution consiste à utiliser une fonction définie par l'utilisateur au lieu de la fonction instrinsic int ou floor.

rint(x)=(x-int(x)>0.9999)?int(x)+1:int(x)

Cette fonction donnera rint(0.0003/0.0001)=3, tout int(0.0003/0.0001)=floor(0.0003/0.0001)=2.

Pourquoi? Veuillez regarder la fonction int de Perl et les zéros de remplissage

J'ai une petite modification à la solution de Born2Smile.

Je sais que cela n'a pas beaucoup de sens, mais vous pouvez le vouloir juste au cas où. Si vos données sont entières et que vous avez besoin d'une taille de bac flottant (peut-être pour la comparaison avec un autre ensemble de données ou une densité de tracé dans une grille plus fine), vous devrez ajouter un nombre aléatoire entre 0 et 1 à l'intérieur du sol. Sinon, il y aura des pics en raison d'une erreur d'arrondi. floor(x/width+0.5)ne le fera pas car il créera un modèle qui n'est pas fidèle aux données d'origine.

binwidth=0.3
bin(x,width)=width*floor(x/width+rand(0))

En ce qui concerne les fonctions de binning, je ne m'attendais pas au résultat des fonctions proposées jusqu'à présent. À savoir, si ma largeur de bin est de 0,001, ces fonctions centraient les cases sur 0,0005 points, alors que je pense qu'il est plus intuitif d'avoir les cases centrées sur les limites de 0,001.

En d'autres termes, j'aimerais avoir

Bin 0.001 contain data from 0.0005 to 0.0014
Bin 0.002 contain data from 0.0015 to 0.0024
...

La fonction de binning que j'ai trouvée est

my_bin(x,width)     = width*(floor(x/width+0.5))

Voici un script pour comparer certaines des fonctions bin offertes à celle-ci:

rint(x) = (x-int(x)>0.9999)?int(x)+1:int(x)
bin(x,width)        = width*rint(x/width) + width/2.0
binc(x,width)       = width*(int(x/width)+0.5)
mitar_bin(x,width)  = width*floor(x/width) + width/2.0
my_bin(x,width)     = width*(floor(x/width+0.5))

binwidth = 0.001

data_list = "-0.1386 -0.1383 -0.1375 -0.0015 -0.0005 0.0005 0.0015 0.1375 0.1383 0.1386"

my_line = sprintf("%7s  %7s  %7s  %7s  %7s","data","bin()","binc()","mitar()","my_bin()")
print my_line
do for [i in data_list] {
    iN = i + 0
    my_line = sprintf("%+.4f  %+.4f  %+.4f  %+.4f  %+.4f",iN,bin(iN,binwidth),binc(iN,binwidth),mitar_bin(iN,binwidth),my_bin(iN,binwidth))
    print my_line
}

et voici la sortie

   data    bin()   binc()  mitar()  my_bin()
-0.1386  -0.1375  -0.1375  -0.1385  -0.1390
-0.1383  -0.1375  -0.1375  -0.1385  -0.1380
-0.1375  -0.1365  -0.1365  -0.1375  -0.1380
-0.0015  -0.0005  -0.0005  -0.0015  -0.0010
-0.0005  +0.0005  +0.0005  -0.0005  +0.0000
+0.0005  +0.0005  +0.0005  +0.0005  +0.0010
+0.0015  +0.0015  +0.0015  +0.0015  +0.0020
+0.1375  +0.1375  +0.1375  +0.1375  +0.1380
+0.1383  +0.1385  +0.1385  +0.1385  +0.1380
+0.1386  +0.1385  +0.1385  +0.1385  +0.1390