Histogramme à l'aide de gnuplot?

Je sais comment créer un histogramme (il suffit d'utiliser "avec des cases") dans gnuplot si mon .dat fichier a déjà correctement mise à la poubelle de données. Est-il possible de prendre une liste de numéros et ont gnuplot fournir un histogramme basé sur les gammes et tailles de bac fournit de l'utilisateur?

  • Si vous n'obtenez pas une réponse il existe d'autres outils qui sont destinés à faire de telles choses. J'utilise la Racine (root.le cern.ch), beaucoup d'autres ici l'utilisation de R, et il y a au moins un peu d'autres options.
  • Bin, c'est la gamme de valeurs recueillies pour chaque barre de l'histogramme. Chaque cellule a une limite inférieure et supérieure, et toutes les données avec une valeur dans cette gamme sera pris en compte dans ce bar. Binned signifie que mon fichier de données est déjà organisé par le nombre de données de points de chute à l'intérieur de chaque cellule, de sorte qu'il est prêt à être représentée sous la forme d'un histogramme.
InformationsquelleAutor mary | 2010-03-18
  1. 224

    oui, et sa rapide et simple bien que très caché:

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

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

    découvrez help smooth freq de voir pourquoi ci-dessus fait un histogramme

    pour faire face aux plages il suffit de régler le xrange variable.

    • Je pense que @ChrisW la réponse ci-dessous apporte un point important pour toute personne qui veut faire un Histogramme dans Gnuplot.
    • Faire très attention, cela ne fonctionne que si il n'y a pas de "manque" bin dans le jeu... Cette fonction corrige la valeur de y la disparition d'un bin à la valeur y de la précédente non-manquantes bin. Cela peut être très trompeur!!!
    InformationsquelleAutor Born2Smile
  2. 87

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

    1. Les caisses vides causé la case adjacente bin mal à s'étendre dans son espace; éviter cela en utilisant set boxwidth binwidth
    2. Dans Born2Smile version, les bacs sont rendus sous centrée sur leur limite inférieure. Strictement elles devraient s'étendre à partir de la limite inférieure à la limite supérieure. Cela peut être corrigé en modifiant le bin fonction: bin(x,width)=width*floor(x/width) + width/2.0
    • En fait que la seconde partie devrait être bin(x,width)=width*floor(x/width) + binwidth/2.0 (les calculs en virgule flottante)
    • Tu veux dire bin(x,width)=width*floor(x/width) + width/2.0. Si nous sommes de passage width comme un argument, puis l'utiliser. 🙂
    InformationsquelleAutor mas90
  3. 76

    Être très prudent: toutes les réponses sur cette page sont implicitement de prendre la décision de l'endroit où le binning commence - le bord gauche de la plus à gauche de la corbeille, si vous le souhaitez de les mains de l'utilisateur. Si l'utilisateur est de combiner l'une de ces fonctions pour le regroupement des données avec son/sa propre décision sur l'endroit où binning commence (comme on le fait sur le blog qui est lié ci-dessus) les fonctions ci-dessus sont toutes erronées. Avec l'arbitraire d'un point de départ pour binning "Min", la fonction correcte est:

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

    Vous pouvez voir pourquoi il est correct de manière séquentielle (il permet de tirer quelques bacs et un point quelque part dans l'un d'eux). Soustraire Min à partir de votre point de données pour voir comment loin dans le binning gamme c'est. Puis diviser par binwidth de sorte que vous avez un travail efficace dans les unités de "bins". Puis "plancher" de la suite pour aller vers le bord gauche de ce bac, ajouter 0,5 à aller au milieu de la cellule, de la multiplier par la largeur de sorte que vous n'avez plus de travail dans les unités de bacs, mais dans l'absolu à nouveau, puis ajouter enfin de retour sur le Min de décalage que vous soustrait au début.

    Considérer cette fonction dans l'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 de 1,1 fait véritablement partie de la gauche de la corbeille:

    • cette fonction correctement les cartes au centre de la gauche de la corbeille (0.75);
    • Born2Smile réponse, bin(x)=largeur*floor(x/largeur), à tort cartes 1;
    • mas90 réponse, bin(x)=largeur*floor(x/largeur) + binwidth/2.0, mal de cartes à 1.5.

    Born2Smile la réponse est correcte uniquement si le bac limites se produire à (n+0.5)*binwidth (où n fonctionne sur les entiers). mas90 la réponse est correcte uniquement si le bac limites se produire à n*binwidth.

    InformationsquelleAutor ChrisW
  4. 45

    Voulez-vous de tracer un graphique comme celui-ci?
    Histogramme à l'aide de gnuplot?
    oui? Ensuite, vous pouvez jeter un oeil à mon article de blog: http://gnuplot-surprising.blogspot.com/2011/09/statistic-analysis-and-histogram.html

    Clé de lignes dans le 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
    InformationsquelleAutor hsxz
  5. 9

    Comme d'habitude, Gnuplot est un outil fantastique pour complot en regardant doux graphiques et il peut être fait pour effectuer toutes sortes de calculs. Cependant, il est destiné à tracer des données plutôt que de servir comme une calculatrice et il est souvent plus facile d'utiliser un programme extérieur (par exemple, l'Octave) pour faire le plus "compliqué", de calculs, d'enregistrer ces données dans un fichier, puis d'utiliser Gnuplot pour produire le graphique. Pour le problème ci-dessus, découvrez le "hist" la fonction est d'Octave à l'aide de [freq,bins]=hist(data), puis tracer cette Gnuplot à l'aide de 

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

    J'ai trouvé ce débat très utile, mais j'ai vécu quelques "arrondi" les problèmes.

    Plus précisément, à l'aide d'un binwidth de 0,05, j'ai remarqué que, avec les techniques présentées ci-dessus, les points de données de lecture de 0,1 et 0,15 tomber dans la même cellule. Ce (évidemment comportement indésirable) est probablement dû à la "parole" de la fonction.

    Ci-après est ma petite contribution pour essayer 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 ce avec plus d'instructions conditionnelles pour obtenir quelque chose de plus général encore.

    InformationsquelleAutor Alex
  7. 6

    Nous n'avons pas besoin d'utiliser la méthode récursive, il peut être lent. Ma solution est d'utiliser une fonction définie par l'utilisateur rint instesd de instrinsic fonction de type int ou au sol. 

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

    Cette fonction rint(0.0003/0.0001)=3, tandis que int(0.0003/0.0001)=floor(0.0003/0.0001)=2.

    Pourquoi? S'il vous plaît regardez Perl fonction int et le remplissage de zéros

    InformationsquelleAutor JOE
  8. 4

    J'ai un peu de modification à Born2Smile de la solution.

    Je sais que cela ne fait pas beaucoup de sens, mais vous souhaitez peut-être juste au cas où. Si vos données est de type entier et vous avez besoin d'un flotteur bin taille (peut-être pour la comparaison avec un autre jeu de données, ou de la parcelle de la densité dans la grille la plus fine), vous aurez besoin d'ajouter un nombre aléatoire entre 0 et 1 à l'intérieur de chaussée. Sinon, il y aura des pointes en raison de round up d'erreur. floor(x/width+0.5) ne le fera pas, car il crée un modèle qui n'est pas vrai pour les données d'origine.

    binwidth=0.3
bin(x,width)=width*floor(x/width+rand(0))
    • Vous n'avez pas rencontré de telles situations, mais vous pouvez plus tard. Vous pouvez testé avec normalement distribués entiers avec un flotteur sd et tracer les histogrammes avec bin=1, et bin=s.d. Voir ce que vous obtenez avec et sans le rand(0) truc. J'ai attrapé un collaborateur de l'erreur lors de la révision de son manuscrit. Ses résultats ont changé à partir d'absolument aucun sens pour une belle figure comme prévu.
    • Ok, peut-être que l'explication est si courte, qu'on ne peut le comprendre sans plus concrets de cas de test. Je vais faire un petit edit de votre réponse afin que je puisse annuler le downvote 😉
    • Considérer les entiers de la distribution normale. Comme ils sont des nombres entiers, beaucoup d'entre eux auront le même x/largeur. Disons que nombre est de 1,3. Avec floor(x/largeur+0.5), tous d'entre eux seront affectés à la corbeille de 1. Mais ce qui 1.3 vraiment les moyens en termes de densité, c'est que 70% d'entre eux devraient être en bin 1 et 30% en bin 2. rand(0) maintient la bonne densité. Donc, 0,5 crée des pointes et rand(0) tient-il vrai. Je parie que la figure en hsxz sera beaucoup plus lisse à l'aide de rand(0) au lieu de 0,5. Ce n'est pas seulement des arrondis, il est arrondi vers le haut sans perturbation.
    InformationsquelleAutor path4
  9. 3

    À l'égard de binning fonctions, je n'ai pas à attendre le résultat de l'fonctions offertes jusqu'à présent. À savoir, si mon binwidth est de 0,001, ces fonctions étaient de centrage de la trémies de 0,0005 points, alors que je pense que c'est plus intuitif pour avoir les poubelles centrée sur 0.001 limites.

    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
...

    Le binning fonction je suis venu avec est

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

    Voici un script de comparer certains de l'offre bin fonctions de celui-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
    InformationsquelleAutor Winston Smith