diff options
Diffstat (limited to 'src/boost/libs/accumulators')
57 files changed, 6134 insertions, 0 deletions
diff --git a/src/boost/libs/accumulators/example/Jamfile.v2 b/src/boost/libs/accumulators/example/Jamfile.v2 new file mode 100644 index 000000000..eff105b37 --- /dev/null +++ b/src/boost/libs/accumulators/example/Jamfile.v2 @@ -0,0 +1,13 @@ +# (C) Copyright 2004: Eric Niebler +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +exe example + : + main.cpp + : + <include>../../.. + <include>$(BOOST_ROOT) + <library>/boost/serialization + <cxxflags>"-Wno-deprecated-declarations" + ; diff --git a/src/boost/libs/accumulators/example/example.vcproj b/src/boost/libs/accumulators/example/example.vcproj new file mode 100644 index 000000000..535370e89 --- /dev/null +++ b/src/boost/libs/accumulators/example/example.vcproj @@ -0,0 +1,396 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="example" + ProjectGUID="{57D2AB8B-8CBB-4B28-921E-C6916109B843}" + Keyword="Win32Proj"> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory="Debug" + IntermediateDirectory="Debug" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..\..\..;$(BOOST_ROOT)" + PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" + MinimalRebuild="TRUE" + BasicRuntimeChecks="3" + RuntimeLibrary="5" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="3"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/example.exe" + LinkIncremental="2" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/example.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory="Release" + IntermediateDirectory="Release" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + AdditionalIncludeDirectories="..\..\..;$(BOOST_ROOT)" + PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" + RuntimeLibrary="4" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="3"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/example.exe" + LinkIncremental="1" + GenerateDebugInformation="TRUE" + SubSystem="1" + OptimizeReferences="2" + EnableCOMDATFolding="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" + UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> + <File + RelativePath=".\main.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc;xsd" + UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> + <File + RelativePath="..\..\..\boost\accumulators\accumulators.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\accumulators_fwd.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics_fwd.hpp"> + </File> + <Filter + Name="statistics" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\statistics\count.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\covariance.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\density.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\error_of.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\error_of_mean.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\extended_p_square.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\extended_p_square_quantile.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\kurtosis.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\max.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\mean.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\median.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\min.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\moment.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\p_square_cumulative_distribution.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\p_square_quantile.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\peaks_over_threshold.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\pot_quantile.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\pot_tail_mean.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\skewness.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\stats.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\sum.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\tail.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\tail_mean.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\tail_quantile.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\tail_variate.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\tail_variate_means.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\times2_iterator.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\variance.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_covariance.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_density.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_extended_p_square.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_kurtosis.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_mean.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_median.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_moment.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_p_square_cumulative_distribution.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_p_square_quantile.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_peaks_over_threshold.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_skewness.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_sum.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_tail_mean.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_tail_quantile.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_tail_variate_means.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\weighted_variance.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\statistics\with_error.hpp"> + </File> + <Filter + Name="variates" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\statistics\variates\covariate.hpp"> + </File> + </Filter> + <Filter + Name="parameters" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\statistics\parameters\quantile_probability.hpp"> + </File> + </Filter> + </Filter> + <Filter + Name="framework" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulator_base.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulator_concept.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulator_set.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\depends_on.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\external.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\extractor.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\features.hpp"> + </File> + <Filter + Name="parameters" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\framework\parameters\accumulator.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\parameters\sample.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\parameters\weight.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\parameters\weights.hpp"> + </File> + </Filter> + <Filter + Name="accumulators" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulators\droppable_accumulator.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulators\external_accumulator.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulators\reference_accumulator.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\framework\accumulators\value_accumulator.hpp"> + </File> + </Filter> + </Filter> + <Filter + Name="numeric" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\numeric\functional.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\functional_fwd.hpp"> + </File> + <Filter + Name="functional" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\numeric\functional\complex.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\functional\valarray.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\functional\vector.hpp"> + </File> + </Filter> + <Filter + Name="detail" + Filter=""> + <File + RelativePath="..\..\..\boost\accumulators\numeric\detail\function1.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\detail\function2.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\detail\function3.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\detail\function4.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\detail\function_n.hpp"> + </File> + <File + RelativePath="..\..\..\boost\accumulators\numeric\detail\pod_singleton.hpp"> + </File> + </Filter> + </Filter> + </Filter> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/src/boost/libs/accumulators/example/main.cpp b/src/boost/libs/accumulators/example/main.cpp new file mode 100644 index 000000000..2c525b21d --- /dev/null +++ b/src/boost/libs/accumulators/example/main.cpp @@ -0,0 +1,262 @@ +/////////////////////////////////////////////////////////////////////////////// +// main.hpp +// +// Copyright 2005 Eric Niebler. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <fstream> // needed for de/serialization example (4) +#include <algorithm> +#include <boost/ref.hpp> +#include <boost/bind.hpp> +#include <boost/array.hpp> +#include <boost/foreach.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics.hpp> +// needed for de/serialization example (4) +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace boost::accumulators; + +// Helper that uses BOOST_FOREACH to display a range of doubles +template<typename Range> +void output_range(Range const &rng) +{ + bool first = true; + BOOST_FOREACH(double d, rng) + { + if(!first) std::cout << ", "; + std::cout << d; + first = false; + } + std::cout << '\n'; +} + +/////////////////////////////////////////////////////////////////////////////// +// example1 +// +// Calculate some useful stats using accumulator_set<> and std::for_each() +// +void example1() +{ + accumulator_set< + double + , stats<tag::min, tag::mean(immediate), tag::sum, tag::moment<2> > + > acc; + + boost::array<double, 4> data = {0., 1., -1., 3.14159}; + + // std::for_each pushes each sample into the accumulator one at a + // time, and returns a copy of the accumulator. + acc = std::for_each(data.begin(), data.end(), acc); + + // The following would be equivalent, and could be more efficient + // because it doesn't pass and return the entire accumulator set + // by value. + //std::for_each(data.begin(), data.end(), bind<void>(ref(acc), _1)); + + std::cout << " min""(acc) = " << (min)(acc) << std::endl; // Extra quotes are to prevent complaints from Boost inspect tool + std::cout << " mean(acc) = " << mean(acc) << std::endl; + + // since mean depends on count and sum, we can get their results, too. + std::cout << " count(acc) = " << count(acc) << std::endl; + std::cout << " sum(acc) = " << sum(acc) << std::endl; + std::cout << " moment<2>(acc) = " << accumulators::moment<2>(acc) << std::endl; +} + +/////////////////////////////////////////////////////////////////////////////// +// example2 +// +// Calculate some tail statistics. This demonstrates how to specify +// constructor and accumulator parameters. Note that the tail statistics +// return multiple values, which are returned in an iterator_range. +// +// It pushes data in and displays the intermediate results to demonstrate +// how the tail statistics are updated. +void example2() +{ + // An accumulator which tracks the right tail (largest N items) and + // some data that are covariate with them. N == 4. + accumulator_set< + double + , stats<tag::tail_variate<double, tag::covariate1, right> > + > acc(tag::tail<right>::cache_size = 4); + + acc(2.1, covariate1 = .21); + acc(1.1, covariate1 = .11); + acc(2.1, covariate1 = .21); + acc(1.1, covariate1 = .11); + + std::cout << " tail = "; output_range(tail(acc)); + std::cout << " tail_variate = "; output_range(tail_variate(acc)); + std::cout << std::endl; + + acc(21.1, covariate1 = 2.11); + acc(11.1, covariate1 = 1.11); + acc(21.1, covariate1 = 2.11); + acc(11.1, covariate1 = 1.11); + + std::cout << " tail = "; output_range(tail(acc)); + std::cout << " tail_variate = "; output_range(tail_variate(acc)); + std::cout << std::endl; + + acc(42.1, covariate1 = 4.21); + acc(41.1, covariate1 = 4.11); + acc(42.1, covariate1 = 4.21); + acc(41.1, covariate1 = 4.11); + + std::cout << " tail = "; output_range(tail(acc)); + std::cout << " tail_variate = "; output_range(tail_variate(acc)); + std::cout << std::endl; + + acc(32.1, covariate1 = 3.21); + acc(31.1, covariate1 = 3.11); + acc(32.1, covariate1 = 3.21); + acc(31.1, covariate1 = 3.11); + + std::cout << " tail = "; output_range(tail(acc)); + std::cout << " tail_variate = "; output_range(tail_variate(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// example3 +// +// Demonstrate how to calculate weighted statistics. This example demonstrates +// both a simple weighted statistical calculation, and a more complicated +// calculation where the weight statistics are calculated and stored in an +// external weight accumulator. +void example3() +{ + // weight == double + double w = 1.; + + // Simple weighted calculation + { + // stats that depend on the weight are made external + accumulator_set<double, stats<tag::mean>, double> acc; + + acc(0., weight = w); + acc(1., weight = w); + acc(-1., weight = w); + acc(3.14159, weight = w); + + std::cout << " mean(acc) = " << mean(acc) << std::endl; + } + + // Weighted calculation with an external weight accumulator + { + // stats that depend on the weight are made external + accumulator_set<double, stats<tag::mean>, external<double> > acc; + + // Here's an external weight accumulator + accumulator_set<void, stats<tag::sum_of_weights>, double> weight_acc; + + weight_acc(weight = w); acc(0., weight = w); + weight_acc(weight = w); acc(1., weight = w); + weight_acc(weight = w); acc(-1., weight = w); + weight_acc(weight = w); acc(3.14159, weight = w); + + std::cout << " mean(acc) = " << mean(acc, weights = weight_acc) << std::endl; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// example4 +// +// Show how accumulators could be persisted into a file, and then continued +// from where they were left of +// +void example4() +{ + accumulator_set< + double + , stats<tag::min, tag::mean(immediate), tag::sum, tag::moment<2>, tag::p_square_quantile, tag::kurtosis > + > acc(quantile_probability = 0.9); + + { + // accumulate values from array + boost::array<double, 10> data = {-10., -8., -7., -6., -5., -4., -3., -2., -1., 0.}; + + acc = std::for_each(data.begin(), data.end(), acc); + } + + std::cout << " min = " << (min)(acc) << std::endl; + std::cout << " mean = " << mean(acc) << std::endl; + std::cout << " count = " << count(acc) << std::endl; + std::cout << " sum = " << sum(acc) << std::endl; + std::cout << " moment<2> = " << accumulators::moment<2>(acc) << std::endl; + std::cout << " p_square_quantile = " << accumulators::p_square_quantile(acc) << std::endl; + std::cout << " kurtosis = " << accumulators::kurtosis(acc) << std::endl; + + // save accumulator list into a file called "saved-stats" + const unsigned ACC_VER = 0; + const char* file_name = "saved-stats"; + { + std::ofstream ofs(file_name); + boost::archive::text_oarchive oa(ofs); + acc.serialize(oa, ACC_VER); + } + + // create a new accumulator set and initialize from data saved into the file + accumulator_set< + double + , stats<tag::min, tag::mean(immediate), tag::sum, tag::moment<2>, tag::p_square_quantile, tag::kurtosis > + > restored_acc(quantile_probability = 0.9); + + { + std::ifstream ifs(file_name); + boost::archive::text_iarchive ia(ifs); + restored_acc.serialize(ia, ACC_VER); + } + + // continue accumulating into both sets + { + // accumulate values from array + boost::array<double, 10> data = {10., 8., 7., 6., 5., 4., 3., 2., 1., 0.}; + + acc = std::for_each(data.begin(), data.end(), acc); + restored_acc = std::for_each(data.begin(), data.end(), restored_acc); + } + + // validate that both return th same values + std::cout << std::endl << "Values in original set:" << std::endl; + std::cout << " min""(acc) = " << (min)(acc) << std::endl; + std::cout << " mean(acc) = " << mean(acc) << std::endl; + std::cout << " count(acc) = " << count(acc) << std::endl; + std::cout << " sum(acc) = " << sum(acc) << std::endl; + std::cout << " moment<2>(acc) = " << accumulators::moment<2>(acc) << std::endl; + std::cout << " p_square_quantile(acc) = " << accumulators::p_square_quantile(acc) << std::endl; + std::cout << " kurtosis(acc) = " << accumulators::kurtosis(acc) << std::endl; + + std::cout << std::endl << "Values in restored set:" << std::endl; + std::cout << " min""(acc) = " << (min)(restored_acc) << std::endl; + std::cout << " mean(acc) = " << mean(restored_acc) << std::endl; + std::cout << " count(acc) = " << count(restored_acc) << std::endl; + std::cout << " sum(acc) = " << sum(restored_acc) << std::endl; + std::cout << " moment<2>(acc) = " << accumulators::moment<2>(restored_acc) << std::endl; + std::cout << " p_square_quantile(acc) = " << accumulators::p_square_quantile(restored_acc) << std::endl; + std::cout << " kurtosis(acc) = " << accumulators::kurtosis(restored_acc) << std::endl; + +} + +/////////////////////////////////////////////////////////////////////////////// +// main +int main() +{ + std::cout << "Example 1:\n"; + example1(); + + std::cout << "\nExample 2:\n"; + example2(); + + std::cout << "\nExample 3:\n"; + example3(); + + std::cout << "\nExample 4:\n"; + example4(); + + return 0; +} diff --git a/src/boost/libs/accumulators/index.html b/src/boost/libs/accumulators/index.html new file mode 100644 index 000000000..c9aff26d2 --- /dev/null +++ b/src/boost/libs/accumulators/index.html @@ -0,0 +1,15 @@ +<html> +<head> +<meta http-equiv="refresh" content="0; URL=../../doc/html/accumulators.html"> +</head> +<body> +Automatic redirection failed, please go to +<a href="../../doc/html/accumulators.html">../../doc/html/accumulators.html</a> +<p>Copyright Eric Niebler 2006</p> +<p>Distributed under the Boost Software License, Version 1.0. (See accompanying file +<a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at +<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>). +</p> +</body> +</html> + diff --git a/src/boost/libs/accumulators/meta/libraries.json b/src/boost/libs/accumulators/meta/libraries.json new file mode 100644 index 000000000..3577daa68 --- /dev/null +++ b/src/boost/libs/accumulators/meta/libraries.json @@ -0,0 +1,14 @@ +{ + "key": "accumulators", + "name": "Accumulators", + "authors": [ + "Eric Niebler" + ], + "description": "Framework for incremental calculation, and collection of statistical accumulators.", + "category": [ + "Math" + ], + "maintainers": [ + "Eric Niebler <eric -at- boostpro.com>" + ] +} diff --git a/src/boost/libs/accumulators/test/Jamfile.v2 b/src/boost/libs/accumulators/test/Jamfile.v2 new file mode 100644 index 000000000..6d2dbf06e --- /dev/null +++ b/src/boost/libs/accumulators/test/Jamfile.v2 @@ -0,0 +1,139 @@ +# (C) Copyright 2005: Eric Niebler +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +# bring in rules for testing +import testing ; +import feature ; + +feature.feature iterator_debugging + : on off + : composite propagated optional + ; + +feature.compose <iterator_debugging>off + : <define>_HAS_ITERATOR_DEBUGGING=0 + ; + +project + : requirements + <library>/boost/test//boost_unit_test_framework + <link>static + <include>../../.. + <toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE + # MSVC's iterator debugging causes some tests to run forever. + <toolset>msvc:<iterator_debugging>off + <toolset>intel-win:<iterator_debugging>off + <cxxflags>"-Wno-deprecated-declarations" + <library>/boost/serialization + ; + +alias accumulators_regular_tests + : [ run count.cpp ] + [ run covariance.cpp ] + [ run droppable.cpp ] + [ run error_of.cpp ] + [ run extended_p_square.cpp ] + [ run extended_p_square_quantile.cpp ] + [ run external_accumulator.cpp ] + [ run external_weights.cpp ] + [ run kurtosis.cpp ] + [ run max.cpp ] + [ run mean.cpp ] + [ run median.cpp ] + [ run min.cpp ] + [ run moment.cpp ] + [ run p_square_cumul_dist.cpp ] + [ run p_square_quantile.cpp ] + [ run reference.cpp ] + [ run rolling_count.cpp ] + [ run rolling_sum.cpp ] + [ run rolling_mean.cpp ] + [ run rolling_variance.cpp ] + [ run rolling_moment.cpp ] + [ run skewness.cpp ] + [ run sum.cpp ] + [ run sum_kahan.cpp ] + [ run tail.cpp ] + [ run tail_mean.cpp ] + [ run tail_quantile.cpp ] + [ run variance.cpp ] + [ run vector.cpp ] + [ run weighted_covariance.cpp ] + [ run weighted_extended_p_square.cpp ] + [ run weighted_kurtosis.cpp ] + [ run weighted_mean.cpp ] + [ run weighted_median.cpp ] + [ run weighted_moment.cpp ] + [ run weighted_p_square_cumul_dist.cpp ] + [ run weighted_p_square_quantile.cpp ] + [ run weighted_skewness.cpp ] + [ run weighted_sum.cpp ] + [ run weighted_sum_kahan.cpp ] + [ run weighted_variance.cpp ] + ; + +alias accumulators_test_valarray + : + : <target-os>linux + <toolset>clang +# TODO: Find the correct attribute that detects libc++. + ; + +alias accumulators_test_valarray + : + : <target-os>darwin + ; + +alias accumulators_test_valarray + : [ run valarray.cpp ] + ; + +alias accumulators_test_tail_variate_means + : + : <toolset>msvc + <toolset-msvc:version>14.0 + ; + +alias accumulators_test_tail_variate_means + : [ run tail_variate_means.cpp ] + ; + +alias accumulators_tests_pot_quantile_and_weighted_tail + : + : <target-os>linux + <toolset>gcc + <toolset-gcc:version>4.4.7 + ; + +alias accumulators_tests_pot_quantile_and_weighted_tail + : [ run pot_quantile.cpp ] + [ run weighted_pot_quantile.cpp ] + [ run weighted_tail_mean.cpp ] + [ run weighted_tail_quantile.cpp ] + ; + +alias accumulators_test_weighted_tail_variate_means + : + : <target-os>linux + <toolset>gcc + <toolset-gcc:version>4.4.7 + ; + +alias accumulators_test_weighted_tail_variate_means + : + : <toolset>msvc + <toolset-msvc:version>14.0 + ; + +alias accumulators_test_weighted_tail_variate_means + : [ run weighted_tail_variate_means.cpp ] + ; + +test-suite "accumulators" + : accumulators_regular_tests + accumulators_test_valarray + accumulators_test_tail_variate_means + accumulators_tests_pot_quantile_and_weighted_tail + accumulators_test_weighted_tail_variate_means + ; diff --git a/src/boost/libs/accumulators/test/count.cpp b/src/boost/libs/accumulators/test/count.cpp new file mode 100644 index 000000000..e2f4436b6 --- /dev/null +++ b/src/boost/libs/accumulators/test/count.cpp @@ -0,0 +1,77 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/count.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::count> > acc; + + acc(1); + BOOST_CHECK_EQUAL(1u, count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(2u, count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(3u, count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(4u, count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(5u, count(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + { + accumulator_set<int, stats<tag::count> > acc; + acc(1); + acc(1); + acc(1); + acc(1); + BOOST_CHECK_EQUAL(4u, count(acc)); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::count> > acc; + BOOST_CHECK_EQUAL(0u, count(acc)); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(4u, count(acc)); + +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("count test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/covariance.cpp b/src/boost/libs/accumulators/test/covariance.cpp new file mode 100644 index 000000000..abdbc9e82 --- /dev/null +++ b/src/boost/libs/accumulators/test/covariance.cpp @@ -0,0 +1,135 @@ +// (C) Copyright 2005 Daniel Egloff, Eric Niebler +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/covariance.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + std::vector<double> dummy; + dummy.push_back(0); + dummy.push_back(0); + + accumulator_set<double, stats<tag::covariance<double, tag::covariate1> > > acc; + accumulator_set<std::vector<double>, stats<tag::covariance<double, tag::covariate1> > > acc2(sample = dummy); + accumulator_set<double, stats<tag::covariance<std::vector<double>, tag::covariate1> > > acc3(covariate1 = dummy); + accumulator_set<std::vector<double>, stats<tag::covariance<std::vector<double>, tag::covariate1> > > acc4(sample = dummy, covariate1 = dummy); + + std::vector<double> a; + a.push_back(1.); + a.push_back(2.); + std::vector<double> b; + b.push_back(3.); + b.push_back(4.); + std::vector<double> c; + c.push_back(2.); + c.push_back(5.); + std::vector<double> d; + d.push_back(4.); + d.push_back(2.); + + // double - double + { + acc(1., covariate1 = 2.); + acc(1., covariate1 = 4.); + acc(2., covariate1 = 3.); + acc(6., covariate1 = 1.); + } + + // vector - double + { + acc2(a, covariate1 = 1.); + acc2(b, covariate1 = 1.); + acc2(c, covariate1 = 2.); + acc2(d, covariate1 = 6.); + } + + // double - vector + { + acc3(1., covariate1 = a); + acc3(1., covariate1 = b); + acc3(2., covariate1 = c); + acc3(6., covariate1 = d); + } + + // vector - vector + { + acc4(a, covariate1 = b); + acc4(b, covariate1 = c); + acc4(a, covariate1 = c); + acc4(d, covariate1 = b); + } + + double epsilon = 1e-6; + + BOOST_CHECK_CLOSE((covariance(acc)), -1.75, epsilon); + BOOST_CHECK_CLOSE((covariance(acc2))[0], 1.75, epsilon); + BOOST_CHECK_CLOSE((covariance(acc2))[1], -1.125, epsilon); + BOOST_CHECK_CLOSE((covariance(acc3))[0], 1.75, epsilon); + BOOST_CHECK_CLOSE((covariance(acc3))[1], -1.125, epsilon); + BOOST_CHECK_CLOSE((covariance(acc4))(0,0), 0.125, epsilon); + BOOST_CHECK_CLOSE((covariance(acc4))(0,1), -0.25, epsilon); + BOOST_CHECK_CLOSE((covariance(acc4))(1,0), -0.125, epsilon); + BOOST_CHECK_CLOSE((covariance(acc4))(1,1), 0.25, epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + // tolerance + double epsilon = 1e-6; + { + + accumulator_set<double, stats<tag::covariance<double, tag::covariate1> > > acc; + acc(1., covariate1 = 2.); + acc(1., covariate1 = 4.); + acc(2., covariate1 = 3.); + acc(6., covariate1 = 1.); + + + BOOST_CHECK_CLOSE((covariance(acc)), -1.75, epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<double, stats<tag::covariance<double, tag::covariate1> > > acc; + BOOST_CHECK_CLOSE((covariance(acc)), 0., epsilon); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_CLOSE((covariance(acc)), -1.75, epsilon); + +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("covariance test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/droppable.cpp b/src/boost/libs/accumulators/test/droppable.cpp new file mode 100644 index 000000000..1ab1f140b --- /dev/null +++ b/src/boost/libs/accumulators/test/droppable.cpp @@ -0,0 +1,142 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +void assert_is_double(T const &) +{ + BOOST_MPL_ASSERT((is_same<T, double>)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<droppable<tag::mean> > > acc, test_acc(sample = 0); + + acc(1); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc(0); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc.drop<tag::mean>(); + + acc(2); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + assert_is_double(mean(acc)); + + + accumulator_set<int, stats<droppable<tag::mean(immediate)> > > acc2, test_acc2(sample = 0); + + acc2(1); + BOOST_CHECK_CLOSE(1., mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc2)); + + acc2(0); + BOOST_CHECK_CLOSE(0.5, mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc2)); + + acc2.drop<tag::mean>(); + + acc2(2); + BOOST_CHECK_CLOSE(0.5, mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc2)); + + assert_is_double(mean(acc2)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat2 +// +void test_stat2() +{ + accumulator_set<int, stats<droppable<tag::sum>, droppable<tag::mean> > > acc, test_acc(sample = 0); + + acc(1); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc(0); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc.drop<tag::mean>(); + acc.drop<tag::sum>(); + + acc(2); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + assert_is_double(mean(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat3 +// +void test_stat3() +{ + accumulator_set<int, stats<droppable<tag::sum>, droppable<tag::count>, droppable<tag::mean> > > acc, test_acc(sample = 0); + + acc(1); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc(0); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc.drop<tag::mean>(); + acc.drop<tag::sum>(); + + acc(2); + BOOST_CHECK_CLOSE(1./3., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc.drop<tag::count>(); + acc(3); + BOOST_CHECK_CLOSE(1./3., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + assert_is_double(mean(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("droppable test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_stat2)); + test->add(BOOST_TEST_CASE(&test_stat3)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/error_of.cpp b/src/boost/libs/accumulators/test/error_of.cpp new file mode 100644 index 000000000..058902396 --- /dev/null +++ b/src/boost/libs/accumulators/test/error_of.cpp @@ -0,0 +1,57 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/with_error.hpp> +#include <boost/accumulators/statistics/error_of_mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<double, stats<tag::error_of<tag::mean(lazy)> > > acc; + acc(1.1); + acc(1.2); + acc(1.3); + BOOST_CHECK_CLOSE(0.057735, accumulators::error_of<tag::mean(lazy)>(acc), 1e-4); + + accumulator_set<double, stats<tag::error_of<tag::mean(immediate)> > > acc2; + acc2(1.1); + acc2(1.2); + acc2(1.3); + BOOST_CHECK_CLOSE(0.057735, accumulators::error_of<tag::mean(immediate)>(acc2), 1e-4); + + accumulator_set<double, stats<with_error<tag::mean(lazy)> > > acc3; + acc3(1.1); + acc3(1.2); + acc3(1.3); + BOOST_CHECK_CLOSE(0.057735, accumulators::error_of<tag::mean(lazy)>(acc3), 1e-4); + + accumulator_set<double, stats<with_error<tag::mean(immediate)> > > acc4; + acc4(1.1); + acc4(1.2); + acc4(1.3); + BOOST_CHECK_CLOSE(0.057735, accumulators::error_of<tag::mean(immediate)>(acc4), 1e-4); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("mean test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/extended_p_square.cpp b/src/boost/libs/accumulators/test/extended_p_square.cpp new file mode 100644 index 000000000..09f50cf87 --- /dev/null +++ b/src/boost/libs/accumulators/test/extended_p_square.cpp @@ -0,0 +1,110 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for extended_p_square.hpp + +#include <iostream> +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/extended_p_square.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +typedef accumulator_set<double, stats<tag::extended_p_square> > accumulator_t; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + + // tolerance + double epsilon = 3; + + // a random number generator + boost::lagged_fibonacci607 rng; + + std::vector<double> probs; + + probs.push_back(0.001); + probs.push_back(0.01 ); + probs.push_back(0.1 ); + probs.push_back(0.25 ); + probs.push_back(0.5 ); + probs.push_back(0.75 ); + probs.push_back(0.9 ); + probs.push_back(0.99 ); + probs.push_back(0.999); + + accumulator_t acc(extended_p_square_probabilities = probs); + + for (int i=0; i<10000; ++i) + acc(rng()); + + BOOST_CHECK_GE(extended_p_square(acc)[0], 0.0005); + BOOST_CHECK_LE(extended_p_square(acc)[0], 0.0015); + BOOST_CHECK_CLOSE(extended_p_square(acc)[1], probs[1], 15); + BOOST_CHECK_CLOSE(extended_p_square(acc)[2], probs[2], 5); + + for (std::size_t i=3; i<probs.size(); ++i) + { + BOOST_CHECK_CLOSE(extended_p_square(acc)[i], probs[i], epsilon); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + // tolerance + double epsilon = 3.; + std::vector<double> probs; + probs.push_back(0.75); + { + accumulator_t acc(extended_p_square_probabilities = probs); + // a random number generator + boost::lagged_fibonacci607 rng; + + for (int i=0; i<10000; ++i) + acc(rng()); + + BOOST_CHECK_CLOSE(extended_p_square(acc)[0], probs[0], epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_t acc(extended_p_square_probabilities = probs); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_CLOSE(extended_p_square(acc)[0], probs[0], epsilon); + +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("extended_p_square test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/extended_p_square_quantile.cpp b/src/boost/libs/accumulators/test/extended_p_square_quantile.cpp new file mode 100644 index 000000000..7d602012f --- /dev/null +++ b/src/boost/libs/accumulators/test/extended_p_square_quantile.cpp @@ -0,0 +1,174 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for extended_p_square_quantile.hpp + +#include <iostream> +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/extended_p_square_quantile.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +typedef accumulator_set<double, stats<tag::extended_p_square_quantile> > accumulator_t; +typedef accumulator_set<double, stats<tag::weighted_extended_p_square_quantile>, double > accumulator_t_weighted; +typedef accumulator_set<double, stats<tag::extended_p_square_quantile(quadratic)> > accumulator_t_quadratic; +typedef accumulator_set<double, stats<tag::weighted_extended_p_square_quantile(quadratic)>, double > accumulator_t_weighted_quadratic; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance + double epsilon = 1; + + // a random number generator + boost::lagged_fibonacci607 rng; + + std::vector<double> probs; + + probs.push_back(0.990); + probs.push_back(0.991); + probs.push_back(0.992); + probs.push_back(0.993); + probs.push_back(0.994); + probs.push_back(0.995); + probs.push_back(0.996); + probs.push_back(0.997); + probs.push_back(0.998); + probs.push_back(0.999); + + accumulator_t acc(extended_p_square_probabilities = probs); + accumulator_t_weighted acc_weighted(extended_p_square_probabilities = probs); + accumulator_t_quadratic acc2(extended_p_square_probabilities = probs); + accumulator_t_weighted_quadratic acc_weighted2(extended_p_square_probabilities = probs); + + for (int i=0; i<10000; ++i) + { + double sample = rng(); + acc(sample); + acc2(sample); + acc_weighted(sample, weight = 1.); + acc_weighted2(sample, weight = 1.); + } + + for (std::size_t i = 0; i < probs.size() - 1; ++i) + { + BOOST_CHECK_CLOSE( + quantile(acc, quantile_probability = 0.99025 + i*0.001) + , 0.99025 + i*0.001 + , epsilon + ); + BOOST_CHECK_CLOSE( + quantile(acc2, quantile_probability = 0.99025 + i*0.001) + , 0.99025 + i*0.001 + , epsilon + ); + BOOST_CHECK_CLOSE( + quantile(acc_weighted, quantile_probability = 0.99025 + i*0.001) + , 0.99025 + i*0.001 + , epsilon + ); + BOOST_CHECK_CLOSE( + quantile(acc_weighted2, quantile_probability = 0.99025 + i*0.001) + , 0.99025 + i*0.001 + , epsilon + ); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + + // tolerance + double epsilon = 1.; + + // a random number generator + boost::lagged_fibonacci607 rng; + + std::vector<double> probs; + probs.push_back(0.990); + probs.push_back(0.991); + probs.push_back(0.992); + probs.push_back(0.993); + probs.push_back(0.994); + probs.push_back(0.995); + probs.push_back(0.996); + probs.push_back(0.997); + probs.push_back(0.998); + probs.push_back(0.999); + + { + accumulator_t acc(extended_p_square_probabilities = probs); + accumulator_t_weighted acc_weighted(extended_p_square_probabilities = probs); + + for (int i=0; i<10000; ++i) + { + double sample = rng(); + acc(sample); + acc_weighted(sample, weight = 1.); + } + + BOOST_CHECK_CLOSE( + quantile(acc, quantile_probability = 0.99025) + , 0.99025 + , epsilon + ); + BOOST_CHECK_CLOSE( + quantile(acc_weighted, quantile_probability = 0.99025) + , 0.99025 + , epsilon + ); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + acc_weighted.serialize(oa, 0); + } + + accumulator_t acc(extended_p_square_probabilities = probs); + accumulator_t_weighted acc_weighted(extended_p_square_probabilities = probs); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + acc_weighted.serialize(ia, 0); + BOOST_CHECK_CLOSE( + quantile(acc, quantile_probability = 0.99025) + , 0.99025 + , epsilon + ); + BOOST_CHECK_CLOSE( + quantile(acc_weighted, quantile_probability = 0.99025) + , 0.99025 + , epsilon + ); +} +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("extended_p_square_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/external_accumulator.cpp b/src/boost/libs/accumulators/test/external_accumulator.cpp new file mode 100644 index 000000000..ad8d5bd04 --- /dev/null +++ b/src/boost/libs/accumulators/test/external_accumulator.cpp @@ -0,0 +1,129 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +namespace my +{ + BOOST_PARAMETER_KEYWORD(tag, sum_acc) +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::mean, tag::external<tag::sum, my::tag::sum_acc> > > acc; + accumulator_set<int, stats<tag::sum> > sum_acc; + + acc(1); + sum_acc(1); + BOOST_CHECK_CLOSE(1., mean(acc, my::sum_acc = sum_acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(sum_acc)); + + acc(0); + sum_acc(0); + BOOST_CHECK_CLOSE(0.5, mean(acc, my::sum_acc = sum_acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc, my::sum_acc = sum_acc)); + + acc(2); + sum_acc(2); + BOOST_CHECK_CLOSE(1., mean(acc, my::sum_acc = sum_acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(3, sum(acc, my::sum_acc = sum_acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_reference +// +void test_reference() +{ + typedef accumulator_set<int, stats<tag::sum> > sum_acc_type; + sum_acc_type sum_acc; + accumulator_set< + int + , stats< + tag::mean + , tag::external<tag::sum, my::tag::sum_acc> + , tag::reference<sum_acc_type, my::tag::sum_acc> + > + > acc(my::sum_acc = sum_acc); + + acc(1); + sum_acc(1); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(sum_acc)); + + acc(0); + sum_acc(0); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc(2); + sum_acc(2); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(3, sum(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_reference2 +// +void test_reference2() +{ + typedef accumulator_set<int, stats<tag::sum> > sum_acc_type; + sum_acc_type sum_acc; + accumulator_set< + int + , stats< + tag::mean + , tag::external<tag::sum, my::tag::sum_acc, sum_acc_type> + > + > acc(my::sum_acc = sum_acc); + + acc(1); + sum_acc(1); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(sum_acc)); + + acc(0); + sum_acc(0); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + + acc(2); + sum_acc(2); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(3, sum(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("external_accumulator test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_reference)); + test->add(BOOST_TEST_CASE(&test_reference2)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/external_weights.cpp b/src/boost/libs/accumulators/test/external_weights.cpp new file mode 100644 index 000000000..4a904b2ed --- /dev/null +++ b/src/boost/libs/accumulators/test/external_weights.cpp @@ -0,0 +1,54 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::weighted_mean>, external<int> > acc; + accumulator_set<void, stats<tag::sum_of_weights>, int> weight_acc; + + acc(10, weight = 2); // 20 + weight_acc(weight = 2); // + BOOST_CHECK_EQUAL(2, sum_of_weights(weight_acc)); // + // + acc(6, weight = 3); // 18 + weight_acc(weight = 3); // + BOOST_CHECK_EQUAL(5, sum_of_weights(weight_acc)); // + // + acc(4, weight = 4); // 16 + weight_acc(weight = 4); // + BOOST_CHECK_EQUAL(9, sum_of_weights(weight_acc)); // + // + acc(6, weight = 5); //+ 30 + weight_acc(weight = 5); // + BOOST_CHECK_EQUAL(14, sum_of_weights(weight_acc)); // + //= 84 / 14 = 6 + + BOOST_CHECK_CLOSE(6., weighted_mean(acc, weights = weight_acc), 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("external_weights test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/kurtosis.cpp b/src/boost/libs/accumulators/test/kurtosis.cpp new file mode 100644 index 000000000..92c5cfe94 --- /dev/null +++ b/src/boost/libs/accumulators/test/kurtosis.cpp @@ -0,0 +1,102 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for kurtosis.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/kurtosis.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + // double epsilon = 1; + + accumulator_set<double, stats<tag::kurtosis > > acc1; + accumulator_set<int, stats<tag::kurtosis > > acc2; + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i=0; i<100000; ++i) + { + acc1(normal()); + } + + // This check fails because epsilon is relative and not absolute + // BOOST_CHECK_CLOSE( kurtosis(acc1), 0., epsilon ); + + acc2(2); + acc2(7); + acc2(4); + acc2(9); + acc2(3); + + BOOST_CHECK_EQUAL( mean(acc2), 5 ); + BOOST_CHECK_EQUAL( accumulators::moment<2>(acc2), 159./5. ); + BOOST_CHECK_EQUAL( accumulators::moment<3>(acc2), 1171./5. ); + BOOST_CHECK_EQUAL( accumulators::moment<4>(acc2), 1863 ); + BOOST_CHECK_CLOSE( kurtosis(acc2), -1.39965397924, 1e-6 ); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + // tolerance + double epsilon = 1e-6; + double kurtosis_value = -1.39965397924; + { + accumulator_set<int, stats<tag::kurtosis > > acc; + acc(2); + acc(7); + acc(4); + acc(9); + acc(3); + BOOST_CHECK_CLOSE( kurtosis(acc), kurtosis_value, epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + + accumulator_set<double, stats<tag::kurtosis > > acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_CLOSE( kurtosis(acc), kurtosis_value, epsilon); + +} +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("kurtosis test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/max.cpp b/src/boost/libs/accumulators/test/max.cpp new file mode 100644 index 000000000..00a979367 --- /dev/null +++ b/src/boost/libs/accumulators/test/max.cpp @@ -0,0 +1,67 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/max.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::max> > acc; + + acc(1); + BOOST_CHECK_EQUAL(1, (max)(acc)); + + acc(0); + BOOST_CHECK_EQUAL(1, (max)(acc)); + + acc(2); + BOOST_CHECK_EQUAL(2, (max)(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set<int, stats<tag::max> > acc; + acc(1); + acc(0); + acc(2); + BOOST_CHECK_EQUAL(2u, max(acc)); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::max> > acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(2u, max(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("max test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/mean.cpp b/src/boost/libs/accumulators/test/mean.cpp new file mode 100644 index 000000000..29d487769 --- /dev/null +++ b/src/boost/libs/accumulators/test/mean.cpp @@ -0,0 +1,123 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_mean.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +void assert_is_double(T const &) +{ + BOOST_MPL_ASSERT((is_same<T, double>)); +} + +typedef accumulator_set<int, stats<tag::mean, + tag::mean_of_variates<int, tag::covariate1> > > mean_t; + +typedef accumulator_set<int, stats<tag::mean(immediate), + tag::mean_of_variates<int, tag::covariate1>(immediate) > > immediate_mean_t; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + mean_t acc, test_acc(sample = 0); + + acc(1, covariate1 = 3); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + BOOST_CHECK_CLOSE(3., (accumulators::mean_of_variates<int, tag::covariate1>(acc)), 1e-5); + + acc(0, covariate1 = 4); + BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(1, sum(acc)); + BOOST_CHECK_CLOSE(3.5, (accumulators::mean_of_variates<int, tag::covariate1>(acc)), 1e-5); + + acc(2, covariate1 = 8); + BOOST_CHECK_CLOSE(1., mean(acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(3, sum(acc)); + BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc)), 1e-5); + + assert_is_double(mean(acc)); + + immediate_mean_t acc2, test_acc2(sample = 0); + + acc2(1, covariate1 = 3); + BOOST_CHECK_CLOSE(1., mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc2)); + BOOST_CHECK_CLOSE(3., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + + acc2(0, covariate1 = 4); + BOOST_CHECK_CLOSE(0.5, mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc2)); + BOOST_CHECK_CLOSE(3.5, (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + + acc2(2, covariate1 = 8); + BOOST_CHECK_CLOSE(1., mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc2)); + BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + + assert_is_double(mean(acc2)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + mean_t acc1; + immediate_mean_t acc2; + + acc1(1, covariate1 = 3); + acc1(0, covariate1 = 4); + acc1(2, covariate1 = 8); + acc2(1, covariate1 = 3); + acc2(0, covariate1 = 4); + acc2(2, covariate1 = 8); + BOOST_CHECK_CLOSE(1., mean(acc1), 1e-5); + BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc1)), 1e-5); + BOOST_CHECK_CLOSE(1., mean(acc2), 1e-5); + BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + boost::archive::text_oarchive oa(ss); + acc1.serialize(oa, 0); + acc2.serialize(oa, 0); + } + mean_t acc1; + immediate_mean_t acc2; + boost::archive::text_iarchive ia(ss); + acc1.serialize(ia, 0); + acc2.serialize(ia, 0); + BOOST_CHECK_CLOSE(1., mean(acc1), 1e-5); + BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("mean test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/median.cpp b/src/boost/libs/accumulators/test/median.cpp new file mode 100644 index 000000000..e34839329 --- /dev/null +++ b/src/boost/libs/accumulators/test/median.cpp @@ -0,0 +1,110 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/random.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/median.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + + +typedef accumulator_set<double, stats<tag::median(with_p_square_quantile) > > p_square_median_t; +typedef accumulator_set<double, stats<tag::median(with_density) > > dist_median_t; +typedef accumulator_set<double, stats<tag::median(with_p_square_cumulative_distribution) > > p_square_dist_median_t; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // two random number generators + double mu = 1.; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(mu,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + p_square_median_t acc; + dist_median_t acc_dens( density_cache_size = 10000, density_num_bins = 1000 ); + p_square_dist_median_t acc_cdist( p_square_cumulative_distribution_num_cells = 100 ); + + for (std::size_t i=0; i<100000; ++i) + { + double sample = normal(); + acc(sample); + acc_dens(sample); + acc_cdist(sample); + } + + BOOST_CHECK_CLOSE(1., median(acc), 1.); + BOOST_CHECK_CLOSE(1., median(acc_dens), 1.); + BOOST_CHECK_CLOSE(1., median(acc_cdist), 3.); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // two random number generators + double mu = 1.; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(mu,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + std::stringstream ss; + { + p_square_median_t acc; + dist_median_t acc_dens( density_cache_size = 10000, density_num_bins = 1000 ); + p_square_dist_median_t acc_cdist( p_square_cumulative_distribution_num_cells = 100 ); + + for (std::size_t i=0; i<100000; ++i) + { + double sample = normal(); + acc(sample); + acc_dens(sample); + acc_cdist(sample); + } + + BOOST_CHECK_CLOSE(1., median(acc), 1.); + BOOST_CHECK_CLOSE(1., median(acc_dens), 1.); + BOOST_CHECK_CLOSE(1., median(acc_cdist), 3.); + + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + acc_dens.serialize(oa, 0); + acc_cdist.serialize(oa, 0); + } + + p_square_median_t acc; + dist_median_t acc_dens( density_cache_size = 10000, density_num_bins = 1000 ); + p_square_dist_median_t acc_cdist( p_square_cumulative_distribution_num_cells = 100 ); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + acc_dens.serialize(ia, 0); + acc_cdist.serialize(ia, 0); + BOOST_CHECK_CLOSE(1., median(acc), 1.); + BOOST_CHECK_CLOSE(1., median(acc_dens), 1.); + BOOST_CHECK_CLOSE(1., median(acc_cdist), 3.); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("median test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/min.cpp b/src/boost/libs/accumulators/test/min.cpp new file mode 100644 index 000000000..614fab4f7 --- /dev/null +++ b/src/boost/libs/accumulators/test/min.cpp @@ -0,0 +1,67 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/min.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::min> > acc; + + acc(1); + BOOST_CHECK_EQUAL(1, (min)(acc)); + + acc(0); + BOOST_CHECK_EQUAL(0, (min)(acc)); + + acc(2); + BOOST_CHECK_EQUAL(0, (min)(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set<int, stats<tag::min> > acc; + acc(1); + acc(0); + acc(2); + BOOST_CHECK_EQUAL(0, (min)(acc)); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::min> > acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(0, (min)(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("min test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/moment.cpp b/src/boost/libs/accumulators/test/moment.cpp new file mode 100644 index 000000000..44fa2a531 --- /dev/null +++ b/src/boost/libs/accumulators/test/moment.cpp @@ -0,0 +1,79 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/moment.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::moment<2> > > acc1; + + acc1(2); // 4 + acc1(4); // 16 + acc1(5); // + 25 + // = 45 / 3 = 15 + + BOOST_CHECK_CLOSE(15., accumulators::moment<2>(acc1), 1e-5); + + accumulator_set<int, stats<tag::moment<5> > > acc2; + + acc2(2); // 32 + acc2(3); // 243 + acc2(4); // 1024 + acc2(5); // + 3125 + // = 4424 / 4 = 1106 + + BOOST_CHECK_CLOSE(1106., accumulators::moment<5>(acc2), 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + double epsilon = 1e-5; + std::stringstream ss; + { + accumulator_set<int, stats<tag::moment<2> > > acc; + acc(2); // 4 + acc(4); // 16 + acc(5); // + 25 + // = 45 / 3 = 15 + BOOST_CHECK_CLOSE(15., accumulators::moment<2>(acc), epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::moment<2> > > acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_CLOSE(15., accumulators::moment<2>(acc), epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("moment test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/p_square_cumul_dist.cpp b/src/boost/libs/accumulators/test/p_square_cumul_dist.cpp new file mode 100644 index 000000000..33e8109ab --- /dev/null +++ b/src/boost/libs/accumulators/test/p_square_cumul_dist.cpp @@ -0,0 +1,124 @@ +// (C) Copyright Eric Niebler, Olivier Gygi 2006. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for p_square_cumul_dist.hpp + +#include <cmath> +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/p_square_cumul_dist.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// erf() not known by VC++ compiler! +// my_erf() computes error function by numerically integrating with trapezoidal rule +// +double my_erf(double const& x, int const& n = 1000) +{ + double sum = 0.; + double delta = x/n; + for (int i = 1; i < n; ++i) + sum += std::exp(-i*i*delta*delta) * delta; + sum += 0.5 * delta * (1. + std::exp(-x*x)); + return sum * 2. / std::sqrt(3.141592653); +} + +typedef accumulator_set<double, stats<tag::p_square_cumulative_distribution> > accumulator_t; +typedef iterator_range<std::vector<std::pair<double, double> >::iterator > histogram_type; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 3; + + accumulator_t acc(p_square_cumulative_distribution_num_cells = 100); + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i=0; i<1000000; ++i) + { + acc(normal()); + } + + histogram_type histogram = p_square_cumulative_distribution(acc); + + for (std::size_t i = 0; i < histogram.size(); ++i) + { + // problem with small results: epsilon is relative (in percent), not absolute! + if ( histogram[i].second > 0.001 ) + BOOST_CHECK_CLOSE( 0.5 * (1.0 + my_erf( histogram[i].first / std::sqrt(2.0) )), histogram[i].second, epsilon ); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + // tolerance in % + double epsilon = 3; + { + accumulator_t acc(p_square_cumulative_distribution_num_cells = 100); + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i=0; i<1000000; ++i) + { + acc(normal()); + } + + histogram_type histogram = p_square_cumulative_distribution(acc); + + BOOST_CHECK_CLOSE(0.5 * (1.0 + my_erf(histogram[25].first / std::sqrt(2.0))), histogram[25].second, epsilon); + BOOST_CHECK_CLOSE(0.5 * (1.0 + my_erf(histogram[50].first / std::sqrt(2.0))), histogram[50].second, epsilon); + BOOST_CHECK_CLOSE(0.5 * (1.0 + my_erf(histogram[75].first / std::sqrt(2.0))), histogram[75].second, epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_t acc(p_square_cumulative_distribution_num_cells = 100); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + histogram_type histogram = p_square_cumulative_distribution(acc); + BOOST_CHECK_CLOSE(0.5 * (1.0 + my_erf(histogram[25].first / std::sqrt(2.0))), histogram[25].second, epsilon); + BOOST_CHECK_CLOSE(0.5 * (1.0 + my_erf(histogram[50].first / std::sqrt(2.0))), histogram[50].second, epsilon); + BOOST_CHECK_CLOSE(0.5 * (1.0 + my_erf(histogram[75].first / std::sqrt(2.0))), histogram[75].second, epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("p_square_cumulative_distribution test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/p_square_quantile.cpp b/src/boost/libs/accumulators/test/p_square_quantile.cpp new file mode 100644 index 000000000..ba678237a --- /dev/null +++ b/src/boost/libs/accumulators/test/p_square_quantile.cpp @@ -0,0 +1,122 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for p_square_quantile.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/p_square_quantile.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +typedef accumulator_set<double, stats<tag::p_square_quantile> > accumulator_t; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1; + + // a random number generator + boost::lagged_fibonacci607 rng; + + accumulator_t acc0(quantile_probability = 0.001); + accumulator_t acc1(quantile_probability = 0.01 ); + accumulator_t acc2(quantile_probability = 0.1 ); + accumulator_t acc3(quantile_probability = 0.25 ); + accumulator_t acc4(quantile_probability = 0.5 ); + accumulator_t acc5(quantile_probability = 0.75 ); + accumulator_t acc6(quantile_probability = 0.9 ); + accumulator_t acc7(quantile_probability = 0.99 ); + accumulator_t acc8(quantile_probability = 0.999); + + for (int i=0; i<100000; ++i) + { + double sample = rng(); + acc0(sample); + acc1(sample); + acc2(sample); + acc3(sample); + acc4(sample); + acc5(sample); + acc6(sample); + acc7(sample); + acc8(sample); + } + + BOOST_CHECK_CLOSE( p_square_quantile(acc0), 0.001, 18*epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc1), 0.01 , 7*epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc2), 0.1 , 3*epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc3), 0.25 , 2*epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc4), 0.5 , epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc5), 0.75 , epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc6), 0.9 , epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc7), 0.99 , epsilon ); + BOOST_CHECK_CLOSE( p_square_quantile(acc8), 0.999, epsilon ); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + // tolerance in % + double epsilon = 1; + // a random number generator + boost::lagged_fibonacci607 rng; + { + accumulator_t acc1(quantile_probability = 0.75 ); + accumulator_t acc2(quantile_probability = 0.999); + + for (int i=0; i<100000; ++i) + { + double sample = rng(); + acc1(sample); + acc2(sample); + } + + BOOST_CHECK_CLOSE(p_square_quantile(acc1), 0.75 , epsilon); + BOOST_CHECK_CLOSE(p_square_quantile(acc2), 0.999, epsilon); + boost::archive::text_oarchive oa(ss); + acc1.serialize(oa, 0); + acc2.serialize(oa, 0); + } + accumulator_t acc1(quantile_probability = 0.75); + accumulator_t acc2(quantile_probability = 0.999); + boost::archive::text_iarchive ia(ss); + acc1.serialize(ia, 0); + acc2.serialize(ia, 0); + BOOST_CHECK_CLOSE(p_square_quantile(acc1), 0.75 , epsilon); + BOOST_CHECK_CLOSE(p_square_quantile(acc2), 0.999, epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("p_square_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/p_square_quantile_extended.cpp b/src/boost/libs/accumulators/test/p_square_quantile_extended.cpp new file mode 100644 index 000000000..debe33ce6 --- /dev/null +++ b/src/boost/libs/accumulators/test/p_square_quantile_extended.cpp @@ -0,0 +1,117 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for p_square_quantile_extended.hpp + +#include <iostream> +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/p_square_quantile_extended.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +typedef accumulator_set<double, stats<tag::p_square_quantile_extended> > accumulator_t; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance + double epsilon = 1e-6; + + // a random number generator + boost::lagged_fibonacci607 rng; + + std::vector<double> probs; + + probs.push_back(0.001); + probs.push_back(0.01 ); + probs.push_back(0.1 ); + probs.push_back(0.25 ); + probs.push_back(0.5 ); + probs.push_back(0.75 ); + probs.push_back(0.9 ); + probs.push_back(0.99 ); + probs.push_back(0.999); + + accumulator_t acc(tag::p_square_quantile_extended::probabilities = probs); + + for (int i=0; i<10000; ++i) + acc(rng()); + + for (std::size_t i=0; i<probs.size(); ++i) + { + BOOST_CHECK_CLOSE(p_square_quantile_extended(acc)[i], probs[i], epsilon); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // "persistent" storage + std::stringstream ss; + // tolerance in % + double epsilon = 1; + // a random number generator + boost::lagged_fibonacci607 rng; + + std::vector<double> probs; + probs.push_back(0.001); + probs.push_back(0.01 ); + probs.push_back(0.1 ); + probs.push_back(0.25 ); + probs.push_back(0.5 ); + probs.push_back(0.75 ); + probs.push_back(0.9 ); + probs.push_back(0.99 ); + probs.push_back(0.999); + { + accumulator_t acc(tag::p_square_quantile_extended::probabilities = probs); + + for (int i=0; i<10000; ++i) + acc(rng()); + + for (std::size_t i=0; i<probs.size(); ++i) + { + BOOST_CHECK_CLOSE(p_square_quantile_extended(acc)[i], probs[i], epsilon); + } + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_t acc(tag::p_square_quantile_extended::probabilities = probs); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + for (std::size_t i=0; i<probs.size(); ++i) + { + BOOST_CHECK_CLOSE(p_square_quantile_extended(acc)[i], probs[i], epsilon); + } +} +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("p_square_quantile_extended test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/pot_quantile.cpp b/src/boost/libs/accumulators/test/pot_quantile.cpp new file mode 100644 index 000000000..4e12ad615 --- /dev/null +++ b/src/boost/libs/accumulators/test/pot_quantile.cpp @@ -0,0 +1,131 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for pot_quantile.hpp + +#define BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics.hpp> +#include <boost/accumulators/statistics/peaks_over_threshold.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1.; + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::exponential_distribution<> lambda(1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + boost::variate_generator<boost::lagged_fibonacci607&, boost::exponential_distribution<> > exponential(rng, lambda); + + accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc1( + pot_threshold_value = 3. + ); + accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_probability)> > acc2( + right_tail_cache_size = 2000 + , pot_threshold_probability = 0.99 + ); + accumulator_set<double, stats<tag::pot_quantile<left>(with_threshold_value)> > acc3( + pot_threshold_value = -3. + ); + accumulator_set<double, stats<tag::pot_quantile<left>(with_threshold_probability)> > acc4( + left_tail_cache_size = 2000 + , pot_threshold_probability = 0.01 + ); + + accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc5( + pot_threshold_value = 5. + ); + accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_probability)> > acc6( + right_tail_cache_size = 2000 + , pot_threshold_probability = 0.995 + ); + + for (std::size_t i = 0; i < 100000; ++i) + { + double sample = normal(); + acc1(sample); + acc2(sample); + acc3(sample); + acc4(sample); + } + + for (std::size_t i = 0; i < 100000; ++i) + { + double sample = exponential(); + acc5(sample); + acc6(sample); + } + + BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, 3*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.999), 3.090232, 2*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.001), -3.090232, 2*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = 0.001), -3.090232, 2*epsilon ); + + BOOST_CHECK_CLOSE( quantile(acc5, quantile_probability = 0.999), 6.908, 3*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc6, quantile_probability = 0.999), 6.908, 3*epsilon ); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // tolerance in % + double epsilon = 1.; + // "persistent" storage + std::stringstream ss; + { + // random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc(pot_threshold_value = 3.); + + for (std::size_t i = 0; i < 100000; ++i) + acc(normal()); + + BOOST_CHECK_CLOSE(quantile(acc, quantile_probability = 0.999), 3.090232, 3*epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc(pot_threshold_value = 3.); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_CLOSE(quantile(acc, quantile_probability = 0.999), 3.090232, 3*epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("pot_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/reference.cpp b/src/boost/libs/accumulators/test/reference.cpp new file mode 100644 index 000000000..bf9b6c60c --- /dev/null +++ b/src/boost/libs/accumulators/test/reference.cpp @@ -0,0 +1,95 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +namespace my +{ + BOOST_PARAMETER_KEYWORD(tag, int_ref) + BOOST_PARAMETER_KEYWORD(tag, sum_acc) +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + int i = 0; + accumulator_set<double, stats<tag::reference<int, my::tag::int_ref> > > acc( + my::int_ref = i); + + int &ref1 = accumulators::reference<int, my::tag::int_ref>(acc); + int &ref2 = accumulators::reference_tag<my::tag::int_ref>(acc); + + BOOST_CHECK_EQUAL(&i, &ref1); + BOOST_CHECK_EQUAL(&i, &ref2); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_external +// +void test_external() +{ + typedef accumulator_set<int, stats<tag::sum> > sum_acc_type; + sum_acc_type sum_acc; // the sum accumulator + accumulator_set< + int + , stats< + tag::mean + , tag::external<tag::sum, my::tag::sum_acc> // make sum external + , tag::reference<sum_acc_type, my::tag::sum_acc> // and hold a reference to it + > + > acc_with_ref(my::sum_acc = sum_acc); // initialize the reference sum + + sum_acc(1); + sum_acc(2); // sum is now 3 for both + + BOOST_CHECK_EQUAL(sum(acc_with_ref), sum(sum_acc)); + BOOST_CHECK_EQUAL(sum(acc_with_ref), 3); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_external2 +// +void test_external2() +{ + typedef accumulator_set<int, stats<tag::sum> > sum_acc_type; + sum_acc_type sum_acc; // the sum accumulator + accumulator_set< + int + , stats< + tag::mean + // make sum external and hold a reference to it + , tag::external<tag::sum, my::tag::sum_acc, sum_acc_type> + > + > acc_with_ref(my::sum_acc = sum_acc); // initialize the reference sum + + sum_acc(1); + sum_acc(2); // sum is now 3 for both + + BOOST_CHECK_EQUAL(sum(acc_with_ref), sum(sum_acc)); + BOOST_CHECK_EQUAL(sum(acc_with_ref), 3); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("reference_accumulator test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_external)); + test->add(BOOST_TEST_CASE(&test_external2)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/rolling_count.cpp b/src/boost/libs/accumulators/test/rolling_count.cpp new file mode 100644 index 000000000..a1b6b6fe8 --- /dev/null +++ b/src/boost/libs/accumulators/test/rolling_count.cpp @@ -0,0 +1,78 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/rolling_count.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::rolling_count> > acc(tag::rolling_window::window_size = 3); + + BOOST_CHECK_EQUAL(0u, rolling_count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(1u, rolling_count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(2u, rolling_count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(3u, rolling_count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(3u, rolling_count(acc)); + + acc(1); + BOOST_CHECK_EQUAL(3u, rolling_count(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set<int, stats<tag::rolling_count> > acc(tag::rolling_window::window_size = 3); + acc(1); + acc(1); + acc(1); + acc(1); + acc(1); + acc(1); + BOOST_CHECK_EQUAL(3u, rolling_count(acc)); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::rolling_count> > acc(tag::rolling_window::window_size = 3); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(3u, rolling_count(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("rolling count test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/rolling_mean.cpp b/src/boost/libs/accumulators/test/rolling_mean.cpp new file mode 100644 index 000000000..f8037b4b0 --- /dev/null +++ b/src/boost/libs/accumulators/test/rolling_mean.cpp @@ -0,0 +1,219 @@ +// Copyright (C) Eric Niebler 2008. +// Copyright (C) Pieter Bastiaan Ober 2014. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/rolling_mean.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +void assert_is_double(T const &) +{ + BOOST_MPL_ASSERT((is_same<T, double>)); +} + +// test_rolling_mean_test_impl +// implements a test for window_size = 5 +size_t window_size = 5; + +template<typename accumulator_set_type> +void +test_rolling_mean_test_impl(accumulator_set_type& acc) +{ + acc(1); + BOOST_CHECK_CLOSE(1., rolling_mean(acc), 1e-5); + + acc(2); + BOOST_CHECK_CLOSE(1.5, rolling_mean(acc), 1e-5); + + acc(3); + BOOST_CHECK_CLOSE(2., rolling_mean(acc), 1e-5); + + acc(4); + BOOST_CHECK_CLOSE(2.5, rolling_mean(acc), 1e-5); + + acc(5); + BOOST_CHECK_CLOSE(3., rolling_mean(acc), 1e-5); + + acc(6); + BOOST_CHECK_CLOSE(4., rolling_mean(acc), 1e-5); + + acc(7); + BOOST_CHECK_CLOSE(5., rolling_mean(acc), 1e-5); + + assert_is_double(rolling_mean(acc)); +} + +template<typename accumulator_set_type> +void +test_rolling_mean_unsigned_test_impl(accumulator_set_type& acc) +{ + acc(7U); + BOOST_CHECK_CLOSE(7., rolling_mean(acc), 1e-5); + + acc(6U); + BOOST_CHECK_CLOSE(6.5, rolling_mean(acc), 1e-5); + + acc(5U); + BOOST_CHECK_CLOSE(6., rolling_mean(acc), 1e-5); + + acc(4U); + BOOST_CHECK_CLOSE(5.5, rolling_mean(acc), 1e-5); + + acc(3U); + BOOST_CHECK_CLOSE(5., rolling_mean(acc), 1e-5); + + acc(2U); + BOOST_CHECK_CLOSE(4., rolling_mean(acc), 1e-5); + + acc(1U); + BOOST_CHECK_CLOSE(3., rolling_mean(acc), 1e-5); + + assert_is_double(rolling_mean(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency_impl +// +template<typename accumulator_set_type> +void test_persistency_impl(accumulator_set_type& acc) +{ + std::stringstream ss; + { + acc(1); + acc(2); + acc(3); + acc(4); + acc(5); + acc(6); + acc(7); + BOOST_CHECK_CLOSE(5., rolling_mean(acc), 1e-5); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + // initialize from acc to make sure all values are passed + accumulator_set_type other_acc = acc; + // accumulate more, to make sure that deserialization set the right value + // and not the copy ctor + other_acc(100); + other_acc(100); + other_acc(100); + other_acc(100); + other_acc(100); + boost::archive::text_iarchive ia(ss); + other_acc.serialize(ia, 0); + BOOST_CHECK_CLOSE(5., rolling_mean(other_acc), 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_rolling_mean +void test_rolling_mean() +{ + accumulator_set<int,stats<tag::immediate_rolling_mean> > + acc_immediate_rolling_mean(tag::immediate_rolling_mean::window_size = window_size), + acc_immediate_rolling_mean2(tag::immediate_rolling_mean::window_size = window_size, sample = 0); + + accumulator_set<int,stats<tag::rolling_mean(immediate)> > + acc_immediate_rolling_mean3(tag::immediate_rolling_mean::window_size = window_size); + + accumulator_set<int,stats<tag::lazy_rolling_mean> > + acc_lazy_rolling_mean(tag::lazy_rolling_mean::window_size = window_size), + acc_lazy_rolling_mean2(tag::lazy_rolling_mean::window_size = window_size, sample = 0); + + accumulator_set<int,stats<tag::rolling_mean(lazy)> > + acc_lazy_rolling_mean3(tag::lazy_rolling_mean::window_size = window_size); + + accumulator_set<int,stats<tag::rolling_mean> > + acc_default_rolling_mean(tag::rolling_mean::window_size = window_size), + acc_default_rolling_mean2(tag::rolling_mean::window_size = window_size, sample = 0); + + //// test the different implementations + test_rolling_mean_test_impl(acc_lazy_rolling_mean); + test_rolling_mean_test_impl(acc_default_rolling_mean); + test_rolling_mean_test_impl(acc_immediate_rolling_mean); + + test_rolling_mean_test_impl(acc_lazy_rolling_mean2); + test_rolling_mean_test_impl(acc_default_rolling_mean2); + test_rolling_mean_test_impl(acc_immediate_rolling_mean2); + + test_rolling_mean_test_impl(acc_lazy_rolling_mean3); + test_rolling_mean_test_impl(acc_immediate_rolling_mean3); + + //// test that the default implementation is the 'immediate' computation + BOOST_REQUIRE(sizeof(acc_lazy_rolling_mean) != sizeof(acc_immediate_rolling_mean)); + BOOST_CHECK (sizeof(acc_default_rolling_mean) == sizeof(acc_immediate_rolling_mean)); + + //// test the equivalence of the different ways to indicate a feature + BOOST_CHECK (sizeof(acc_lazy_rolling_mean) == sizeof(acc_lazy_rolling_mean2)); + BOOST_CHECK (sizeof(acc_lazy_rolling_mean) == sizeof(acc_lazy_rolling_mean3)); + BOOST_CHECK (sizeof(acc_immediate_rolling_mean) == sizeof(acc_immediate_rolling_mean2)); + BOOST_CHECK (sizeof(acc_immediate_rolling_mean) == sizeof(acc_immediate_rolling_mean3)); + + //// test unsigned int with both implementations + accumulator_set<unsigned int,stats<tag::immediate_rolling_mean> > + acc_immediate_rolling_mean4(tag::immediate_rolling_mean::window_size = window_size), + acc_immediate_rolling_mean5(tag::immediate_rolling_mean::window_size = window_size, sample = 0); + + test_rolling_mean_unsigned_test_impl(acc_immediate_rolling_mean4); + test_rolling_mean_unsigned_test_impl(acc_immediate_rolling_mean5); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +void test_persistency() +{ + accumulator_set<int,stats<tag::immediate_rolling_mean> > + acc_immediate_rolling_mean(tag::immediate_rolling_mean::window_size = window_size), + acc_immediate_rolling_mean2(tag::immediate_rolling_mean::window_size = window_size, sample = 0); + + accumulator_set<int,stats<tag::rolling_mean(immediate)> > + acc_immediate_rolling_mean3(tag::immediate_rolling_mean::window_size = window_size); + + accumulator_set<int,stats<tag::lazy_rolling_mean> > + acc_lazy_rolling_mean(tag::lazy_rolling_mean::window_size = window_size), + acc_lazy_rolling_mean2(tag::lazy_rolling_mean::window_size = window_size, sample = 0); + + accumulator_set<int,stats<tag::rolling_mean(lazy)> > + acc_lazy_rolling_mean3(tag::lazy_rolling_mean::window_size = window_size); + + accumulator_set<int,stats<tag::rolling_mean> > + acc_default_rolling_mean(tag::rolling_mean::window_size = window_size), + acc_default_rolling_mean2(tag::rolling_mean::window_size = window_size, sample = 0); + + //// test the different implementations + test_persistency_impl(acc_lazy_rolling_mean); + test_persistency_impl(acc_default_rolling_mean); + test_persistency_impl(acc_immediate_rolling_mean); + + test_persistency_impl(acc_lazy_rolling_mean2); + test_persistency_impl(acc_default_rolling_mean2); + test_persistency_impl(acc_immediate_rolling_mean2); + + test_persistency_impl(acc_lazy_rolling_mean3); + test_persistency_impl(acc_immediate_rolling_mean3); +} +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("rolling mean test"); + + test->add(BOOST_TEST_CASE(&test_rolling_mean)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/rolling_moment.cpp b/src/boost/libs/accumulators/test/rolling_moment.cpp new file mode 100644 index 000000000..30d0c88b5 --- /dev/null +++ b/src/boost/libs/accumulators/test/rolling_moment.cpp @@ -0,0 +1,119 @@ +// Copyright (C) Eric Niebler 2005. +// Copyright (C) Pieter Bastiaan Ober 2014. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/rolling_moment.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +void assert_is_double(T const &) +{ + BOOST_MPL_ASSERT((is_same<T, double>)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_rolling_moment +// + +void test_rolling_second_moment() +{ + accumulator_set<int, stats<tag::rolling_moment<2> > > acc(tag::rolling_moment<2>::window_size = 3); + + acc(2); + + BOOST_CHECK_CLOSE(rolling_moment<2>(acc), 4.0/1 ,1e-5); + + acc(4); + + BOOST_CHECK_CLOSE(rolling_moment<2>(acc), (4.0 + 16.0)/2, 1e-5); + + acc(5); + + BOOST_CHECK_CLOSE(rolling_moment<2>(acc), (4.0 + 16.0 + 25.0)/3, 1e-5); + + acc(6); + + BOOST_CHECK_CLOSE(rolling_moment<2>(acc), (16.0 + 25.0 + 36.0)/3, 1e-5); + + assert_is_double(rolling_moment<2>(acc)); +} + +void test_rolling_fifth_moment() +{ + accumulator_set<int, stats<tag::rolling_moment<5> > > acc(tag::rolling_moment<2>::window_size = 3); + + acc(2); + + BOOST_CHECK_CLOSE(rolling_moment<5>(acc), 32.0/1, 1e-5); + + acc(3); + + BOOST_CHECK_CLOSE(rolling_moment<5>(acc), (32.0 + 243.0)/2, 1e-5); + + acc(4); + + BOOST_CHECK_CLOSE(rolling_moment<5>(acc), (32.0 + 243.0 + 1024.0)/3, 1e-5); + + acc(5); + + BOOST_CHECK_CLOSE(rolling_moment<5>(acc), (243.0 + 1024.0 + 3125.0)/3, 1e-5); + + assert_is_double(rolling_moment<5>(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set<int, stats<tag::rolling_moment<2> > > acc2(tag::rolling_moment<2>::window_size = 3); + accumulator_set<int, stats<tag::rolling_moment<5> > > acc5(tag::rolling_moment<5>::window_size = 3); + + acc2(2); acc5(2); + acc2(4); acc5(3); + acc2(5); acc5(4); + acc2(6); acc5(5); + + BOOST_CHECK_CLOSE(rolling_moment<2>(acc2), (16.0 + 25.0 + 36.0)/3, 1e-5); + BOOST_CHECK_CLOSE(rolling_moment<5>(acc5), (243.0 + 1024.0 + 3125.0)/3, 1e-5); + boost::archive::text_oarchive oa(ss); + acc2.serialize(oa, 0); + acc5.serialize(oa, 0); + } + accumulator_set<int, stats<tag::rolling_moment<2> > > acc2(tag::rolling_moment<2>::window_size = 3); + accumulator_set<int, stats<tag::rolling_moment<5> > > acc5(tag::rolling_moment<5>::window_size = 3); + boost::archive::text_iarchive ia(ss); + acc2.serialize(ia, 0); + acc5.serialize(ia, 0); + BOOST_CHECK_CLOSE(rolling_moment<2>(acc2), (16.0 + 25.0 + 36.0)/3, 1e-5); + BOOST_CHECK_CLOSE(rolling_moment<5>(acc5), (243.0 + 1024.0 + 3125.0)/3, 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("rolling moment test"); + + test->add(BOOST_TEST_CASE(&test_rolling_second_moment)); + test->add(BOOST_TEST_CASE(&test_rolling_fifth_moment)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/rolling_sum.cpp b/src/boost/libs/accumulators/test/rolling_sum.cpp new file mode 100644 index 000000000..374514c00 --- /dev/null +++ b/src/boost/libs/accumulators/test/rolling_sum.cpp @@ -0,0 +1,77 @@ +// (C) Copyright Eric Niebler 2008. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/rolling_sum.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::rolling_sum> > acc(tag::rolling_window::window_size = 3); + + BOOST_CHECK_EQUAL(0, rolling_sum(acc)); + + acc(1); + BOOST_CHECK_EQUAL(1, rolling_sum(acc)); + + acc(2); + BOOST_CHECK_EQUAL(3, rolling_sum(acc)); + + acc(3); + BOOST_CHECK_EQUAL(6, rolling_sum(acc)); + + acc(4); + BOOST_CHECK_EQUAL(9, rolling_sum(acc)); + + acc(5); + BOOST_CHECK_EQUAL(12, rolling_sum(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set<int, stats<tag::rolling_sum> > acc(tag::rolling_window::window_size = 3); + acc(1); + acc(2); + acc(3); + acc(4); + acc(5); + BOOST_CHECK_EQUAL(12, rolling_sum(acc)); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::rolling_sum> > acc(tag::rolling_window::window_size = 3); + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(12, rolling_sum(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("rolling sum test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/rolling_variance.cpp b/src/boost/libs/accumulators/test/rolling_variance.cpp new file mode 100644 index 000000000..d7f007595 --- /dev/null +++ b/src/boost/libs/accumulators/test/rolling_variance.cpp @@ -0,0 +1,208 @@ +// (C) Copyright Pieter Bastiaan Ober 2014. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> +#include <boost/accumulators/statistics/rolling_variance.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +void assert_is_double(T const &) +{ + BOOST_MPL_ASSERT((is_same<T, double>)); +} + +/* +REFERENCE VALUES PROVIDED BY OCTAVE: + +x=[1.2 2.3 3.4 4.5 0.4 2.2 7.1 4.0] + +v1_2 = var(x(1:2)) +v1_3 = var(x(1:3)) +v1_4 = var(x(1:4)) +v2_5 = var(x(2:5)) +v3_6 = var(x(3:6)) +v4_7 = var(x(4:7)) +v5_8 = var(x(5:8)) + +GIVES: + +v1_2 = 0.605000000000000 +v1_3 = 1.21000000000000 +v1_4 = 2.01666666666667 +v2_5 = 3.05666666666667 +v3_6 = 3.08250000000000 +v4_7 = 8.41666666666667 +v5_8 = 8.16250000000000 +*/ + +/////////////////////////////////////////////////////////////////////////////// +// rolling_variance_test_impl +// implements a test for window_size = 4 + +size_t window_size = 4; + +template<typename accumulator_set_type> +void rolling_variance_test_impl(accumulator_set_type& acc) +{ + // Window contains x(1), value is zero + acc(1.2); + BOOST_CHECK_CLOSE(rolling_variance(acc),0.0,1e-10); + + // Window contains x(1)...x(2) + acc(2.3); + BOOST_CHECK_CLOSE(rolling_variance(acc),0.605,1e-10); + + // Window contains x(1)...x(3) + acc(3.4); + BOOST_CHECK_CLOSE(rolling_variance(acc),1.21,1e-10); + + // Window contains x(1)...x(4) + acc(4.5); + BOOST_CHECK_CLOSE(rolling_variance(acc),2.01666666666667,1e-10); + + // Window contains x(2)...x(5) + acc(0.4); + BOOST_CHECK_CLOSE(rolling_variance(acc),3.05666666666667,1e-10); + + // Window contains x(3)...x(6) + acc(2.2); + BOOST_CHECK_CLOSE(rolling_variance(acc),3.08250000000000,1e-10); + + // Window contains x(4)...x(7) + acc(7.1); + BOOST_CHECK_CLOSE(rolling_variance(acc),8.41666666666667,1e-10); + + // Window contains x(5)...x(8) + acc(4.0); + BOOST_CHECK_CLOSE(rolling_variance(acc),8.16250000000000,1e-10); + + assert_is_double(rolling_variance(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_rolling_variance +// +void test_rolling_variance() +{ + // tag::rolling_window::window_size + accumulator_set<double, stats<tag::immediate_rolling_variance> > + acc_immediate_rolling_variance(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::immediate_rolling_variance, tag::rolling_mean> > + acc_immediate_rolling_variance2(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::rolling_variance(immediate)> > + acc_immediate_rolling_variance3(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::lazy_rolling_variance> > + acc_lazy_rolling_variance(tag::lazy_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::rolling_variance(lazy)> > + acc_lazy_rolling_variance2(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::rolling_variance> > + acc_default_rolling_variance(tag::rolling_variance::window_size = window_size); + + //// test the different implementations + rolling_variance_test_impl(acc_immediate_rolling_variance); + rolling_variance_test_impl(acc_immediate_rolling_variance2); + rolling_variance_test_impl(acc_immediate_rolling_variance3); + rolling_variance_test_impl(acc_lazy_rolling_variance); + rolling_variance_test_impl(acc_lazy_rolling_variance2); + rolling_variance_test_impl(acc_default_rolling_variance); + + //// test that the default implementation is the 'immediate' computation + BOOST_REQUIRE(sizeof(acc_lazy_rolling_variance) != sizeof(acc_immediate_rolling_variance)); + BOOST_CHECK (sizeof(acc_default_rolling_variance) == sizeof(acc_immediate_rolling_variance)); + + //// test the equivalence of the different ways to indicate a feature + BOOST_CHECK (sizeof(acc_immediate_rolling_variance) == sizeof(acc_immediate_rolling_variance2)); + BOOST_CHECK (sizeof(acc_immediate_rolling_variance) == sizeof(acc_immediate_rolling_variance3)); + BOOST_CHECK (sizeof(acc_lazy_rolling_variance) == sizeof(acc_lazy_rolling_variance2)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency_impl +// +template<typename accumulator_set_type> +void test_persistency_impl(accumulator_set_type& acc) +{ + std::stringstream ss; + { + acc(1.2); + acc(2.3); + acc(3.4); + acc(4.5); + acc(0.4); + acc(2.2); + acc(7.1); + acc(4.0); + BOOST_CHECK_CLOSE(rolling_variance(acc),8.16250000000000,1e-10); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set_type other_acc = acc; + boost::archive::text_iarchive ia(ss); + other_acc.serialize(ia, 0); + BOOST_CHECK_CLOSE(rolling_variance(acc),8.16250000000000,1e-10); + +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + // tag::rolling_window::window_size + accumulator_set<double, stats<tag::immediate_rolling_variance> > + acc_immediate_rolling_variance(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::immediate_rolling_variance, tag::rolling_mean> > + acc_immediate_rolling_variance2(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::rolling_variance(immediate)> > + acc_immediate_rolling_variance3(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::lazy_rolling_variance> > + acc_lazy_rolling_variance(tag::lazy_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::rolling_variance(lazy)> > + acc_lazy_rolling_variance2(tag::immediate_rolling_variance::window_size = window_size); + + accumulator_set<double, stats<tag::rolling_variance> > + acc_default_rolling_variance(tag::rolling_variance::window_size = window_size); + + //// test the different implementations + test_persistency_impl(acc_immediate_rolling_variance); + test_persistency_impl(acc_immediate_rolling_variance2); + test_persistency_impl(acc_immediate_rolling_variance3); + test_persistency_impl(acc_lazy_rolling_variance); + test_persistency_impl(acc_lazy_rolling_variance2); + test_persistency_impl(acc_default_rolling_variance); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("rolling variance test"); + + test->add(BOOST_TEST_CASE(&test_rolling_variance)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/skewness.cpp b/src/boost/libs/accumulators/test/skewness.cpp new file mode 100644 index 000000000..8a8246883 --- /dev/null +++ b/src/boost/libs/accumulators/test/skewness.cpp @@ -0,0 +1,100 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for skewness.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/skewness.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + // double epsilon = 1; + + accumulator_set<double, stats<tag::skewness > > acc1; + accumulator_set<int, stats<tag::skewness > > acc2; + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i=0; i<100000; ++i) + { + acc1(normal()); + } + + // This check fails because epsilon is relative and not absolute + // BOOST_CHECK_CLOSE( skewness(acc1), 0., epsilon ); + + acc2(2); + acc2(7); + acc2(4); + acc2(9); + acc2(3); + + BOOST_CHECK_EQUAL( mean(acc2), 5 ); + BOOST_CHECK_EQUAL( accumulators::moment<2>(acc2), 159./5. ); + BOOST_CHECK_EQUAL( accumulators::moment<3>(acc2), 1171./5. ); + BOOST_CHECK_CLOSE( skewness(acc2), 0.406040288214, 1e-6 ); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + double epsilon = 1e-6; + std::stringstream ss; + { + accumulator_set<int, stats<tag::skewness > > acc; + acc(2); + acc(7); + acc(4); + acc(9); + acc(3); + + BOOST_CHECK_EQUAL(accumulators::moment<3>(acc), 1171./5.); + BOOST_CHECK_CLOSE(skewness(acc), 0.406040288214, epsilon); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::skewness > > acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(accumulators::moment<3>(acc), 1171./5.); + BOOST_CHECK_CLOSE(skewness(acc), 0.406040288214, epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("skewness test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/sum.cpp b/src/boost/libs/accumulators/test/sum.cpp new file mode 100644 index 000000000..c0c8f8c08 --- /dev/null +++ b/src/boost/libs/accumulators/test/sum.cpp @@ -0,0 +1,80 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/sum.hpp> +#include <boost/accumulators/statistics/weighted_sum.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::sum, tag::sum_of_weights, tag::sum_of_variates<int, tag::covariate1> >, int> acc; + + acc(1, weight = 2, covariate1 = 3); + BOOST_CHECK_EQUAL(2, sum(acc)); + BOOST_CHECK_EQUAL(2, sum_of_weights(acc)); + BOOST_CHECK_EQUAL(3, sum_of_variates(acc)); + + acc(2, weight = 4, covariate1 = 6); + BOOST_CHECK_EQUAL(10, sum(acc)); + BOOST_CHECK_EQUAL(6, sum_of_weights(acc)); + BOOST_CHECK_EQUAL(9, sum_of_variates(acc)); + + acc(3, weight = 6, covariate1 = 9); + BOOST_CHECK_EQUAL(28, sum(acc)); + BOOST_CHECK_EQUAL(12, sum_of_weights(acc)); + BOOST_CHECK_EQUAL(18, sum_of_variates(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set<int, stats<tag::sum, tag::sum_of_weights, tag::sum_of_variates<int, tag::covariate1> >, int> acc; + acc(1, weight = 2, covariate1 = 3); + acc(2, weight = 4, covariate1 = 6); + acc(3, weight = 6, covariate1 = 9); + BOOST_CHECK_EQUAL(28, sum(acc)); + BOOST_CHECK_EQUAL(12, sum_of_weights(acc)); + BOOST_CHECK_EQUAL(18, sum_of_variates(acc)); + + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set<int, stats<tag::sum, tag::sum_of_weights, tag::sum_of_variates<int, tag::covariate1> >, int> acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(28, sum(acc)); + BOOST_CHECK_EQUAL(12, sum_of_weights(acc)); + BOOST_CHECK_EQUAL(18, sum_of_variates(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("sum test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/sum_kahan.cpp b/src/boost/libs/accumulators/test/sum_kahan.cpp new file mode 100644 index 000000000..85edb1169 --- /dev/null +++ b/src/boost/libs/accumulators/test/sum_kahan.cpp @@ -0,0 +1,120 @@ +// (C) Copyright Gaetano Mendola 2010, Simon West 2011. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/sum_kahan.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_sum_kahan +// +void test_sum_kahan() +{ + accumulator_set<float, stats<tag::sum_kahan> > acc; + + BOOST_CHECK_EQUAL(0.0f, sum_kahan(acc)); + + for (size_t i = 0; i < 1e6; ++i) { + acc(1e-6f); + } + + BOOST_CHECK_EQUAL(1.0f, sum_kahan(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_sum_of_weights_kahan +// +void test_sum_of_weights_kahan() +{ + accumulator_set<float, stats<tag::sum_of_weights_kahan>, float > acc; + + BOOST_CHECK_EQUAL(0.0f, sum_of_weights_kahan(acc)); + + for (size_t i = 0; i < 1e6; ++i) { + acc(0, weight = 1e-6f); + } + + BOOST_CHECK_EQUAL(1.0f, sum_of_weights_kahan(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_sum_of_variates_kahan +// +void test_sum_of_variates_kahan() +{ + accumulator_set< + float, + stats<tag::sum_of_variates_kahan<float, tag::covariate1> >, + float + > + acc; + + BOOST_CHECK_EQUAL(0.0f, sum_of_variates_kahan(acc)); + + for (size_t i = 0; i < 1e6; ++i) { + acc(0, covariate1 = 1e-6f); + } + + BOOST_CHECK_EQUAL(1.0f, sum_of_variates_kahan(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + std::stringstream ss; + { + accumulator_set< + float, + stats<tag::sum_of_variates_kahan<float, tag::covariate1> >, + float + > + acc; + + BOOST_CHECK_EQUAL(0.0f, sum_of_variates_kahan(acc)); + + for (size_t i = 0; i < 1e6; ++i) { + acc(0, covariate1 = 1e-6f); + } + + BOOST_CHECK_EQUAL(1.0f, sum_of_variates_kahan(acc)); + boost::archive::text_oarchive oa(ss); + acc.serialize(oa, 0); + } + accumulator_set< + float, + stats<tag::sum_of_variates_kahan<float, tag::covariate1> >, + float + > + acc; + boost::archive::text_iarchive ia(ss); + acc.serialize(ia, 0); + BOOST_CHECK_EQUAL(1.0f, sum_of_variates_kahan(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("sum kahan tests"); + + test->add(BOOST_TEST_CASE(&test_sum_kahan)); + test->add(BOOST_TEST_CASE(&test_sum_of_weights_kahan)); + test->add(BOOST_TEST_CASE(&test_sum_of_variates_kahan)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/tail.cpp b/src/boost/libs/accumulators/test/tail.cpp new file mode 100644 index 000000000..f3e248ec8 --- /dev/null +++ b/src/boost/libs/accumulators/test/tail.cpp @@ -0,0 +1,126 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/foreach.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/tail.hpp> +#include <boost/accumulators/statistics/tail_variate.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename Range> +void check_tail(Range const &rng, char const *expected) +{ + BOOST_FOREACH(int i, rng) + { + if(!*expected) + { + BOOST_CHECK(false); + return; + } + BOOST_CHECK_EQUAL(i, *expected++); + } + BOOST_CHECK(!*expected); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_right_tail +// +void test_right_tail() +{ + accumulator_set<int, stats<tag::tail_weights<right>, tag::tail_variate<int, tag::covariate1, right> >, int > acc( + right_tail_cache_size = 4 + ); + + acc(010, weight = 2, covariate1 = 3); + check_tail(tail(acc), "\10"); + check_tail(tail_variate(acc), "\3"); + check_tail(tail_weights(acc), "\2"); + + acc(020, weight = 7, covariate1 = 1); + check_tail(tail(acc), "\20\10"); + check_tail(tail_variate(acc), "\1\3"); + check_tail(tail_weights(acc), "\7\2"); + + acc(014, weight = 6, covariate1 = 4); + check_tail(tail(acc), "\20\14\10"); + check_tail(tail_variate(acc), "\1\4\3"); + check_tail(tail_weights(acc), "\7\6\2"); + + acc(030, weight = 4, covariate1 = 5); + check_tail(tail(acc), "\30\20\14\10"); + check_tail(tail_variate(acc), "\5\1\4\3"); + check_tail(tail_weights(acc), "\4\7\6\2"); + + acc(001, weight = 1, covariate1 = 9); + check_tail(tail(acc), "\30\20\14\10"); + check_tail(tail_variate(acc), "\5\1\4\3"); + check_tail(tail_weights(acc), "\4\7\6\2"); + + acc(011, weight = 3, covariate1 = 7); + check_tail(tail(acc), "\30\20\14\11"); + check_tail(tail_variate(acc), "\5\1\4\7"); + check_tail(tail_weights(acc), "\4\7\6\3"); + +} + +/////////////////////////////////////////////////////////////////////////////// +// test_left_tail +// +void test_left_tail() +{ + accumulator_set<int, stats<tag::tail_weights<left>, tag::tail_variate<int, tag::covariate1, left> >, int > acc( + left_tail_cache_size = 4 + ); + + acc(010, weight = 2, covariate1 = 3); + check_tail(tail(acc), "\10"); + check_tail(tail_variate(acc), "\3"); + check_tail(tail_weights(acc), "\2"); + + acc(020, weight = 7, covariate1 = 1); + check_tail(tail(acc), "\10\20"); + check_tail(tail_variate(acc), "\3\1"); + check_tail(tail_weights(acc), "\2\7"); + + acc(014, weight = 6, covariate1 = 4); + check_tail(tail(acc), "\10\14\20"); + check_tail(tail_variate(acc), "\3\4\1"); + check_tail(tail_weights(acc), "\2\6\7"); + + acc(030, weight = 4, covariate1 = 5); + check_tail(tail(acc), "\10\14\20\30"); + check_tail(tail_variate(acc), "\3\4\1\5"); + check_tail(tail_weights(acc), "\2\6\7\4"); + + acc(001, weight = 1, covariate1 = 9); + check_tail(tail(acc), "\1\10\14\20"); + check_tail(tail_variate(acc), "\x9\3\4\1"); + check_tail(tail_weights(acc), "\1\2\6\7"); + + acc(011, weight = 3, covariate1 = 7); + check_tail(tail(acc), "\1\10\11\14"); + check_tail(tail_variate(acc), "\x9\3\7\4"); + check_tail(tail_weights(acc), "\1\2\3\6"); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("tail test"); + + test->add(BOOST_TEST_CASE(&test_right_tail)); + test->add(BOOST_TEST_CASE(&test_left_tail)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/tail_mean.cpp b/src/boost/libs/accumulators/test/tail_mean.cpp new file mode 100644 index 000000000..5132eb247 --- /dev/null +++ b/src/boost/libs/accumulators/test/tail_mean.cpp @@ -0,0 +1,86 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for tail_mean.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/tail_mean.hpp> +#include <boost/accumulators/statistics/tail_quantile.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1; + + std::size_t n = 100000; // number of MC steps + std::size_t c = 10000; // cache size + + typedef accumulator_set<double, stats<tag::non_coherent_tail_mean<right>, tag::tail_quantile<right> > > accumulator_t_right1; + typedef accumulator_set<double, stats<tag::non_coherent_tail_mean<left>, tag::tail_quantile<left> > > accumulator_t_left1; + typedef accumulator_set<double, stats<tag::coherent_tail_mean<right>, tag::tail_quantile<right> > > accumulator_t_right2; + typedef accumulator_set<double, stats<tag::coherent_tail_mean<left>, tag::tail_quantile<left> > > accumulator_t_left2; + + accumulator_t_right1 acc0( right_tail_cache_size = c ); + accumulator_t_left1 acc1( left_tail_cache_size = c ); + accumulator_t_right2 acc2( right_tail_cache_size = c ); + accumulator_t_left2 acc3( left_tail_cache_size = c ); + + // a random number generator + boost::lagged_fibonacci607 rng; + + for (std::size_t i = 0; i < n; ++i) + { + double sample = rng(); + acc0(sample); + acc1(sample); + acc2(sample); + acc3(sample); + } + + // check uniform distribution + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc0, quantile_probability = 0.95), 0.975, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc0, quantile_probability = 0.975), 0.9875, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc0, quantile_probability = 0.99), 0.995, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc0, quantile_probability = 0.999), 0.9995, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc1, quantile_probability = 0.05), 0.025, 5*epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc1, quantile_probability = 0.025), 0.0125, 6*epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc1, quantile_probability = 0.01), 0.005, 8*epsilon ); + BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc1, quantile_probability = 0.001), 0.0005, 25*epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc2, quantile_probability = 0.95), 0.975, epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc2, quantile_probability = 0.975), 0.9875, epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc2, quantile_probability = 0.99), 0.995, epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc2, quantile_probability = 0.999), 0.9995, epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc3, quantile_probability = 0.05), 0.025, 5*epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc3, quantile_probability = 0.025), 0.0125, 6*epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc3, quantile_probability = 0.01), 0.005, 8*epsilon ); + BOOST_CHECK_CLOSE( tail_mean(acc3, quantile_probability = 0.001), 0.0005, 25*epsilon ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("tail_mean test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/tail_quantile.cpp b/src/boost/libs/accumulators/test/tail_quantile.cpp new file mode 100644 index 000000000..1f539d854 --- /dev/null +++ b/src/boost/libs/accumulators/test/tail_quantile.cpp @@ -0,0 +1,85 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for tail_quantile.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/tail_quantile.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1; + + std::size_t n = 100000; // number of MC steps + std::size_t c = 10000; // cache size + + typedef accumulator_set<double, stats<tag::tail_quantile<right> > > accumulator_t_right; + typedef accumulator_set<double, stats<tag::tail_quantile<left> > > accumulator_t_left; + + accumulator_t_right acc0( right_tail_cache_size = c ); + accumulator_t_right acc1( right_tail_cache_size = c ); + accumulator_t_left acc2( left_tail_cache_size = c ); + accumulator_t_left acc3( left_tail_cache_size = c ); + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i = 0; i < n; ++i) + { + double sample1 = rng(); + double sample2 = normal(); + acc0(sample1); + acc1(sample2); + acc2(sample1); + acc3(sample2); + } + + // check uniform distribution + BOOST_CHECK_CLOSE( quantile(acc0, quantile_probability = 0.95 ), 0.95, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc0, quantile_probability = 0.975), 0.975, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc0, quantile_probability = 0.99 ), 0.99, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc0, quantile_probability = 0.999), 0.999, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.05 ), 0.05, 4*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.025), 0.025, 5*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.01 ), 0.01, 7*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.001), 0.001, 22*epsilon ); + + // check standard normal distribution + BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.975), 1.959963, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, 3*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.025), -1.959963, 2*epsilon ); + BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.001), -3.090232, 3*epsilon ); + +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("tail_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/tail_variate_means.cpp b/src/boost/libs/accumulators/test/tail_variate_means.cpp new file mode 100644 index 000000000..6d0031999 --- /dev/null +++ b/src/boost/libs/accumulators/test/tail_variate_means.cpp @@ -0,0 +1,131 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for tail_variate_means.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/tail_variate_means.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + std::size_t c = 5; // cache size + + typedef double variate_type; + typedef std::vector<variate_type> variate_set_type; + + typedef accumulator_set<double, stats<tag::tail_variate_means<right, variate_set_type, tag::covariate1>(relative)> > accumulator_t1; + typedef accumulator_set<double, stats<tag::tail_variate_means<right, variate_set_type, tag::covariate1>(absolute)> > accumulator_t2; + typedef accumulator_set<double, stats<tag::tail_variate_means<left, variate_set_type, tag::covariate1>(relative)> > accumulator_t3; + typedef accumulator_set<double, stats<tag::tail_variate_means<left, variate_set_type, tag::covariate1>(absolute)> > accumulator_t4; + + accumulator_t1 acc1( right_tail_cache_size = c ); + accumulator_t2 acc2( right_tail_cache_size = c ); + accumulator_t3 acc3( left_tail_cache_size = c ); + accumulator_t4 acc4( left_tail_cache_size = c ); + + variate_set_type cov1, cov2, cov3, cov4, cov5; + double c1[] = { 10., 20., 30., 40. }; // 100 + double c2[] = { 26., 4., 17., 3. }; // 50 + double c3[] = { 46., 64., 40., 50. }; // 200 + double c4[] = { 1., 3., 70., 6. }; // 80 + double c5[] = { 2., 2., 2., 14. }; // 20 + cov1.assign(c1, c1 + sizeof(c1)/sizeof(variate_type)); + cov2.assign(c2, c2 + sizeof(c2)/sizeof(variate_type)); + cov3.assign(c3, c3 + sizeof(c3)/sizeof(variate_type)); + cov4.assign(c4, c4 + sizeof(c4)/sizeof(variate_type)); + cov5.assign(c5, c5 + sizeof(c5)/sizeof(variate_type)); + + acc1(100., covariate1 = cov1); + acc1( 50., covariate1 = cov2); + acc1(200., covariate1 = cov3); + acc1( 80., covariate1 = cov4); + acc1( 20., covariate1 = cov5); + + acc2(100., covariate1 = cov1); + acc2( 50., covariate1 = cov2); + acc2(200., covariate1 = cov3); + acc2( 80., covariate1 = cov4); + acc2( 20., covariate1 = cov5); + + acc3(100., covariate1 = cov1); + acc3( 50., covariate1 = cov2); + acc3(200., covariate1 = cov3); + acc3( 80., covariate1 = cov4); + acc3( 20., covariate1 = cov5); + + acc4(100., covariate1 = cov1); + acc4( 50., covariate1 = cov2); + acc4(200., covariate1 = cov3); + acc4( 80., covariate1 = cov4); + acc4( 20., covariate1 = cov5); + + // check relative risk contributions + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.7).begin() ), 14./75. ); // (10 + 46) / 300 = 14/75 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 1), 7./25. ); // (20 + 64) / 300 = 7/25 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 2), 7./30. ); // (30 + 40) / 300 = 7/30 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 3), 3./10. ); // (40 + 50) / 300 = 3/10 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() ), 14./35. ); // (26 + 2) / 70 = 14/35 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 1), 3./35. ); // ( 4 + 2) / 70 = 3/35 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 2), 19./70. ); // (17 + 2) / 70 = 19/70 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 3), 17./70. ); // ( 3 + 14) / 70 = 17/70 + + // check absolute risk contributions + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.7).begin() ), 28 ); // (10 + 46) / 2 = 28 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.7).begin() + 1), 42 ); // (20 + 64) / 2 = 42 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.7).begin() + 2), 35 ); // (30 + 40) / 2 = 35 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.7).begin() + 3), 45 ); // (40 + 50) / 2 = 45 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() ), 14 ); // (26 + 2) / 2 = 14 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() + 1), 3 ); // ( 4 + 2) / 2 = 3 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() + 2),9.5 ); // (17 + 2) / 2 = 9.5 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() + 3),8.5 ); // ( 3 + 14) / 2 = 8.5 + + // check relative risk contributions + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.9).begin() ), 23./100. ); // 46/200 = 23/100 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 1), 8./25. ); // 64/200 = 8/25 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 2), 1./5. ); // 40/200 = 1/5 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 3), 1./4. ); // 50/200 = 1/4 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() ), 1./10. ); // 2/ 20 = 1/10 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 1), 1./10. ); // 2/ 20 = 1/10 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 2), 1./10. ); // 2/ 20 = 1/10 + BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 3), 7./10. ); // 14/ 20 = 7/10 + + // check absolute risk contributions + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.9).begin() ), 46 ); // 46 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.9).begin() + 1), 64 ); // 64 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.9).begin() + 2), 40 ); // 40 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.9).begin() + 3), 50 ); // 50 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.1).begin() ), 2 ); // 2 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.1).begin() + 1), 2 ); // 2 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.1).begin() + 2), 2 ); // 2 + BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.1).begin() + 3), 14 ); // 14 +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("tail_variate_means test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/valarray.cpp b/src/boost/libs/accumulators/test/valarray.cpp new file mode 100644 index 000000000..ca0842de8 --- /dev/null +++ b/src/boost/libs/accumulators/test/valarray.cpp @@ -0,0 +1,180 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <valarray> +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_floating_point.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/min.hpp> +#include <boost/accumulators/statistics/max.hpp> +#include <boost/accumulators/statistics/mean.hpp> +#include <boost/accumulators/statistics/weighted_mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +typename boost::enable_if<is_floating_point<T> >::type is_equal_or_close(T const &left, T const &right) +{ + BOOST_CHECK_CLOSE(left, right, 1e-5); +} + +template<typename T> +typename boost::disable_if<is_floating_point<T> >::type is_equal_or_close(T const &left, T const &right) +{ + BOOST_CHECK_EQUAL(left, right); +} + +template<typename T> +void is_equal(std::valarray<T> const &left, std::valarray<T> const &right) +{ + BOOST_CHECK_EQUAL(left.size(), right.size()); + if(left.size() == right.size()) + { + for(std::size_t i = 0; i < left.size(); ++i) + { + is_equal_or_close(left[i], right[i]); + } + } +} + +namespace std +{ + template<typename T> + inline std::ostream &operator <<(std::ostream &sout, std::valarray<T> const &arr) + { + sout << '('; + for(std::size_t i = 0; i < arr.size(); ++i) + { + sout << arr[i] << ','; + } + sout << ')' << std::endl; + return sout; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + typedef std::valarray<int> sample_t; + + // test sum + { + accumulator_set<sample_t, stats<tag::sum> > acc(sample = sample_t(0,3)); + + acc(sample_t(1,3)); + acc(sample_t(2,3)); + acc(sample_t(3,3)); + + is_equal(sample_t(6,3), sum(acc)); + } + + // test min and max + { + int s1[] = {1,2,3}, s2[] = {0,3,4}, s3[] = {2,1,4}, min_res[] = {0,1,3}, max_res[] = {2,3,4}; + accumulator_set<sample_t, stats<tag::min, tag::max> > acc(sample = sample_t(0,3)); + + acc(sample_t(s1,3)); + acc(sample_t(s2,3)); + acc(sample_t(s3,3)); + + is_equal(sample_t(min_res,3), (min)(acc)); + is_equal(sample_t(max_res,3), (max)(acc)); + } + + // test mean(lazy) and mean(immediate) + { + accumulator_set<sample_t, stats<tag::mean> > acc(sample = sample_t(0,3)); + + acc(sample_t(1,3)); + is_equal(std::valarray<double>(1., 3), mean(acc)); + BOOST_CHECK_EQUAL(1u, count(acc)); + is_equal(sample_t(1, 3), sum(acc)); + + acc(sample_t(0,3)); + is_equal(std::valarray<double>(0.5, 3), mean(acc)); + BOOST_CHECK_EQUAL(2u, count(acc)); + is_equal(sample_t(1, 3), sum(acc)); + + acc(sample_t(2,3)); + is_equal(std::valarray<double>(1., 3), mean(acc)); + BOOST_CHECK_EQUAL(3u, count(acc)); + is_equal(sample_t(3, 3), sum(acc)); + + + accumulator_set<sample_t, stats<tag::mean(immediate)> > acc2(sample = sample_t(0,3)); + + acc2(sample_t(1,3)); + is_equal(std::valarray<double>(1., 3), mean(acc2)); + BOOST_CHECK_EQUAL(1u, count(acc2)); + + acc2(sample_t(0,3)); + is_equal(std::valarray<double>(0.5, 3), mean(acc2)); + BOOST_CHECK_EQUAL(2u, count(acc2)); + + acc2(sample_t(2,3)); + is_equal(std::valarray<double>(1., 3), mean(acc2)); + BOOST_CHECK_EQUAL(3u, count(acc2)); + } + + // test weighted_mean + { + accumulator_set<sample_t, stats<tag::weighted_mean>, int> acc(sample = sample_t(0,3)); + + acc(sample_t(10,3), weight = 2); // 20 + BOOST_CHECK_EQUAL(2, sum_of_weights(acc)); // + // + acc(sample_t(6,3), weight = 3); // 18 + BOOST_CHECK_EQUAL(5, sum_of_weights(acc)); // + // + acc(sample_t(4,3), weight = 4); // 16 + BOOST_CHECK_EQUAL(9, sum_of_weights(acc)); // + // + acc(sample_t(6,3), weight = 5); //+ 30 + BOOST_CHECK_EQUAL(14, sum_of_weights(acc)); // + //= 84 / 14 = 6 + + is_equal(std::valarray<double>(6.,3), weighted_mean(acc)); + + + accumulator_set<sample_t, stats<tag::weighted_mean(immediate)>, int> acc2(sample = sample_t(0,3)); + + acc2(sample_t(10,3), weight = 2); // 20 + BOOST_CHECK_EQUAL(2, sum_of_weights(acc2)); // + // + acc2(sample_t(6,3), weight = 3); // 18 + BOOST_CHECK_EQUAL(5, sum_of_weights(acc2)); // + // + acc2(sample_t(4,3), weight = 4); // 16 + BOOST_CHECK_EQUAL(9, sum_of_weights(acc2)); // + // + acc2(sample_t(6,3), weight = 5); //+ 30 + BOOST_CHECK_EQUAL(14, sum_of_weights(acc2));// + //= 84 / 14 = 6 + + is_equal(std::valarray<double>(6.,3), weighted_mean(acc2)); + + } +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("valarray test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/value.cpp b/src/boost/libs/accumulators/test/value.cpp new file mode 100644 index 000000000..3f059ce25 --- /dev/null +++ b/src/boost/libs/accumulators/test/value.cpp @@ -0,0 +1,45 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +namespace my +{ + BOOST_PARAMETER_KEYWORD(tag, int_val) +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + int i = 42; + accumulator_set<double, stats<tag::value<int, my::tag::int_val> > > acc2( + my::int_val = i); + + int val1 = value<int, my::tag::int_val>(acc2); + int val2 = value_tag<my::tag::int_val>(acc2); + + BOOST_CHECK_EQUAL(i, val1); + BOOST_CHECK_EQUAL(i, val2); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("value_accumulator test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/variance.cpp b/src/boost/libs/accumulators/test/variance.cpp new file mode 100644 index 000000000..8c48713f5 --- /dev/null +++ b/src/boost/libs/accumulators/test/variance.cpp @@ -0,0 +1,107 @@ +// (C) Copyright 2005 Daniel Egloff, Eric Niebler +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/variance.hpp> +#include <sstream> +#include <boost/archive/text_oarchive.hpp> +#include <boost/archive/text_iarchive.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // matlab + // >> samples = [1:5]; + // >> mean(samples) + // ans = 3 + // >> sum(samples .* samples) / length(samples) + // ans = 11 + // >> sum(samples .* samples) / length(samples) - mean(samples)^2 + // ans = 2 + + // lazy variance, now lazy with syntactic sugar, thanks to Eric + accumulator_set<int, stats<tag::variance(lazy)> > acc1; + + acc1(1); + acc1(2); + acc1(3); + acc1(4); + acc1(5); + + BOOST_CHECK_EQUAL(5u, count(acc1)); + BOOST_CHECK_CLOSE(3., mean(acc1), 1e-5); + BOOST_CHECK_CLOSE(11., accumulators::moment<2>(acc1), 1e-5); + BOOST_CHECK_CLOSE(2., variance(acc1), 1e-5); + + // immediate variance + accumulator_set<int, stats<tag::variance> > acc2; + + acc2(1); + acc2(2); + acc2(3); + acc2(4); + acc2(5); + + BOOST_CHECK_EQUAL(5u, count(acc2)); + BOOST_CHECK_CLOSE(3., mean(acc2), 1e-5); + BOOST_CHECK_CLOSE(2., variance(acc2), 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_persistency +// +void test_persistency() +{ + double epsilon = 1e-5; + std::stringstream ss; + { + accumulator_set<int, stats<tag::variance(lazy)> > acc1; + accumulator_set<int, stats<tag::variance> > acc2; + acc1(1); + acc1(2); + acc1(3); + acc1(4); + acc1(5); + acc2(1); + acc2(2); + acc2(3); + acc2(4); + acc2(5); + BOOST_CHECK_CLOSE(2., variance(acc2), epsilon); + BOOST_CHECK_CLOSE(2., variance(acc1), epsilon); + boost::archive::text_oarchive oa(ss); + acc1.serialize(oa, 0); + acc2.serialize(oa, 0); + } + accumulator_set<int, stats<tag::variance(lazy)> > acc1; + accumulator_set<int, stats<tag::variance> > acc2; + boost::archive::text_iarchive ia(ss); + acc1.serialize(ia, 0); + acc2.serialize(ia, 0); + BOOST_CHECK_CLOSE(2., variance(acc2), epsilon); + BOOST_CHECK_CLOSE(2., variance(acc1), epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("variance test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + test->add(BOOST_TEST_CASE(&test_persistency)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/vector.cpp b/src/boost/libs/accumulators/test/vector.cpp new file mode 100644 index 000000000..d0dee2bf7 --- /dev/null +++ b/src/boost/libs/accumulators/test/vector.cpp @@ -0,0 +1,180 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <iostream> +#include <vector> +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_floating_point.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/min.hpp> +#include <boost/accumulators/statistics/max.hpp> +#include <boost/accumulators/statistics/mean.hpp> +#include <boost/accumulators/statistics/weighted_mean.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +typename boost::enable_if<is_floating_point<T> >::type is_equal_or_close(T const &left, T const &right) +{ + BOOST_CHECK_CLOSE(left, right, 1e-5); +} + +template<typename T> +typename boost::disable_if<is_floating_point<T> >::type is_equal_or_close(T const &left, T const &right) +{ + BOOST_CHECK_EQUAL(left, right); +} + +template<typename T> +void is_equal(std::vector<T> const &left, std::vector<T> const &right) +{ + BOOST_CHECK_EQUAL(left.size(), right.size()); + if(left.size() == right.size()) + { + for(std::size_t i = 0; i < left.size(); ++i) + { + is_equal_or_close(left[i], right[i]); + } + } +} + +namespace std +{ + template<typename T> + inline std::ostream &operator <<(std::ostream &sout, std::vector<T> const &arr) + { + sout << '('; + for(std::size_t i = 0; i < arr.size(); ++i) + { + sout << arr[i] << ','; + } + sout << ')' << std::endl; + return sout; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + typedef std::vector<int> sample_t; + + // test sum + { + accumulator_set<sample_t, stats<tag::sum> > acc(sample = sample_t(3,0)); + + acc(sample_t(3,1)); + acc(sample_t(3,2)); + acc(sample_t(3,3)); + + is_equal(sample_t(3,6), sum(acc)); + } + + // test min and max + { + int s1[] = {1,2,3}, s2[] = {0,3,4}, s3[] = {2,1,4}, min_res[] = {0,1,3}, max_res[] = {2,3,4}; + accumulator_set<sample_t, stats<tag::min, tag::max> > acc(sample = sample_t(3,0)); + + acc(sample_t(s1,s1+3)); + acc(sample_t(s2,s2+3)); + acc(sample_t(s3,s3+3)); + + is_equal(sample_t(min_res,min_res+3), (min)(acc)); + is_equal(sample_t(max_res,max_res+3), (max)(acc)); + } + + // test mean(lazy) and mean(immediate) + { + accumulator_set<sample_t, stats<tag::mean> > acc(sample = sample_t(3,0)); + + acc(sample_t(3,1)); + is_equal(std::vector<double>(3, 1.), mean(acc)); + BOOST_CHECK_EQUAL(1u, count(acc)); + is_equal(sample_t(3,1), sum(acc)); + + acc(sample_t(3,0)); + is_equal(std::vector<double>(3, 0.5), mean(acc)); + BOOST_CHECK_EQUAL(2u, count(acc)); + is_equal(sample_t(3,1), sum(acc)); + + acc(sample_t(3,2)); + is_equal(std::vector<double>(3, 1.), mean(acc)); + BOOST_CHECK_EQUAL(3u, count(acc)); + is_equal(sample_t(3,3), sum(acc)); + + + accumulator_set<sample_t, stats<tag::mean(immediate)> > acc2(sample = sample_t(3,0)); + + acc2(sample_t(3,1)); + is_equal(std::vector<double>(3,1.), mean(acc2)); + BOOST_CHECK_EQUAL(1u, count(acc2)); + + acc2(sample_t(3,0)); + is_equal(std::vector<double>(3,0.5), mean(acc2)); + BOOST_CHECK_EQUAL(2u, count(acc2)); + + acc2(sample_t(3,2)); + is_equal(std::vector<double>(3,1.), mean(acc2)); + BOOST_CHECK_EQUAL(3u, count(acc2)); + } + + // test weighted_mean + { + accumulator_set<sample_t, stats<tag::weighted_mean>, int> acc(sample = sample_t(3,0)); + + acc(sample_t(3,10), weight = 2); // 20 + BOOST_CHECK_EQUAL(2, sum_of_weights(acc)); // + // + acc(sample_t(3,6), weight = 3); // 18 + BOOST_CHECK_EQUAL(5, sum_of_weights(acc)); // + // + acc(sample_t(3,4), weight = 4); // 16 + BOOST_CHECK_EQUAL(9, sum_of_weights(acc)); // + // + acc(sample_t(3,6), weight = 5); //+ 30 + BOOST_CHECK_EQUAL(14, sum_of_weights(acc)); // + //= 84 / 14 = 6 + + is_equal(std::vector<double>(3,6.), weighted_mean(acc)); + + + accumulator_set<sample_t, stats<tag::weighted_mean(immediate)>, int> acc2(sample = sample_t(3,0)); + + acc2(sample_t(3,10), weight = 2); // 20 + BOOST_CHECK_EQUAL(2, sum_of_weights(acc2)); // + // + acc2(sample_t(3,6), weight = 3); // 18 + BOOST_CHECK_EQUAL(5, sum_of_weights(acc2)); // + // + acc2(sample_t(3,4), weight = 4); // 16 + BOOST_CHECK_EQUAL(9, sum_of_weights(acc2)); // + // + acc2(sample_t(3,6), weight = 5); //+ 30 + BOOST_CHECK_EQUAL(14, sum_of_weights(acc2));// + //= 84 / 14 = 6 + + is_equal(std::vector<double>(3,6.), weighted_mean(acc2)); + + } +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("vector test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_covariance.cpp b/src/boost/libs/accumulators/test/weighted_covariance.cpp new file mode 100644 index 000000000..be4abf08a --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_covariance.cpp @@ -0,0 +1,101 @@ +// (C) Copyright 2005 Daniel Egloff, Eric Niebler +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_covariance.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + std::vector<double> dummy; + dummy.push_back(0); + dummy.push_back(0); + + accumulator_set<double, stats<tag::weighted_covariance<double, tag::covariate1> >, double > acc; + accumulator_set<std::vector<double>, stats<tag::weighted_covariance<double, tag::covariate1> >, double > acc2(sample = dummy); + accumulator_set<double, stats<tag::weighted_covariance<std::vector<double>, tag::covariate1> >, double > acc3(covariate1 = dummy); + accumulator_set<std::vector<double>, stats<tag::weighted_covariance<std::vector<double>, tag::covariate1> >, double > acc4(sample = dummy, covariate1 = dummy); + + std::vector<double> a; + a.push_back(1.); + a.push_back(2.); + std::vector<double> b; + b.push_back(3.); + b.push_back(4.); + std::vector<double> c; + c.push_back(2.); + c.push_back(5.); + std::vector<double> d; + d.push_back(4.); + d.push_back(2.); + + // double - double + { + acc(1., weight = 1.1, covariate1 = 2.); + acc(1., weight = 2.2, covariate1 = 4.); + acc(2., weight = 3.3, covariate1 = 3.); + acc(6., weight = 4.4, covariate1 = 1.); + } + + // vector - double + { + acc2(a, weight = 1.1, covariate1 = 1.); + acc2(b, weight = 2.2, covariate1 = 1.); + acc2(c, weight = 3.3, covariate1 = 2.); + acc2(d, weight = 4.4, covariate1 = 6.); + } + + // double - vector + { + acc3(1., weight = 1.1, covariate1 = a); + acc3(1., weight = 2.2, covariate1 = b); + acc3(2., weight = 3.3, covariate1 = c); + acc3(6., weight = 4.4, covariate1 = d); + } + + // vector - vector + { + acc4(a, weight = 1.1, covariate1 = b); + acc4(b, weight = 2.2, covariate1 = c); + acc4(a, weight = 3.3, covariate1 = c); + acc4(d, weight = 4.4, covariate1 = b); + } + + double epsilon = 1e-6; + + BOOST_CHECK_CLOSE((weighted_covariance(acc)), -2.39, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc2))[0], 1.93, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc2))[1], -2.09, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc3))[0], 1.93, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc3))[1], -2.09, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc4))(0,0), 0.4, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc4))(0,1), -0.2, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc4))(1,0), -0.4, epsilon); + BOOST_CHECK_CLOSE((weighted_covariance(acc4))(1,1), 0.2, epsilon); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_covariance test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_extended_p_square.cpp b/src/boost/libs/accumulators/test/weighted_extended_p_square.cpp new file mode 100644 index 000000000..e13b0e3b1 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_extended_p_square.cpp @@ -0,0 +1,100 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_extended_p_square.hpp + +#include <iostream> +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_extended_p_square.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + typedef accumulator_set<double, stats<tag::weighted_extended_p_square>, double> accumulator_t; + + // problem with small results: epsilon is relative (in percent), not absolute + + // tolerance in % + double epsilon = 1; + + // some random number generators + double mu1 = -1.0; + double mu2 = 1.0; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma1(mu1, 1); + boost::normal_distribution<> mean_sigma2(mu2, 1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal1(rng, mean_sigma1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal2(rng, mean_sigma2); + + std::vector<double> probs_uniform, probs_normal1, probs_normal2, probs_normal_exact1, probs_normal_exact2; + + double p1[] = {/*0.001,*/ 0.01, 0.1, 0.5, 0.9, 0.99, 0.999}; + probs_uniform.assign(p1, p1 + sizeof(p1) / sizeof(double)); + + double p2[] = {0.001, 0.025}; + double p3[] = {0.975, 0.999}; + probs_normal1.assign(p2, p2 + sizeof(p2) / sizeof(double)); + probs_normal2.assign(p3, p3 + sizeof(p3) / sizeof(double)); + + double p4[] = {-3.090232, -1.959963}; + double p5[] = {1.959963, 3.090232}; + probs_normal_exact1.assign(p4, p4 + sizeof(p4) / sizeof(double)); + probs_normal_exact2.assign(p5, p5 + sizeof(p5) / sizeof(double)); + + accumulator_t acc_uniform(extended_p_square_probabilities = probs_uniform); + accumulator_t acc_normal1(extended_p_square_probabilities = probs_normal1); + accumulator_t acc_normal2(extended_p_square_probabilities = probs_normal2); + + for (std::size_t i = 0; i < 100000; ++i) + { + acc_uniform(rng(), weight = 1.); + + double sample1 = normal1(); + double sample2 = normal2(); + acc_normal1(sample1, weight = std::exp(-mu1 * (sample1 - 0.5 * mu1))); + acc_normal2(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2))); + } + + // check for uniform distribution + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[0], probs_uniform[0], 6*epsilon); + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[1], probs_uniform[1], 3*epsilon); + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[2], probs_uniform[2], epsilon); + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[3], probs_uniform[3], epsilon); + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[4], probs_uniform[4], epsilon); + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[5], probs_uniform[5], epsilon); + + // check for standard normal distribution + for (std::size_t i = 0; i < probs_normal1.size(); ++i) + { + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_normal1)[i], probs_normal_exact1[i], epsilon); + BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_normal2)[i], probs_normal_exact2[i], epsilon); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_extended_p_square test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_kurtosis.cpp b/src/boost/libs/accumulators/test/weighted_kurtosis.cpp new file mode 100644 index 000000000..3cedd5a25 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_kurtosis.cpp @@ -0,0 +1,70 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_kurtosis.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_kurtosis.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + // double epsilon = 1; + + accumulator_set<double, stats<tag::weighted_kurtosis>, double > acc1; + accumulator_set<int, stats<tag::weighted_kurtosis>, int > acc2; + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i=0; i<100000; ++i) + { + acc1(normal(), weight = rng()); + } + + // This check fails because epsilon is relative and not absolute + // BOOST_CHECK_CLOSE( weighted_kurtosis(acc1), 0., epsilon ); + + acc2(2, weight = 4); + acc2(7, weight = 1); + acc2(4, weight = 3); + acc2(9, weight = 1); + acc2(3, weight = 2); + + BOOST_CHECK_EQUAL( weighted_mean(acc2), 42./11. ); + BOOST_CHECK_EQUAL( accumulators::weighted_moment<2>(acc2), 212./11. ); + BOOST_CHECK_EQUAL( accumulators::weighted_moment<3>(acc2), 1350./11. ); + BOOST_CHECK_EQUAL( accumulators::weighted_moment<4>(acc2), 9956./11. ); + BOOST_CHECK_CLOSE( weighted_kurtosis(acc2), 0.58137026432, 1e-6 ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_kurtosis test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_mean.cpp b/src/boost/libs/accumulators/test/weighted_mean.cpp new file mode 100644 index 000000000..ae71e8dfa --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_mean.cpp @@ -0,0 +1,102 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_mean.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +template<typename T> +void assert_is_double(T const &) +{ + BOOST_MPL_ASSERT((is_same<T, double>)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set< + int + , stats< + tag::weighted_mean + , tag::mean_of_weights + , tag::weighted_mean_of_variates<int, tag::covariate1> + > + , int + > acc, test_acc(sample = 0); + + acc(1, weight = 2, covariate1 = 3); + BOOST_CHECK_CLOSE(1., weighted_mean(acc), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc)); + BOOST_CHECK_EQUAL(2, sum(acc)); + BOOST_CHECK_CLOSE(2., mean_of_weights(acc), 1e-5); + BOOST_CHECK_CLOSE(3., (accumulators::weighted_mean_of_variates<int, tag::covariate1>(acc)), 1e-5); + + acc(0, weight = 4, covariate1 = 4); + BOOST_CHECK_CLOSE(1./3., weighted_mean(acc), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc)); + BOOST_CHECK_EQUAL(2, sum(acc)); + BOOST_CHECK_CLOSE(3., mean_of_weights(acc), 1e-5); + BOOST_CHECK_CLOSE(11./3., (accumulators::weighted_mean_of_variates<int, tag::covariate1>(acc)), 1e-5); + + acc(2, weight = 9, covariate1 = 8); + BOOST_CHECK_CLOSE(4./3., weighted_mean(acc), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc)); + BOOST_CHECK_EQUAL(20, sum(acc)); + BOOST_CHECK_CLOSE(5., mean_of_weights(acc), 1e-5); + BOOST_CHECK_CLOSE(94./15., (accumulators::weighted_mean_of_variates<int, tag::covariate1>(acc)), 1e-5); + + assert_is_double(mean(acc)); + + accumulator_set< + int + , stats< + tag::weighted_mean(immediate) + , tag::mean_of_weights(immediate) + , tag::weighted_mean_of_variates<int, tag::covariate1>(immediate) + > + , int + > acc2, test_acc2(sample = 0); + + acc2(1, weight = 2, covariate1 = 3); + BOOST_CHECK_CLOSE(1., weighted_mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(1u, count(acc2)); + BOOST_CHECK_CLOSE(2., mean_of_weights(acc2), 1e-5); + BOOST_CHECK_CLOSE(3., (accumulators::weighted_mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + + acc2(0, weight = 4, covariate1 = 4); + BOOST_CHECK_CLOSE(1./3., weighted_mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(2u, count(acc2)); + BOOST_CHECK_CLOSE(3., mean_of_weights(acc2), 1e-5); + BOOST_CHECK_CLOSE(11./3., (accumulators::weighted_mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + + acc2(2, weight = 9, covariate1 = 8); + BOOST_CHECK_CLOSE(4./3., weighted_mean(acc2), 1e-5); + BOOST_CHECK_EQUAL(3u, count(acc2)); + BOOST_CHECK_CLOSE(5., mean_of_weights(acc2), 1e-5); + BOOST_CHECK_CLOSE(94./15., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5); + + assert_is_double(mean(acc2)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_mean test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_median.cpp b/src/boost/libs/accumulators/test/weighted_median.cpp new file mode 100644 index 000000000..60321d1c0 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_median.cpp @@ -0,0 +1,69 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/random.hpp> +#include <boost/range/iterator_range.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_median.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // Median estimation of normal distribution N(1,1) using samples from a narrow normal distribution N(1,0.01) + // The weights equal to the likelihood ratio of the corresponding samples + + // two random number generators + double mu = 1.; + double sigma_narrow = 0.01; + double sigma = 1.; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma_narrow(mu,sigma_narrow); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal_narrow(rng, mean_sigma_narrow); + + accumulator_set<double, stats<tag::weighted_median(with_p_square_quantile) >, double > acc; + accumulator_set<double, stats<tag::weighted_median(with_density) >, double > + acc_dens( density_cache_size = 10000, density_num_bins = 1000 ); + accumulator_set<double, stats<tag::weighted_median(with_p_square_cumulative_distribution) >, double > + acc_cdist( p_square_cumulative_distribution_num_cells = 100 ); + + + for (std::size_t i=0; i<1000000; ++i) + { + double sample = normal_narrow(); + double w = std::exp( + 0.5 * (sample - mu) * (sample - mu) * ( + 1./sigma_narrow/sigma_narrow - 1./sigma/sigma + ) + ); + acc(sample, weight = w); + acc_dens(sample, weight = w); + acc_cdist(sample, weight = w); + } + + BOOST_CHECK_CLOSE(1., weighted_median(acc), 2); + BOOST_CHECK_CLOSE(1., weighted_median(acc_dens), 3); + BOOST_CHECK_CLOSE(1., weighted_median(acc_cdist), 3); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_median test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_moment.cpp b/src/boost/libs/accumulators/test/weighted_moment.cpp new file mode 100644 index 000000000..4aec80d3e --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_moment.cpp @@ -0,0 +1,47 @@ +// (C) Copyright Eric Niebler, Olivier Gygi 2006. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_moment.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<double, stats<tag::weighted_moment<2> >, double> acc2; + accumulator_set<double, stats<tag::weighted_moment<7> >, double> acc7; + + acc2(2.1, weight = 0.7); + acc2(2.7, weight = 1.4); + acc2(1.8, weight = 0.9); + + acc7(2.1, weight = 0.7); + acc7(2.7, weight = 1.4); + acc7(1.8, weight = 0.9); + + BOOST_CHECK_CLOSE(5.403, accumulators::weighted_moment<2>(acc2), 1e-5); + BOOST_CHECK_CLOSE(548.54182, accumulators::weighted_moment<7>(acc7), 1e-5); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_moment test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_p_square_cumul_dist.cpp b/src/boost/libs/accumulators/test/weighted_p_square_cumul_dist.cpp new file mode 100644 index 000000000..3fb5b57f3 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_p_square_cumul_dist.cpp @@ -0,0 +1,103 @@ +// (C) Copyright Eric Niebler, Olivier Gygi 2006. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_p_square_cumul_dist.hpp + +#include <cmath> +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// erf() not known by VC++ compiler! +// my_erf() computes error function by numerically integrating with trapezoidal rule +// +double my_erf(double const& x, int const& n = 1000) +{ + double sum = 0.; + double delta = x/n; + for (int i = 1; i < n; ++i) + sum += std::exp(-i*i*delta*delta) * delta; + sum += 0.5 * delta * (1. + std::exp(-x*x)); + return sum * 2. / std::sqrt(3.141592653); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 4; + + typedef accumulator_set<double, stats<tag::weighted_p_square_cumulative_distribution>, double > accumulator_t; + + accumulator_t acc_upper(p_square_cumulative_distribution_num_cells = 100); + accumulator_t acc_lower(p_square_cumulative_distribution_num_cells = 100); + + // two random number generators + double mu_upper = 1.0; + double mu_lower = -1.0; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma_upper(mu_upper,1); + boost::normal_distribution<> mean_sigma_lower(mu_lower,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal_upper(rng, mean_sigma_upper); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal_lower(rng, mean_sigma_lower); + + for (std::size_t i=0; i<100000; ++i) + { + double sample = normal_upper(); + acc_upper(sample, weight = std::exp(-mu_upper * (sample - 0.5 * mu_upper))); + } + + for (std::size_t i=0; i<100000; ++i) + { + double sample = normal_lower(); + acc_lower(sample, weight = std::exp(-mu_lower * (sample - 0.5 * mu_lower))); + } + + typedef iterator_range<std::vector<std::pair<double, double> >::iterator > histogram_type; + histogram_type histogram_upper = weighted_p_square_cumulative_distribution(acc_upper); + histogram_type histogram_lower = weighted_p_square_cumulative_distribution(acc_lower); + + // Note that applying importance sampling results in a region of the distribution + // to be estimated more accurately and another region to be estimated less accurately + // than without importance sampling, i.e., with unweighted samples + + for (std::size_t i = 0; i < histogram_upper.size(); ++i) + { + // problem with small results: epsilon is relative (in percent), not absolute! + + // check upper region of distribution + if ( histogram_upper[i].second > 0.1 ) + BOOST_CHECK_CLOSE( 0.5 * (1.0 + my_erf( histogram_upper[i].first / std::sqrt(2.0) )), histogram_upper[i].second, epsilon ); + // check lower region of distribution + if ( histogram_lower[i].second < -0.1 ) + BOOST_CHECK_CLOSE( 0.5 * (1.0 + my_erf( histogram_lower[i].first / std::sqrt(2.0) )), histogram_lower[i].second, epsilon ); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_p_square_cumulative_distribution test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_p_square_quantile.cpp b/src/boost/libs/accumulators/test/weighted_p_square_quantile.cpp new file mode 100644 index 000000000..cf4fdeae1 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_p_square_quantile.cpp @@ -0,0 +1,100 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_p_square_quantile.hpp + +#include <cmath> // for std::exp() +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_p_square_quantile.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + typedef accumulator_set<double, stats<tag::weighted_p_square_quantile>, double> accumulator_t; + + // tolerance in % + double epsilon = 1; + + // some random number generators + double mu4 = -1.0; + double mu5 = -1.0; + double mu6 = 1.0; + double mu7 = 1.0; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma4(mu4, 1); + boost::normal_distribution<> mean_sigma5(mu5, 1); + boost::normal_distribution<> mean_sigma6(mu6, 1); + boost::normal_distribution<> mean_sigma7(mu7, 1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal4(rng, mean_sigma4); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal5(rng, mean_sigma5); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal6(rng, mean_sigma6); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal7(rng, mean_sigma7); + + accumulator_t acc0(quantile_probability = 0.001); + accumulator_t acc1(quantile_probability = 0.025); + accumulator_t acc2(quantile_probability = 0.975); + accumulator_t acc3(quantile_probability = 0.999); + + accumulator_t acc4(quantile_probability = 0.001); + accumulator_t acc5(quantile_probability = 0.025); + accumulator_t acc6(quantile_probability = 0.975); + accumulator_t acc7(quantile_probability = 0.999); + + + for (std::size_t i=0; i<100000; ++i) + { + double sample = rng(); + acc0(sample, weight = 1.); + acc1(sample, weight = 1.); + acc2(sample, weight = 1.); + acc3(sample, weight = 1.); + + double sample4 = normal4(); + double sample5 = normal5(); + double sample6 = normal6(); + double sample7 = normal7(); + acc4(sample4, weight = std::exp(-mu4 * (sample4 - 0.5 * mu4))); + acc5(sample5, weight = std::exp(-mu5 * (sample5 - 0.5 * mu5))); + acc6(sample6, weight = std::exp(-mu6 * (sample6 - 0.5 * mu6))); + acc7(sample7, weight = std::exp(-mu7 * (sample7 - 0.5 * mu7))); + } + // check for uniform distribution with weight = 1 + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc0), 0.001, 28 ); + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc1), 0.025, 5 ); + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc2), 0.975, epsilon ); + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc3), 0.999, epsilon ); + + // check for shifted standard normal distribution ("importance sampling") + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc4), -3.090232, epsilon ); + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc5), -1.959963, epsilon ); + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc6), 1.959963, epsilon ); + BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc7), 3.090232, epsilon ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_p_square_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_pot_quantile.cpp b/src/boost/libs/accumulators/test/weighted_pot_quantile.cpp new file mode 100644 index 000000000..28d424ac0 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_pot_quantile.cpp @@ -0,0 +1,104 @@ +// (C) Copyright Eric Niebler 2005. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for pot_quantile.hpp (weighted feature) + +#define BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1.; + + double mu1, mu2, l; + + mu1 = 1.; + mu2 = -1.; + l = 0.5; + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma1(mu1,1); + boost::normal_distribution<> mean_sigma2(mu2,1); + boost::exponential_distribution<> lambda(l); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal1(rng, mean_sigma1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal2(rng, mean_sigma2); + boost::variate_generator<boost::lagged_fibonacci607&, boost::exponential_distribution<> > exponential(rng, lambda); + + accumulator_set<double, stats<tag::weighted_pot_quantile<right>(with_threshold_value)>, double > acc1( + pot_threshold_value = 3. + ); + accumulator_set<double, stats<tag::weighted_pot_quantile<right>(with_threshold_probability)>, double > acc2( + right_tail_cache_size = 10000 + , pot_threshold_probability = 0.99 + ); + accumulator_set<double, stats<tag::weighted_pot_quantile<left>(with_threshold_value)>, double > acc3( + pot_threshold_value = -3. + ); + accumulator_set<double, stats<tag::weighted_pot_quantile<left>(with_threshold_probability)>, double > acc4( + left_tail_cache_size = 10000 + , pot_threshold_probability = 0.01 + ); + + accumulator_set<double, stats<tag::weighted_pot_quantile<right>(with_threshold_value)>, double > acc5( + pot_threshold_value = 5. + ); + accumulator_set<double, stats<tag::weighted_pot_quantile<right>(with_threshold_probability)>, double > acc6( + right_tail_cache_size = 10000 + , pot_threshold_probability = 0.995 + ); + + for (std::size_t i = 0; i < 100000; ++i) + { + double sample1 = normal1(); + double sample2 = normal2(); + acc1(sample1, weight = std::exp(-mu1 * (sample1 - 0.5 * mu1))); + acc2(sample1, weight = std::exp(-mu1 * (sample1 - 0.5 * mu1))); + acc3(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2))); + acc4(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2))); + } + + for (std::size_t i = 0; i < 100000; ++i) + { + double sample = exponential(); + acc5(sample, weight = 1./l * std::exp(-sample * (1. - l))); + acc6(sample, weight = 1./l * std::exp(-sample * (1. - l))); + } + + BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.999), 3.090232, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.001), -3.090232, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = 0.001), -3.090232, epsilon ); + + BOOST_CHECK_CLOSE( quantile(acc5, quantile_probability = 0.999), 6.908, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc6, quantile_probability = 0.999), 6.908, epsilon ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_pot_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_skewness.cpp b/src/boost/libs/accumulators/test/weighted_skewness.cpp new file mode 100644 index 000000000..b5ca1aab7 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_skewness.cpp @@ -0,0 +1,69 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_skewness.hpp + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/numeric/functional/vector.hpp> +#include <boost/accumulators/numeric/functional/complex.hpp> +#include <boost/accumulators/numeric/functional/valarray.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_skewness.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + // double epsilon = 1; + + accumulator_set<double, stats<tag::weighted_skewness>, double > acc1; + accumulator_set<int, stats<tag::weighted_skewness>, int > acc2; + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + for (std::size_t i=0; i<100000; ++i) + { + acc1(normal(), weight = rng()); + } + + // This check fails because epsilon is relative and not absolute + // BOOST_CHECK_CLOSE( weighted_skewness(acc1), 0., epsilon ); + + acc2(2, weight = 4); + acc2(7, weight = 1); + acc2(4, weight = 3); + acc2(9, weight = 1); + acc2(3, weight = 2); + + BOOST_CHECK_EQUAL( weighted_mean(acc2), 42./11. ); + BOOST_CHECK_EQUAL( accumulators::weighted_moment<2>(acc2), 212./11. ); + BOOST_CHECK_EQUAL( accumulators::weighted_moment<3>(acc2), 1350./11. ); + BOOST_CHECK_CLOSE( weighted_skewness(acc2), 1.30708406282, 1e-6 ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_skewness test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_sum.cpp b/src/boost/libs/accumulators/test/weighted_sum.cpp new file mode 100644 index 000000000..f0f79c817 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_sum.cpp @@ -0,0 +1,46 @@ +// (C) Copyright Eric Niebler, Olivier Gygi 2006. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_sum.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + accumulator_set<int, stats<tag::weighted_sum, tag::weighted_sum_of_variates<int, tag::covariate1> >, int> acc; + + acc(1, weight = 2, covariate1 = 3); + BOOST_CHECK_EQUAL(2, weighted_sum(acc)); + BOOST_CHECK_EQUAL(6, weighted_sum_of_variates(acc)); + + acc(2, weight = 3, covariate1 = 6); + BOOST_CHECK_EQUAL(8, weighted_sum(acc)); + BOOST_CHECK_EQUAL(24, weighted_sum_of_variates(acc)); + + acc(4, weight = 6, covariate1 = 9); + BOOST_CHECK_EQUAL(32, weighted_sum(acc)); + BOOST_CHECK_EQUAL(78, weighted_sum_of_variates(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_sum test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_sum_kahan.cpp b/src/boost/libs/accumulators/test/weighted_sum_kahan.cpp new file mode 100644 index 000000000..68cf87b87 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_sum_kahan.cpp @@ -0,0 +1,64 @@ +// (C) Copyright Simon West 2011. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_sum_kahan.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_weighted_sum_kahan +// +void test_weighted_sum_kahan() +{ + accumulator_set<float, stats<tag::weighted_sum_kahan>, float > acc; + + BOOST_CHECK_EQUAL(0.0f, weighted_sum_kahan(acc)); + + for (size_t i = 0; i < 1e6; ++i) { + acc(1, weight = 1e-6f); + } + + BOOST_CHECK_EQUAL(1.0f, weighted_sum_kahan(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// test_weighted_sum_of_variates_kahan +// +void test_weighted_sum_of_variates_kahan() +{ + accumulator_set< + float, + stats<tag::weighted_sum_of_variates_kahan<float, tag::covariate1> >, + float + > + acc; + + BOOST_CHECK_EQUAL(0.0f, weighted_sum_of_variates_kahan(acc)); + + for (size_t i = 0; i < 1e6; ++i) { + acc(0, weight = 1.0f, covariate1 = 1e-6f); + } + + BOOST_CHECK_EQUAL(1.0f, weighted_sum_of_variates_kahan(acc)); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted sum kahan tests"); + + test->add(BOOST_TEST_CASE(&test_weighted_sum_kahan)); + test->add(BOOST_TEST_CASE(&test_weighted_sum_of_variates_kahan)); + + return test; +} diff --git a/src/boost/libs/accumulators/test/weighted_tail_mean.cpp b/src/boost/libs/accumulators/test/weighted_tail_mean.cpp new file mode 100644 index 000000000..d7a6aa3e3 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_tail_mean.cpp @@ -0,0 +1,77 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_tail_mean.hpp + +#define BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics.hpp> +#include <boost/accumulators/statistics/weighted_tail_mean.hpp> +#include <boost/accumulators/statistics/weighted_tail_quantile.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1; + + std::size_t n = 100000; // number of MC steps + std::size_t c = 25000; // cache size + + accumulator_set<double, stats<tag::non_coherent_weighted_tail_mean<right> >, double > + acc0( right_tail_cache_size = c ); + accumulator_set<double, stats<tag::non_coherent_weighted_tail_mean<left> >, double > + acc1( left_tail_cache_size = c ); + + // random number generators + boost::lagged_fibonacci607 rng; + + for (std::size_t i = 0; i < n; ++i) + { + double smpl = std::sqrt(rng()); + acc0(smpl, weight = 1./smpl); + } + + for (std::size_t i = 0; i < n; ++i) + { + double smpl = rng(); + acc1(smpl*smpl, weight = smpl); + } + + // check uniform distribution + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc0, quantile_probability = 0.95), 0.975, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc0, quantile_probability = 0.975), 0.9875, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc0, quantile_probability = 0.99), 0.995, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc0, quantile_probability = 0.999), 0.9995, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc1, quantile_probability = 0.05), 0.025, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc1, quantile_probability = 0.025), 0.0125, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc1, quantile_probability = 0.01), 0.005, epsilon ); + BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc1, quantile_probability = 0.001), 0.0005, 5*epsilon ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_tail_mean test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_tail_quantile.cpp b/src/boost/libs/accumulators/test/weighted_tail_quantile.cpp new file mode 100644 index 000000000..339366617 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_tail_quantile.cpp @@ -0,0 +1,75 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_tail_quantile.hpp + +#define BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics.hpp> +#include <boost/accumulators/statistics/weighted_tail_quantile.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // tolerance in % + double epsilon = 1; + + std::size_t n = 100000; // number of MC steps + std::size_t c = 20000; // cache size + + double mu1 = 1.0; + double mu2 = -1.0; + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma1(mu1,1); + boost::normal_distribution<> mean_sigma2(mu2,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal1(rng, mean_sigma1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal2(rng, mean_sigma2); + + accumulator_set<double, stats<tag::weighted_tail_quantile<right> >, double> + acc1(right_tail_cache_size = c); + + accumulator_set<double, stats<tag::weighted_tail_quantile<left> >, double> + acc2(left_tail_cache_size = c); + + for (std::size_t i = 0; i < n; ++i) + { + double sample1 = normal1(); + double sample2 = normal2(); + acc1(sample1, weight = std::exp(-mu1 * (sample1 - 0.5 * mu1))); + acc2(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2))); + } + + // check standard normal distribution + BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.975), 1.959963, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.025), -1.959963, epsilon ); + BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.001), -3.090232, epsilon ); + +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_tail_quantile test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_tail_variate_means.cpp b/src/boost/libs/accumulators/test/weighted_tail_variate_means.cpp new file mode 100644 index 000000000..e2248a25a --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_tail_variate_means.cpp @@ -0,0 +1,131 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// Test case for weighted_tail_variate_means.hpp + +#define BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT +#define BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT + +#include <boost/random.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/variates/covariate.hpp> +#include <boost/accumulators/statistics.hpp> +#include <boost/accumulators/statistics/weighted_tail_variate_means.hpp> + +using namespace boost; +using namespace unit_test; +using namespace boost::accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + std::size_t c = 5; // cache size + + typedef double variate_type; + typedef std::vector<variate_type> variate_set_type; + + accumulator_set<double, stats<tag::weighted_tail_variate_means<right, variate_set_type, tag::covariate1>(relative)>, double > + acc1( right_tail_cache_size = c ); + accumulator_set<double, stats<tag::weighted_tail_variate_means<right, variate_set_type, tag::covariate1>(absolute)>, double > + acc2( right_tail_cache_size = c ); + accumulator_set<double, stats<tag::weighted_tail_variate_means<left, variate_set_type, tag::covariate1>(relative)>, double > + acc3( left_tail_cache_size = c ); + accumulator_set<double, stats<tag::weighted_tail_variate_means<left, variate_set_type, tag::covariate1>(absolute)>, double > + acc4( left_tail_cache_size = c ); + + variate_set_type cov1, cov2, cov3, cov4, cov5; + double c1[] = { 10., 20., 30., 40. }; // 100 + double c2[] = { 26., 4., 17., 3. }; // 50 + double c3[] = { 46., 64., 40., 50. }; // 200 + double c4[] = { 1., 3., 70., 6. }; // 80 + double c5[] = { 2., 2., 2., 14. }; // 20 + cov1.assign(c1, c1 + sizeof(c1)/sizeof(variate_type)); + cov2.assign(c2, c2 + sizeof(c2)/sizeof(variate_type)); + cov3.assign(c3, c3 + sizeof(c3)/sizeof(variate_type)); + cov4.assign(c4, c4 + sizeof(c4)/sizeof(variate_type)); + cov5.assign(c5, c5 + sizeof(c5)/sizeof(variate_type)); + + acc1(100., weight = 0.8, covariate1 = cov1); + acc1( 50., weight = 0.9, covariate1 = cov2); + acc1(200., weight = 1.0, covariate1 = cov3); + acc1( 80., weight = 1.1, covariate1 = cov4); + acc1( 20., weight = 1.2, covariate1 = cov5); + + acc2(100., weight = 0.8, covariate1 = cov1); + acc2( 50., weight = 0.9, covariate1 = cov2); + acc2(200., weight = 1.0, covariate1 = cov3); + acc2( 80., weight = 1.1, covariate1 = cov4); + acc2( 20., weight = 1.2, covariate1 = cov5); + + acc3(100., weight = 0.8, covariate1 = cov1); + acc3( 50., weight = 0.9, covariate1 = cov2); + acc3(200., weight = 1.0, covariate1 = cov3); + acc3( 80., weight = 1.1, covariate1 = cov4); + acc3( 20., weight = 1.2, covariate1 = cov5); + + acc4(100., weight = 0.8, covariate1 = cov1); + acc4( 50., weight = 0.9, covariate1 = cov2); + acc4(200., weight = 1.0, covariate1 = cov3); + acc4( 80., weight = 1.1, covariate1 = cov4); + acc4( 20., weight = 1.2, covariate1 = cov5); + + // check relative risk contributions + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.7).begin() ), (0.8*10 + 1.0*46)/(0.8*100 + 1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 1), (0.8*20 + 1.0*64)/(0.8*100 + 1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 2), (0.8*30 + 1.0*40)/(0.8*100 + 1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 3), (0.8*40 + 1.0*50)/(0.8*100 + 1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() ), (0.9*26 + 1.2*2)/(0.9*50 + 1.2*20) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 1), (0.9*4 + 1.2*2)/(0.9*50 + 1.2*20) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 2), (0.9*17 + 1.2*2)/(0.9*50 + 1.2*20) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 3), (0.9*3 + 1.2*14)/(0.9*50 + 1.2*20) ); + + // check absolute risk contributions + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.7).begin() ), (0.8*10 + 1.0*46)/1.8 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.7).begin() + 1), (0.8*20 + 1.0*64)/1.8 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.7).begin() + 2), (0.8*30 + 1.0*40)/1.8 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.7).begin() + 3), (0.8*40 + 1.0*50)/1.8 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() ), (0.9*26 + 1.2*2)/2.1 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() + 1), (0.9*4 + 1.2*2)/2.1 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() + 2), (0.9*17 + 1.2*2)/2.1 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() + 3), (0.9*3 + 1.2*14)/2.1 ); + + // check relative risk contributions + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.9).begin() ), 1.0*46/(1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 1), 1.0*64/(1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 2), 1.0*40/(1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 3), 1.0*50/(1.0*200) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() ), 1.2*2/(1.2*20) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 1), 1.2*2/(1.2*20) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 2), 1.2*2/(1.2*20) ); + BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 3), 1.2*14/(1.2*20) ); + + // check absolute risk contributions + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.9).begin() ), 1.0*46/1.0 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.9).begin() + 1), 1.0*64/1.0 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.9).begin() + 2), 1.0*40/1.0 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.9).begin() + 3), 1.0*50/1.0 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.1).begin() ), 1.2*2/1.2 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.1).begin() + 1), 1.2*2/1.2 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.1).begin() + 2), 1.2*2/1.2 ); + BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.1).begin() + 3), 1.2*14/1.2 ); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_tail_variate_means test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} + diff --git a/src/boost/libs/accumulators/test/weighted_variance.cpp b/src/boost/libs/accumulators/test/weighted_variance.cpp new file mode 100644 index 000000000..f4b81d479 --- /dev/null +++ b/src/boost/libs/accumulators/test/weighted_variance.cpp @@ -0,0 +1,81 @@ +// (C) Copyright 2006 Eric Niebler, Olivier Gygi +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#include <boost/test/unit_test.hpp> +#include <boost/test/floating_point_comparison.hpp> +#include <boost/random.hpp> +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/weighted_variance.hpp> + +using namespace boost; +using namespace unit_test; +using namespace accumulators; + +/////////////////////////////////////////////////////////////////////////////// +// test_stat +// +void test_stat() +{ + // lazy weighted_variance + accumulator_set<int, stats<tag::weighted_variance(lazy)>, int> acc1; + + acc1(1, weight = 2); // 2 + acc1(2, weight = 3); // 6 + acc1(3, weight = 1); // 3 + acc1(4, weight = 4); // 16 + acc1(5, weight = 1); // 5 + + // weighted_mean = (2+6+3+16+5) / (2+3+1+4+1) = 32 / 11 = 2.9090909090909090909090909090909 + + BOOST_CHECK_EQUAL(5u, count(acc1)); + BOOST_CHECK_CLOSE(2.9090909, weighted_mean(acc1), 1e-5); + BOOST_CHECK_CLOSE(10.1818182, accumulators::weighted_moment<2>(acc1), 1e-5); + BOOST_CHECK_CLOSE(1.7190083, weighted_variance(acc1), 1e-5); + + accumulator_set<int, stats<tag::weighted_variance>, int> acc2; + + acc2(1, weight = 2); + acc2(2, weight = 3); + acc2(3, weight = 1); + acc2(4, weight = 4); + acc2(5, weight = 1); + + BOOST_CHECK_EQUAL(5u, count(acc2)); + BOOST_CHECK_CLOSE(2.9090909, weighted_mean(acc2), 1e-5); + BOOST_CHECK_CLOSE(1.7190083, weighted_variance(acc2), 1e-5); + + // check lazy and immediate variance with random numbers + + // two random number generators + boost::lagged_fibonacci607 rng; + boost::normal_distribution<> mean_sigma(0,1); + boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma); + + accumulator_set<double, stats<tag::weighted_variance(lazy)>, double > acc_lazy; + accumulator_set<double, stats<tag::weighted_variance>, double > acc_immediate; + + for (std::size_t i=0; i<10000; ++i) + { + double value = normal(); + acc_lazy(value, weight = rng()); + acc_immediate(value, weight = rng()); + } + + BOOST_CHECK_CLOSE(1., weighted_variance(acc_lazy), 5.); + BOOST_CHECK_CLOSE(1., weighted_variance(acc_immediate), 5.); +} + +/////////////////////////////////////////////////////////////////////////////// +// init_unit_test_suite +// +test_suite* init_unit_test_suite( int argc, char* argv[] ) +{ + test_suite *test = BOOST_TEST_SUITE("weighted_variance test"); + + test->add(BOOST_TEST_CASE(&test_stat)); + + return test; +} |