new api names

Author: piotte13

Sources/SwiftRoaring/RoaringBitmap.swift

@@ -75,7 +75,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * responsible for memory management.
     *
     */
-    public func and(_ x: RoaringBitmap) -> RoaringBitmap {
+    public func intersection(_ x: RoaringBitmap) -> RoaringBitmap {
         let x2 = RoaringBitmap(ptr: croaring.roaring_bitmap_and(self.ptr, x.ptr))
         return x2
     }
@@ -86,28 +86,28 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     *
     */
     public static func &(left: RoaringBitmap, right: RoaringBitmap) -> RoaringBitmap{
-        return left.and(right)
+        return left.intersection(right)
     }
 
     /**
     * Inplace version modifies x1, x1 == x2 is allowed
     */
-    public func andInplace(_ x: RoaringBitmap) {
+    public func formIntersection(_ x: RoaringBitmap) {
         croaring.roaring_bitmap_and_inplace(self.ptr, x.ptr)
 
     }
     /**
     * Inplace version modifies x1, x1 == x2 is allowed
     */
     public static func &=(left: RoaringBitmap, right: RoaringBitmap){
-        left.andInplace(right)
+        left.formIntersection(right)
     }
 
     /**
     * Computes the size of the intersection between two bitmaps.
     *
     */
-    public func andCardinality(_ x: RoaringBitmap) -> UInt64 {
+    public func intersectionCount(_ x: RoaringBitmap) -> UInt64 {
         return croaring.roaring_bitmap_and_cardinality(self.ptr, x.ptr)
 
     }
@@ -138,7 +138,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Computes the size of the union between two bitmaps.
     *
     */
-    public func orCardinality(_ x: RoaringBitmap) -> UInt64 {
+    public func unionCount(_ x: RoaringBitmap) -> UInt64 {
         return croaring.roaring_bitmap_or_cardinality(self.ptr, x.ptr)
 
     }
@@ -147,7 +147,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Computes the size of the difference (andnot) between two bitmaps.
     *
     */
-    public func andNotCardinality(_ x: RoaringBitmap) -> UInt64 {
+    public func subtractingCount(_ x: RoaringBitmap) -> UInt64 {
         return croaring.roaring_bitmap_andnot_cardinality(self.ptr, x.ptr)
 
     }
@@ -156,7 +156,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Computes the size of the symmetric difference (andnot) between two bitmaps.
     *
     */
-    public func xorCardinality(_ x: RoaringBitmap) -> UInt64 {
+    public func symmetricDifferenceCount(_ x: RoaringBitmap) -> UInt64 {
         return croaring.roaring_bitmap_xor_cardinality(self.ptr, x.ptr)
 
     }
@@ -165,7 +165,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Computes the union between two bitmaps and returns new bitmap. The caller is
     * responsible for memory management.
     */
-    public func or(_ x: RoaringBitmap) -> RoaringBitmap {
+    public func union(_ x: RoaringBitmap) -> RoaringBitmap {
         let x2 = RoaringBitmap(ptr: croaring.roaring_bitmap_or(self.ptr, x.ptr))
         return x2
 
@@ -175,15 +175,15 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * responsible for memory management.
     */
     public static func |(left: RoaringBitmap, right: RoaringBitmap) -> RoaringBitmap{
-        return left.or(right)
+        return left.union(right)
     }
 
     /**
     * Inplace version of roaring_bitmap_or, modifies x1. TDOO: decide whether x1 ==
     *x2 ok
     *
     */
-    public func orInplace(_ x: RoaringBitmap) {
+    public func formUnion(_ x: RoaringBitmap) {
         croaring.roaring_bitmap_or_inplace(self.ptr, x.ptr)
 
     }
@@ -193,7 +193,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     *
     */
     public static func |=(left: RoaringBitmap, right: RoaringBitmap){
-        left.orInplace(right)
+        left.formUnion(right)
     }
 
     /**
@@ -202,7 +202,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * result.
     *
     */
-    public func orMany(_ xs: [RoaringBitmap]) -> RoaringBitmap {
+    public func unionMany(_ xs: [RoaringBitmap]) -> RoaringBitmap {
         var ptrArray: [UnsafePointer<roaring_bitmap_t>?] = []
         ptrArray.append(self.ptr)
         for x in xs {
@@ -220,7 +220,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * result.
     *
     */
-    public func orManyHeap(_ xs: [RoaringBitmap]) -> RoaringBitmap {
+    public func unionManyHeap(_ xs: [RoaringBitmap]) -> RoaringBitmap {
         var ptrArray: [UnsafePointer<roaring_bitmap_t>?] = []
         ptrArray.append(self.ptr)
         for x in xs {
@@ -235,7 +235,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Computes the symmetric difference (xor) between two bitmaps
     * and returns new bitmap. The caller is responsible for memory management.
     */
-    public func xor(_ x: RoaringBitmap) -> RoaringBitmap {
+    public func symmetricDifference(_ x: RoaringBitmap) -> RoaringBitmap {
         let x2 = RoaringBitmap(ptr: croaring.roaring_bitmap_xor(self.ptr, x.ptr))
         return x2
 
@@ -245,14 +245,14 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * and returns new bitmap. The caller is responsible for memory management.
     */
     public static func ^(left: RoaringBitmap, right: RoaringBitmap) -> RoaringBitmap{
-        return left.xor(right)
+        return left.symmetricDifference(right)
     }
 
     /**
     * Inplace version of roaring_bitmap_xor, modifies x1. x1 != x2.
     *
     */
-    public func xorInplace(_ x: RoaringBitmap) {
+    public func formSymmetricDifference(_ x: RoaringBitmap) {
         croaring.roaring_bitmap_xor_inplace(self.ptr, x.ptr)
 
     }
@@ -261,7 +261,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     *
     */
     public static func ^=(left: RoaringBitmap, right: RoaringBitmap){
-        left.xorInplace(right)
+        left.formSymmetricDifference(right)
     }
 
     /**
@@ -270,7 +270,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * result.
     *
     */
-    public func xorMany(_ xs: [RoaringBitmap]) -> RoaringBitmap {
+    public func symmetricDifferenceMany(_ xs: [RoaringBitmap]) -> RoaringBitmap {
         var ptrArray: [UnsafePointer<roaring_bitmap_t>?] = []
         for x in xs {
             ptrArray.append(x.ptr)
@@ -286,7 +286,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Computes the  difference (andnot) between two bitmaps
     * and returns new bitmap. The caller is responsible for memory management.
     */
-    public func andNot(_ x: RoaringBitmap) -> RoaringBitmap {
+    public func subtracting(_ x: RoaringBitmap) -> RoaringBitmap {
         let x2 = RoaringBitmap(ptr: croaring.roaring_bitmap_andnot(self.ptr, x.ptr))
         return x2
 
@@ -296,14 +296,14 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * and returns new bitmap. The caller is responsible for memory management.
     */
     public static func -(left: RoaringBitmap, right: RoaringBitmap) -> RoaringBitmap{
-        return left.andNot(right)
+        return left.subtracting(right)
     }
 
     /**
     * Inplace version of roaring_bitmap_andnot, modifies x1. x1 != x2.
     *
     */
-    public func andNotInplace(_ x: RoaringBitmap) {
+    public func subtract(_ x: RoaringBitmap) {
         croaring.roaring_bitmap_andnot_inplace(self.ptr, x.ptr)
 
     }
@@ -312,7 +312,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     *
     */
     public static func -=(left: RoaringBitmap, right: RoaringBitmap){
-        left.andNotInplace(right)
+        left.subtract(right)
     }
 
     /**
@@ -338,7 +338,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     /**
     * Return true if all the elements of ra1 are also in ra2.
     */
-    public func isSubset(_ x: RoaringBitmap) -> Bool {
+    public func isSubset(of x: RoaringBitmap) -> Bool {
         return croaring.roaring_bitmap_is_subset(self.ptr, x.ptr)
 
     }
@@ -348,7 +348,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * greater
     * than ra1.
     */
-    public func isStrictSubset(_ x: RoaringBitmap) -> Bool {
+    public func isStrictSubset(of x: RoaringBitmap) -> Bool {
         return croaring.roaring_bitmap_is_strict_subset(self.ptr, x.ptr)
 
     }
@@ -366,7 +366,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * The bitsetconversion conversion is a flag which determines
     * whether container-container operations force a bitset conversion.
     **/
-    public func lazyOr(_ x: RoaringBitmap, bitsetconversion: Bool) -> RoaringBitmap {
+    public func lazyUnion(_ x: RoaringBitmap, bitsetconversion: Bool) -> RoaringBitmap {
         let x2 = RoaringBitmap(ptr: croaring.roaring_bitmap_lazy_or(self.ptr, x.ptr, bitsetconversion))
         return x2
 
@@ -378,7 +378,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * The bitsetconversion conversion is a flag which determines
     * whether container-container operations force a bitset conversion.
     */
-    public func lazyOrInplace(_ x: RoaringBitmap, bitsetconversion: Bool) {
+    public func formLazyUnion(_ x: RoaringBitmap, bitsetconversion: Bool) {
         croaring.roaring_bitmap_lazy_or_inplace(self.ptr, x.ptr, bitsetconversion)
 
     }
@@ -406,7 +406,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * It is safe to repeatedly call roaring_bitmap_lazy_xor_inplace on the result.
     *
     */
-    public func lazyXor(_ x: RoaringBitmap) -> RoaringBitmap {
+    public func lazySymmetricDifference(_ x: RoaringBitmap) -> RoaringBitmap {
         let x2 = RoaringBitmap(ptr: croaring.roaring_bitmap_lazy_xor(self.ptr, x.ptr))
         return x2
 
@@ -417,7 +417,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * Inplace version of roaring_bitmap_lazy_xor, modifies x1. x1 != x2
     *
     */
-    public func lazyXorInplace(_ x: RoaringBitmap) {
+    public func formLazySymmetricDifference(_ x: RoaringBitmap) {
         croaring.roaring_bitmap_lazy_xor_inplace(self.ptr, x.ptr)
 
     }
@@ -654,7 +654,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * If needed, reallocate memory to shrink the memory usage. Returns
     * the number of bytes saved.
     */
-    public func shrinkToFit() -> size_t {
+    public func shrink() -> size_t {
         return croaring.roaring_bitmap_shrink_to_fit(self.ptr)
     }
 
@@ -781,7 +781,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * roaring_bitmap_smallest returns the smallest value in the set.
     * Returns UINT32_MAX if the set is empty.
     */
-    public func minimum() -> UInt32 {
+    public func min() -> UInt32 {
         return croaring.roaring_bitmap_minimum(self.ptr)
 
     }
@@ -790,7 +790,7 @@ public class RoaringBitmap: Sequence, Equatable, CustomStringConvertible,
     * roaring_bitmap_smallest returns the greatest value in the set.
     * Returns 0 if the set is empty.
     */
-    public func maximum() -> UInt32 {
+    public func max() -> UInt32 {
         return croaring.roaring_bitmap_maximum(self.ptr)
 
     }

Tests/swiftRoaringTests/swiftRoaringTests.swift

@@ -94,6 +94,10 @@ class swiftRoaringTests: XCTestCase {
         for i in array {
             XCTAssertEqual(rbmArray.contains(UInt32(i)), true)
         }
+        let l: RoaringBitmap = [0,1,2,4,5,6]
+        for i in array {
+            XCTAssertEqual(l.contains(UInt32(i)), true)
+        }
     }
 
     func testFlip(){
@@ -113,16 +117,16 @@ class swiftRoaringTests: XCTestCase {
 
     func testSubset(){
         let cpy = rbm.copy()
-        XCTAssertTrue(rbm.isSubset(cpy))
+        XCTAssertTrue(rbm.isSubset(of: cpy))
         cpy.add(800)
-        XCTAssertTrue(rbm.isStrictSubset(cpy))
+        XCTAssertTrue(rbm.isStrictSubset(of: cpy))
         cpy.remove(800)
     }
 
     func testOptimisations(){
         rbm.addRangeClosed(min:0, max:500)
         XCTAssertTrue(rbm.sizeInBytes() > 0)
-        XCTAssertTrue(rbm.shrinkToFit() >= 0)
+        XCTAssertTrue(rbm.shrink() >= 0)
         XCTAssertTrue(rbm.runOptimize())
         XCTAssertTrue(rbm.removeRunCompression())
     }
@@ -150,8 +154,8 @@ class swiftRoaringTests: XCTestCase {
         rbm.addRangeClosed(min:0, max:500)
         let cpy = rbm.copy()
         _ = cpy.containsRange(start:0, end:501)
-        XCTAssertEqual(cpy.maximum(), 500)
-        XCTAssertEqual(cpy.minimum(), 0)
+        XCTAssertEqual(cpy.max(), 500)
+        XCTAssertEqual(cpy.min(), 0)
         XCTAssertEqual(cpy.rank(value: 499), 500)
         let rbmap = RoaringBitmap()
         rbmap.addRange(min: 0, max: 11)
@@ -184,7 +188,7 @@ class swiftRoaringTests: XCTestCase {
         rbm1 &= rbm2
         XCTAssertEqual(andSwift, Set(rbm1.toArray()))
 
-        let andCardinality = rbm1.andCardinality(rbm2)
+        let andCardinality = rbm1.intersectionCount(rbm2)
         XCTAssertEqual(Int(andCardinality), andSwift.count)
 
         XCTAssertEqual(rbm1.intersect(rbm2), andSwift.count > 0)   
@@ -197,22 +201,22 @@ class swiftRoaringTests: XCTestCase {
         let andSwift = swiftSet1.union(swiftSet2)
         XCTAssertEqual(andSwift, Set(andRbm.toArray()))
 
-        let orCardinality = rbm1.orCardinality(rbm2)
+        let orCardinality = rbm1.unionCount(rbm2)
         XCTAssertEqual(Int(orCardinality), andSwift.count)
 
         let (rbm3, rbm4, swiftSet3, swiftSet4) = makeSets()
-        var orMany = rbm1.orMany([rbm2,rbm3,rbm4])
+        var orMany = rbm1.unionMany([rbm2,rbm3,rbm4])
         var swiftOrMany = swiftSet1.union(swiftSet2)
         swiftOrMany = swiftOrMany.union(swiftSet3)
         swiftOrMany = swiftOrMany.union(swiftSet4)
         XCTAssertEqual(swiftOrMany, Set(orMany.toArray()))
 
-        orMany = rbm1.orManyHeap([rbm2,rbm3,rbm4])
+        orMany = rbm1.unionManyHeap([rbm2,rbm3,rbm4])
         XCTAssertEqual(swiftOrMany, Set(orMany.toArray()))
 
-        let lazy = rbm3.lazyOr(rbm4, bitsetconversion: false)
+        let lazy = rbm3.lazyUnion(rbm4, bitsetconversion: false)
         XCTAssertEqual(swiftSet3.union(swiftSet4), Set(lazy.toArray()))
-        rbm3.lazyOrInplace(rbm4, bitsetconversion: false)
+        rbm3.formLazyUnion(rbm4, bitsetconversion: false)
         rbm3.repairAfterLazy()
         XCTAssertEqual(swiftSet3.union(swiftSet4), Set(rbm3.toArray()))
 
@@ -227,19 +231,19 @@ class swiftRoaringTests: XCTestCase {
         let andSwift = swiftSet1.symmetricDifference(swiftSet2)
         XCTAssertEqual(andSwift, Set(andRbm.toArray()))
 
-        let xorCardinality = rbm1.xorCardinality(rbm2)
+        let xorCardinality = rbm1.symmetricDifferenceCount(rbm2)
         XCTAssertEqual(Int(xorCardinality), andSwift.count)
 
         let (rbm3, rbm4, swiftSet3, swiftSet4) = makeSets()
-        let orMany = rbm1.xorMany([rbm2,rbm3,rbm4])
+        let orMany = rbm1.symmetricDifferenceMany([rbm2,rbm3,rbm4])
         var swiftOrMany = swiftSet1.symmetricDifference(swiftSet2)
         swiftOrMany = swiftOrMany.symmetricDifference(swiftSet3)
         swiftOrMany = swiftOrMany.symmetricDifference(swiftSet4)
         XCTAssertEqual(swiftOrMany, Set(orMany.toArray()))
 
-        let lazy = rbm3.lazyXor(rbm4)
+        let lazy = rbm3.lazySymmetricDifference(rbm4)
         XCTAssertEqual(swiftSet3.symmetricDifference(swiftSet4), Set(lazy.toArray()))
-        rbm3.lazyXorInplace(rbm4)
+        rbm3.formLazySymmetricDifference(rbm4)
         rbm3.repairAfterLazy()
         XCTAssertEqual(swiftSet3.symmetricDifference(swiftSet4), Set(rbm3.toArray()))
 
@@ -257,7 +261,7 @@ class swiftRoaringTests: XCTestCase {
         rbm1 -= rbm2
         XCTAssertEqual(andSwift, Set(rbm1.toArray()))
 
-        let andNotCardinality = rbm1.andNotCardinality(rbm2)
+        let andNotCardinality = rbm1.subtractingCount(rbm2)
         XCTAssertEqual(Int(andNotCardinality), andSwift.count)
     }