Redesigned algorithm for redistribution of solid precip on steep slopes. This is done by pushing precip from the top to the bottom of the slope.
Curvature correction has been turned off. Now this redesign will be validated with laser-scanner data. 

More size_t fixes (ie trying to be consistent) and a bug was found when spatially interpolating using a few specific algorithms that would not reset their internal vectors between two calls (thanks Matteo for helping uncover this bug!)

Some "TODO" have been removed, a missing check has been added in Interpol1D:linRegression (at least 2 valid points are required), type inconsistencies have been fixed in FilterTukey and ProcessinStack. However using size_t for the meteo parameter index is not necessarily a good idea and this will require a careful review.

A new test has been created to cover basic statistical functions on vectors. Two bugs have been found and fixed when computing the derivative on a vector of data (the right derivative was in fact a left derivative and the case of X containing nodata was not covered).

Documentation fixes in libinterpol2D and ResamplingAlgorithms. The cmake macro for finding MeteoIO now looks first in the home directory of the user on Mac (as is done on Linux).

One more step closer to the goal: the dem is now only passed when calling calculate() and the simpleDEMWindInterpolate now computes the curvatures if necessary.

Small optimizations in IOHandler.

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.

Lots of vectors copies were made using push_back(). This is definitely not efficient! This has been replaced by vec_o = vec_i, we will see which impact it has on performances...

fixing some of the warnings found on Hera (sorry for not noticing before). All the size_t / unsigned int stuff will have to be addressed 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).

Since the autotools are obsolete (and unmaintained) in MeteoIO, they have been removed. The popc++ version can be compiled with cmake (with some tricks: disable GSN and force the compiler to popcc). 

For consistency, the various definitions of ot_deg and to_rad have been suppressed and replaced by Cst::to_deg or Cst::to_rad. Some mentions of the Earth's radius have been replaced by Cst::earth_R0. In Coords, some variables have been declared as const.

The Passive_T filter has been reworked and renamed as ProcPassiveT. A proper documentation has been written for it.

All the cout have been replaced by cerr in order to avoid messing with the end user's application. Some old commented out code has been removed.

Hopefully, a (slightly) more sensitive fix (there is no need to apply any correction to a null wind speed!)

An extra check on the timestamp has been added in SMETIO in order to throw an exception for duplicated timestamps or non chronological order (as happens with daylight saving time). Some private methods in libinterpol2D as well as some () operators for the arrays are now inline in order to help autovectorization find more potentially vectorizable code (and it finds some more). An arithmetic exception could happen in FilterRate (division by 0) and has been fixed.

If the speed is equal to 0 (exactly) we assume a small speed of 0.01 m/s.

Otherwise a division by zero would occur because:
u = (-1.) * (speed * sin(dir));
dir = (1.5 * Cst::PI) - atan(v/u);

IOManager: added another interpolate procedure that takes as arguments a Date, a DEMObject, the parameter to interpolate, a vector of Coords objects and a vector of doubles. The Coords represent different points in the DEM. The interpolation is only performed for these points and for each point one double value is stored in a vector. 

Furthermore IOManager now has a member variable called interpolater of type Meteo2DInterpolator. A circular inclusion problem has been solved between IOManager and Meteo2DInterpolator.

libinterpol2D bugfix: The SimpleDEMWindInterpolate algorithm had  a small bug in it, it wasn't interpolating values in the last row or last column of the 2D grid.

A new file has been created to contain math optimizations (fast invSqrt, fast floor, etc). Please keep in mind that you must benchmark your code before committing something using these functions, since such optimizations can actually be slower than the standard version in some cases...

Since the _USE_MATH_DEFINES for Windows was making trouble (it should have enabled using M_PI), the basic math constants have been added to meteolaws/meteoconst.h. Now, please use things like Cst::PI and include meteoconst.h.

Speed improvement for IDW based on the profiling performed by HES-SO's V. Grivel: the stations' positions are saved in two vectors (eastings and northings) before walking the grid. For low number of stations, this makes no visible difference. For large number of stations, this makes a huge difference (as seen on the Graubünden simulation, with 35 stations).

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.

Oups, types mismatch... and the version numbers have been pushed up in order to prepare for the upcoming release

The LIDW interpolation was not safe when less stations were available than the requested number of neighbors. Since this interpolation method is still quite experiemental (the bilinear lapse rate can lead to very wrong results), it has been removed from the example io.ini.

Because POPC does not properly support std::cout and requires cout instead, this has been fixed in the code, with the necessary "using namespace" added. Only one std::cout remains (in IOUtils) and will be removed if absolutely necessary later.

The OLWR hack for Norway has been implemented in SMETIO (a cleaner, long term solution will still have to be developed). Various types issues have been identified by Visual C++ and should have been fixed.

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.

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 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).

The Welcome and Readme texts have been swapped. A new index file has been made for the html documentation, that sits above the html directory and redirects to the proper page. Some unnecessary (and commented) lines for cpack have been cleaned up.

A warning has been silenced for Visual C++ (float to double cast in the Quake3 optimized square root).

The arrays are now using the vector filling methods when possible. A specialized template for convertString(unsigned int) has been written. 

A two segments linear fit (for elevation detrending) has been implemented with a fixed inflection point. This is quite primitive but allows the LLIDW spatial interpolation to use it and therefore to behave like the traditional SLF SnowFit program. More work will be needed for fully configurable regression algorithm choice though... 

Some namming issues have been fixed in COSMOXML. A better emissivity handling has been implemented in SNIO to be closer to the original Snowpack (ie: compute clear sky ILWR when no cloudiness/emissivity is given).

More fixes for Visual C++ (but not all done yet) as well as new assignments operators for 1d, 2d, 3d arrays. It is now possible to do something like my2Dgrid.grid2D = 2.; and every cell will be filled with 2.

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...