[Emacs-diffs] trunk r115140: Improve API of recently-added bool vector functions.

[Paul Eggert]

------------------------------------------------------------
revno: 115140
revision-id: address@hidden
parent: address@hidden
fixes bug: http://debbugs.gnu.org/15912
committer: Paul Eggert <address@hidden>
branch nick: trunk
timestamp: Mon 2013-11-18 10:56:42 -0800
message:
  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.
modified:
  etc/NEWS                       news-20100311060928-aoit31wvzf25yr1z-1
  src/ChangeLog                  changelog-20091113204419-o5vbwnq5f7feedwu-1438
  src/data.c                     data.c-20091113204419-o5vbwnq5f7feedwu-251
  test/ChangeLog                 changelog-20091113204419-o5vbwnq5f7feedwu-8588
  test/automated/data-tests.el   datatests.el-20130911041418-ha1keli7tcoxl2ij-1

=== modified file 'etc/NEWS'
--- a/etc/NEWS  2013-11-18 02:27:12 +0000
+++ b/etc/NEWS  2013-11-18 18:56:42 +0000
@@ -736,8 +736,8 @@
 *** `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.
 

=== modified file 'src/ChangeLog'
--- a/src/ChangeLog     2013-11-18 18:37:25 +0000
+++ b/src/ChangeLog     2013-11-18 18:56:42 +0000
@@ -1,5 +1,19 @@
 2013-11-18  Paul Eggert  <address@hidden>
 
+       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

=== modified file 'src/data.c'
--- a/src/data.c        2013-11-18 18:37:25 +0000
+++ b/src/data.c        2013-11-18 18:56:42 +0000
@@ -3282,11 +3282,12 @@
   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 @@
   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 @@
   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);
 

=== modified file 'test/ChangeLog'
--- a/test/ChangeLog    2013-11-16 11:46:37 +0000
+++ b/test/ChangeLog    2013-11-18 18:56:42 +0000
@@ -1,3 +1,8 @@
+2013-11-18  Paul Eggert  <address@hidden>
+
+       Improve API of recently-added bool vector functions (Bug#15912).
+       * automated/data-tests.el: Adjust to API changes.
+
 2013-11-16  Michael Albinus  <address@hidden>
 
        * automated/tramp-tests.el (tramp-test07-file-exists-p)

=== modified file 'test/automated/data-tests.el'
--- a/test/automated/data-tests.el      2013-09-22 09:31:55 +0000
+++ b/test/automated/data-tests.el      2013-11-18 18:56:42 +0000
@@ -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
+                 (zerop
+                  (bool-vector-count-population bv))))))
+
+(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 t)))
+                (should
                  (eql
-                  (bool-vector-count-matches bv nil)
+                  (bool-vector-count-population bv)
                   sz)))))
 
-(ert-deftest bool-vector-count-matches-all-0-t ()
-  (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 t)
-                  0)))))
-
-(ert-deftest bool-vector-count-matches-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)))
-  )
-
-(ert-deftest bool-vector-count-matches-1-t ()
-  (let* ((bv (make-bool-vector 45 nil)))
-    (aset bv 40 t)
-    (aset bv 0 t)
-    (should
-     (eql
-      (bool-vector-count-matches bv 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-population bv)
+      2))))
+
+(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-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 @@
      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 @@
   "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)