Slightly improved documentation on spatial interpolations and now really allowing linear regression on only 2 points

The Krigging is now working. The current limitations are: 1)there is no maximum range, so each available station would take part to the variogram fit. 2)the covariance is currently NOT computed on past time series, limiting the relevance of the variogram. Practically, the variogram fit that always ends up being used is LINVARIO.

All matrix and fit methods that used to return void but could also throw exceptions now return a boolean to indicate if things went well (ie a matrix could be inverted, etc). They still throw exceptions for logic errors (incompatible dimensions, etc).

Following the latest changes, this is a general code cleanup in all the classes involved in spatial interpolations. The LIDW method has been commented out since this works very poorly and would need to be properly redone.

Moving forward with the trend/residuals approach for the spatial interpolations: here are the necessary changes in the supporting infrastructure: basically, better handling of forced lapse rates and fractional lapse rates, proper toString() methods for the fit1D object and components

Preparing the way for the new spatial interpolation architecture: the 1D regressions should now offer the necessary features (but this is a first shot at it, it will need to be redone in a more generic way later).

Lots of small fixes after running cppcheck on Windows: unused variables, use ++i instead of i++ for complex types (ie mostly iterators for us) for more performance, a few variables that could be passed as const&, use vector.empty() instead of vector.size==0 (for clarity and potentially performances).

The Fit1D class constructor can now read a fit model name as a string. This was necessary for parsing a user input coming from io.ini. 

The ordinary kriging interpolation algorithm is now active. It is far from perfect (the variogram is computed in a very cheap way that contributes to make it very fragile), but it is time for the first users to start playing with it. The variogram model to use can be provided as an optional argument and in case of fit failure, an appropriate error message is given (but no fallback mechanism exists). The next step will be to compute the variogram on time series, which should produce more reliable data sets for fitting the variogram model on.

Some error messages have been improved in the matrix class.

Several HACKS have been removed (either the HACK had been fixed but the comment was still there, or it has now been fixed, or after more (careful) consideration, it has been decided that the HACK was not a HACK)

The VW_MAX field was not properly handled in SMETIO. The failure count has been slightly improved in SNIO (to decrease the number of failures when a model could recover: if ILWR is not provided but TSS is, we don't count it as a failure anymore). 

The implementation of the krigging is moving forward. A bug has been found and fixed in Fit1D, a variogram is now computed (but not using a true covariance, which prevents our krigging from properly working). 

The #define NOSAFECHECKS have been deleted and replaced by a definition by the CMakeLists when in debug mode. This means that when compiling in debug mode, the code will be quite slower but will properly check and report out of bounds access in tables and matrix.

A Fit1D object is now created by specifying which regression model to use through an enum. Assignment operators as well as copy constructors have also been implemented (and tested).

The config.dox file has been updated by doxygen to match more recent doxygen versions and syntax.

A (more) intelligent handling of buffered grids has been implemented: the grids are stored in the equivalent of a circular buffer of a given size (user defined, or 10 by default). This prevents running out of memory when processing large numbers of grids!

A method for computing quantiles has been implemented in libinterpol1D. A vector of data has to be provided as well as a vector of the desired quantiles (ex: 0.25, 0.5, 0.75) and a vector of values for these quantiles will be returned. So far, the algorithm that is used produces the same results as R in default operations. The possibility of choosing which quantiles algorithms might be added in the future.

The getJulianDayNumber method was just totally wrong... This has been fixed. One can also force a GMT day of year with a flag.

Finally, some documentation has been written/updated.

Some methods have been moved into another class (like the simple linear interpolation between two points that is now in ResamplingAlgorithms), some renammed (like the new weightedMean that replaces the ill-nammed "linearInterpolate"). The regression model based on two segments is now part of libinterpol1D and has been renammed. More regression models have been implemented. 

The "initFit" method of Fit1D has been renammed in "fit" and the setGuess method now turns fit_ready to true, so that a user can force his provided parameters to be used by a given model (do a setGuess() with the parameters, then call f(x) without calling "fit", so no internal fit of the parameters would be performed).

Reorganizing all the statistical elements... this commit won't compile, this is just to move files around. Wait for next commit before updating!

The standard linear regression as well as our tweaked "noisy linear" regression have been integrated into the Fit1D class. This means that we should now only use this class for statistical models. The implementation that is in libinterpol1D will be moved into libfitCore.

The 1D regression component is now coming into shape: the Fit1D class receives two vectors (of X and Y), compute a specified regression model, then transparently provides modelled values (calling fit1D.f()). Introducing a new regression model consists of implementing this f() method as well as a method computing initial guesses. A new method has been introduced in libInterpol1D that computes the derivative of a data set, given a vector of X and a vector of Y. Another method has been implemented to sort such two vectors in order of increasing X.

Partial pivoting has been implemented in Matrix, and complete pivoting has been started but is not finished yet (it will throw an exception if used).

In SNIO, the METAFILE can now be optional (which means that the metadata remain nodata, the user has therefore to fill them himself). This is used by Snowpack.

After the Visual C++ compilation log from Raphael, some changes have been implemented: lots of warnigs about signed/unsigned fixed, some unreachable code removed, and some methods reimplemented for Windows. We are not there yet, but moving closer...

The necessary wrapping code has been added, so that the user can dynamically specify which regression model to use. This might have to be done differently in the future, so that sensible initial guess could be associated with each model.

The least square fit now works. It still needs some polishing (to dynamically change the fit model), but the core works.

A new way of calling Matrix::solve has been added (writing the result into a given matrix instead of allocating a new one).

A missing include in MeteoIO.h has been added.

A new group of classes has been created, under the meteolaws subdirectory. This contains various general meteorological laws, such as a sun radiation model, standard atmosphere, etc

The first implementation (not tested yet) of a non-linear least square fit algorithm has been implemented in the libfit1D. 

Several documentation issues have been fixed (obsolete code examples, etc) and classes grouped by modules. This should help the user to quickly locate the classes of interest.