Index: trunk/npstat/stat/SineGOFTest1D.cc
===================================================================
--- trunk/npstat/stat/SineGOFTest1D.cc	(revision 841)
+++ trunk/npstat/stat/SineGOFTest1D.cc	(revision 842)
@@ -1,128 +1,126 @@
 #include <sstream>
 #include <stdexcept>
 
 #include "npstat/stat/SineGOFTest1D.hh"
 #include "npstat/stat/Distributions1D.hh"
 
 #define PI 3.1415926535897932385
 #define SQR2 1.4142135623730950488
 
 static npstat::Matrix<double> sineTransformMatrix(
     const unsigned N, const unsigned K)
 {
     if (!N) throw std::invalid_argument(
         "In sineTransformMatrix: number of sine terms must be positive");
     if (!K) throw std::invalid_argument(
         "In sineTransformMatrix: number of discretization points must be positive");
 
     const double h = 1.0/K;
     const double norm = SQR2*h;
 
     npstat::Matrix<double> result(N, K);
     for (unsigned n=1; n<=N; ++n)
     {
-        const double nPi = n*PI;
+        const double nPih = n*PI*h;
+        double* base = result[n - 1U];
         for (unsigned j=0; j<K; ++j)
-        {
-            const double x = (j + 0.5)*h;
-            result[n-1][j] = norm*sin(nPi*x);
-        }
+            base[j] = norm*sin(nPih*(j + 0.5));
     }
 
     return result;
 }
 
 namespace npstat {
     SineGOFTest1D::SineGOFTest1D(
         const AbsDistribution1D& nullDistro,
         const unsigned nSineTerms, const unsigned nDiscretizationPoints,
         const unsigned char* mask, const unsigned lenMask)
         : AbsUnbinnedGOFTest1D(nullDistro),
           nSineTerms_(nSineTerms),
           nPt_(nDiscretizationPoints),
           mask_(nSineTerms, 0),
           sineM_(sineTransformMatrix(nSineTerms, nDiscretizationPoints)),
           points_(0.0, 1.0, nDiscretizationPoints),
           quantiles_(nDiscretizationPoints),
           nUnmasked_(nSineTerms),
           cdfValues_(nDiscretizationPoints),
           sineValues_(nSineTerms),
           statBuf_(nSineTerms)
     {
         initMask(mask, lenMask);
     }
 
     SineGOFTest1D::SineGOFTest1D(const AbsDistribution1D& nullDistro,
                                  const unsigned nDiscretizationPoints,
                                  const std::vector<int>& mask)
         : AbsUnbinnedGOFTest1D(nullDistro),
           nSineTerms_(mask.size()),
           nPt_(nDiscretizationPoints),
           mask_(mask.size(), 0),
           sineM_(sineTransformMatrix(mask.size(), nDiscretizationPoints)),
           points_(0.0, 1.0, nDiscretizationPoints),
           quantiles_(nDiscretizationPoints),
           nUnmasked_(mask.size()),
           cdfValues_(nDiscretizationPoints),
           sineValues_(mask.size()),
           statBuf_(mask.size())
     {
         if (!mask.empty())
             initMask(&mask[0], mask.size());
         else
             initMask((int*)0, 0);
     }
 
     double SineGOFTest1D::analyticPValue(
         const double stat, unsigned long /* sz */) const
     {
         Gamma1D chisq(0.0, 2.0, nUnmasked_/2.0);
         return chisq.exceedance(stat);
     }
 
     double SineGOFTest1D::inverseExceedance(
         const double pvalue, const unsigned long sz,
         const double smin, const double smax) const
     {
         if (pvalue <= 0.0 || pvalue >= 1.0) throw std::invalid_argument(
             "In npstat::SineGOFTest1D::inverseExceedance: "
             "p-value argument must be inside (0, 1) interval");
 
         if (pvalue > 1.0e-10)
         {
             Gamma1D chisq(0.0, 2.0, nUnmasked_/2.0);
             return chisq.quantile(1.0 - pvalue);
         }
         else
             return AbsUnbinnedGOFTest1D::inverseExceedance(
                 pvalue, sz, smin, smax);
     }
 
     std::string SineGOFTest1D::shortName() const
     {
         std::ostringstream os;
         os << "Sine_" << nSineTerms_ << '_' << nPt_;
 
         if (nUnmasked_ < nSineTerms_)
         {
             // Figure out the number of the last
             // masked term
             unsigned lastMasked = nSineTerms_;
             for (unsigned i=0; i<nSineTerms_; ++i)
                 if (mask_[i])
                     lastMasked = i;
             assert(lastMasked < nSineTerms_);
 
             // Add mask info
             os << '_';
             for (unsigned i=0; i<=lastMasked; ++i)
             {
                 if (mask_[i])
                     os << '1';
                 else
                     os << '0';
             }
         }
         return os.str();
     }
 }