propane 2.9.0-java → 2.9.1-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (37) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +2 -0
  3. data/Rakefile +2 -3
  4. data/lib/.gitignore +1 -0
  5. data/lib/export.txt +2 -0
  6. data/lib/propane/version.rb +1 -1
  7. data/pom.rb +2 -49
  8. data/pom.xml +1 -64
  9. data/propane.gemspec +13 -10
  10. data/src/main/java/processing/awt/PGraphicsJava2D.java +29 -20
  11. data/src/main/java/processing/core/PApplet.java +12854 -12803
  12. data/src/main/java/processing/core/PGraphics.java +17 -22
  13. data/src/main/java/processing/core/PShape.java +42 -20
  14. data/src/main/java/processing/core/PShapeSVG.java +20 -5
  15. data/src/main/java/processing/core/PSurfaceNone.java +1 -4
  16. data/src/main/java/processing/data/DoubleDict.java +848 -0
  17. data/src/main/java/processing/data/DoubleList.java +928 -0
  18. data/src/main/java/processing/data/FloatDict.java +18 -2
  19. data/src/main/java/processing/data/FloatList.java +26 -2
  20. data/src/main/java/processing/data/IntDict.java +12 -3
  21. data/src/main/java/processing/data/IntList.java +24 -1
  22. data/src/main/java/processing/data/JSONObject.java +2 -2
  23. data/src/main/java/processing/data/LongDict.java +800 -0
  24. data/src/main/java/processing/data/LongList.java +937 -0
  25. data/src/main/java/processing/data/Sort.java +1 -1
  26. data/src/main/java/processing/data/StringDict.java +12 -3
  27. data/src/main/java/processing/data/StringList.java +25 -2
  28. data/src/main/java/processing/data/Table.java +16 -5
  29. data/src/main/java/processing/data/XML.java +8 -1
  30. data/src/main/java/processing/opengl/PGL.java +23 -16
  31. data/src/main/java/processing/opengl/PGraphicsOpenGL.java +13 -10
  32. data/src/main/java/processing/opengl/PJOGL.java +35 -12
  33. data/src/main/java/processing/opengl/shaders/LightVert-brcm.glsl +154 -0
  34. data/src/main/java/processing/opengl/shaders/LightVert-vc4.glsl +2 -2
  35. data/src/main/java/processing/opengl/shaders/TexLightVert-brcm.glsl +160 -0
  36. data/src/main/java/processing/opengl/shaders/TexLightVert-vc4.glsl +2 -2
  37. metadata +22 -13
@@ -0,0 +1,937 @@
1
+ package processing.data;
2
+
3
+ import java.io.File;
4
+ import java.io.PrintWriter;
5
+ import java.util.Arrays;
6
+ import java.util.Iterator;
7
+ import java.util.Random;
8
+
9
+ import processing.core.PApplet;
10
+
11
+
12
+ // splice, slice, subset, concat, reverse
13
+
14
+ // trim, join for String versions
15
+
16
+
17
+ /**
18
+ * Helper class for a list of ints. Lists are designed to have some of the
19
+ * features of ArrayLists, but to maintain the simplicity and efficiency of
20
+ * working with arrays.
21
+ *
22
+ * Functions like sort() and shuffle() always act on the list itself. To get
23
+ * a sorted copy, use list.copy().sort().
24
+ *
25
+ * @webref data:composite
26
+ * @see FloatList
27
+ * @see StringList
28
+ */
29
+ public class LongList implements Iterable<Long> {
30
+ protected int count;
31
+ protected long[] data;
32
+
33
+
34
+ public LongList() {
35
+ data = new long[10];
36
+ }
37
+
38
+
39
+ /**
40
+ * @nowebref
41
+ */
42
+ public LongList(int length) {
43
+ data = new long[length];
44
+ }
45
+
46
+
47
+ /**
48
+ * @nowebref
49
+ */
50
+ public LongList(int[] source) {
51
+ count = source.length;
52
+ data = new long[count];
53
+ System.arraycopy(source, 0, data, 0, count);
54
+ }
55
+
56
+
57
+ /**
58
+ * Construct an IntList from an iterable pile of objects.
59
+ * For instance, a float array, an array of strings, who knows).
60
+ * Un-parseable or null values will be set to 0.
61
+ * @nowebref
62
+ */
63
+ public LongList(Iterable<Object> iter) {
64
+ this(10);
65
+ for (Object o : iter) {
66
+ if (o == null) {
67
+ append(0); // missing value default
68
+ } else if (o instanceof Number) {
69
+ append(((Number) o).intValue());
70
+ } else {
71
+ append(PApplet.parseInt(o.toString().trim()));
72
+ }
73
+ }
74
+ crop();
75
+ }
76
+
77
+
78
+ /**
79
+ * Construct an IntList from a random pile of objects.
80
+ * Un-parseable or null values will be set to zero.
81
+ */
82
+ public LongList(Object... items) {
83
+ final int missingValue = 0; // nuts, can't be last/final/second arg
84
+
85
+ count = items.length;
86
+ data = new long[count];
87
+ int index = 0;
88
+ for (Object o : items) {
89
+ int value = missingValue;
90
+ if (o != null) {
91
+ if (o instanceof Number) {
92
+ value = ((Number) o).intValue();
93
+ } else {
94
+ value = PApplet.parseInt(o.toString().trim(), missingValue);
95
+ }
96
+ }
97
+ data[index++] = value;
98
+ }
99
+ }
100
+
101
+
102
+ static public LongList fromRange(int stop) {
103
+ return fromRange(0, stop);
104
+ }
105
+
106
+
107
+ static public LongList fromRange(int start, int stop) {
108
+ int count = stop - start;
109
+ LongList newbie = new LongList(count);
110
+ for (int i = 0; i < count; i++) {
111
+ newbie.set(i, start+i);
112
+ }
113
+ return newbie;
114
+ }
115
+
116
+
117
+ /**
118
+ * Improve efficiency by removing allocated but unused entries from the
119
+ * internal array used to store the data. Set to private, though it could
120
+ * be useful to have this public if lists are frequently making drastic
121
+ * size changes (from very large to very small).
122
+ */
123
+ private void crop() {
124
+ if (count != data.length) {
125
+ data = PApplet.subset(data, 0, count);
126
+ }
127
+ }
128
+
129
+
130
+ /**
131
+ * Get the length of the list.
132
+ *
133
+ * @webref intlist:method
134
+ * @brief Get the length of the list
135
+ */
136
+ public int size() {
137
+ return count;
138
+ }
139
+
140
+
141
+ public void resize(int length) {
142
+ if (length > data.length) {
143
+ long[] temp = new long[length];
144
+ System.arraycopy(data, 0, temp, 0, count);
145
+ data = temp;
146
+
147
+ } else if (length > count) {
148
+ Arrays.fill(data, count, length, 0);
149
+ }
150
+ count = length;
151
+ }
152
+
153
+
154
+ /**
155
+ * Remove all entries from the list.
156
+ *
157
+ * @webref intlist:method
158
+ * @brief Remove all entries from the list
159
+ */
160
+ public void clear() {
161
+ count = 0;
162
+ }
163
+
164
+
165
+ /**
166
+ * Get an entry at a particular index.
167
+ *
168
+ * @webref intlist:method
169
+ * @brief Get an entry at a particular index
170
+ */
171
+ public long get(int index) {
172
+ if (index >= this.count) {
173
+ throw new ArrayIndexOutOfBoundsException(index);
174
+ }
175
+ return data[index];
176
+ }
177
+
178
+
179
+ /**
180
+ * Set the entry at a particular index. If the index is past the length of
181
+ * the list, it'll expand the list to accommodate, and fill the intermediate
182
+ * entries with 0s.
183
+ *
184
+ * @webref intlist:method
185
+ * @brief Set the entry at a particular index
186
+ */
187
+ public void set(int index, int what) {
188
+ if (index >= count) {
189
+ data = PApplet.expand(data, index+1);
190
+ for (int i = count; i < index; i++) {
191
+ data[i] = 0;
192
+ }
193
+ count = index+1;
194
+ }
195
+ data[index] = what;
196
+ }
197
+
198
+
199
+ /** Just an alias for append(), but matches pop() */
200
+ public void push(int value) {
201
+ append(value);
202
+ }
203
+
204
+
205
+ public long pop() {
206
+ if (count == 0) {
207
+ throw new RuntimeException("Can't call pop() on an empty list");
208
+ }
209
+ long value = get(count-1);
210
+ count--;
211
+ return value;
212
+ }
213
+
214
+
215
+ /**
216
+ * Remove an element from the specified index
217
+ *
218
+ * @webref intlist:method
219
+ * @brief Remove an element from the specified index
220
+ */
221
+ public long remove(int index) {
222
+ if (index < 0 || index >= count) {
223
+ throw new ArrayIndexOutOfBoundsException(index);
224
+ }
225
+ long entry = data[index];
226
+ // int[] outgoing = new int[count - 1];
227
+ // System.arraycopy(data, 0, outgoing, 0, index);
228
+ // count--;
229
+ // System.arraycopy(data, index + 1, outgoing, 0, count - index);
230
+ // data = outgoing;
231
+ // For most cases, this actually appears to be faster
232
+ // than arraycopy() on an array copying into itself.
233
+ for (int i = index; i < count-1; i++) {
234
+ data[i] = data[i+1];
235
+ }
236
+ count--;
237
+ return entry;
238
+ }
239
+
240
+
241
+ // Remove the first instance of a particular value,
242
+ // and return the index at which it was found.
243
+ public int removeValue(int value) {
244
+ int index = index(value);
245
+ if (index != -1) {
246
+ remove(index);
247
+ return index;
248
+ }
249
+ return -1;
250
+ }
251
+
252
+
253
+ // Remove all instances of a particular value,
254
+ // and return the number of values found and removed
255
+ public int removeValues(int value) {
256
+ int ii = 0;
257
+ for (int i = 0; i < count; i++) {
258
+ if (data[i] != value) {
259
+ data[ii++] = data[i];
260
+ }
261
+ }
262
+ int removed = count - ii;
263
+ count = ii;
264
+ return removed;
265
+ }
266
+
267
+
268
+ /**
269
+ * Add a new entry to the list.
270
+ *
271
+ * @webref intlist:method
272
+ * @brief Add a new entry to the list
273
+ */
274
+ public void append(long value) {
275
+ if (count == data.length) {
276
+ data = PApplet.expand(data);
277
+ }
278
+ data[count++] = value;
279
+ }
280
+
281
+
282
+ public void append(int[] values) {
283
+ for (int v : values) {
284
+ append(v);
285
+ }
286
+ }
287
+
288
+
289
+ public void append(LongList list) {
290
+ for (long v : list.values()) { // will concat the list...
291
+ append(v);
292
+ }
293
+ }
294
+
295
+
296
+ /** Add this value, but only if it's not already in the list. */
297
+ public void appendUnique(int value) {
298
+ if (!hasValue(value)) {
299
+ append(value);
300
+ }
301
+ }
302
+
303
+
304
+ // public void insert(int index, int value) {
305
+ // if (index+1 > count) {
306
+ // if (index+1 < data.length) {
307
+ // }
308
+ // }
309
+ // if (index >= data.length) {
310
+ // data = PApplet.expand(data, index+1);
311
+ // data[index] = value;
312
+ // count = index+1;
313
+ //
314
+ // } else if (count == data.length) {
315
+ // if (index >= count) {
316
+ // //int[] temp = new int[count << 1];
317
+ // System.arraycopy(data, 0, temp, 0, index);
318
+ // temp[index] = value;
319
+ // System.arraycopy(data, index, temp, index+1, count - index);
320
+ // data = temp;
321
+ //
322
+ // } else {
323
+ // // data[] has room to grow
324
+ // // for() loop believed to be faster than System.arraycopy over itself
325
+ // for (int i = count; i > index; --i) {
326
+ // data[i] = data[i-1];
327
+ // }
328
+ // data[index] = value;
329
+ // count++;
330
+ // }
331
+ // }
332
+
333
+
334
+ public void insert(int index, long value) {
335
+ insert(index, new long[] { value });
336
+ }
337
+
338
+
339
+ // same as splice
340
+ public void insert(int index, long[] values) {
341
+ if (index < 0) {
342
+ throw new IllegalArgumentException("insert() index cannot be negative: it was " + index);
343
+ }
344
+ if (index >= data.length) {
345
+ throw new IllegalArgumentException("insert() index " + index + " is past the end of this list");
346
+ }
347
+
348
+ long[] temp = new long[count + values.length];
349
+
350
+ // Copy the old values, but not more than already exist
351
+ System.arraycopy(data, 0, temp, 0, Math.min(count, index));
352
+
353
+ // Copy the new values into the proper place
354
+ System.arraycopy(values, 0, temp, index, values.length);
355
+
356
+ // if (index < count) {
357
+ // The index was inside count, so it's a true splice/insert
358
+ System.arraycopy(data, index, temp, index+values.length, count - index);
359
+ count = count + values.length;
360
+ // } else {
361
+ // // The index was past 'count', so the new count is weirder
362
+ // count = index + values.length;
363
+ // }
364
+ data = temp;
365
+ }
366
+
367
+
368
+ public void insert(int index, LongList list) {
369
+ insert(index, list.values());
370
+ }
371
+
372
+
373
+ // below are aborted attempts at more optimized versions of the code
374
+ // that are harder to read and debug...
375
+
376
+ // if (index + values.length >= count) {
377
+ // // We're past the current 'count', check to see if we're still allocated
378
+ // // index 9, data.length = 10, values.length = 1
379
+ // if (index + values.length < data.length) {
380
+ // // There's still room for these entries, even though it's past 'count'.
381
+ // // First clear out the entries leading up to it, however.
382
+ // for (int i = count; i < index; i++) {
383
+ // data[i] = 0;
384
+ // }
385
+ // data[index] =
386
+ // }
387
+ // if (index >= data.length) {
388
+ // int length = index + values.length;
389
+ // int[] temp = new int[length];
390
+ // System.arraycopy(data, 0, temp, 0, count);
391
+ // System.arraycopy(values, 0, temp, index, values.length);
392
+ // data = temp;
393
+ // count = data.length;
394
+ // } else {
395
+ //
396
+ // }
397
+ //
398
+ // } else if (count == data.length) {
399
+ // int[] temp = new int[count << 1];
400
+ // System.arraycopy(data, 0, temp, 0, index);
401
+ // temp[index] = value;
402
+ // System.arraycopy(data, index, temp, index+1, count - index);
403
+ // data = temp;
404
+ //
405
+ // } else {
406
+ // // data[] has room to grow
407
+ // // for() loop believed to be faster than System.arraycopy over itself
408
+ // for (int i = count; i > index; --i) {
409
+ // data[i] = data[i-1];
410
+ // }
411
+ // data[index] = value;
412
+ // count++;
413
+ // }
414
+
415
+
416
+ /** Return the first index of a particular value. */
417
+ public int index(int what) {
418
+ /*
419
+ if (indexCache != null) {
420
+ try {
421
+ return indexCache.get(what);
422
+ } catch (Exception e) { // not there
423
+ return -1;
424
+ }
425
+ }
426
+ */
427
+ for (int i = 0; i < count; i++) {
428
+ if (data[i] == what) {
429
+ return i;
430
+ }
431
+ }
432
+ return -1;
433
+ }
434
+
435
+
436
+ // !!! TODO this is not yet correct, because it's not being reset when
437
+ // the rest of the entries are changed
438
+ // protected void cacheIndices() {
439
+ // indexCache = new HashMap<Integer, Integer>();
440
+ // for (int i = 0; i < count; i++) {
441
+ // indexCache.put(data[i], i);
442
+ // }
443
+ // }
444
+
445
+ /**
446
+ * @webref intlist:method
447
+ * @brief Check if a number is a part of the list
448
+ */
449
+ public boolean hasValue(int value) {
450
+ // if (indexCache == null) {
451
+ // cacheIndices();
452
+ // }
453
+ // return index(what) != -1;
454
+ for (int i = 0; i < count; i++) {
455
+ if (data[i] == value) {
456
+ return true;
457
+ }
458
+ }
459
+ return false;
460
+ }
461
+
462
+ /**
463
+ * @webref intlist:method
464
+ * @brief Add one to a value
465
+ */
466
+ public void increment(int index) {
467
+ if (count <= index) {
468
+ resize(index + 1);
469
+ }
470
+ data[index]++;
471
+ }
472
+
473
+
474
+ private void boundsProblem(int index, String method) {
475
+ final String msg = String.format("The list size is %d. " +
476
+ "You cannot %s() to element %d.", count, method, index);
477
+ throw new ArrayIndexOutOfBoundsException(msg);
478
+ }
479
+
480
+
481
+ /**
482
+ * @webref intlist:method
483
+ * @brief Add to a value
484
+ */
485
+ public void add(int index, int amount) {
486
+ if (index < count) {
487
+ data[index] += amount;
488
+ } else {
489
+ boundsProblem(index, "add");
490
+ }
491
+ }
492
+
493
+ /**
494
+ * @webref intlist:method
495
+ * @brief Subtract from a value
496
+ */
497
+ public void sub(int index, int amount) {
498
+ if (index < count) {
499
+ data[index] -= amount;
500
+ } else {
501
+ boundsProblem(index, "sub");
502
+ }
503
+ }
504
+
505
+ /**
506
+ * @webref intlist:method
507
+ * @brief Multiply a value
508
+ */
509
+ public void mult(int index, int amount) {
510
+ if (index < count) {
511
+ data[index] *= amount;
512
+ } else {
513
+ boundsProblem(index, "mult");
514
+ }
515
+ }
516
+
517
+ /**
518
+ * @webref intlist:method
519
+ * @brief Divide a value
520
+ */
521
+ public void div(int index, int amount) {
522
+ if (index < count) {
523
+ data[index] /= amount;
524
+ } else {
525
+ boundsProblem(index, "div");
526
+ }
527
+ }
528
+
529
+
530
+ private void checkMinMax(String functionName) {
531
+ if (count == 0) {
532
+ String msg =
533
+ String.format("Cannot use %s() on an empty %s.",
534
+ functionName, getClass().getSimpleName());
535
+ throw new RuntimeException(msg);
536
+ }
537
+ }
538
+
539
+
540
+ /**
541
+ * @webref intlist:method
542
+ * @brief Return the smallest value
543
+ */
544
+ public long min() {
545
+ checkMinMax("min");
546
+ long outgoing = data[0];
547
+ for (int i = 1; i < count; i++) {
548
+ if (data[i] < outgoing) outgoing = data[i];
549
+ }
550
+ return outgoing;
551
+ }
552
+
553
+
554
+ // returns the index of the minimum value.
555
+ // if there are ties, it returns the first one found.
556
+ public int minIndex() {
557
+ checkMinMax("minIndex");
558
+ long value = data[0];
559
+ int index = 0;
560
+ for (int i = 1; i < count; i++) {
561
+ if (data[i] < value) {
562
+ value = data[i];
563
+ index = i;
564
+ }
565
+ }
566
+ return index;
567
+ }
568
+
569
+
570
+ /**
571
+ * @webref intlist:method
572
+ * @brief Return the largest value
573
+ */
574
+ public long max() {
575
+ checkMinMax("max");
576
+ long outgoing = data[0];
577
+ for (int i = 1; i < count; i++) {
578
+ if (data[i] > outgoing) outgoing = data[i];
579
+ }
580
+ return outgoing;
581
+ }
582
+
583
+
584
+ // returns the index of the maximum value.
585
+ // if there are ties, it returns the first one found.
586
+ public int maxIndex() {
587
+ checkMinMax("maxIndex");
588
+ long value = data[0];
589
+ int index = 0;
590
+ for (int i = 1; i < count; i++) {
591
+ if (data[i] > value) {
592
+ value = data[i];
593
+ index = i;
594
+ }
595
+ }
596
+ return index;
597
+ }
598
+
599
+
600
+ public int sum() {
601
+ long amount = sumLong();
602
+ if (amount > Integer.MAX_VALUE) {
603
+ throw new RuntimeException("sum() exceeds " + Integer.MAX_VALUE + ", use sumLong()");
604
+ }
605
+ if (amount < Integer.MIN_VALUE) {
606
+ throw new RuntimeException("sum() less than " + Integer.MIN_VALUE + ", use sumLong()");
607
+ }
608
+ return (int) amount;
609
+ }
610
+
611
+
612
+ public long sumLong() {
613
+ long sum = 0;
614
+ for (int i = 0; i < count; i++) {
615
+ sum += data[i];
616
+ }
617
+ return sum;
618
+ }
619
+
620
+
621
+ /**
622
+ * Sorts the array in place.
623
+ *
624
+ * @webref intlist:method
625
+ * @brief Sorts the array, lowest to highest
626
+ */
627
+ public void sort() {
628
+ Arrays.sort(data, 0, count);
629
+ }
630
+
631
+
632
+ /**
633
+ * Reverse sort, orders values from highest to lowest.
634
+ *
635
+ * @webref intlist:method
636
+ * @brief Reverse sort, orders values from highest to lowest
637
+ */
638
+ public void sortReverse() {
639
+ new Sort() {
640
+ @Override
641
+ public int size() {
642
+ return count;
643
+ }
644
+
645
+ @Override
646
+ public int compare(int a, int b) {
647
+ long diff = data[b] - data[a];
648
+ return diff == 0 ? 0 : (diff < 0 ? -1 : 1);
649
+ }
650
+
651
+ @Override
652
+ public void swap(int a, int b) {
653
+ long temp = data[a];
654
+ data[a] = data[b];
655
+ data[b] = temp;
656
+ }
657
+ }.run();
658
+ }
659
+
660
+
661
+ // use insert()
662
+ // public void splice(int index, int value) {
663
+ // }
664
+
665
+
666
+ // public void subset(int start) {
667
+ // subset(start, count - start);
668
+ // }
669
+ //
670
+ //
671
+ // public void subset(int start, int num) {
672
+ // for (int i = 0; i < num; i++) {
673
+ // data[i] = data[i+start];
674
+ // }
675
+ // count = num;
676
+ // }
677
+
678
+ /**
679
+ * @webref intlist:method
680
+ * @brief Reverse the order of the list elements
681
+ */
682
+ public void reverse() {
683
+ int ii = count - 1;
684
+ for (int i = 0; i < count/2; i++) {
685
+ long t = data[i];
686
+ data[i] = data[ii];
687
+ data[ii] = t;
688
+ --ii;
689
+ }
690
+ }
691
+
692
+
693
+ /**
694
+ * Randomize the order of the list elements. Note that this does not
695
+ * obey the randomSeed() function in PApplet.
696
+ *
697
+ * @webref intlist:method
698
+ * @brief Randomize the order of the list elements
699
+ */
700
+ public void shuffle() {
701
+ Random r = new Random();
702
+ int num = count;
703
+ while (num > 1) {
704
+ int value = r.nextInt(num);
705
+ num--;
706
+ long temp = data[num];
707
+ data[num] = data[value];
708
+ data[value] = temp;
709
+ }
710
+ }
711
+
712
+
713
+ /**
714
+ * Randomize the list order using the random() function from the specified
715
+ * sketch, allowing shuffle() to use its current randomSeed() setting.
716
+ */
717
+ public void shuffle(PApplet sketch) {
718
+ int num = count;
719
+ while (num > 1) {
720
+ int value = (int) sketch.random(num);
721
+ num--;
722
+ long temp = data[num];
723
+ data[num] = data[value];
724
+ data[value] = temp;
725
+ }
726
+ }
727
+
728
+
729
+ public LongList copy() {
730
+ LongList outgoing = new LongList(data);
731
+ outgoing.count = count;
732
+ return outgoing;
733
+ }
734
+
735
+
736
+ /**
737
+ * Returns the actual array being used to store the data. For advanced users,
738
+ * this is the fastest way to access a large list. Suitable for iterating
739
+ * with a for() loop, but modifying the list will have terrible consequences.
740
+ */
741
+ public long[] values() {
742
+ crop();
743
+ return data;
744
+ }
745
+
746
+
747
+ @Override
748
+ public Iterator<Long> iterator() {
749
+ // public Iterator<Integer> valueIterator() {
750
+ return new Iterator<Long>() {
751
+ int index = -1;
752
+
753
+ public void remove() {
754
+ LongList.this.remove(index);
755
+ index--;
756
+ }
757
+
758
+ public Long next() {
759
+ return data[++index];
760
+ }
761
+
762
+ public boolean hasNext() {
763
+ return index+1 < count;
764
+ }
765
+ };
766
+ }
767
+
768
+
769
+ /**
770
+ * Create a new array with a copy of all the values.
771
+ *
772
+ * @return an array sized by the length of the list with each of the values.
773
+ * @webref intlist:method
774
+ * @brief Create a new array with a copy of all the values
775
+ */
776
+ public int[] array() {
777
+ return array(null);
778
+ }
779
+
780
+
781
+ /**
782
+ * Copy values into the specified array. If the specified array is null or
783
+ * not the same size, a new array will be allocated.
784
+ * @param array
785
+ */
786
+ public int[] array(int[] array) {
787
+ if (array == null || array.length != count) {
788
+ array = new int[count];
789
+ }
790
+ System.arraycopy(data, 0, array, 0, count);
791
+ return array;
792
+ }
793
+
794
+
795
+ // public int[] toIntArray() {
796
+ // int[] outgoing = new int[count];
797
+ // for (int i = 0; i < count; i++) {
798
+ // outgoing[i] = (int) data[i];
799
+ // }
800
+ // return outgoing;
801
+ // }
802
+
803
+
804
+ // public long[] toLongArray() {
805
+ // long[] outgoing = new long[count];
806
+ // for (int i = 0; i < count; i++) {
807
+ // outgoing[i] = (long) data[i];
808
+ // }
809
+ // return outgoing;
810
+ // }
811
+
812
+
813
+ // public float[] toFloatArray() {
814
+ // float[] outgoing = new float[count];
815
+ // System.arraycopy(data, 0, outgoing, 0, count);
816
+ // return outgoing;
817
+ // }
818
+
819
+
820
+ // public double[] toDoubleArray() {
821
+ // double[] outgoing = new double[count];
822
+ // for (int i = 0; i < count; i++) {
823
+ // outgoing[i] = data[i];
824
+ // }
825
+ // return outgoing;
826
+ // }
827
+
828
+
829
+ // public String[] toStringArray() {
830
+ // String[] outgoing = new String[count];
831
+ // for (int i = 0; i < count; i++) {
832
+ // outgoing[i] = String.valueOf(data[i]);
833
+ // }
834
+ // return outgoing;
835
+ // }
836
+
837
+
838
+ /**
839
+ * Returns a normalized version of this array. Called getPercent() for
840
+ * consistency with the Dict classes. It's a getter method because it needs
841
+ * to returns a new list (because IntList/Dict can't do percentages or
842
+ * normalization in place on int values).
843
+ */
844
+ public FloatList getPercent() {
845
+ double sum = 0;
846
+ for (float value : array()) {
847
+ sum += value;
848
+ }
849
+ FloatList outgoing = new FloatList(count);
850
+ for (int i = 0; i < count; i++) {
851
+ double percent = data[i] / sum;
852
+ outgoing.set(i, (float) percent);
853
+ }
854
+ return outgoing;
855
+ }
856
+
857
+
858
+ // /**
859
+ // * Count the number of times each entry is found in this list.
860
+ // * Converts each entry to a String so it can be used as a key.
861
+ // */
862
+ // public IntDict getTally() {
863
+ // IntDict outgoing = new IntDict();
864
+ // for (int i = 0; i < count; i++) {
865
+ // outgoing.increment(String.valueOf(data[i]));
866
+ // }
867
+ // return outgoing;
868
+ // }
869
+
870
+
871
+ public LongList getSubset(int start) {
872
+ return getSubset(start, count - start);
873
+ }
874
+
875
+
876
+ public LongList getSubset(int start, int num) {
877
+ int[] subset = new int[num];
878
+ System.arraycopy(data, start, subset, 0, num);
879
+ return new LongList(subset);
880
+ }
881
+
882
+
883
+ public String join(String separator) {
884
+ if (count == 0) {
885
+ return "";
886
+ }
887
+ StringBuilder sb = new StringBuilder();
888
+ sb.append(data[0]);
889
+ for (int i = 1; i < count; i++) {
890
+ sb.append(separator);
891
+ sb.append(data[i]);
892
+ }
893
+ return sb.toString();
894
+ }
895
+
896
+
897
+ public void print() {
898
+ for (int i = 0; i < count; i++) {
899
+ System.out.format("[%d] %d%n", i, data[i]);
900
+ }
901
+ }
902
+
903
+
904
+ /**
905
+ * Save tab-delimited entries to a file (TSV format, UTF-8 encoding)
906
+ */
907
+ public void save(File file) {
908
+ PrintWriter writer = PApplet.createWriter(file);
909
+ write(writer);
910
+ writer.close();
911
+ }
912
+
913
+
914
+ /**
915
+ * Write entries to a PrintWriter, one per line
916
+ */
917
+ public void write(PrintWriter writer) {
918
+ for (int i = 0; i < count; i++) {
919
+ writer.println(data[i]);
920
+ }
921
+ writer.flush();
922
+ }
923
+
924
+
925
+ /**
926
+ * Return this dictionary as a String in JSON format.
927
+ */
928
+ public String toJSON() {
929
+ return "[ " + join(", ") + " ]";
930
+ }
931
+
932
+
933
+ @Override
934
+ public String toString() {
935
+ return getClass().getSimpleName() + " size=" + size() + " " + toJSON();
936
+ }
937
+ }