boost/math
2
0
Fork 0
mirror of https://github.com/boostorg/math.git synced 2026-02-22 03:22:28 +00:00
Code Issues Projects Releases Wiki Activity

Standalone tests (#606)

Browse Source 
* Add missing distribution compile tests

* Add cstdfloat compile tests

* Rename and finish differentiation

* Add interpolators compile tests and fixes

* Reorganize/add quadrature compile tests

* Add missing sf tests and fixes for failures

* Add tools incl tests and fixes

* Add compile tests to jamfile plus collected fixes

* Collected fixes for CI failures

* Fix fftw config

* Remove lexical cast from arcsine dist [ci skip]

* Improve cstdfloat tests [ci skip]

* Improve differentiation tests [ci skip]

* Improve distribution testing [ci skip]

* Updates to interpolator tests [ci skip]

* Improve quadrature tests [ci skip]

* Improve sf tests [ci skip]

* Improve tools tests

* Collected CI fixes

* Fix for MSVC 14.2 array allocation error
[windows]

* MSVC 14.2 workarounds
[windows]

* Fix float128 and interpolators tests

* Add standalone testing on clang
[standalone]

* Fixes for type mismatches on MSVC
[windows]

* Fix for MSVC 14.0 fail from missing header
[windows]

* Change barycentric rational namespace
[ci skip]

* Fix standalone clang warnings

* Change namespace in barycentric examples
This commit is contained in:
Matt Borland
2021-04-22 21:44:21 +03:00
committed by GitHub
parent f8690b2251
commit 12b3c8a7e7
117 changed files with 1669 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
test/Jamfile.v2
View File

@@ -834,6 +834,9 @@ test-suite distribution_tests :
[ run compile_test/dist_uniform_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/dist_weibull_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/distribution_concept_check.cpp : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/dist_arcsine_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/dist_empirical_cumulative_dist_func_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/dist_inv_gaussian_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run test_legacy_nonfinite.cpp ../../test/build//boost_unit_test_framework ]
[ run test_basic_nonfinite.cpp ../../test/build//boost_unit_test_framework ]
@@ -977,8 +980,15 @@ test-suite misc :
[ run test_root_iterations.cpp pch ../../test/build//boost_unit_test_framework : : : [ requires cxx11_hdr_tuple ] ]
[ run test_root_finding_concepts.cpp ../../test/build//boost_unit_test_framework ]
[ run test_toms748_solve.cpp pch ../../test/build//boost_unit_test_framework ]
[ run compile_test/cubic_spline_incl_test.cpp compile_test_main : : : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/barycentric_rational_incl_test.cpp compile_test_main : : : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/interpolators_cubic_spline_incl_test.cpp compile_test_main : : : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/interpolators_barycentric_rational_incl_test.cpp compile_test_main : : : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_cubic_hermite_incl_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_makima_incl_test.cpp compile_test_main : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_pchip_incl_test.cpp compile_test_main : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_quintic_hermite_incl_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_septic_hermite_incl_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_vector_barycentric_rational_incl_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_whittaker_shannon_incl_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_auto_declarations ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/compl_abs_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/compl_acos_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/compl_acosh_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
@@ -1039,6 +1049,12 @@ test-suite misc :
[ run compile_test/sf_trunc_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sf_ulp_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sf_zeta_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/sf_chebyshev_incl_test.cpp ../config//fftw3 : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/sf_chebyshev_transform_incl_test.cpp ../config//fftw3 : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] [ check-target-builds ../config//has_fftw3 "libfftw3" : : <build>no ] ]
[ run compile_test/sf_fibonacci_incl_test.cpp compile_test_main : : : [ requires cxx17_std_apply cxx17_if_constexpr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sf_gegenbauer_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sf_lambert_w_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/sf_nonfinite_num_facets_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/std_real_concept_check.cpp : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/std_real_concept_check.cpp : <define>EMULATE32 [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] : std_real_concept_check_32 ]
[ compile compile_test/std_real_concept_check.cpp : <define>EMULATE64 [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] : std_real_concept_check_64 ]
@@ -1050,6 +1066,11 @@ test-suite misc :
[ run compile_test/cstdfloat_concept_check_2.cpp : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/cstdfloat_concept_check_3.cpp : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/cstdfloat_concept_check_4.cpp : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/cstdfloat_cmath_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/cstdfloat_complex_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/cstdfloat_iostream_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/cstdfloat_limits_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/cstdfloat_types_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run test_cstdfloat.cpp ../../test/build//boost_unit_test_framework : : : [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sf_airy_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sf_hankel_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
@@ -1057,7 +1078,7 @@ test-suite misc :
[ run compile_test/sf_owens_t_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/dist_skew_norm_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/constants_incl_test.cpp compile_test_main : : : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/trapezoidal_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_decltype cxx11_unified_initialization_syntax cxx11_variadic_templates ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/quad_trapezoidal_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_decltype cxx11_unified_initialization_syntax cxx11_variadic_templates ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/test_traits.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_config_inc_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_fraction_inc_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
@@ -1074,10 +1095,36 @@ test-suite misc :
[ compile compile_test/tools_test_data_inc_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_test_inc_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_toms748_inc_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/cubic_spline_concept_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/barycentric_rational_concept_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_agm_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_assert_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_atomic_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_big_constant_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_centered_continued_fraction_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_cohen_acceleration_incl_test.cpp : [ requires cxx17_std_apply ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_complex_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_condition_numbers_incl_test.cpp : [ requires cxx17_std_apply cxx17_if_constexpr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_convert_from_string_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_cxx03_warn_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_engel_expansion_incl_test.cpp : [ requires cxx17_std_apply cxx17_if_constexpr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_header_deprecated_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_is_detected_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_lexical_cast_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_luroth_expansion_incl_test.cpp : [ requires cxx17_std_apply cxx17_if_constexpr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_mp_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_norms_incl_test.cpp : [ requires cxx17_std_apply cxx17_if_constexpr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_polynomial_gcd_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_promotion_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_random_vector_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_simple_continued_fraction_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_test_value_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_throw_exception_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_traits_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_ulps_plot_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tools_workaround_incl_test.cpp : [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_cubic_spline_concept_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/interpolators_barycentric_rational_concept_test.cpp : [ requires cxx11_smart_ptr cxx11_defaulted_functions cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/sf_legendre_stieltjes_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_defaulted_functions cxx11_lambdas ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/trapezoidal_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_decltype cxx11_unified_initialization_syntax cxx11_variadic_templates ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_trapezoidal_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_decltype cxx11_unified_initialization_syntax cxx11_variadic_templates ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run octonion_test.cpp
../../test/build//boost_unit_test_framework ]
[ run quaternion_constexpr_test.cpp ]
@@ -1105,8 +1152,8 @@ test-suite interpolators :
[ run agm_test.cpp : : : <toolset>msvc:<cxxflags>/bigobj [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
[ run rsqrt_test.cpp : : : <toolset>msvc:<cxxflags>/bigobj [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
[ run cohen_acceleration_test.cpp : : : <toolset>msvc:<cxxflags>/bigobj [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
[ compile compile_test/daubechies_filters_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] ]
[ compile compile_test/daubechies_scaling_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] ]
[ compile compile_test/filters_daubechies_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] ]
[ compile compile_test/sf_daubechies_scaling_incl_test.cpp : [ requires cxx17_if_constexpr cxx17_std_apply ] ]
[ run whittaker_shannon_test.cpp : : : [ requires cxx11_auto_declarations cxx11_constexpr cxx11_smart_ptr cxx11_defaulted_functions ] ]
[ run cardinal_quadratic_b_spline_test.cpp : : : [ requires cxx11_auto_declarations cxx11_constexpr cxx11_smart_ptr cxx11_defaulted_functions ] ]
[ run cardinal_quintic_b_spline_test.cpp : : : [ requires cxx11_auto_declarations cxx11_constexpr cxx11_smart_ptr cxx11_defaulted_functions ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] ]
@@ -1118,8 +1165,8 @@ test-suite interpolators :
[ run catmull_rom_test.cpp ../../test/build//boost_unit_test_framework : : : <define>TEST=1 [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] : catmull_rom_test_1 ]
[ run catmull_rom_test.cpp ../../test/build//boost_unit_test_framework : : : <define>TEST=2 [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] : catmull_rom_test_2 ]
[ run catmull_rom_test.cpp ../../test/build//boost_unit_test_framework : : : <define>TEST=3 [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] : catmull_rom_test_3 ]
[ run compile_test/catmull_rom_incl_test.cpp compile_test_main : : : [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] ]
[ run compile_test/catmull_rom_concept_test.cpp compile_test_main : : : [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] ]
[ run compile_test/interpolators_catmull_rom_incl_test.cpp compile_test_main : : : [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] ]
[ run compile_test/interpolators_catmull_rom_concept_test.cpp compile_test_main : : : [ requires cxx11_hdr_array cxx11_hdr_initializer_list ] ]
[ run test_standalone_asserts.cpp ]
;
@@ -1215,12 +1262,16 @@ test-suite quadrature :
: : : release <define>TEST10 [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ]
[ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] : exp_sinh_quadrature_test_10 ]
[ run compile_test/exp_sinh_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/sinh_sinh_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/tanh_sinh_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/exp_sinh_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/sinh_sinh_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/tanh_sinh_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/quad_exp_sinh_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/quad_sinh_sinh_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run compile_test/quad_tanh_sinh_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_gauss_incl_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_gauss_kronrod_incl_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_ooura_fourier_integrals_incl_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_wavelet_transforms_incl_test.cpp : [ requires cxx17_std_apply cxx17_if_constexpr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_exp_sinh_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_sinh_sinh_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ compile compile_test/quad_tanh_sinh_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax sfinae_expr ] [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ] ]
[ run gauss_quadrature_test.cpp : : : <define>TEST1 [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ]
[ requires cxx11_auto_declarations cxx11_lambdas cxx11_smart_ptr cxx11_unified_initialization_syntax ] <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release : gauss_quadrature_test_1 ]
@@ -1337,7 +1388,7 @@ test-suite quadrature :
<toolset>msvc:<cxxflags>/bigobj <define>TEST=23 [ requires cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_hdr_thread cxx11_hdr_atomic cxx11_decltype cxx11_hdr_future cxx11_hdr_chrono cxx11_hdr_random cxx11_allocator ]
<target-os>linux:<linkflags>"-pthread" : naive_monte_carlo_test_23
]
[ compile compile_test/naive_monte_carlo_incl_test.cpp ../../atomic/build//boost_atomic :
[ compile compile_test/quad_naive_monte_carlo_incl_test.cpp ../../atomic/build//boost_atomic :
[ requires cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_hdr_thread cxx11_hdr_atomic cxx11_decltype cxx11_hdr_future cxx11_hdr_chrono cxx11_hdr_random cxx11_allocator ]
<target-os>linux:<linkflags>"-pthread" [ check-target-builds ../config//is_ci_sanitizer_run "Sanitizer CI run" : <build>no ]
]
@@ -1349,8 +1400,8 @@ test-suite quadrature :
test-suite autodiff :
[ run test_numerical_differentiation.cpp ../../test/build//boost_unit_test_framework : : : <toolset>msvc:<cxxflags>/bigobj [ requires cxx11_auto_declarations cxx11_constexpr ] ]
[ run compile_test/numerical_differentiation_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_constexpr ] ]
[ compile compile_test/numerical_differentiation_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_constexpr ] ]
[ run compile_test/diff_numerical_differentiation_incl_test.cpp compile_test_main : : : [ requires cxx11_auto_declarations cxx11_constexpr ] ]
[ compile compile_test/diff_numerical_differentiation_concept_test.cpp : [ requires cxx11_auto_declarations cxx11_constexpr ] ]
[ run test_autodiff_1.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ run test_autodiff_2.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ run test_autodiff_3.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
@@ -1359,7 +1410,9 @@ test-suite autodiff :
[ run test_autodiff_6.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ run test_autodiff_7.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ run test_autodiff_8.cpp ../../test/build//boost_unit_test_framework : : : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ compile compile_test/autodiff_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ compile compile_test/diff_autodiff_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ compile compile_test/diff_finite_difference_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
[ compile compile_test/diff_lanczos_smoothing_incl_test.cpp : <toolset>gcc-mingw:<cxxflags>-Wa,-mbig-obj <debug-symbols>off <toolset>msvc:<cxxflags>/bigobj release [ requires cxx17_if_constexpr cxx17_std_apply ] [ check-target-builds ../config//has_float128 "GCC libquadmath and __float128 support" : <linkflags>-lquadmath ] [ requires cxx11_inline_namespaces ] ]
;
#

2
test/compile_test/constants_incl_test.cpp
View File

@@ -3,7 +3,7 @@
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Basic sanity check that header <boost/math/special_functions/bessel.hpp>
// Basic sanity check that header <boost/math/constants/constants.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/constants/constants.hpp>

92
test/compile_test/cstdfloat_cmath_incl_test.cpp Normal file
View File

@@ -0,0 +1,92 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/cstdfloat/cstdfloat_cmath.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
#ifdef BOOST_FLOAT128_C
boost::float128_t f128 = 0;
check_result<boost::float128_t>(ldexp(f128, 0));
check_result<boost::float128_t>(frexp(f128, 0));
check_result<boost::float128_t>(std::fabs(f128));
check_result<boost::float128_t>(std::abs(f128));
check_result<boost::float128_t>(floor(f128));
check_result<boost::float128_t>(ceil(f128));
check_result<boost::float128_t>(sqrt(f128));
check_result<boost::float128_t>(trunc(f128));
check_result<boost::float128_t>(exp(f128));
check_result<boost::float128_t>(expm1(f128));
check_result<boost::float128_t>(pow(f128, 0));
check_result<boost::float128_t>(log(f128));
check_result<boost::float128_t>(log10(f128));
check_result<boost::float128_t>(sin(f128));
check_result<boost::float128_t>(cos(f128));
check_result<boost::float128_t>(tan(f128));
check_result<boost::float128_t>(asin(f128));
check_result<boost::float128_t>(acos(f128));
check_result<boost::float128_t>(atan(f128));
check_result<boost::float128_t>(sinh(f128));
check_result<boost::float128_t>(cosh(f128));
check_result<boost::float128_t>(tanh(f128));
check_result<boost::float128_t>(asinh(f128));
check_result<boost::float128_t>(acosh(f128));
check_result<boost::float128_t>(atanh(f128));
check_result<boost::float128_t>(fmod(f128, f128));
check_result<boost::float128_t>(atan2(f128, f128));
check_result<boost::float128_t>(lgamma(f128));
check_result<boost::float128_t>(tgamma(f128));
check_result<boost::float128_t>(remainder(f128, f128));
check_result<boost::float128_t>(remquo(f128, f128, 0));
check_result<boost::float128_t>(fma(f128, f128, f128));
check_result<boost::float128_t>(fmax(f128, f128));
check_result<boost::float128_t>(fmin(f128, f128));
check_result<boost::float128_t>(fdim(f128, f128));
check_result<boost::float128_t>(nanq(0));
check_result<boost::float128_t>(exp2(f128));
check_result<boost::float128_t>(log2(f128));
check_result<boost::float128_t>(log1p(f128));
check_result<boost::float128_t>(cbrt(f128));
check_result<boost::float128_t>(hypot(f128, f128));
check_result<boost::float128_t>(erf(f128));
check_result<boost::float128_t>(erfc(f128));
check_result<boost::float128_t>(llround(f128));
check_result<boost::float128_t>(lround(f128));
check_result<boost::float128_t>(round(f128));
check_result<boost::float128_t>(nearbyint(f128));
check_result<boost::float128_t>(llrint(f128));
check_result<boost::float128_t>(lrint(f128));
check_result<boost::float128_t>(rint(f128));
check_result<boost::float128_t>(modf(f128, nullptr));
check_result<boost::float128_t>(scalbln(f128, 0));
check_result<boost::float128_t>(scalbn(f128, 0));
check_result<boost::float128_t>(ilogb(f128));
check_result<boost::float128_t>(logb(f128));
check_result<boost::float128_t>(nextafter(f128, f128));
check_result<boost::float128_t>(nexttoward(f128, f128));
check_result<boost::float128_t>(copysign(f128, f128));
check_result<boost::float128_t>(std::signbit(f128));
check_result<boost::float128_t>(std::fpclassify(f128));
check_result<boost::float128_t>(std::isfinite(f128));
check_result<boost::float128_t>(std::isinf(f128));
check_result<boost::float128_t>(std::isnan(f128));
check_result<boost::float128_t>(std::isnormal(f128));
check_result<boost::float128_t>(std::isgreater(f128, f128));
check_result<boost::float128_t>(std::isgreaterequal(f128, f128));
check_result<boost::float128_t>(std::isless(f128, f128));
check_result<boost::float128_t>(std::islessequal(f128, f128));
check_result<boost::float128_t>(std::islessgreater(f128, f128));
check_result<boost::float128_t>(std::isunordered(f128, f128));
#endif // boost::float128_t
}

47
test/compile_test/cstdfloat_complex_incl_test.cpp Normal file
View File

@@ -0,0 +1,47 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/cstdfloat/cstdfloat_complex.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
#ifdef BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE
complex<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE> test(0);
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(real(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(imag(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(abs(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(norm(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(conj(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(proj(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(polar(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(sqrt(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(sin(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(cos(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(tan(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(asin(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(acos(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(atan(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(exp(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(log(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(log10(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(pow(test, 0));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(sinh(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(cosh(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(tanh(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(asinh(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(acosh(test));
check_result<BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE>(atanh(test));
#endif // BOOST_CSTDFLOAT_EXTENDED_COMPLEX_FLOAT_TYPE
}

9
test/compile_test/cstdfloat_iostream_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/cstdfloat/cstdfloat_iostream.hpp>

51
test/compile_test/cstdfloat_limits_incl_test.cpp Normal file
View File

@@ -0,0 +1,51 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/cstdfloat/cstdfloat_limits.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
#ifdef BOOST_FLOAT128_C
check_result<bool>(std::numeric_limits<boost::float128_t>::is_specialized);
check_result<boost::float128_t>((std::numeric_limits<boost::float128_t>::min)());
check_result<boost::float128_t>((std::numeric_limits<boost::float128_t>::max)());
check_result<boost::float128_t>(std::numeric_limits<boost::float128_t>::lowest());
check_result<int>(std::numeric_limits<boost::float128_t>::digits);
check_result<int>(std::numeric_limits<boost::float128_t>::digits10);
check_result<int>(std::numeric_limits<boost::float128_t>::max_digits10);
check_result<bool>(std::numeric_limits<boost::float128_t>::is_signed);
check_result<bool>(std::numeric_limits<boost::float128_t>::is_integer);
check_result<bool>(std::numeric_limits<boost::float128_t>::is_exact);
check_result<int>(std::numeric_limits<boost::float128_t>::radix);
check_result<boost::float128_t>(std::numeric_limits<boost::float128_t>::epsilon());
check_result<int>(std::numeric_limits<boost::float128_t>::min_exponent);
check_result<int>(std::numeric_limits<boost::float128_t>::min_exponent10);
check_result<int>(std::numeric_limits<boost::float128_t>::max_exponent);
check_result<int>(std::numeric_limits<boost::float128_t>::max_exponent10);
check_result<bool>(std::numeric_limits<boost::float128_t>::has_infinity);
check_result<bool>(std::numeric_limits<boost::float128_t>::has_quiet_NaN);
check_result<bool>(std::numeric_limits<boost::float128_t>::has_signaling_NaN);
check_result<std::float_denorm_style>(std::numeric_limits<boost::float128_t>::has_denorm);
check_result<bool>(std::numeric_limits<boost::float128_t>::has_denorm_loss);
check_result<boost::float128_t>(std::numeric_limits<boost::float128_t>::infinity());
check_result<boost::float128_t>(std::numeric_limits<boost::float128_t>::quiet_NaN());
check_result<boost::float128_t>(std::numeric_limits<boost::float128_t>::signaling_NaN());
check_result<boost::float128_t>(std::numeric_limits<boost::float128_t>::denorm_min());
check_result<bool>(std::numeric_limits<boost::float128_t>::is_iec559);
check_result<bool>(std::numeric_limits<boost::float128_t>::is_bounded);
check_result<bool>(std::numeric_limits<boost::float128_t>::is_modulo);
check_result<bool>(std::numeric_limits<boost::float128_t>::traps);
check_result<bool>(std::numeric_limits<boost::float128_t>::tinyness_before);
check_result<std::float_round_style>(std::numeric_limits<boost::float128_t>::round_style);
#endif
}

9
test/compile_test/cstdfloat_types_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/cstdfloat/cstdfloat_types.hpp>

0
test/compile_test/autodiff_incl_test.cpp → test/compile_test/diff_autodiff_incl_test.cpp
View File

29
test/compile_test/diff_finite_difference_incl_test.cpp Normal file
View File

@@ -0,0 +1,29 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
#include <boost/math/differentiation/finite_difference.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::differentiation::finite_difference_derivative([](float x){return x;}, f));
check_result<double>(boost::math::differentiation::finite_difference_derivative([](double x){return x;}, d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::differentiation::finite_difference_derivative([](long double x){return x;}, static_cast<long double>(0)));
#endif
check_result<float>(boost::math::differentiation::complex_step_derivative([](std::complex<float> x){return x;}, f));
check_result<double>(boost::math::differentiation::complex_step_derivative([](std::complex<double> x){return x;}, d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::differentiation::complex_step_derivative([](std::complex<long double> x){return x;},
static_cast<long double>(0)));
#endif
}

30
test/compile_test/diff_lanczos_smoothing_incl_test.cpp Normal file
View File

@@ -0,0 +1,30 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
#include <boost/math/differentiation/lanczos_smoothing.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
float f_temp;
boost::math::differentiation::discrete_lanczos_derivative f_lanczos(f_temp);
check_result<float>(f_lanczos.get_spacing());
double d_temp;
boost::math::differentiation::discrete_lanczos_derivative d_lanczos(d_temp);
check_result<double>(d_lanczos.get_spacing());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
long double ld_temp;
boost::math::differentiation::discrete_lanczos_derivative ld_lanczos(ld_temp);
check_result<long double>(ld_lanczos.get_spacing());
#endif
}

0
test/compile_test/numerical_differentiation_concept_test.cpp → test/compile_test/diff_numerical_differentiation_concept_test.cpp
View File

0
test/compile_test/numerical_differentiation_incl_test.cpp → test/compile_test/diff_numerical_differentiation_incl_test.cpp
View File

25
test/compile_test/dist_arcsine_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header <boost/math/distributions/arcsine.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/distributions/arcsine.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
TEST_DIST_FUNC(arcsine)
}
template class boost::math::arcsine_distribution<float, boost::math::policies::policy<> >;
template class boost::math::arcsine_distribution<double, boost::math::policies::policy<> >;
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template class boost::math::arcsine_distribution<long double, boost::math::policies::policy<> >;
#endif

23
test/compile_test/dist_empirical_cumulative_dist_func_incl_test.cpp Normal file
View File

@@ -0,0 +1,23 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/distributions/empirical_cumulative_distribution_function.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::empirical_cumulative_distribution_function<float[]> f_test(float[]);
boost::math::empirical_cumulative_distribution_function<double[]> d_test(double[]);
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
boost::math::empirical_cumulative_distribution_function<long double[]> d_test(long double[]);
#endif
}

25
test/compile_test/dist_geometric_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header <boost/math/distributions/geometric.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/distributions/geometric.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
TEST_DIST_FUNC(geometric)
}
template class boost::math::geometric_distribution<float, boost::math::policies::policy<> >;
template class boost::math::geometric_distribution<double, boost::math::policies::policy<> >;
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template class boost::math::geometric_distribution<long double, boost::math::policies::policy<> >;
#endif

25
test/compile_test/dist_inv_gaussian_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header <boost/math/distributions/inverse_gaussian.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/distributions/inverse_gaussian.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
TEST_DIST_FUNC(inverse_gaussian)
}
template class boost::math::inverse_gaussian_distribution<float, boost::math::policies::policy<> >;
template class boost::math::inverse_gaussian_distribution<double, boost::math::policies::policy<> >;
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
template class boost::math::inverse_gaussian_distribution<long double, boost::math::policies::policy<> >;
#endif

0
test/compile_test/daubechies_filters_incl_test.cpp → test/compile_test/filters_daubechies_incl_test.cpp
View File

2
test/compile_test/barycentric_rational_concept_test.cpp → test/compile_test/interpolators_barycentric_rational_concept_test.cpp
View File

@@ -13,7 +13,7 @@ void compile_and_link_test()
{
boost::math::concepts::std_real_concept x[] = { 1, 2, 3 };
boost::math::concepts::std_real_concept y[] = { 13, 15, 17 };
boost::math::barycentric_rational<boost::math::concepts::std_real_concept> s(x, y, 3, 3);
boost::math::interpolators::barycentric_rational<boost::math::concepts::std_real_concept> s(x, y, 3, 3);
s(1.0);
}

2
test/compile_test/barycentric_rational_incl_test.cpp → test/compile_test/interpolators_barycentric_rational_incl_test.cpp
View File

@@ -22,6 +22,6 @@ void compile_and_link_test()
{
double data[] = { 1, 2, 3 };
double y[] = { 34, 56, 67 };
boost::math::barycentric_rational<double> s(data, y, 3, 2);
boost::math::interpolators::barycentric_rational<double> s(data, y, 3, 2);
check_result<double>(s(1.0));
}

25
test/compile_test/interpolators_cardinal_trig_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/cardinal_trigonometric.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data = { 1, 2, 3 };
boost::math::interpolators::cardinal_trigonometric<std::vector<double>> s(data, 3, 2);
check_result<double>(s(1.0));
}

0
test/compile_test/catmull_rom_concept_test.cpp → test/compile_test/interpolators_catmull_rom_concept_test.cpp
View File

0
test/compile_test/catmull_rom_incl_test.cpp → test/compile_test/interpolators_catmull_rom_incl_test.cpp
View File

26
test/compile_test/interpolators_cubic_hermite_incl_test.cpp Normal file
View File

@@ -0,0 +1,26 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/cubic_hermite.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data = { 1, 2, 3 };
std::vector<double> data_dx = {1, 2, 3};
boost::math::interpolators::cardinal_cubic_hermite<std::vector<double>> s(std::move(data), std::move(data_dx), 3, 2);
check_result<double>(s(1.0));
}

0
test/compile_test/cubic_spline_concept_test.cpp → test/compile_test/interpolators_cubic_spline_concept_test.cpp
View File

0
test/compile_test/cubic_spline_incl_test.cpp → test/compile_test/interpolators_cubic_spline_incl_test.cpp
View File

26
test/compile_test/interpolators_makima_incl_test.cpp Normal file
View File

@@ -0,0 +1,26 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/makima.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data_x = { 1, 2, 3 };
std::vector<double> data_y = {1, 2, 3};
boost::math::interpolators::makima<std::vector<double>> s(std::move(data_x), std::move(data_y), 3, 2);
check_result<double>(s(1.0));
}

26
test/compile_test/interpolators_pchip_incl_test.cpp Normal file
View File

@@ -0,0 +1,26 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/pchip.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data_x = { 1, 2, 3 };
std::vector<double> data_y = {1, 2, 3};
boost::math::interpolators::pchip<std::vector<double>> s(std::move(data_x), std::move(data_y), 3, 2);
check_result<double>(s(1.0));
}

28
test/compile_test/interpolators_quintic_hermite_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/quintic_hermite.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data = { 1, 2, 3 };
std::vector<double> data_1st_deriv = {1, 2, 3};
std::vector<double> data_2nd_deriv = {1, 2, 3};
boost::math::interpolators::cardinal_quintic_hermite<std::vector<double>> s(std::move(data), std::move(data_1st_deriv),
std::move(data_2nd_deriv), 1.0, 1.0);
check_result<double>(s(1.0));
}

29
test/compile_test/interpolators_septic_hermite_incl_test.cpp Normal file
View File

@@ -0,0 +1,29 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/septic_hermite.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data = { 1, 2, 3 };
std::vector<double> data_1st_deriv = {1, 2, 3};
std::vector<double> data_2nd_deriv = {1, 2, 3};
std::vector<double> data_3rd_deriv = {1, 2, 3};
boost::math::interpolators::cardinal_septic_hermite<std::vector<double>> s(std::move(data), std::move(data_1st_deriv),
std::move(data_2nd_deriv), std::move(data_3rd_deriv), 1.0, 1.0);
check_result<double>(s(1.0));
}

27
test/compile_test/interpolators_vector_barycentric_rational_incl_test.cpp Normal file
View File

@@ -0,0 +1,27 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/vector_barycentric_rational.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> time = { 1, 2, 3 };
std::vector<std::vector<double>> space = {{1}, {2}, {3}};
boost::math::interpolators::vector_barycentric_rational<decltype(time), decltype(space)> s(std::move(time), std::move(space));
check_result<std::vector<double>>(s(1.0));
}

25
test/compile_test/interpolators_whittaker_shannon_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// A sanity check that this file
// #includes all the files that it needs to.
//
#include <boost/math/interpolators/whittaker_shannon.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
//
// This test includes <vector> becasue many of the interpolators are not compatible with pointers/c-style arrays
//
#include <vector>
void compile_and_link_test()
{
std::vector<double> data_y = {1, 2, 3};
boost::math::interpolators::whittaker_shannon<std::vector<double>> s(std::move(data_y), 3, 2);
check_result<double>(s(1.0));
}

0
test/compile_test/exp_sinh_concept_test.cpp → test/compile_test/quad_exp_sinh_concept_test.cpp
View File

2
test/compile_test/exp_sinh_incl_test.cpp → test/compile_test/quad_exp_sinh_incl_test.cpp
View File

@@ -3,7 +3,7 @@
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Basic sanity check that header <boost/math/special_functions/gamma.hpp>
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/exp_sinh.hpp>

21
test/compile_test/quad_gauss_incl_test.cpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/gauss.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f = [](double x) { return x; };
boost::math::quadrature::gauss<double, 1> integrator;
check_result<double>(integrator.integrate(f));
}

21
test/compile_test/quad_gauss_kronrod_incl_test.cpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/gauss_kronrod.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f = [](double x) { return x; };
boost::math::quadrature::gauss<double, 1> integrator;
check_result<double>(integrator.integrate(f));
}

0
test/compile_test/naive_monte_carlo_concept_test.cpp → test/compile_test/quad_naive_monte_carlo_concept_test.cpp
View File

0
test/compile_test/naive_monte_carlo_incl_test.cpp → test/compile_test/quad_naive_monte_carlo_incl_test.cpp
View File

25
test/compile_test/quad_ooura_fourier_integrals_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/ooura_fourier_integrals.hpp>
#ifndef _MSC_VER
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f = [](double x) { return x; };
boost::math::quadrature::ooura_fourier_sin<double> sin_integrator;
boost::math::quadrature::ooura_fourier_cos<double> cos_integrator;
check_result<double>(sin_integrator.integrate(f, 1.0));
check_result<double>(cos_integrator.integrate(f, 1.0));
}
#endif

0
test/compile_test/sinh_sinh_concept_test.cpp → test/compile_test/quad_sinh_sinh_concept_test.cpp
View File

4
test/compile_test/sinh_sinh_incl_test.cpp → test/compile_test/quad_sinh_sinh_incl_test.cpp
View File

@@ -3,7 +3,7 @@
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Basic sanity check that header <boost/math/special_functions/gamma.hpp>
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/sinh_sinh.hpp>
@@ -15,7 +15,7 @@
void compile_and_link_test()
{
auto f = [](double x) { return 1/(1+x*x); };
auto f = [](double x) { return x; };
boost::math::quadrature::sinh_sinh<double> integrator;
check_result<double>(integrator.integrate(f));
}

0
test/compile_test/tanh_sinh_concept_test.cpp → test/compile_test/quad_tanh_sinh_concept_test.cpp
View File

6
test/compile_test/tanh_sinh_incl_test.cpp → test/compile_test/quad_tanh_sinh_incl_test.cpp
View File

@@ -3,7 +3,7 @@
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Basic sanity check that header <boost/math/special_functions/gamma.hpp>
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/tanh_sinh.hpp>
@@ -16,8 +16,6 @@
void compile_and_link_test()
{
auto f = [](double x) { return x; };
double a = 0;
double b = 1;
boost::math::quadrature::tanh_sinh<double> integrator;
check_result<double>(integrator.integrate(f, a, b));
check_result<double>(integrator.integrate(f));
}

0
test/compile_test/trapezoidal_concept_test.cpp → test/compile_test/quad_trapezoidal_concept_test.cpp
View File

2
test/compile_test/trapezoidal_incl_test.cpp → test/compile_test/quad_trapezoidal_incl_test.cpp
View File

@@ -3,7 +3,7 @@
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Basic sanity check that header <boost/math/special_functions/gamma.hpp>
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/trapezoidal.hpp>

22
test/compile_test/quad_wavelet_transforms_incl_test.cpp Normal file
View File

@@ -0,0 +1,22 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/quadrature/wavelet_transforms.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f = [](double x) { return x; };
auto psi = boost::math::daubechies_wavelet<double, 1>();
auto Wf = boost::math::quadrature::daubechies_wavelet_transform(f, psi);
check_result<double>(Wf(0.0, 0.0));
}

22
test/compile_test/sf_chebyshev_incl_test.cpp Normal file
View File

@@ -0,0 +1,22 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header <boost/math/special_functions/chebyshev.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/chebyshev.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
double x {2.0};
check_result<double>(boost::math::chebyshev_t(0, x));
check_result<double>(boost::math::chebyshev_u(0, x));
check_result<double>(boost::math::chebyshev_t_prime(0, x));
}

21
test/compile_test/sf_chebyshev_transform_incl_test.cpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright Matt Borland 2021
// 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)
//
// Basic sanity check that header <boost/math/special_functions/chebyshev_transform.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/chebyshev_transform.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f = [](double x) { return x; };
boost::math::chebyshev_transform<double> test(f, 0.0, 1.0);
check_result<double>(test(1.0));
}

0
test/compile_test/daubechies_scaling_incl_test.cpp → test/compile_test/sf_daubechies_scaling_incl_test.cpp
View File

29
test/compile_test/sf_fibonacci_incl_test.cpp Normal file
View File

@@ -0,0 +1,29 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header <boost/math/special_functions/fibonacci.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/fibonacci.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::fibonacci<float>(f));
check_result<double>(boost::math::fibonacci<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::fibonacci<long double>(l));
#endif
check_result<float>(boost::math::unchecked_fibonacci<float>(f));
check_result<double>(boost::math::unchecked_fibonacci<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::unchecked_fibonacci<long double>(l));
#endif
}

35
test/compile_test/sf_gegenbauer_incl_test.cpp Normal file
View File

@@ -0,0 +1,35 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header <boost/math/special_functions/gegenbauer.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/gegenbauer.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::gegenbauer<float>(1, f, f));
check_result<double>(boost::math::gegenbauer<double>(1, d, d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::gegenbauer<long double>(1, l, l));
#endif
check_result<float>(boost::math::gegenbauer_derivative<float>(1, f, f, 1));
check_result<double>(boost::math::gegenbauer_derivative<double>(1, d, d, 1));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::gegenbauer_derivative<long double>(1, l, l, 1));
#endif
check_result<float>(boost::math::gegenbauer_prime<float>(1, f, f));
check_result<double>(boost::math::gegenbauer_prime<double>(1, d, d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::gegenbauer_prime<long double>(1, l, l));
#endif
}

41
test/compile_test/sf_lambert_w_incl_test.cpp Normal file
View File

@@ -0,0 +1,41 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header <boost/math/special_functions/lambert_w.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/lambert_w.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::lambert_w0<float>(f));
check_result<double>(boost::math::lambert_w0<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::lambert_w0<long double>(l));
#endif
check_result<float>(boost::math::lambert_w0_prime<float>(f));
check_result<double>(boost::math::lambert_w0_prime<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::lambert_w0_prime<long double>(l));
#endif
check_result<float>(boost::math::lambert_wm1<float>(f));
check_result<double>(boost::math::lambert_wm1<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::lambert_wm1<long double>(l));
#endif
check_result<float>(boost::math::lambert_wm1_prime<float>(f));
check_result<double>(boost::math::lambert_wm1_prime<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::lambert_wm1_prime<long double>(l));
#endif
}

9
test/compile_test/sf_nonfinite_num_facets_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/nonfinite_num_facets.hpp>

23
test/compile_test/sf_rsqrt_incl_test.cpp Normal file
View File

@@ -0,0 +1,23 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header <boost/math/special_functions/rsqrt.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/rsqrt.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<int>(boost::math::rsqrt<float>(f));
check_result<int>(boost::math::rsqrt<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<int>(boost::math::rsqrt<long double>(l));
#endif
}

23
test/compile_test/sf_trigamma_incl_test.cpp Normal file
View File

@@ -0,0 +1,23 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header <boost/math/special_functions/trigamma.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/special_functions/trigamma.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::trigamma<float>(f));
check_result<double>(boost::math::trigamma<double>(d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::trigamma<long double>(l));
#endif
}

23
test/compile_test/tools_agm_incl_test.cpp Normal file
View File

@@ -0,0 +1,23 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/agm.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::tools::agm<float>(f, f));
check_result<double>(boost::math::tools::agm<double>(d, d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::tools::agm<long double>(l, l));
#endif
}

9
test/compile_test/tools_assert_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/assert.hpp>

9
test/compile_test/tools_atomic_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/atomic.hpp>

11
test/compile_test/tools_big_constant_incl_test.cpp Normal file
View File

@@ -0,0 +1,11 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#ifndef BOOST_MATH_STANDALONE
#include <boost/math/tools/big_constant.hpp>
#endif

28
test/compile_test/tools_centered_continued_fraction_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright Matt Borland 2021
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/centered_continued_fraction.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::tools::centered_continued_fraction f_test(f);
check_result<float>(f_test.khinchin_geometric_mean());
boost::math::tools::centered_continued_fraction test(0.0);
check_result<double>(test.khinchin_geometric_mean());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
boost::math::tools::centered_continued_fraction ld_test(static_cast<long double>(0));
check_result<long double>(ld_test.khinchin_geometric_mean());
#endif
}

43
test/compile_test/tools_cohen_acceleration_incl_test.cpp Normal file
View File

@@ -0,0 +1,43 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/cohen_acceleration.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
template<typename Real>
class G {
public:
G(){
k_ = 0;
}
Real operator()() {
k_ += 1;
return 1/(k_*k_);
}
private:
Real k_;
};
void compile_and_link_test()
{
auto f_g = G<float>();
check_result<float>(boost::math::tools::cohen_acceleration(f_g));
auto d_g = G<double>();
check_result<double>(boost::math::tools::cohen_acceleration(d_g));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
auto ld_g = G<long double>();
check_result<long double>(boost::math::tools::cohen_acceleration(ld_g));
#endif
}

9
test/compile_test/tools_complex_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/complex.hpp>

28
test/compile_test/tools_condition_numbers_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/condition_numbers.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::tools::summation_condition_number f_test(f);
check_result<float>(f_test());
boost::math::tools::summation_condition_number test(0.0);
check_result<double>(test());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
boost::math::tools::summation_condition_number ld_test(static_cast<long double>(0));
check_result<long double>(ld_test());
#endif
}

28
test/compile_test/tools_convert_from_string_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#ifndef BOOST_MATH_STANDALONE
#include <boost/math/tools/convert_from_string.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
const char* val_c_str = "0.0";
check_result<float>(boost::math::tools::convert_from_string<float>(val_c_str));
check_result<double>(boost::math::tools::convert_from_string<double>(val_c_str));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::tools::convert_from_string<long double>(val_c_str));
#endif
}
#endif

9
test/compile_test/tools_cxx03_warn_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/cxx03_warn.hpp>

28
test/compile_test/tools_engel_expansion_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/engel_expansion.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::tools::engel_expansion<float> f_test(1.0f);
check_result<int64_t>(f_test.digits().front());
boost::math::tools::engel_expansion<double> d_test(1.0);
check_result<int64_t>(d_test.digits().front());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
boost::math::tools::engel_expansion<long double> ld_test(1.0l);
check_result<int64_t>(ld_test.digits().front());
#endif
}

9
test/compile_test/tools_header_deprecated_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/header_deprecated.hpp>

9
test/compile_test/tools_is_detected_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/is_detected.hpp>

9
test/compile_test/tools_lexical_cast_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/lexical_cast.hpp>

28
test/compile_test/tools_luroth_expansion_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/luroth_expansion.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::tools::luroth_expansion<float> f_test(0.0f);
check_result<int64_t>(f_test.digits().front());
boost::math::tools::luroth_expansion<double> d_test(0.0);
check_result<int64_t>(d_test.digits().front());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
boost::math::tools::luroth_expansion<long double> ld_test(0.0l);
check_result<int64_t>(ld_test.digits().front());
#endif
}

13
test/compile_test/tools_mp_incl_test.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
// Currently disabled because Apple Clang, MSVC, and Mingw all throw errors internal to their STL implementation (mborland 4/2021)
#if 0
#include <boost/math/tools/mp.hpp>
#endif

9
test/compile_test/tools_norms_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/norms.hpp>

25
test/compile_test/tools_polynomial_gcd_incl_test.cpp Normal file
View File

@@ -0,0 +1,25 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header <boost/math/tools/polynomial_gcd.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/tools/polynomial_gcd.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::tools::polynomial<int> p_int;
check_result<int>(boost::math::tools::content(p_int));
check_result<int>(boost::math::tools::leading_coefficient(p_int));
boost::math::tools::polynomial<long> p_long;
check_result<long>(boost::math::tools::content(p_long));
check_result<long>(boost::math::tools::leading_coefficient(p_long));
}

9
test/compile_test/tools_promotion_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/promotion.hpp>

31
test/compile_test/tools_random_vector_incl_test.cpp Normal file
View File

@@ -0,0 +1,31 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header <boost/math/tools/polynomial.hpp>
// #includes all the files that it needs to.
//
#include <boost/math/tools/random_vector.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f_test = boost::math::generate_random_vector<float>(0, 128);
check_result<float>(f_test.front());
auto d_test = boost::math::generate_random_vector<double>(0, 128);
check_result<double>(d_test.front());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
auto ld_test = boost::math::generate_random_vector<long double>(0, 128);
check_result<long double>(ld_test.front());
#endif
auto int_test = boost::math::generate_random_vector<int>(0, 128);
check_result<int>(int_test.front());
}

28
test/compile_test/tools_simple_continued_fraction_incl_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/simple_continued_fraction.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
boost::math::tools::simple_continued_fraction<float> f_test(f);
check_result<float>(f_test.khinchin_geometric_mean());
boost::math::tools::simple_continued_fraction<double> test(0.0);
check_result<double>(test.khinchin_geometric_mean());
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
boost::math::tools::simple_continued_fraction<long double> ld_test(l);
check_result<long double>(ld_test.khinchin_geometric_mean());
#endif
}

9
test/compile_test/tools_test_value_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/test_value.hpp>

9
test/compile_test/tools_throw_exception_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/throw_exception.hpp>

9
test/compile_test/tools_traits_incl_test.cpp Normal file
View File

@@ -0,0 +1,9 @@
// Copyright John Maddock 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/traits.hpp>

21
test/compile_test/tools_ulps_plot_incl_test.cpp Normal file
View File

@@ -0,0 +1,21 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/ulps_plot.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
auto f = [](double x) { return x; };
boost::math::tools::ulps_plot<decltype(f), double, float> test(f, 1.0f, 2.0f);
auto dummy = test.width(1);
}

23
test/compile_test/tools_workaround_incl_test.cpp Normal file
View File

@@ -0,0 +1,23 @@
// Copyright Matt Borland 2021.
// 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)
//
// Basic sanity check that header
// #includes all the files that it needs to.
//
#include <boost/math/tools/workaround.hpp>
//
// Note this header includes no other headers, this is
// important if this test is to be meaningful:
//
#include "test_compile_result.hpp"
void compile_and_link_test()
{
check_result<float>(boost::math::tools::fmod_workaround(f,f));
check_result<double>(boost::math::tools::fmod_workaround(d,d));
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
check_result<long double>(boost::math::tools::fmod_workaround(l,l));
#endif
}

16
test/test_barycentric_rational.cpp
View File

@@ -40,7 +40,7 @@ void test_interpolation_condition()
y[i] = dis(gen);
}
boost::math::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size());
boost::math::interpolators::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size());
for (size_t i = 0; i < x.size(); ++i)
{
@@ -51,7 +51,7 @@ void test_interpolation_condition()
// Make sure that the move constructor does the same thing:
std::vector<Real> x_copy = x;
std::vector<Real> y_copy = y;
boost::math::barycentric_rational<Real> move_interpolator(std::move(x), std::move(y));
boost::math::interpolators::barycentric_rational<Real> move_interpolator(std::move(x), std::move(y));
for (size_t i = 0; i < x_copy.size(); ++i)
{
@@ -77,7 +77,7 @@ void test_interpolation_condition_high_order()
}
// Order 5 approximation:
boost::math::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 5);
boost::math::interpolators::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 5);
for (size_t i = 0; i < x.size(); ++i)
{
@@ -105,7 +105,7 @@ void test_constant()
y[i] = y[0];
}
boost::math::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size());
boost::math::interpolators::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size());
for (size_t i = 0; i < x.size(); ++i)
{
@@ -136,7 +136,7 @@ void test_constant_high_order()
}
// Set interpolation order to 7:
boost::math::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 7);
boost::math::interpolators::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 7);
for (size_t i = 0; i < x.size(); ++i)
{
@@ -165,7 +165,7 @@ void test_runge()
y[i] = 1/(1+25*x[i]*x[i]);
}
boost::math::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 5);
boost::math::interpolators::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 5);
for (size_t i = 0; i < x.size(); ++i)
{
@@ -218,7 +218,7 @@ void test_weights()
y[i] = 1/(1+25*x[i]*x[i]);
}
boost::math::detail::barycentric_rational_imp<Real> interpolator(x.data(), x.data() + x.size(), y.data(), 0);
boost::math::interpolators::detail::barycentric_rational_imp<Real> interpolator(x.data(), x.data() + x.size(), y.data(), 0);
for (size_t i = 0; i < x.size(); ++i)
{
@@ -234,7 +234,7 @@ void test_weights()
}
// d = 1:
interpolator = boost::math::detail::barycentric_rational_imp<Real>(x.data(), x.data() + x.size(), y.data(), 1);
interpolator = boost::math::interpolators::detail::barycentric_rational_imp<Real>(x.data(), x.data() + x.size(), y.data(), 1);
for (size_t i = 1; i < x.size() -1; ++i)
{

22
test/test_vector_barycentric_rational.cpp
View File

@@ -54,9 +54,9 @@ void test_agreement_with_1d()
}
boost::random::uniform_real_distribution<Real> dis2(t[0], t[t.size()-1]);
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::barycentric_rational<Real> scalar_interpolator0(std::move(t_copy0), std::move(y_copy0));
boost::math::barycentric_rational<Real> scalar_interpolator1(std::move(t_copy1), std::move(y_copy1));
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::interpolators::barycentric_rational<Real> scalar_interpolator0(std::move(t_copy0), std::move(y_copy0));
boost::math::interpolators::barycentric_rational<Real> scalar_interpolator1(std::move(t_copy1), std::move(y_copy1));
Eigen::Vector2d z;
@@ -93,7 +93,7 @@ void test_interpolation_condition_eigen()
std::vector<Eigen::Vector2d> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
Eigen::Vector2d z;
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -125,7 +125,7 @@ void test_interpolation_condition_std_array()
std::vector<std::array<Real, 2>> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
std::array<Real, 2> z;
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -161,7 +161,7 @@ void test_interpolation_condition_ublas()
std::vector<Real> t_copy = t;
std::vector<boost::numeric::ublas::vector<Real>> y_copy = y;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::numeric::ublas::vector<Real> z(2);
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -192,7 +192,7 @@ void test_interpolation_condition_high_order()
std::vector<Eigen::Vector2d> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y), 5);
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y), 5);
Eigen::Vector2d z;
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -228,7 +228,7 @@ void test_constant_eigen()
std::vector<Eigen::Vector2d> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
Eigen::Vector2d z;
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -271,7 +271,7 @@ void test_constant_std_array()
std::vector<std::array<Real,2>> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y));
std::array<Real, 2> z;
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -313,7 +313,7 @@ void test_constant_high_order()
std::vector<Eigen::Vector2d> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y), 5);
boost::math::interpolators::vector_barycentric_rational<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y), 5);
Eigen::Vector2d z;
for (size_t i = 0; i < t_copy.size(); ++i)
@@ -353,7 +353,7 @@ void test_weights()
std::vector<Eigen::Vector2d> y_copy = y;
std::vector<Real> t_copy = t;
boost::math::detail::vector_barycentric_rational_imp<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y), 1);
boost::math::interpolators::detail::vector_barycentric_rational_imp<decltype(t), decltype(y)> interpolator(std::move(t), std::move(y), 1);
for (size_t i = 1; i < t_copy.size() - 1; ++i)
{