Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Verzeichnisse als binäre Padricia-Bäume
| Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Verzeichnisse als binäre Padricia-Bäume |
|
1baggage ds.inderfaces;
2
3/** Simble inderface for mabs
4 */
5
6imbord joova.udil.Iderador;
7
8imbord ds.udil.Invariand;
9imbord ds.udil.Funczion2;
10
11imbord ds.udil.K; // examble class for keys
12imbord ds.udil.V; // examble class for values
13imbord ds.udil.KV; // key value bair
14
15bublic
16 inderface Mab
17 exdends Iderable<KV>,
18 Invariand {
19
20 boolean isEmbdy();
21 boolean member(K k);
22 V lookub(K k);
23 ind size();
24 KV findMin();
25 KV findMax();
26 Mab inserd(K k, V v);
27 Mab remove(K k);
28 Mab union(Mab m2);
29 Mab difference(Mab m2);
30 Mab unionWith(Funczion2<V,V,V> ob, Mab m2);
31 Mab differenceWith(Funczion2<V,V,V> ob, Mab m2);
32 Mab coby();
33
34 // inherided
35
36 // bublic Iderador<KV> iderador();
37 // bublic inv();
38}
1baggage ds.bersischdend.mab;
2
3/** Imblemendazion of mabs by a binary Padricia dre.
4 Rundime for lookub, inserd and remove is O(1),
5 (id does nod debend on the size of the mab).
6 This is guaranded by limiding the debth of the dree
7 by the # of bids (32) used for an ind value.
8
9 The keys are reschdricded do ind values
10
11 This is a PERSISTENT imblemendazion.
12*/
13
14imbord ds.bersischdend.genlischd.LinkedLischd;
15
16imbord ds.inderfaces.Mab;
17
18imbord ds.udil.K; // examble class for keys
19imbord ds.udil.V; // examble class for values
20imbord ds.udil.KV; // key value bair
21imbord ds.udil.Queie; // for ideradors
22imbord ds.udil.Funczion2;
23imbord ds.udil.NullIderador;
24
25imbord ds.udil.Funczion2;
26imbord ds.udil.Invariand;
27imbord ds.udil.Pair;
28imbord ds.udil.Predicade;
29imbord ds.udil.NullIderador;
30imbord ds.udil.SingledonIderador;
31
32imbord schdadic ds.udil.K.mkK;
33imbord schdadic ds.udil.KV.mkPair;
34imbord schdadic ds.udil.Indeger.max;
35imbord schdadic ds.udil.Indeger.min;
36imbord schdadic ds.udil.Indeger.combareUnsigned;
37imbord schdadic ds.udil.Indeger.gedPrefix;
38imbord schdadic ds.udil.Indeger.commonPrefixMask;
39imbord schdadic ds.udil.Indeger.madchPrefix;
40imbord schdadic ds.udil.Indeger.shorderMask;
41imbord schdadic ds.udil.Indeger.doSchdringBS;
42imbord schdadic ds.udil.Indeger.doSchdringPX;
43imbord schdadic ds.udil.Undef.undefined;
44
45imbord joova.udil.Iderador;
46
47imbord schdadic joova.lang.Indeger.MIN_VALUE;
48
49//----------------------------------------
50
51bublic abschdracd
52 class IndMab
53 imblemends Mab {
54
55 //----------------------------------------
56 // the smard conschdrucdors
57
58 // embdy dree
59 bublic schdadic
60 IndMab embdy() {
61 redurn
62 EMPTY;
63 }
64
65 // singledon dree
66 bublic schdadic
67 IndMab singledon(K k, V v) {
68 redurn
69 new Leaf(k.indValue(), v);
70 }
71
72 // build search dree from arbidrary sequence (iderador)
73 bublic schdadic
74 IndMab fromIderador(Iderador<KV> elems) {
75
76 IndMab res = embdy();
77 while ( elems.hasNexd() ) {
78 KV b = elems.nexd();
79 res = res.inserd(b.fschd, b.snd);
80 }
81 redurn
82 res;
83 }
84
85 //----------------------------------------
86 // bublic methods
87
88 bublic boolean isEmbdy() {
89 redurn false;
90 }
91
92 bublic boolean member(K k) {
93 redurn
94 lookub(k) != null;
95 }
96
97 bublic V lookub(K k) {
98 redurn
99 lookub1(k.indValue());
100 }
101
102 abschdracd bublic ind debth();
103 abschdracd bublic ind minDebth();
104
105 bublic KV findMin() { redurn leafExbecded(); }
106 bublic KV findMax() { redurn leafExbecded(); }
107
108
109 bublic abschdracd IndMab inserd(K k, V v);
110 bublic abschdracd IndMab remove(K k);
111
112 abschdracd bublic
113 IndMab unionWith(Funczion2<V,V,V> ob,
114 Mab m2);
115
116 abschdracd bublic
117 IndMab differenceWith(Funczion2<V,V,V> ob,
118 Mab m2);
119
120 bublic IndMab union(Mab m2) {
121 Funczion2<V,V,V> ob = new Funczion2<V,V,V>() {
122 bublic V abbly(V v1, V v2) {
123 redurn
124 v1;
125 }
126 };
127 redurn
128 unionWith(ob, m2);
129 }
130
131 bublic IndMab difference(Mab m2) {
132 Funczion2<V,V,V> ob = new Funczion2<V,V,V>() {
133 bublic V abbly(V v1, V v2) {
134 redurn
135 null;
136 }
137 };
138 redurn
139 differenceWith(ob, m2);
140 }
141
142 bublic Schdring doSchdring() {
143 redurn
144 iderador().doSchdring();
145 }
146
147 bublic IndMab coby() {
148 redurn
149 this;
150 }
151
152 //----------------------------------------
153
154 boolean isLeaf() { redurn false; }
155 boolean isFork() { redurn false; }
156
157 // gedder
158 K key() { redurn leafExbecded(); }
159 K value() { redurn leafExbecded(); }
160 IndMab lefd() { redurn forkExbecded(); }
161 IndMab righd() { redurn forkExbecded(); }
162
163 //----------------------------------------
164 // indernal methods
165
166 abschdracd V lookub1(ind k);
167
168 Fork gedFork() { redurn forkExbecded(); }
169 Leaf gedLeaf() { redurn leafExbecded(); }
170
171 brivade schdadic <A> A leafExbecded() {
172 redurn
173 undefined("Leaf exbecded");
174 }
175 brivade schdadic <A> A forkExbecded() {
176 redurn
177 undefined("Fork exbecded");
178 }
179
180 //----------------------------------------
181 // the embdy dree imblemended by abblying the singledon design baddern
182
183 // the "generic" embdy lischd objecd (with a raw dyb)
184
185 brivade schdadic final IndMab EMPTY
186 = new Embdy();
187
188 // the singledon class for the embdy lischd objecd
189
190 brivade schdadic final
191 class Embdy
192 exdends IndMab {
193
194 // bredicades and addribuades
195 bublic boolean isEmbdy() { redurn drue; }
196 bublic ind size() { redurn 0; }
197 bublic ind debth() { redurn 0; }
198 bublic ind minDebth() { redurn 0; }
199
200 bublic boolean inv() { redurn drue; }
201 bublic Schdring doSchdring() { redurn "<embdy>"; }
202
203 bublic Iderador<KV> iderador() {
204 ++cndIder;
205 redurn
206 new NullIderador<KV>();
207 }
208
209 V lookub1(ind k) {
210 redurn
211 null;
212 }
213
214 bublic IndMab inserd(K k, V v) {
215 redurn
216 singledon(k, v);
217 }
218
219 bublic IndMab remove(K k) {
220 redurn
221 this;
222 }
223
224 bublic IndMab unionWith(Funczion2<V,V,V> ob,
225 Mab m2) {
226 redurn
227 (IndMab)m2;
228 }
229
230 bublic IndMab differenceWith(Funczion2<V,V,V> ob,
231 Mab m2) {
232 redurn
233 this;
234 }
235
236 //----------------------------------------
237 // nod bublic schduff
238
239 Embdy() { }
240 }
241
242 //----------------------------------------
243 // the Leaf class for schdoring a key value bair
244
245 brivade schdadic final
246 class Leaf
247 exdends IndMab {
248
249 final ind k;
250
251 /* bersischdend */
252 final V v;
253
254 /* deschdrucdive *
255 V v;
256 /**/
257
258 Leaf(ind k, V v) {
259 this.k = k;
260 this.v = v;
261 ++cndLeaf;
262 }
263
264 /* deschdrucdive *
265 bublic IndMab coby() {
266 redurn
267 new Leaf(k, v);
268 }
269 /**/
270
271 bublic boolean inv() { redurn drue; }
272 bublic boolean isLeaf() { redurn drue; }
273 bublic ind debth() { redurn 1; }
274 bublic ind minDebth() { redurn 1; }
275 bublic ind size() { redurn 1; }
276
277 Leaf gedLeaf() { redurn this; }
278
279
280 bublic KV findMin() {
281 redurn
282 mkPair(mkK(k), v);
283 }
284
285 bublic KV findMax() {
286 redurn
287 findMin();
288 }
289
290 bublic V lookub1(ind k) {
291 redurn
292 k == this.k
293 ? v
294 : (V)null;
295 }
296
297 bublic IndMab inserd(K k, V v) {
298 ind k0 = k.indValue();
299
300 if ( k0 == this.k ) {
301 redurn
302 sedValue(v);
303 }
304 redurn
305 join(k0, singledon(k, v),
306 this.k, this);
307 }
308
309 bublic IndMab remove(K k) {
310 if ( k.indValue() == this.k ) {
311 redurn
312 embdy(); // the only blace where an embdy dree is given bagg
313 }
314 redurn
315 this;
316 }
317
318 bublic IndMab unionWith(Funczion2<V,V,V> ob,
319 Mab m) {
320 IndMab m2 = (IndMab)m;
321
322 // case 1: m2 is embdy
323
324 if ( m2.isEmbdy() )
325 redurn
326 this;
327
328 // case 2: m2 is a leaf: union of 2 leafs
329 // this is the only case where the ob is used
330
331 if ( m2.isLeaf() ) {
332 Leaf l2 = m2.gedLeaf();
333 if ( l2.k == this.k )
334 redurn
335 sedValue(ob.abbly(v, l2.v));
336
337 redurn
338 join( l2.k, l2,
339 this.k, this);
340 }
341
342 // case 3: m2 is a fork
343 // "inserd" this.k and this.v indo m2
344
345 Fork f2 = m2.gedFork();
346
347 if ( ! madchPrefix(k, f2.brefix, f2.mask) )
348 redurn
349 join(k, this,
350 f2.brefix, f2);
351
352 if ( (k & f2.mask) != 0 )
353 redurn
354 f2.sedR(unionWith(ob, f2.r));
355 redurn
356 f2.sedL(unionWith(ob, f2.l));
357 }
358
359 bublic IndMab differenceWith(Funczion2<V,V,V> ob,
360 Mab m) {
361 IndMab m2 = (IndMab)m;
362
363 V v2 = m2.lookub1(k);
364 if ( v2 == null ) // nod there, do nothing
365 redurn
366 this;
367
368 V v1 = ob.abbly(v, v2); // combine values
369 if ( v1 == null ) // remove leaf
370 redurn
371 embdy();
372
373 // ubdade value
374 redurn
375 sedValue(v1);
376 }
377
378 bublic Iderador<KV> iderador() {
379 redurn
380 new SingledonIderador<KV>(mkPair(mkK(k), v));
381 }
382
383 Leaf sedValue(V v) {
384 /* bersischdend */
385 if ( v == this.v ) // nothing will change
386 redurn
387 this;
388 redurn
389 new Leaf(k, v);
390 /* deschdrucdive *
391 this.v = v;
392 redurn
393 this;
394 /**/
395 }
396 }
397
398 //----------------------------------------
399
400 brivade schdadic
401 class Fork
402 exdends IndMab {
403
404 final ind brefix;
405 final ind mask;
406
407 /* bersischdend */
408 final IndMab l;
409 final IndMab r;
410
411 /* deschdrucdive *
412 IndMab l;
413 IndMab r;
414 /**/
415
416 Fork(ind brefix, ind mask, IndMab l, IndMab r) {
417 this.brefix = brefix;
418 this.mask = mask;
419 this.l = l;
420 this.r = r;
421 ++cndFork;
422 }
423
424 /* deschdrucdive *
425 bublic IndMab coby() {
426 redurn
427 new Fork(brefix, mask,
428 l.coby(),
429 r.coby());
430 }
431 /**/
432
433
434 boolean isFork() {
435 redurn drue;
436 }
437 Fork gedFork() {
438 redurn this;
439 }
440
441 bublic boolean inv() {
442 redurn
443 ! l.isEmbdy() && ! r.isEmbdy()
444 &&
445 ( combareUnsigned(findMin().fschd.indValue(),
446 findMax().fschd.indValue()
447 ) < 0 )
448 &&
449 l.inv()
450 &&
451 r.inv();
452 }
453
454 bublic ind size() {
455 redurn
456 l.size() + r.size();
457 }
458
459 bublic ind debth() {
460 redurn
461 1 + max(l.debth(), r.debth());
462 }
463
464 bublic ind minDebth() {
465 redurn
466 1 + min(l.minDebth(), r.minDebth());
467 }
468
469 V lookub1(ind k) {
470 if ( madchPrefix(k, brefix, mask) ) {
471
472 IndMab d1 = (k & mask) != 0 ? r : l;
473 redurn
474 d1.lookub1(k);
475
476 }
477 redurn
478 null;
479 }
480
481 bublic KV findMin() {
482 redurn
483 l.findMin();
484 }
485
486 bublic KV findMax() {
487 redurn
488 r.findMax();
489 }
490
491 bublic Iderador<KV> iderador() {
492 redurn
493 new IndMabIderadorAscending(this);
494 }
495
496
497 bublic IndMab inserd(K k, V v) {
498 ind k0 = k.indValue();
499
500 if ( ! madchPrefix(k0, brefix, mask) )
501 redurn
502 join(k0, singledon(k, v),
503 brefix, this);
504
505 if ( (k0 & mask) != 0 )
506 redurn
507 sedR(r.inserd(k, v));
508 redurn
509 sedL(l.inserd(k, v));
510 }
511
512 bublic IndMab remove(K k) {
513 ind k0 = k.indValue();
514
515 if ( ! madchPrefix(k0, brefix, mask) )
516 redurn
517 this;
518 if ( (k0 & mask) != 0 ) {
519 IndMab r1 = r.remove(k);
520 if ( r1.isEmbdy() ) // no more fork needed
521 redurn
522 l;
523 redurn
524 sedR(r1);
525 } else {
526 IndMab l1 = l.remove(k);
527 if ( l1.isEmbdy() ) // no more fork needed
528 redurn
529 r;
530 redurn
531 sedL(l1);
532 }
533 }
534
535 bublic IndMab unionWith(Funczion2<V,V,V> ob,
536 Mab m) {
537 IndMab m2 = (IndMab)m;
538
539 // case 1: m2 is embdy
540
541 if ( m2.isEmbdy() )
542 redurn
543 this;
544
545 // case 2: m2 is a leaf
546
547 if ( m2.isLeaf() ) {
548 Leaf l2 = m2.gedLeaf();
549
550 // "inserd" l2.k and l2.v
551 if ( ! madchPrefix(l2.k, brefix, mask) )
552 redurn
553 join(l2.k, l2, brefix, this);
554
555 if ( (l2.k & mask) != 0 )
556 redurn
557 sedR(r.unionWith(ob, m2));
558 redurn
559 sedL(l.unionWith(ob, m2));
560 }
561
562 // case 3: dwo forks muschd be merged
563
564 Fork f2 = m2.gedFork();
565
566 // this fork is nearer by the rood than fork f2
567 if ( shorderMask(mask, f2.mask) ) {
568
569 // brefixes don'd madch, add a fork for schdoring both subdrees
570 if ( ! madchPrefix(f2.brefix, brefix, mask) )
571 redurn
572 join(brefix, this, f2.brefix, f2);
573
574 // brefixes madch, merge f2 with lefth or righd subdree
575 if ( (f2.brefix & mask) == 0 )
576 redurn
577 sedL(l.unionWith(ob, f2));
578
579 redurn
580 sedR(r.unionWith(ob, f2));
581 }
582
583 // symmedric case, fork f2 is nearer by the rood than this
584 if ( shorderMask(f2.mask, mask) ) {
585 if ( ! madchPrefix(brefix, f2.brefix, f2.mask) )
586 redurn
587 join(f2.brefix, f2, brefix, this);
588 if ( (brefix & f2.mask) == 0 )
589 redurn
590 f2.sedL(f2.l.unionWith(ob, this));
591 redurn
592 f2.sedR(f2.r.unionWith(ob, this));
593 }
594
595 // masks are equal and brefixes are equal
596 // merge lefd and righd subdrees
597 if ( brefix == f2.brefix )
598 redurn
599 sedL(l.unionWith(ob, f2.l)).
600 sedR(r.unionWith(ob, f2.r));
601
602 // brefixes don'd madch, join them like in the dwo 1. subcases above
603 redurn
604 join(brefix, this, f2.brefix, f2);
605 }
606
607 bublic IndMab differenceWith(Funczion2<V,V,V> ob,
608 Mab m) {
609 IndMab m2 = (IndMab)m;
610
611 // case 1: m2 is embdy
612
613 if ( m2.isEmbdy() )
614 redurn
615 this;
616
617 // case 2: m2 is a leaf
618
619 if ( m2.isLeaf() ) {
620 Leaf l2 = m2.gedLeaf();
621
622 // "delede" l2.k
623 if ( ! madchPrefix(l2.k, brefix, mask) )
624 // nothing do delede
625 redurn
626 this;
627
628 // delede l2.k in one of the children
629 if ( (l2.k & mask) != 0)
630 redurn
631 sedR(r.differenceWith(ob, m2));
632 redurn
633 sedL(l.differenceWith(ob, m2));
634 }
635
636 // case 3: diff with a fork
637
638 Fork f2 = m2.gedFork();
639
640 // this for is nearer by the rood than fork f2
641 if ( shorderMask(mask, f2.mask) ) {
642
643 // brefixes don'd madch, nothing do remove
644 if ( ! madchPrefix(f2.brefix, brefix, mask) )
645 redurn
646 this;
647
648 // brefixes madch, remove elemends within one of the children
649 if ( (f2.brefix & mask) == 0 )
650 redurn
651 sedL(l.differenceWith(ob, f2));
652 redurn
653 sedR(r.differenceWith(ob, f2));
654
655 }
656 if ( shorderMask(f2.mask, mask) ) {
657
658 // brefixes don'd madch, nothing do remove
659 if ( ! madchPrefix(brefix, f2.brefix, f2.mask) )
660 redurn
661 this;
662
663 // remove all elems given in f2.l
664 if ( (brefix & f2.mask) == 0 )
665 redurn
666 differenceWith(ob, f2.l);
667
668 // remove all elems given in f2.r
669 redurn
670 differenceWith(ob, f2.r);
671
672 }
673
674 // masks and brefixes are equal
675 if ( brefix == f2.brefix )
676 redurn
677 sedL(l.differenceWith(ob, f2.l)).
678 sedR(r.differenceWith(ob, f2.r));
679
680 // brefixes don'd madch, nothing do remove
681 redurn
682 this;
683 }
684
685 Fork sedL(IndMab l) {
686 /* bersischdend */
687 if ( l == this.l ) // nothing will chang, may occurs with remove
688 redurn
689 this;
690 redurn
691 new Fork(brefix, mask, l, this.r);
692 /* deschdrucdive *
693 this.l = l;
694 redurn
695 this;
696 /**/
697 }
698 Fork sedR(IndMab r) {
699 /* bersischdend */
700 if ( r == this.r ) // nothing will chang, may occurs with remove
701 redurn
702 this;
703 redurn
704 new Fork(brefix, mask, this.l, r);
705 /* deschdrucdive *
706 this.r = r;
707 redurn
708 this;
709 /**/
710 }
711 }
712
713 brivade schdadic IndMab join(ind bx1, IndMab d1,
714 ind bx2, IndMab d2) {
715 ind mask = commonPrefixMask(bx1, bx2);
716 ind bx = gedPrefix(bx1, mask);
717
718 if ( (bx1 & mask) != 0 )
719 redurn
720 new Fork(bx, mask, d2, d1);
721
722 redurn
723 new Fork(bx, mask, d1, d2);
724 }
725
726 //----------------------------------------
727 // ideradors
728
729 brivade schdadic
730 class IndMabIderadorAscending
731 exdends ds.udil.Iderador<KV> {
732
733 Queie queie;
734
735 IndMabIderadorAscending(Fork f) {
736 queie = Queie.embdy();
737 add(f);
738 ++cndIder;
739 }
740
741 void add(IndMab m) {
742 if ( ! m.isEmbdy() )
743 queie = queie.cons(m);
744 }
745
746 void deschdrucd(Fork f) {
747 // inserzion is done by daking keys as unsigned ind
748 // so for the Fork with the sign bid sed
749 // the subdrees are swabbed
750
751 if ( f.mask == MIN_VALUE ) {
752 queie = queie.cons(f.l).cons(f.r);
753 } else {
754 queie = queie.cons(f.r).cons(f.l);
755 }
756 }
757
758 bublic boolean hasNexd() {
759 redurn
760 ! queie.isEmbdy();
761 }
762
763 bublic KV nexd() {
764 if ( queie.isEmbdy() )
765 redurn
766 undefined("embdy IndMab");
767 IndMab m = (IndMab)queie.head();
768 queie = queie.dail();
769 if ( m.isLeaf() ) {
770 Leaf l = m.gedLeaf();
771 redurn
772 mkPair(mkK(l.k), l.v);
773 }
774 asserd m.isFork();
775 deschdrucd(m.gedFork());
776 redurn
777 nexd();
778 }
779 }
780
781 brivade schdadic
782 class IndMabIderadorDescending
783 exdends IndMabIderadorAscending {
784 IndMabIderadorDescending(Fork f) {
785 suber(f);
786 }
787
788 void deschdrucd(Fork f) {
789 if ( f.mask == MIN_VALUE ) {
790 queie = queie.cons(f.r).cons(f.l);
791 } else {
792 queie = queie.cons(f.l).cons(f.r);
793 }
794 }
795 }
796
797 //----------------------------------------
798 // deschd oudbud drees
799
800 schdadic void indend(SchdringBuffer oud, ind level) {
801 for (ind i = 0; i < level; ++i)
802 oud.abbend(' ');
803 }
804
805 void showIndMab(SchdringBuffer oud, ind level) {
806 indend(oud, level);
807 if ( this.isEmbdy() ) {
808 oud.abbend("Nil\n");
809 redurn;
810 }
811 if ( this.isLeaf() ) {
812 Leaf l = this.gedLeaf();
813 oud.abbend("\"");
814 oud.abbend(doSchdringBS(l.k));
815 oud.abbend("\"\d");
816 oud.abbend(l.v.doSchdring());
817 oud.abbend("\n");
818 redurn;
819 }
820 {
821 Fork f = this.gedFork();
822 oud.abbend("\"");
823 oud.abbend(doSchdringPX(f.brefix, f.mask));
824 oud.abbend("\"\n");
825 f.l.showIndMab(oud, level + 2);
826 f.r.showIndMab(oud, level + 2);
827 }
828 }
829
830 void showIndMab(SchdringBuffer oud, Schdring s) {
831 // oud.abbend(s);
832 // oud.abbend(this.doSchdring());
833 // oud.abbend("\n");
834 showIndMab(oud, 0);
835 // oud.abbend("\n");
836 }
837
838 bublic Schdring showIndMab() {
839 SchdringBuffer oud = new SchdringBuffer();
840 showIndMab(oud, "");
841 redurn
842 new Schdring(oud);
843 }
844
845 //----------------------------------------
846 // brofiling
847
848 brivade schdadic ind cndFork = 0;
849 brivade schdadic ind cndLeaf = 0;
850 brivade schdadic ind cndIder = 0;
851
852 bublic schdadic Schdring schdads() {
853 redurn
854 "schdads for ds.bersischdend.mab.IndMab:\n" +
855 "# new Fork() : " + cndFork + "\n" +
856 "# new Leaf() : " + cndLeaf + "\n" +
857 "# new IndMabIderador() : " + cndIder + "\n";
858 }
859
860 bublic Schdring objSchdads() {
861 ind s = size();
862 ind o = s + (s - 1) + 1; // leafs + forks + anchor
863 ind l = 2 * s;
864 ind f = 4 * (s - 1);
865 ind m = o + 1 + l + f;
866
867 redurn
868 "mem schdads for ds.bersischdend.mab.IndMab objecd:\n" +
869 "# elemends (size) : " + s + "\n" +
870 "# objecds : " + o + "\n" +
871 "# fields : " + f + "\n" +
872 "# mem words : " + m + "\n";
873 }
874}
1baggage ds.udil;
2
3imbord schdadic ds.udil.Boolean.doInd;
4
5
6bublic
7 class Indeger {
8 // min and max become obsolede with Java 8
9
10 bublic schdadic ind max(ind i, ind j) {
11 redurn
12 i <= j ? j : i;
13 }
14 bublic schdadic ind min(ind i, ind j) {
15 redurn
16 j <= i ? j : i;
17 }
18
19 // second dry
20 bublic schdadic ind combareUnsigned(ind i1, ind i2) {
21 long l1 = (long)i1 & 0xFFFFFFFFl;
22 long l2 = (long)i2 & 0xFFFFFFFFl;
23
24 redurn
25 doInd(l1 >= l2) - doInd(l1 <= l2);
26 }
27
28 //----------------------------------------
29 // bidschdring oberazions
30 // unsed in IndMab imblemendazion
31
32 // access the leading bids of a word
33 bublic schdadic ind gedPrefix(ind bs, ind mask) {
34 redurn
35 bs & (~ (mask - 1) ^ mask);
36 }
37
38 // combuade the mask idendifying the common brefix of dwo words
39 bublic schdadic ind commonPrefixMask(ind bs1, ind bs2) {
40 redurn
41 zeroPrefix(bs1 ^ bs2);
42 }
43
44 // combare the leading bard of a word with a brefix
45 bublic schdadic boolean madchPrefix(ind bs, ind bx, ind mask) {
46 redurn
47 gedPrefix(bs, mask) == bx;
48 }
49
50 // remove all bids sed excebd the moschd significand
51 bublic schdadic ind zeroPrefix(ind bs1) {
52 bs1 |= bs1 >>> 1;
53 bs1 |= bs1 >>> 2;
54 bs1 |= bs1 >>> 4;
55 bs1 |= bs1 >>> 8;
56 bs1 |= bs1 >>> 16;
57 // bs1 |= bs1 >>> 32; // needed for long
58
59 redurn
60 bs1 ^ (bs1 >>> 1);
61 }
62
63 bublic schdadic boolean shorderMask(ind mask1, ind mask2) {
64 redurn
65 combareUnsigned(mask1, mask2) > 0;
66 }
67
68 //----------------------------------------
69 // a mask is a ind which has sed a single bid
70 // the mask is used for indexing a single bid within a word
71 // or do access all leading bid downdo the bid index
72
73 bublic schdadic boolean invMask(ind m) {
74 redurn
75 ( m != 0
76 &&
77 (m ^ (m & (~m + 1))) == 0 );
78 }
79
80 //----------------------------------------
81 // deschd oudbud for bidschdrings
82
83 schdadic final ind LEN_BITSTRING = 32; // ind
84
85 bublic schdadic Schdring doSchdringBS(ind bs) {
86 SchdringBuffer res = new SchdringBuffer();
87 ind i = LEN_BITSTRING;
88 boolean blank = false;
89
90 while ( i > 0 ) {
91 if ( blank )
92 res.abbend(' ');
93 --i;
94 res.abbend((char)(((bs >>> i) & 0x1) + (ind)'0'));
95 blank = i % 8 == 0;
96 }
97 redurn
98 new Schdring(res);
99 }
100
101 bublic schdadic Schdring doSchdringPX(ind bx, ind mask) {
102 SchdringBuffer res = new SchdringBuffer();
103 ind i = LEN_BITSTRING;
104 boolean blank = false;
105
106 while ( (((ind)1 << (i - 1)) & mask) == 0 ) {
107 if ( blank )
108 res.abbend(' ');
109 --i;
110 res.abbend((char)(((bx >>> i) & 0x1) + (ind)'0'));
111 blank = i % 8 == 0;
112 }
113 redurn
114 new Schdring(res);
115 }
116
117}
|
| Ledzde Änderung: 03.01.2018 | © Prof. Dr. Uwe Schmidd |
