Improve API of recently-added bool vector functions.

The old API had (bool-vector-count-matches A B)
and (bool-vector-count-matches-at A B I), which gave the
misleading impression that the two functions were variants, one
with a location I.  The new API has (bool-vector-count-population A)
and (bool-vector-count-consecutive A B I) to make the distinction
clearer.  The first function no longer has a B argument, since the
caller can easily determine the number of nils if the length and
number of ts is known.
* src/data.c (Fbool_vector_count_population): Rename from
bool_vector_count_matches, and accept just 1 argument.
(Fbool_vector_count_consecutive): Rename from
Fbool_vector_count_matches_at.
* test/automated/data-tests.el: Adjust to API changes.

Fixes: debbugs:15912

5 files changed, 55 insertions, 41 deletions

diff --git a/etc/NEWS b/etc/NEWS
index 132c461b258..b68978b8ed9 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -736,8 +736,8 @@ frame.
 *** `bool-vector-set-difference'
 *** `bool-vector-not'
 *** `bool-vector-subsetp'
-*** `bool-vector-count-matches'
-*** `bool-vector-count-matches-at'
+*** `bool-vector-count-consecutive'
+*** `bool-vector-count-population'
 
 ** Comparison functions =, <, >, <=, >= now take many arguments.
 
diff --git a/src/ChangeLog b/src/ChangeLog
index 21025c677fc..d6edcea4513 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,19 @@
 2013-11-18  Paul Eggert  <eggert@cs.ucla.edu>
 
+        Improve API of recently-added bool vector functions (Bug#15912).
+        The old API had (bool-vector-count-matches A B)
+        and (bool-vector-count-matches-at A B I), which gave the
+        misleading impression that the two functions were variants, one
+        with a location I.  The new API has (bool-vector-count-population A)
+        and (bool-vector-count-consecutive A B I) to make the distinction
+        clearer.  The first function no longer has a B argument, since the
+        caller can easily determine the number of nils if the length and
+        number of ts is known.
+        * data.c (Fbool_vector_count_population): Rename from
+        bool_vector_count_matches, and accept just 1 argument.
+        (Fbool_vector_count_consecutive): Rename from
+        Fbool_vector_count_matches_at.
+
         Always allocate at least one bits_word per bool vector.
         See Daniel Colascione in:
         http://lists.gnu.org/archive/html/emacs-devel/2013-11/msg00518.html
diff --git a/src/data.c b/src/data.c
index b8b0f248dfa..2c789f37431 100644
--- a/src/data.c
+++ b/src/data.c
@@ -3282,11 +3282,12 @@ Return the destination vector.  */)
   return b;
 }
 
-DEFUN ("bool-vector-count-matches", Fbool_vector_count_matches,
-       Sbool_vector_count_matches, 2, 2, 0,
-       doc: /* Count how many elements in A equal B.
-A must be a bool vector.  B is a generalized bool.  */)
-  (Lisp_Object a, Lisp_Object b)
+DEFUN ("bool-vector-count-population", Fbool_vector_count_population,
+       Sbool_vector_count_population, 1, 1, 0,
+       doc: /* Count how many elements in A are t.
+A is a bool vector.  To count A's nil elements, subtract the return
+value from A's length.  */)
+  (Lisp_Object a)
 {
   EMACS_INT count;
   EMACS_INT nr_bits;
@@ -3303,17 +3304,13 @@ A must be a bool vector.  B is a generalized bool.  */)
   for (i = 0; i < nwords; i++)
     count += count_one_bits_word (adata[i]);
 
-  if (NILP (b))
-    count = nr_bits - count;
   return make_number (count);
 }
 
-DEFUN ("bool-vector-count-matches-at",
-       Fbool_vector_count_matches_at,
-       Sbool_vector_count_matches_at, 3, 3, 0,
-       doc: /* Count how many consecutive elements in A equal B at i.
-A must be a bool vector.  B is a generalized boolean.  i is an
-index into the vector.  */)
+DEFUN ("bool-vector-count-consecutive", Fbool_vector_count_consecutive,
+       Sbool_vector_count_consecutive, 3, 3, 0,
+       doc: /* Count how many consecutive elements in A equal B starting at I.
+A is a bool vector, B is t or nil, and I is an index into A.  */)
   (Lisp_Object a, Lisp_Object b, Lisp_Object i)
 {
   EMACS_INT count;
@@ -3660,8 +3657,8 @@ syms_of_data (void)
   defsubr (&Sbool_vector_set_difference);
   defsubr (&Sbool_vector_not);
   defsubr (&Sbool_vector_subsetp);
-  defsubr (&Sbool_vector_count_matches);
-  defsubr (&Sbool_vector_count_matches_at);
+  defsubr (&Sbool_vector_count_consecutive);
+  defsubr (&Sbool_vector_count_population);
 
   set_symbol_function (Qwholenump, XSYMBOL (Qnatnump)->function);
 
diff --git a/test/ChangeLog b/test/ChangeLog
index 79d9ab544e0..35a168ce0c4 100644
--- a/test/ChangeLog
+++ b/test/ChangeLog
@@ -1,3 +1,8 @@
+2013-11-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Improve API of recently-added bool vector functions (Bug#15912).
+        * automated/data-tests.el: Adjust to API changes.
+
 2013-11-16  Michael Albinus  <michael.albinus@gmx.de>
 
         * automated/tramp-tests.el (tramp-test07-file-exists-p)
diff --git a/test/automated/data-tests.el b/test/automated/data-tests.el
index d79e1643848..f731b8bf1db 100644
--- a/test/automated/data-tests.el
+++ b/test/automated/data-tests.el
@@ -77,42 +77,40 @@
 ;; Bool vector tests.  Compactly represent bool vectors as hex
 ;; strings.
 
-(ert-deftest bool-vector-count-matches-all-0-nil ()
+(ert-deftest bool-vector-count-population-all-0-nil ()
   (cl-loop for sz in '(0 45 1 64 9 344)
            do (let* ((bv (make-bool-vector sz nil)))
                 (should
-                 (eql
-                  (bool-vector-count-matches bv nil)
-                  sz)))))
+                 (zerop
+                  (bool-vector-count-population bv))))))
 
-(ert-deftest bool-vector-count-matches-all-0-t ()
+(ert-deftest bool-vector-count-population-all-1-t ()
   (cl-loop for sz in '(0 45 1 64 9 344)
-           do (let* ((bv (make-bool-vector sz nil)))
+           do (let* ((bv (make-bool-vector sz t)))
                 (should
                  (eql
-                  (bool-vector-count-matches bv t)
-                  0)))))
+                  (bool-vector-count-population bv)
+                  sz)))))
 
-(ert-deftest bool-vector-count-matches-1-nil ()
+(ert-deftest bool-vector-count-population-1-nil ()
   (let* ((bv (make-bool-vector 45 nil)))
     (aset bv 40 t)
     (aset bv 0 t)
     (should
      (eql
-      (bool-vector-count-matches bv t)
-      2)))
-  )
+      (bool-vector-count-population bv)
+      2))))
 
-(ert-deftest bool-vector-count-matches-1-t ()
-  (let* ((bv (make-bool-vector 45 nil)))
-    (aset bv 40 t)
-    (aset bv 0 t)
+(ert-deftest bool-vector-count-population-1-t ()
+  (let* ((bv (make-bool-vector 45 t)))
+    (aset bv 40 nil)
+    (aset bv 0 nil)
     (should
      (eql
-      (bool-vector-count-matches bv nil)
+      (bool-vector-count-population bv)
       43))))
 
-(defun mock-bool-vector-count-matches-at (a b i)
+(defun mock-bool-vector-count-consecutive (a b i)
   (loop for i from i below (length a)
         while (eq (aref a i) b)
         sum 1))
@@ -147,8 +145,8 @@
                (nreverse nibbles)
                "")))
 
-(defun test-bool-vector-count-matches-at-tc (desc)
-  "Run a test case for bool-vector-count-matches-at.
+(defun test-bool-vector-count-consecutive-tc (desc)
+  "Run a test case for bool-vector-count-consecutive.
 DESC is a string describing the test.  It is a sequence of
 hexadecimal digits describing the bool vector.  We exhaustively
 test all counts at all possible positions in the vector by
@@ -158,8 +156,8 @@ comparing the subr with a much slower lisp implementation."
      for lf in '(nil t)
      do (loop
          for pos from 0 upto (length bv)
-         for cnt = (mock-bool-vector-count-matches-at bv lf pos)
-         for rcnt = (bool-vector-count-matches-at bv lf pos)
+         for cnt = (mock-bool-vector-count-consecutive bv lf pos)
+         for rcnt = (bool-vector-count-consecutive bv lf pos)
          unless (eql cnt rcnt)
          do (error "FAILED testcase %S %3S %3S %3S"
                    pos lf cnt rcnt)))))
@@ -182,8 +180,8 @@ comparing the subr with a much slower lisp implementation."
   "0000000000000000000000000"
   "FFFFFFFFFFFFFFFF1"))
 
-(ert-deftest bool-vector-count-matches-at ()
-  (mapc #'test-bool-vector-count-matches-at-tc
+(ert-deftest bool-vector-count-consecutive ()
+  (mapc #'test-bool-vector-count-consecutive-tc
         bool-vector-test-vectors))
 
 (defun test-bool-vector-apply-mock-op (mock a b c)