The noisy linear fit now removes points based on their distance to the regression line (this should be marginally better but is anyway simpler and faster). 

The new usage timers have been slightly cleaned up for white spaces and for precision (casting to long double first in order to avoid loss of precision as shown with the previous timers). The declaration order in the class now takes care of alignments issues.

Fixing some warnings for Visual C++ and also using ostringstream instead of stringstream when appropriate

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

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

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

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. 

A new spatial interpolation algorithm, LocalLapse_IDW (key being LIDW_LAPSE) has been implemented. It takes a number of stations  as mandatory parameter, and computes for each pixel the IDW_LAPSE only using the closest n stations. This is specially useful when dealing with large number of stations over a wide area. Please keep in mind that since the linear regression calculation might exclude some outliers, a sufficiently large number of stations should be given.

The algorithm that is computing a linear regression with the possibility of excluding some outliers has been renamed as NoisyLinRegression and moved to Interpol1D. Moreover, the regression algorithm provide an information stringstream that can be directly printed to the screen (usual behavior) or differently handled (specially useful for mutliple regressions calculations or when using GUIs).

The spatial interpolation algorithm MUST now be initialized by calling their initialize(param) method. This makes it possible to optimize their processing (not recomputing the list of stations to process, etc) and also allow to build an info string that can be returned with the interpolation and contain various useful information (specially for GUIs).

The embryo of a matrix class has been implemented. It is still based on Array2D and therefore the indexing is still 0 to n-1 instead of being 1 to n and the coordinates are swapped compared to normal matrices.

New regression models have been added, all based on the linear regression code but using variable transforms to achieve their goal. 

The global header file (MeteoIO.h) was incomplete. It has therefore been reorganized and now contains everything that it should...

Several 1D statistical methods has been implemented while the existing ones have been made nodata safe.

Added a redefinition of the << operator for IOPlugin and IOHandler. This should be convenient for debugging!

Some small optimizations have been brought into the spatial interpolations following some tests with cachegrind. Nothing huge, but small improvements.

Overall all include statements within in the library have been replaced by angle brackets, the default install path for the include file is $CMAKE_INSTALL_DIR/include/meteoio, the meteoio libraries (static and shared) will be installed in $CMAKE_INSTALL_DIR/lib per default.

The plugins will be installed in the subdirectory $CMAKE_INSTALL_DIR/lib/meteoio/plugins

New interpolation interface: Now the 1D interpolation can be configured by the user through an own section in io.ini:

[Interpolations1D]
TA::resample = linear
TA::args     = extrapolate
RH::resample = nearest_neighbour
HNW::resample = no
P::resample = linear

Currently two algorithms are implemented: linear interpolation and nearest_neighbour interpolation. The interpolation can be switched off explicitly by P::resample = no

The default remains linear resampling, however the linear resampling may not only resample within bounds (interpolate), but also out of bounds (extrapolate), this needs to be configured with the resampling algorithm argument "extrapolate" as seen in the example above. 

Changed the name of the Date_IO class to Date. In case of namespace conflicts, just use mio::Date to reference the MeteoIO Date class.

The new interpolations interface with all algorithms that used to reside within libinterpol2D exclusively. Every algorithm is an own class derived from InterpolationAlgorithm abstract base class. An AlgorithmFactory instantiates the required algorithm within class Meteo2DInterpolator. The user needs to configured which algorithms to be used within the section [Interpolations2D] in the io.ini:

[Interpolations2D]
TA::algorithms = cst cst_lapse idw_lapse
TA::cst_lapse = -0.008

libinterpol1D has a new function for the calculation of arithmetic means. all of libinterpol2D is static. the rest will be thrown out in the coming days.

The license information has been added: LPGLv3 headers in all header files, license texts as well as a Linux Software Map entry file.

The installation procedure has been added to cmake configuration files (similar to the autotools)

The whole library has been given its new name and several classes have been renamed in order to better match their purpose. The Makefile has been modified accordingly.