Index: trunk/tests/test_KDTree.cc
===================================================================
--- trunk/tests/test_KDTree.cc	(revision 831)
+++ trunk/tests/test_KDTree.cc	(revision 832)
@@ -1,321 +1,321 @@
 #include "UnitTest++.h"
 
 #include "test_utils.hh"
 #include "mvarPointCount.hh"
 
 #include "npstat/nm/KDTree.hh"
 #include "geners/CPP11_array.hh"
 
 using namespace npstat;
 using namespace std;
 
 #define KDDIM 4
 #define NCYCLES 10
 #define NPOINTS 1000
 #define NSEARCHES 1000
 
 namespace {
     static int int_rng()
     {
         return static_cast<int>(50.0*test_rng()) - 25;
     }
 
     TEST(KDTree_float)
     {
         typedef CPP11_array<float,KDDIM> Point;
         Point ftmp;
         VisitCounter<Point> pCount;
 
         std::vector<unsigned> dimUse(KDDIM);
         for (unsigned i=0; i<KDDIM; ++i)
             dimUse[i] = i;
 
         for (unsigned icycle=0; icycle<NCYCLES; ++icycle)
         {
             std::vector<Point> data;
             for (unsigned i=0; i<NPOINTS; ++i)
             {
                 for (unsigned k=0; k<KDDIM; ++k)
                     ftmp[k] = test_rng();
                 data.push_back(ftmp);
             }
             KDTree<Point,float> tree(data, &dimUse[0], dimUse.size());
 
             // Test "nCdf"
             for (unsigned i=0; i<NSEARCHES; ++i)
             {
                 Point upper;
                 for (unsigned k=0; k<KDDIM; ++k)
                     upper[k] = test_rng();
 
                 // Count the number of cdf points by brute force
                 unsigned icdf_brute = 0U;
                 for (unsigned m=0; m<NPOINTS; ++m)
                 {
                     const Point& dat(data[m]);
                     unsigned le = 1;
                     for (unsigned dim=0; dim<KDDIM && le; ++dim)
                         if (dat[dim] > upper[dim])
                             le = 0;
                     icdf_brute += le;
                 }
 
                 // Count the number of cdf points with the tree
                 const unsigned icdf_tree = tree.nCdf(&upper[0], KDDIM);
 
                 CHECK_EQUAL(icdf_brute, icdf_tree);
             }
 
             // Test "nInBox"
             for (unsigned i=0; i<NSEARCHES; ++i)
             {
                 BoxND<float> box(KDDIM);
                 for (unsigned k=0; k<KDDIM; ++k)
                 {
                     float lo, hi;
                     do
                     {
                         lo = test_rng();
                         hi = test_rng();
                     } while (lo > hi);
                     box[k].setBounds(lo, hi);
                 }
 
                 // Count the number of points by brute force
                 unsigned n_brute = 0U;
                 for (unsigned m=0; m<NPOINTS; ++m)
                     if (box.isInsideUpper(&data[m][0], KDDIM))
                         ++n_brute;
 
                 // Count the number of points with the tree
                 const unsigned n_tree = tree.nInBox(box);
 
                 // Count the number of points seen by the visitor
                 pCount.clear();
                 tree.visitInBox(pCount, box);
                 const unsigned count = pCount.result();
 
                 CHECK_EQUAL(n_brute, n_tree);
                 CHECK_EQUAL(n_brute, count);
             }
         }
     }
 
     TEST(KDTree_int)
     {
         typedef std::vector<int> Point;
         std::vector<unsigned> dimUse(KDDIM);
         VisitCounter<Point> pCount;
 
         for (unsigned icycle=0; icycle<NCYCLES; ++icycle)
         {
             for (unsigned i=0; i<KDDIM; ++i)
                 dimUse[i] = i;
 
             std::vector<Point> data;
             data.reserve(NPOINTS);
             for (unsigned i=0; i<NPOINTS; ++i)
             {
                 Point newpt(KDDIM);
                 for (unsigned k=0; k<KDDIM; ++k)
                     newpt[k] = int_rng();
                 data.push_back(newpt);
             }
             KDTree<Point,int> tree(data, &dimUse[0], dimUse.size());
 
             dimUse[0] = 3;
             dimUse[1] = 0;
             dimUse[2] = 2;
             KDTree<Point> tree2(data, &dimUse[0], 3);
 
             // Test "nCdf"
             for (unsigned i=0; i<NSEARCHES; ++i)
             {
                 Point upper(KDDIM);
                 for (unsigned k=0; k<KDDIM; ++k)
                     upper[k] = int_rng();
 
                 // Count the number of cdf points by brute force
                 unsigned icdf_brute = 0U;
                 for (unsigned m=0; m<NPOINTS; ++m)
                 {
                     bool allLE = true;
                     for (unsigned k=0; k<KDDIM; ++k)
                         if (data[m][k] > upper[k])
                         {
                             allLE = false;
                             break;
                         }
                     if (allLE)
                         ++icdf_brute;
                 }
 
                 // Count the number of cdf points with the tree
                 unsigned icdf_tree = tree.nCdf(&upper[0], upper.size());
 
                 CHECK_EQUAL(icdf_brute, icdf_tree);
 
                 // Check using the other tree
                 std::vector<double> upper2(KDDIM);
                 for (unsigned k=0; k<3; ++k)
                     upper2[k] = upper[dimUse[k]];
                 upper2[3] = 100;
 
                 // Count the number of cdf points by brute force
                 icdf_brute = 0U;
                 upper[1] = 100;
                 for (unsigned m=0; m<NPOINTS; ++m)
                 {
                     bool allLE = true;
                     for (unsigned k=0; k<KDDIM; ++k)
                         if (data[m][k] > upper[k])
                         {
                             allLE = false;
                             break;
                         }
                     if (allLE)
                         ++icdf_brute;
                 }
 
                 // Count the number of cdf points with the tree
                 icdf_tree = tree2.nCdf(&upper2[0], 3);
 
                 CHECK_EQUAL(icdf_brute, icdf_tree);
             }
 
             // Test "nInBox"
             for (unsigned i=0; i<NSEARCHES; ++i)
             {
                 BoxND<int> box(KDDIM);
                 for (unsigned k=0; k<KDDIM; ++k)
                 {
                     int lo, hi;
                     do
                     {
                         lo = int_rng();
                         hi = int_rng();
                     } while (lo > hi);
                     box[k].setBounds(lo, hi);
                 }
 
                 // Count the number of points by brute force
                 unsigned n_brute = 0U;
                 for (unsigned m=0; m<NPOINTS; ++m)
                     if (box.isInsideUpper(&data[m][0], KDDIM))
                         ++n_brute;
 
                 // Count the number of points with the tree
                 unsigned n_tree = tree.nInBox(box);
 
                 // Count the number of points seen by the visitor
                 pCount.clear();
                 tree.visitInBox(pCount, box);
                 const unsigned count = pCount.result();
 
                 CHECK_EQUAL(n_brute, n_tree);
                 CHECK_EQUAL(n_brute, count);
 
                 // Check using the other tree
                 BoxND<double> swapped(3);
                 for (unsigned k=0; k<3; ++k)
                     swapped[k].setBounds(box[dimUse[k]].min(),
                                          box[dimUse[k]].max());
 
                 // Count the number of cdf points by brute force
                 n_brute = 0U;
                 box[1].setBounds(-100, 100);
                 for (unsigned m=0; m<NPOINTS; ++m)
                     if (box.isInsideUpper(&data[m][0], KDDIM))
                         ++n_brute;
 
                 n_tree = tree2.nInBox(swapped);
 
                 CHECK_EQUAL(n_brute, n_tree);
             }
 
             // Test "nInBox" with explicit boundary inclusion
             for (unsigned i=0; i<NSEARCHES; ++i)
             {
                 BoxND<int> box(KDDIM);
                 for (unsigned k=0; k<KDDIM; ++k)
                 {
                     int lo, hi;
                     do
                     {
                         lo = int_rng();
                         hi = int_rng();
                     } while (lo > hi);
                     box[k].setBounds(lo, hi);
                 }
 
                 std::vector<BoundaryInclusion> bv(KDDIM);
                 for (unsigned k=0; k<KDDIM; ++k)
                     bv[k] = static_cast<BoundaryInclusion>(test_rng()*4);
 
                 // Count the number of points by brute force
                 unsigned n_brute = 0U;
                 for (unsigned m=0; m<NPOINTS; ++m)
                     if (box.isInside(&data[m][0], KDDIM, &bv[0], KDDIM))
                         ++n_brute;
 
                 // Count the number of points with the tree
                 const unsigned n_tree = tree.nInBox(box, bv);
                 CHECK_EQUAL(n_brute, n_tree);
             }
         }
     }
 
     TEST(KDTree_mvarPointCount)
     {
         const int intInf = 1000; // Infinity for the purpose of this test
         const unsigned dim = 3U; // Must be at most 3
         typedef CPP11_array<int,dim> Point;
 
         unsigned index[3];
         std::vector<unsigned> dimUse(dim);
         for (unsigned i=0; i<dim; ++i)
             dimUse[i] = i;
 
         for (unsigned icycle=0; icycle<NCYCLES; ++icycle)
         {
             std::vector<Point> data;
             data.reserve(NPOINTS);
             {
                 Point newpt;
                 for (unsigned i=0; i<NPOINTS; ++i)
                 {
                     for (unsigned k=0; k<dim; ++k)
                         newpt[k] = int_rng();
                     data.push_back(newpt);
                 }
             }
             KDTree<Point,int> tree(data, &dimUse[0], dimUse.size());
 
             for (unsigned i=0; i<NSEARCHES; ++i)
             {
                 int limits[3];
                 for (unsigned k=0; k<3U; ++k)
                     limits[k] = int_rng();
 
-                const ArrayND<unsigned long>& counts =
+                const ArrayND<unsigned>& counts =
                     mvarPointCount(data, limits[0], limits[1], limits[2]);
-                const unsigned long len = counts.length();
+                const unsigned len = counts.length();
                 
                 BoxND<int> box(dim);
-                for (unsigned long iarr=0; iarr<len; ++iarr)
+                for (unsigned iarr=0; iarr<len; ++iarr)
                 {
                     counts.convertLinearIndex(iarr, index, dim);
                     for (unsigned idim=0; idim<dim; ++idim)
                     {
                         if (index[idim])
                             box[idim].setBounds(limits[idim], intInf);
                         else
                             box[idim].setBounds(-intInf, limits[idim]);
                     }
-                    const unsigned long n_tree = tree.nInBox(box);
+                    const unsigned n_tree = tree.nInBox(box);
                     CHECK_EQUAL(counts.linearValue(iarr), n_tree);
                 }
             }
         }
     }
 }
Index: trunk/tests/mvarPointCount.hh
===================================================================
--- trunk/tests/mvarPointCount.hh	(revision 831)
+++ trunk/tests/mvarPointCount.hh	(revision 832)
@@ -1,68 +1,54 @@
 #ifndef MVARPOINTCOUNT_HH_
 #define MVARPOINTCOUNT_HH_
 
 #include <vector>
 #include <cassert>
 
 #include "npstat/nm/ArrayND.hh"
 #include "npstat/nm/PointDimensionality.hh"
 
 template<class Point>
-npstat::ArrayND<unsigned long> mvarPointCount(
+npstat::ArrayND<unsigned> mvarPointCount(
     const std::vector<Point>& data,
     const double x, const double y, const double z)
 {
-    const unsigned maxDim = 3U;
+    static const unsigned maxDim = 3U;
+    static const unsigned shape[maxDim] = {2U, 2U, 2U};
 
+    // The result that will be filled and returned
     const unsigned dim = npstat::PointDimensionality<Point>::dim_size;
-    assert(dim == 2U || dim == 3U);
-    const unsigned long sz = data.size();
-
-    const unsigned shape[maxDim] = {2U, 2U, 2U};
-    npstat::ArrayND<unsigned long> result(shape, dim);
+    assert(dim >= 2U || dim <= maxDim);
+    npstat::ArrayND<unsigned> result(shape, dim);
     result.clear();
 
+    const unsigned sz = data.size();
+
+    // The code below assumes that boolean "true" converts into unsigned 1
     if (dim == 2U)
     {
-        for (unsigned long ipt=0; ipt<sz; ++ipt)
+        for (unsigned ipt=0; ipt<sz; ++ipt)
         {
-            const Point& pt = data[ipt];
-
-            bool continueSearching = true;
-            for (unsigned ix=0U; ix<2U && continueSearching; ++ix)
-                if (ix ? pt[0] > x : pt[0] <= x)
-                    for (unsigned iy=0U; iy<2U && continueSearching; ++iy)
-                        if (iy ? pt[1] > y : pt[1] <= y)
-                        {
-                            ++result(ix, iy);
-                            continueSearching = false;
-                        }
+            const Point& pt(data[ipt]);
+            const unsigned ix = pt[0] > x;
+            const unsigned iy = pt[1] > y;
+            ++result(ix, iy);
         }
     }
     else if (dim == 3U)
     {
-        for (unsigned long ipt=0; ipt<sz; ++ipt)
+        for (unsigned ipt=0; ipt<sz; ++ipt)
         {
-            const Point& pt = data[ipt];
-
-            bool continueSearching = true;
-            for (unsigned ix=0U; ix<2U && continueSearching; ++ix)
-                if (ix ? pt[0] > x : pt[0] <= x)
-                    for (unsigned iy=0U; iy<2U && continueSearching; ++iy)
-                        if (iy ? pt[1] > y : pt[1] <= y)
-                            for (unsigned iz=0U; iz<2U && continueSearching; ++iz)
-                                if (iz ? pt[2] > z : pt[2] <= z)
-                                {
-                                    ++result(ix, iy, iz);
-                                    continueSearching = false;
-                                }
+            const Point& pt(data[ipt]);
+            const unsigned ix = pt[0] > x;
+            const unsigned iy = pt[1] > y;
+            const unsigned iz = pt[2] > z;
+            ++result(ix, iy, iz);
         }
     }
     else
-        assert(!"Unprocessed dimensionality in mvarPointCount");
+        assert(!"Unsupported dimensionality case in mvarPointCount");
 
-    assert(result.sum<unsigned long>() == sz);
     return result;
 }
 
 #endif // MVARPOINTCOUNT_HH_