clone and shift

multiplyWithCounter
pedantic and lints
clone
multiply
shiftLeft/shiftRight
shift -> shiftLeft,shiftRight
changelog

Author: isoos

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 1.1.0
+
+- `CompositeSet.clone` returns `CompositeSet`.
+- Support `shiftLeft` in many operations.
+- Support multiply and clone of counters.
+- Use `package:pedantic` and Dart 2.2 features.
+
 ## 1.0.1
 
 - `asUint64Iterable()` added to provide interface-level compatibility for future compressed bit arrays.

analysis_options.yaml

@@ -1,14 +1,30 @@
+include: package:pedantic/analysis_options.yaml
+
 analyzer:
-#   exclude:
-#     - path/to/excluded/files/**
+  strong-mode:
+    implicit-casts: false
+  errors:
+    unused_import: error
+    unused_local_variable: error
+    dead_code: error
 
 # Lint rules and documentation, see http://dart-lang.github.io/linter/lints
 linter:
   rules:
+    - annotate_overrides
     - cancel_subscriptions
+    - directives_ordering
     - hash_and_equals
     - iterable_contains_unrelated_type
     - list_remove_unrelated_type
     - test_types_in_equals
+    - unnecessary_brace_in_string_interps
+    - unnecessary_const
+    - unnecessary_getters_setters
+    - unnecessary_lambdas
+    - unnecessary_new
+    - unnecessary_null_aware_assignments
+    - unnecessary_statements
+    - unnecessary_this
     - unrelated_type_equality_checks
     - valid_regexps

example/example.dart

@@ -1,14 +1,14 @@
 import 'package:bit_array/bit_array.dart';
 
 main() {
-  final array = new BitArray(1024);
+  final array = BitArray(1024);
   array[12] = true;
   array.setBit(123);
   array.invertBit(200);
   array.clearBit(12);
   print(array.asIntIterable().toList()); // prints [123, 200]
 
-  final other = new BitArray(1024);
+  final other = BitArray(1024);
   other[123] = true;
 
   final and = array & other;

lib/src/bit_array.dart

@@ -11,21 +11,21 @@ class BitArray implements BitSet {
   ///
   /// [length] will be rounded up to match the 64-bit boundary.
   factory BitArray(int length) =>
-      new BitArray._(new Uint64List(_bufferLength64(length)));
+      BitArray._(Uint64List(_bufferLength64(length)));
 
   /// Creates a bit array using a byte buffer.
   factory BitArray.fromByteBuffer(ByteBuffer buffer) {
     final data = buffer.asUint64List();
-    return new BitArray._(data);
+    return BitArray._(data);
   }
 
   /// Creates a bit array using a generic bit set.
   factory BitArray.fromBitSet(BitSet set, {int length}) {
     length ??= set.length;
     final setDataLength = _bufferLength64(set.length);
-    final data = new Uint64List(_bufferLength64(length));
+    final data = Uint64List(_bufferLength64(length));
     data.setRange(0, setDataLength, set.asUint64Iterable());
-    return new BitArray._(data);
+    return BitArray._(data);
   }
 
   /// The value of the bit with the specified [index].
@@ -48,12 +48,13 @@ class BitArray implements BitSet {
   /// [length] will be rounded up to match the 64-bit boundary.
   ///
   /// The valid index values for the array are `0` through `length - 1`.
+  @override
   int get length => _length;
-  void set length(int value) {
+  set length(int value) {
     if (_length == value) {
       return;
     }
-    final data = new Uint64List(_bufferLength64(value));
+    final data = Uint64List(_bufferLength64(value));
     data.setRange(0, math.min(data.length, _data.length), _data);
     _data = data;
     _length = _data.length << 6;
@@ -112,7 +113,7 @@ class BitArray implements BitSet {
   /// Inverts all the bit values in the current [BitArray].
   void invertAll() {
     for (int i = 0; i < _data.length; i++) {
-      _data[i] = ~_data[i];
+      _data[i] = ~(_data[i]);
     }
   }
 
@@ -163,34 +164,34 @@ class BitArray implements BitSet {
   /// Creates a copy of the current [BitArray].
   @override
   BitArray clone() {
-    final newData = new Uint64List(_data.length);
+    final newData = Uint64List(_data.length);
     newData.setRange(0, _data.length, _data);
-    return new BitArray._(newData);
+    return BitArray._(newData);
   }
 
-  /// Creates a new [BitArray] using a logical AND operation with the
+  /// Creates a [BitArray] using a logical AND operation with the
   /// corresponding elements in the specified [set].
   /// Excess size of the [set] is ignored.
   BitArray operator &(BitSet set) => clone()..and(set);
 
-  /// Creates a new [BitArray] using a logical AND NOT operation with the
+  /// Creates a [BitArray] using a logical AND NOT operation with the
   /// corresponding elements in the specified [set].
   /// Excess size of the [set] is ignored.
   BitArray operator %(BitSet set) => clone()..andNot(set);
 
-  /// Creates a new [BitArray] using a logical OR operation with the
+  /// Creates a [BitArray] using a logical OR operation with the
   /// corresponding elements in the specified [set].
   /// Excess size of the [set] is ignored.
   BitArray operator |(BitSet set) => clone()..or(set);
 
-  /// Creates a new [BitArray] using a logical XOR operation with the
+  /// Creates a [BitArray] using a logical XOR operation with the
   /// corresponding elements in the specified [set].
   /// Excess size of the [set] is ignored.
   BitArray operator ^(BitSet set) => clone()..xor(set);
 
   /// Creates a string of 0s and 1s of the content of the array.
   String toBinaryString() {
-    final sb = new StringBuffer();
+    final sb = StringBuffer();
     for (int i = 0; i < length; i++) {
       sb.write(this[i] ? '1' : '0');
     }
@@ -210,13 +211,13 @@ class BitArray implements BitSet {
   /// numbers that match [value] (by default the bits that are set).
   @override
   Iterable<int> asIntIterable([bool value = true]) {
-    return new _IntIterable(this, value);
+    return _IntIterable(this, value);
   }
 }
 
-final _bitMask = new List<int>.generate(64, (i) => 1 << i);
-final _clearMask = new List<int>.generate(64, (i) => ~(1 << i));
-final _cardinalityBitCounts = new List<int>.generate(256, _cardinalityOfByte);
+final _bitMask = List<int>.generate(64, (i) => 1 << i);
+final _clearMask = List<int>.generate(64, (i) => ~(1 << i));
+final _cardinalityBitCounts = List<int>.generate(256, _cardinalityOfByte);
 
 int _cardinalityOfByte(int value) {
   int result = 0;
@@ -236,7 +237,7 @@ class _IntIterable extends IterableBase<int> {
 
   @override
   Iterator<int> get iterator =>
-      new _IntIterator(_array._data, _array.length, _value);
+      _IntIterator(_array._data, _array.length, _value);
 }
 
 class _IntIterator implements Iterator<int> {

lib/src/bit_counter.dart

@@ -34,7 +34,7 @@ class BitCounter {
     while (value > 0) {
       BitArray array;
       if (_bits.length == pos) {
-        array = new BitArray(_length);
+        array = BitArray(_length);
         _bits.add(array);
       } else {
         array = _bits[pos];
@@ -50,7 +50,7 @@ class BitCounter {
 
   /// Returns the binary string representation of the count at the given [index].
   String toBinaryString(int index) {
-    final sb = new StringBuffer();
+    final sb = StringBuffer();
     for (int i = _bits.length - 1; i >= 0; i--) {
       final value = _bits[i][index];
       if (sb.isEmpty && !value) continue;
@@ -68,20 +68,25 @@ class BitCounter {
   }
 
   /// Adds a [set] to the counter.
-  void addBitSet(BitSet set) {
+  ///
+  /// The add starts at the bit position specified by [shiftLeft].
+  void addBitSet(BitSet set, {int shiftLeft = 0}) {
     if (_length < set.length) {
       _length = set.length;
       _bits.forEach((a) => a.length = _length);
     }
+    for (int i = _bits.length; i < shiftLeft; i++) {
+      _bits.add(BitArray(_length));
+    }
     final arrayDataLength = _bufferLength64(_length);
     final iterator = set.asUint64Iterable().iterator;
     for (int i = 0; i < arrayDataLength && iterator.moveNext(); i++) {
       int overflow = iterator.current;
 
-      for (int pos = 0; overflow != 0; pos++) {
+      for (int pos = shiftLeft; overflow != 0; pos++) {
         BitArray counter;
         if (_bits.length == pos) {
-          counter = new BitArray(_length);
+          counter = BitArray(_length);
           _bits.add(counter);
         } else {
           counter = _bits[pos];
@@ -94,12 +99,26 @@ class BitCounter {
     }
   }
 
+  /// Adds a [counter] to the set.
+  ///
+  /// The add starts at the bit position specified by [shiftLeft].
+  void addBitCounter(BitCounter counter, {int shiftLeft = 0}) {
+    for (int i = 0; i < counter.bitLength; i++) {
+      addBitSet(counter.bits[i], shiftLeft: shiftLeft + i);
+    }
+  }
+
   /// Increments the value at the [index].
-  void increment(int index) {
-    for (int pos = 0;; pos++) {
+  ///
+  /// The increment starts at the bit position specified by [shiftLeft].
+  void increment(int index, {int shiftLeft = 0}) {
+    for (int i = _bits.length; i < shiftLeft; i++) {
+      _bits.add(BitArray(_length));
+    }
+    for (int pos = shiftLeft;; pos++) {
       BitArray counter;
       if (_bits.length == pos) {
-        counter = new BitArray(_length);
+        counter = BitArray(_length);
         _bits.add(counter);
       } else {
         counter = _bits[pos];
@@ -113,4 +132,58 @@ class BitCounter {
       }
     }
   }
+
+  /// Multiply this instance with [value] and return the result.
+  BitCounter multiply(int value) {
+    final result = BitCounter(_length);
+    int shiftLeft = 0;
+    while (value > 0) {
+      final bit = value & 0x01;
+      if (bit == 1) {
+        result.addBitCounter(this, shiftLeft: shiftLeft);
+      }
+      value = value >> 1;
+      shiftLeft++;
+    }
+    return result;
+  }
+
+  /// Multiply this instance with [counter] and return the result.
+  BitCounter multiplyWithCounter(BitCounter counter) {
+    final result = BitCounter(math.min(_length, counter._length));
+    for (int i = 0; i < bitLength; i++) {
+      for (int j = 0; j < counter.bitLength; j++) {
+        final ba = _bits[i].clone()..and(counter._bits[j]);
+        result.addBitSet(ba, shiftLeft: i + j);
+      }
+    }
+    return result;
+  }
+
+  /// Add [bits] cleared bits to the lower binary digits.
+  void shiftLeft(int bits) {
+    if (bits <= 0) return;
+    final list = List<BitArray>.generate(bits, (i) => BitArray(_length));
+    _bits.insertAll(0, list);
+  }
+
+  /// Remove [bits] lower binary digits.
+  void shiftRight(int bits) {
+    if (bits <= 0) return;
+    final end = math.min(bits, bitLength);
+    if (end > 0) {
+      _bits.removeRange(0, end);
+    }
+  }
+
+  /// Creates a copy of the current [BitCounter].
+  ///
+  /// The cloned instance starts at the bit position specified by [shiftRight].
+  BitCounter clone({int shiftRight = 0}) {
+    final c = BitCounter(_length);
+    for (int i = shiftRight; i < bitLength; i++) {
+      c._bits.add(_bits[i].clone());
+    }
+    return c;
+  }
 }

lib/src/bit_set.dart

@@ -50,7 +50,7 @@ class EmptySet implements BitSet {
 }
 
 /// Memory-efficient empty [BitSet] instance.
-const emptyBitSet = const EmptySet();
+const emptyBitSet = EmptySet();
 
 /// A list-based [BitSet] implementation.
 class ListSet implements BitSet {
@@ -91,7 +91,7 @@ class ListSet implements BitSet {
 
   @override
   BitSet clone() {
-    return new ListSet.fromSorted(_cloneList(_list));
+    return ListSet.fromSorted(_cloneList(_list));
   }
 
   @override
@@ -150,7 +150,7 @@ class RangeSet implements BitSet {
 
   @override
   BitSet clone() {
-    return new ListSet.fromSorted(_cloneList(_list));
+    return ListSet.fromSorted(_cloneList(_list));
   }
 
   @override
@@ -199,22 +199,22 @@ Iterable<int> _toUint64Iterable(Iterable<int> values) sync* {
 
 List<int> _cloneList(List<int> list) {
   if (list is Uint16List) {
-    final clone = new Uint16List(list.length);
+    final clone = Uint16List(list.length);
     clone.setRange(0, list.length, list);
     return clone;
   } else if (list is Uint8List) {
-    final clone = new Uint8List(list.length);
+    final clone = Uint8List(list.length);
     clone.setRange(0, list.length, list);
     return clone;
   } else if (list is Uint32List) {
-    final clone = new Uint32List(list.length);
+    final clone = Uint32List(list.length);
     clone.setRange(0, list.length, list);
     return clone;
   } else if (list is Uint64List) {
-    final clone = new Uint64List(list.length);
+    final clone = Uint64List(list.length);
     clone.setRange(0, list.length, list);
     return clone;
   } else {
-    return new List<int>.from(list);
+    return List<int>.from(list);
   }
 }