import java.io.*;
import java.math.*;
import uk.ac.ed.ph.advcompsim.part3.histogram.Histogram;
/**
* ---------------------------------------------------------------
* Excersize 3.1.3
* ---------------------------------------------------------------<br />
* I would expect the histogram to be fairly flat, because over a large number of N I would expect the probability of getting a value in the region
* 0-0.1 to be the same as that of getting a number in the region 0.4-0.5 for example.
*/
public class exc313 {
/**
* Takes a number n and prints that many random numbers.
*/
public static void main (String args[]) {
int n = 200; // number of random numbers to be generated
int nb = 10; // number of bins to use.
float[] data = new float[n]; // The data array
float lb = 0; // The lower boundary
float ub = 1; // The upper boundary
for(int i=0;i < n;i++) {
data[i] = (float)(Math.random()); // print the randomly generated number to screen
}
//Histogram.DataHistogram(nb, lb, ub, data, true);
}
}
THEN THE OTHER BITS
001 package uk.ac.ed.ph.advcompsim.part3.histogram;
002
003 import uk.ac.ed.ph.advcompsim.part3.display.GUI;
004 import java.awt.geom.Rectangle2D;
005 import uk.ac.ed.ph.advcompsim.part3.display.Board;
006 import uk.ac.ed.ph.advcompsim.part3.closure.Closure;
007 import java.awt.*;
008 import java.awt.Dimension;
009 import java.util.*;
010
011 /**
012 * This abstract base class provides basic methods and fields for the manipulation of
013 * histograms. It must be subclassed by a <code>Histogram</code> class, which defines methods
014 * for binning a data sample or a given function.
015 *
016 *
017 * @author M. L. Ciccolini
018 * @author Tony Kennedy
019 * @version 1.2
020 * @see Histogram Histogram
021 * @see Closure Closure
022 */
023
024 public abstract class Histogram implements Closure {
025
026 /** Is the area normalized to one? */
027 protected boolean normalized;
028
029 /** Number of bins */
030 protected int numBins;
031
032 /** Width of the bins */
033 protected float binWidth;
034
035 /**
036 * Cumulative area of the histogram in each bin, i.e., the area under the
037 * histogram up to and including that bin
038 */
039 protected float[] area;
040
041 /** Total area under the (unnormalized) histogram */
042 protected float totalArea;
043
044 /**Lower limit of the values included in the histogram */
045 protected float lowerBound;
046
047 /** Upper limit of the values included in the histogram */
048 protected float upperBound;
049
050 /** GUI in which to show graphs */
051 private static GUI window = null;
052
053 /**
054 * Partially initialize an object belonging to a class derived from
055 * {@link Histogram}: <ul><li>Allocate memory for the {@link Histogram#area area}
056 * array,</li> <li>Initialize {@link Histogram#upperBound upperBound},
057 * {@link Histogram#lowerBound lowerBound},
058 * {@link Histogram#numBins numBins}, {@link Histogram#binWidth binWidth},
059 * and {@link Histogram#normalized normalized}
060 * fields.</li></ol>. This constructor for the <em>abstract</em>
061 * base class for histograms <em>does not</em> initialize the
062 * values in the {@link Histogram#area area} array, as no such values are yet
063 * available to it.
064 *
065 *
066 * @param nBins Number of bins
067 * @param ub Upper bound on values to be histogrammed
068 * @param lb Lower bound on values to be histogrammed
069 * @param normalize set if the area under the histogram is to be normalized
070 * to unity.
071 * @throws IllegalArgumentException If the lower bound is greater than the upper
072 * bound, or if the number of bins is not positive.
073 */
074 protected Histogram(int nBins, float lb, float ub, boolean normalize) throws IllegalArgumentException {
075 if (nBins <= 0)
076 throw new IllegalArgumentException("Number of bins must be positive");
077 numBins = nBins;
078 upperBound = ub;
079 lowerBound = lb;
080 binWidth = (upperBound - lowerBound) / (float) numBins;
081 if (binWidth <= 0.0f)
082 throw new IllegalArgumentException("Bins must have positive width");
083 area = new float[numBins];
084 normalized = normalize;
085 }
086
087 /**
088 * Area of the specified histogram bin.
089 *
090 * @param bin Bin whose area is desired
091 * @return Area of <code>bin</code>
092 * @throws IllegalArgumentException if <code>bin</code> is out of range
093 */
094 public float binArea(int bin) throws IllegalArgumentException {
095 if (bin < 0 || bin >= numBins)
096 throw new IllegalArgumentException("Bin " + bin + " out of range");
097 if (bin == 0) return area[0];
098 return area[bin] - area[bin-1];
099 }
100
101 /**
102 * Height of the specified histogram bin.
103 *
104 * @param bin Bin whose height is desired
105 * @return Height of <code>bin</code>
106 * @throws IllegalArgumentException if <code>bin</code> is out of range
107 */
108 public float height(int bin) throws IllegalArgumentException {
109 return binArea(bin) / binWidth;
110 }
111
112 /**
113 * Bin containing coordinate <code>x</code>.
114 *
115 *
116 * @param x coordinate value
117 * @return bin containing <code>x</code>
118 * @throws IllegalArgumentException if <code>x</code> is not between
119 * {@link Histogram#upperBound lowerBound} and {@link Histogram#upperBound upperBound}
120 */
121 public int binValue(float x) {
122 int bin = (int) ((x - lowerBound) / binWidth);
123 if (bin < 0 || bin > numBins)
124 throw new IllegalArgumentException("Value " + x + "out of range");
125 return bin;
126 }
127
128 /**
129 * Find the bin containing the cumulative area <code>x</code> within it.
130 * This implementation just steps through the bins until it finds that the
131 * cumulative area (in the {@link Histogram#area area} array) exceeds
132 * <code>x</code>, so it takes <code>O(numBins)</code> time.
133 *
134 * {@question Can you find and implement an algorithm that takes
135 * <code>O(ln(numBins))</code> time instead?}
136 *
137 * @param x Cumulative area to to left of bin.
138 * @return <code>bin</code> such that <code>area[bin-1] <= x < area[bin]</code>.
139 * @throws IllegalArgumentException if the <code>x</code> does not correspond
140 * to any bin.
141 */
142 public int lookupBin(float x) throws IllegalArgumentException {
143 if (x < 0.0f || x > area[numBins - 1])
144 throw new IllegalArgumentException("Area " + x + " not underhistogram");
145 for (int bin = 0; bin < numBins; bin++) {
146 if (x < area[bin]) return bin;
147 }
148 throw new Error("This cannot happen");
149 }
150
151 /**
152 * Maximum height of the histogram.
153 *
154 * @return Maximum height
155 */
156 public float maxHeight() {
157 float max = 0.0f;
158 for (int i = 0; i < numBins; i++) {
159 float ht = height(i);
160 if (ht > max) max = ht;
161 }
162 return max;
163 }
164
165 /**
166 * Number of bins in histogram.
167 *
168 * @return Number of bins
169 */
170 public int getNumBins() { return numBins; }
171
172 /**
173 * Upper bound of values in histogram.
174 *
175 * @return Upper bound.
176 */
177 public float getUpperBound() { return upperBound; }
178
179 /**
180 * Lower bound of values in histogram
181 *
182 * @return Lower bound.
183 */
184 public float getLowerBound() { return lowerBound; }
185
186 /**
187 * Bounding {@link Rectangle} for this Histogram.
188 *
189 * @return Bounding {@link Rectangle} for this Histogram.
190 */
191 public Rectangle2D.Float getBounds() {
192 return new Rectangle2D.Float(lowerBound, 0.0f, upperBound - lowerBound, maxHeight());
193 }
194
195 /**
196 * Evaluate the histogram as a function.
197 *
198 * @param x coordinate
199 * @return Height of bin containing <code>x</code>
200 */
201 public float function(float x) {
202 if (x < lowerBound || x > upperBound) return 0.0f;
203 return height(binValue(x));
204 }
205
206 public String toString() {
207 return "AbsHistogram(lowerBound = " + lowerBound
208 + ", upperBound = " + upperBound
209 + ", numBins = " + numBins
210 + (normalized ? "" : " not") + "normalized)";
211 }
212
213 /**
214 * Prints the contents of the histogram to <code>System.out</code> as three
215 * columns: the first is the bin number, the second the location of the midpoint
216 * of the bin, and the third the height of the bin.
217 */
218 public void printHistogram() {
219 System.out.printf("\nBin #\tPosition\tHeight\n");
220 for (int bin = 0; bin < numBins; bin++) {
221 float middle = lowerBound + binWidth * (0.5f + (float) bin);
222 System.out.printf("%-6d\t%-10.2g\t%-10.2f\n", bin, middle, height(bin));
223 }
224 System.out.printf("\ntotalArea = %-10.2f\n", totalArea);
225 }
226
227 /**
228 * Display board in the GUI window, which is created if necessary.
229 *
230 * @param graph Board to be displayed.
231 * @see Board
232 * @see GUI
233 */
234 private static void show(Board graph) {
235 if (window == null) window = new GUI(graph);
236 else window.show(graph);
237 }
238
239 /**
240 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
241 * superimposed on a single graph with specified bounds on the graph's data
242 * coordinate system.</p>
243 *
244 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
245 * can be paged through in the {@link GUI} window.</p>
246 *
247 * <p>If you want to display an {@link Histogram} as a function rather than as
248 * a histogram, by making use of the fact that it implments the {@link Closure}
249 * interface and thus provide the {@link Histogram#function function} method, then you will
250 * need create a wrapper object that implements {@link Closure} but not {@link
251 * Histogram}. This is because if an object both implements the {@link Closure}
252 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
253 * a histogram rather than as a function.</p>
254 *
255 * <p>For convenient this method allows a collection of {@link Closure}s as well as
256 * and vararg list of them.</p>
257 *
258 * @param title Title for the graph.
259 * @param bounds Bounds on the graph in data coordinates.
260 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
261 * and {@link Closure}s to superimpose on the graph.
262 * @param things {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
263 * and {@link Closure}s to superimpose on the graph.
264 * @see Board
265 * @see Closure
266 */
267 public static void draw(String title, Rectangle2D.Float bounds, Iterable<Closure> thingCollection, Closure ... things) {
268 LinkedList<Histogram> ahs = new LinkedList<Histogram>();
269 LinkedList<Closure> fns = new LinkedList<Closure>();
270 if (thingCollection != null) {
271 for (Closure f : thingCollection) {
272 if (f instanceof Histogram) ahs.add((Histogram) f);
273 else fns.add(f);
274 }
275 }
276 if (things != null) {
277 for (Closure f : things) {
278 if (f instanceof Histogram) ahs.add((Histogram) f);
279 else fns.add(f);
280 }
281 }
282 show(new Board(ahs, fns, bounds, title));
283 }
284
285 /**
286 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
287 * superimposed on a single graph with a scale chosen to fit all of them.</p>
288 *
289 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
290 * can be paged through in the {@link GUI} window.</p>
291 *
292 * <p>If you want to display an {@link Histogram} as a function rather than as
293 * a histogram, by making use of the fact that it implments the {@link Closure}
294 * interface and thus provide the {@link Histogram#function function} method, then you will
295 * need create a wrapper object that implements {@link Closure} but not {@link
296 * Histogram}. This is because if an object both implements the {@link Closure}
297 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
298 * a histogram rather than as a function.</p>
299 *
300 * <p>For convenient this method allows a collection of {@link Closure}s as well as
301 * and vararg list of them.</p>
302 *
303 * @param title Title for the graph.
304 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
305 * and {@link Closure}s to superimpose on the graph.
306 * @param things {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
307 * and {@link Closure}s to superimpose on the graph.
308 * @see Board
309 * @see Closure
310 */
311 public static void draw(String title, Iterable<Closure> thingCollection, Closure ... things) {
312 draw(title, null, thingCollection, things);
313 }
314
315 /**
316 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
317 * superimposed on a single graph with specified bounds on the graph's data
318 * coordinate system.</p>
319 *
320 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
321 * can be paged through in the {@link GUI} window.</p>
322 *
323 * <p>If you want to display an {@link Histogram} as a function rather than as
324 * a histogram, by making use of the fact that it implments the {@link Closure}
325 * interface and thus provide the {@link Histogram#function function} method, then you will
326 * need create a wrapper object that implements {@link Closure} but not {@link
327 * Histogram}. This is because if an object both implements the {@link Closure}
328 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
329 * a histogram rather than as a function.</p>
330 *
331 * <p>For convenient this method allows a collection of {@link Closure}s as well as
332 * and vararg list of them.</p>
333 *
334 * @param bounds Bounds on the graph in data coordinates.
335 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
336 * and {@link Closure}s to superimpose on the graph.
337 * @param things {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
338 * and {@link Closure}s to superimpose on the graph.
339 * @see Board
340 * @see Closure
341 */
342 public static void draw(Rectangle2D.Float bounds, Iterable<Closure> thingCollection, Closure ... things) {
343 draw(null, bounds, thingCollection, things);
344 }
345
346 /**
347 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
348 * superimposed on a single graph with a scale chosen to fit all of them.</p>
349 *
350 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
351 * can be paged through in the {@link GUI} window.</p>
352 *
353 * <p>If you want to display an {@link Histogram} as a function rather than as
354 * a histogram, by making use of the fact that it implments the {@link Closure}
355 * interface and thus provide the {@link Histogram#function function} method, then you will
356 * need create a wrapper object that implements {@link Closure} but not {@link
357 * Histogram}. This is because if an object both implements the {@link Closure}
358 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
359 * a histogram rather than as a function.</p>
360 *
361 * <p>For convenient this method allows a collection of {@link Closure}s as well as
362 * and vararg list of them.</p>
363 *
364 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
365 * and {@link Closure}s to superimpose on the graph.
366 * @param things {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
367 * and {@link Closure}s to superimpose on the graph.
368 * @see Board
369 * @see Closure
370 */
371 public static void draw(Iterable<Closure> thingCollection, Closure ... things) {
372 draw(null, null, thingCollection, things);
373 }
374
375 /**
376 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
377 * superimposed on a single graph with specified bounds on the graph's data
378 * coordinate system.</p>
379 *
380 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
381 * can be paged through in the {@link GUI} window.</p>
382 *
383 * <p>If you want to display an {@link Histogram} as a function rather than as
384 * a histogram, by making use of the fact that it implments the {@link Closure}
385 * interface and thus provide the {@link Histogram#function function} method, then you will
386 * need create a wrapper object that implements {@link Closure} but not {@link
387 * Histogram}. This is because if an object both implements the {@link Closure}
388 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
389 * a histogram rather than as a function.</p>
390 *
391 * @param title Title for the graph.
392 * @param bounds Bounds on the graph in data coordinates.
393 * @param things {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
394 * and {@link Closure}s to superimpose on the graph.
395 * @see Board
396 * @see Closure
397 */
398 public static void draw(String title, Rectangle2D.Float bounds, Closure ... things) {
399 draw(title, bounds, null, things);
400 }
401
402 /**
403 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
404 * superimposed on a single graph with a scale chosen to fit all of them.</p>
405 *
406 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
407 * can be paged through in the {@link GUI} window.</p>
408 *
409 * <p>If you want to display an {@link Histogram} as a function rather than as
410 * a histogram, by making use of the fact that it implments the {@link Closure}
411 * interface and thus provide the {@link Histogram#function function} method, then you will
412 * need create a wrapper object that implements {@link Closure} but not {@link
413 * Histogram}. This is because if an object both implements the {@link Closure}
414 * interface <em>and</em> extends {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram
415 * Histogram} then it will be plotted as a histogram rather than as a function.</p>
416 *
417 * @param title Title for the graph.
418 * @param things {@link Histogram}s and {@link Closure}s to superimpose on the
419 * graph.
420 * @see Board
421 * @see Closure
422 */
423 public static void draw(String title, Closure ... things) { draw(title, null, null, things); }
424
425 /**
426 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
427 * superimposed on a single graph with a scale chosen to fit all of them.</p>
428 *
429 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
430 * can be paged through in the {@link GUI} window.</p>
431 *
432 * <p>If you want to display an {@link Histogram} as a function rather than as
433 * a histogram, by making use of the fact that it implments the {@link Closure}
434 * interface and thus provide the {@link Histogram#function function} method, then you will
435 * need create a wrapper object that implements {@link Closure} but not {@link
436 * Histogram}. This is because if an object both implements the {@link Closure}
437 * interface <em>and</em> extends {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram
438 * Histogram} then it will be plotted as a histogram rather than as a function.</p>
439 *
440 * @param things {@link Histogram}s and {@link Closure}s to superimpose on the
441 * graph.
442 * @see Board
443 * @see Closure
444 */
445 public static void draw(Closure ... things) { draw(null, null, null, things); }
446
447 /**
448 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
449 * superimposed on a single graph with specified bounds on the graph's data
450 * coordinate system.</p>
451 *
452 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
453 * can be paged through in the {@link GUI} window.</p>
454 *
455 * <p>If you want to display an {@link Histogram} as a function rather than as
456 * a histogram, by making use of the fact that it implments the {@link Closure}
457 * interface and thus provide the {@link Histogram#function function} method, then you will
458 * need create a wrapper object that implements {@link Closure} but not {@link
459 * Histogram}. This is because if an object both implements the {@link Closure}
460 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
461 * a histogram rather than as a function.</p>
462 *
463 * @param title Title for the graph.
464 * @param bounds Bounds on the graph in data coordinates.
465 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
466 * and {@link Closure}s to superimpose on the graph.
467 * @see Board
468 * @see Closure
469 */
470 public static void draw(String title, Rectangle2D.Float bounds, Iterable<Closure> thingCollection) {
471 draw(title, bounds, thingCollection, (Closure []) null);
472 }
473
474 /**
475 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
476 * superimposed on a single graph with specified bounds on the graph's data
477 * coordinate system.</p>
478 *
479 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
480 * can be paged through in the {@link GUI} window.</p>
481 *
482 * <p>If you want to display an {@link Histogram} as a function rather than as
483 * a histogram, by making use of the fact that it implments the {@link Closure}
484 * interface and thus provide the {@link Histogram#function function} method, then you will
485 * need create a wrapper object that implements {@link Closure} but not {@link
486 * Histogram}. This is because if an object both implements the {@link Closure}
487 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
488 * a histogram rather than as a function.</p>
489 *
490 * @param bounds Bounds on the graph in data coordinates.
491 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
492 * and {@link Closure}s to superimpose on the graph.
493 * @see Board
494 * @see Closure
495 */
496 public static void draw(Rectangle2D.Float bounds, Iterable<Closure> thingCollection) {
497 draw(null, bounds, thingCollection, (Closure []) null);
498 }
499
500 /**
501 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
502 * superimposed on a single graph with a scale chosen to fit all of them.</p>
503 *
504 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
505 * can be paged through in the {@link GUI} window.</p>
506 *
507 * <p>If you want to display an {@link Histogram} as a function rather than as
508 * a histogram, by making use of the fact that it implments the {@link Closure}
509 * interface and thus provide the {@link Histogram#function function} method, then you will
510 * need create a wrapper object that implements {@link Closure} but not {@link
511 * Histogram}. This is because if an object both implements the {@link Closure}
512 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
513 * a histogram rather than as a function.</p>
514 *
515 * @param title Title for the graph.
516 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
517 * and {@link Closure}s to superimpose on the graph.
518 * @see Board
519 * @see Closure
520 */
521 public static void draw(String title, Iterable<Closure> thingCollection) {
522 draw(title, null, thingCollection, (Closure []) null);
523 }
524
525 /**
526 * <p>Display a collection of {@link Histogram}s and {@link Closure}s
527 * superimposed on a single graph with a scale chosen to fit all of them.</p>
528 *
529 * <p>Multiple calls to {@link Board#draw draw} will produce multiple graphs which
530 * can be paged through in the {@link GUI} window.</p>
531 *
532 * <p>If you want to display an {@link Histogram} as a function rather than as
533 * a histogram, by making use of the fact that it implments the {@link Closure}
534 * interface and thus provide the {@link Histogram#function function} method, then you will
535 * need create a wrapper object that implements {@link Closure} but not {@link
536 * Histogram}. This is because if an object both implements the {@link Closure}
537 * interface <em>and</em> extends {@link Histogram} then it will be plotted as
538 * a histogram rather than as a function.</p>
539 *
540 * @param thingCollection {@link uk.ac.ed.ph.advcompsim.part3.histogram.Histogram Histogram}s
541 * and {@link Closure}s to superimpose on the graph.
542 * @see Board
543 * @see Closure
544 */
545 public static void draw(Iterable<Closure> thingCollection) {
546 draw(null, null, thingCollection, (Closure []) null);
547 }
548
549 /**
550 * Display the histogram.
551 * TODO Check that this works!
552 */
553 public void draw() { draw(this); }
554
555 /**
556 * Display the histogram.
557 *
558 * TODO Check that this works!
559 * @param title Title for the graph.
560 */
561 public void draw(String title) { draw(title, this); }
562 }
THEN DATAHISTOGRAM FILE
01 package uk.ac.ed.ph.advcompsim.part3.histogram;
02
03 import uk.ac.ed.ph.advcompsim.part3.closure.Closure;
04
05 /**
06 * This class implements histograms generated by binning sample data values.
07 * It is a subclass of the abstract {@link Histogram} class.
08 *
09 * @author M. L. Ciccolini
10 * @author <a href="mailto:adk@ph.ed.ac.uk">Tony Kennedy</a>
11 * @version 1.3
12 */
13
14 public class DataHistogram extends Histogram {
15
16 /**
17 * This constructor calls the constructor of the superclass {@link Histogram} setting
18 * the interval and the number of bins. It then bins the sample and constructs the histogram.
19 *
20 * @param nb Number of bins
21 * @param ub Upper bound
22 * @param lb Lower bound
23 * @param data Data samples to be binned
24 * @param normalize Area to be normalized?
25 * @throws IllegalArgumentException if the arguments are invalid
26 */
27
28 public DataHistogram(int nb, float lb, float ub, float[] data, boolean normalize)
29 throws IllegalArgumentException {
30 super(nb, lb, ub, normalize);
31 binData(data);
32 }
33
34 /**
35 * Bin <code>data</code> and initialize {@link Histogram#area area} array.
36 * The {@link Histogram#totalArea totalArea} field is set to the number of
37 * samples falling within the histogram bounds. The {@link Histogram#area area}
38 * array is normalized to have total area one if {@link Histogram#normalized
39 * normalized} is set.
40 *
41 *
42 * @param data Sample data
43 */
44 private void binData(float[] data) {
45 int count = 0;
46 int [] hits = new int[numBins];
47 for (int bin = 0; bin < numBins; bin++) hits[bin] = 0;
48 for (float sample : data) {
49 if (sample >= lowerBound && sample <= upperBound) {
50 hits[binValue(sample)]++;
51 count++;
52 }
53 }
54 totalArea = 0.0f;
55 for (int bin = 0; bin < numBins; bin++) {
56 totalArea += (float) hits[bin];
57 area[bin] = totalArea;
58 if (normalized) area[bin] /= count;
59 }
60 }
61 }