diff --git a/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/Lorentzian.h b/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/Lorentzian.h
index e966eef72b61..18fbb764193c 100644
--- a/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/Lorentzian.h
+++ b/Code/Mantid/Framework/CurveFitting/inc/MantidCurveFitting/Lorentzian.h
@@ -12,9 +12,9 @@ namespace Mantid
   {
     /**
     Provide lorentzian peak shape function interface to IPeakFunction.
-    I.e. the function: <math>\frac{A}{\pi}( \Gamma/2((x-PeakCentre)^2+(\Gamma/2)^2) ).
+    I.e. the function: \f$ \frac{A}{\pi}( \Gamma/2((x-PeakCentre)^2+(\Gamma/2)^2) )\f$.
 
-    \Gamma/2 (HWHM) - half-width at half-maximum
+    \f$\Gamma/2\f$ (HWHM) - half-width at half-maximum
 
     Lorentzian parameters:
     <UL>
diff --git a/Code/Mantid/Framework/CurveFitting/src/AugmentedLagrangianOptimizer.cpp b/Code/Mantid/Framework/CurveFitting/src/AugmentedLagrangianOptimizer.cpp
index 6209baa35689..cc134678e13b 100644
--- a/Code/Mantid/Framework/CurveFitting/src/AugmentedLagrangianOptimizer.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/AugmentedLagrangianOptimizer.cpp
@@ -301,9 +301,11 @@ namespace Mantid
     }
 
     /**
+     * @param lambda
+     * @param mu
+     * @param rho
      * @param xcur The starting parameters for the limited unconstrained optimization. They will
-     * be updated as it proceeds
-     * @param d
+     *             be updated as it proceeds
      */
     void AugmentedLagrangianOptimizer::unconstrainedOptimization(const std::vector<double> & lambda,
                                                                  const std::vector<double> & mu,
diff --git a/Code/Mantid/Framework/CurveFitting/src/ComptonScatteringCountRate.cpp b/Code/Mantid/Framework/CurveFitting/src/ComptonScatteringCountRate.cpp
index a36f2b5ac822..85700dcb797f 100644
--- a/Code/Mantid/Framework/CurveFitting/src/ComptonScatteringCountRate.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/ComptonScatteringCountRate.cpp
@@ -307,7 +307,6 @@ namespace CurveFitting
   }
 
   /**
-   * @param funcIndex Index within composite
    * @param profile Function of type ComptonProfile
    * @param paramsOffset The offset of the given function's parameters within composite
    */
@@ -325,7 +324,6 @@ namespace CurveFitting
   }
 
   /**
-   * @param funcIndex Index within composite
    * @param function1D Function of type IFunction1D
    * @param paramsOffset The offset of the given function's parameters within composite
    */
diff --git a/Code/Mantid/Framework/CurveFitting/src/CubicSpline.cpp b/Code/Mantid/Framework/CurveFitting/src/CubicSpline.cpp
index 0f5d09f84506..7b116f6a4c3a 100644
--- a/Code/Mantid/Framework/CurveFitting/src/CubicSpline.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/CubicSpline.cpp
@@ -190,9 +190,8 @@ namespace Mantid
 
     /**Evaluate a point on the spline. Includes basic error handling
      *
-     * @param out :: The array to store the calculated values
-     * @param xValues :: The array of x values we wish to interpolate
-     * @param nData :: The size of the arrays
+     * @param x :: Point to evaluate
+     * @return :: the value of the spline at the given point
      */
     double CubicSpline::splineEval(const double x) const
     {
diff --git a/Code/Mantid/Framework/CurveFitting/src/LeBailFunction.cpp b/Code/Mantid/Framework/CurveFitting/src/LeBailFunction.cpp
index 53511ce35454..fc844d293e4e 100644
--- a/Code/Mantid/Framework/CurveFitting/src/LeBailFunction.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/LeBailFunction.cpp
@@ -112,7 +112,8 @@ namespace CurveFitting
   /** Calculate powder diffraction pattern by Le Bail algorithm
     * @param out :: output vector
     * @param xvalues :: input vector
-    * @param includebkgd :: if true, then calculate background and add to output.  otherwise, assume zero background
+    * @param calpeaks :: if true, calculate peaks
+    * @param calbkgd :: if true, then calculate background and add to output.  otherwise, assume zero background
     */
   void LeBailFunction::function(std::vector<double>& out, const std::vector<double>& xvalues, bool calpeaks, bool calbkgd) const
   {
@@ -179,7 +180,7 @@ namespace CurveFitting
 
   //----------------------------------------------------------------------------------------------
   /** Check whether a parameter is a profile parameter
-    * @param parammane :: parameter name to check with
+   * @param paramname :: parameter name to check with
    */
   bool LeBailFunction::hasProfileParameter(std::string paramname)
   {
@@ -256,7 +257,9 @@ namespace CurveFitting
 
   //----------------------------------------------------------------------------------------------
   /** Set peak position tolerance during importing/adding peaks
-    * @param peakhkls :: list of Miller indexes (HKL)
+    * @param peakpostol :: tolerance for peak position
+    * @param tofmin :: minimum TOF for peak position
+    * @param tofmax :: maximum TOF for peak position
    */
   void LeBailFunction::setPeakCentreTolerance(double peakpostol,  double tofmin, double tofmax)
   {
@@ -777,6 +780,7 @@ namespace CurveFitting
   //----------------------------------------------------------------------------------------------
   /** Group peaks together
     * @param peakgroupvec:  output vector containing peaks grouped together.
+    * @param outboundpeakvec: output vector containing peaks out of bound range
     * @param xmin : minimim x value of the data
     * @param xmax : maximum x value of the data
     * Disabled argument: MatrixWorkspace_sptr dataws, size_t workspaceindex,
@@ -902,6 +906,8 @@ namespace CurveFitting
   /** Add background function.
     * The supported background types are Polynomial/Linear/Flat and Chebyshev
     * @param backgroundtype :: string, type of background, such as Polynomial, Chebyshev
+    * @param order :: polynomial order for the background
+    * @param vecparnames :: vector of parameter names
     * @param vecparvalues :: vector of parameter values from order 0.
     * @param startx :: background's StartX.  Used by Chebyshev
     * @param endx :: background's EndX.  Used by Chebyshev
@@ -1046,7 +1052,7 @@ namespace CurveFitting
 
   //----------------------------------------------------------------------------------------------
   /** Reset all peaks' height
-    * @param peakheights :: list of peak heights corresponding to each peak
+    * @param inheights :: list of peak heights corresponding to each peak
    */
   void LeBailFunction::setPeakHeights(std::vector<double> inheights)
   {
diff --git a/Code/Mantid/Framework/CurveFitting/src/Linear.cpp b/Code/Mantid/Framework/CurveFitting/src/Linear.cpp
deleted file mode 100644
index 482a7e765a06..000000000000
--- a/Code/Mantid/Framework/CurveFitting/src/Linear.cpp
+++ /dev/null
@@ -1,266 +0,0 @@
-/*WIKI* 
-
-This algorithm fits a line, of the form <math> Y = c0 + c1 X </math>, to the specified part of a particular spectrum. As well as outputting the result to the log (debug level) and as output properties, a 1D workspace is created with the same X bins/points as the fitted spectrum and the value and error on the fit at each point. The covariance matrix is not currently returned as an output: if this is required please contact the development team.
-
-==== References ====
-This algorithm uses the gsl linear regression algorithms ''gsl_fit_linear'' and ''gsl_fit_wlinear'', which are documented [http://www.gnu.org/software/gsl/manual/html_node/Linear-regression.html here].
-
-
-*WIKI*/
-//----------------------------------------------------------------------
-// Includes
-//----------------------------------------------------------------------
-#include "MantidCurveFitting/Linear.h"
-#include <gsl/gsl_errno.h>
-#include <gsl/gsl_fit.h>
-#include "MantidKernel/BoundedValidator.h"
-
-namespace Mantid
-{
-namespace CurveFitting
-{
-
-// Register the algorithm into the AlgorithmFactory
-DECLARE_ALGORITHM(Linear)
-
-/// Sets documentation strings for this algorithm
-void Linear::initDocs()
-{
-  this->setWikiSummary("Performs linear least-squares regression on a spectrum (or portion of one).");
-  this->setOptionalMessage("Performs linear least-squares regression on a spectrum (or portion of one).");
-}
-
-
-using namespace Mantid::Kernel;
-using namespace Mantid::API;
-
-
-Linear::Linear() : API::Algorithm(), m_minX(0), m_maxX(0), m_progress(NULL)
-{
-  useAlgorithm("Fit");
-}
-
-Linear::~Linear() {if(m_progress) delete m_progress;m_progress=NULL;}
-
-void Linear::init()
-{
-  declareProperty(new WorkspaceProperty<>("InputWorkspace","",Direction::Input),
-    "The name of the workspace containing the spectrum to fit.");
-  declareProperty(new WorkspaceProperty<>("OutputWorkspace","",Direction::Output),
-    "A Workspace1D containing the fit result and errors for the X values of the input spectrum.");
-
-  auto mustBePositive = boost::make_shared<BoundedValidator<int> >();
-  mustBePositive->setLower(0);
-  declareProperty("WorkspaceIndex",0, mustBePositive,
-    "Index number of the Workspace to fit");
-  declareProperty("StartX", EMPTY_DBL(),
-    "The X value to start fitting from (default: "
-    "the lowest value of X)");
-  declareProperty("EndX", EMPTY_DBL(),
-    "The last X value to include in the fitting range "
-    "(default: the highest X value");
-  declareProperty("FitStatus", "", boost::make_shared<NullValidator>(),
-    "Empty if the fit succeeded, otherwise contains the gsl error "
-    "message", Direction::Output);
-  declareProperty("FitIntercept", 0.0,
-    "The intercept with the ordinate of the fitted line. <math>c0</math> in the equation below.", 
-                  Direction::Output);
-  declareProperty("FitSlope",0.0,
-                  "The slope of the fitted line. <math>c1</math> in the equation below.",
-    Direction::Output);
-  declareProperty("Cov00",0.0,
-    "The first diagonal component of the covariance matrix.",
-    Direction::Output);
-  declareProperty("Cov11",0.0,
-    "The second diagonal component of the covariance matrix.",
-    Direction::Output);
-  declareProperty("Cov01",0.0,
-    "The off-diagonal component of the covariance matrix.",
-    Direction::Output);
-  declareProperty("Chi2",0.0,
-    "The <math> \\chi^2 </math> value for the goodness of the fit.", 
-                  Direction::Output);
-
-  // Disable default gsl error handler (which is to call abort!)
-  gsl_set_error_handler_off();
-}
-
-void Linear::exec()
-{
-  // Get the input workspace
-  MatrixWorkspace_const_sptr inputWorkspace = getProperty("InputWorkspace");
-  // Get the spectrum to fit
-  const int histNumber = getProperty("WorkspaceIndex");
-  // Check validity
-  if ( histNumber >= static_cast<int>(inputWorkspace->getNumberHistograms()) )
-  {
-    g_log.error() << "WorkspaceIndex set to an invalid value of " << histNumber << std::endl;
-    throw Exception::IndexError(histNumber,inputWorkspace->getNumberHistograms(),"Linear WorkspaceIndex property");
-  }
-
-  // Get references to the data in the chosen spectrum
-  const MantidVec& X = inputWorkspace->readX(histNumber);
-  const MantidVec& Y = inputWorkspace->readY(histNumber);
-  const MantidVec& E = inputWorkspace->readE(histNumber);
-  // Check if this spectrum has errors
-  double errorsCount = 0.0;
-
-  // Retrieve the Start/EndX properties, if set
-  this->setRange(X,Y);
-  
-  const bool isHistogram = inputWorkspace->isHistogramData();
-  // If the spectrum to be fitted has masked bins, we want to exclude them (even if only partially masked)
-  const MatrixWorkspace::MaskList * const maskedBins = 
-    ( inputWorkspace->hasMaskedBins(histNumber) ? &(inputWorkspace->maskedBins(histNumber)) : NULL );
-  // Put indices of masked bins into a set for easy searching later
-  std::set<size_t> maskedIndices;
-  if (maskedBins)
-  {
-    MatrixWorkspace::MaskList::const_iterator it;
-    for (it = maskedBins->begin(); it != maskedBins->end(); ++it)
-      maskedIndices.insert(it->first);
-  }
-  
-  progress(0);
-
-  // Declare temporary vectors and reserve enough space if they're going to be used
-  std::vector<double> XCen, unmaskedY, weights;
-  int numPoints = m_maxX - m_minX;
-  if (isHistogram) XCen.reserve(numPoints);
-  if (maskedBins) unmaskedY.reserve(numPoints);
-  weights.reserve(numPoints);
-
-  for (int i = 0; i < numPoints; ++i)
-  {
-    // If the current bin is masked, skip it
-    if ( maskedBins && maskedIndices.count(m_minX+i) ) continue;
-    // Need to adjust X to centre of bin, if a histogram
-    if (isHistogram) XCen.push_back( 0.5*(X[m_minX+i]+X[m_minX+i+1]) );
-    // If there are masked bins present, we need to copy the unmasked Y values
-    if (maskedBins) unmaskedY.push_back(Y[m_minX+i]);
-    // GSL wants the errors as weights, i.e. 1/sigma^2
-    // We need to be careful if E is zero because that would naively lead to an infinite weight on the point.
-    // Solution taken here is to zero weight if error is zero, which typically means Y is zero
-    //   (so it is effectively excluded from the fit).
-    const double& currentE = E[m_minX+i];
-    weights.push_back( currentE ? 1.0/(currentE*currentE) : 0.0 );
-    // However, if the spectrum given has all errors of zero, then we should use the gsl function that
-    //   doesn't take account of the errors.
-    if ( currentE ) ++errorsCount;
-  }
-  progress(0.3);
-  
-  // If masked bins present, need to recalculate numPoints here
-  if (maskedBins) numPoints = static_cast<int>(unmaskedY.size());
-  // If no points left for any reason, bail out
-  if (numPoints == 0)
-  {
-    g_log.error("No points in this range to fit");
-    throw std::runtime_error("No points in this range to fit");
-  }
-
-  // Set up pointer variables to pass to gsl, pointing them to the right place
-  const double * const xVals = ( isHistogram ? &XCen[0] : &X[m_minX] );
-  const double * const yVals = ( maskedBins ? &unmaskedY[0] : &Y[m_minX] );
-
-  // Call the gsl fitting function
-  // The stride value of 1 reflects that fact that we want every element of our input vectors
-  const int stride = 1;
-  double *c0(new double),*c1(new double),*cov00(new double),*cov01(new double),*cov11(new double),*chisq(new double);
-  int status;
-  // Unless our spectrum has error values for vast majority of points, 
-  //   call the gsl function that doesn't use errors
-  if ( errorsCount/numPoints < 0.9 )
-  {
-    g_log.debug("Calling gsl_fit_linear (doesn't use errors in fit)");
-    status = gsl_fit_linear(xVals,stride,yVals,stride,numPoints,c0,c1,cov00,cov01,cov11,chisq);
-  }
-  // Otherwise, call the one that does account for errors on the data points
-  else
-  {
-    g_log.debug("Calling gsl_fit_wlinear (uses errors in fit)");
-    status = gsl_fit_wlinear(xVals,stride,&weights[0],stride,yVals,stride,numPoints,c0,c1,cov00,cov01,cov11,chisq);
-  }
-  progress(0.8);
-
-  // Check that the fit succeeded
-  std::string fitStatus = gsl_strerror(status);
-  // For some reason, a fit where c0,c1 & chisq are all infinity doesn't report as a 
-  //   failure, so check explicitly.
-  if ( !gsl_finite(*chisq) || !gsl_finite(*c0) || !gsl_finite(*c1) )
-    fitStatus = "Fit gives infinities";
-  if (fitStatus != "success") g_log.error() << "The fit failed: " << fitStatus << "\n";
-  else
-    g_log.information() << "The fit succeeded, giving y = " << *c0 << " + " << *c1 << "*x, with a Chi^2 of " << *chisq << "\n";
-  
-  // Set the fit result output properties
-  setProperty("FitStatus",fitStatus);
-  setProperty("FitIntercept",*c0);
-  setProperty("FitSlope",*c1);
-  setProperty("Cov00",*cov00);
-  setProperty("Cov11",*cov11);
-  setProperty("Cov01",*cov01);
-  setProperty("Chi2",*chisq);
-  
-  // Create and fill a workspace2D with the same bins as the fitted spectrum and the value of the fit for the centre of each bin
-  const size_t YSize = Y.size();
-  MatrixWorkspace_sptr outputWorkspace = WorkspaceFactory::Instance().create(inputWorkspace,1,X.size(),YSize);
-  
-  // Copy over the X bins
-  outputWorkspace->dataX(0).assign(X.begin(),X.end());
-  // Now loop over the spectrum and use gsl function to calculate the Y & E values for the function
-  for (size_t i = 0; i < YSize; ++i)
-  {
-    const double x = ( isHistogram ? 0.5*(X[i]+X[i+1]) : X[i] );
-    const int err = gsl_fit_linear_est(x,*c0,*c1,*cov00,*cov01,*cov11,&(outputWorkspace->dataY(0)[i]),&(outputWorkspace->dataE(0)[i]));
-    if (err) g_log.warning() << "Problem in filling the output workspace: " << gsl_strerror(err) << std::endl;
-  }
-  setProperty("OutputWorkspace",outputWorkspace);
-  progress(1);
-  // Clean up
-  delete c0;
-  delete c1;
-  delete cov00;
-  delete cov01;
-  delete cov11;
-  delete chisq;
-}
-
-/// Retrieve and check the Start/EndX parameters, if set
-void Linear::setRange(const MantidVec& X, const MantidVec& Y)
-{
-  //read in the values that the user selected
-  double startX = getProperty("StartX");
-  double endX = getProperty("EndX");
-  //If the user didn't a start default to the start of the data
-  if ( isEmpty(startX) ) startX = X.front();
-  //the default for the end is the end of the data
-  if ( isEmpty(endX) ) endX = X.back();
-
-  // Check the validity of startX
-  if ( startX < X.front() )
-  {
-    g_log.warning("StartX out of range! Set to start of frame.");
-    startX = X.front();
-  }
-  // Now get the corresponding bin boundary that comes before (or coincides with) this value
-  for (m_minX = 0; X[m_minX+1] < startX; ++m_minX) {}
-
-  // Check the validity of endX and get the bin boundary that come after (or coincides with) it
-  if ( endX >= X.back() || endX < startX )
-  {
-    if ( endX != X.back() )
-    {
-      g_log.warning("EndX out of range! Set to end of frame");
-      endX = X.back();
-    }
-    m_maxX = static_cast<int>(Y.size());
-  }
-  else
-  {
-    for (m_maxX = m_minX; X[m_maxX] < endX; ++m_maxX) {}
-  }  
-}
-
-} // namespace Algorithm
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/CurveFitting/src/SeqDomain.cpp b/Code/Mantid/Framework/CurveFitting/src/SeqDomain.cpp
index c4a3ed24ac33..c5415b71c653 100644
--- a/Code/Mantid/Framework/CurveFitting/src/SeqDomain.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/SeqDomain.cpp
@@ -101,7 +101,7 @@ void SeqDomain::leastSquaresVal(const CostFuncLeastSquares& leastSquares)
 //------------------------------------------------------------------------------------------------
 /**
  * Calculate the value of a least squares cost function
- * @param leastSquares :: The least squares cost func to calculate the value for
+ * @param rwp :: The RWP cost func to calculate the value for
  */
 void SeqDomain::rwpVal(const CostFuncRwp& rwp)
 {
diff --git a/Code/Mantid/Framework/CurveFitting/src/SplineInterpolation.cpp b/Code/Mantid/Framework/CurveFitting/src/SplineInterpolation.cpp
index d83c26715a64..459d611eff38 100644
--- a/Code/Mantid/Framework/CurveFitting/src/SplineInterpolation.cpp
+++ b/Code/Mantid/Framework/CurveFitting/src/SplineInterpolation.cpp
@@ -248,7 +248,6 @@ namespace Mantid
      * @param inputWorkspace :: The input workspace
      * @param outputWorkspace :: The output workspace
      * @param order :: The order of derivatives to calculate
-     * @param row :: The row of spectra to use
      */
     void SplineInterpolation::calculateDerivatives(API::MatrixWorkspace_const_sptr inputWorkspace,
         API::MatrixWorkspace_sptr outputWorkspace, int order) const