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

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

The median computations were relying on std::nth_element and wrongly assuming that the output would be sorted. This is non-standard behavior and is not the case with more recent versions of the STL. This has been fixed.

The ProcessingStack constructor has been optimized by using new methods of Config to remove some now redundant code.

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

Removing some unnecessary pointers (for things like "const double a = vecM[ii](param)") and replacing a vector push_back by a proper allocation in constructor followed by assignments

Some code cleanup and micro-optimizations. The documentation has been improved (configuration of doxygen as well as some duplicate section labels).

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

Bugfix in libinterpol1D.cc: "if (in_X.size()>0) B=in_X[1]" should read "if (in_X.size()>0) B=in_X[0]"

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.

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

Spatial resampling has been added. This is still quite primitive (no end-user front end or interaction, only nearest neighbor or bilinear), but can nevertheless be convenient. Since the "round" function call was needed, the VC++ implementation has been moved to IOUtils so no matter what is the compiler, we can use "round" in the code (this is NOT in the IOUtils namespace, but still in the mio namespace). 

Several obsolte comments/hacks have been removed and the DEBUG_ARITHM flag commented out, since it does not belong into a library (this is per process, not per object). The VC++ "equivalent" flag still needs to be checked (ie: is it per process or per object?). A missing "required" flag for cmake for Oracle has been added.

Finally, the lsm file had been forgotten in the last release... this is now in order.

Fixing some unsigned int / size_t conversion issues by using more widely size_t (as it seems to be recommended and done in the STL)

A bug has been found in the processing of the variance: we were using a naive formula that is ill-fitted to signals showing small variations around a large mean. This lead to catastrophic cancellation and negative values... This has been replaced by a (slower) compensated formula (that works in two passes). The standard deviation filter has been fixed. 

The Tukey filter has been brought back into the new infrastructure and should now be usable. However it is not suitable to snow heights: in such a case, the standard deviation is too small (or even zero) and the signal might show some sudden variations (like in the case of a snow fall) that would therefore be falsely rejected. This filter seems much better suited to wind speeds that exhibit some constant background noise, thus a non-null standard deviation.

The rate filter can now take 2 arguments: in such a case, the first one is the minimum rate and the second the maximum rate. This would allow to define a descent rate different from the climb rate.

Several error messages have been improved in A3DIO and general plugin loading.

Finally, two small tools for working with smet files have been contributed, one allowing transparent loading of smet files in xmgrace (smet2agr). And the example io.ini has been fixed (it had been broken and was not working with the examples anymore)

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

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 smoothing algorithms have been renammed as Process instead of Filter. The rate and the Tukey filters have been improved so that they correctly handles nodata.

A new resampling algorithm has been introduced: "none". It does just that: nothing. This is an easy way to debug filters by not performing any temporal interpolations.

The getMedian method has been re-implemented using the standard nth_element method for increased performances.

The doxygen documentation has been updated to reflect the latest changes.

Some code annotations (TODO and HACK) as well as new filters or new implementations: rate filter, standard deviation filter and Tukey 53H filter.

An error was found: the linear regression returns the regression coefficient r, not r2!! It has been modified so that it returns |r| and prints r2 in the info strings.

The HNW_SNOW spatial interpolation algorithm had errors. It was not properly calling its base algorithm (the one computing the initial distribution) and its rating was too low. It has now the same rating as CST_LAPSE for one station when the lapse rate is provided. This could be improved in the future, to make it depend on the rating of the base algorithm...

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.

The linear regression implementation is now able to remove a variable number of "invalid" points based on the initial size of the data set. Some extra weighting methods have been implemented (but are not yet used).

ImisIO ran into troubles with oracle when requesting a date with the hour set to 24 (ORACLE only accepts values from 0 to 23), thus a small fix needed to be applied.

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. 

Then, the remaining namespace issues with doxygen have been fixed, by enclosing the full class implementation in the namespace (as seen for the libstdc++). This removes all these irritating issues. But the popc version has been broken by the change (as seen in LegacyIO).

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.

A new slope computation algorithm has bee added: CARD It computes the slope using Corripio and then discretizes the azimuth along 8 cardinal directions and the slope by degrees. This should be all that GEOtop needs for its drainage direction (then simply calling a dem.update("CARDINAL")).

The copyright notices have been put in place in all files (headers and cc) with proper attribution of copyright.

The documentation has been improved, specially fixing issue 22. Warning messages of doxygen have been fixed. An example subdirectory has been created in /doc and contains (currently) 2 examples of code using MeteoIO.