Index: trunk/npstat/stat/DiscreteGaussCopulaSmoother.cc
===================================================================
--- trunk/npstat/stat/DiscreteGaussCopulaSmoother.cc	(revision 679)
+++ trunk/npstat/stat/DiscreteGaussCopulaSmoother.cc	(revision 680)
@@ -1,89 +1,91 @@
 #include <map>
 #include <cmath>
 #include <memory>
 #include <utility>
 #include <stdexcept>
 
 #include "npstat/nm/PtrBufferHandle.hh"
 
 #include "npstat/stat/DiscreteGaussCopulaSmoother.hh"
 #include "npstat/stat/DiscreteGauss1DBuilder.hh"
 
 static std::vector<double> effectiveBwValues(
     const npstat::Matrix<double>& bandwidthsToUse)
 {
     const unsigned nFilters = bandwidthsToUse.nRows();
     const unsigned dim = bandwidthsToUse.nColumns();
     std::vector<double> bwvec(nFilters);
     for (unsigned ifilt=0; ifilt<nFilters; ++ifilt)
     {
         long double h = 1.0L;
         for (unsigned idim=0; idim<dim; ++idim)
             h *= bandwidthsToUse(ifilt, idim);
         bwvec[ifilt] = powl(h, 1.0/dim);
     }
     return bwvec;
 }
 
 namespace npstat {
     DiscreteGaussCopulaSmoother::DiscreteGaussCopulaSmoother(
         const unsigned* nBinsInEachDim, const unsigned dim,
         const double marginTolerance, const unsigned nNormCycles,
         const CVCalc* cvCalc, const bool assumeCvCalcOwnership,
         const Matrix<double>& bandwidthsToUse)
         : CVCopulaSmoother<SequentialPolyFilterND>(
             nBinsInEachDim, dim, marginTolerance, nNormCycles,
             effectiveBwValues(bandwidthsToUse),
             cvCalc, assumeCvCalcOwnership, true)
     {
         typedef std::pair<double,unsigned> Key;
         typedef std::shared_ptr<DiscreteGauss1DBuilder> BuilderPtr;
         typedef std::map<Key,BuilderPtr> BuilderMap;
 
         const unsigned nFilters = bandwidthsToUse.nRows();
         if (nFilters)
         {
             if (dim != bandwidthsToUse.nColumns()) throw std::invalid_argument(
                 "In npstat::DescreteGaussCopulaSmoother constructor: "
                 "incompatible matrix of polynomial degrees");
             if (bandwidthsToUse.minValue() < 0.0) throw std::invalid_argument(
                 "In npstat::DescreteGaussCopulaSmoother constructor: "
                 "all bandwidth values must be nonnegative");
 
             // Generate all filters. Making "DiscreteGauss1DBuilder"
             // objects is relatively expensive, so we will memoize
             // them in the hope that they can be reused.
             BuilderMap bmap;
             for (unsigned ifilt=0; ifilt<nFilters; ++ifilt)
             {
                 std::vector<const LocalPolyFilter1D*> f1d(dim, 0);
                 Private::PtrBufferHandle<const LocalPolyFilter1D> handle(&f1d[0], dim);
 
                 for (unsigned idim=0; idim<dim; ++idim)
                 {
                     DiscreteGauss1DBuilder* builder = 0;
                     const double bw = bandwidthsToUse(ifilt, idim);
                     const unsigned nbins = nBinsInEachDim[idim];
                     const Key key(bw, nbins);
 
                     BuilderMap::iterator it = bmap.find(key);
                     if (it == bmap.end())
                     {
-                        builder = new DiscreteGauss1DBuilder(bw, nbins);
+                        // Bin width is 1.0/nbins, so the bandwidth in the
+                        // units of bin width is bw*nbins
+                        builder = new DiscreteGauss1DBuilder(bw*nbins, nbins);
                         BuilderPtr ptr(builder);
                         bmap.insert(std::make_pair(key, ptr));
                     }
                     else
                         builder = &(*(it->second));
                     f1d[idim] = new LocalPolyFilter1D(0, 0, *builder, nbins);
                 }
 
                 // Generate the filter
                 Filter* f = new SequentialPolyFilterND(&f1d[0], dim, true);
                 handle.release();
 
                 this->setFilter(ifilt, f);
             }
         }
     }
 }